@xopcai/xopc 0.0.244 → 0.0.246

package/dist/src/agent/coding/workspace-revision.js

@@ -0,0 +1,77 @@
+import { isAbsolute, relative, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, readFile, readlink, realpath } from "node:fs/promises";
+import { promisify } from "node:util";
+//#region src/agent/coding/workspace-revision.ts
+const exec$1 = promisify(execFile);
+/** A content fingerprint, including user changes and untracked files, without changing Git state. */
+async function readWorkspaceRevision(workspace) {
+	let cwd = workspace;
+	const git = async (args) => (await exec$1("git", [
+		"-c",
+		"core.fsmonitor=false",
+		...args
+	], {
+		cwd,
+		timeout: 1e4,
+		maxBuffer: 16 * 1024 * 1024,
+		env: {
+			...process.env,
+			GIT_OPTIONAL_LOCKS: "0"
+		}
+	})).stdout;
+	try {
+		cwd = await realpath(workspace);
+		cwd = await realpath((await git(["rev-parse", "--show-toplevel"])).trim());
+		const head = await git([
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		]).catch(() => "unborn");
+		const [diff, untracked] = await Promise.all([head === "unborn" ? Promise.all([git([
+			"diff",
+			"--no-ext-diff",
+			"--no-textconv",
+			"--binary",
+			"--cached",
+			"--"
+		]), git([
+			"diff",
+			"--no-ext-diff",
+			"--no-textconv",
+			"--binary",
+			"--"
+		])]).then((parts) => parts.join("\0")) : git([
+			"diff",
+			"--no-ext-diff",
+			"--no-textconv",
+			"--binary",
+			"HEAD",
+			"--"
+		]), git([
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"-z"
+		])]);
+		const hash = createHash("sha256").update(head).update(diff);
+		for (const file of untracked.split("\0").filter(Boolean).sort()) {
+			const path = resolve(cwd, file);
+			const rel = relative(cwd, path);
+			if (isAbsolute(rel) || rel === ".." || rel.startsWith("../")) return void 0;
+			const stat = await lstat(path);
+			if (stat.isSymbolicLink()) {
+				hash.update(file).update("\0link\0").update(await readlink(path)).update("\0");
+				continue;
+			}
+			if (!stat.isFile() || stat.size > 16 * 1024 * 1024) return void 0;
+			hash.update(JSON.stringify([file, stat.mode])).update("\0").update(await readFile(path)).update("\0");
+		}
+		return hash.digest("hex");
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { readWorkspaceRevision };

package/dist/src/agent/commands/command-isolation.d.ts

@@ -0,0 +1,21 @@
+export type CommandIsolation = {
+    mode: 'host';
+} | {
+    mode: 'docker';
+    image: string;
+    network?: boolean;
+};
+/** Docker is opt-in and never falls back to host execution or pulls an image implicitly. */
+export declare function isolatedCommand(input: {
+    id: string;
+    command: string;
+    cwd: string;
+    workspace: string;
+    isolation?: CommandIsolation;
+}): Promise<{
+    executable: string;
+    args: string[];
+    shell: boolean;
+    containerName?: string;
+}>;
+export declare function removeCommandContainer(name: string): Promise<void>;

package/dist/src/agent/commands/command-isolation.js

@@ -0,0 +1,71 @@
+import { isAbsolute, relative, sep } from "node:path";
+import { execFile } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { promisify } from "node:util";
+//#region src/agent/commands/command-isolation.ts
+const exec$1 = promisify(execFile);
+/** Docker is opt-in and never falls back to host execution or pulls an image implicitly. */
+async function isolatedCommand(input) {
+	if (!input.isolation || input.isolation.mode === "host") return {
+		executable: input.command,
+		args: [],
+		shell: true
+	};
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9./:_-]*@sha256:[a-f0-9]{64}$/.test(input.isolation.image)) throw new Error("Docker command isolation requires an image pinned by sha256 digest.");
+	const [workspace, cwd] = await Promise.all([realpath(input.workspace), realpath(input.cwd)]);
+	const rel = relative(workspace, cwd);
+	if (isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) throw new Error("Container cwd must be inside the workspace.");
+	if (workspace.includes(",")) throw new Error("Container workspace paths cannot contain commas.");
+	const containerName = `xopc-command-${input.id}`;
+	return {
+		executable: "docker",
+		shell: false,
+		containerName,
+		args: [
+			"run",
+			"--rm",
+			"--pull=never",
+			"--name",
+			containerName,
+			"--interactive",
+			"--init",
+			"--read-only",
+			"--cap-drop=ALL",
+			"--security-opt=no-new-privileges",
+			"--pids-limit=256",
+			"--memory=2g",
+			"--cpus=2",
+			"--network",
+			input.isolation.network ? "bridge" : "none",
+			"--user",
+			`${process.getuid?.() || 65534}:${process.getgid?.() || 65534}`,
+			"--mount",
+			`type=bind,source=${workspace},target=/workspace`,
+			"--tmpfs",
+			"/tmp:rw,nosuid,nodev,size=256m",
+			"--env",
+			"HOME=/tmp",
+			"--env",
+			"CI=true",
+			"--workdir",
+			`/workspace${rel ? `/${rel.split(sep).join("/")}` : ""}`,
+			"--entrypoint",
+			"/bin/sh",
+			input.isolation.image,
+			"-lc",
+			input.command
+		]
+	};
+}
+async function removeCommandContainer(name) {
+	if (!/^xopc-command-[a-f0-9-]{36}$/.test(name)) throw new Error("Invalid command container name");
+	await exec$1("docker", [
+		"rm",
+		"--force",
+		name
+	], { timeout: 1e4 }).catch((error) => {
+		if (!String(error.stderr).includes("No such container")) throw error;
+	});
+}
+//#endregion
+export { isolatedCommand, removeCommandContainer };

package/dist/src/agent/commands/command-registry.d.ts

@@ -0,0 +1,56 @@
+import { type CommandIsolation } from './command-isolation.js';
+export declare const DEFAULT_COMMAND_TIMEOUT_MS: number;
+export declare const MAX_COMMAND_TIMEOUT_MS: number;
+export type CommandStatus = 'running' | 'success' | 'failed' | 'cancelled' | 'timed_out' | 'interrupted';
+export interface CommandResult {
+    id: string;
+    command: string;
+    cwd: string;
+    status: CommandStatus;
+    exitCode: number | null;
+    createdAtMs: number;
+    durationMs: number;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    aggregatedOutput: string;
+    totalOutputBytes: number;
+    captureTruncated: boolean;
+    logPath: string;
+    logTruncated: boolean;
+    startRevision?: string;
+    endRevision?: string;
+    isolation?: 'host' | 'docker';
+    containerName?: string;
+}
+export declare function commandTimeout(raw: unknown, ceiling?: number): number;
+/** Foreground and background tools share ownership, cancellation, output and durable receipts. */
+export declare class CommandRegistry {
+    private readonly root;
+    private readonly prunedAt;
+    private readonly running;
+    constructor(root?: string);
+    private directory;
+    private persist;
+    start(input: {
+        owner: string;
+        command: string;
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+        timeoutMs: number;
+        workspace?: string;
+        isolation?: CommandIsolation;
+        maxOutputChars?: number;
+        signal?: AbortSignal;
+        snapshot?: boolean;
+        onOutput?: (stream: 'stdout' | 'stderr', delta: string) => void;
+    }): Promise<CommandResult>;
+    get(owner: string, id: string): CommandResult | undefined;
+    wait(owner: string, id: string, waitMs?: number, signal?: AbortSignal): Promise<CommandResult | undefined>;
+    cancel(owner: string, id: string): Promise<CommandResult | undefined>;
+    write(owner: string, id: string, chars: string, end?: boolean): boolean;
+    shutdown(): void;
+    private prune;
+    list(owner: string): CommandResult[];
+}
+export declare function commandRegistry(): CommandRegistry;

package/dist/src/agent/commands/command-registry.js

@@ -0,0 +1,259 @@
+import { resolveStateDir } from "../../config/paths-state.js";
+import { resolveGlobalSingleton } from "../../utils/global-singleton.js";
+import { init_paths } from "../../config/paths.js";
+import { isolatedCommand, removeCommandContainer } from "./command-isolation.js";
+import { readWorkspaceRevision } from "../coding/workspace-revision.js";
+import { join } from "node:path";
+import { appendFileSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/agent/commands/command-registry.ts
+init_paths();
+const DEFAULT_COMMAND_TIMEOUT_MS = 30 * 6e4;
+const MAX_COMMAND_TIMEOUT_MS = 240 * 6e4;
+const MAX_LOG_BYTES = 8 * 1024 * 1024;
+function commandTimeout(raw, ceiling = MAX_COMMAND_TIMEOUT_MS) {
+	return Math.min(ceiling, Math.max(1, typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : DEFAULT_COMMAND_TIMEOUT_MS));
+}
+function killTree(child) {
+	if (!child.pid) return;
+	if (process.platform === "win32") {
+		const killer = spawn("taskkill", [
+			"/pid",
+			String(child.pid),
+			"/t",
+			"/f"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		killer.on("error", () => child.kill("SIGKILL"));
+		killer.unref();
+	} else try {
+		process.kill(-child.pid, "SIGKILL");
+	} catch {
+		child.kill("SIGKILL");
+	}
+}
+/** Foreground and background tools share ownership, cancellation, output and durable receipts. */
+var CommandRegistry = class {
+	prunedAt = /* @__PURE__ */ new Map();
+	running = /* @__PURE__ */ new Map();
+	constructor(root = join(resolveStateDir(), "command-runs")) {
+		this.root = root;
+	}
+	directory(owner) {
+		return join(this.root, createHash("sha256").update(owner).digest("hex"));
+	}
+	persist(owner, result) {
+		const file = join(this.directory(owner), `${result.id}.json`);
+		writeFileSync(`${file}.tmp`, JSON.stringify(result), { mode: 384 });
+		renameSync(`${file}.tmp`, file);
+	}
+	async start(input) {
+		input.signal?.throwIfAborted();
+		if (this.running.size >= 64) throw new Error("Command capacity reached; wait for or cancel an existing job.");
+		const directory = this.directory(input.owner);
+		mkdirSync(directory, {
+			recursive: true,
+			mode: 448
+		});
+		this.prune(input.owner);
+		const id = randomUUID();
+		const startRevision = input.snapshot ? await readWorkspaceRevision(input.cwd) : void 0;
+		input.signal?.throwIfAborted();
+		const launch = await isolatedCommand({
+			id,
+			command: input.command,
+			cwd: input.cwd,
+			workspace: input.workspace ?? input.cwd,
+			isolation: input.isolation
+		});
+		const result = {
+			isolation: input.isolation?.mode ?? "host",
+			...launch.containerName ? { containerName: launch.containerName } : {},
+			id,
+			command: input.command,
+			cwd: input.cwd,
+			status: "running",
+			exitCode: null,
+			createdAtMs: Date.now(),
+			durationMs: 0,
+			timedOut: false,
+			stdout: "",
+			stderr: "",
+			aggregatedOutput: "",
+			totalOutputBytes: 0,
+			captureTruncated: false,
+			logPath: join(directory, `${id}.log`),
+			logTruncated: false,
+			...startRevision ? { startRevision } : {}
+		};
+		writeFileSync(result.logPath, "", {
+			mode: 384,
+			flag: "wx"
+		});
+		this.persist(input.owner, result);
+		const child = spawn(launch.executable, launch.args, {
+			shell: launch.shell,
+			cwd: input.cwd,
+			env: input.env,
+			detached: process.platform !== "win32"
+		});
+		const limit = input.maxOutputChars ?? 5e4;
+		let logBytes = 0;
+		let closed = false;
+		let containerCleanup;
+		const append = (stream, chunk) => {
+			const value = String(chunk);
+			result.totalOutputBytes += Buffer.byteLength(value);
+			result.captureTruncated ||= result[stream].length + value.length > limit || result.aggregatedOutput.length + value.length > limit;
+			result[stream] = (result[stream] + value).slice(-limit);
+			result.aggregatedOutput = (result.aggregatedOutput + value).slice(-limit);
+			const bytes = Buffer.from(value), remaining = Math.max(0, MAX_LOG_BYTES - logBytes);
+			if (remaining > 0) try {
+				appendFileSync(result.logPath, bytes.subarray(0, remaining));
+			} catch {
+				result.logTruncated = true;
+			}
+			logBytes += Math.min(bytes.length, remaining);
+			result.logTruncated ||= bytes.length > remaining;
+			input.onOutput?.(stream, value.length > 16e3 ? `${value.slice(0, 16e3)}\n[stream delta truncated]` : value);
+		};
+		const stop = (status) => {
+			if (result.status !== "running" || closed) return;
+			result.status = status;
+			result.timedOut = status === "timed_out";
+			if (launch.containerName) containerCleanup = removeCommandContainer(launch.containerName).catch((error) => {
+				result.status = "interrupted";
+				append("stderr", `Container cleanup failed: ${String(error)}`);
+			});
+			killTree(child);
+		};
+		const timer = setTimeout(() => stop("timed_out"), commandTimeout(input.timeoutMs));
+		timer.unref();
+		const abort = () => stop("cancelled");
+		input.signal?.addEventListener("abort", abort, { once: true });
+		const done = new Promise((resolve) => {
+			child.stdout?.on("data", (value) => append("stdout", value));
+			child.stderr?.on("data", (value) => append("stderr", value));
+			child.on("error", (error) => append("stderr", error.message));
+			child.stdin?.on("error", (error) => append("stderr", error.message));
+			child.on("close", async (exitCode) => {
+				closed = true;
+				clearTimeout(timer);
+				input.signal?.removeEventListener("abort", abort);
+				if (containerCleanup) await containerCleanup;
+				if (input.snapshot) result.endRevision = await readWorkspaceRevision(input.cwd);
+				if (result.status === "running") result.status = exitCode === 0 ? "success" : "failed";
+				result.exitCode = exitCode;
+				result.durationMs = Date.now() - result.createdAtMs;
+				try {
+					this.persist(input.owner, result);
+				} catch {
+					result.logTruncated = true;
+				}
+				this.running.delete(id);
+				resolve({ ...result });
+			});
+		});
+		this.running.set(id, {
+			owner: input.owner,
+			result,
+			process: child,
+			done,
+			stop
+		});
+		if (input.signal?.aborted) abort();
+		return { ...result };
+	}
+	get(owner, id) {
+		if (!/^[\da-f-]{36}$/.test(id)) return void 0;
+		const current = this.running.get(id);
+		if (current) return current.owner === owner ? {
+			...current.result,
+			durationMs: Date.now() - current.result.createdAtMs
+		} : void 0;
+		try {
+			const result = JSON.parse(readFileSync(join(this.directory(owner), `${id}.json`), "utf8"));
+			if (result.status === "running") {
+				result.status = "interrupted";
+				result.stderr += "\nRuntime ownership was lost. Process/container state is unknown; inspect before restarting.";
+				this.persist(owner, result);
+			}
+			return result;
+		} catch {
+			return;
+		}
+	}
+	async wait(owner, id, waitMs = 3e4, signal) {
+		const current = this.running.get(id);
+		if (!current || current.owner !== owner) return this.get(owner, id);
+		signal?.throwIfAborted();
+		let timer;
+		let aborted;
+		try {
+			return await Promise.race([current.done, new Promise((resolve, reject) => {
+				timer = setTimeout(() => resolve(this.get(owner, id)), Math.min(6e4, Math.max(0, waitMs)));
+				aborted = () => reject(signal?.reason ?? /* @__PURE__ */ new Error("Aborted"));
+				signal?.addEventListener("abort", aborted, { once: true });
+			})]);
+		} finally {
+			clearTimeout(timer);
+			if (aborted) signal?.removeEventListener("abort", aborted);
+		}
+	}
+	async cancel(owner, id) {
+		const current = this.running.get(id);
+		if (current?.owner === owner) {
+			current.stop("cancelled");
+			return current.done;
+		}
+		return this.get(owner, id);
+	}
+	write(owner, id, chars, end = false) {
+		const current = this.running.get(id);
+		if (!current || current.owner !== owner || current.result.status !== "running" || !current.process.stdin?.writable) return false;
+		if (end) current.process.stdin.end(chars);
+		else current.process.stdin.write(chars);
+		return true;
+	}
+	shutdown() {
+		for (const command of this.running.values()) command.stop("cancelled");
+	}
+	prune(owner) {
+		if (Date.now() - (this.prunedAt.get(owner) ?? 0) < 6e4) return;
+		this.prunedAt.set(owner, Date.now());
+		const directory = this.directory(owner);
+		const completed = readdirSync(directory).filter((file) => file.endsWith(".json")).flatMap((file) => {
+			try {
+				const job = JSON.parse(readFileSync(join(directory, file), "utf8"));
+				return this.running.has(job.id) || job.status === "running" ? [] : [job];
+			} catch {
+				return [];
+			}
+		}).sort((a, b) => b.createdAtMs - a.createdAtMs);
+		for (const [index, job] of completed.entries()) {
+			if (index < 500 && Date.now() - job.createdAtMs < 10080 * 6e4) continue;
+			if (!/^[\da-f-]{36}$/.test(job.id)) continue;
+			rmSync(join(directory, `${job.id}.json`), { force: true });
+			rmSync(join(directory, `${job.id}.log`), { force: true });
+		}
+	}
+	list(owner) {
+		try {
+			return readdirSync(this.directory(owner)).filter((file) => file.endsWith(".json")).map((file) => this.get(owner, file.slice(0, -5))).filter((job) => !!job).sort((a, b) => b.createdAtMs - a.createdAtMs).slice(0, 50);
+		} catch {
+			return [];
+		}
+	}
+};
+function commandRegistry() {
+	return resolveGlobalSingleton(Symbol.for("xopc.commandRegistry"), () => {
+		const registry = new CommandRegistry();
+		process.once("exit", () => registry.shutdown());
+		return registry;
+	});
+}
+//#endregion
+export { CommandRegistry, DEFAULT_COMMAND_TIMEOUT_MS, MAX_COMMAND_TIMEOUT_MS, commandRegistry, commandTimeout };

package/dist/src/agent/embedded/index.js

@@ -1,7 +1,7 @@
+import { abortEmbeddedRun, getEmbeddedRunBySessionKey, queueEmbeddedSteer } from "./runs.js";
 import { DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, resolveLiveToolResultMaxChars, truncateToolResultMessage } from "./tool-result-truncation.js";
 import { getRawSessionAppendMessage, guardSessionManager, installSessionToolResultGuard } from "./session-tool-result-guard.js";
 import { acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner, getEmbeddedSessionRunnerIdleTtlMs, getEmbeddedSessionRunnerStats, isEmbeddedSessionRunnerEnabled, resetEmbeddedSessionRunnerForTest } from "./session-runner.js";
-import { abortEmbeddedRun, getEmbeddedRunBySessionKey, queueEmbeddedSteer } from "./runs.js";
 import { repairAssistantUsageInSessionManager } from "./session-manager-init.js";
 import { openSqliteHydratingSessionManager } from "./sqlite-hydrating-session-manager.js";
 import { InMemoryTranscriptRuntime, createSqliteTranscriptRuntime } from "./transcript-runtime.js";

package/dist/src/agent/embedded/run-for-session.js

@@ -6,9 +6,9 @@ import { init_providers, resolveModel } from "../../providers/index.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
 import { evaluateContextBudget } from "../memory/context-budget.js";
+import { runXopcEmbeddedTurn } from "./run-turn.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { projectTurnOutcome } from "../../session/turn-outcome-projector.js";
-import { runXopcEmbeddedTurn } from "./run-turn.js";
 import { voicePresentationPrompt } from "../prompt/voice-presentation.js";
 import { applyStartupContextToUserMessage } from "../reply/apply-turn-user-enrichment.js";
 import { AgentRunSupervisor } from "../orchestration/agent-run-supervisor.js";
@@ -196,6 +196,7 @@ async function runEmbeddedTurnForSession(params) {
 					turnPolicy,
 					abortSignal: supervisor.signal,
 					onEvent: params.onEvent,
+					onAgentEvent: (event) => agentManager.emitRuntimeEvent(sessionKey, event),
 					resumeLastUserMessage
 				});
 				if (turnResult.ok) {