oh-my-opencode 5.0.0-beta.23 → 5.0.0-beta.25

package/packages/lsp-core/src/lsp/server-resolution-local-binary.test.ts

@@ -1,170 +0,0 @@
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { runWithRequestContext } from "../request-context.js";
-import { formatServerLookupError } from "./client-wrapper.js";
-import { __resetServerBinaryResolutionCacheForTests } from "./server-installation.js";
-import { findServerForExtension } from "./server-resolution.js";
-
-const tempDirectories: string[] = [];
-let previousPath: string | undefined;
-
-function makeTempRoot(prefix: string): string {
-	const root = mkdtempSync(join(tmpdir(), prefix));
-	tempDirectories.push(root);
-	return root;
-}
-
-function writeExecutable(path: string): string {
-	mkdirSync(join(path, ".."), { recursive: true });
-	writeFileSync(path, "#!/bin/sh\nexit 0\n");
-	chmodSync(path, 0o755);
-	return path;
-}
-
-function contextFor(cwd: string) {
-	return {
-		cwd,
-		projectConfigPaths: [join(cwd, ".codex", "lsp-client.json")],
-		userConfigPath: join(cwd, "home-config", "lsp-client.json"),
-		installDecisionsPath: join(cwd, "home-config", "lsp-install-decisions.json"),
-		capabilities: { installDecisionTool: true },
-	} as const;
-}
-
-beforeEach(() => {
-	previousPath = process.env["PATH"];
-	__resetServerBinaryResolutionCacheForTests();
-});
-
-afterEach(() => {
-	if (previousPath === undefined) delete process.env["PATH"];
-	else process.env["PATH"] = previousPath;
-	for (const directory of tempDirectories.splice(0)) {
-		rmSync(directory, { recursive: true, force: true });
-	}
-	__resetServerBinaryResolutionCacheForTests();
-});
-
-describe("findServerForExtension local binary substitution", () => {
-	test("#given a repo-local biome #when looking up a typescript file #then the command spawns the absolute local path", () => {
-		// given
-		const root = makeTempRoot("lsp-resolution-local-");
-		writeFileSync(join(root, "package.json"), "{}\n");
-		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
-		process.env["PATH"] = join(root, "definitely-empty");
-
-		// when
-		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
-
-		// then
-		expect(result.status).toBe("found");
-		if (result.status !== "found") throw new Error("expected a found server");
-		expect(result.server.command[0]).toBe(binaryPath);
-		expect(result.server.command.slice(1)).toEqual(["lsp-proxy", "--stdio"]);
-	});
-
-	test("#given a PATH-only server #when looking up #then the resolved PATH entry is substituted", () => {
-		// given
-		const root = makeTempRoot("lsp-resolution-path-root-");
-		writeFileSync(join(root, "package.json"), "{}\n");
-		const pathDir = makeTempRoot("lsp-resolution-path-");
-		const pathBinary = writeExecutable(join(pathDir, "biome"));
-		process.env["PATH"] = pathDir;
-
-		// when
-		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
-
-		// then
-		expect(result.status).toBe("found");
-		if (result.status !== "found") throw new Error("expected a found server");
-		expect(result.server.command[0]).toBe(pathBinary);
-	});
-
-	test("#given no server anywhere #when looking up #then the not_installed result is preserved", () => {
-		// given
-		const root = makeTempRoot("lsp-resolution-missing-");
-		process.env["PATH"] = join(root, "definitely-empty");
-
-		// when
-		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
-
-		// then
-		expect(result.status).toBe("not_installed");
-		if (result.status !== "not_installed") throw new Error("expected not_installed");
-		expect(result.installHint.length).toBeGreaterThan(0);
-	});
-
-	test("#given an unknown extension #when looking up #then the not_configured result is preserved", () => {
-		// given
-		const root = makeTempRoot("lsp-resolution-unknown-");
-		process.env["PATH"] = join(root, "definitely-empty");
-
-		// when
-		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".unknown-ext"));
-
-		// then
-		expect(result.status).toBe("not_configured");
-	});
-});
-
-describe("not-installed message repo-local guidance", () => {
-	test("#given a missing biome #when formatting the message #then the repo-local install is suggested before the global hint", () => {
-		// given: .css is served by biome alone, so the lookup cannot fall through to typescript
-		const root = makeTempRoot("lsp-message-biome-");
-		process.env["PATH"] = join(root, "definitely-empty");
-		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".css"));
-		if (result.status !== "not_installed") throw new Error("expected not_installed");
-		expect(result.server.id).toBe("biome");
-
-		// when
-		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
-
-		// then
-		expect(message).toContain("bun add -d @biomejs/biome");
-		expect(message).toContain("npm install -g @biomejs/biome");
-		expect(message.indexOf("bun add -d @biomejs/biome")).toBeLessThan(message.indexOf("npm install -g @biomejs/biome"));
-		expect(message).toContain("ACTION REQUIRED");
-		expect(message).toContain("NOT INSTALLED");
-	});
-
-	test("#given a server with no repo-local route #when formatting the message #then only the global hint is shown", () => {
-		// given
-		const root = makeTempRoot("lsp-message-global-");
-		process.env["PATH"] = join(root, "definitely-empty");
-		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".rs"));
-		if (result.status !== "not_installed") throw new Error("expected not_installed");
-
-		// when
-		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
-
-		// then
-		expect(message).toContain("To install, run:");
-		expect(message).not.toContain("THIS repository");
-		expect(message).toContain("ACTION REQUIRED");
-	});
-
-	test("#given a pre-authorized install #when formatting the message #then both install routes stay visible", () => {
-		// given
-		const root = makeTempRoot("lsp-message-allowed-");
-		process.env["PATH"] = join(root, "definitely-empty");
-		const context = contextFor(root);
-		mkdirSync(join(root, "home-config"), { recursive: true });
-		writeFileSync(
-			context.installDecisionsPath,
-			`${JSON.stringify({ biome: { decision: "allowed", decidedAt: new Date().toISOString() } })}\n`,
-		);
-		const result = runWithRequestContext(context, () => findServerForExtension(".css"));
-		if (result.status !== "not_installed") throw new Error("expected not_installed");
-
-		// when
-		const message = runWithRequestContext(context, () => formatServerLookupError(result));
-
-		// then
-		expect(message).toContain("pre-authorized");
-		expect(message).toContain("bun add -d @biomejs/biome");
-		expect(message).toContain("npm install -g @biomejs/biome");
-	});
-});

package/packages/lsp-core/src/tools/format.test.ts

@@ -1,56 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "bun:test";
-
-import { parseLspRequestContext, runWithRequestContext } from "../request-context.js";
-import { executeLspFormat } from "./format.js";
-import type { LspFormatDetails } from "./types.js";
-
-const workspaces: string[] = [];
-
-afterEach(() => {
-	for (const workspace of workspaces.splice(0)) rmSync(workspace, { recursive: true, force: true });
-});
-
-function workspaceWith(fileName: string, content: string): { readonly root: string; readonly filePath: string } {
-	const root = mkdtempSync(join(tmpdir(), "lsp-format-tool-"));
-	workspaces.push(root);
-	const filePath = join(root, fileName);
-	writeFileSync(filePath, content, "utf-8");
-	return { root, filePath };
-}
-
-function contextFor(root: string) {
-	return parseLspRequestContext({
-		cwd: root,
-		projectConfigPaths: [join(root, "lsp.json")],
-		userConfigPath: join(root, "user-lsp.json"),
-		installDecisionsPath: join(root, "install-decisions.json"),
-		capabilities: { installDecisionTool: false },
-	});
-}
-
-describe("executeLspFormat", () => {
-	it("#given an extension with no configured server #when format runs #then the missing dependency result is returned and the file is untouched", async () => {
-		// given
-		const original = "value\n";
-		const { root, filePath } = workspaceWith("module.wat", original);
-
-		// when
-		const result = await runWithRequestContext(contextFor(root), () => executeLspFormat({ filePath }));
-
-		// then
-		const details = result.details as LspFormatDetails;
-		expect(details.errorKind).toBe("missing_dependency");
-		expect(details.status).toBe("unavailable");
-		expect(result.content[0]?.text).toContain("No LSP server configured for extension: .wat");
-		expect(readFileSync(filePath)).toEqual(Buffer.from(original));
-	});
-
-	it("#given a missing filePath argument #when format runs #then the parameter contract is enforced", async () => {
-		// given / when / then
-		await expect(executeLspFormat({})).rejects.toThrow(/filePath/);
-	});
-});

package/packages/lsp-core/src/tools/format.ts

@@ -1,56 +0,0 @@
-import { withLspClient } from "../lsp/client-wrapper.js";
-import { type FormatDocumentResult, formatDocumentWithClient } from "../lsp/format-document.js";
-import { missingDependencyResult } from "../missing-dependency-result.js";
-import { clientOptions, requireString } from "./parameters.js";
-import { text } from "./result.js";
-import type { LspFormatDetails, ToolExecutionResult } from "./types.js";
-
-export async function executeLspFormat(
-	params: Record<string, unknown>,
-	signal?: AbortSignal,
-): Promise<ToolExecutionResult> {
-	const filePath = requireString(params, "filePath");
-
-	try {
-		const result = await withLspClient(
-			filePath,
-			async (client, _workspaceRoot, resolvedFilePath) =>
-				formatDocumentWithClient(client, resolvedFilePath, signal === undefined ? {} : { signal }),
-			"format",
-			clientOptions(signal),
-		);
-		return text(describeResult(filePath, result), formatDetails(filePath, result));
-	} catch (error) {
-		const missingDependency = missingDependencyResult(error, {
-			filePath,
-			status: "unavailable",
-			reason: "server_unavailable",
-			linesAdded: 0,
-			linesRemoved: 0,
-		} satisfies Omit<LspFormatDetails, "error" | "errorKind">);
-		if (missingDependency) return missingDependency;
-		throw error;
-	}
-}
-
-function formatDetails(filePath: string, result: FormatDocumentResult): LspFormatDetails {
-	if (result.status === "unavailable") {
-		return { filePath, status: "unavailable", reason: result.reason, linesAdded: 0, linesRemoved: 0 };
-	}
-	return {
-		filePath,
-		status: result.status,
-		linesAdded: result.linesAdded,
-		linesRemoved: result.linesRemoved,
-	};
-}
-
-function describeResult(filePath: string, result: FormatDocumentResult): string {
-	if (result.status === "unavailable") {
-		return `Formatting unavailable for ${filePath}: the language server does not advertise documentFormattingProvider.`;
-	}
-	if (result.status === "unchanged") {
-		return `Already formatted: ${filePath}`;
-	}
-	return `Formatted ${filePath} (+${result.linesAdded}/-${result.linesRemoved} lines)`;
-}

package/packages/omo-codex/plugin/skills/debugging/references/scripts/dap.mjs

@@ -1,267 +0,0 @@
-#!/usr/bin/env node
-// Zero-dependency DAP REPL, modeled on oh-my-pi's debug tool. DAP framing is UTF-8 byte based.
-import { spawn } from "node:child_process";
-import { createConnection } from "node:net";
-import { createInterface } from "node:readline";
-import { stdin, stdout, stderr, env } from "node:process";
-
-export const MAX_ROWS = 100;
-export const MAX_OUTPUT_BYTES = 32 * 1024;
-
-export function isTcpAdapterSpec(spec) {
-  const separator = spec.lastIndexOf(":");
-  return separator > 0 &&
-    !spec.includes("/") &&
-    !spec.includes("\\") &&
-    /^\d+$/.test(spec.slice(separator + 1));
-}
-
-export class DapFrameParser {
-  constructor() { this.buffer = Buffer.alloc(0); }
-  push(chunk) {
-    this.buffer = Buffer.concat([this.buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
-    const messages = [];
-    while (true) {
-      const marker = this.buffer.indexOf(Buffer.from("\r\n\r\n"));
-      if (marker < 0) break;
-      const header = this.buffer.subarray(0, marker).toString("ascii");
-      const match = header.match(/(?:^|\r\n)Content-Length:\s*(\d+)/i);
-      if (!match) { this.buffer = this.buffer.subarray(marker + 4); continue; }
-      const length = Number(match[1]);
-      const start = marker + 4;
-      if (this.buffer.length < start + length) break;
-      const body = this.buffer.subarray(start, start + length);
-      this.buffer = this.buffer.subarray(start + length);
-      try { messages.push(JSON.parse(body.toString("utf8"))); } catch { /* malformed frames are ignored */ }
-    }
-    return messages;
-  }
-}
-
-const timeoutMs = Number(env.DAP_TIMEOUT_MS || 15000);
-let transport = null;
-let parser = null;
-let nextSeq = 1;
-let initialized = false;
-let terminated = false;
-let currentStop = null;
-let topFrame = null;
-const pending = new Map();
-const breakpoints = new Map();
-// Event-driven waits. A tight `await setImmediate` busy-loop starves Bun's socket
-// data callbacks (the `initialized` event then never processes and launch deadlocks),
-// so every wait subscribes to the actual DAP event instead of polling state.
-const eventWaiters = new Map();
-function onEvent(name) {
-  return new Promise(resolve => {
-    const list = eventWaiters.get(name) || [];
-    list.push(resolve);
-    eventWaiters.set(name, list);
-  });
-}
-function emitEvent(name, value) {
-  const list = eventWaiters.get(name) || [];
-  eventWaiters.delete(name);
-  for (const resolve of list) resolve(value);
-}
-function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
-
-const debugTraffic = Boolean(env.DAP_DEBUG);
-function trace(direction, message) { if (debugTraffic) stderr.write(`DAP ${direction} ${JSON.stringify(message).slice(0, 300)}\n`); }
-function line(text) { stdout.write(`${text}\n`); }
-function error(kind, detail = "") { line(`ERR: ${kind}${detail ? ` ${detail}` : ""}`); }
-function send(message) {
-  trace(">", message);
-  const body = Buffer.from(JSON.stringify(message));
-  transport.write(Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`), body]));
-}
-function request(command, args = {}) {
-  if (!transport || terminated) return Promise.reject(new Error("no-session"));
-  const seq = nextSeq++;
-  send({ type: "request", seq, command, arguments: args });
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => { pending.delete(seq); reject(new Error("timeout")); }, timeoutMs);
-    pending.set(seq, { resolve: value => { clearTimeout(timer); resolve(value); }, reject: value => { clearTimeout(timer); reject(value); } });
-  });
-}
-function onMessage(message) {
-  trace("<", message);
-  if (message.type === "response") {
-    const wait = pending.get(message.request_seq);
-    if (!wait) return;
-    pending.delete(message.request_seq);
-    if (message.success === false) wait.reject(new Error("adapter-error")); else wait.resolve(message);
-  } else if (message.type === "event") {
-    if (message.event === "initialized") { initialized = true; emitEvent("initialized"); }
-    if (message.event === "stopped") { currentStop = message.body || {}; emitEvent("stopped", currentStop); }
-    if (message.event === "terminated" || message.event === "exited") { terminated = true; emitEvent("terminated"); }
-  }
-}
-function connectTransport(write, read, close = read) {
-  transport = { write: chunk => write.write(chunk), destroy: () => close.destroy?.() };
-  parser = new DapFrameParser();
-  read.on("data", chunk => { for (const message of parser.push(chunk)) onMessage(message); });
-  read.on("error", () => { if (!terminated) error("adapter-failed"); });
-  read.on("close", () => { if (!terminated) error("adapter-failed"); });
-}
-function connectSocket(socket) { connectTransport(socket, socket, socket); }
-async function startAdapter(spec) {
-  if (isTcpAdapterSpec(spec)) {
-    const separator = spec.lastIndexOf(":");
-    const socket = createConnection(Number(spec.slice(separator + 1)), spec.slice(0, separator));
-    connectSocket(socket);
-    await new Promise((resolve, reject) => { socket.once("connect", resolve); socket.once("error", reject); });
-  } else {
-    // A .mjs/.cjs/.ts adapter spec runs under the current Bun/Node runtime (e.g. the
-    // fixture adapter); any other spec is an adapter executable (lldb-dap, debugpy, dlv)
-    // spawned directly with its own argv.
-    const isScript = /\.(mjs|cjs|ts)$/.test(spec);
-    const [cmd, argv] = isScript ? [process.execPath, [spec]] : [spec, []];
-    const child = spawn(cmd, argv, { stdio: ["pipe", "pipe", "inherit"] });
-    connectTransport(child.stdin, child.stdout, child);
-    child.on("error", () => error("adapter-failed"));
-  }
-}
-// Waits for a stopped event. When `required` is false this is a best-effort grace
-// window (e.g. an optional stop-on-entry); it returns on the first stop OR on timeout
-// without failing, so adapters that run straight to a breakpoint are not broken.
-async function waitForStop(required = true, graceMs) {
-  if (currentStop || terminated) return Boolean(currentStop);
-  const budget = graceMs ?? timeoutMs;
-  await Promise.race([onEvent("stopped"), onEvent("terminated"), sleep(budget)]);
-  return Boolean(currentStop);
-}
-// Waits for the adapter's `initialized` event, event-driven (never a busy-loop).
-async function waitInitialized() {
-  if (initialized) return;
-  await Promise.race([onEvent("initialized"), sleep(timeoutMs)]);
-  if (!initialized) throw new Error("timeout");
-}
-// Adapters gate the `initialized` event on a recognized adapterID (debugpy withholds
-// it for unknown IDs, hanging the handshake). Infer a known ID from the adapter spec.
-function adapterIdFor(spec) {
-  const base = String(spec).split("/").pop().toLowerCase();
-  if (base.includes("debugpy") || base.includes("python")) return "debugpy";
-  if (base.includes("lldb")) return "lldb-dap";
-  if (base.includes("dlv") || base.includes("delve")) return "dlv";
-  if (base.includes("js-debug")) return "js-debug";
-  if (base.includes("gdb")) return "gdb";
-  return "omo";
-}
-async function launch(adapter, program, args) {
-  if (transport) return error("adapter-error", "session already exists");
-  try {
-    await startAdapter(adapter);
-    await request("initialize", { clientID: "omo-dap", adapterID: adapterIdFor(adapter), linesStartAt1: true, columnsStartAt1: true, pathFormat: "path" });
-    // Send launch BEFORE awaiting `initialized`: debugpy's adapter defers/flushes the
-    // initialized event until further client activity, so waiting for it first
-    // deadlocks the handshake. DAP allows launch any time after the initialize
-    // response; `initialized` is only required before configurationDone.
-    // stopOnEntry yields an initial stopped event with a real threadId, so the client
-    // can set breakpoints and inspect from a valid stopped state before continuing.
-    // `console: "internalConsole"` is REQUIRED by debugpy (without it the launch never
-    // spawns the debug server -> "Server is not available"); lldb-dap ignores it.
-    // lldb-dap reports the launch response success unreliably (false even when the
-    // process started and stopped); the process/stopped EVENTS are the real signal,
-    // so a non-success launch response is tolerated, not fatal.
-    await request("launch", { program, args, console: "internalConsole", justMyCode: false, stopOnEntry: true }).catch(() => null);
-    await waitInitialized();
-    await request("configurationDone").catch(() => null);
-    // Best-effort: lldb-dap stops at entry, other adapters run to the first breakpoint.
-    await waitForStop(false, 2000);
-    line("READY: launch");
-  } catch (e) { error(e.message === "timeout" ? "timeout" : e.message === "adapter-error" ? "adapter-error" : "adapter-failed"); }
-}
-async function snapshot() {
-  if (terminated) { line("EXIT: terminated"); return; }
-  try {
-    const response = await request("stackTrace", { threadId: currentStop?.threadId || 1, levels: 1 });
-    topFrame = response.body?.stackFrames?.[0];
-    const f = topFrame;
-    if (f) line(`STOP: stopped reason=${currentStop?.reason || "unknown"} threadId=${currentStop?.threadId || ""} ${f.name} at ${f.source?.path || "?"}:${f.line || 0}:${f.column || 0}`);
-    else line(`STOP: stopped reason=${currentStop?.reason || "unknown"} threadId=${currentStop?.threadId || ""} ? at ?:0:0`);
-  } catch (e) { error(e.message === "timeout" ? "timeout" : "adapter-error"); }
-}
-function boundedTable(header, rows) {
-  const all = rows.map(row => row.join("\t"));
-  const chosen = all.slice(0, MAX_ROWS);
-  const prefix = `${header.join("\t")}\n`;
-  let output = prefix;
-  let count = 0;
-  for (const row of chosen) {
-    const candidate = `${row}\n`;
-    if (Buffer.byteLength(output + candidate) > MAX_OUTPUT_BYTES) break;
-    output += candidate; count++;
-  }
-  stdout.write(output);
-  const rowDropped = all.length - count;
-  const byteDropped = Buffer.byteLength(all.slice(count).join("\n") + (all.length > count ? "\n" : ""));
-  if (rowDropped > 0 || byteDropped > 0) line(`TRUNCATED: rows dropped=${rowDropped} bytes dropped=${byteDropped}`);
-}
-async function command(input) {
-  const parts = input.trim().split(/\s+/);
-  const cmd = parts.shift();
-  if (!cmd) return;
-  if (cmd === "quit") { transport?.destroy?.(); process.exit(0); }
-  if (cmd === "launch") return launch(parts.shift(), parts.shift(), parts);
-  if (cmd === "attach") {
-    const [host, port] = (parts.shift() || "").split(":");
-    try {
-      await startAdapter(`${host}:${port}`);
-      await request("initialize", { clientID: "omo-dap", adapterID: "debugpy", linesStartAt1: true, columnsStartAt1: true, pathFormat: "path" });
-      await waitInitialized();
-      await request("attach", { justMyCode: false });
-      await request("configurationDone");
-      line("READY: attach");
-    } catch (e) { error(e.message === "timeout" ? "timeout" : "adapter-failed"); }
-    return;
-  }
-  if (!transport) return error("no-session");
-  try {
-    if (cmd === "break" || cmd === "rmbreak") {
-      const [file, lineNo] = (parts[0] || "").split(":");
-      if (!file || !lineNo) return error("invalid-args");
-      const set = breakpoints.get(file) || [];
-      const next = cmd === "break" ? [...set.filter(x => x.line !== Number(lineNo)), { line: Number(lineNo) }] : set.filter(x => x.line !== Number(lineNo));
-      const response = await request("setBreakpoints", { source: { path: file }, breakpoints: next });
-      breakpoints.set(file, next);
-      if (response.body?.breakpoints?.some(bp => bp.verified === false)) error("unverified-breakpoint"); else line(`BREAK: ${file}:${lineNo}`);
-    } else if (["continue", "step", "next", "stepin", "stepout", "pause"].includes(cmd)) {
-      const dapCmd = { step: "next", stepin: "stepIn", stepout: "stepOut" }[cmd] || cmd;
-      const threadId = currentStop?.threadId || 1;
-      currentStop = null;
-      await request(dapCmd, { threadId });
-      // Wait for the resulting stopped event (breakpoint hit / step completed) before
-      // snapshotting; without this the stack is read while the debuggee is still running.
-      await waitForStop();
-      await snapshot();
-    } else if (cmd === "stack") {
-      const r = await request("stackTrace", { threadId: currentStop?.threadId || 1, levels: Number(parts[0]) || 100 });
-      boundedTable(["FRAME", "NAME", "FILE", "LINE", "COLUMN"], (r.body?.stackFrames || []).map(f => [String(f.id), f.name, f.source?.path || "", String(f.line || ""), String(f.column || "")]));
-    } else if (cmd === "scopes") {
-      const r = await request("scopes", { frameId: topFrame?.id || 42 });
-      boundedTable(["NAME", "VARIABLES_REFERENCE"], (r.body?.scopes || []).map(s => [s.name, String(s.variablesReference)]));
-    } else if (cmd === "vars") {
-      if (!parts[0]) return error("invalid-args");
-      const r = await request("variables", { variablesReference: Number(parts[0]) });
-      boundedTable(["NAME", "VALUE"], (r.body?.variables || []).map(v => [v.name, v.value ?? ""]));
-    } else if (cmd === "eval") {
-      if (!parts.length) return error("invalid-args");
-      const r = await request("evaluate", { expression: parts.join(" "), frameId: topFrame?.id || 42 });
-      line(`EVAL\t${r.body?.result || ""}`);
-    } else if (cmd === "threads") {
-      const r = await request("threads"); boundedTable(["ID", "NAME"], (r.body?.threads || []).map(t => [String(t.id), t.name]));
-    } else if (cmd === "sessions") line("SESSION\tSTATE\n1\tactive");
-    else if (cmd === "terminate") { await request("terminate", { restart: false }); line("EXIT: terminated"); terminated = true; }
-    else error("invalid-args");
-  } catch (e) { error(e.message === "timeout" ? "timeout" : e.message === "adapter-error" ? "adapter-error" : "adapter-failed"); }
-}
-
-if (import.meta.main) {
-  // Serialize stdin commands: fire-and-forget (`void command(...)`) lets a `continue`
-  // race ahead of the launch handshake's configurationDone, and the adapter then
-  // drops or rejects the out-of-order request. Each line awaits the previous command.
-  let chain = Promise.resolve();
-  const rl = createInterface({ input: stdin, crlfDelay: Infinity });
-  rl.on("line", value => { chain = chain.then(() => command(value)).catch(() => {}); });
-}

package/packages/omo-codex/plugin/skills/debugging/references/scripts/fixture-adapter.mjs

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-// Deterministic DAP fixture used by dap.test.ts.
-import { stdin, stdout, argv } from "node:process";
-
-let seq = 1;
-let buffer = Buffer.alloc(0);
-const noAnswer = argv.includes("--no-answer") || process.env.DAP_FIXTURE_NO_ANSWER === "1";
-
-function send(message) {
-  const body = Buffer.from(JSON.stringify(message));
-  stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
-  stdout.write(body);
-}
-function response(request, body = {}, success = true, message) {
-  send({ type: "response", seq: seq++, request_seq: request.seq, success, command: request.command, body, ...(message ? { message } : {}) });
-}
-function event(event, body = {}) { send({ type: "event", seq: seq++, event, body }); }
-function handle(request) {
-  if (noAnswer && request.command === "initialize") return;
-  switch (request.command) {
-    case "initialize":
-      response(request, { supportsConfigurationDoneRequest: true, supportsEvaluateForHovers: true });
-      event("initialized");
-      break;
-    case "setBreakpoints": {
-      const bps = request.arguments?.breakpoints ?? [];
-      response(request, { breakpoints: bps.map((bp, i) => ({ id: i + 1, verified: !request.arguments?.source?.path?.includes("unverified"), line: bp.line, column: bp.column ?? 1, message: "fixture" })) });
-      break;
-    }
-    case "configurationDone": response(request); break;
-    case "launch": response(request); break;
-    case "continue": response(request, { allThreadsContinued: true }); event("stopped", { reason: "breakpoint", threadId: 1, allThreadsStopped: true }); break;
-    case "next": case "stepIn": case "stepOut": response(request); event("stopped", { reason: "step", threadId: 1 }); break;
-    case "pause": response(request); event("stopped", { reason: "pause", threadId: 1 }); break;
-    case "threads": response(request, { threads: [{ id: 1, name: "main" }] }); break;
-    case "stackTrace": response(request, { stackFrames: [{ id: 42, name: "main", source: { path: "/tmp/program.py" }, line: 12, column: 3 }] }); break;
-    case "scopes": response(request, { scopes: [{ name: "Locals", variablesReference: 7, expensive: false }] }); break;
-    case "variables": response(request, { variables: Array.from({ length: 250 }, (_, i) => ({ name: `v${i + 1}`, value: request.arguments?.variablesReference === 8 ? `${String(i + 1)} ${"x".repeat(500)}` : String(i + 1), variablesReference: 0 })) }); break;
-    case "evaluate": response(request, { result: "42", type: "int", variablesReference: 0 }); break;
-    case "terminate": response(request); event("terminated", {}); break;
-    default: response(request, {}, false, `unsupported ${request.command}`);
-  }
-}
-stdin.on("data", chunk => {
-  buffer = Buffer.concat([buffer, chunk]);
-  while (true) {
-    const marker = buffer.indexOf(Buffer.from("\r\n\r\n"));
-    if (marker < 0) return;
-    const header = buffer.subarray(0, marker).toString();
-    const match = header.match(/Content-Length:\s*(\d+)/i);
-    if (!match) { buffer = buffer.subarray(marker + 4); continue; }
-    const length = Number(match[1]);
-    const start = marker + 4;
-    if (buffer.length < start + length) return;
-    const body = buffer.subarray(start, start + length);
-    buffer = buffer.subarray(start + length);
-    try { handle(JSON.parse(body.toString("utf8"))); } catch { /* fixture input is controlled */ }
-  }
-});