@gajae-code/coding-agent 0.10.2 → 0.11.1

package/scripts/generate-telegram-baseline-manifest.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+
+import * as path from "node:path";
+import { Glob } from "bun";
+import { type Manifest, validateManifest } from "./manifest-schema";
+
+const repoRoot = path.resolve(import.meta.dir, "..", "..", "..");
+const testDirectory = process.env.GJC_TELEGRAM_BASELINE_TEST_DIR
+	? path.resolve(process.env.GJC_TELEGRAM_BASELINE_TEST_DIR)
+	: path.join(repoRoot, "packages", "coding-agent", "test");
+const manifestPath = process.env.GJC_TELEGRAM_BASELINE_MANIFEST
+	? path.resolve(process.env.GJC_TELEGRAM_BASELINE_MANIFEST)
+	: path.join(testDirectory, "manifests", "telegram-baseline-v1.json");
+const reviewedExclusions: Manifest["excluded"] = [];
+
+const explicitTests = [
+	"daemon-control.test.ts",
+	"telegram-send-tool.test.ts",
+	"telegram-onboarding-docs.test.ts",
+	"lifecycle-notification-docs.test.ts",
+];
+const requiredTests = [
+	"packages/coding-agent/test/daemon-control.test.ts",
+	"packages/coding-agent/test/notifications-chat-adapters.test.ts",
+];
+
+function toRepoPath(relativeTestPath: string): string {
+	return path.posix.join("packages/coding-agent/test", relativeTestPath.split(path.sep).join("/"));
+}
+
+async function discoverTests(): Promise<string[]> {
+	const tests = new Set<string>();
+	for (const pattern of ["notifications-*.test.ts", "telegram-*.test.ts"]) {
+		for await (const relativePath of new Glob(pattern).scan(testDirectory)) {
+			tests.add(toRepoPath(relativePath));
+		}
+	}
+
+	for (const filename of explicitTests) {
+		const filePath = path.join(testDirectory, filename);
+		if (await Bun.file(filePath).exists()) {
+			tests.add(toRepoPath(filename));
+		}
+	}
+
+	return [...tests].sort();
+}
+
+function generateManifest(tests: string[]): Manifest {
+	const excludedFiles = new Set(reviewedExclusions.map(exclusion => exclusion.file));
+	return {
+		version: 1,
+		commands: tests.filter(test => !excludedFiles.has(test)).map(file => ({ argv: ["bun", "test", file] })),
+		excluded: [...reviewedExclusions],
+		required: requiredTests,
+	};
+}
+
+function normalizedManifest(manifest: Manifest): Manifest {
+	return {
+		version: manifest.version,
+		commands: manifest.commands
+			.map(command => ({ argv: [...command.argv] }))
+			.sort((left, right) => left.argv.join("\0").localeCompare(right.argv.join("\0"))),
+		excluded: manifest.excluded
+			.map(exclusion => ({ ...exclusion }))
+			.sort((left, right) => left.file.localeCompare(right.file) || left.reason.localeCompare(right.reason)),
+		required: [...(manifest.required ?? [])].sort(),
+		rows: (manifest.rows ?? [])
+			.map(row => ({ ...row, argv: [...row.argv] }))
+			.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))),
+	};
+}
+
+function describeMismatch(expected: Manifest, actual: Manifest): string {
+	const expectedCommands = new Set(expected.commands.map(command => command.argv.join("\0")));
+	const actualCommands = new Set(actual.commands.map(command => command.argv.join("\0")));
+	const expectedExclusions = new Set(expected.excluded.map(exclusion => `${exclusion.file}\0${exclusion.reason}`));
+	const actualExclusions = new Set(actual.excluded.map(exclusion => `${exclusion.file}\0${exclusion.reason}`));
+	const differences = [
+		...actual.commands
+			.filter(command => !expectedCommands.has(command.argv.join("\0")))
+			.map(command => `- stale command: ${command.argv.join(" ")}`),
+		...expected.commands
+			.filter(command => !actualCommands.has(command.argv.join("\0")))
+			.map(command => `- missing command: ${command.argv.join(" ")}`),
+		...actual.excluded
+			.filter(exclusion => !expectedExclusions.has(`${exclusion.file}\0${exclusion.reason}`))
+			.map(exclusion => `- unapproved exclusion: ${exclusion.file} (${exclusion.reason})`),
+		...expected.excluded
+			.filter(exclusion => !actualExclusions.has(`${exclusion.file}\0${exclusion.reason}`))
+			.map(exclusion => `- missing reviewed exclusion: ${exclusion.file} (${exclusion.reason})`),
+	];
+	return differences.length > 0 ? differences.join("\n") : "- manifest fields differ";
+}
+
+async function checkManifest(expected: Manifest): Promise<void> {
+	let manifest: Manifest;
+	try {
+		manifest = validateManifest(await Bun.file(manifestPath).json());
+	} catch (error) {
+		throw new Error(
+			`Unable to read ${path.relative(repoRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+
+	const normalizedExpected = normalizedManifest(expected);
+	const normalizedManifestFile = normalizedManifest(manifest);
+	if (JSON.stringify(normalizedManifestFile) !== JSON.stringify(normalizedExpected)) {
+		throw new Error(
+			`Telegram baseline manifest does not exactly match the generated baseline:\n${describeMismatch(normalizedExpected, normalizedManifestFile)}`,
+		);
+	}
+}
+
+const tests = await discoverTests();
+const generatedManifest = validateManifest(generateManifest(tests));
+if (process.argv.slice(2).includes("--check")) {
+	try {
+		await checkManifest(generatedManifest);
+	} catch (error) {
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		process.exit(1);
+	}
+} else {
+	await Bun.write(manifestPath, `${JSON.stringify(generatedManifest, null, "\t")}\n`);
+	process.stderr.write(`Generated ${path.relative(repoRoot, manifestPath)} (${tests.length} commands)\n`);
+}

package/scripts/manifest-schema.ts

@@ -0,0 +1,124 @@
+export type ManifestCommand = {
+	argv: string[];
+};
+
+export type ManifestExclusion = {
+	file: string;
+	reason: string;
+};
+
+export type ManifestAdapterRow = {
+	adapterTestId: string;
+	sdkId: string;
+	adapter: "telegram" | "discord" | "slack" | "mcp" | "acp" | "daemonCli";
+	disposition: "native_alias" | "generic_safe" | "machine_only" | "provider_only" | "prohibited";
+	testFile: string;
+	testNamePattern: string;
+	expected: "forwarded" | "rejected_before_send" | "internal_only";
+	argv: string[];
+};
+
+export type Manifest = {
+	version: 1;
+	commands: ManifestCommand[];
+	excluded: ManifestExclusion[];
+	required?: string[];
+	rows?: ManifestAdapterRow[];
+};
+
+export function validateManifest(value: unknown): Manifest {
+	if (typeof value !== "object" || value === null) throw new Error("Manifest must be an object.");
+	if (!("version" in value) || value.version !== 1) {
+		throw new Error(
+			`Manifest version must be 1; received ${"version" in value ? JSON.stringify(value.version) : "missing"}.`,
+		);
+	}
+	if (!("commands" in value) || !Array.isArray(value.commands)) throw new Error("Manifest commands must be an array.");
+	if (!("excluded" in value) || !Array.isArray(value.excluded)) throw new Error("Manifest excluded must be an array.");
+	if ("required" in value && !Array.isArray(value.required)) throw new Error("Manifest required must be an array.");
+	if ("rows" in value && !Array.isArray(value.rows)) throw new Error("Manifest rows must be an array.");
+
+	if (value.commands.length === 0) throw new Error("Manifest must contain at least one command.");
+
+	for (const [index, command] of value.commands.entries()) {
+		if (
+			typeof command !== "object" ||
+			command === null ||
+			!("argv" in command) ||
+			!Array.isArray(command.argv) ||
+			command.argv.length === 0 ||
+			!command.argv.every((argument: unknown) => typeof argument === "string")
+		) {
+			throw new Error(`Manifest command ${index} must contain a non-empty string argv array.`);
+		}
+	}
+
+	for (const [index, exclusion] of value.excluded.entries()) {
+		if (
+			typeof exclusion !== "object" ||
+			exclusion === null ||
+			!("file" in exclusion) ||
+			typeof exclusion.file !== "string" ||
+			exclusion.file.length === 0 ||
+			!("reason" in exclusion) ||
+			typeof exclusion.reason !== "string" ||
+			exclusion.reason.trim().length === 0
+		) {
+			throw new Error(`Manifest excluded entry ${index} must contain non-empty string file and reason fields.`);
+		}
+	}
+
+	const required: unknown[] = "required" in value && Array.isArray(value.required) ? value.required : [];
+	for (const [index, file] of required.entries()) {
+		if (typeof file !== "string" || file.length === 0) {
+			throw new Error(`Manifest required entry ${index} must be a non-empty string.`);
+		}
+	}
+
+	const rows: unknown[] = "rows" in value && Array.isArray(value.rows) ? value.rows : [];
+	const adapters = new Set(["telegram", "discord", "slack", "mcp", "acp", "daemonCli"]);
+	const dispositions = new Set(["native_alias", "generic_safe", "machine_only", "provider_only", "prohibited"]);
+	const expected = new Set(["forwarded", "rejected_before_send", "internal_only"]);
+	for (const [index, row] of rows.entries()) {
+		if (
+			typeof row !== "object" ||
+			row === null ||
+			!("adapterTestId" in row) ||
+			typeof row.adapterTestId !== "string" ||
+			!row.adapterTestId ||
+			!("sdkId" in row) ||
+			typeof row.sdkId !== "string" ||
+			!row.sdkId ||
+			!("adapter" in row) ||
+			typeof row.adapter !== "string" ||
+			!adapters.has(row.adapter) ||
+			!("disposition" in row) ||
+			typeof row.disposition !== "string" ||
+			!dispositions.has(row.disposition) ||
+			!("testFile" in row) ||
+			typeof row.testFile !== "string" ||
+			!row.testFile ||
+			!("testNamePattern" in row) ||
+			typeof row.testNamePattern !== "string" ||
+			!row.testNamePattern.trim() ||
+			!("argv" in row) ||
+			!Array.isArray(row.argv) ||
+			!row.argv.every(argument => typeof argument === "string") ||
+			!("expected" in row) ||
+			typeof row.expected !== "string" ||
+			!expected.has(row.expected)
+		)
+			throw new Error(`Manifest row ${index} must contain valid adapter coverage fields.`);
+		if (
+			row.argv.length !== 5 ||
+			row.argv[0] !== "bun" ||
+			row.argv[1] !== "test" ||
+			row.argv[2] !== row.testFile ||
+			row.argv[3] !== "--test-name-pattern" ||
+			row.argv[4].trim().length === 0
+		)
+			throw new Error(`Manifest row ${index} must contain an exact bun test receipt argv.`);
+	}
+
+	return value as Manifest;
+}

package/scripts/run-test-manifest.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+
+import * as path from "node:path";
+import { CHAT_OPERATION_POLICY } from "../src/sdk/bus/chat-command-policy";
+import { ADAPTERS, OPERATIONS } from "../src/sdk/protocol/operation-registry";
+import { type Manifest, type ManifestAdapterRow, validateManifest } from "./manifest-schema";
+
+const repoRoot = path.resolve(import.meta.dir, "..", "..", "..");
+
+function usage(): never {
+	process.stderr.write(
+		"Usage: bun run packages/coding-agent/scripts/run-test-manifest.ts <manifest.json> [--check]\n",
+	);
+	process.exit(2);
+}
+
+function testCount(output: string): number | undefined {
+	const ran = output.match(/Ran\s+(\d+)\s+tests?\s+across\b/);
+	if (ran) return Number(ran[1]);
+	const summary = output.match(/^(\d+) pass(?:\s*,?\s*\d+ fail)?$/m);
+	return summary ? Number(summary[1]) : undefined;
+}
+
+const [manifestArgument, ...flags] = process.argv.slice(2);
+if (manifestArgument === undefined || flags.some(flag => flag !== "--check")) usage();
+const checkOnly = flags.includes("--check");
+const manifestPath = path.resolve(manifestArgument);
+let manifest: Manifest;
+try {
+	manifest = validateManifest(await Bun.file(manifestPath).json());
+} catch (error) {
+	process.stderr.write(`Unable to read ${manifestPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(2);
+}
+
+function validateRowReceipts(rows: ManifestAdapterRow[]): void {
+	const ids = new Set<string>();
+	const counts = new Map<string, number>();
+	for (const row of rows) {
+		if (ids.has(row.adapterTestId)) throw new Error(`Duplicate adapter test ID: ${row.adapterTestId}`);
+		ids.add(row.adapterTestId);
+		if (/placeholder|todo|tbd|example/i.test(row.testNamePattern))
+			throw new Error(`${row.adapterTestId} has a placeholder test pattern.`);
+		if (row.argv[4] === undefined || !row.argv[4].includes(row.adapterTestId))
+			throw new Error(`${row.adapterTestId} receipt does not select its exact test.`);
+
+		const [, , operationId] = row.adapterTestId.split("-");
+		const operation = OPERATIONS.find(candidate => candidate.id === operationId && candidate.sdkId === row.sdkId);
+		if (!operation) throw new Error(`${row.adapterTestId} does not identify a registry operation.`);
+		if (row.disposition !== operation.adapterDispositions[row.adapter])
+			throw new Error(`${row.adapterTestId} disposition diverges from the operation registry.`);
+		if (row.adapter === "telegram" || row.adapter === "discord" || row.adapter === "slack") {
+			const policyExpected = row.adapterTestId.endsWith("-secret")
+				? "rejected_before_send"
+				: CHAT_OPERATION_POLICY[row.adapter][operation.id] === "allowed"
+					? "forwarded"
+					: "rejected_before_send";
+			if (row.expected !== policyExpected)
+				throw new Error(`${row.adapterTestId} expected outcome diverges from chat command policy.`);
+		}
+		counts.set(row.adapter, (counts.get(row.adapter) ?? 0) + 1);
+	}
+	if (rows.length !== ADAPTERS.length * 91)
+		throw new Error(`Expected ${ADAPTERS.length * 91} adapter rows; received ${rows.length}.`);
+	for (const adapter of ADAPTERS) {
+		if (counts.get(adapter) !== 91)
+			throw new Error(`Expected 91 ${adapter} rows; received ${counts.get(adapter) ?? 0}.`);
+	}
+	process.stdout.write(
+		`manifest check: ${rows.length} row receipts (${[...counts].map(([adapter, count]) => `${adapter}=${count}`).join(", ")})\n`,
+	);
+}
+
+// Required files must be either exact `bun test <file>` commands or fail-closed
+// anchored partitions that collectively match every declared row for that file.
+const rows = manifest.rows ?? [];
+const exactExecutableFiles = new Set(
+	manifest.commands
+		.filter(command => command.argv.length === 3 && command.argv[0] === "bun" && command.argv[1] === "test")
+		.map(command => command.argv[2]),
+);
+for (const file of manifest.required ?? []) {
+	if (exactExecutableFiles.has(file)) continue;
+	const fileRows = rows.filter(row => row.testFile === file);
+	const partitions = manifest.commands
+		.filter(
+			command =>
+				command.argv.length === 5 &&
+				command.argv[0] === "bun" &&
+				command.argv[1] === "test" &&
+				command.argv[2] === file &&
+				command.argv[3] === "--test-name-pattern" &&
+				command.argv[4]?.startsWith("^"),
+		)
+		.map(command => new RegExp(command.argv[4]!));
+	if (
+		fileRows.length === 0 ||
+		partitions.length === 0 ||
+		fileRows.some(row => !partitions.some(pattern => pattern.test(row.testNamePattern)))
+	) {
+		process.stderr.write(`Manifest required file is not covered by executable commands: ${file}\n`);
+		process.exit(1);
+	}
+}
+if (rows.length > 0) {
+	try {
+		validateRowReceipts(rows);
+	} catch (error) {
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		process.exit(1);
+	}
+}
+if (checkOnly) process.exit(0);
+
+const startedAt = performance.now();
+let commandReceipts = 0;
+let rowReceipts = 0;
+const perAdapter = new Map<string, number>();
+
+async function executeReceipt(argv: string[]): Promise<void> {
+	const child = Bun.spawn(argv, { cwd: repoRoot, stdout: "pipe", stderr: "pipe" });
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+		child.exited,
+	]);
+	process.stdout.write(stdout);
+	process.stderr.write(stderr);
+	const tests = testCount(`${stdout}\n${stderr}`);
+	process.stdout.write(`receipt: ${argv.join(" ")} exit=${exitCode} tests=${tests ?? "unknown"}\n`);
+	if (exitCode === 0 && tests !== undefined && tests >= 1) return;
+	const reason = exitCode !== 0 ? `exit ${exitCode}` : "did not report at least one test";
+	process.stderr.write(`Manifest receipt failed: ${argv.join(" ")} (${reason})\n`);
+	process.exit(1);
+}
+
+for (const command of manifest.commands) {
+	await executeReceipt(command.argv);
+	commandReceipts++;
+}
+process.stdout.write(`manifest command receipts complete: ${commandReceipts}\n`);
+
+for (const row of rows) {
+	await executeReceipt(row.argv);
+	rowReceipts++;
+	perAdapter.set(row.adapter, (perAdapter.get(row.adapter) ?? 0) + 1);
+}
+if (rows.length > 0) {
+	process.stdout.write(
+		`manifest row receipts complete: ${rowReceipts} (${[...perAdapter].map(([adapter, count]) => `${adapter}=${count}`).join(", ")})\n`,
+	);
+}
+process.stdout.write(`manifest receipts runtime=${Math.round(performance.now() - startedAt)}ms\n`);

package/scripts/run-threat-model-check.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { NotificationServer } from "../../natives/native/index.js";
+import { Broker } from "../src/sdk/broker/broker";
+import { brokerDiscoveryPath } from "../src/sdk/broker/discovery";
+import { brokerIdentityPath, getBrokerIdentityKey } from "../src/sdk/broker/identity";
+
+type Check = { id: string; description: string; kind: "assertion" | "negative-test"; command?: string };
+type Manifest = { version: 1; checks: Check[] };
+
+function assert(condition: unknown, message: string): asserts condition {
+	if (!condition) throw new Error(message);
+}
+
+async function rejectedWebSocket(url: string): Promise<void> {
+	const ws = new WebSocket(url);
+	await new Promise<void>((resolve, reject) => {
+		const timeout = setTimeout(() => reject(new Error("unauthorized WebSocket was not rejected")), 2_000);
+		ws.addEventListener(
+			"close",
+			() => {
+				clearTimeout(timeout);
+				resolve();
+			},
+			{ once: true },
+		);
+		ws.addEventListener(
+			"open",
+			() => {
+				clearTimeout(timeout);
+				ws.close();
+				reject(new Error("unauthorized WebSocket connected"));
+			},
+			{ once: true },
+		);
+		ws.addEventListener(
+			"error",
+			() => {
+				clearTimeout(timeout);
+				resolve();
+			},
+			{ once: true },
+		);
+	});
+}
+
+async function mode(file: string): Promise<number> {
+	return (await fs.stat(file)).mode & 0o777;
+}
+
+async function main(): Promise<void> {
+	const manifestPath = process.argv[2];
+	if (!manifestPath) throw new Error("Usage: bun scripts/run-threat-model-check.ts <manifest.json>");
+	const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8")) as Manifest;
+	assert(manifest.version === 1 && Array.isArray(manifest.checks), "Invalid threat-model manifest");
+	const ids = new Set<string>();
+	for (const check of manifest.checks) {
+		assert(
+			typeof check.id === "string" && check.id.length > 0 && !ids.has(check.id),
+			"Invalid or duplicate check id",
+		);
+		assert(
+			typeof check.description === "string" && (check.kind === "assertion" || check.kind === "negative-test"),
+			`Invalid check ${check.id}`,
+		);
+		ids.add(check.id);
+	}
+
+	const agentDir = await fs.mkdtemp(path.join(process.env.TMPDIR ?? "/tmp", "gjc-broker-threat-model-"));
+	const broker = new Broker({ agentDir, packageGeneration: "threat-model" });
+	const failures: string[] = [];
+	try {
+		const discovery = await broker.start();
+		await getBrokerIdentityKey(agentDir);
+		const statusOutput = JSON.stringify(broker.status());
+		const checks: Record<string, () => Promise<void>> = {
+			"broker-token-agent-global-blast-radius": async () => {
+				assert(discovery.token.length === 64, "broker token is not a 256-bit value");
+			},
+			"broker-discovery-file-permissions": async () => {
+				if (process.platform !== "win32") {
+					assert((await mode(brokerDiscoveryPath(agentDir))) === 0o600, "broker.json is not mode 0600");
+					assert((await mode(path.join(agentDir, "sdk"))) === 0o700, "sdk directory is not mode 0700");
+				}
+			},
+			"broker-identity-file-permissions": async () => {
+				if (process.platform !== "win32")
+					assert((await mode(brokerIdentityPath(agentDir))) === 0o600, "broker.identity is not mode 0600");
+			},
+			"broker-loopback-only": async () => {
+				assert(discovery.host === "127.0.0.1", "broker advertised a non-loopback host");
+				assert(discovery.url === `ws://127.0.0.1:${discovery.port}`, "broker advertised a non-loopback URL");
+			},
+			"broker-token-rotation-on-stale-takeover": async () => {
+				const takeoverDir = await fs.mkdtemp(path.join(process.env.TMPDIR ?? "/tmp", "gjc-broker-takeover-"));
+				const first = new Broker({ agentDir: takeoverDir, packageGeneration: "threat-model" });
+				try {
+					const previous = await first.start();
+					await first.stop();
+					const replacement = new Broker({ agentDir: takeoverDir, packageGeneration: "threat-model" });
+					try {
+						const next = await replacement.start();
+						assert(next.token !== previous.token, "broker token did not rotate on takeover");
+					} finally {
+						await replacement.stop();
+					}
+				} finally {
+					await first.stop();
+					await fs.rm(takeoverDir, { recursive: true, force: true });
+				}
+			},
+			"broker-per-session-token-separation": async () => {
+				const sessionRoot = await fs.mkdtemp(path.join(process.env.TMPDIR ?? "/tmp", "gjc-broker-session-token-"));
+				const sessionToken = "session-token-that-must-not-authorize-broker";
+				const sessionServer = new NotificationServer("threat-model", sessionToken, sessionRoot, true);
+				try {
+					const endpoint = await sessionServer.start();
+					assert(endpoint.url.startsWith("ws://127.0.0.1:"), "per-session endpoint did not start on loopback");
+					await rejectedWebSocket(`${discovery.url}/?token=${encodeURIComponent(sessionToken)}`);
+				} finally {
+					sessionServer.stop();
+					await fs.rm(sessionRoot, { recursive: true, force: true });
+				}
+			},
+			"broker-status-token-redaction": async () => {
+				assert(!statusOutput.includes(discovery.token), "broker token appeared in production status output");
+				assert(statusOutput.includes("[redacted]"), "production status output did not redact broker token");
+			},
+			"broker-non-loopback-negative-test": async () => {
+				assert(!discovery.url.includes("0.0.0.0"), "non-loopback broker URL exists");
+				await rejectedWebSocket(`${discovery.url}/?token=wrong-token`);
+			},
+		};
+		for (const check of manifest.checks) {
+			try {
+				const run = checks[check.id];
+				assert(run, `No implementation for check ${check.id}`);
+				await run();
+				console.log(`PASS ${check.id}`);
+			} catch (error) {
+				failures.push(check.id);
+				console.error(`FAIL ${check.id}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	} finally {
+		await broker.stop();
+		await fs.rm(agentDir, { recursive: true, force: true });
+	}
+	if (failures.length) {
+		process.stderr.write(`Failed threat-model checks: ${failures.join(", ")}\n`);
+		process.exitCode = 1;
+	}
+}
+
+await main();