@yuandc/aica 0.1.0

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

@@ -0,0 +1,128 @@
+export class JsonLineRpcClient {
+    child;
+    handlers;
+    nextId = 1;
+    lineBuffer = "";
+    pending = new Map();
+    peerName;
+    includeJsonRpc;
+    notifications = [];
+    stdout = "";
+    stderr = "";
+    exitCode = null;
+    signal = null;
+    constructor(child, handlers = {}) {
+        this.child = child;
+        this.handlers = handlers;
+        this.peerName = handlers.peerName || "JSON-RPC peer";
+        this.includeJsonRpc = handlers.includeJsonRpc === true;
+        child.stdout.on("data", (chunk) => this.handleStdout(String(chunk)));
+        child.stderr.on("data", (chunk) => {
+            this.stderr += String(chunk);
+        });
+        child.on("close", (code, signal) => {
+            this.exitCode = code;
+            this.signal = signal;
+            for (const [id, pending] of this.pending) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error(`${this.peerName} exited before ${pending.method} completed (code=${code}, signal=${signal})`));
+                this.pending.delete(id);
+            }
+        });
+        child.on("error", (error) => {
+            for (const [id, pending] of this.pending) {
+                clearTimeout(pending.timer);
+                pending.reject(error);
+                this.pending.delete(id);
+            }
+        });
+    }
+    request(method, params, timeoutMs = 120_000) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = this.createRequestTimeout(id, method, timeoutMs, reject);
+            timer.unref();
+            this.pending.set(id, { method, resolve, reject, timer, timeoutMs });
+            this.write({ ...(this.includeJsonRpc ? { jsonrpc: "2.0" } : {}), id, method, ...(params === undefined ? {} : { params }) });
+        });
+    }
+    notify(method, params) {
+        this.write({ ...(this.includeJsonRpc ? { jsonrpc: "2.0" } : {}), method, ...(params === undefined ? {} : { params }) });
+    }
+    refreshPendingRequestTimeout(method) {
+        for (const [id, pending] of this.pending) {
+            if (pending.method !== method)
+                continue;
+            clearTimeout(pending.timer);
+            pending.timer = this.createRequestTimeout(id, pending.method, pending.timeoutMs, pending.reject);
+            pending.timer.unref();
+        }
+    }
+    respond(id, result) {
+        this.write({ ...(this.includeJsonRpc ? { jsonrpc: "2.0" } : {}), id, result });
+    }
+    respondError(id, error) {
+        this.write({ ...(this.includeJsonRpc ? { jsonrpc: "2.0" } : {}), id, error: { code: -32603, message: error.message } });
+    }
+    createRequestTimeout(id, method, timeoutMs, reject) {
+        return setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`${this.peerName} request timed out while waiting for ${method}`));
+        }, timeoutMs);
+    }
+    handleStdout(chunk) {
+        this.stdout += chunk;
+        this.lineBuffer += chunk;
+        const lines = this.lineBuffer.split("\n");
+        this.lineBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                this.stderr += `\n[non-json stdout] ${trimmed}`;
+                continue;
+            }
+            void this.handleMessage(message);
+        }
+    }
+    async handleMessage(message) {
+        if ("id" in message && ("result" in message || "error" in message) && typeof message.method !== "string") {
+            const id = Number(message.id);
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            if ("error" in message) {
+                const error = message.error;
+                pending.reject(new Error(error?.message || `${this.peerName} error ${error?.code ?? "unknown"}`));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (typeof message.method !== "string")
+            return;
+        if ("id" in message) {
+            try {
+                const result = await this.handlers.onRequest?.(message.method, message.params, message);
+                this.respond(message.id, result ?? null);
+            }
+            catch (error) {
+                this.respondError(message.id, error instanceof Error ? error : new Error(String(error)));
+            }
+            return;
+        }
+        this.notifications.push(message);
+        await this.handlers.onNotification?.(message.method, message.params, message);
+    }
+    write(message) {
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+}

package/dist/acp/provider-types.js

@@ -0,0 +1 @@
+export {};

package/dist/acp/providers/codex/codex-process.js

@@ -0,0 +1,51 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { acpChildEnvironment } from "../../../core/process-identity.js";
+export function startCodexAppServer(cwd) {
+    const command = resolveCodexPath();
+    const args = ["app-server", "--stdio"];
+    const child = spawn(command, args, {
+        cwd,
+        env: acpChildEnvironment({ CODEX_PATH: command }),
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    return { command, args, child };
+}
+export function resolveCodexPath() {
+    const explicit = process.env.CODEX_PATH;
+    if (explicit?.trim() && !isNodeWrapperCodexPath(explicit))
+        return explicit;
+    const nativeCandidates = [
+        "/usr/local/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/bin/codex"
+    ];
+    const native = nativeCandidates.find((candidate) => isExecutableFile(candidate));
+    if (native)
+        return native;
+    const fallbackCandidates = [
+        ...(explicit?.trim() ? [explicit] : []),
+        "/usr/local/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/bin/codex",
+        "/usr/local/bin/codex",
+        "codex"
+    ];
+    return fallbackCandidates.find((candidate) => candidate === "codex" || isExecutableFile(candidate)) ?? "codex";
+}
+function isExecutableFile(filePath) {
+    try {
+        fs.accessSync(filePath, fs.constants.X_OK);
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isNodeWrapperCodexPath(filePath) {
+    try {
+        const realPath = fs.realpathSync(filePath);
+        return realPath.endsWith(".js");
+    }
+    catch {
+        return false;
+    }
+}