@rynx-ai/runtime 0.1.0 → 0.1.9

package/dist/codex-app-server/transport.js

@@ -67,6 +67,9 @@ export class CodexTransportError extends Error {
         this.data = data;
     }
 }
+/** A server request was resolved by another app-server client. In that case the
+ * local handler must settle without sending a second JSON-RPC response. */
+export const NO_SERVER_RESPONSE = Symbol("NO_SERVER_RESPONSE");
 /**
  * Wraps the Codex `app-server` subprocess and exposes a typed JSON-RPC API
  * over its stdio. Frames are line-delimited NDJSON (no Content-Length
@@ -88,6 +91,7 @@ export class CodexAppServerTransport extends EventEmitter {
     logger;
     onServerRequest;
     onNotification;
+    onServerRequestResponseDelivery;
     child = null;
     rl = null;
     stderrRl = null;
@@ -95,7 +99,7 @@ export class CodexAppServerTransport extends EventEmitter {
     pending = new Map();
     startPromise = null;
     exited = false;
-    constructor({ spawner, channel, logger = defaultLogger, onServerRequest, onNotification, }) {
+    constructor({ spawner, channel, logger = defaultLogger, onServerRequest, onNotification, onServerRequestResponseDelivery, }) {
         super();
         if (!spawner && !channel) {
             throw new Error("CodexAppServerTransport requires a spawner or a channel");
@@ -105,6 +109,7 @@ export class CodexAppServerTransport extends EventEmitter {
         this.logger = logger;
         this.onServerRequest = onServerRequest;
         this.onNotification = onNotification;
+        this.onServerRequestResponseDelivery = onServerRequestResponseDelivery;
     }
     emit(event, ...args) {
         return super.emit(event, ...args);
@@ -145,39 +150,46 @@ export class CodexAppServerTransport extends EventEmitter {
     async sendRequest(method, params) {
         await this.ensureStarted();
         const id = this.nextId++;
-        return await new Promise((resolve, reject) => {
+        const envelope = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            ...(params === undefined ? {} : { params }),
+        };
+        let rejectResponse;
+        const response = new Promise((resolve, reject) => {
+            rejectResponse = reject;
             this.pending.set(id, {
                 resolve: resolve,
                 reject,
                 method,
             });
-            const envelope = {
-                jsonrpc: "2.0",
-                id,
-                method,
-                ...(params === undefined ? {} : { params }),
-            };
-            try {
-                this.writeLine(envelope);
-            }
-            catch (error) {
-                this.pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
         });
+        try {
+            await this.writeLine(envelope);
+        }
+        catch (error) {
+            this.pending.delete(id);
+            rejectResponse(error instanceof Error ? error : new Error(String(error)));
+        }
+        return await response;
     }
-    sendNotification(method, params) {
+    async sendNotification(method, params) {
         const envelope = {
             jsonrpc: "2.0",
             method,
             ...(params === undefined ? {} : { params }),
         };
-        this.writeLine(envelope);
+        await this.writeLine(envelope);
     }
     async stop(signal = "SIGTERM") {
         if (this.channel) {
-            this.exited = true;
             await this.channel.stop(signal);
+            // Channel implementations may report close asynchronously (or not at all).
+            // Run the same exit path synchronously so pending RPCs reject and clients
+            // clear pending native interactions before stop() resolves.
+            if (!this.exited)
+                this.handleExit(null, signal, null);
             return;
         }
         const child = this.child;
@@ -268,25 +280,29 @@ export class CodexAppServerTransport extends EventEmitter {
         });
         this.emit("exit", code, signal);
     }
-    writeLine(envelope) {
+    async writeLine(envelope) {
         const line = `${JSON.stringify(envelope)}\n`;
         if (this.channel) {
             if (this.exited) {
                 throw new CodexTransportError("Codex app-server is not running");
             }
-            this.channel.send(line);
+            await this.channel.send(line);
             return;
         }
         const child = this.child;
         if (!child || this.exited) {
             throw new CodexTransportError("Codex app-server is not running");
         }
-        const ok = child.stdin.write(line);
-        if (!ok) {
-            // Don't block — back-pressure on stdin is unlikely with line-sized
-            // messages, but we surface it as a log entry if it ever shows up.
-            this.logger.log({ event: "transport.stdin_backpressure" });
-        }
+        await new Promise((resolve, reject) => {
+            const ok = child.stdin.write(line, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+            if (!ok)
+                this.logger.log({ event: "transport.stdin_backpressure" });
+        });
     }
     handleLine(line) {
         if (!line.trim()) {
@@ -352,34 +368,71 @@ export class CodexAppServerTransport extends EventEmitter {
     }
     async handleServerRequest(envelope) {
         if (!this.onServerRequest) {
-            this.respondToServerRequest(envelope.id, undefined, {
-                code: -32601,
-                message: `No handler registered for ${envelope.method}`,
-            });
+            try {
+                await this.respondToServerRequest(envelope.id, undefined, {
+                    code: -32601,
+                    message: `No handler registered for ${envelope.method}`,
+                });
+            }
+            catch (error) {
+                this.logger.log({
+                    event: "transport.server_request_error_write_failed",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
             return;
         }
+        let result;
         try {
-            const result = await this.onServerRequest(envelope.method, envelope.params);
-            this.respondToServerRequest(envelope.id, result, null);
+            result = await this.onServerRequest(envelope.method, envelope.params, envelope.id);
         }
         catch (error) {
-            this.respondToServerRequest(envelope.id, undefined, {
-                code: -32000,
-                message: error instanceof Error ? error.message : String(error),
+            try {
+                await this.respondToServerRequest(envelope.id, undefined, {
+                    code: -32000,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            catch (writeError) {
+                this.logger.log({
+                    event: "transport.server_request_error_write_failed",
+                    error: writeError instanceof Error ? writeError.message : String(writeError),
+                });
+            }
+            return;
+        }
+        if (result === NO_SERVER_RESPONSE)
+            return;
+        try {
+            await this.respondToServerRequest(envelope.id, result, null);
+            this.notifyServerRequestResponseDelivery(envelope.id, { delivered: true });
+        }
+        catch (writeError) {
+            const error = writeError instanceof Error ? writeError : new Error(String(writeError));
+            this.logger.log({
+                event: "transport.server_request_write_failed",
+                error: error.message,
+            });
+            this.notifyServerRequestResponseDelivery(envelope.id, {
+                delivered: false,
+                error,
             });
         }
     }
-    respondToServerRequest(id, result, error) {
+    async respondToServerRequest(id, result, error) {
         const envelope = error
             ? { jsonrpc: "2.0", id, error }
             : { jsonrpc: "2.0", id, result };
+        await this.writeLine(envelope);
+    }
+    notifyServerRequestResponseDelivery(requestId, result) {
         try {
-            this.writeLine(envelope);
+            this.onServerRequestResponseDelivery?.(requestId, result);
         }
-        catch (writeError) {
+        catch (error) {
             this.logger.log({
-                event: "transport.server_request_write_failed",
-                error: writeError instanceof Error ? writeError.message : String(writeError),
+                event: "transport.server_request_delivery_handler_failed",
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }

package/dist/codex-app-server/ws-channel.d.ts

@@ -28,7 +28,7 @@ export declare class WsRpcChannel implements RpcChannel {
     }) => void): void;
     isOpen(): boolean;
     start(): Promise<void>;
-    send(line: string): void;
+    send(line: string): Promise<void>;
     stop(signal?: NodeJS.Signals): Promise<void>;
     private emitClose;
     private connectWithRetry;
@@ -37,7 +37,7 @@ export declare class WsRpcChannel implements RpcChannel {
 /**
  * Connect-only {@link RpcChannel}: attaches an ADDITIONAL client to an app-server
  * someone else already started (a {@link WsRpcChannel}'s `url`) — no spawn. This
- * is how rynx runs omnigent's multi-connection codex-native model: the backend
+ * is how rynx runs reference implementation's multi-connection codex-native model: the backend
  * client owns the app-server + drives injection, while a SEPARATE forwarder
  * connection `thread/resume`s the same thread to subscribe to its item/turn
  * notifications (verified: codex delivers a thread's items to every connection
@@ -65,7 +65,7 @@ export declare class ExternalWsChannel implements RpcChannel {
     }) => void): void;
     isOpen(): boolean;
     start(): Promise<void>;
-    send(line: string): void;
+    send(line: string): Promise<void>;
     stop(): Promise<void>;
     private emitClose;
     private connect;

package/dist/codex-app-server/ws-channel.js

@@ -2,13 +2,13 @@
  * WebSocket {@link RpcChannel} for a codex `app-server --listen ws://IP:PORT`.
  *
  * Why a WebSocket and not the default stdio: stdio admits exactly one client
- * (the process that spawned it), so it cannot be co-driven. omnigent's working
+ * (the process that spawned it), so it cannot be co-driven. reference implementation's working
  * codex-native uses a multi-client transport (ws / uds) so a separate `codex
  * --remote` TUI can attach to the SAME app-server and resume the SAME thread.
  * This channel owns that app-server child on a loopback ws port and connects a
  * client to it; the TUI attaches to {@link WsRpcChannel.url}.
  *
- * Framing matches codex (verified from omnigent): one JSON-RPC object per
+ * Framing matches codex (verified from reference implementation): one JSON-RPC object per
  * WebSocket text frame — no newline delimiting. So `send` writes one frame per
  * message and every inbound frame is one complete JSON object.
  */
@@ -69,12 +69,20 @@ export class WsRpcChannel {
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
         this.ws.on("error", (error) => this.emitClose(null, null, error));
     }
-    send(line) {
+    async send(line) {
         if (this.ws?.readyState !== WebSocket.OPEN) {
             throw new Error("codex ws channel is not open");
         }
         // Codex expects one JSON object per frame; drop the NDJSON newline.
-        this.ws.send(line.endsWith("\n") ? line.slice(0, -1) : line);
+        const payload = line.endsWith("\n") ? line.slice(0, -1) : line;
+        await new Promise((resolve, reject) => {
+            this.ws.send(payload, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
     }
     async stop(signal = "SIGTERM") {
         try {
@@ -140,7 +148,7 @@ export class WsRpcChannel {
 /**
  * Connect-only {@link RpcChannel}: attaches an ADDITIONAL client to an app-server
  * someone else already started (a {@link WsRpcChannel}'s `url`) — no spawn. This
- * is how rynx runs omnigent's multi-connection codex-native model: the backend
+ * is how rynx runs reference implementation's multi-connection codex-native model: the backend
  * client owns the app-server + drives injection, while a SEPARATE forwarder
  * connection `thread/resume`s the same thread to subscribe to its item/turn
  * notifications (verified: codex delivers a thread's items to every connection
@@ -189,11 +197,19 @@ export class ExternalWsChannel {
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
         this.ws.on("error", (error) => this.emitClose(null, null, error));
     }
-    send(line) {
+    async send(line) {
         if (this.ws?.readyState !== WebSocket.OPEN) {
             throw new Error("external codex ws channel is not open");
         }
-        this.ws.send(line.endsWith("\n") ? line.slice(0, -1) : line);
+        const payload = line.endsWith("\n") ? line.slice(0, -1) : line;
+        await new Promise((resolve, reject) => {
+            this.ws.send(payload, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
     }
     async stop() {
         try {

package/dist/codex-child-env.js

@@ -6,6 +6,14 @@ const CODEX_CHILD_ENV_ALLOWLIST = [
     "TMPDIR",
     "CODEX_HOME",
     "TRAE_HOME",
+    // Keep Runtime-local CLIs on the same resident daemon when its state root is
+    // configured outside the default ~/.rynx location.
+    "RYNX_HOME",
+    // RunnerManager supplies this rotation-safe handle for the exact managed
+    // Session. Codex command executions need it to call their own Runtime
+    // Browser; the raw Browser capability and internal runner key stay outside
+    // the allowlist.
+    "RYNX_BROWSER_CONTEXT_FILE",
     "HTTP_PROXY",
     "HTTPS_PROXY",
     "ALL_PROXY",
@@ -15,6 +23,24 @@ const CODEX_CHILD_ENV_ALLOWLIST = [
     "all_proxy",
     "no_proxy",
 ];
+const PROXY_ENV_KEYS = [
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy",
+];
+const LOOPBACK_NO_PROXY_HOSTS = ["localhost", "127.0.0.1", "::1"];
+function withLoopbackNoProxy(value) {
+    const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean) ?? [];
+    const seen = new Set(entries.map((entry) => entry.toLowerCase()));
+    for (const host of LOOPBACK_NO_PROXY_HOSTS) {
+        if (!seen.has(host))
+            entries.push(host);
+    }
+    return entries.join(",");
+}
 export function createCodexChildEnv(env) {
     const childEnv = {};
     for (const key of CODEX_CHILD_ENV_ALLOWLIST) {
@@ -23,5 +49,12 @@ export function createCodexChildEnv(env) {
             childEnv[key] = value;
         }
     }
+    if (childEnv.NO_PROXY || childEnv.no_proxy || PROXY_ENV_KEYS.some((key) => childEnv[key])) {
+        const upper = childEnv.NO_PROXY ?? childEnv.no_proxy;
+        const lower = childEnv.no_proxy ?? childEnv.NO_PROXY;
+        // CIDR matching in NO_PROXY varies; Codex's WebSocket client needs exact loopback hosts.
+        childEnv.NO_PROXY = withLoopbackNoProxy(upper);
+        childEnv.no_proxy = withLoopbackNoProxy(lower);
+    }
     return childEnv;
 }

package/dist/codex-home.d.ts

@@ -1,6 +1,6 @@
 /**
  * The deterministic private CODEX_HOME path for a rynx session. PER-SESSION
- * (uid-scoped + `sha256(sessionId)[:32]`), mirroring omnigent's per-session
+ * (uid-scoped + `sha256(sessionId)[:32]`), mirroring reference implementation's per-session
  * `bridge_dir/codex-home` and rynx's own `claudeBridgeDir`. Pure — computes the
  * path without touching disk, so the daemon (rollout-synth) and the runner child
  * (app-server) both locate the SAME session's home from `sessionId` alone.
@@ -14,17 +14,17 @@ export declare function legacyCodexHomePath(): string;
  * `auth.json`) and settings (copied `config.toml`) but NOT the real home's pending
  * update / first-run (NUX) state — so a co-driven `codex` app-server + `--remote`
  * TUI never block on an "Update now / Press enter to continue" prompt (which would
- * wedge terminal injection). Ports omnigent's `_CODEX_HOME_SYMLINK_FILES` /
+ * wedge terminal injection). Ports reference implementation's `_CODEX_HOME_SYMLINK_FILES` /
  * `_CODEX_HOME_COPY_FILES`.
  *
- * PER-SESSION: one private home per rynx session (matching omnigent), so concurrent
+ * PER-SESSION: one private home per rynx session (matching reference implementation), so concurrent
  * agents never share a `skills/` dir. Idempotent: the symlink/copy are refreshed each
  * call so a re-login/config change propagates. Returns the private home dir.
  */
 export declare function prepareCodexHome(sessionId: string, realHome?: string): string;
 /**
  * Link a resolved skill set into `<codexHome>/skills/<name>/` so the native Codex
- * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism omnigent
+ * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism reference implementation
  * uses (`populate_codex_skills_from_bundle` → `_populate_codex_skills`), NOT a
  * `<skills_instructions>` block injected into the prompt. Codex's app-server
  * watches this dir and re-scans on change, so a live `codex --remote` TUI — whose
@@ -32,9 +32,9 @@ export declare function prepareCodexHome(sessionId: string, realHome?: string):
  * — still sees the agent's skills.
  *
  * Each skill is a symlink to its source dir; a filesystem without symlink support
- * falls back to a recursive copy (matches omnigent's fallback).
+ * falls back to a recursive copy (matches reference implementation's fallback).
  *
- * omnigent boots a fresh per-session CODEX_HOME, so it only ever links into an
+ * reference implementation boots a fresh per-session CODEX_HOME, so it only ever links into an
  * empty dir. rynx shares ONE private home per runtime (see {@link prepareCodexHome}),
  * so this CONVERGES the dir to `skills`: it links the missing ones and removes
  * entries no longer selected, honouring the agent spec's gating. (Concurrent

package/dist/codex-home.js

@@ -17,7 +17,7 @@ function rynxUidRoot() {
 }
 /**
  * The deterministic private CODEX_HOME path for a rynx session. PER-SESSION
- * (uid-scoped + `sha256(sessionId)[:32]`), mirroring omnigent's per-session
+ * (uid-scoped + `sha256(sessionId)[:32]`), mirroring reference implementation's per-session
  * `bridge_dir/codex-home` and rynx's own `claudeBridgeDir`. Pure — computes the
  * path without touching disk, so the daemon (rollout-synth) and the runner child
  * (app-server) both locate the SAME session's home from `sessionId` alone.
@@ -36,10 +36,10 @@ export function legacyCodexHomePath() {
  * `auth.json`) and settings (copied `config.toml`) but NOT the real home's pending
  * update / first-run (NUX) state — so a co-driven `codex` app-server + `--remote`
  * TUI never block on an "Update now / Press enter to continue" prompt (which would
- * wedge terminal injection). Ports omnigent's `_CODEX_HOME_SYMLINK_FILES` /
+ * wedge terminal injection). Ports reference implementation's `_CODEX_HOME_SYMLINK_FILES` /
  * `_CODEX_HOME_COPY_FILES`.
  *
- * PER-SESSION: one private home per rynx session (matching omnigent), so concurrent
+ * PER-SESSION: one private home per rynx session (matching reference implementation), so concurrent
  * agents never share a `skills/` dir. Idempotent: the symlink/copy are refreshed each
  * call so a re-login/config change propagates. Returns the private home dir.
  */
@@ -79,7 +79,7 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
 }
 /**
  * Link a resolved skill set into `<codexHome>/skills/<name>/` so the native Codex
- * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism omnigent
+ * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism reference implementation
  * uses (`populate_codex_skills_from_bundle` → `_populate_codex_skills`), NOT a
  * `<skills_instructions>` block injected into the prompt. Codex's app-server
  * watches this dir and re-scans on change, so a live `codex --remote` TUI — whose
@@ -87,9 +87,9 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
  * — still sees the agent's skills.
  *
  * Each skill is a symlink to its source dir; a filesystem without symlink support
- * falls back to a recursive copy (matches omnigent's fallback).
+ * falls back to a recursive copy (matches reference implementation's fallback).
  *
- * omnigent boots a fresh per-session CODEX_HOME, so it only ever links into an
+ * reference implementation boots a fresh per-session CODEX_HOME, so it only ever links into an
  * empty dir. rynx shares ONE private home per runtime (see {@link prepareCodexHome}),
  * so this CONVERGES the dir to `skills`: it links the missing ones and removes
  * entries no longer selected, honouring the agent spec's gating. (Concurrent
@@ -99,7 +99,7 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
 export function populateCodexSkills(codexHome, skills) {
     const skillsDir = join(codexHome, "skills");
     const want = new Map(skills.map((s) => [s.name, s.dir]));
-    // Converge: drop entries no longer selected (shared-home adaptation; omnigent's
+    // Converge: drop entries no longer selected (shared-home adaptation; reference implementation's
     // per-session home never needs this). `.system` holds codex's own embedded system
     // skills (the app-server installs them into `$CODEX_HOME/skills/.system`) — never
     // rynx-managed, so leave it untouched; only converge the entries we linked.
@@ -116,8 +116,7 @@ export function populateCodexSkills(codexHome, skills) {
     mkdirSync(skillsDir, { recursive: true });
     for (const [name, src] of want) {
         const link = join(skillsDir, name);
-        if (existsSync(link))
-            continue; // already linked (a skill's dir for a name is stable)
+        rmSync(link, { recursive: true, force: true });
         try {
             symlinkSync(src, link);
         }

package/dist/codex-session-store.d.ts

@@ -1,10 +1,11 @@
-import { type AgentRuntimeId } from "@rynx-ai/core";
+import { type AgentRuntimeId, type ReasoningEffort } from "@rynx-ai/core";
 import type { AppConfig } from "@rynx-ai/core";
 export interface CodexSessionRecord {
     localThreadId: string;
     codexSessionId: string;
     cwd: string;
     model: string;
+    reasoningEffort?: ReasoningEffort;
     /** Runtime this thread is bound to. Legacy records backfill to `codex`. */
     runtime: AgentRuntimeId;
     /** Declarative agent spec name bound to this thread, if any. */