Debug API

function startDebugging(
  folder: WorkspaceFolder | undefined,
  nameOrConfiguration: string | DebugConfiguration,
  parentSessionOrOptions?: DebugSession | DebugSessionOptions
): Thenable<boolean>

import * as vscode from 'vscode';

// Start debugging using a launch.json configuration by name
await vscode.debug.startDebugging(
  vscode.workspace.workspaceFolders?.[0],
  'Launch Program'
);

// Start debugging with inline configuration
await vscode.debug.startDebugging(
  vscode.workspace.workspaceFolders?.[0],
  {
    type: 'node',
    request: 'launch',
    name: 'Debug Current File',
    program: '${file}'
  }
);

function stopDebugging(session?: DebugSession): Thenable<void>

// Stop current session
if (vscode.debug.activeDebugSession) {
  await vscode.debug.stopDebugging(vscode.debug.activeDebugSession);
}

// Stop all sessions
await vscode.debug.stopDebugging();

function registerDebugAdapterDescriptorFactory(
  debugType: string,
  factory: DebugAdapterDescriptorFactory
): Disposable

class MyDebugAdapterFactory implements vscode.DebugAdapterDescriptorFactory {
  createDebugAdapterDescriptor(
    session: vscode.DebugSession,
    executable: vscode.DebugAdapterExecutable | undefined
  ): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
    // Return descriptor for debug adapter
    return new vscode.DebugAdapterExecutable(
      'node',
      ['./out/debugAdapter.js']
    );
  }
}

vscode.debug.registerDebugAdapterDescriptorFactory(
  'myDebugger',
  new MyDebugAdapterFactory()
);

function registerDebugConfigurationProvider(
  debugType: string,
  provider: DebugConfigurationProvider,
  triggerKind?: DebugConfigurationProviderTriggerKind
): Disposable

class MyConfigProvider implements vscode.DebugConfigurationProvider {
  resolveDebugConfiguration(
    folder: vscode.WorkspaceFolder | undefined,
    config: vscode.DebugConfiguration,
    token?: vscode.CancellationToken
  ): vscode.ProviderResult<vscode.DebugConfiguration> {
    // Modify or validate configuration
    if (!config.program) {
      config.program = '${file}';
    }
    return config;
  }
}

vscode.debug.registerDebugConfigurationProvider(
  'node',
  new MyConfigProvider()
);

const activeDebugSession: DebugSession | undefined

if (vscode.debug.activeDebugSession) {
  console.log(`Debugging: ${vscode.debug.activeDebugSession.name}`);
}

const activeDebugConsole: DebugConsole

vscode.debug.activeDebugConsole.appendLine('Debug message');
vscode.debug.activeDebugConsole.append('Inline message');

const breakpoints: readonly Breakpoint[]

const allBreakpoints = vscode.debug.breakpoints;
console.log(`Total breakpoints: ${allBreakpoints.length}`);

const onDidStartDebugSession: Event<DebugSession>

vscode.debug.onDidStartDebugSession(session => {
  console.log(`Started debugging: ${session.name}`);
  vscode.window.showInformationMessage(`Debug session started: ${session.name}`);
});

const onDidTerminateDebugSession: Event<DebugSession>

const onDidChangeActiveDebugSession: Event<DebugSession | undefined>

const onDidChangeBreakpoints: Event<BreakpointsChangeEvent>

vscode.debug.onDidChangeBreakpoints(event => {
  console.log(`Added: ${event.added.length}`);
  console.log(`Removed: ${event.removed.length}`);
  console.log(`Changed: ${event.changed.length}`);
});

function addBreakpoints(breakpoints: readonly Breakpoint[]): void

const uri = vscode.Uri.file('/path/to/file.ts');
const breakpoint = new vscode.SourceBreakpoint(
  new vscode.Location(uri, new vscode.Position(10, 0)),
  true
);

vscode.debug.addBreakpoints([breakpoint]);

function removeBreakpoints(breakpoints: readonly Breakpoint[]): void

import * as vscode from 'vscode';

export function activate(context: vscode.ExtensionContext) {
  // Register debug configuration provider
  const configProvider = vscode.debug.registerDebugConfigurationProvider(
    'node',
    {
      resolveDebugConfiguration(
        folder: vscode.WorkspaceFolder | undefined,
        config: vscode.DebugConfiguration
      ): vscode.ProviderResult<vscode.DebugConfiguration> {
        if (!config.request) {
          vscode.window.showErrorMessage('No debug configuration found');
          return undefined;
        }
        return config;
      }
    }
  );

  context.subscriptions.push(configProvider);

  // Monitor debug sessions
  context.subscriptions.push(
    vscode.debug.onDidStartDebugSession(session => {
      vscode.debug.activeDebugConsole.appendLine(
        `Debug session started: ${session.name}`
      );
    })
  );

  // Command to start debugging
  const startDebug = vscode.commands.registerCommand(
    'myExtension.startDebugging',
    async () => {
      const editor = vscode.window.activeTextEditor;
      if (!editor) {
        return;
      }

      await vscode.debug.startDebugging(
        vscode.workspace.getWorkspaceFolder(editor.document.uri),
        {
          type: 'node',
          request: 'launch',
          name: 'Debug File',
          program: editor.document.uri.fsPath
        }
      );
    }
  );

  context.subscriptions.push(startDebug);
}