VSCode拡張機能Native Debug雑記

docker run -itd --name vscodeex -v ./:/work -w /work -u node node:21.7.1-bookworm-slim

docker exec -it -u root vscodeex bash
apt update && apt install -y git

yo code

    const editor = vscode.window.activeTextEditor;
    const selection = editor!.selection;
    const text = editor!.document.getText(selection);
    editor!.edit((edit: vscode.TextEditorEdit) => {
      edit.replace(selection, text!.toUpperCase());
    });

docker exec -it -u root vscodeex bash
apt install -y gdb gcc procps
exit

git clone https://github.com/WebFreak001/code-debug
cd code-debug
npm install
code .

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "gdb",
      "request": "launch",
      "name": "Launch Program",
      "target": "/work/vscode-mock-debug/sampleWorkspace/sample",
      "cwd": "${workspaceRoot}",
      "valuesFormatting": "parseText",
      "gdbpath": "/usr/bin/gdb"
    }
  ]
}

which gdb

/usr/bin/gdb

@@ -54,10 +54,6 @@ class GDBDebugSession extends MI2DebugSession {

        protected override launchRequest(response: DebugProtocol.LaunchResponse, args: LaunchRequestArguments): void {
                const dbgCommand = args.gdbpath || "gdb";
-               if (this.checkCommand(dbgCommand)) {
-                       this.sendErrorResponse(response, 104, `Configured debugger ${dbgCommand} not found.`);
-                       return;
-               }
                this.miDebugger = new MI2(dbgCommand, ["-q", "--interpreter=mi2"], args.debugger_args, args.env);
                this.setPathSubstitutions(args.pathSubstitutions);
                this.initDebugger();
@@ -100,10 +96,6 @@ class GDBDebugSession extends MI2DebugSession {

        protected override attachRequest(response: DebugProtocol.AttachResponse, args: AttachRequestArguments): void {
                const dbgCommand = args.gdbpath || "gdb";
-               if (this.checkCommand(dbgCommand)) {
-                       this.sendErrorResponse(response, 104, `Configured debugger ${dbgCommand} not found.`);
-                       return;
-               }
                this.miDebugger = new MI2(dbgCommand, ["-q", "--interpreter=mi2"], args.debugger_args, args.env);
                this.setPathSubstitutions(args.pathSubstitutions);
                this.initDebugger();

    let disposable = vscode.commands.registerCommand(
        "sample2.helloWorld",
        () => {
            const items = ["item1", "item2", "item3"];
            vscode.window.showQuickPick(items).then((item) => {
                if (item !== undefined) {
                    vscode.window.showInformationMessage(
                        `selected item is ${item}`
                    );
                }
            });
        }
    );

    let disposable = vscode.commands.registerCommand(
        "sample2.helloWorld",
        () => {
            vscode.window
                .showQuickPick([
                    {
                        label: "item1",
                        description: "desc1",
                    },
                    {
                        label: "item2",
                        description: "desc2",
                    },
                    {
                        label: "item3",
                        description: "desc3",
                    },
                ])
                .then((item) => {
                    if (item !== undefined) {
                        vscode.window.showInformationMessage(
                            `selected item is ${item.label}`
                        );
                    }
                });
        }
    );

export class PsProcessParser {
    private static get secondColumnCharacters(): number { return 50; }
    private static get commColumnTitle(): string { return Array(PsProcessParser.secondColumnCharacters).join("a"); }
    // the BSD version of ps uses '-c' to have 'comm' only output the executable name and not
    // the full path. The Linux version of ps has 'comm' to only display the name of the executable
    // Note that comm on Linux systems is truncated to 16 characters:
    // https://bugzilla.redhat.com/show_bug.cgi?id=429565
    // Since 'args' contains the full path to the executable, even if truncated, searching will work as desired.
    public static get psLinuxCommand(): string { return `ps axww -o pid=,comm=${PsProcessParser.commColumnTitle},args=`; }
    public static get psDarwinCommand(): string { return `ps axww -o pid=,comm=${PsProcessParser.commColumnTitle},args= -c`; }
    public static get psToyboxCommand(): string { return `ps -A -o pid=,comm=${PsProcessParser.commColumnTitle},args=`; }

npm install ssh2
npm i --save-dev @types/ssh2

import { Client, ClientChannel } from "ssh2";

・・・

    let disposable = vscode.commands.registerCommand(
        "sample2.helloWorld",
        () => {
            const conn = new Client();
            conn.on("ready", () => {
                conn.exec(
                    "ls -al",
                    (err: Error | undefined, stream: ClientChannel) => {
                        if (err) {
                            vscode.window.showInformationMessage(
                                `error: ${err}`
                            );
                            return;
                        }

                        stream.on("data", (data: Buffer) => {
                            vscode.window.showInformationMessage(
                                `stdout: ${data}`
                            );
                        });

                        stream.stderr.on("data", (data: Buffer) => {
                            vscode.window.showInformationMessage(
                                `stderr: ${data}`
                            );
                        });

                        stream.on("close", (code: number, signal: string) => {
                            conn.end();
                            vscode.window
                                .showQuickPick([
                                    {
                                        label: "item1",
                                        description: "desc1",
                                    },
                                    {
                                        label: "item2",
                                        description: "desc2",
                                    },
                                    {
                                        label: "item3",
                                        description: "desc3",
                                    },
                                ])
                                .then((item) => {
                                    if (item !== undefined) {
                                        vscode.window.showInformationMessage(
                                            `selected item is ${item.label}`
                                        );
                                    }
                                });
                        });
                    }
                );
            }).connect({
                host: "ホスト名",
                port: ポート番号,
                username: "ユーザー名",
                password: "パスワード",
            });
        }
    );

interface SSHConfig {
    host: string;
    port: number;
    username: string;
    password: string;
}

function connectSSH(config: SSHConfig): Promise<Client> {
    return new Promise((resolve, reject) => {
        const conn = new Client();
        conn.on("ready", () => {
            resolve(conn);
        })
            .on("error", (err) => {
                reject(err);
            })
            .connect(config);
    });
}

function executeCommand(conn: Client, command: string): Promise<string> {
    return new Promise((resolve, reject) => {
        conn.exec(command, (err: Error | undefined, stream: ClientChannel) => {
            if (err) {
                reject(err);
                return;
            }

            let output = "";
            stream.on("data", (data: Buffer) => {
                output += data.toString();
            });

            stream.on("close", (code: number, signal: string) => {
                if (code === 0) {
                    resolve(output);
                } else {
                    reject(
                        new Error(
                            `Command execution failed with code ${code} and signal ${signal}`
                        )
                    );
                }
            });
        });
    });
}

export function activate(context: vscode.ExtensionContext) {
    console.log('Congratulations, your extension "sample2" is now active!');

    let disposable = vscode.commands.registerCommand(
        "sample2.helloWorld",
        async () => {
            try {
                const conn = await connectSSH({
                    host: "ホスト名",
                    port: ポート番号,
                    username: "ユーザー名",
                    password: "パスワード",
                });
                const commandOutput = await executeCommand(conn, "ls -al");
                conn.end();
                vscode.window.showInformationMessage(
                    `result: ${commandOutput}`
                );
                vscode.window
                    .showQuickPick([
                        {
                            label: "item1",
                            description: "desc1",
                        },
                        {
                            label: "item2",
                            description: "desc2",
                        },
                        {
                            label: "item3",
                            description: "desc3",
                        },
                    ])
                    .then((item) => {
                        if (item !== undefined) {
                            vscode.window.showInformationMessage(
                                `selected item is ${item.label}`
                            );
                        }
                    });
            } catch (error) {
                vscode.window.showErrorMessage(`error: ${error}`);
            }
        }
    );

    context.subscriptions.push(disposable);
}

interface SSHCmdResult {
    stdout: string | null;
    stderr: string | null;
    code: number;
    signal: string;
}
・・・
function executeCommand(conn: Client, command: string): Promise<SSHCmdResult> {
    return new Promise((resolve, reject) => {
        conn.exec(command, (err: Error | undefined, stream: ClientChannel) => {
            if (err) {
                reject(err);
                return;
            }

            let stdout: string | null = null;
            stream.on("data", (data: Buffer) => {
                if (stdout === null) {
                    stdout = "";
                }
                stdout += data.toString();
            });

            let stderr: string | null = null;
            stream.stderr.on("data", (data: Buffer) => {
                if (stderr === null) {
                    stderr = "";
                }
                stderr += data.toString();
            });

            stream.on("close", (code: number, signal: string) => {
                resolve({
                    stdout: stdout,
                    stderr: stderr,
                    code: code,
                    signal: signal,
                });
            });
        });
    });
}

export function activate(context: vscode.ExtensionContext) {
    console.log('Congratulations, your extension "sample2" is now active!');

    let disposable = vscode.commands.registerCommand(
        "sample2.helloWorld",
        async () => {
            try {
                const conn = await connectSSH({
                    host: "",
                    port: ,
                    username: "",
                    password: "",
                });
                const cmdResult = await executeCommand(conn, "ls -al");
                conn.end();
                vscode.window.showInformationMessage(
                    `stdout: ${cmdResult.stdout}, code: ${cmdResult.code}`
                );
・・・

const getProcessCommand: string =
    `if [ "$(uname)" = "Linux" ] || [ "$(uname)" = "NetBSD" ]; then ` +
    `ps axww | awk '{$2=$3=$4=""; print $1 substr($0, 5)}'; ` +
    `else echo "Unsupported OS: $(uname)" >&2 && exit 1; fi`;
const processRegExp: RegExp = new RegExp(`^\\s*([0-9]+)\\s+(.*)$`);

function parseProcessOverSSH(conn: Client): Promise<ProcessInfo[]> {
    return new Promise(async (resolve, reject) => {
        const psResult = await executeCommand(conn, getProcessCommand);
        if (psResult.code !== 0) {
            reject(
                `get processes over SSH failed: ${psResult.code} stderr: ${psResult.stderr}`
            );
            return;
        }
        if (psResult.stdout === null) {
            reject("get processes over SSH failed: stdout is null");
            return;
        }
        let processes: ProcessInfo[] = [];
        const stdOutLines: string[] = psResult.stdout.split("\n");
        for (let i: number = 1; i < stdOutLines.length; i++) {
            const matches: RegExpExecArray | null = processRegExp.exec(
                stdOutLines[i]
            );
            if (matches) {
                processes.push({
                    id: parseInt(matches[1].trim()),
                    command: matches[2].trim(),
                });
            }
        }

        resolve(processes);
    });
}
・・・
    let disposable = vscode.commands.registerCommand(
        "sample2.helloWorld",
        async () => {
            try {
                const conn = await connectSSH({
                    host: "",
                    port: ,
                    username: "",
                    password: "",
                });
                const processes = await parseProcessOverSSH(conn);
                conn.end();
                if (processes.length === 0) {
                    vscode.window.showErrorMessage(`no process`);
                    return;
                }
                const items: vscode.QuickPickItem[] = processes.map((e) => {
                    const processItem: vscode.QuickPickItem = {
                        label: e.id.toString(),
                        description: e.command,
                    };
                    return processItem;
                });
                vscode.window.showQuickPick(items).then((item) => {
                    if (item !== undefined) {
                        vscode.window.showInformationMessage(
                            `selected item is ${item.label} command: ${item.description}`
                        );
                    }
                });

@@ -20,7 +20,8 @@
 	"activationEvents": [
 		"onCommand:code-debug.examineMemoryLocation",
 		"onCommand:code-debug.getFileNameNoExt",
-		"onCommand:code-debug.getFileBasenameNoExt"
+		"onCommand:code-debug.getFileBasenameNoExt",
+		"onCommand:code-debug.pickRemoteNativeProcess"
 	],
 	"categories": [
 		"Debuggers"

@@ -3,6 +3,33 @@ import * as net from "net";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { Client, ClientChannel } from "ssh2";
+
+interface SSHConfig {
+	host: string;
+	port: number;
+	username: string;
+	password: string;
+}
+
+interface SSHCmdResult {
+	stdout?: string;
+	stderr?: string;
+	code: number;
+	signal: string;
+}
+
+interface ProcessInfo {
+	id: number;
+	command: string;
+}
+
+const getProcessCommand: string =
+	`if [ "$(uname)" = "Linux" ] || [ "$(uname)" = "NetBSD" ]; then ` +
+	`ps axww | awk '{$2=$3=$4=""; print $1 substr($0, 5)}'; ` +
+	`else echo "Unsupported OS: $(uname)" >&2 && exit 1; fi`;
+
+const processRegExp: RegExp = new RegExp(`^\\s*([0-9]+)\\s+(.*)$`);
 
 export function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider("debugmemory", new MemoryContentProvider()));
@@ -25,8 +52,127 @@ export function activate(context: vscode.ExtensionContext) {
 		const ext = path.extname(fileName);
 		return fileName.substring(0, fileName.length - ext.length);
 	}));
+	context.subscriptions.push(vscode.commands.registerCommand("code-debug.pickRemoteNativeProcess", (any) => ShowAttachEntries(any)));
+}
+function connectSSH(config: SSHConfig): Promise<Client> {
+	return new Promise((resolve, reject) => {
+		const conn = new Client();
+		conn.on("ready", () => {
+			resolve(conn);
+		})
+			.on("error", (err) => {
+				reject(err);
+			})
+			.connect(config);
+	});
 }
 
+function executeCommand(conn: Client, command: string): Promise<SSHCmdResult> {
+	return new Promise((resolve, reject) => {
+		conn.exec(command, (err: Error | undefined, stream: ClientChannel) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+
+			let stdout: string | undefined = undefined;
+			stream.on("data", (data: Buffer) => {
+				if (stdout === undefined) {
+					stdout = "";
+				}
+				stdout += data.toString();
+			});
+
+			let stderr: string | undefined = undefined;
+			stream.stderr.on("data", (data: Buffer) => {
+				if (stderr === undefined) {
+					stderr = "";
+				}
+				stderr += data.toString();
+			});
+
+			stream.on("close", (code: number, signal: string) => {
+				resolve({
+					stdout: stdout,
+					stderr: stderr,
+					code: code,
+					signal: signal,
+				});
+			});
+		});
+	});
+}
+
+function parseProcessOverSSH(conn: Client): Promise<ProcessInfo[]> {
+	return new Promise((resolve, reject) => {
+		executeCommand(conn, getProcessCommand).then((psResult: SSHCmdResult) => {
+			if (psResult.code !== 0) {
+				reject(
+					`get processes over SSH failed: ${psResult.code} stderr: ${psResult.stderr}`
+				);
+				return;
+			}
+			if (psResult.stdout === undefined) {
+				reject("get processes over SSH failed: stdout is null");
+				return;
+			}
+			const processes: ProcessInfo[] = [];
+			const stdOutLines: string[] = psResult.stdout.split("\n");
+			for (let i: number = 1; i < stdOutLines.length; i++) {
+				const matches: RegExpExecArray | null = processRegExp.exec(
+					stdOutLines[i]
+				);
+				if (matches) {
+					processes.push({
+						id: parseInt(matches[1].trim()),
+						command: matches[2].trim(),
+					});
+				}
+			}
+			resolve(processes);
+		});
+	});
+}
+
+async function ShowAttachEntries(any: any): Promise<String> {
+	try {
+		const conn = await connectSSH({
+			host: any.ssh.host,
+			port: any.ssh.port || 22,
+			username: any.ssh.user,
+			password: any.ssh.password,
+		});
+		const processes = await parseProcessOverSSH(conn);
+		conn.end();
+		if (processes.length === 0) {
+			vscode.window.showErrorMessage("no process");
+			return;
+		}
+		const items: vscode.QuickPickItem[] = processes.map((e) => {
+			const processItem: vscode.QuickPickItem = {
+				label: e.id.toString(),
+				description: e.command,
+			};
+			return processItem;
+		});
+		const pid: String = await selectProcess(items);
+		return pid;
+	} catch (error) {
+		throw Error(`error: ${error}`);
+	}
+}
+
+function selectProcess(items: vscode.QuickPickItem[]): Promise<String> {
+	return new Promise((resolve, reject) => {
+		vscode.window.showQuickPick(items).then((item) => {
+			if (item !== undefined) {
+				resolve(item.label);
+				return;
+			}
+			reject("no item selected");
+		});
+	});
+}
 const memoryLocationRegex = /^0x[0-9a-f]+$/;
 
 function getMemoryRange(range: string) {

Failed to SSH: Couldn't get registers: Device busy. (from target-attach 711)

Running /usr/local/bin/gdb over ssh...
1-gdb-set target-async on
2-list-features
3-environment-directory "/root/sample"
4-environment-cd "/root/sample"
5-target-attach 706
GDB -> App: {"outOfBandRecord":[{"isStream":false,"type":"notify","asyncClass":"thread-group-added","output":[["id","i1"]],"content":""}]}
GDB -> App: {"token":1,"outOfBandRecord":[],"resultRecords":{"resultClass":"done","results":[]}}
GDB -> App: {"token":2,"outOfBandRecord":[],"resultRecords":{"resultClass":"done","results":[["features",["frozen-varobjs","pending-breakpoints","thread-info","data-read-memory-bytes","breakpoint-notifications","ada-task-info","language-option","info-gdb-mi-command","undefined-command-error-code","exec-run-start-option"]]]}}
GDB -> App: {"token":3,"outOfBandRecord":[],"resultRecords":{"resultClass":"done","results":[["source-path","/root/sample:$cdir:$cwd"]]}}
GDB -> App: {"token":4,"outOfBandRecord":[],"resultRecords":{"resultClass":"done","results":[]}}
GDB -> App: {"outOfBandRecord":[{"isStream":false,"type":"notify","asyncClass":"thread-group-started","output":[["id","i1"],["pid","706"]],"content":""}]}
GDB -> App: {"outOfBandRecord":[{"isStream":false,"type":"notify","asyncClass":"thread-created","output":[["id","1"],["group-id","i1"]],"content":""}]}
6-thread-info
GDB -> App: {"token":5,"outOfBandRecord":[],"resultRecords":{"resultClass":"error","results":[["msg","Couldn't get registers: Device busy."]]}}

const resultRecordRegex = /^(\d*)\^(done|running|connected|error|exit)/;

GDB -> App: {"token":66,"outOfBandRecord":[],"resultRecords":{"resultClass":"done","results":[["variables",[[["name","target_value"],["type","int"],["value","10"]],[["name","current_value"],["type","int"],["value","0"]]]]]}}
67-exec-continue
str: 67^running
*running,thread-id="all"
(gdb) 
GDB -> App: {"token":67,"outOfBandRecord":[],"resultRecords":{"resultClass":"running","results":[]}}
GDB -> App: {"outOfBandRecord":[{"isStream":false,"type":"exec","asyncClass":"running","output":[["thread-id","all"]],"content":""}]}

/usr/local/bin/gdb -q --interpreter=mi2

1-gdb-set target-async on
2-list-features
3-environment-directory "/root/sample"
4-environment-cd "/root/sample"
5-target-attach 1965
6-thread-info
7-thread-info
8-stack-info-depth --thread 1
9-stack-info-depth --thread 1
10-stack-list-frames --thread 1 0 2
11-stack-list-frames --thread 1 0 2
12-stack-list-variables --thread 1 --frame 2 --simple-values
13-exec-continue

if (attach) {
	// Attach to local process
	promises.push(this.sendCommand("target-attach " + target));
	promises.push(this.sendCommand("break-insert sample.c:10"));
} else if (procArgs && procArgs.length)
	・・・

protected override setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments): void {
	let path = args.source.path;
	this.miDebugger.log("stdout", args.breakpoints.map((brk => `${path}:${brk.line}`)).join("\n"));
	if (this.isSSH) {

protected commandServer: net.Server;
・・・
if (!fs.existsSync(systemPath.join(os.tmpdir(), "code-debug-sockets")))
		fs.mkdirSync(systemPath.join(os.tmpdir(), "code-debug-sockets"));
	this.commandServer.listen(this.serverPath = systemPath.join(os.tmpdir(), "code-debug-sockets", ("Debug-Instance-" + Math.floor(Math.random() * 36 * 36 * 36 * 36).toString(36)).toLowerCase()));

promises.push(...autorun.map(value => { return this.sendUserInput(value); }));
Promise.all(promises).then(() => {
	this.log("stdout", new Error().stack);
	this.emit("debug-ready");
	resolve(undefined);

promises.push(...autorun.map(value => { return this.sendUserInput(value); }));
Promise.all(promises).then(() => {
	this.log("stdout", new Error().stack);
	resolve(undefined);
}, reject);
this.emit("debug-ready");

sendCommand(command: string, suppressFailure: boolean = false): Thenable<MINode> {
	const sel = this.currentToken++;
	return new Promise((resolve, reject) => {
		this.handlers[sel] = (node: MINode) => {
			if (node && node.resultRecords && node.resultRecords.resultClass === "error") {
				if (suppressFailure) {
					this.log("stderr", `WARNING: Error executing command '${command}'`);
					this.log("stdout", `resolved executing command with warning '${command}'`);
					resolve(node);
				} else {
					this.log("stderr", `rejected executing command '${command}' ${node.result("msg")}`);
					reject(new MIError(node.result("msg") || "Internal error", command));
				}
			} else {
				this.log("stdout", `resolved executing command '${command}'`);
				resolve(node);
			}
		};
		this.sendRaw(sel + "-" + command);

resolved executing command 'gdb-set target-async on'
resolved executing command 'list-features'
resolved executing command 'environment-directory "/work"'
resolved executing command 'environment-cd "/work"'
resolved executing command 'target-attach 25'
resolved executing command 'break-insert -f "/work/sample.c:9"'
resolved executing command 'thread-info'
resolved executing command 'thread-info'
resolved executing command 'exec-continue'
resolved executing command 'thread-info'
resolved executing command 'thread-info'
resolved executing command 'stack-info-depth --thread 1'
resolved executing command 'stack-list-frames --thread 1 0 0'
resolved executing command 'stack-list-variables --thread 1 --frame 0 --simple-values'
resolved executing command 'exec-continue'

resolved executing command 'gdb-set target-async on'
resolved executing command 'list-features'
resolved executing command 'environment-directory "/root/sample"'
resolved executing command 'environment-cd "/root/sample"'
resolved executing command 'thread-info'
resolved executing command 'thread-info'
resolved executing command 'stack-info-depth --thread 1'
resolved executing command 'stack-info-depth --thread 1'
resolved executing command 'stack-list-frames --thread 1 0 2'
resolved executing command 'stack-list-frames --thread 1 0 2'
resolved executing command 'stack-list-variables --thread 1 --frame 2 --simple-values'
resolved executing command 'exec-continue'

onOutput(str: string) {
		this.log("stdout", `on output: ${str}`);

on output: 5^error,msg="Couldn't get registers: Device busy."
(gdb) 
GDB -> App: {"token":5,"outOfBandRecord":[],"resultRecords":{"resultClass":"error","results":[["msg","Couldn't get registers: Device busy."]]}}
rejected executing command 'target-attach 1016' Couldn't get registers: Device busy.

if (attach) {
	// Attach to local process
	promises.push(this.sendCommand("target-attach " + target, true));

・・・

sendCommand(command: string, suppressFailure: boolean = false): Thenable<MINode> {

1-gdb-set target-async on
1^done
(gdb)
2-gdb-show target-async
2^done,value="on"