@gajae-code/coding-agent 0.13.3 → 0.14.0

package/dist/types/session/auth-broker-config.d.ts

@@ -1,13 +0,0 @@
-export interface AuthBrokerClientConfig {
-    url: string;
-    token: string;
-}
-/** Path to the local bearer token file. Created on the broker host by `gjc auth-broker token`. */
-export declare function getAuthBrokerTokenFilePath(): string;
-/**
- * Read broker configuration. Returns null when the URL is missing
- * (broker disabled — local store is used). Throws when URL is set but no
- * token is available — the caller cannot fall back silently because the
- * user explicitly asked to use the broker.
- */
-export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null>;

package/dist/types/session/heap-eviction-artifacts.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/skills/skills.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/slash-commands/notify-command.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/task/token-log.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/tools/computer.enforcement.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/tools/descriptors.test.d.ts

@@ -1 +0,0 @@
-export {};

package/scripts/g005-daemon-smoke.ts

@@ -1,180 +0,0 @@
-// G005 real end-to-end daemon-orchestration smoke.
-//
-// Drives the lifecycle orchestrator's create -> close path with REAL effects:
-// a real fsynced file-backed idempotency ledger, a real audit JSONL, and a real
-// tmux session spawned/closed via the actual tmux helpers. Proves the daemon
-// orchestration turns a `session_create` frame into a genuinely-spawned,
-// GJC-tagged tmux session and a `session_close` frame into a real hard-close,
-// with idempotent re-ack. Not part of the unit suite.
-import assert from "node:assert";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import {
-	buildGjcTmuxExactOptionTarget,
-	buildGjcTmuxProfileCommands,
-	resolveGjcTmuxCommand,
-} from "../src/gjc-runtime/tmux-common";
-import { forceCloseGjcTmuxSession, statusGjcTmuxSession } from "../src/gjc-runtime/tmux-sessions";
-import type { SessionCloseFrame, SessionCreateFrame } from "../src/sdk/bus/index";
-import {
-	type AuditEvent,
-	handleLifecycleRequest,
-	type LedgerDoc,
-	type LedgerStore,
-	type OrchestratorDeps,
-} from "../src/sdk/bus/lifecycle-orchestrator";
-
-const tmux = resolveGjcTmuxCommand(process.env);
-const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "gjc-g005-"));
-const ledgerPath = path.join(tmpRoot, "idempotency.json");
-const auditPath = path.join(tmpRoot, "audit.jsonl");
-const created: string[] = [];
-
-function sh(args: string[]): number {
-	return Bun.spawnSync([tmux, ...args], { stdout: "pipe", stderr: "pipe" }).exitCode;
-}
-function exists(name: string): boolean {
-	return sh(["has-session", "-t", `=${name}`]) === 0;
-}
-
-// Real fsynced + atomic file ledger store.
-const store: LedgerStore = {
-	async read(): Promise<LedgerDoc> {
-		try {
-			return JSON.parse(fs.readFileSync(ledgerPath, "utf8")) as LedgerDoc;
-		} catch {
-			return { version: 1, entries: {} };
-		}
-	},
-	async write(doc: LedgerDoc): Promise<void> {
-		const tmp = `${ledgerPath}.${process.pid}.tmp`;
-		const fd = fs.openSync(tmp, "w", 0o600);
-		fs.writeSync(fd, JSON.stringify(doc));
-		fs.fsyncSync(fd);
-		fs.closeSync(fd);
-		fs.renameSync(tmp, ledgerPath);
-	},
-};
-
-const auditLines: AuditEvent[] = [];
-const deps: OrchestratorDeps = {
-	pairedChatId: "42",
-	auditRedactionKey: new Uint8Array(32).fill(5),
-	isPsmuxProvider: () => false,
-	now: () => Date.now(),
-	store,
-	audit: e => {
-		auditLines.push(e);
-		fs.appendFileSync(auditPath, `${JSON.stringify(e)}\n`, { mode: 0o600 });
-	},
-	allowCreate: () => true,
-	writeStartupPrompt: async (requestId, prompt) => {
-		if (prompt === undefined) return undefined;
-		const ref = path.join(tmpRoot, `prompt-${requestId}`);
-		const fd = fs.openSync(ref, "w", 0o600);
-		fs.writeSync(fd, prompt);
-		fs.fsyncSync(fd);
-		fs.closeSync(fd);
-		return ref;
-	},
-	// REAL spawn: create a GJC-tagged tmux session carrying the authoritative id.
-	spawnCreate: async (_frame, ids) => {
-		const name = `gjc_g005_${ids.intendedSessionId}`;
-		created.push(name);
-		if (sh(["new-session", "-d", "-s", name, "sleep 600"]) !== 0) {
-			throw new Error(`tmux spawn failed for ${name}`);
-		}
-		const target = buildGjcTmuxExactOptionTarget(name);
-		for (const cmd of buildGjcTmuxProfileCommands(target, process.env, {
-			sessionId: ids.intendedSessionId,
-		})) {
-			if (sh(cmd.args) !== 0) throw new Error(`tag failed for ${name}`);
-		}
-		return {
-			sessionId: ids.intendedSessionId,
-			tmuxSession: name,
-			endpointUrl: "ws://127.0.0.1:0",
-			topicThreadId: "1",
-		};
-	},
-	// REAL close: hard-close the GJC-managed tmux session, id-matched.
-	closeSession: async target => {
-		forceCloseGjcTmuxSession(target.tmuxSession ?? "", process.env, target.sessionId);
-		return { processGone: !exists(target.tmuxSession ?? "") };
-	},
-	resumeSession: async () => ({ ambiguous: [] }),
-};
-
-const createFrame: SessionCreateFrame = {
-	type: "session_create",
-	requestId: "lc_g005",
-	lifecycleRequestId: "lc_g005",
-	intendedSessionId: `g005${Date.now().toString(36)}`,
-	updateId: 100,
-	chatId: "42",
-	token: "control-token",
-	target: { kind: "existing_path", path: tmpRoot },
-};
-
-async function main(): Promise<void> {
-	// 1. CREATE -> real tmux session spawned + GJC-tagged with the authoritative id.
-	const createOut = await handleLifecycleRequest(createFrame, deps);
-	assert.equal(createOut.status, "ok", "create must succeed");
-	const session = createOut.status === "ok" ? createOut.entry.tmuxSession! : "";
-	assert.ok(exists(session), "real tmux session must exist after create");
-	const status = statusGjcTmuxSession(session);
-	assert.equal(status.profile, "1", "spawned session must be GJC-managed");
-	assert.equal(status.sessionId, createFrame.intendedSessionId, "authoritative session id propagated to tmux tag");
-	console.log(`[g005] CREATE -> live tmux session ${session} (id=${status.sessionId})`);
-
-	// 2. Idempotent re-ack: same updateId+body must NOT spawn a second session.
-	const before = created.length;
-	const dupOut = await handleLifecycleRequest(createFrame, deps);
-	assert.equal(dupOut.status, "ok", "duplicate create re-acks ok");
-	assert.equal(created.length, before, "duplicate create must NOT spawn a second session");
-	console.log("[g005] DUPLICATE create re-acked, no second spawn (idempotent)");
-
-	// 3. CLOSE -> real hard-close of the GJC-managed session, id-matched.
-	const closeFrame: SessionCloseFrame = {
-		type: "session_close",
-		requestId: "lc_g005_close",
-		updateId: 101,
-		chatId: "42",
-		token: "control-token",
-		target: { sessionId: createFrame.intendedSessionId, tmuxSession: session },
-		force: true,
-	};
-	const closeOut = await handleLifecycleRequest(closeFrame, deps);
-	assert.equal(closeOut.status, "ok", "close must succeed");
-	assert.ok(!exists(session), "real tmux session must be gone after close");
-	console.log(`[g005] CLOSE -> hard-closed ${session} (id-matched)`);
-
-	// 4. Durable ledger + audit redaction.
-	const doc = JSON.parse(fs.readFileSync(ledgerPath, "utf8")) as LedgerDoc;
-	assert.equal(doc.entries["42:100"]?.state, "success");
-	assert.equal(doc.entries["42:101"]?.state, "success");
-	const auditBlob = fs.readFileSync(auditPath, "utf8");
-	assert.ok(!auditBlob.includes("control-token"), "audit must never contain the control token");
-	assert.ok(
-		auditLines.some(a => a.event === "spawn_started"),
-		"audit records spawn_started",
-	);
-	console.log("[g005] durable fsynced ledger + token-redacted audit verified");
-
-	console.log("[g005] PASS: real create->close daemon orchestration over live tmux");
-}
-
-main()
-	.then(() => {
-		for (const n of created) sh(["kill-session", "-t", `=${n}`]);
-		fs.rmSync(tmpRoot, { recursive: true, force: true });
-		process.exit(0);
-	})
-	.catch(err => {
-		for (const n of created) sh(["kill-session", "-t", `=${n}`]);
-		fs.rmSync(tmpRoot, { recursive: true, force: true });
-		console.error("[g005] FAIL", err);
-		process.exit(1);
-	});

package/scripts/g011-daemon-path-smoke.ts

@@ -1,153 +0,0 @@
-// G011 real daemon-path smoke.
-//
-// Drives a PARSED /session_* command through the LIVE native
-// NotificationControlServer + a real loopback WebSocket client (NO injected/fake
-// seams), wired to the real orchestrator (with stubbed spawn/close effects so the
-// focus is the authenticated wire path, not tmux). Asserts:
-//  - a wrong-token handshake is rejected (control token gates the endpoint);
-//  - a valid frame is forwarded with the control token STRIPPED from payloadJson;
-//  - the host response is routed back to the client by requestId;
-//  - control discovery exists while running and is removed after stop.
-import assert from "node:assert";
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import WebSocket from "ws";
-
-// Import the WORKTREE native build directly (not @gajae-code/natives, which can
-// resolve to a different checkout in this dev environment).
-import { NotificationControlServer } from "../../natives/native/index.js";
-import { parseLifecycleCommand } from "../src/sdk/bus/lifecycle-commands";
-import { attachLifecycleControl, fileAudit, fileLedgerStore } from "../src/sdk/bus/lifecycle-control-runtime";
-import type { OrchestratorDeps } from "../src/sdk/bus/lifecycle-orchestrator";
-
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gjc-g011-"));
-const token = crypto.randomBytes(32).toString("base64url");
-const ownerId = "daemon-g011";
-const closed: string[] = [];
-
-function deps(): OrchestratorDeps {
-	return {
-		pairedChatId: "42",
-		auditRedactionKey: new Uint8Array(32).fill(11),
-		isPsmuxProvider: () => false,
-		now: () => Date.now(),
-		store: fileLedgerStore(path.join(tmp, "idempotency.json")),
-		audit: fileAudit(path.join(tmp, "audit.jsonl")),
-		allowCreate: () => true,
-		writeStartupPrompt: async () => undefined,
-		// Stubbed effects: this smoke proves the WIRE path, not tmux (covered by g005).
-		spawnCreate: async (_f, ids) => ({
-			sessionId: ids.intendedSessionId,
-			tmuxSession: `gjc-${ids.intendedSessionId}`,
-			endpointUrl: "ws://127.0.0.1:0",
-			topicThreadId: "1",
-		}),
-		closeSession: async t => {
-			closed.push(t.sessionId);
-			return { processGone: true };
-		},
-		resumeSession: async () => ({ ambiguous: [] }),
-	};
-}
-
-function send(ws: WebSocket, frame: unknown): void {
-	ws.send(JSON.stringify(frame));
-}
-
-async function main(): Promise<void> {
-	const server = new NotificationControlServer(token, ownerId, tmp);
-
-	// Wire the real orchestrator to the real native control server.
-	const d = deps();
-	attachLifecycleControl(server as never, d);
-
-	const ep = (await server.start()) as { url: string };
-	assert.ok(ep.url.startsWith("ws://127.0.0.1:"), `loopback url, got ${ep.url}`);
-	const controlJson = path.join(tmp, "notifications", "control.json");
-	assert.ok(fs.existsSync(controlJson), "control discovery must exist while running");
-	// The control discovery file MUST NOT persist the privileged control token:
-	// the daemon holds it in memory and is the only client.
-	const controlRaw = fs.readFileSync(controlJson, "utf8");
-	assert.ok(!controlRaw.includes(token), "control token MUST NOT be persisted in control.json");
-	assert.ok(
-		!("token" in (JSON.parse(controlRaw) as Record<string, unknown>)),
-		"control.json must omit any token field",
-	);
-	console.log(`[g011] live control endpoint ${ep.url}; discovery present, no persisted token`);
-
-	// 1. Wrong-token handshake must be rejected.
-	await new Promise<void>(resolve => {
-		const bad = new WebSocket(`${ep.url}/?token=wrong`);
-		bad.on("open", () => {
-			throw new Error("wrong-token handshake must NOT open");
-		});
-		bad.on("error", () => {
-			console.log("[g011] wrong-token handshake rejected (expected)");
-			resolve();
-		});
-	});
-
-	// 2. Valid client: send a PARSED /session_close command through the real wire.
-	const parsed = parseLifecycleCommand("/session_close sess-g011");
-	assert.equal(parsed.kind, "close", "parser must yield a close command");
-	const requestId = "lc-g011-1";
-	const frame = {
-		type: "session_close",
-		requestId,
-		updateId: 1,
-		chatId: "42",
-		token,
-		target: parsed.kind === "close" ? parsed.target : { sessionId: "sess-g011" },
-		force: true,
-	};
-
-	const response = await new Promise<Record<string, unknown>>((resolve, reject) => {
-		const ws = new WebSocket(`${ep.url}/?token=${token}`);
-		const timer = setTimeout(() => reject(new Error("timed out")), 5000);
-		ws.on("open", () => send(ws, frame));
-		ws.on("message", data => {
-			clearTimeout(timer);
-			ws.close();
-			resolve(JSON.parse(String(data)) as Record<string, unknown>);
-		});
-		ws.on("error", reject);
-	});
-
-	assert.equal(response.type, "session_close_response", "response routed back to client");
-	assert.equal(response.requestId, requestId, "response correlated by requestId");
-	assert.equal(response.sessionId, "sess-g011");
-	assert.deepEqual(closed, ["sess-g011"], "orchestrator close effect ran exactly once");
-	console.log("[g011] parsed command -> real wire -> orchestrator -> routed response OK");
-
-	// 3. The real orchestrator path must NOT leak the control token into its
-	// durable audit log or idempotency ledger (g002 separately proves the native
-	// payloadJson boundary is token-stripped).
-	for (const f of ["audit.jsonl", "idempotency.json"]) {
-		const p = path.join(tmp, f);
-		if (fs.existsSync(p)) {
-			assert.ok(!fs.readFileSync(p, "utf8").includes(token), `control token leaked into ${f}`);
-		}
-	}
-	console.log("[g011] no control-token leak in audit/ledger on the real path");
-
-	// 4. Stop removes control discovery.
-	server.stop();
-	await new Promise(r => setTimeout(r, 50));
-	assert.ok(!fs.existsSync(controlJson), "control discovery removed after stop");
-	console.log("[g011] control discovery removed after stop");
-
-	console.log("[g011] PASS: real daemon-path (parse -> native control endpoint -> orchestrator -> reply)");
-}
-
-main()
-	.then(() => {
-		fs.rmSync(tmp, { recursive: true, force: true });
-		process.exit(0);
-	})
-	.catch(err => {
-		fs.rmSync(tmp, { recursive: true, force: true });
-		console.error("[g011] FAIL", err);
-		process.exit(1);
-	});