@kodelyth/acpx 2026.5.39 → 2026.6.1

package/dist/index.js

@@ -0,0 +1,14 @@
+import { createAcpxRuntimeService } from "./register.runtime.js";
+import { tryDispatchAcpReplyHook } from "klaw/plugin-sdk/acp-runtime-backend";
+//#region extensions/acpx/index.ts
+const plugin = {
+	id: "acpx",
+	name: "ACPX Runtime",
+	description: "Embedded ACP runtime backend with plugin-owned session and transport management.",
+	register(api) {
+		api.registerService(createAcpxRuntimeService({ pluginConfig: api.pluginConfig }));
+		api.on("reply_dispatch", tryDispatchAcpReplyHook);
+	}
+};
+//#endregion
+export { plugin as default };

package/dist/process-reaper-DdVqzAA_.js

@@ -0,0 +1,370 @@
+import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { readJsonFileWithFallback, writeJsonFileAtomically } from "klaw/plugin-sdk/json-store";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region extensions/acpx/src/process-lease.ts
+const KLAW_ACPX_LEASE_ID_ENV = "KLAW_ACPX_LEASE_ID";
+const KLAW_GATEWAY_INSTANCE_ID_ENV = "KLAW_GATEWAY_INSTANCE_ID";
+const KLAW_ACPX_LEASE_ID_ARG = "--klaw-acpx-lease-id";
+const KLAW_GATEWAY_INSTANCE_ID_ARG = "--klaw-gateway-instance-id";
+const LEASE_FILE = "process-leases.json";
+function normalizeLease(value) {
+	if (typeof value !== "object" || value === null) return;
+	const record = value;
+	if (typeof record.leaseId !== "string" || typeof record.gatewayInstanceId !== "string" || typeof record.sessionKey !== "string" || typeof record.wrapperRoot !== "string" || typeof record.wrapperPath !== "string" || typeof record.rootPid !== "number" || typeof record.commandHash !== "string" || typeof record.startedAt !== "number" || ![
+		"open",
+		"closing",
+		"closed",
+		"lost"
+	].includes(String(record.state))) return;
+	return {
+		leaseId: record.leaseId,
+		gatewayInstanceId: record.gatewayInstanceId,
+		sessionKey: record.sessionKey,
+		wrapperRoot: record.wrapperRoot,
+		wrapperPath: record.wrapperPath,
+		rootPid: record.rootPid,
+		...typeof record.processGroupId === "number" ? { processGroupId: record.processGroupId } : {},
+		commandHash: record.commandHash,
+		startedAt: record.startedAt,
+		state: record.state
+	};
+}
+async function readLeaseFile(filePath) {
+	const { value } = await readJsonFileWithFallback(filePath, {
+		version: 1,
+		leases: []
+	});
+	return {
+		version: 1,
+		leases: Array.isArray(value.leases) ? value.leases.map(normalizeLease).filter((lease) => !!lease) : []
+	};
+}
+function writeLeaseFile(filePath, value) {
+	return writeJsonFileAtomically(filePath, value);
+}
+function createAcpxProcessLeaseStore(params) {
+	const filePath = path.join(params.stateDir, LEASE_FILE);
+	let updateQueue = Promise.resolve();
+	async function update(mutator) {
+		const run = updateQueue.then(async () => {
+			await fs.mkdir(params.stateDir, { recursive: true });
+			await writeLeaseFile(filePath, {
+				version: 1,
+				leases: mutator((await readLeaseFile(filePath)).leases)
+			});
+		});
+		updateQueue = run.catch(() => {});
+		await run;
+	}
+	async function readCurrent() {
+		await updateQueue;
+		return await readLeaseFile(filePath);
+	}
+	return {
+		async load(leaseId) {
+			return (await readCurrent()).leases.find((lease) => lease.leaseId === leaseId);
+		},
+		async listOpen(gatewayInstanceId) {
+			return (await readCurrent()).leases.filter((lease) => (lease.state === "open" || lease.state === "closing") && (!gatewayInstanceId || lease.gatewayInstanceId === gatewayInstanceId));
+		},
+		async save(lease) {
+			await update((leases) => [...leases.filter((entry) => entry.leaseId !== lease.leaseId), lease]);
+		},
+		async markState(leaseId, state) {
+			await update((leases) => leases.map((lease) => lease.leaseId === leaseId ? {
+				...lease,
+				state
+			} : lease));
+		}
+	};
+}
+function createAcpxProcessLeaseId() {
+	return randomUUID();
+}
+function hashAcpxProcessCommand(command) {
+	return createHash("sha256").update(command).digest("hex");
+}
+function quoteEnvValue(value) {
+	return /^[A-Za-z0-9_./:=@+-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+function appendAcpxLeaseArgs(params) {
+	return [
+		params.command,
+		KLAW_ACPX_LEASE_ID_ARG,
+		quoteEnvValue(params.leaseId),
+		KLAW_GATEWAY_INSTANCE_ID_ARG,
+		quoteEnvValue(params.gatewayInstanceId)
+	].join(" ");
+}
+function withAcpxLeaseEnvironment(params) {
+	if ((params.platform ?? process.platform) === "win32") return appendAcpxLeaseArgs(params);
+	return [
+		"env",
+		`${KLAW_ACPX_LEASE_ID_ENV}=${quoteEnvValue(params.leaseId)}`,
+		`${KLAW_GATEWAY_INSTANCE_ID_ENV}=${quoteEnvValue(params.gatewayInstanceId)}`,
+		appendAcpxLeaseArgs(params)
+	].join(" ");
+}
+//#endregion
+//#region extensions/acpx/src/process-reaper.ts
+const execFileAsync = promisify(execFile);
+const requireFromHere = createRequire(import.meta.url);
+const GENERATED_WRAPPER_BASENAMES = new Set(["codex-acp-wrapper.mjs", "claude-agent-acp-wrapper.mjs"]);
+const KLAW_PLUGIN_DEPS_MARKER = "/plugin-runtime-deps/";
+const OWNED_ACP_PACKAGE_NAMES = [
+	"@zed-industries/codex-acp",
+	"@zed-industries/codex-acp-darwin-arm64",
+	"@zed-industries/codex-acp-darwin-x64",
+	"@zed-industries/codex-acp-linux-arm64",
+	"@zed-industries/codex-acp-linux-x64",
+	"@zed-industries/codex-acp-win32-arm64",
+	"@zed-industries/codex-acp-win32-x64",
+	"@agentclientprotocol/claude-agent-acp",
+	"acpx"
+];
+const ACP_PACKAGE_MARKERS = [
+	"/@zed-industries/codex-acp/",
+	"/@agentclientprotocol/claude-agent-acp/",
+	"/acpx/dist/"
+];
+function normalizePathLike(value) {
+	return value.replaceAll("\\", "/");
+}
+function resolvePackageRoot(packageName) {
+	try {
+		return normalizePathLike(path.dirname(requireFromHere.resolve(`${packageName}/package.json`)));
+	} catch {
+		return;
+	}
+}
+const OWNED_ACP_PACKAGE_ROOTS = OWNED_ACP_PACKAGE_NAMES.map(resolvePackageRoot).filter((root) => Boolean(root));
+function commandBelongsToResolvedAcpPackage(command) {
+	return OWNED_ACP_PACKAGE_ROOTS.some((root) => command.includes(`${root}/`));
+}
+function commandMentionsGeneratedWrapper(command) {
+	return Array.from(GENERATED_WRAPPER_BASENAMES).some((basename) => command.includes(basename));
+}
+function commandWrapperBelongsToRoot(command, wrapperRoot) {
+	if (!wrapperRoot) return true;
+	const normalizedCommand = normalizePathLike(command);
+	const normalizedRoot = normalizePathLike(wrapperRoot).replace(/\/+$/, "");
+	return Array.from(GENERATED_WRAPPER_BASENAMES).some((basename) => normalizedCommand.includes(`${normalizedRoot}/${basename}`));
+}
+function isKlawLeaseAwareAcpxProcessCommand(params) {
+	const command = params.command?.trim();
+	if (!command) return false;
+	const normalized = normalizePathLike(command);
+	return commandMentionsGeneratedWrapper(normalized) && commandWrapperBelongsToRoot(normalized, params.wrapperRoot);
+}
+function commandsReferToSameRootCommand(liveCommand, storedCommand) {
+	if (!storedCommand?.trim()) return true;
+	return normalizePathLike(liveCommand).trim() === normalizePathLike(storedCommand).trim();
+}
+function splitCommandParts(value) {
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let escaping = false;
+	for (const ch of value) {
+		if (escaping) {
+			current += ch;
+			escaping = false;
+			continue;
+		}
+		if (ch === "\\" && quote !== "'") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (ch === quote) quote = null;
+			else current += ch;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += ch;
+	}
+	if (escaping) current += "\\";
+	if (current) parts.push(current);
+	return parts;
+}
+function commandOptionEquals(parts, option, expected) {
+	if (!expected) return true;
+	const index = parts.indexOf(option);
+	return index >= 0 && parts[index + 1] === expected;
+}
+function liveCommandMatchesLeaseIdentity(params) {
+	if (!params.expectedLeaseId && !params.expectedGatewayInstanceId) return true;
+	const parts = splitCommandParts(params.command ?? "");
+	return commandOptionEquals(parts, "--klaw-acpx-lease-id", params.expectedLeaseId) && commandOptionEquals(parts, "--klaw-gateway-instance-id", params.expectedGatewayInstanceId);
+}
+function isKlawOwnedAcpxProcessCommand(params) {
+	const command = params.command?.trim();
+	if (!command) return false;
+	const normalized = normalizePathLike(command);
+	if (isKlawLeaseAwareAcpxProcessCommand({
+		command: normalized,
+		wrapperRoot: params.wrapperRoot
+	})) return true;
+	if (commandBelongsToResolvedAcpPackage(normalized)) return true;
+	if (!normalized.includes(KLAW_PLUGIN_DEPS_MARKER)) return false;
+	return ACP_PACKAGE_MARKERS.some((marker) => normalized.includes(marker));
+}
+function parseProcessList(stdout) {
+	const processes = [];
+	for (const line of stdout.split(/\r?\n/)) {
+		const match = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<command>.+?)\s*$/.exec(line);
+		if (!match?.groups) continue;
+		processes.push({
+			pid: Number.parseInt(match.groups.pid, 10),
+			ppid: Number.parseInt(match.groups.ppid, 10),
+			command: match.groups.command
+		});
+	}
+	return processes;
+}
+async function listPlatformProcesses() {
+	if (process.platform === "win32") return [];
+	const { stdout } = await execFileAsync("ps", ["-axo", "pid=,ppid=,command="], { maxBuffer: 8 * 1024 * 1024 });
+	return parseProcessList(stdout);
+}
+function collectProcessTree(processes, rootPid) {
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const processInfo of processes) {
+		const children = childrenByParent.get(processInfo.ppid) ?? [];
+		children.push(processInfo);
+		childrenByParent.set(processInfo.ppid, children);
+	}
+	const root = new Map(processes.map((processInfo) => [processInfo.pid, processInfo])).get(rootPid);
+	const collected = [];
+	if (root) collected.push(root);
+	const queue = [...childrenByParent.get(rootPid) ?? []];
+	while (queue.length > 0) {
+		const next = queue.shift();
+		if (!next || collected.some((processInfo) => processInfo.pid === next.pid)) continue;
+		collected.push(next);
+		queue.push(...childrenByParent.get(next.pid) ?? []);
+	}
+	return collected;
+}
+function uniquePids(processes) {
+	return Array.from(new Set(processes.map((processInfo) => processInfo.pid).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid)));
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function terminatePids(pids, deps) {
+	const killProcess = deps?.killProcess ?? ((pid, signal) => process.kill(pid, signal));
+	const sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const terminated = [];
+	for (const pid of pids) try {
+		killProcess(pid, "SIGTERM");
+		terminated.push(pid);
+	} catch {}
+	if (terminated.length === 0) return terminated;
+	await sleep(750);
+	for (const pid of terminated) if (deps?.killProcess || isProcessAlive(pid)) try {
+		killProcess(pid, "SIGKILL");
+	} catch {}
+	return terminated;
+}
+async function cleanupKlawOwnedAcpxProcessTree(params) {
+	const rootPid = params.rootPid;
+	if (!rootPid || rootPid <= 0 || rootPid === process.pid) return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "missing-root"
+	};
+	let processes = [];
+	try {
+		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
+	} catch {
+		processes = [];
+	}
+	const listedTree = collectProcessTree(processes, rootPid);
+	if (listedTree.length === 0) return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unverified-root"
+	};
+	const rootCommand = listedTree[0]?.command ?? params.rootCommand;
+	const liveCommandWasGeneratedWrapper = commandMentionsGeneratedWrapper(normalizePathLike(rootCommand ?? ""));
+	const storedCommandWasGeneratedWrapper = commandMentionsGeneratedWrapper(normalizePathLike(params.rootCommand ?? ""));
+	if (!liveCommandWasGeneratedWrapper && storedCommandWasGeneratedWrapper) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-klaw-owned"
+	};
+	if (!liveCommandWasGeneratedWrapper && !commandsReferToSameRootCommand(rootCommand ?? "", params.rootCommand)) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-klaw-owned"
+	};
+	if (!isKlawOwnedAcpxProcessCommand({
+		command: rootCommand,
+		wrapperRoot: params.wrapperRoot
+	})) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-klaw-owned"
+	};
+	if (!liveCommandMatchesLeaseIdentity({
+		command: rootCommand,
+		expectedLeaseId: params.expectedLeaseId,
+		expectedGatewayInstanceId: params.expectedGatewayInstanceId
+	})) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-klaw-owned"
+	};
+	const pids = uniquePids(listedTree.toReversed());
+	return {
+		inspectedPids: uniquePids(listedTree),
+		terminatedPids: await terminatePids(pids, params.deps)
+	};
+}
+async function reapStaleKlawOwnedAcpxOrphans(params) {
+	if (process.platform === "win32") return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unsupported-platform"
+	};
+	let processes;
+	try {
+		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
+	} catch {
+		return {
+			inspectedPids: [],
+			terminatedPids: [],
+			skippedReason: "process-list-unavailable"
+		};
+	}
+	const orphanTrees = processes.filter((processInfo) => processInfo.ppid === 1 && isKlawOwnedAcpxProcessCommand({
+		command: processInfo.command,
+		wrapperRoot: params.wrapperRoot
+	})).map((orphan) => collectProcessTree(processes, orphan.pid));
+	return {
+		inspectedPids: uniquePids(orphanTrees.flat()),
+		terminatedPids: await terminatePids(uniquePids(orphanTrees.flatMap((tree) => tree.toReversed())), params.deps)
+	};
+}
+//#endregion
+export { KLAW_ACPX_LEASE_ID_ENV as a, createAcpxProcessLeaseStore as c, KLAW_ACPX_LEASE_ID_ARG as i, hashAcpxProcessCommand as l, isKlawLeaseAwareAcpxProcessCommand as n, KLAW_GATEWAY_INSTANCE_ID_ARG as o, reapStaleKlawOwnedAcpxOrphans as r, createAcpxProcessLeaseId as s, cleanupKlawOwnedAcpxProcessTree as t, withAcpxLeaseEnvironment as u };

package/dist/register.runtime.js

@@ -0,0 +1,53 @@
+import { getAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "klaw/plugin-sdk/acp-runtime-backend";
+//#region extensions/acpx/register.runtime.ts
+const ACPX_BACKEND_ID = "acpx";
+let serviceModulePromise = null;
+function loadServiceModule() {
+	serviceModulePromise ??= import("./service-CXeUME_-.js");
+	return serviceModulePromise;
+}
+async function startRealService(state) {
+	if (state.realRuntime) return state.realRuntime;
+	if (!state.ctx) throw new Error("ACPX runtime service is not started");
+	state.startPromise ??= (async () => {
+		const { createAcpxRuntimeService } = await loadServiceModule();
+		const service = createAcpxRuntimeService(state.params);
+		state.realService = service;
+		await service.start(state.ctx);
+		const backend = getAcpRuntimeBackend(ACPX_BACKEND_ID);
+		if (!backend?.runtime) throw new Error("ACPX runtime service did not register an ACP backend");
+		state.realRuntime = backend.runtime;
+		return state.realRuntime;
+	})();
+	return await state.startPromise;
+}
+function createAcpxRuntimeService(params = {}) {
+	const state = {
+		ctx: null,
+		params,
+		realRuntime: null,
+		realService: null,
+		startPromise: null
+	};
+	return {
+		id: "acpx-runtime",
+		async start(ctx) {
+			if (process.env.KLAW_SKIP_ACPX_RUNTIME === "1") {
+				ctx.logger.info("skipping embedded acpx runtime backend (KLAW_SKIP_ACPX_RUNTIME=1)");
+				return;
+			}
+			state.ctx = ctx;
+			await startRealService(state);
+		},
+		async stop(ctx) {
+			if (state.realService) await state.realService.stop?.(ctx);
+			else unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
+			state.ctx = null;
+			state.realRuntime = null;
+			state.realService = null;
+			state.startPromise = null;
+		}
+	};
+}
+//#endregion
+export { createAcpxRuntimeService };