@gajae-code/coding-agent 0.12.0 → 0.12.1

package/scripts/acp-conformance-agent.ts

@@ -0,0 +1,218 @@
+#!/usr/bin/env bun
+
+/**
+ * Credential-free ACP fixture launcher. The loopback endpoint is deliberately
+ * deterministic; the child remains the production `gjc --mode acp` surface.
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const root = path.resolve(import.meta.dir, "..", "..", "..");
+const agentDir = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-acp-conformance-"));
+let child: ReturnType<typeof Bun.spawn> | undefined;
+let server: ReturnType<typeof Bun.serve> | undefined;
+
+/**
+ * Deterministic replies for the pinned `acp-core-v1` corpus. Each branch mirrors one
+ * upstream case expectation; nothing here reaches the network.
+ */
+function response(prompt: string): string {
+	if (prompt.includes("inspect-prompt")) return `received blocks: {"type":"resource"}`;
+	if (prompt.includes("this-command-does-not-exist")) return "unrecognized prompt";
+	if (/^\s*read\b/m.test(prompt)) return "read README.md: acpx";
+	if (/^\s*write\b/m.test(prompt)) {
+		const target = /write\s+(\S+)/.exec(prompt)?.[1] ?? "file";
+		return `wrote ${target}`;
+	}
+	const echo = /^\s*echo\s*(.*)$/m.exec(prompt);
+	if (echo) return echo[1] || "echo";
+	return "ok";
+}
+
+function sse(value: unknown): string {
+	return `data: ${JSON.stringify(value)}\n\n`;
+}
+
+function completion(delta: Record<string, unknown>, finishReason: string | null = null): string {
+	return sse({ id: "gjc-conformance", choices: [{ delta, finish_reason: finishReason }] });
+}
+
+function toolCall(name: "read" | "write", arguments_: Record<string, string>): string {
+	return completion(
+		{
+			tool_calls: [
+				{
+					index: 0,
+					id: `conformance-${name}`,
+					type: "function",
+					function: { name, arguments: JSON.stringify(arguments_) },
+				},
+			],
+		},
+		"tool_calls",
+	);
+}
+
+function textCompletion(text: string): string {
+	return `${completion({ content: text })}${completion({}, "stop")}data: [DONE]\n\n`;
+}
+
+async function cleanup(code = 0): Promise<never> {
+	server?.stop(true);
+	if (child && child.exitCode === null) child.kill();
+	await fs.rm(agentDir, { recursive: true, force: true });
+	process.exit(code);
+}
+
+server = Bun.serve({
+	hostname: "127.0.0.1",
+	port: 0,
+	async fetch(request) {
+		const body = (await request.json().catch(() => ({}))) as {
+			messages?: Array<{ role?: string; content?: unknown }>;
+		};
+		// OpenAI-style content is either a plain string or an array of typed blocks.
+		const textOf = (content: unknown): string =>
+			typeof content === "string"
+				? content
+				: Array.isArray(content)
+					? content
+							.map(block =>
+								typeof block === "object" &&
+								block !== null &&
+								typeof (block as { text?: unknown }).text === "string"
+									? (block as { text: string }).text
+									: "",
+							)
+							.join("")
+					: "";
+		const messages = body.messages ?? [];
+		const prompt =
+			[...messages]
+				.reverse()
+				.filter(message => message.role === "user")
+				.map(message => textOf(message.content))
+				.find(text => text.length > 0) ?? "";
+		const hasToolResult = messages.some(message => message.role === "tool");
+		const isRead = /^\s*read\b/m.test(prompt);
+		const isWrite = /^\s*write\b/m.test(prompt);
+		const isLateTool = prompt.includes("late-tool 40 follow-up");
+
+		if (prompt.includes("sleep")) {
+			const requested = Number(/\bsleep\s+(\d+)/.exec(prompt)?.[1] ?? 0);
+			const delay = Math.min(Math.max(requested, 0), 30_000);
+			const stream = new ReadableStream<Uint8Array>({
+				start(controller) {
+					let closed = false;
+					const close = () => {
+						if (closed) return;
+						closed = true;
+						controller.close();
+					};
+					request.signal.addEventListener("abort", close, { once: true });
+					void Bun.sleep(delay).then(() => {
+						if (closed) return;
+						controller.enqueue(new TextEncoder().encode(textCompletion("slept")));
+						close();
+					});
+				},
+			});
+			return new Response(stream, { headers: { "content-type": "text/event-stream" } });
+		}
+
+		if ((isRead || isWrite || isLateTool) && !hasToolResult) {
+			if (isLateTool) {
+				const prefix = `${completion({ content: "preparing" })}${completion({ content: " writing now" })}${completion({ content: " before tool" })}`;
+				return new Response(
+					`${prefix}${toolCall("write", { path: ".acpx-conformance-late.txt", content: "late" })}data: [DONE]\n\n`,
+					{
+						headers: { "content-type": "text/event-stream" },
+					},
+				);
+			}
+			// Neutral pre-tool text: every corpus assertion below must come from the real
+			// tool result, never from a marker announced before the tool ran.
+			const provisional = isRead ? "checking the requested file" : "applying the requested write";
+			return new Response(
+				`${completion({ content: provisional })}${toolCall(
+					isRead ? "read" : "write",
+					isRead
+						? { path: "README.md" }
+						: {
+								path: /write\s+(\S+)/.exec(prompt)?.[1] ?? "file",
+								content: /write\s+\S+\s*(.*)/.exec(prompt)?.[1] ?? "",
+							},
+				)}data: [DONE]\n\n`,
+				{ headers: { "content-type": "text/event-stream" } },
+			);
+		}
+
+		// Derive the reply from what the tool actually returned so a broken permission
+		// bridge, filesystem bridge, or tool result cannot still satisfy the corpus.
+		const toolText = messages
+			.filter(message => message.role === "tool")
+			.map(message => textOf(message.content))
+			.join("\n");
+		const toolDenied = /rejected by user|permission denied|not permitted/i.test(toolText);
+		const reply = toolDenied
+			? `permission denied: ${toolText.slice(0, 200)}`
+			: isRead
+				? `read README.md: ${toolText.trim().slice(0, 200)}`
+				: isWrite
+					? `wrote ${/write\s+(\S+)/.exec(prompt)?.[1] ?? "file"}: ${toolText.trim().slice(0, 120)}`
+					: isLateTool
+						? `writing now: ${toolText.trim().slice(0, 120)}`
+						: response(prompt);
+		return new Response(textCompletion(reply), { headers: { "content-type": "text/event-stream" } });
+	},
+});
+
+await Bun.write(
+	path.join(agentDir, "models.json"),
+	JSON.stringify({
+		providers: {
+			conformance: {
+				api: "openai-completions",
+				baseUrl: `http://127.0.0.1:${server.port}/v1`,
+				auth: "none",
+				models: [{ id: "fixture", name: "fixture", input: ["text"], contextWindow: 1_000_000, maxTokens: 8192 }],
+			},
+		},
+	}),
+);
+
+// The pinned corpus reads `README.md` from the session cwd the runner passes on
+// `session/new`. The runner creates that directory but seeds no content, so seed it
+// here (never inside the upstream corpus) when the harness names it.
+const scratchCwd = process.env.GJC_ACP_CONFORMANCE_CWD?.trim();
+if (scratchCwd) {
+	const scratchReadme = path.join(scratchCwd, "README.md");
+	if (!(await Bun.file(scratchReadme).exists())) await Bun.write(scratchReadme, "acpx conformance workspace\n");
+}
+
+child = Bun.spawn(
+	[
+		"bun",
+		path.join(root, "packages", "coding-agent", "src", "cli.ts"),
+		"--mode",
+		"acp",
+		"--model",
+		"conformance/fixture",
+	],
+	{
+		cwd: root,
+		env: { ...process.env, GJC_CODING_AGENT_DIR: agentDir, PI_CODING_AGENT_DIR: agentDir },
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+	},
+);
+process.once("SIGTERM", () => {
+	void cleanup(0);
+});
+process.once("SIGINT", () => {
+	void cleanup(0);
+});
+await child.exited;
+await cleanup(child.exitCode ?? 1);

package/scripts/capture-gjc-bundle-settings.ts

@@ -0,0 +1,306 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { GjcLifecycleContext } from "../src/extensibility/gjc-plugins/lifecycle";
+import type { GjcRuntimeSnapshotProvider } from "../src/extensibility/gjc-plugins/runtime-quarantine";
+import type {
+	GjcBundleIdentity,
+	GjcBundleSummary,
+	GjcLifecycleResult,
+	GjcToggleResult,
+	GjcUpdateApplyResult,
+	GjcUpdatePreview,
+} from "../src/extensibility/gjc-plugins/types";
+import { type GjcBundleLifecyclePort, GjcBundleSettingsComponent } from "../src/modes/components/gjc-bundle-settings";
+import { setTheme } from "../src/modes/theme/theme";
+import {
+	GJC_BUNDLE_SETTINGS_ENTRIES,
+	GJC_BUNDLE_SETTINGS_STATES,
+	GJC_BUNDLE_SETTINGS_VIEWPORTS,
+	type GjcBundleSettingsFixture,
+} from "../test/fixtures/gjc-bundles-settings-cases";
+
+export const GJC_BUNDLE_SETTINGS_CAPTURE_FILES = [
+	"terminal.txt",
+	"terminal-ansi.txt",
+	"terminal.html",
+	"metadata.json",
+] as const;
+
+type CaptureFileName = (typeof GJC_BUNDLE_SETTINGS_CAPTURE_FILES)[number];
+
+type FixtureEntry = (typeof GJC_BUNDLE_SETTINGS_ENTRIES)[number];
+
+type CapturePlanItem = {
+	entryId: string;
+	fileName: CaptureFileName;
+};
+
+type CaptureMetadata = {
+	entryId: string;
+	stateId: string;
+	viewport: { id: string; cols: number; rows: number };
+	variant: { renderMode: string };
+	sha256: Record<Exclude<CaptureFileName, "metadata.json">, string>;
+};
+
+/**
+ * Locator-shaped content that must never reach a capture. Applied to the
+ * rendered terminal text, which is the only surface that can carry a leaked
+ * locator; generated HTML/CSS legitimately contains `#rrggbb` colors and
+ * escaped entities, so it is checked against the same rules via its source
+ * text rather than its markup.
+ */
+const FORBIDDEN_CAPTURE_CONTENT = /:\/\/user:|@[^\s/]+|\?[^\s]*=|token|\/Users\/|\/home\//i;
+
+function sha256(content: string): string {
+	return new Bun.CryptoHasher("sha256").update(content).digest("hex");
+}
+
+function json(value: unknown): string {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function escapeHtml(text: string): string {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+function ansiToHtml(ansi: string): string {
+	const sgr = /\x1b\[([0-9;]*)m/g;
+	let html = "";
+	let offset = 0;
+	let style = "";
+	for (const match of ansi.matchAll(sgr)) {
+		html += `<span style="${style}">${escapeHtml(ansi.slice(offset, match.index))}</span>`;
+		offset = (match.index ?? 0) + match[0].length;
+		const codes = (match[1] || "0").split(";").map(Number);
+		for (let index = 0; index < codes.length; index += 1) {
+			const code = codes[index];
+			if (code === 0) style = "";
+			else if (code === 1) style = `${style}font-weight:700;`;
+			else if (code === 2) style = `${style}opacity:.65;`;
+			else if (code === 22) style = style.replace("font-weight:700;", "").replace("opacity:.65;", "");
+			else if (code === 38 && codes[index + 1] === 2) {
+				const [red, green, blue] = codes.slice(index + 2, index + 5);
+				if ([red, green, blue].every(Number.isInteger)) style = `${style}color:rgb(${red},${green},${blue});`;
+				index += 4;
+			} else if (code === 39) style = style.replace(/color:[^;]+;/g, "");
+		}
+	}
+	html += `<span style="${style}">${escapeHtml(ansi.slice(offset))}</span>`;
+	return `<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><meta name="color-scheme" content="dark"><title>GJC Bundles settings</title><style>body{margin:0;background:#111;color:#eee}pre{margin:0;padding:1em;white-space:pre-wrap;font-family:ui-monospace,monospace;line-height:1.2}</style></head>
+<body><pre>${html}</pre></body>
+</html>
+`;
+}
+
+function asciiText(text: string): string {
+	return text
+		.replaceAll("─", "-")
+		.replaceAll("…", "...")
+		.replaceAll("·", ".")
+		.replaceAll("→", "->")
+		.replaceAll("−", "-");
+}
+
+function cloneSummary(summary: GjcBundleSummary): GjcBundleSummary {
+	return {
+		...summary,
+		identity: { ...summary.identity },
+		source: { ...summary.source },
+		surfaces: summary.surfaces.map(surface => ({ ...surface })),
+	};
+}
+
+class FixtureLifecyclePort implements GjcBundleLifecyclePort {
+	constructor(private readonly fixture: GjcBundleSettingsFixture) {}
+
+	async listGjcBundles(_ctx: GjcLifecycleContext): Promise<GjcBundleSummary[]> {
+		return this.fixture.bundles.map(cloneSummary);
+	}
+
+	async getGjcBundle(
+		_ctx: GjcLifecycleContext,
+		identity: GjcBundleIdentity,
+	): Promise<GjcLifecycleResult<GjcBundleSummary>> {
+		const summary = this.fixture.bundles.find(
+			bundle =>
+				bundle.identity.kind === identity.kind &&
+				bundle.identity.scope === identity.scope &&
+				bundle.identity.name === identity.name,
+		);
+		return summary
+			? { ok: true, value: cloneSummary(summary) }
+			: { ok: false, error: { code: "not_installed", message: "Bundle is not installed." } };
+	}
+
+	async previewGjcBundleUpdate(
+		_ctx: GjcLifecycleContext,
+		_identity: GjcBundleIdentity,
+	): Promise<GjcLifecycleResult<GjcUpdatePreview>> {
+		return this.fixture.updatePreview
+			? { ok: true, value: this.fixture.updatePreview }
+			: { ok: false, error: { code: "source_unsupported", message: "Update is unavailable." } };
+	}
+
+	async applyGjcBundleUpdate(
+		_ctx: GjcLifecycleContext,
+		_token: GjcUpdatePreview["token"],
+	): Promise<GjcLifecycleResult<GjcUpdateApplyResult>> {
+		return { ok: false, error: { code: "stale_candidate", message: "Capture fixtures do not apply updates." } };
+	}
+
+	async setGjcBundleEnabled(
+		_ctx: GjcLifecycleContext,
+		_identity: GjcBundleIdentity,
+		_enabled: boolean,
+	): Promise<GjcLifecycleResult<GjcToggleResult>> {
+		return { ok: false, error: { code: "invalid_target", message: "Capture fixtures do not mutate bundles." } };
+	}
+
+	async setGjcBundleSurfaceEnabled(
+		_ctx: GjcLifecycleContext,
+		_identity: GjcBundleIdentity,
+		_surfaceId: string,
+		_enabled: boolean,
+	): Promise<GjcLifecycleResult<GjcToggleResult>> {
+		return { ok: false, error: { code: "invalid_target", message: "Capture fixtures do not mutate surfaces." } };
+	}
+}
+
+function fixtureFor(stateId: string): GjcBundleSettingsFixture {
+	const state = GJC_BUNDLE_SETTINGS_STATES.find(candidate => candidate.id === stateId);
+	if (!state) throw new Error(`Unknown GJC Bundle settings state: ${stateId}`);
+	return state.fixture;
+}
+
+function viewportFor(viewportId: string): { id: string; cols: number; rows: number } {
+	const viewport = GJC_BUNDLE_SETTINGS_VIEWPORTS.find(candidate => candidate.id === viewportId);
+	if (viewport) return viewport;
+	if (viewportId === "48x36") return { id: "48x36", cols: 48, rows: 36 };
+	throw new Error(`Unknown GJC Bundle settings viewport: ${viewportId}`);
+}
+
+async function settle(): Promise<void> {
+	for (let index = 0; index < 8; index += 1) await Promise.resolve();
+}
+
+export async function renderGjcBundleSettingsEntry(
+	entry: FixtureEntry,
+): Promise<{ terminalText: string; terminalAnsiText: string; viewport: { id: string; cols: number; rows: number } }> {
+	const fixture = fixtureFor(entry.stateId);
+	const viewport = viewportFor(entry.viewportId);
+	const runtime: GjcRuntimeSnapshotProvider = { current: () => fixture.runtime };
+	await setTheme("red-claw");
+	const component = new GjcBundleSettingsComponent(
+		"/fixture/project",
+		{ onClose: () => {} },
+		{
+			lifecycle: new FixtureLifecyclePort(fixture),
+			runtimeSnapshotProvider: runtime,
+			activationGeneration: 7,
+		},
+	);
+	await settle();
+	const rendered = component.render(viewport.cols).join("\n");
+	component.dispose();
+	const terminalAnsiText = entry.renderMode === "ascii-no-color" ? asciiText(Bun.stripANSI(rendered)) : rendered;
+	const terminalText = Bun.stripANSI(terminalAnsiText);
+	return { terminalText, terminalAnsiText, viewport };
+}
+
+export function gjcBundleSettingsCapturePlan(
+	entries: readonly FixtureEntry[] = GJC_BUNDLE_SETTINGS_ENTRIES,
+): CapturePlanItem[] {
+	return entries.flatMap(entry =>
+		GJC_BUNDLE_SETTINGS_CAPTURE_FILES.map(fileName => ({ entryId: entry.entryId, fileName })),
+	);
+}
+
+function assertSafeContent(label: string, content: string): void {
+	if (FORBIDDEN_CAPTURE_CONTENT.test(content)) throw new Error(`Unsafe locator content in ${label}`);
+}
+
+async function artifactContents(entry: FixtureEntry): Promise<Record<CaptureFileName, string>> {
+	const rendered = await renderGjcBundleSettingsEntry(entry);
+	const terminalHtml = ansiToHtml(rendered.terminalAnsiText);
+	const metadata: CaptureMetadata = {
+		entryId: entry.entryId,
+		stateId: entry.stateId,
+		viewport: rendered.viewport,
+		variant: { renderMode: entry.renderMode },
+		sha256: {
+			"terminal.txt": sha256(rendered.terminalText),
+			"terminal-ansi.txt": sha256(rendered.terminalAnsiText),
+			"terminal.html": sha256(terminalHtml),
+		},
+	};
+	return {
+		"terminal.txt": rendered.terminalText,
+		"terminal-ansi.txt": rendered.terminalAnsiText,
+		"terminal.html": terminalHtml,
+		"metadata.json": json(metadata),
+	};
+}
+
+async function writeEntry(entry: FixtureEntry, outputRoot: string): Promise<void> {
+	const artifacts = await artifactContents(entry);
+	// The HTML artifact is a pure rendering of the ANSI text, so proving the two
+	// text surfaces and the metadata are clean proves the whole entry is clean.
+	for (const name of ["terminal.txt", "terminal-ansi.txt", "metadata.json"] as const) {
+		assertSafeContent(`${entry.entryId}/${name}`, artifacts[name]);
+	}
+	const directory = path.join(outputRoot, entry.entryId);
+	await fs.mkdir(directory, { recursive: true });
+	await Promise.all(
+		GJC_BUNDLE_SETTINGS_CAPTURE_FILES.map(fileName => Bun.write(path.join(directory, fileName), artifacts[fileName])),
+	);
+}
+
+export async function verifyGjcBundleSettingsCapture(outputRoot: string): Promise<void> {
+	for (const entry of GJC_BUNDLE_SETTINGS_ENTRIES) {
+		const directory = path.join(outputRoot, entry.entryId);
+		const names = (await fs.readdir(directory)).sort();
+		if (
+			names.length !== GJC_BUNDLE_SETTINGS_CAPTURE_FILES.length ||
+			names.some((name, index) => name !== GJC_BUNDLE_SETTINGS_CAPTURE_FILES.slice().sort()[index])
+		) {
+			throw new Error(`Expected exactly four capture files for ${entry.entryId}`);
+		}
+		const artifacts = await artifactContents(entry);
+		for (const fileName of GJC_BUNDLE_SETTINGS_CAPTURE_FILES) {
+			const content = await Bun.file(path.join(directory, fileName)).text();
+			assertSafeContent(`${entry.entryId}/${fileName}`, content);
+			if (content !== artifacts[fileName])
+				throw new Error(`Capture does not match deterministic fixture render for ${entry.entryId}/${fileName}`);
+		}
+		const metadata = JSON.parse(artifacts["metadata.json"]) as CaptureMetadata;
+		for (const fileName of ["terminal.txt", "terminal-ansi.txt", "terminal.html"] as const) {
+			if (metadata.sha256[fileName] !== sha256(artifacts[fileName]))
+				throw new Error(`SHA-256 mismatch for ${entry.entryId}/${fileName}`);
+		}
+	}
+}
+
+function parseArgs(args: string[]): { mode: "capture" | "verify"; outputRoot: string } {
+	if (args.length === 2 && args[0] === "--output" && args[1]) return { mode: "capture", outputRoot: args[1] };
+	if (args.length === 2 && args[0] === "--verify" && args[1]) return { mode: "verify", outputRoot: args[1] };
+	throw new Error("Usage: bun scripts/capture-gjc-bundle-settings.ts --output <directory> | --verify <directory>");
+}
+
+async function main(): Promise<void> {
+	const { mode, outputRoot } = parseArgs(process.argv.slice(2));
+	const resolvedOutputRoot = path.resolve(outputRoot);
+	if (mode === "verify") {
+		await verifyGjcBundleSettingsCapture(resolvedOutputRoot);
+		process.stdout.write(
+			`Verified ${GJC_BUNDLE_SETTINGS_ENTRIES.length} deterministic GJC Bundle settings entries.\n`,
+		);
+		return;
+	}
+	for (const entry of GJC_BUNDLE_SETTINGS_ENTRIES) await writeEntry(entry, resolvedOutputRoot);
+	process.stdout.write(`Captured ${GJC_BUNDLE_SETTINGS_ENTRIES.length} deterministic GJC Bundle settings entries.\n`);
+}
+
+if (import.meta.main) await main();

package/scripts/generate-sdk-operation-inventory.ts

@@ -125,6 +125,7 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:getActiveModelProfile": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getSessionDefaultModelSelector": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:recordResumeDefaultModel": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:resolveConfiguredDefaultModel": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:setModelTemporary": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:setModelTemporaryForControl":
 		"internal Telegram control wrapper over the reviewed model.set seam, not an independent public SDK operation",
@@ -150,6 +151,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:runIdleCompaction": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:abortBranchSummary": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:abortHandoff": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:abortPromptAndWait":
+		"internal SDK prompt-terminalization resource fence over a host-captured run handle, not an independent public SDK control seam",
 	"agent_session:prepareContributionPrep": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:setResourceSampler": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:setRetainedMemorySampler": "internal accessor/plumbing, not a user-facing control seam",