@glubean/port 0.1.0 → 0.1.1

package/dist/providers/codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/providers/codex.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,cAAc,EAEd,aAAa,EAEb,kBAAkB,EAElB,SAAS,EACT,IAAI,EACJ,WAAW,EAGZ,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,KAAK,gBAAgB,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;AAEpD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,OAAO,CAwCpD,CAAC;AAEF,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAEvF;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAIrG;AAiPD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACpC,GAAG,SAAS,CAYZ"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/providers/codex.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,cAAc,EAEd,aAAa,EAEb,kBAAkB,EAElB,SAAS,EACT,IAAI,EACJ,WAAW,EAGZ,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,KAAK,gBAAgB,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;AAEpD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,OAAO,CAwCpD,CAAC;AAEF,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAEvF;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAIrG;AAuUD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACpC,GAAG,SAAS,CAYZ"}

package/dist/providers/codex.js

@@ -55,6 +55,13 @@ export async function createCodexAdapter(options) {
     await runtime.start();
     return runtime.adapter;
 }
+/**
+ * Cap stderr buffer to a bounded number of lines so a chatty codex
+ * process cannot grow memory unbounded over a long-lived session. The
+ * tail (most recent N lines) is what we surface in error messages —
+ * head lines from a healthy startup are rarely useful for diagnosis.
+ */
+const STDERR_BUFFER_MAX_LINES = 200;
 class CodexRuntime {
     #options;
     #process;
@@ -62,6 +69,17 @@ class CodexRuntime {
     #normalizer = new CodexEventNormalizer();
     #events = new EventEmitter();
     #closed = false;
+    /**
+     * Bounded ring buffer of recent codex stderr lines, surfaced in
+     * augmented error messages so a 30ms "JSON-RPC input closed" failure
+     * carries the actual codex stderr (auth error, bad flag, missing
+     * config, etc.) instead of disappearing into the void.
+     */
+    #stderrBuffer = [];
+    /** Captured at process 'exit' so subsequent rpc.request rejections can cite it. */
+    #exitInfo = null;
+    /** Captured at process 'error' (e.g. spawn ENOENT) for the same reason. */
+    #spawnError = null;
     constructor(options) {
         this.#options = options;
     }
@@ -104,27 +122,84 @@ class CodexRuntime {
             shell: false,
         });
         this.#process.stderr.on("data", (chunk) => {
-            const message = chunk.toString("utf8").trim();
-            if (message)
-                this.#emit({ type: "error", message });
+            const text = chunk.toString("utf8");
+            // Buffer stderr line-by-line so #augmentError can surface a
+            // bounded tail. We still emit the chunk as an error event so
+            // existing event-stream consumers aren't broken.
+            for (const line of text.split(/\r?\n/)) {
+                if (!line)
+                    continue;
+                this.#stderrBuffer.push(line);
+                if (this.#stderrBuffer.length > STDERR_BUFFER_MAX_LINES) {
+                    this.#stderrBuffer.splice(0, this.#stderrBuffer.length - STDERR_BUFFER_MAX_LINES);
+                }
+            }
+            const trimmed = text.trim();
+            if (trimmed)
+                this.#emit({ type: "error", message: trimmed });
         });
         this.#process.on("exit", (code, signal) => {
+            this.#exitInfo = { code, signal };
             if (!this.#closed) {
                 this.#emit({ type: "error", message: `Codex app-server exited: code=${code ?? "null"} signal=${signal ?? "null"}` });
             }
         });
+        // 'error' fires on spawn failures (e.g. ENOENT when codex binary is
+        // missing from PATH). Without a listener Node would crash the
+        // process on the unhandled emit; instead capture and let the
+        // pending rpc.request rejection surface the spawn error.
+        this.#process.on("error", (err) => {
+            this.#spawnError = err;
+            if (!this.#closed) {
+                this.#emit({ type: "error", message: `Codex app-server spawn error: ${err.message}` });
+            }
+        });
         this.#rpc = new JsonRpcLineConnection(this.#process.stdout, this.#process.stdin);
         this.#rpc.onNotification((notification) => {
             for (const event of this.#normalizer.normalize(notification)) {
                 this.#emit(event);
             }
         });
-        await this.#rpc.request("initialize", {
-            clientInfo: { name: "glubean-port", version: "0.0.0" },
-            capabilities: { experimentalApi: true },
-        });
+        try {
+            await this.#rpc.request("initialize", {
+                clientInfo: { name: "glubean-port", version: "0.0.0" },
+                capabilities: { experimentalApi: true },
+            });
+        }
+        catch (err) {
+            throw await this.#augmentError(err);
+        }
         this.#rpc.notify("initialized", {});
     }
+    /**
+     * Wrap an rpc rejection with codex process diagnostics so callers see
+     * (a) why the process closed if it did, (b) any spawn 'error' (e.g.
+     * ENOENT), and (c) the most recent stderr lines. The original error
+     * is preserved as `cause` for callers that introspect it.
+     *
+     * Awaits a microtask so any racing `process.on("exit")` fires before
+     * we read `#exitInfo` — JsonRpcLineConnection rejects synchronously
+     * from `input.on("close")`, but Node may fire stream 'close' before
+     * the matching process 'exit' on some versions.
+     */
+    async #augmentError(err) {
+        await new Promise((resolve) => setImmediate(resolve));
+        const original = err instanceof Error ? err : new Error(String(err));
+        const parts = [original.message];
+        if (this.#spawnError) {
+            parts.push(`(codex spawn error: ${this.#spawnError.message})`);
+        }
+        if (this.#exitInfo) {
+            parts.push(`(codex process exited: code=${this.#exitInfo.code ?? "null"} signal=${this.#exitInfo.signal ?? "null"})`);
+        }
+        if (this.#stderrBuffer.length > 0) {
+            const tail = this.#stderrBuffer.slice(-20).join("\n");
+            parts.push(`(codex stderr tail:\n${tail})`);
+        }
+        const augmented = new Error(parts.join(" "));
+        augmented.cause = original;
+        return augmented;
+    }
     async close() {
         this.#closed = true;
         this.#rpc?.close();
@@ -152,7 +227,14 @@ class CodexRuntime {
         });
         if (method === "thread/resume")
             params.threadId = input.id ?? "";
-        const result = asRecord(await rpc.request(method, params));
+        let rawResult;
+        try {
+            rawResult = await rpc.request(method, params);
+        }
+        catch (err) {
+            throw await this.#augmentError(err);
+        }
+        const result = asRecord(rawResult);
         const thread = asRecord(result.thread);
         const id = asString(thread.id) ?? input.id;
         if (!id)
@@ -183,18 +265,25 @@ class CodexRuntime {
             const runtimeOptions = resolveRuntimeOptions(input, this.#options.options);
             const codexOptions = providerRuntimeOptions(runtimeOptions);
             const effort = toCodexReasoningEffort(codexOptions.effort);
-            const result = asRecord(await rpc.request("turn/start", {
-                threadId: input.sessionId,
-                input: normalizeInput(input.input),
-                ...(runtimeOptions.cwd ? { cwd: runtimeOptions.cwd } : {}),
-                ...(runtimeOptions.model ? { model: runtimeOptions.model } : {}),
-                ...(runtimeOptions.approvalPolicy ? { approvalPolicy: runtimeOptions.approvalPolicy } : {}),
-                ...(runtimeOptions.sandbox ? { sandboxPolicy: toCodexSandboxPolicy(runtimeOptions.sandbox) } : {}),
-                ...(effort ? { effort } : {}),
-                ...(codexOptions?.reasoningSummary ? { summary: codexOptions.reasoningSummary } : {}),
-                ...(codexOptions?.serviceTier ? { serviceTier: codexOptions.serviceTier } : {}),
-                ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
-            }));
+            let rawResult;
+            try {
+                rawResult = await rpc.request("turn/start", {
+                    threadId: input.sessionId,
+                    input: normalizeInput(input.input),
+                    ...(runtimeOptions.cwd ? { cwd: runtimeOptions.cwd } : {}),
+                    ...(runtimeOptions.model ? { model: runtimeOptions.model } : {}),
+                    ...(runtimeOptions.approvalPolicy ? { approvalPolicy: runtimeOptions.approvalPolicy } : {}),
+                    ...(runtimeOptions.sandbox ? { sandboxPolicy: toCodexSandboxPolicy(runtimeOptions.sandbox) } : {}),
+                    ...(effort ? { effort } : {}),
+                    ...(codexOptions?.reasoningSummary ? { summary: codexOptions.reasoningSummary } : {}),
+                    ...(codexOptions?.serviceTier ? { serviceTier: codexOptions.serviceTier } : {}),
+                    ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
+                });
+            }
+            catch (err) {
+                throw await this.#augmentError(err);
+            }
+            const result = asRecord(rawResult);
             expectedTurnId = readTurnId(result);
             for await (const event of queue) {
                 yield event;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glubean/port",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Neutral runtime adapter for local coding agents.",
   "type": "module",
   "exports": {