@yuandc/aica 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+# AICA
+
+AICA connects a machine to ACA Server and executes remote Agent jobs.
+
+Run directly with `npx @yuandc/aica`, or install globally with `npm install -g @yuandc/aica`. The installed command is `aica`.
+
+Runtime configuration is stored in `~/.aica` by default and can be overridden with `--aica-home` or `AICA_HOME`.
+
+The package does not include local Session storage or better-sqlite3.

package/dist/acp/agent.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import { createAgentProvider } from "./providers/registry.js";
+export async function sendAgentPrompt(input) {
+    if (!fs.existsSync(input.cwd) || !fs.statSync(input.cwd).isDirectory()) {
+        throw new Error(`Project root does not exist or is not a directory: ${input.cwd}`);
+    }
+    const provider = createAgentProvider({
+        agentType: input.agentType || "codex",
+        cliType: input.cliType || "builtin"
+    });
+    const session = await provider.createSession({
+        cwd: input.cwd,
+        providerSessionId: input.acpSessionId ?? null,
+        timeoutMs: input.timeoutMs
+    });
+    try {
+        const result = await session.sendPrompt({
+            ...input,
+            providerSessionId: input.acpSessionId ?? null
+        });
+        return {
+            ...result,
+            acpSessionId: result.providerSessionId
+        };
+    }
+    finally {
+        await session.close().catch(() => void 0);
+    }
+}
+export async function compactAgentContext(input) {
+    const provider = createAgentProvider({
+        agentType: input.agentType || "codex",
+        cliType: input.cliType || "builtin"
+    });
+    const session = await provider.createSession({
+        cwd: input.cwd,
+        providerSessionId: input.acpSessionId,
+        timeoutMs: input.timeoutMs
+    });
+    if (!session.compactContext) {
+        await session.close().catch(() => void 0);
+        throw new Error(`Provider does not support context compaction: ${input.agentType || "codex"}`);
+    }
+    try {
+        const result = await session.compactContext(input);
+        return {
+            ...result,
+            acpSessionId: result.providerSessionId
+        };
+    }
+    finally {
+        await session.close().catch(() => void 0);
+    }
+}

package/dist/acp/client/acp-client.js

@@ -0,0 +1,102 @@
+import { JsonLineRpcClient } from "./json-rpc.js";
+export class AcpClient {
+    onSessionUpdate;
+    onClientRequest;
+    rpc;
+    constructor(child, onSessionUpdate, onClientRequest) {
+        this.onSessionUpdate = onSessionUpdate;
+        this.onClientRequest = onClientRequest;
+        this.rpc = new JsonLineRpcClient(child, {
+            peerName: "ACP server",
+            includeJsonRpc: true,
+            onNotification: (method, params, message) => {
+                if (method === "session/update")
+                    this.onSessionUpdate(params, message);
+            },
+            onRequest: async (method, params, message) => {
+                if (this.onClientRequest)
+                    return this.onClientRequest(method, params, message);
+                throw new Error(`Unsupported ACP client request: ${method}`);
+            }
+        });
+    }
+    initialize(timeoutMs = 60_000) {
+        return this.rpc.request("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false
+            },
+            clientInfo: { name: "aca", version: "0.1.0" }
+        }, timeoutMs);
+    }
+    newSession(input, timeoutMs = 120_000) {
+        return this.rpc.request("session/new", {
+            cwd: input.cwd,
+            mcpServers: input.mcpServers ?? [],
+            ...(input.config ? { config: input.config } : {})
+        }, timeoutMs);
+    }
+    resumeSession(input, timeoutMs = 120_000) {
+        return this.rpc.request("session/resume", {
+            sessionId: input.sessionId,
+            cwd: input.cwd,
+            mcpServers: input.mcpServers ?? [],
+            ...(input.config ? { config: input.config } : {})
+        }, timeoutMs);
+    }
+    loadSession(input, timeoutMs = 120_000) {
+        return this.rpc.request("session/load", {
+            sessionId: input.sessionId,
+            cwd: input.cwd,
+            mcpServers: input.mcpServers ?? [],
+            ...(input.config ? { config: input.config } : {})
+        }, timeoutMs);
+    }
+    closeSession(sessionId, timeoutMs = 30_000) {
+        return this.rpc.request("session/close", { sessionId }, timeoutMs);
+    }
+    listSessions(params = {}, timeoutMs = 60_000) {
+        return this.rpc.request("session/list", params, timeoutMs);
+    }
+    deleteSession(sessionId, timeoutMs = 60_000) {
+        return this.rpc.request("session/delete", { sessionId }, timeoutMs);
+    }
+    forkSession(input, timeoutMs = 120_000) {
+        return this.rpc.request("session/fork", {
+            sessionId: input.sessionId,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            ...(input.mcpServers ? { mcpServers: input.mcpServers } : {})
+        }, timeoutMs);
+    }
+    setSessionConfigOption(input, timeoutMs = 60_000) {
+        return this.rpc.request("session/set_config_option", input, timeoutMs);
+    }
+    setSessionMode(input, timeoutMs = 60_000) {
+        return this.rpc.request("session/set_mode", input, timeoutMs);
+    }
+    prompt(input, timeoutMs) {
+        return this.rpc.request("session/prompt", input, timeoutMs);
+    }
+    compactSession(input, timeoutMs = 10 * 60 * 1000) {
+        return this.rpc.request("session/compact", input, timeoutMs);
+    }
+    cancel(sessionId) {
+        this.rpc.notify("session/cancel", { sessionId });
+    }
+    authenticate(input, timeoutMs = 120_000) {
+        return this.rpc.request("authenticate", input, timeoutMs);
+    }
+    logout(input = {}, timeoutMs = 60_000) {
+        return this.rpc.request("logout", input, timeoutMs);
+    }
+    listProviders(input = {}, timeoutMs = 60_000) {
+        return this.rpc.request("providers/list", input, timeoutMs);
+    }
+    setProvider(input, timeoutMs = 60_000) {
+        return this.rpc.request("providers/set", input, timeoutMs);
+    }
+    disableProvider(input, timeoutMs = 60_000) {
+        return this.rpc.request("providers/disable", input, timeoutMs);
+    }
+}

package/dist/acp/client/acp-content.js

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+export function promptBlocksToAcpContent(prompt, blocks) {
+    const inputBlocks = blocks?.length ? blocks : [{ type: "text", text: prompt }];
+    return inputBlocks.map((block) => {
+        if (block.type === "image") {
+            if (block.uri && fs.existsSync(block.uri)) {
+                return { type: "image", uri: block.uri, mimeType: block.mimeType };
+            }
+            return { type: "image", data: block.data, mimeType: block.mimeType };
+        }
+        return { type: "text", text: block.text };
+    });
+}

package/dist/acp/client/acp-events.js

@@ -0,0 +1,106 @@
+import { STANDARD_AGENT_EVENT_TYPES, createAgentMessageChunk, createAgentProgressChunk, createAgentThoughtChunk, createToolCall, createToolCallUpdate, firstString, normalizeToolKind, normalizeToolStatus } from "../standard-events.js";
+export function acpSessionUpdateFromParams(params) {
+    if (!params || typeof params !== "object" || Array.isArray(params))
+        return null;
+    const record = params;
+    const update = record.update;
+    if (!update || typeof update !== "object" || Array.isArray(update))
+        return null;
+    return {
+        sessionId: typeof record.sessionId === "string" ? record.sessionId : undefined,
+        update: update
+    };
+}
+export function eventFromAcpSessionUpdate(params) {
+    const parsed = acpSessionUpdateFromParams(params);
+    if (!parsed)
+        return null;
+    const updateType = String(parsed.update.sessionUpdate || "");
+    if (updateType === "agent_message_chunk") {
+        return createAgentMessageChunk({ text: textFromAcpContent(parsed.update.content), method: "session/update", params });
+    }
+    if (updateType === "agent_progress_chunk") {
+        return createAgentProgressChunk({ text: textFromAcpContent(parsed.update.content), method: "session/update", params });
+    }
+    if (updateType === "agent_thought_chunk") {
+        return createAgentThoughtChunk({ text: textFromAcpContent(parsed.update.content), method: "session/update", params });
+    }
+    if (updateType === "tool_call" || updateType === "tool_call_update") {
+        return toolEventFromAcpUpdate(updateType, parsed.update, params);
+    }
+    if (STANDARD_AGENT_EVENT_TYPES.has(updateType)) {
+        return {
+            type: updateType,
+            label: labelForUpdate(updateType),
+            ...(textFromAcpContent(parsed.update.content) ? { text: textFromAcpContent(parsed.update.content) } : {}),
+            raw: { method: "session/update", params, update: parsed.update },
+            atMs: Date.now()
+        };
+    }
+    return null;
+}
+export function statusFromAcpSessionUpdate(params) {
+    const parsed = acpSessionUpdateFromParams(params);
+    if (!parsed)
+        return null;
+    const updateType = String(parsed.update.sessionUpdate || "");
+    if (updateType === "agent_message_chunk")
+        return { phase: "thinking", label: "回复中", detail: textPreview(textFromAcpContent(parsed.update.content)), updateType };
+    if (updateType === "agent_progress_chunk")
+        return { phase: "thinking", label: "处理中", detail: textPreview(textFromAcpContent(parsed.update.content)), updateType };
+    if (updateType === "agent_thought_chunk")
+        return { phase: "thinking", label: "思考中", detail: textPreview(textFromAcpContent(parsed.update.content)), updateType };
+    if (updateType === "tool_call" || updateType === "tool_call_update")
+        return { phase: "exploring", label: "执行工具", detail: firstString(parsed.update.title, parsed.update.kind), updateType };
+    if (updateType === "plan" || updateType === "plan_update")
+        return { phase: "thinking", label: "规划中", updateType };
+    if (updateType === "aca_context_maintenance") {
+        return {
+            phase: "thinking",
+            label: firstString(parsed.update.label) || "正在整理会话上下文",
+            detail: firstString(parsed.update.detail),
+            updateType
+        };
+    }
+    return null;
+}
+export function textFromAcpContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!content || typeof content !== "object" || Array.isArray(content))
+        return "";
+    const record = content;
+    if (typeof record.text === "string")
+        return record.text;
+    return "";
+}
+function toolEventFromAcpUpdate(updateType, update, params) {
+    const toolCallId = firstString(update.toolCallId, update.id) || `acp.${Date.now()}`;
+    const kind = normalizeToolKind(firstString(update.kind, update.title));
+    const status = normalizeToolStatus(firstString(update.status));
+    const input = update.rawInput ?? update.input;
+    const output = update.rawOutput ?? update.output;
+    const createInput = {
+        method: "session/update",
+        params,
+        toolCallId,
+        kind,
+        title: firstString(update.title, update.kind),
+        status,
+        rawInput: input,
+        rawOutput: output,
+        content: update.content,
+        locations: Array.isArray(update.locations) ? update.locations.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : undefined,
+        meta: update._meta && typeof update._meta === "object" && !Array.isArray(update._meta) ? update._meta : undefined
+    };
+    return updateType === "tool_call" ? createToolCall(createInput) : createToolCallUpdate(createInput);
+}
+function labelForUpdate(updateType) {
+    return updateType.replace(/_/g, " ");
+}
+function textPreview(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return undefined;
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}

package/dist/acp/client/acp-process.js

@@ -0,0 +1,34 @@
+import { spawn } from "node:child_process";
+import { acpChildEnvironment } from "../../core/process-identity.js";
+export function startAcpProcess(command, args, cwd) {
+    const child = spawn(command, args, {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: acpChildEnvironment()
+    });
+    return { command, args, child };
+}
+export async function closeAcpProcess(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    child.stdin.end();
+    if (await waitForProcessClose(child, 2_000))
+        return;
+    child.kill("SIGTERM");
+    if (await waitForProcessClose(child, 1_000))
+        return;
+    child.kill("SIGKILL");
+    await waitForProcessClose(child, 1_000);
+}
+function waitForProcessClose(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), timeoutMs);
+        timer.unref();
+        child.once("close", () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+}

package/dist/acp/client/acp-runtime-pool.js

@@ -0,0 +1,248 @@
+import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import { AcpClient } from "./acp-client.js";
+import { closeAcpProcess, startAcpProcess } from "./acp-process.js";
+const DEFAULT_IDLE_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_SWEEP_INTERVAL_MS = 60 * 1000;
+const DEFAULT_MAX_IDLE_RUNTIMES = 4;
+export class AcpRuntimePool {
+    runtimes = new Map();
+    idleTtlMs;
+    sweepIntervalMs;
+    maxIdleRuntimes;
+    sweepTimer = null;
+    disposeAllPromise = null;
+    constructor(options = {}) {
+        this.idleTtlMs = Math.max(1_000, options.idleTtlMs ?? readRuntimePoolIdleTtlMs());
+        this.sweepIntervalMs = Math.max(1_000, options.sweepIntervalMs ?? readRuntimePoolSweepIntervalMs());
+        this.maxIdleRuntimes = Math.max(0, options.maxIdleRuntimes ?? readRuntimePoolMaxIdleRuntimes());
+    }
+    async acquire(input) {
+        if (this.disposeAllPromise)
+            await this.disposeAllPromise;
+        const cwd = fs.realpathSync(input.cwd);
+        this.ensureSweep();
+        const existingKey = input.providerSessionId ? runtimeKey(input.providerId, cwd, input.providerSessionId) : null;
+        const existing = existingKey ? this.runtimes.get(existingKey) : null;
+        if (existing && !this.isRuntimeAlive(existing)) {
+            await this.disposeEntry(existing).catch(() => void 0);
+        }
+        const reusable = existingKey ? this.runtimes.get(existingKey) : null;
+        if (reusable) {
+            this.activateEntry(reusable, input);
+            return this.createLease(reusable);
+        }
+        const tempSessionId = input.providerSessionId || `pending:${randomUUID()}`;
+        const key = runtimeKey(input.providerId, cwd, tempSessionId);
+        const entry = this.createEntry({ ...input, cwd, key, providerSessionId: input.providerSessionId ?? null });
+        this.runtimes.set(key, entry);
+        return this.createLease(entry);
+    }
+    disposeAll() {
+        if (this.disposeAllPromise)
+            return this.disposeAllPromise;
+        const promise = this.performDisposeAll();
+        this.disposeAllPromise = promise;
+        void promise.finally(() => {
+            if (this.disposeAllPromise === promise)
+                this.disposeAllPromise = null;
+        });
+        return promise;
+    }
+    async performDisposeAll() {
+        if (this.sweepTimer) {
+            clearInterval(this.sweepTimer);
+            this.sweepTimer = null;
+        }
+        const entries = [...this.runtimes.values()];
+        await Promise.all(entries.map((entry) => this.disposeEntry(entry).catch(() => void 0)));
+    }
+    async sweepIdle(nowMs = Date.now()) {
+        const entries = [...this.runtimes.values()];
+        for (const entry of entries) {
+            if (entry.inUse || entry.disposed)
+                continue;
+            if (nowMs - entry.lastUsedAtMs < this.idleTtlMs)
+                continue;
+            await this.disposeEntry(entry).catch(() => void 0);
+        }
+        await this.trimIdleRuntimes();
+    }
+    stats() {
+        const entries = [...this.runtimes.values()].filter((entry) => !entry.disposed);
+        return {
+            total: entries.length,
+            inUse: entries.filter((entry) => entry.inUse).length,
+            idle: entries.filter((entry) => !entry.inUse).length,
+            pids: entries.map((entry) => entry.started.child.pid).filter((pid) => Number.isInteger(pid))
+        };
+    }
+    createEntry(input) {
+        const started = startAcpProcess(input.command, input.args, input.cwd);
+        const entry = {
+            key: input.key,
+            providerId: input.providerId,
+            cwd: input.cwd,
+            providerSessionId: input.providerSessionId,
+            started,
+            client: null,
+            initialized: false,
+            sessionEstablished: false,
+            inUse: true,
+            disposed: false,
+            disposePromise: null,
+            lastUsedAtMs: Date.now(),
+            sessionResponse: null,
+            activeHandlers: {
+                onSessionUpdate: input.onSessionUpdate,
+                onClientRequest: input.onClientRequest
+            }
+        };
+        entry.client = new AcpClient(started.child, (params, message) => entry.activeHandlers?.onSessionUpdate(params, message), async (method, params, message) => {
+            if (!entry.activeHandlers?.onClientRequest)
+                throw new Error(`Unsupported ACP client request: ${method}`);
+            return entry.activeHandlers.onClientRequest(method, params, message);
+        });
+        started.child.once("close", () => {
+            if (this.runtimes.get(entry.key) === entry)
+                this.runtimes.delete(entry.key);
+            entry.disposed = true;
+            entry.inUse = false;
+            entry.activeHandlers = null;
+        });
+        return entry;
+    }
+    activateEntry(entry, input) {
+        if (entry.inUse) {
+            throw new Error(`ACP runtime is already in use: provider=${entry.providerId} session=${entry.providerSessionId ?? "unknown"}`);
+        }
+        entry.inUse = true;
+        entry.activeHandlers = {
+            onSessionUpdate: input.onSessionUpdate,
+            onClientRequest: input.onClientRequest
+        };
+    }
+    createLease(entry) {
+        let released = false;
+        return {
+            get client() {
+                return entry.client;
+            },
+            get started() {
+                return entry.started;
+            },
+            get cwd() {
+                return entry.cwd;
+            },
+            get providerSessionId() {
+                return entry.providerSessionId;
+            },
+            get sessionResponse() {
+                return entry.sessionResponse;
+            },
+            get initialized() {
+                return entry.initialized;
+            },
+            get sessionEstablished() {
+                return entry.sessionEstablished;
+            },
+            markInitialized: () => {
+                entry.initialized = true;
+            },
+            setProviderSession: (input) => {
+                entry.providerSessionId = input.providerSessionId;
+                entry.sessionEstablished = true;
+                if ("sessionResponse" in input)
+                    entry.sessionResponse = input.sessionResponse ?? null;
+                this.rekeyEntry(entry, runtimeKey(entry.providerId, entry.cwd, input.providerSessionId));
+            },
+            setSessionResponse: (sessionResponse) => {
+                entry.sessionResponse = sessionResponse;
+            },
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                entry.inUse = false;
+                entry.activeHandlers = null;
+                entry.lastUsedAtMs = Date.now();
+                void this.trimIdleRuntimes();
+            },
+            dispose: async () => {
+                released = true;
+                await this.disposeEntry(entry);
+            }
+        };
+    }
+    rekeyEntry(entry, nextKey) {
+        if (entry.key === nextKey)
+            return;
+        const previous = this.runtimes.get(nextKey);
+        if (previous && previous !== entry) {
+            if (previous.inUse) {
+                throw new Error(`ACP runtime key is already active: provider=${previous.providerId} session=${previous.providerSessionId ?? "unknown"}`);
+            }
+            void this.disposeEntry(previous);
+        }
+        if (this.runtimes.get(entry.key) === entry)
+            this.runtimes.delete(entry.key);
+        entry.key = nextKey;
+        this.runtimes.set(nextKey, entry);
+    }
+    async disposeEntry(entry) {
+        if (entry.disposePromise)
+            return entry.disposePromise;
+        if (entry.disposed)
+            return;
+        const promise = this.performDisposeEntry(entry);
+        entry.disposePromise = promise;
+        return promise;
+    }
+    async performDisposeEntry(entry) {
+        entry.disposed = true;
+        entry.inUse = false;
+        entry.activeHandlers = null;
+        if (this.runtimes.get(entry.key) === entry)
+            this.runtimes.delete(entry.key);
+        if (entry.providerSessionId) {
+            await entry.client.closeSession(entry.providerSessionId, 5_000).catch(() => void 0);
+        }
+        await closeAcpProcess(entry.started.child);
+    }
+    async trimIdleRuntimes() {
+        const idle = [...this.runtimes.values()]
+            .filter((entry) => !entry.inUse && !entry.disposed)
+            .sort((left, right) => left.lastUsedAtMs - right.lastUsedAtMs);
+        const excess = Math.max(0, idle.length - this.maxIdleRuntimes);
+        for (const entry of idle.slice(0, excess)) {
+            await this.disposeEntry(entry).catch(() => void 0);
+        }
+    }
+    isRuntimeAlive(entry) {
+        return !entry.disposed && entry.started.child.exitCode === null && entry.started.child.signalCode === null;
+    }
+    ensureSweep() {
+        if (this.sweepTimer)
+            return;
+        this.sweepTimer = setInterval(() => {
+            void this.sweepIdle();
+        }, this.sweepIntervalMs);
+        this.sweepTimer.unref();
+    }
+}
+export const defaultAcpRuntimePool = new AcpRuntimePool();
+function runtimeKey(providerId, cwd, providerSessionId) {
+    return `${providerId}\0${cwd}\0${providerSessionId}`;
+}
+function readRuntimePoolIdleTtlMs() {
+    const parsed = Number.parseInt(process.env.ACA_ACP_RUNTIME_IDLE_TTL_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 1_000 ? parsed : DEFAULT_IDLE_TTL_MS;
+}
+function readRuntimePoolSweepIntervalMs() {
+    const parsed = Number.parseInt(process.env.ACA_ACP_RUNTIME_SWEEP_INTERVAL_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 1_000 ? parsed : DEFAULT_SWEEP_INTERVAL_MS;
+}
+function readRuntimePoolMaxIdleRuntimes() {
+    const parsed = Number.parseInt(process.env.ACA_ACP_RUNTIME_MAX_IDLE ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 0 ? Math.min(parsed, 32) : DEFAULT_MAX_IDLE_RUNTIMES;
+}

package/dist/acp/client/context-usage.js

@@ -0,0 +1,29 @@
+import { acpSessionUpdateFromParams } from "./acp-events.js";
+/**
+ * Converts the standard ACP UsageUpdate shape into ACA's persisted session
+ * usage shape. ACP defines `used` as tokens currently in context and `size`
+ * as the model context-window size. Do not derive this from message length.
+ */
+export function contextUsageFromAcpSessionUpdate(params, fallbackContextWindow) {
+    const parsed = acpSessionUpdateFromParams(params);
+    if (!parsed || parsed.update.sessionUpdate !== "usage_update")
+        return null;
+    const usedTokens = nonNegativeNumber(parsed.update.used);
+    const reportedWindow = nonNegativeNumber(parsed.update.size);
+    const contextWindow = reportedWindow || nonNegativeNumber(fallbackContextWindow);
+    if (usedTokens <= 0 || contextWindow <= 0)
+        return null;
+    return {
+        usedTokens,
+        // ACP's standard update intentionally has no input-token breakdown.
+        inputTokens: usedTokens,
+        contextWindow,
+        ratio: Math.min(1, usedTokens / contextWindow),
+        observedAtMs: Date.now(),
+        state: "active",
+        maintenanceAction: null
+    };
+}
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}