@yuandc/aica 0.1.0

package/dist/commands/start.js

@@ -0,0 +1,137 @@
+import { Command } from "commander";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { randomUUID } from "node:crypto";
+import { Logger } from "../core/logger.js";
+import { loadCredentials, saveApiKeyCredential } from "../core/auth.js";
+import { getRuntimeStatePath } from "../core/paths.js";
+import { writeJsonFile } from "../core/fs.js";
+import { HEARTBEAT_INTERVAL_MS, startHeartbeatLoop } from "../core/heartbeat.js";
+import { startJobWorkerLoop } from "../core/job-worker.js";
+import { startFileTransferWorkerLoop } from "../core/file-transfer-worker.js";
+import { startMachineFilesystemWorkerLoop } from "../core/machine-filesystem-worker.js";
+import { cleanupOrphanedAcpProcesses } from "../core/acp-orphan-cleanup.js";
+import { defaultAcpRuntimePool } from "../acp/client/acp-runtime-pool.js";
+import { writePidFile, removePidFile } from "../core/process.js";
+import { applyRuntimePathOptions } from "../core/runtime-options.js";
+import { loadAcaConfig, updateAcaConfig } from "../core/aca-config.js";
+import { ACA_WORKER_INSTANCE_ENV, ACA_WORKER_PID_ENV, ACA_WORKER_START_TICKS_ENV, readProcessStartTicks } from "../core/process-identity.js";
+export function createStartCommand() {
+    return new Command("start")
+        .description("Start agent service in native mode")
+        .option("--aica-home <path>", "Runtime home directory (defaults to ~/.aica or AICA_HOME)")
+        .option("--aica-config <path>", "Config file path (defaults to <aica-home>/config.json)")
+        .option("--aca-home <path>", "Deprecated alias for --aica-home")
+        .option("--aca-config <path>", "Deprecated alias for --aica-config")
+        .option("--server <url>", "ACA Server URL override")
+        .option("--machine-id <id>", "Machine ID override for this runtime")
+        .option("--machine-name <name>", "Machine name to register (defaults to hostname)")
+        .option("--cli-types <types...>", "Specify CLI types to register, `claude` or `codex`")
+        .option("--debug", "enable debug output")
+        .option("--heartbeat-log", "output current timestamp every 5 seconds")
+        .option("--auth <api-key>", "Use a CLI API key for non-interactive authentication")
+        .action(async (options) => {
+        await runStart(options);
+    });
+}
+async function runStart(options) {
+    applyRuntimePathOptions(options);
+    const workerInstanceId = process.env[ACA_WORKER_INSTANCE_ENV] || randomUUID();
+    const workerStartTicks = readProcessStartTicks(process.pid) || "";
+    process.env[ACA_WORKER_INSTANCE_ENV] = workerInstanceId;
+    process.env[ACA_WORKER_PID_ENV] = String(process.pid);
+    process.env[ACA_WORKER_START_TICKS_ENV] = workerStartTicks;
+    const logger = new Logger("start", options.debug ? "debug" : "info");
+    const loadedConfig = loadAcaConfig();
+    const configPatch = {
+        ...(options.server?.trim() ? { serverUrl: options.server.trim() } : {}),
+        ...(options.machineId ? { machineId: options.machineId.trim() } : {}),
+        ...(options.machineName ? { machineName: options.machineName.trim() } : {})
+    };
+    const acaConfig = Object.keys(configPatch).length > 0 ? updateAcaConfig(configPatch) : loadedConfig;
+    const machineName = options.machineName?.trim() || acaConfig.machineName || os.hostname();
+    const credentials = options.auth ? saveApiKeyCredential(options.auth, machineName) : loadCredentials();
+    writePidFile(process.pid);
+    writeRuntimeState({
+        pid: process.pid,
+        workerInstanceId,
+        workerStartTicks,
+        phase: "running",
+        startupStage: "local-compatible",
+        machineId: acaConfig.machineId || credentials?.machine?.machineId || "local-machine",
+        machineName,
+        cliTypes: options.cliTypes ?? detectCliTypes(),
+        startedAt: new Date().toISOString(),
+        heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+        issues: [
+            {
+                severity: "info",
+                message: "aca is running in aca-server compatibility mode; ACP execution happens on this machine."
+            }
+        ]
+    });
+    logger.info(`Starting aca local-compatible service on machine ${machineName}`);
+    logger.info(`PID ${process.pid}`);
+    const orphanCleanup = await cleanupOrphanedAcpProcesses();
+    if (orphanCleanup.terminated > 0) {
+        logger.warn(`terminated ${orphanCleanup.terminated} orphaned ACP process(es): ${orphanCleanup.pids.join(",")}`);
+    }
+    let shuttingDown = false;
+    let heartbeatTimer;
+    let jobWorker;
+    let fileTransferWorker;
+    let machineFilesystemWorker;
+    const shutdown = async (exitCode) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info("Shutting down");
+        if (heartbeatTimer)
+            clearInterval(heartbeatTimer);
+        fileTransferWorker?.stop();
+        machineFilesystemWorker?.stop();
+        await jobWorker?.stop().catch((error) => logger.warn(`job worker shutdown failed: ${error instanceof Error ? error.message : String(error)}`));
+        const beforeDispose = defaultAcpRuntimePool.stats();
+        await defaultAcpRuntimePool.disposeAll().catch((error) => logger.warn(`ACP runtime shutdown failed: ${error instanceof Error ? error.message : String(error)}`));
+        logger.info(`ACP runtimes stopped total=${beforeDispose.total} inUse=${beforeDispose.inUse} idle=${beforeDispose.idle}`);
+        writeRuntimeState({
+            pid: process.pid,
+            phase: "stopped",
+            stoppedAt: new Date().toISOString(),
+            issues: []
+        });
+        removePidFile();
+        process.exit(exitCode);
+    };
+    process.once("SIGINT", () => void shutdown(130));
+    process.once("SIGTERM", () => void shutdown(0));
+    if (options.heartbeatLog) {
+        setInterval(() => logger.info(`heartbeat: ${new Date().toISOString()}`), 5_000);
+    }
+    heartbeatTimer = startHeartbeatLoop(logger);
+    jobWorker = startJobWorkerLoop(logger);
+    fileTransferWorker = startFileTransferWorkerLoop(logger);
+    machineFilesystemWorker = startMachineFilesystemWorkerLoop(logger);
+    await new Promise(() => { });
+}
+function detectCliTypes() {
+    return ["codex", "claude"].filter((name) => commandExists(name));
+}
+function commandExists(name) {
+    const pathValue = process.env.PATH || "";
+    for (const dir of pathValue.split(":")) {
+        try {
+            if (dir && fs.existsSync(path.join(dir, name)))
+                return true;
+        }
+        catch {
+            // Ignore malformed PATH entries.
+        }
+    }
+    return false;
+}
+function writeRuntimeState(value) {
+    writeJsonFile(getRuntimeStatePath(), value);
+}

package/dist/commands/worker-auth.js

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import os from "node:os";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { acaServerRequest } from "../core/aca-server-client.js";
+import { applyRuntimePathOptions } from "../core/runtime-options.js";
+import { DEFAULT_ACA_SERVER_URL, ensureMachineIdentity, updateAcaConfig } from "../core/aca-config.js";
+import { getAcaConfigPath } from "../core/paths.js";
+export function createWorkerAuthCommand() {
+    return new Command("login")
+        .description("登录 ACA Server 并生成 Worker 认证配置")
+        .option("--server <url>", "ACA Server URL")
+        .option("--username <name>", "用户名")
+        .option("--password <password>", "密码；不传入时交互式输入")
+        .option("--aica-home <path>", "Runtime home directory (defaults to ~/.aica)")
+        .option("--aica-config <path>", "Config file path")
+        .option("--aca-home <path>", "Deprecated alias for --aica-home")
+        .option("--aca-config <path>", "Deprecated alias for --aica-config")
+        .option("--machine-id <id>", "Machine ID")
+        .option("--machine-name <name>", "Machine display name")
+        .action(async (options) => {
+        applyRuntimePathOptions(options);
+        const server = options.server?.trim() || process.env.ACA_DEFAULT_SERVER_URL || DEFAULT_ACA_SERVER_URL;
+        const username = options.username?.trim() || await promptLine("用户名: ");
+        const password = options.password ?? await promptSecret("密码: ");
+        if (!username)
+            throw new Error("用户名不能为空。");
+        if (!password)
+            throw new Error("密码不能为空。");
+        const machine = ensureMachineIdentity({
+            machineId: options.machineId?.trim(),
+            machineName: options.machineName?.trim() || os.hostname()
+        });
+        const response = await acaServerRequest("POST", "/api/auth/login", {
+            username,
+            password,
+            machineId: machine.machineId,
+            machineName: machine.machineName
+        }, { serverUrl: server });
+        const config = updateAcaConfig({
+            serverUrl: server,
+            token: response.token,
+            username: response.username,
+            machineId: machine.machineId,
+            machineName: machine.machineName,
+            defaultWorkspaceId: "default"
+        });
+        console.log(`登录成功：${response.username}`);
+        console.log(`认证配置已保存：${getAcaConfigPath()}`);
+        console.log(`机器：${config.machineName} (${config.machineId})`);
+    });
+}
+async function promptLine(message) {
+    if (!input.isTTY || !output.isTTY)
+        throw new Error("非交互环境请使用 --username 和 --password 参数。");
+    const reader = readline.createInterface({ input, output });
+    try {
+        return (await reader.question(message)).trim();
+    }
+    finally {
+        reader.close();
+    }
+}
+async function promptSecret(message) {
+    if (!input.isTTY || !output.isTTY || !input.setRawMode) {
+        throw new Error("非交互环境请使用 --password 参数。");
+    }
+    output.write(message);
+    input.setRawMode(true);
+    input.resume();
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const onData = (chunk) => {
+            const char = chunk.toString("utf8");
+            if (char === "\u0003") {
+                cleanup();
+                output.write("\n");
+                reject(new Error("已取消登录。"));
+                return;
+            }
+            if (char === "\r" || char === "\n") {
+                cleanup();
+                output.write("\n");
+                resolve(value);
+                return;
+            }
+            if (char === "\u007f") {
+                value = value.slice(0, -1);
+                return;
+            }
+            value += char;
+        };
+        const cleanup = () => {
+            input.setRawMode?.(false);
+            input.pause();
+            input.off("data", onData);
+        };
+        input.on("data", onData);
+    });
+}

package/dist/commands/worker-project.js

@@ -0,0 +1,57 @@
+import { Command } from "commander";
+import path from "node:path";
+import { acaServerRequest } from "../core/aca-server-client.js";
+import { applyRuntimePathOptions } from "../core/runtime-options.js";
+import { loadAcaConfig, upsertLocalProject } from "../core/aca-config.js";
+export function createWorkerProjectCommand() {
+    return new Command("project")
+        .description("Manage remote projects without local SQLite")
+        .addCommand(new Command("add")
+        .description("Register a local project on ACA Server")
+        .argument("<root>", "Project root path")
+        .option("--aica-home <path>", "Runtime home directory (defaults to ~/.aica)")
+        .option("--aica-config <path>", "Config file path")
+        .option("--aca-home <path>", "Deprecated alias for --aica-home")
+        .option("--aca-config <path>", "Deprecated alias for --aica-config")
+        .option("--name <name>", "Project name")
+        .option("--workspace <id>", "ACA workspace ID")
+        .option("--type <project|chat-room>", "Project type", "project")
+        .action(async (root, options) => {
+        applyRuntimePathOptions(options);
+        if (options.type !== "project" && options.type !== "chat-room") {
+            throw new Error("Project type must be 'project' or 'chat-room'.");
+        }
+        const config = loadAcaConfig();
+        const rootPath = path.resolve(root);
+        const name = options.name?.trim() || path.basename(rootPath);
+        const response = await acaServerRequest("POST", "/api/projects", {
+            workspaceId: options.workspace || config.defaultWorkspaceId,
+            name,
+            rootPath,
+            source: "aica",
+            projectType: options.type === "chat-room" ? "chat_room" : "project"
+        });
+        const item = response.item;
+        upsertLocalProject({
+            projectId: item.project_id,
+            workspaceId: item.workspace_id,
+            name: item.name,
+            rootPath: item.root_path
+        });
+        console.log(`${item.project_id} ${item.name} ${item.root_path}`);
+    }))
+        .addCommand(new Command("list")
+        .description("List projects from ACA Server")
+        .option("--aica-home <path>", "Runtime home directory (defaults to ~/.aica)")
+        .option("--aica-config <path>", "Config file path")
+        .option("--aca-home <path>", "Deprecated alias for --aica-home")
+        .option("--aca-config <path>", "Deprecated alias for --aica-config")
+        .option("--workspace <id>", "ACA workspace ID")
+        .action(async (options) => {
+        applyRuntimePathOptions(options);
+        const query = options.workspace ? `?workspaceId=${encodeURIComponent(options.workspace)}` : "";
+        const response = await acaServerRequest("GET", `/api/projects${query}`);
+        for (const item of response.items)
+            console.log(`${item.project_id} workspace=${item.workspace_id} name=${item.name} root=${item.root_path}`);
+    }));
+}

package/dist/core/aca-config.js

@@ -0,0 +1,74 @@
+import { readJsonFile, writeJsonFile } from "./fs.js";
+import { getAcaConfigPath } from "./paths.js";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+export const DEFAULT_ACA_SERVER_URL = "https://aca.kinghon.com.cn:8843/";
+export function loadAcaConfig() {
+    const value = readJsonFile(getAcaConfigPath()) ?? {};
+    return {
+        serverUrl: value.serverUrl || process.env.ACA_DEFAULT_SERVER_URL || DEFAULT_ACA_SERVER_URL,
+        token: value.token,
+        username: value.username,
+        machineId: value.machineId || randomUUID(),
+        machineName: value.machineName || os.hostname(),
+        defaultWorkspaceId: value.defaultWorkspaceId || "default",
+        defaultProjectId: value.defaultProjectId,
+        projects: Array.isArray(value.projects) ? value.projects : []
+    };
+}
+export function ensureMachineIdentity(overrides = {}) {
+    const current = readJsonFile(getAcaConfigPath()) ?? {};
+    const config = {
+        ...loadAcaConfig(),
+        ...(overrides.machineId ? { machineId: overrides.machineId } : {}),
+        ...(overrides.machineName ? { machineName: overrides.machineName } : {})
+    };
+    if (!current.machineId || overrides.machineId || overrides.machineName) {
+        saveAcaConfig(config);
+    }
+    return { machineId: config.machineId, machineName: config.machineName };
+}
+export function saveAcaConfig(config) {
+    writeJsonFile(getAcaConfigPath(), config);
+}
+export function updateAcaConfig(patch) {
+    const next = { ...loadAcaConfig(), ...patch };
+    saveAcaConfig(next);
+    return next;
+}
+export function upsertLocalProject(project) {
+    const config = loadAcaConfig();
+    const projects = config.projects.filter((item) => item.projectId !== project.projectId && item.name !== project.name);
+    projects.push(project);
+    const next = {
+        ...config,
+        defaultWorkspaceId: project.workspaceId,
+        defaultProjectId: project.projectId,
+        projects
+    };
+    saveAcaConfig(next);
+    return next;
+}
+export function removeLocalProject(projectIdOrName) {
+    const config = loadAcaConfig();
+    const projects = config.projects.filter((item) => item.projectId !== projectIdOrName && item.name !== projectIdOrName);
+    const defaultProjectId = config.defaultProjectId === projectIdOrName || config.projects.find((item) => item.name === projectIdOrName)?.projectId === config.defaultProjectId
+        ? projects[0]?.projectId
+        : config.defaultProjectId;
+    const next = {
+        ...config,
+        defaultProjectId,
+        projects
+    };
+    saveAcaConfig(next);
+    return next;
+}
+export function findLocalProject(idOrName) {
+    const config = loadAcaConfig();
+    if (!idOrName && config.defaultProjectId) {
+        return config.projects.find((project) => project.projectId === config.defaultProjectId) ?? null;
+    }
+    if (!idOrName)
+        return config.projects[0] ?? null;
+    return config.projects.find((project) => project.projectId === idOrName || project.name === idOrName) ?? null;
+}

package/dist/core/aca-server-client.js

@@ -0,0 +1,57 @@
+import { Agent } from "undici";
+import { loadAcaConfig } from "./aca-config.js";
+// 仅对 ACA Server 请求启用，避免使用 NODE_TLS_REJECT_UNAUTHORIZED=0 影响
+// Codex、Mimo、OpenCode 以及其它外部 HTTPS 请求。
+const insecureTlsDispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+export async function acaServerRequest(method, path, body, options = {}) {
+    const config = loadAcaConfig();
+    const serverUrl = (options.serverUrl || config.serverUrl).replace(/\/$/, "");
+    const token = options.token ?? config.token;
+    const headers = {
+        ...(body === undefined ? {} : { "content-type": "application/json" }),
+        ...(token ? { authorization: `Bearer ${token}` } : {})
+    };
+    const response = await fetch(`${serverUrl}${path}`, {
+        method,
+        headers,
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        ...acaServerTlsInit(serverUrl)
+    });
+    const text = await response.text();
+    const value = text ? JSON.parse(text) : null;
+    if (!response.ok) {
+        const message = value && typeof value === "object" && "message" in value ? String(value.message) : `HTTP ${response.status}`;
+        throw new Error(message);
+    }
+    return value;
+}
+export async function acaServerStreamRequest(method, path, body, headers = {}, options = {}) {
+    const config = loadAcaConfig();
+    const serverUrl = (options.serverUrl || config.serverUrl).replace(/\/$/, "");
+    const token = options.token ?? config.token;
+    const response = await fetch(`${serverUrl}${path}`, {
+        method,
+        headers: {
+            ...headers,
+            ...(token ? { authorization: `Bearer ${token}` } : {})
+        },
+        body,
+        duplex: "half",
+        ...acaServerTlsInit(serverUrl)
+    });
+    const text = await response.text();
+    const value = text ? JSON.parse(text) : null;
+    if (!response.ok) {
+        const message = value && typeof value === "object" && "message" in value ? String(value.message) : `HTTP ${response.status}`;
+        throw new Error(message);
+    }
+    return value;
+}
+function acaServerTlsInit(serverUrl) {
+    if (!/^https:/i.test(serverUrl) || !isTruthy(process.env.ACA_SERVER_INSECURE_TLS))
+        return {};
+    return { dispatcher: insecureTlsDispatcher };
+}
+function isTruthy(value) {
+    return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}

package/dist/core/acp-event-coalescer.js

@@ -0,0 +1,108 @@
+const MAX_TEXT_CHARS = 1024;
+const TEXT_EVENT_TYPES = new Set(["agent_message_chunk", "agent_progress_chunk", "agent_thought_chunk", "user_message_chunk"]);
+const SNAPSHOT_EVENT_TYPES = new Set(["usage_update", "session_info_update"]);
+/**
+ * Coalesce only adjacent compatible events in the Worker batch. Tool calls,
+ * plans, permissions and errors naturally act as barriers because their type
+ * is neither text nor a replaceable snapshot.
+ */
+export function appendCoalescedAcpEvent(buffer, incoming) {
+    const previous = buffer.at(-1);
+    if (!previous) {
+        buffer.push(incoming);
+        return false;
+    }
+    if (canMergeText(previous, incoming)) {
+        const mergedText = `${previous.text ?? ""}${incoming.text ?? ""}`;
+        if (mergedText.length <= MAX_TEXT_CHARS) {
+            previous.text = mergedText;
+            previous.raw = mergeRaw(previous.raw, incoming.raw, mergedText);
+            return true;
+        }
+    }
+    if (canReplaceSnapshot(previous, incoming)) {
+        const firstSequence = sequenceStart(previous.raw);
+        previous.label = incoming.label;
+        previous.text = incoming.text;
+        previous.status = incoming.status;
+        previous.toolCallId = incoming.toolCallId;
+        previous.raw = mergeRaw(previous.raw, incoming.raw, incoming.text, firstSequence);
+        return true;
+    }
+    buffer.push(incoming);
+    return false;
+}
+function canMergeText(previous, incoming) {
+    return TEXT_EVENT_TYPES.has(previous.eventType)
+        && previous.eventType === incoming.eventType
+        && previous.turnId === incoming.turnId
+        && previous.label === incoming.label
+        && previous.status === incoming.status
+        && !previous.toolCallId
+        && !incoming.toolCallId
+        && typeof previous.text === "string"
+        && typeof incoming.text === "string";
+}
+function canReplaceSnapshot(previous, incoming) {
+    if (previous.eventType !== incoming.eventType || previous.turnId !== incoming.turnId)
+        return false;
+    if (SNAPSHOT_EVENT_TYPES.has(previous.eventType))
+        return true;
+    if (previous.eventType !== "config_option_update")
+        return false;
+    const previousKey = configOptionKey(previous.raw);
+    const incomingKey = configOptionKey(incoming.raw);
+    return Boolean(previousKey) && previousKey === incomingKey;
+}
+function configOptionKey(raw) {
+    const update = rawUpdate(raw);
+    for (const key of ["configId", "optionId", "id", "key", "name"]) {
+        if (typeof update?.[key] === "string" && update[key].trim())
+            return update[key].trim();
+    }
+    return "";
+}
+function mergeRaw(previous, incoming, mergedText, firstSequence = sequenceStart(previous)) {
+    const next = asRecord(incoming);
+    if (!next)
+        return incoming;
+    const end = sequenceEnd(incoming);
+    const count = sourceCount(previous) + sourceCount(incoming);
+    const raw = {
+        ...next,
+        acaSequence: firstSequence,
+        acaSequenceEnd: end,
+        sourceEventCount: count
+    };
+    if (mergedText !== undefined) {
+        const update = asRecord(next.update);
+        if (update) {
+            raw.update = {
+                ...update,
+                content: { type: "text", text: mergedText }
+            };
+        }
+    }
+    return raw;
+}
+function rawUpdate(raw) {
+    return asRecord(asRecord(raw)?.update);
+}
+function sequenceStart(raw) {
+    const value = asRecord(raw)?.acaSequence;
+    return typeof value === "number" ? value : undefined;
+}
+function sequenceEnd(raw) {
+    const record = asRecord(raw);
+    const end = record?.acaSequenceEnd;
+    if (typeof end === "number")
+        return end;
+    return typeof record?.acaSequence === "number" ? record.acaSequence : undefined;
+}
+function sourceCount(raw) {
+    const value = asRecord(raw)?.sourceEventCount;
+    return typeof value === "number" && value > 0 ? value : 1;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}

package/dist/core/acp-event-upload-filter.js

@@ -0,0 +1,16 @@
+/** Matches the Server-side protocol marker filter before it reaches the batcher.
+ * Keeping this marker out of the buffer prevents it from splitting adjacent
+ * visible assistant text into separate coalescing groups. */
+export function shouldUploadAcpEvent(event) {
+    if (event.eventType !== "agent_message_chunk" || event.text?.trim() !== "text")
+        return true;
+    const raw = asRecord(event.raw);
+    if (!raw)
+        return false;
+    const update = asRecord(raw.update);
+    const content = asRecord(update?.content);
+    return !(content?.type === "text" && content.text === "text");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}

package/dist/core/acp-orphan-cleanup.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import { ACA_ACP_CHILD_ENV, ACA_ACP_OWNER_PID_ENV, ACA_ACP_OWNER_START_TICKS_ENV, ACA_ACP_WORKER_INSTANCE_ENV, ACA_WORKER_INSTANCE_ENV, readProcessStartTicks } from "./process-identity.js";
+export async function cleanupOrphanedAcpProcesses() {
+    if (process.platform !== "linux")
+        return { inspected: 0, terminated: 0, pids: [] };
+    let inspected = 0;
+    const pids = [];
+    for (const entry of safeReadDir("/proc")) {
+        if (!/^\d+$/.test(entry))
+            continue;
+        const pid = Number(entry);
+        if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid)
+            continue;
+        const environment = readProcessEnvironment(pid);
+        if (environmentValue(environment, ACA_ACP_CHILD_ENV) !== "1")
+            continue;
+        inspected += 1;
+        const ownerPid = Number.parseInt(environmentValue(environment, ACA_ACP_OWNER_PID_ENV), 10);
+        const ownerStartTicks = environmentValue(environment, ACA_ACP_OWNER_START_TICKS_ENV);
+        const workerInstanceId = environmentValue(environment, ACA_ACP_WORKER_INSTANCE_ENV);
+        if (isMatchingWorkerProcess(ownerPid, ownerStartTicks, workerInstanceId))
+            continue;
+        try {
+            process.kill(pid, "SIGTERM");
+            pids.push(pid);
+        }
+        catch {
+            // Process may have exited between /proc inspection and signal delivery.
+        }
+    }
+    if (pids.length > 0) {
+        await delay(2_000);
+        for (const pid of pids) {
+            if (!isProcessAlive(pid))
+                continue;
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch {
+                // Process may have exited after the liveness check.
+            }
+        }
+    }
+    return { inspected, terminated: pids.length, pids };
+}
+function readProcessEnvironment(pid) {
+    try {
+        return fs.readFileSync(`/proc/${pid}/environ`, "utf8").split("\0").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function isMatchingWorkerProcess(pid, expectedStartTicks, expectedInstanceId) {
+    if (!Number.isInteger(pid) || pid <= 1 || !expectedStartTicks)
+        return false;
+    try {
+        process.kill(pid, 0);
+        if (readProcessStartTicks(pid) !== expectedStartTicks)
+            return false;
+        const ownerInstanceId = environmentValue(readProcessEnvironment(pid), ACA_WORKER_INSTANCE_ENV);
+        return !expectedInstanceId || !ownerInstanceId || ownerInstanceId === expectedInstanceId;
+    }
+    catch {
+        return false;
+    }
+}
+function environmentValue(environment, name) {
+    const prefix = `${name}=`;
+    return environment.find((value) => value.startsWith(prefix))?.slice(prefix.length) ?? "";
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function safeReadDir(directory) {
+    try {
+        return fs.readdirSync(directory);
+    }
+    catch {
+        return [];
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}