@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.7

package/src/launch/broker-output-snapshot.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, it, vi } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { TempDir } from "@oh-my-pi/pi-utils";
-import { startDaemonBrokerFromEnvironment } from "./broker";
-import { createDaemonBrokerClient } from "./client";
-import {
-	DAEMON_IDLE_GRACE_ENV,
-	DAEMON_PROJECT_DIR_ENV,
-	DAEMON_RUNTIME_DIR_ENV,
-	type DaemonOperation,
-} from "./protocol";
-import * as terminalOutput from "./terminal-output";
-
-function restoreEnv(name: string, value: string | undefined): void {
-	if (value === undefined) delete process.env[name];
-	else process.env[name] = value;
-}
-
-describe("daemon broker log snapshots", () => {
-	it("returns the cursor captured with the PTY bytes rendered in the response", async () => {
-		using tempDir = TempDir.createSync("@omp-launch-cursor-");
-		const projectDir = path.join(tempDir.path(), "project");
-		const runtimeDir = path.join(tempDir.path(), "runtime");
-		await fs.mkdir(projectDir);
-		const scriptPath = path.join(projectDir, "service.ts");
-		await Bun.write(
-			scriptPath,
-			`process.stdin.setEncoding("utf8");
-process.stdin.resume();
-process.stdout.write("READY\\n");
-process.stdin.on("data", () => process.stdout.write("AFTER-SNAPSHOT\\n"));
-`,
-		);
-
-		const client = await createDaemonBrokerClient(projectDir, { runtimeDir, idleGraceMs: 5_000 });
-		const renderStarted = Promise.withResolvers<void>();
-		const releaseRender = Promise.withResolvers<void>();
-		const renderTerminalOutput = terminalOutput.renderTerminalOutput;
-		vi.spyOn(terminalOutput, "renderTerminalOutput").mockImplementation(async (output, options) => {
-			renderStarted.resolve();
-			await releaseRender.promise;
-			return renderTerminalOutput(output, options);
-		});
-
-		const previousProjectDir = process.env[DAEMON_PROJECT_DIR_ENV];
-		const previousRuntimeDir = process.env[DAEMON_RUNTIME_DIR_ENV];
-		const previousGrace = process.env[DAEMON_IDLE_GRACE_ENV];
-		const previousTitle = process.title;
-		process.env[DAEMON_PROJECT_DIR_ENV] = projectDir;
-		process.env[DAEMON_RUNTIME_DIR_ENV] = runtimeDir;
-		process.env[DAEMON_IDLE_GRACE_ENV] = "5000";
-		const broker = startDaemonBrokerFromEnvironment();
-		restoreEnv(DAEMON_PROJECT_DIR_ENV, previousProjectDir);
-		restoreEnv(DAEMON_RUNTIME_DIR_ENV, previousRuntimeDir);
-		restoreEnv(DAEMON_IDLE_GRACE_ENV, previousGrace);
-
-		try {
-			const started = await client.request({
-				op: "start",
-				spec: {
-					name: "cursor",
-					application: process.execPath,
-					args: [scriptPath],
-					env: {},
-					cwd: projectDir,
-					pty: true,
-					ready: { log: "READY", timeoutMs: 5_000 },
-					restart: "no",
-					persist: false,
-					detached: false,
-				},
-			});
-			if (started.op !== "start") throw new Error("unexpected start result");
-			expect(started.readyTimedOut).toBeFalse();
-
-			const snapshotPromise = client.request({
-				op: "logs",
-				name: "cursor",
-				lines: 20,
-				head: false,
-				follow: false,
-				timeoutMs: 1_000,
-				renderTerminalRows: true,
-			} as DaemonOperation);
-			await renderStarted.promise;
-			await client.request({ op: "send", name: "cursor", data: "race\r" });
-			const observed = await client.request({
-				op: "wait",
-				name: "cursor",
-				for: "exit",
-				pattern: "AFTER-SNAPSHOT",
-				timeoutMs: 1_000,
-			});
-			if (observed.op !== "wait") throw new Error("unexpected wait result");
-			expect(observed.timedOut).toBeFalse();
-			releaseRender.resolve();
-
-			const snapshot = await snapshotPromise;
-			if (snapshot.op !== "logs") throw new Error("unexpected logs result");
-			expect(snapshot.terminalRows?.join("\n")).not.toContain("AFTER-SNAPSHOT");
-
-			const followed = await client.request({
-				op: "logs",
-				name: "cursor",
-				lines: 20,
-				head: false,
-				follow: true,
-				cursor: snapshot.cursor,
-				timeoutMs: 1_000,
-				renderTerminalRows: true,
-			} as DaemonOperation);
-			if (followed.op !== "logs") throw new Error("unexpected follow result");
-			expect(followed.timedOut).toBeFalse();
-			expect(followed.text).toContain("AFTER-SNAPSHOT");
-		} finally {
-			releaseRender.resolve();
-			await client.request({ op: "stop", name: "cursor", timeoutMs: 2_000 }).catch(() => undefined);
-			await client.request({ op: "shutdown" }).catch(() => undefined);
-			client.close();
-			await broker;
-			process.title = previousTitle;
-			vi.restoreAllMocks();
-		}
-	}, 20_000);
-});

package/src/launch/protocol.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { type DaemonOperation, parseDaemonRpcResult, parseDaemonWireRequest } from "./protocol";
-
-const operation: Extract<DaemonOperation, { op: "logs" }> = {
-	op: "logs",
-	name: "web",
-	lines: 20,
-	head: false,
-	follow: false,
-	timeoutMs: 1_000,
-};
-
-const baseResult = {
-	name: "web",
-	text: "ready",
-	cursor: 42,
-	timedOut: false,
-	state: "running" as const,
-};
-
-describe("launch logs protocol", () => {
-	it("decodes terminal rows without changing their bytes", () => {
-		const terminalRows = ["\x1b[0m\x1b[1;38;5;2mready", "", "界e\u0301"];
-		expect(parseDaemonRpcResult(operation, { ...baseResult, terminalRows })).toEqual({
-			op: "logs",
-			...baseResult,
-			terminalRows,
-		});
-	});
-
-	it("rejects a non-array terminal row payload", () => {
-		expect(() => parseDaemonRpcResult(operation, { ...baseResult, terminalRows: "ready" })).toThrow(
-			"result.terminalRows must be an array of strings",
-		);
-	});
-
-	it("rejects non-string terminal row entries", () => {
-		expect(() => parseDaemonRpcResult(operation, { ...baseResult, terminalRows: ["ready", 7] })).toThrow(
-			"result.terminalRows item must be a string",
-		);
-	});
-});
-
-describe("launch logs compatibility", () => {
-	it("preserves the rendered-row request for upgraded brokers", () => {
-		const request = parseDaemonWireRequest({
-			id: "request-1",
-			token: "token-1",
-			operation: { ...operation, renderTerminalRows: true },
-		});
-		expect(request.operation).toMatchObject({ ...operation, renderTerminalRows: true });
-	});
-
-	it("decodes raw terminal text from an already-running legacy broker", () => {
-		const result = parseDaemonRpcResult(operation, { ...baseResult, terminalText: "progress\rready" });
-		if (result.op !== "logs") throw new Error("unexpected result");
-		expect("terminalText" in result ? result.terminalText : undefined).toBe("progress\rready");
-	});
-});

package/src/launch/spawn-options.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { resolveDaemonSpawnOptions } from "./spawn-options";
-
-describe("resolveDaemonSpawnOptions", () => {
-	it("hides Windows daemons when the host has no console", () => {
-		expect(
-			resolveDaemonSpawnOptions({
-				platform: "win32",
-				hostHasInheritableConsole: false,
-			}),
-		).toEqual({ detached: false, windowsHide: true });
-	});
-
-	it("inherits the Windows host console instead of detaching", () => {
-		expect(
-			resolveDaemonSpawnOptions({
-				platform: "win32",
-				hostHasInheritableConsole: true,
-			}),
-		).toEqual({ detached: false, windowsHide: false });
-	});
-
-	it("keeps POSIX daemons in their own session", () => {
-		expect(
-			resolveDaemonSpawnOptions({
-				platform: "linux",
-				hostHasInheritableConsole: false,
-			}),
-		).toEqual({ detached: true });
-	});
-});

package/src/launch/terminal-output.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { renderTerminalOutput } from "./terminal-output";
-
-const RESET = "\x1b[0m";
-
-interface TerminalCase {
-	name: string;
-	input: string;
-	expected: string[];
-}
-
-const cases: TerminalCase[] = [
-	{
-		name: "overwrites the current row after carriage return",
-		input: "progress 10%\rDONE",
-		expected: [`${RESET}DONEress 10%`],
-	},
-	{
-		name: "honors absolute and relative horizontal cursor movement",
-		input: "abcdef\x1b[3GZ\x1b[2CX",
-		expected: [`${RESET}abZdeX`],
-	},
-	{
-		name: "honors absolute and relative vertical cursor movement",
-		input: "one\r\ntwo\r\nthree\x1b[2A\x1b[1GONE\x1b[1B\x1b[2D]",
-		expected: [`${RESET}ONE`, `${RESET}t]o`, `${RESET}three`],
-	},
-	{
-		name: "honors absolute cursor positioning",
-		input: "abc\r\ndef\x1b[1;2HZ",
-		expected: [`${RESET}aZc`, `${RESET}def`],
-	},
-	{
-		name: "erases from the cursor through the row",
-		input: "abcdef\r\x1b[3C\x1b[K",
-		expected: [`${RESET}abc`],
-	},
-	{
-		name: "inserts characters without losing shifted content",
-		input: "abcdef\r\x1b[3C\x1b[2@XY",
-		expected: [`${RESET}abcXYdef`],
-	},
-	{
-		name: "deletes characters and closes the gap",
-		input: "abcdef\r\x1b[2C\x1b[2P",
-		expected: [`${RESET}abef`],
-	},
-	{
-		name: "inserts a terminal row",
-		input: "one\r\ntwo\r\nthree\x1b[2;1H\x1b[Linserted",
-		expected: [`${RESET}one`, `${RESET}inserted`, `${RESET}two`, `${RESET}three`],
-	},
-	{
-		name: "deletes a terminal row",
-		input: "one\r\ntwo\r\nthree\x1b[2;1H\x1b[M",
-		expected: [`${RESET}one`, `${RESET}three`],
-	},
-	{
-		name: "wraps at the fixed 120-column PTY width",
-		input: `${"a".repeat(120)}b`,
-		expected: [`${RESET}${"a".repeat(120)}`, `${RESET}b`],
-	},
-	{
-		name: "preserves wide and combining characters",
-		input: "A界e\u0301B",
-		expected: [`${RESET}A界e\u0301B`],
-	},
-	{
-		name: "canonicalizes color, reset, and text decorations",
-		input: "\x1b[1;2;3;4;7;9;53;38;2;1;2;3;48;5;17mX\x1b[0mY",
-		expected: [`${RESET}\x1b[1;2;3;4;7;9;53;38;2;1;2;3;48;5;17mX${RESET}Y`],
-	},
-	{
-		name: "restores the normal buffer after alternate-buffer output",
-		input: "main\x1b[?1049hALT\x1b[?1049l",
-		expected: [`${RESET}main`],
-	},
-	{
-		name: "keeps internal blank rows while trimming blank rows and spaces at the end",
-		input: "alpha   \r\n\r\nomega   \r\n\r\n",
-		expected: [`${RESET}alpha`, "", `${RESET}omega`],
-	},
-];
-
-describe("renderTerminalOutput", () => {
-	for (const testCase of cases) {
-		it(testCase.name, async () => {
-			expect(await renderTerminalOutput(testCase.input, { head: false, maxRows: 100 })).toEqual(testCase.expected);
-		});
-	}
-
-	it("returns an empty row set for empty output", async () => {
-		expect(await renderTerminalOutput("", { head: false, maxRows: 100 })).toEqual([]);
-	});
-
-	it("applies head and tail row limits after replaying scrollback", async () => {
-		const output = Array.from({ length: 4_200 }, (_, index) => `row-${index}`).join("\r\n");
-		expect(await renderTerminalOutput(output, { head: true, maxRows: 2 })).toEqual([
-			`${RESET}row-64`,
-			`${RESET}row-65`,
-		]);
-		expect(await renderTerminalOutput(output, { head: false, maxRows: 2 })).toEqual([
-			`${RESET}row-4198`,
-			`${RESET}row-4199`,
-		]);
-	});
-});

package/src/live/protocol.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-	buildDelegationContextAppend,
-	buildLiveSessionPayload,
-	buildSessionClose,
-	buildSessionContextAppend,
-	CONTEXT_CHUNK_BYTES,
-	chunkLiveContext,
-	LIVE_MODEL,
-	parseLiveServerEvent,
-} from "./protocol";
-
-describe("Frameless Bidi server events", () => {
-	test("parses a client delegation and keeps only input text content", () => {
-		const event = parseLiveServerEvent(
-			JSON.stringify({
-				type: "delegation.created",
-				item: {
-					type: "delegation",
-					target: "client",
-					id: "delegation-7",
-					content: [
-						{ type: "input_text", text: "Inspect the failing build. " },
-						{ type: "output_text", text: "ignored" },
-						{ type: "input_text", text: "Repair the root cause." },
-					],
-				},
-			}),
-		);
-
-		expect(event).toEqual({
-			type: "delegation.created",
-			item: {
-				type: "delegation",
-				target: "client",
-				id: "delegation-7",
-				content: [
-					{ type: "input_text", text: "Inspect the failing build. " },
-					{ type: "input_text", text: "Repair the root cause." },
-				],
-			},
-		});
-	});
-
-	test("parses input and output transcript deltas", () => {
-		expect(parseLiveServerEvent({ type: "input_transcript.added", item: { text: "What changed?" } })).toEqual({
-			type: "input_transcript.added",
-			item: { text: "What changed?" },
-		});
-		expect(parseLiveServerEvent({ type: "output_transcript.added", item: { text: "I will inspect it." } })).toEqual({
-			type: "output_transcript.added",
-			item: { text: "I will inspect it." },
-		});
-	});
-
-	test("parses completed user and assistant turns", () => {
-		expect(
-			parseLiveServerEvent({ type: "turn.done", turn: { role: "user", transcript: "Run the checks." } }),
-		).toEqual({ type: "turn.done", turn: { role: "user", transcript: "Run the checks." } });
-		expect(
-			parseLiveServerEvent({
-				type: "turn.done",
-				turn: { role: "assistant", transcript: "The checks pass." },
-			}),
-		).toEqual({ type: "turn.done", turn: { role: "assistant", transcript: "The checks pass." } });
-	});
-
-	test("parses an output audio delta", () => {
-		expect(parseLiveServerEvent('{"type":"output_audio.delta","audio":"AAECAw=="}')).toEqual({
-			type: "output_audio.delta",
-			audio: "AAECAw==",
-		});
-	});
-
-	test("extracts top-level and nested error messages", () => {
-		expect(parseLiveServerEvent({ type: "error", message: "call expired" })).toEqual({
-			type: "error",
-			message: "call expired",
-		});
-		expect(parseLiveServerEvent({ type: "error", error: { message: "media rejected", code: "bad_media" } })).toEqual({
-			type: "error",
-			message: "media rejected",
-		});
-	});
-
-	test("classifies unsupported events and rejects malformed known events", () => {
-		expect(parseLiveServerEvent({ type: "rate_limits.updated", remaining: 3 })).toEqual({
-			type: "unknown",
-			wireType: "rate_limits.updated",
-		});
-		expect(parseLiveServerEvent({ type: "output_audio.delta", audio: 12 })).toBeNull();
-		expect(parseLiveServerEvent({ type: "turn.done", turn: { role: "tool", transcript: "no" } })).toBeNull();
-		expect(parseLiveServerEvent("not json")).toBeNull();
-	});
-});
-
-describe("Frameless Bidi client payloads", () => {
-	test("builds the exact live call session JSON", () => {
-		const payload = buildLiveSessionPayload("Be concise.", "marin");
-
-		expect(LIVE_MODEL).toBe("gpt-live-1-codex");
-		expect(JSON.stringify(payload)).toBe(
-			'{"model":"gpt-live-1-codex","instructions":"Be concise.","audio":{"output":{"voice":"marin"}},"delegation":{"type":"client"}}',
-		);
-	});
-
-	test("builds the exact delegation context JSON", () => {
-		const message = buildDelegationContextAppend("delegation-7", "The tests now pass.", "commentary");
-
-		expect(JSON.stringify(message)).toBe(
-			'{"type":"delegation.context.append","delegation_item_id":"delegation-7","channel":"commentary","content":[{"type":"input_text","text":"The tests now pass."}]}',
-		);
-	});
-
-	test("omits optional channels and builds session close", () => {
-		expect(buildDelegationContextAppend("delegation-8", "Done.")).toEqual({
-			type: "delegation.context.append",
-			delegation_item_id: "delegation-8",
-			content: [{ type: "input_text", text: "Done." }],
-		});
-		expect(buildSessionContextAppend("Still investigating.", "speakable")).toEqual({
-			type: "session.context.append",
-			channel: "speakable",
-			content: [{ type: "input_text", text: "Still investigating." }],
-		});
-		expect(buildSessionClose()).toEqual({ type: "session.close" });
-	});
-});
-
-test("context chunks are UTF-8 safe, bounded, and perfectly reassemble", () => {
-	const text = `${"a".repeat(497)}🙂${"é漢🙂".repeat(180)}`;
-	const chunks = chunkLiveContext(text);
-	const encoder = new TextEncoder();
-
-	expect(chunks.length).toBeGreaterThan(1);
-	expect(chunks.join("")).toBe(text);
-	for (const chunk of chunks) {
-		expect(encoder.encode(chunk).byteLength).toBeLessThanOrEqual(CONTEXT_CHUNK_BYTES);
-	}
-});

package/src/mcp/config-writer.test.ts

@@ -1,43 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { addMCPServer, readDisabledServers, readMCPConfigFile, setServerDisabled } from "./config-writer";
-
-describe("config-writer concurrent mutations", () => {
-	let dir: string;
-	let filePath: string;
-
-	beforeEach(async () => {
-		dir = await fs.mkdtemp(path.join(os.tmpdir(), "omp-mcp-config-"));
-		filePath = path.join(dir, "mcp.json");
-	});
-
-	afterEach(async () => {
-		await fs.rm(dir, { recursive: true, force: true });
-	});
-
-	it("preserves both servers when two adds race the same file", async () => {
-		await Promise.all([
-			addMCPServer(filePath, "alpha", { type: "stdio", command: "a" }),
-			addMCPServer(filePath, "bravo", { type: "stdio", command: "b" }),
-		]);
-
-		const config = await readMCPConfigFile(filePath);
-		expect(Object.keys(config.mcpServers ?? {}).sort()).toEqual(["alpha", "bravo"]);
-	});
-
-	it("preserves both denylist edits when disable calls race", async () => {
-		await Promise.all([setServerDisabled(filePath, "alpha", true), setServerDisabled(filePath, "bravo", true)]);
-
-		expect((await readDisabledServers(filePath)).sort()).toEqual(["alpha", "bravo"]);
-	});
-
-	it("writes into a directory that does not exist yet", async () => {
-		const nestedPath = path.join(dir, "nested", "deep", "mcp.json");
-		await addMCPServer(nestedPath, "alpha", { type: "stdio", command: "a" });
-
-		const config = await readMCPConfigFile(nestedPath);
-		expect(Object.keys(config.mcpServers ?? {})).toEqual(["alpha"]);
-	});
-});

package/src/mcp/smithery-auth.test.ts

@@ -1,29 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import { pollSmitheryCliAuthSession } from "./smithery-auth";
-
-type FetchInput = string | URL | Request;
-type FetchInit = RequestInit | BunFetchRequestInit;
-
-describe("pollSmitheryCliAuthSession fetch cancellation", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("bounds each poll request with a timeout abort signal even without a caller signal", async () => {
-		const signals: AbortSignal[] = [];
-		const fetchStub = Object.assign(
-			async (_input: FetchInput, init?: FetchInit) => {
-				if (init?.signal instanceof AbortSignal) signals.push(init.signal);
-				return Response.json({ status: "pending" });
-			},
-			{ preconnect: globalThis.fetch.preconnect },
-		);
-		vi.spyOn(globalThis, "fetch").mockImplementation(fetchStub);
-
-		const result = await pollSmitheryCliAuthSession("sess-123");
-
-		expect(result.status).toBe("pending");
-		expect(signals).toHaveLength(1);
-		expect(signals[0]?.aborted).toBe(false);
-	});
-});

package/src/mcp/smithery-registry.test.ts

@@ -1,51 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import { searchSmitheryRegistry } from "./smithery-registry";
-
-type FetchInput = string | URL | Request;
-type FetchInit = RequestInit | BunFetchRequestInit;
-
-describe("searchSmitheryRegistry fetch cancellation", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("adds timeout signals to search and detail requests", async () => {
-		const signals: AbortSignal[] = [];
-		const fetchStub = Object.assign(
-			async (input: FetchInput, init?: FetchInit) => {
-				if (init?.signal instanceof AbortSignal) signals.push(init.signal);
-				const url = String(input);
-				if (url.includes("?")) {
-					return Response.json({
-						servers: [
-							{
-								id: "srv_1",
-								namespace: "smithery-ai",
-								slug: "filesystem",
-								qualifiedName: "@smithery-ai/filesystem",
-								displayName: "Filesystem",
-								description: "File access",
-								useCount: 1,
-							},
-						],
-					});
-				}
-				return Response.json({
-					qualifiedName: "@smithery-ai/filesystem",
-					displayName: "Filesystem",
-					description: "File access",
-					connections: [{ type: "http", deploymentUrl: "https://mcp.example" }],
-					tools: [],
-				});
-			},
-			{ preconnect: globalThis.fetch.preconnect },
-		);
-		vi.spyOn(globalThis, "fetch").mockImplementation(fetchStub);
-
-		const results = await searchSmitheryRegistry("filesystem", { limit: 1 });
-
-		expect(results[0]?.name).toBe("smithery-ai/filesystem");
-		expect(signals).toHaveLength(2);
-		expect(signals.every(signal => signal instanceof AbortSignal)).toBe(true);
-	});
-});