@yuandc/aica 0.1.0

package/dist/acp/providers/codex/permissions.js

@@ -0,0 +1,49 @@
+export async function resolveCodexApprovalRequest(method, params, callback) {
+    const options = approvalOptionsForMethod(method);
+    if (callback) {
+        const response = await callback({
+            requestId: `perm-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+            params,
+            options
+        });
+        return codexApprovalResponse(method, response.outcome.outcome === "selected");
+    }
+    return codexApprovalResponse(method, false);
+}
+export function isCodexApprovalRequest(method) {
+    return method === "item/commandExecution/requestApproval"
+        || method === "item/fileChange/requestApproval"
+        || method === "item/permissions/requestApproval"
+        || method === "execCommandApproval"
+        || method === "applyPatchApproval";
+}
+function approvalOptionsForMethod(method) {
+    if (method === "item/permissions/requestApproval") {
+        return [
+            { optionId: "allow", kind: "allow", label: "允许" },
+            { optionId: "deny", kind: "reject", label: "拒绝" }
+        ];
+    }
+    return [
+        { optionId: "accept", kind: "allow", label: "允许" },
+        { optionId: "decline", kind: "reject", label: "拒绝" }
+    ];
+}
+function codexApprovalResponse(method, allowed) {
+    switch (method) {
+        case "item/commandExecution/requestApproval":
+            return { decision: allowed ? "accept" : "decline" };
+        case "item/fileChange/requestApproval":
+            return { decision: allowed ? "accept" : "decline" };
+        case "item/permissions/requestApproval":
+            return allowed
+                ? { permissions: {}, scope: "turn" }
+                : { permissions: {}, scope: "turn", strictAutoReview: true };
+        case "execCommandApproval":
+            return { decision: allowed ? "approved" : "denied" };
+        case "applyPatchApproval":
+            return { decision: allowed ? "approved" : "denied" };
+        default:
+            return {};
+    }
+}

package/dist/acp/providers/codex/provider.js

@@ -0,0 +1,376 @@
+import fs from "node:fs";
+import { JsonLineRpcClient } from "../../client/json-rpc.js";
+import { startCodexAppServer } from "./codex-process.js";
+import { extractAssistantTextFromTurn, mapCodexNotification } from "./events.js";
+import { isCodexApprovalRequest, resolveCodexApprovalRequest } from "./permissions.js";
+const CANCEL_INTERRUPT_TIMEOUT_MS = 1_500;
+export const nativeCodexCapabilities = {
+    sessionResume: true,
+    imageInput: true,
+    fileAttachment: true,
+    filesystem: true,
+    terminal: true,
+    permissionRequest: true,
+    configOptions: true,
+    usage: true,
+    contextUsage: true,
+    contextCompaction: true,
+    plan: true,
+    diff: true
+};
+export class NativeCodexProvider {
+    id = "native-codex";
+    name = "Native Codex";
+    capabilities = nativeCodexCapabilities;
+    async createSession(input) {
+        return new NativeCodexSession(input.cwd, input.providerSessionId ?? null, input.timeoutMs);
+    }
+}
+class NativeCodexSession {
+    cwd;
+    providerSessionId;
+    defaultTimeoutMs;
+    started;
+    rpc;
+    initialized = false;
+    content = "";
+    promptActive = false;
+    updates = [];
+    statusTimeline = [];
+    statusCallback = null;
+    updateCallback = null;
+    permissionCallback = null;
+    abortHandler = null;
+    completedTurns = new Map();
+    pendingTurnCompletions = new Map();
+    agentMessagePhases = new Map();
+    constructor(cwd, providerSessionId, defaultTimeoutMs = readAcpPromptTimeoutMs()) {
+        this.cwd = cwd;
+        this.providerSessionId = providerSessionId;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        this.started = startCodexAppServer(cwd);
+        this.rpc = new JsonLineRpcClient(this.started.child, {
+            onNotification: (method, params) => this.handleNotification(method, params),
+            onRequest: (method, params) => this.handleReverseRequest(method, params)
+        });
+    }
+    async sendPrompt(input) {
+        const startedAt = Date.now();
+        const effectiveConfig = codexAccessConfigFromMode(input.mode);
+        this.statusCallback = input.onStatus ?? null;
+        this.updateCallback = input.onUpdate ?? null;
+        this.permissionCallback = input.onPermissionRequest ?? null;
+        this.attachAbortSignal(input.signal);
+        this.emitStatus("initializing", "Codex 初始化中", "initialize");
+        await this.initialize();
+        const threadId = await this.establishThread(input);
+        this.emitStatus("thinking", "思考中");
+        this.content = "";
+        this.updates.length = 0;
+        this.agentMessagePhases.clear();
+        this.promptActive = true;
+        let promptResponse;
+        let turn;
+        try {
+            promptResponse = await this.rpc.request("turn/start", {
+                threadId,
+                clientUserMessageId: `aca-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                input: promptBlocksToCodexInput(input.prompt, input.promptBlocks),
+                cwd: input.cwd,
+                ...(input.model ? { model: input.model } : {}),
+                ...turnConfigFromOptions(input.configOptionValues)
+            }, input.timeoutMs ?? this.defaultTimeoutMs);
+            const turnId = String(promptResponse?.turn?.id ?? "");
+            turn = turnId
+                ? await this.waitForTurnCompleted(turnId, input.timeoutMs ?? this.defaultTimeoutMs)
+                : promptResponse?.turn;
+        }
+        finally {
+            this.promptActive = false;
+        }
+        const finalContent = this.content.trim() || extractAssistantTextFromTurn(turn);
+        this.emitStatus("completed", "已完成");
+        return {
+            providerSessionId: threadId,
+            cliType: "builtin",
+            agentType: "codex",
+            effectiveConfig,
+            command: this.started.command,
+            args: this.started.args,
+            cwd: this.cwd,
+            exitCode: this.rpc.exitCode,
+            signal: this.rpc.signal,
+            durationMs: Date.now() - startedAt,
+            stdout: this.rpc.stdout,
+            stderr: this.rpc.stderr,
+            content: finalContent,
+            updates: this.updates,
+            statusTimeline: this.statusTimeline,
+            promptResponse
+        };
+    }
+    async cancel() {
+        try {
+            if (this.providerSessionId && this.started.child.exitCode === null && this.started.child.signalCode === null) {
+                await this.rpc.request("turn/interrupt", { threadId: this.providerSessionId }, CANCEL_INTERRUPT_TIMEOUT_MS).catch(() => void 0);
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+    async close() {
+        this.statusCallback = null;
+        this.updateCallback = null;
+        this.permissionCallback = null;
+        for (const pending of this.pendingTurnCompletions.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Codex app-server session closed"));
+        }
+        this.pendingTurnCompletions.clear();
+        if (this.abortHandler)
+            this.abortHandler = null;
+        await this.closeCodexProcess();
+    }
+    async closeCodexProcess() {
+        if (this.started.child.exitCode !== null || this.started.child.signalCode !== null)
+            return;
+        this.started.child.stdin.end();
+        if (await this.waitForProcessClose(2_000))
+            return;
+        this.started.child.kill("SIGTERM");
+        if (await this.waitForProcessClose(1_000))
+            return;
+        this.started.child.kill("SIGKILL");
+        await this.waitForProcessClose(1_000);
+    }
+    waitForProcessClose(timeoutMs) {
+        if (this.started.child.exitCode !== null || this.started.child.signalCode !== null)
+            return Promise.resolve(true);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(false), timeoutMs);
+            timer.unref();
+            this.started.child.once("close", () => {
+                clearTimeout(timer);
+                resolve(true);
+            });
+        });
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.rpc.request("initialize", {
+            clientInfo: { name: "aca", version: "0.1.0" },
+            capabilities: {
+                experimentalApi: true,
+                requestAttestation: false
+            }
+        });
+        this.initialized = true;
+    }
+    async establishThread(input) {
+        const accessConfig = codexAccessConfigFromMode(input.mode);
+        if (this.providerSessionId) {
+            try {
+                this.emitStatus("resuming", "Codex 会话恢复中", "thread/resume");
+                const resumed = await this.rpc.request("thread/resume", {
+                    threadId: this.providerSessionId,
+                    cwd: input.cwd,
+                    ...(input.model ? { model: input.model } : {}),
+                    approvalsReviewer: "user",
+                    ...accessConfig
+                }, 60_000);
+                this.providerSessionId = String(resumed?.thread?.id ?? this.providerSessionId);
+                return this.providerSessionId;
+            }
+            catch {
+                this.providerSessionId = null;
+            }
+        }
+        this.emitStatus("acp", "Codex 启动中", "thread/start");
+        const created = await this.rpc.request("thread/start", {
+            cwd: input.cwd,
+            ...(input.model ? { model: input.model } : {}),
+            approvalsReviewer: "user",
+            ...accessConfig,
+            ephemeral: false,
+            threadSource: "aca"
+        }, 60_000);
+        const threadId = created?.thread?.id;
+        if (!threadId)
+            throw new Error("Codex app-server thread/start did not return thread id");
+        this.providerSessionId = threadId;
+        return threadId;
+    }
+    attachAbortSignal(signal) {
+        if (!signal)
+            return;
+        this.abortHandler = () => {
+            void this.cancel();
+        };
+        if (signal.aborted)
+            throw new Error("ACP prompt cancelled");
+        signal.addEventListener("abort", this.abortHandler, { once: true });
+    }
+    handleNotification(method, params) {
+        if (!this.promptActive && !shouldHandleIdleCodexNotification(method))
+            return;
+        this.rpc.refreshPendingRequestTimeout("turn/start");
+        this.updates.push({ method, params });
+        this.captureAgentMessagePhase(method, params);
+        this.appendFinalAnswerDelta(method, params);
+        if (method === "turn/completed") {
+            this.resolveTurnCompleted(params);
+        }
+        mapCodexNotification(method, params, {
+            pushUpdate: (event) => this.updateCallback?.(event),
+            pushStatus: (phase, label, detail, updateType) => this.emitStatus(phase, label, detail, updateType)
+        }, { agentMessagePhases: this.agentMessagePhases });
+    }
+    captureAgentMessagePhase(method, params) {
+        if (method !== "item/started" && method !== "item/completed")
+            return;
+        const item = params?.item;
+        if (item?.type !== "agentMessage" || !item.id)
+            return;
+        this.agentMessagePhases.set(item.id, item.phase ?? "");
+    }
+    appendFinalAnswerDelta(method, params) {
+        if (method !== "item/agentMessage/delta")
+            return;
+        const deltaParams = params;
+        if (!deltaParams.itemId || typeof deltaParams.delta !== "string")
+            return;
+        const phase = this.agentMessagePhases.get(deltaParams.itemId);
+        if (phase === "final_answer" || !phase) {
+            this.content += deltaParams.delta;
+        }
+    }
+    waitForTurnCompleted(turnId, timeoutMs) {
+        const completed = this.completedTurns.get(turnId);
+        if (completed)
+            return Promise.resolve(completed);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingTurnCompletions.delete(turnId);
+                reject(new Error(`Codex app-server request timed out while waiting for turn/completed`));
+            }, timeoutMs);
+            timer.unref();
+            this.pendingTurnCompletions.set(turnId, { resolve, reject, timer });
+        });
+    }
+    resolveTurnCompleted(params) {
+        const turn = params?.turn;
+        const turnId = turn?.id;
+        if (!turnId)
+            return;
+        this.completedTurns.set(turnId, turn);
+        const pending = this.pendingTurnCompletions.get(turnId);
+        if (!pending)
+            return;
+        this.pendingTurnCompletions.delete(turnId);
+        clearTimeout(pending.timer);
+        if (turn.status === "failed") {
+            pending.reject(new Error(`Codex turn failed: ${JSON.stringify(turn.error ?? {})}`));
+            return;
+        }
+        pending.resolve(turn);
+    }
+    async handleReverseRequest(method, params) {
+        if (isCodexApprovalRequest(method)) {
+            this.emitStatus("requestPermission", "等待授权", summarizeRequest(params), method);
+            return resolveCodexApprovalRequest(method, params, this.permissionCallback);
+        }
+        return {};
+    }
+    emitStatus(phase, label, detail, updateType) {
+        const status = {
+            phase,
+            label,
+            ...(detail ? { detail } : {}),
+            ...(updateType ? { updateType } : {}),
+            atMs: Date.now()
+        };
+        const last = this.statusTimeline[this.statusTimeline.length - 1];
+        if (last && last.phase === status.phase && last.label === status.label && last.detail === status.detail && last.updateType === status.updateType)
+            return;
+        this.statusTimeline.push(status);
+        this.statusCallback?.(status);
+    }
+}
+function promptBlocksToCodexInput(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: "localImage", path: block.uri };
+            return { type: "image", url: `data:${block.mimeType};base64,${block.data}` };
+        }
+        return { type: "text", text: block.text, text_elements: [] };
+    });
+}
+function codexAccessConfigFromMode(mode) {
+    const normalized = String(mode || "").trim();
+    if (normalized === "read-only") {
+        return {
+            approvalPolicy: "on-request",
+            sandbox: "read-only"
+        };
+    }
+    if (normalized === "acceptEdits" || normalized === "accept-edits") {
+        return {
+            approvalPolicy: "on-failure",
+            sandbox: "workspace-write"
+        };
+    }
+    if (["agent-full-access", "full-access", "bypassPermissions", "danger-full-access"].includes(normalized)) {
+        return {
+            approvalPolicy: "never",
+            sandbox: "danger-full-access"
+        };
+    }
+    return {
+        approvalPolicy: "on-request",
+        sandbox: "workspace-write"
+    };
+}
+function turnConfigFromOptions(values) {
+    if (!values)
+        return {};
+    const result = {};
+    const effort = values.reasoningEffort ?? values["model_reasoning_effort"];
+    if (typeof effort === "string" && effort)
+        result.effort = effort;
+    return result;
+}
+function summarizeRequest(params) {
+    if (!params || typeof params !== "object" || Array.isArray(params))
+        return undefined;
+    const record = params;
+    for (const key of ["command", "cwd", "reason", "grantRoot"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return textPreview(value);
+    }
+    return undefined;
+}
+function textPreview(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+function shouldHandleIdleCodexNotification(method) {
+    if (method.startsWith("thread/"))
+        return true;
+    return [
+        "account/rateLimits/updated",
+        "account/updated",
+        "configWarning",
+        "warning",
+        "model/rerouted",
+        "thread/compacted"
+    ].includes(method);
+}
+function readAcpPromptTimeoutMs() {
+    const parsed = Number.parseInt(process.env.ACA_ACP_PROMPT_TIMEOUT_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 30_000 ? parsed : 6 * 60 * 60 * 1000;
+}