@rynx-ai/runtime 0.1.11-beta.5 → 0.1.11-beta.51

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

@@ -14,8 +14,11 @@
  */
 import { spawn } from "node:child_process";
 import { createServer } from "node:net";
+import { join } from "node:path";
+import { diagnosticEvents, teeDiagnosticStream } from "@rynx-ai/core";
 import { WebSocket } from "ws";
 import { createCodexChildEnv } from "../codex-child-env.js";
+import { newRuntimeProcessTag, reconcileRuntimeProcesses, registerRuntimeProcess, runtimeProcessArgv0, runtimeProcessOwnerIdentity, unregisterRuntimeProcess, withRuntimeProcessStateArg, } from "./process-registry.js";
 /** Reserve a free loopback TCP port (best-effort; racy but fine for local use). */
 async function freeLoopbackPort() {
     return await new Promise((resolve, reject) => {
@@ -28,6 +31,7 @@ async function freeLoopbackPort() {
         });
     });
 }
+const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
 export class WsRpcChannel {
     opts;
     child = null;
@@ -35,12 +39,14 @@ export class WsRpcChannel {
     lineCb = null;
     closeCb = null;
     closedEmitted = false;
+    processTag = null;
+    stopTask = null;
     readyTimeoutMs;
     /** The `ws://IP:PORT` the app-server listens on — pass to the TUI's `--remote`. */
     url = "";
     constructor(opts) {
         this.opts = opts;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -52,16 +58,55 @@ export class WsRpcChannel {
         return this.ws?.readyState === WebSocket.OPEN;
     }
     async start() {
+        this.stopTask = null;
+        this.closedEmitted = false;
+        if (this.opts.stateDir) {
+            reconcileRuntimeProcesses();
+        }
         const port = await freeLoopbackPort();
         this.url = `ws://127.0.0.1:${port}`;
-        const args = [...this.opts.baseArgs, "--listen", this.url];
+        const baseArgs = this.opts.stateDir
+            ? withRuntimeProcessStateArg(this.opts.baseArgs, this.opts.stateDir)
+            : this.opts.baseArgs;
+        const args = [...baseArgs, "--listen", this.url];
+        const processTag = this.opts.stateDir ? newRuntimeProcessTag() : null;
+        this.processTag = processTag;
         this.child = spawn(this.opts.cliPath, args, {
             stdio: ["ignore", "ignore", "pipe"],
             env: { ...createCodexChildEnv(process.env), ...(this.opts.extraEnv ?? {}) },
+            detached: process.platform !== "win32",
+            ...(processTag ? { argv0: runtimeProcessArgv0(this.opts.cliPath, processTag) } : {}),
+        });
+        const childPid = this.child.pid;
+        if (process.env.RYNX_RUNTIME_LOG_DIR) {
+            const logDir = process.env.RYNX_RUNTIME_LOG_DIR;
+            teeDiagnosticStream(this.child.stderr, join(logDir, "app-server.stderr.log"));
+            const event = diagnosticEvents(join(logDir, "process-events.jsonl"));
+            event("app-server.spawn", { pid: childPid });
+            this.child.on("exit", (code, signal) => event("app-server.exit", { code, signal }));
+        }
+        if (processTag && this.opts.stateDir && childPid) {
+            registerRuntimeProcess({
+                pid: childPid,
+                pgid: childPid,
+                ownerPid: process.pid,
+                ownerIdentity: runtimeProcessOwnerIdentity(process.pid),
+                sessionTag: processTag,
+                stateDir: this.opts.stateDir,
+            });
+        }
+        this.child.on("exit", (code, signal) => {
+            this.unregisterProcess();
+            this.emitClose(code, signal, null);
         });
-        this.child.on("exit", (code, signal) => this.emitClose(code, signal, null));
         this.child.on("error", (error) => this.emitClose(null, null, error));
-        this.ws = await this.connectWithRetry(this.url);
+        try {
+            this.ws = await this.connectWithRetry(this.url);
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
         this.ws.on("message", (data) => {
             // One JSON-RPC object per frame (codex ws framing).
             this.lineCb?.(data.toString());
@@ -85,6 +130,12 @@ export class WsRpcChannel {
         });
     }
     async stop(signal = "SIGTERM") {
+        if (this.stopTask)
+            return await this.stopTask;
+        this.stopTask = this.stopOwnedProcess(signal);
+        return await this.stopTask;
+    }
+    async stopOwnedProcess(signal) {
         try {
             this.ws?.close();
         }
@@ -92,14 +143,33 @@ export class WsRpcChannel {
             /* already closing */
         }
         const child = this.child;
-        if (child) {
-            try {
-                child.kill(signal);
-            }
-            catch {
-                /* already gone */
+        if (child && child.exitCode === null && child.signalCode === null) {
+            this.signalChild(child, signal);
+            if (!await waitForExit(child, 5_000)) {
+                this.signalChild(child, "SIGKILL");
+                await waitForExit(child, 2_000);
             }
         }
+        this.unregisterProcess();
+        this.child = null;
+        this.ws = null;
+    }
+    signalChild(child, signal) {
+        try {
+            if (process.platform !== "win32" && child.pid)
+                process.kill(-child.pid, signal);
+            else
+                child.kill(signal);
+        }
+        catch {
+            // Already gone.
+        }
+    }
+    unregisterProcess() {
+        const tag = this.processTag;
+        this.processTag = null;
+        if (tag)
+            unregisterRuntimeProcess(tag);
     }
     emitClose(code, signal, error) {
         if (this.closedEmitted)
@@ -114,7 +184,7 @@ export class WsRpcChannel {
         // eslint-disable-next-line no-constant-condition
         while (Date.now() < deadline) {
             try {
-                return await this.tryConnect(url);
+                return await this.tryConnect(url, Math.max(1, deadline - Date.now()));
             }
             catch (error) {
                 lastError = error;
@@ -123,9 +193,9 @@ export class WsRpcChannel {
         }
         throw new Error(`codex app-server ws did not become ready at ${url}: ${lastError?.message ?? "timeout"}`);
     }
-    tryConnect(url) {
+    tryConnect(url, handshakeTimeout) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            const ws = new WebSocket(url, { handshakeTimeout });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);
@@ -145,6 +215,22 @@ export class WsRpcChannel {
         });
     }
 }
+function waitForExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            child.off("exit", onExit);
+            resolve(false);
+        }, timeoutMs);
+        timer.unref?.();
+        const onExit = () => {
+            clearTimeout(timer);
+            resolve(true);
+        };
+        child.once("exit", onExit);
+    });
+}
 /**
  * Connect-only {@link RpcChannel}: attaches an ADDITIONAL client to an app-server
  * someone else already started (a {@link WsRpcChannel}'s `url`) — no spawn. This
@@ -166,7 +252,7 @@ export class ExternalWsChannel {
     /** The `ws://IP:PORT` of the already-running app-server to attach to. */
     url, opts = {}) {
         this.url = url;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -178,20 +264,16 @@ export class ExternalWsChannel {
         return this.ws?.readyState === WebSocket.OPEN;
     }
     async start() {
-        const deadline = Date.now() + this.readyTimeoutMs;
-        let lastError;
-        while (Date.now() < deadline) {
-            try {
-                this.ws = await this.connect(this.url);
-                break;
-            }
-            catch (error) {
-                lastError = error;
-                await new Promise((r) => setTimeout(r, 150));
-            }
+        // A channel instance is reusable after an observer disconnect. Do not let
+        // the prior closed socket make a failed reconnect look successful, and arm
+        // close delivery for the newly connected socket.
+        this.ws = null;
+        this.closedEmitted = false;
+        try {
+            this.ws = await this.connect(this.url);
         }
-        if (!this.ws) {
-            throw new Error(`could not attach to app-server ws ${this.url}: ${lastError?.message ?? "timeout"}`);
+        catch (error) {
+            throw new Error(`could not attach to app-server ws ${this.url}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
         this.ws.on("message", (data) => this.lineCb?.(data.toString()));
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
@@ -227,7 +309,10 @@ export class ExternalWsChannel {
     }
     connect(url) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            // The app-server owner has already completed its readiness probe. Use one
+            // bounded attach, then reuse this exact connection as the forwarder
+            // instead of running a second startup retry stage.
+            const ws = new WebSocket(url, { handshakeTimeout: this.readyTimeoutMs });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);

package/dist/codex-child-env.js

@@ -1,28 +1,3 @@
-const CODEX_CHILD_ENV_ALLOWLIST = [
-    "PATH",
-    "HOME",
-    "USER",
-    "SHELL",
-    "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",
-    "NO_PROXY",
-    "http_proxy",
-    "https_proxy",
-    "all_proxy",
-    "no_proxy",
-];
 const PROXY_ENV_KEYS = [
     "HTTP_PROXY",
     "HTTPS_PROXY",
@@ -42,13 +17,9 @@ function withLoopbackNoProxy(value) {
     return entries.join(",");
 }
 export function createCodexChildEnv(env) {
-    const childEnv = {};
-    for (const key of CODEX_CHILD_ENV_ALLOWLIST) {
-        const value = env[key];
-        if (typeof value === "string" && value.length > 0) {
-            childEnv[key] = value;
-        }
-    }
+    // Managed Codex/TraeX processes need the same development environment as
+    // their runner, including workspace metadata and user-configured CLI keys.
+    const childEnv = { ...env };
     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;

package/dist/codex-home.d.ts

@@ -1,5 +1,16 @@
-import { type AgentRuntimeId } from "@rynx-ai/core";
+import { type AgentRuntimeId, type ResolvedRetryPolicy } from "@rynx-ai/core";
 export type CodexLineageRuntime = Exclude<AgentRuntimeId, "claude">;
+export type CodexAuthMode = "chatgpt" | "apikey" | "pat";
+export type CodexConfigAuth = "provider-ready" | "provider-auth-missing" | "codex-login";
+/** Read the credential mode from Codex's optional-field auth.json shape. */
+export declare function codexAuthEffectiveMode(authPath: string): CodexAuthMode | null;
+/** Mirror Codex's provider-specific auth decision without spawning the CLI. */
+export declare function codexConfigEffectiveAuth(configPath: string, env?: NodeJS.ProcessEnv): CodexConfigAuth;
+/** True only when this exact launch would defer to an absent Codex login. */
+export declare function codexLaunchRequiresLogin(codexHome: string, env?: NodeJS.ProcessEnv): boolean;
+/** Resolve the user's auth/config source without nesting a parent Session's
+ * private CODEX_HOME into a child Session. */
+export declare function resolveCodexHomeConfigSource(candidate: string, defaultHome?: string): string;
 /**
  * The deterministic private CODEX_HOME path for a rynx session. PER-SESSION,
  * under the daemon-owned RYNX_HOME runtime tree,
@@ -22,8 +33,8 @@ export declare function legacyCodexHomePath(): string;
  * `_CODEX_HOME_COPY_FILES`.
  *
  * 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.
+ * agents never share a `skills/` dir. Idempotent: existing Session-owned entries stay
+ * unchanged; live symlinks still observe source credential updates. Returns the private home dir.
  */
 export declare function prepareCodexHome(sessionId: string, realHome?: string): string;
 /**
@@ -32,6 +43,27 @@ export declare function prepareCodexHome(sessionId: string, realHome?: string):
  * real home and cannot wedge a managed app-server/TUI pair.
  */
 export declare function prepareRuntimeHome(sessionId: string, runtime: CodexLineageRuntime, realHome?: string): string;
+/** Trust a runner-selected workspace only in the Session's private config so
+ * Codex cannot stop a detached TUI at its project-trust prompt. */
+export declare function trustCodexProject(codexHome: string, cwd: string): void;
+/** Apply the Session retry budget through Codex's supported provider settings.
+ * A config with no provider definitions is left untouched. */
+export declare function applyCodexProviderRetryPolicy(codexHome: string, retry?: ResolvedRetryPolicy | null): void;
+/** Preserve the user's private-home base instructions and append only the raw
+ * Agent-authored text. Repeated launches replace the managed suffix instead of
+ * accumulating it. Invalid user TOML is intentionally left untouched. */
+export declare function syncCodexDeveloperInstructions(codexHome: string, instructions?: string | null): void;
+export type CodexDeveloperInstructionsState = {
+    state: "present";
+    value: string;
+} | {
+    state: "absent";
+} | {
+    state: "unreadable";
+};
+/** Read the active private-home instructions without conflating a definite
+ * absence with malformed or temporarily unreadable config. */
+export declare function readCodexDeveloperInstructionsState(codexHome: string): CodexDeveloperInstructionsState;
 /** Persist immutable skill copies in a native Provider home. Fork descendants
  * share that home, so entries must outlive every runner's temporary sources. */
 export declare function populateCodexSkills(codexHome: string, skills: {