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

package/dist/codex-app-server/process-registry.js

@@ -0,0 +1,320 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { rynxRuntimeDir } from "@rynx-ai/core";
+const REGISTRY_FILE = "process-registry.json";
+const TAG_PREFIX = "rynx_crash_teardown_tag=";
+const STATE_PREFIX = "rynx_crash_teardown_state_dir=";
+export function runtimeProcessRegistryPath() {
+    return join(rynxRuntimeDir(), REGISTRY_FILE);
+}
+export function runtimeProcessTagArg(sessionTag) {
+    if (!sessionTag)
+        throw new Error("sessionTag must be non-empty");
+    return `${TAG_PREFIX}${sessionTag}`;
+}
+export function runtimeProcessArgv0(cliPath, sessionTag) {
+    return `${basename(cliPath)} ${runtimeProcessTagArg(sessionTag)}`;
+}
+export function withRuntimeProcessStateArg(baseArgs, stateDir) {
+    const args = [...baseArgs];
+    const marker = ["-c", `${STATE_PREFIX}${JSON.stringify(stateDir)}`];
+    const subcommand = args.indexOf("app-server");
+    args.splice(subcommand >= 0 ? subcommand : 0, 0, ...marker);
+    return args;
+}
+export function registerRuntimeProcess(entry, registryPath = runtimeProcessRegistryPath()) {
+    if (!validEntry(entry))
+        return;
+    mutateRegistry(registryPath, (entries) => [
+        ...entries.filter((candidate) => candidate.sessionTag !== entry.sessionTag),
+        entry,
+    ]);
+}
+export function unregisterRuntimeProcess(sessionTag, registryPath = runtimeProcessRegistryPath()) {
+    if (!sessionTag)
+        return;
+    mutateRegistry(registryPath, (entries) => entries.filter((entry) => entry.sessionTag !== sessionTag));
+}
+export function reconcileRuntimeProcesses(opts = {}) {
+    return reconcileEntries(undefined, opts);
+}
+export function reapRuntimeProcessesForStateDir(stateDir, opts = {}) {
+    if (process.platform === "win32" && !opts.processListing)
+        return 0;
+    const listing = opts.processListing?.() ?? listProcesses();
+    if (!listing)
+        return 0;
+    const currentPgid = opts.currentPgid?.() ?? processGroupId(process.pid);
+    const signalGroup = opts.signalGroup ?? signalProcessGroup;
+    const childAlive = opts.childAlive ?? isProcessAlive;
+    const graceMs = opts.graceMs ?? 1_500;
+    const victims = new Map();
+    for (const line of listing.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+([\s\S]+)$/.exec(line);
+        if (!match)
+            continue;
+        const pid = Number.parseInt(match[1], 10);
+        const pgid = Number.parseInt(match[2], 10);
+        const command = match[3];
+        if (!command.includes(stateDir) || !command.includes("app-server"))
+            continue;
+        if (pid === process.pid || pgid <= 0 || pgid === currentPgid)
+            continue;
+        victims.set(pid, pgid);
+    }
+    if (victims.size === 0)
+        return 0;
+    for (const pgid of new Set(victims.values()))
+        signalGroup(pgid, "SIGTERM");
+    const deadline = Date.now() + graceMs;
+    while (Date.now() < deadline && [...victims.keys()].some(childAlive)) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+    }
+    for (const [pid, pgid] of victims) {
+        if (childAlive(pid))
+            signalGroup(pgid, "SIGKILL");
+    }
+    return victims.size;
+}
+function reconcileEntries(stateDir, opts) {
+    const registryPath = opts.registryPath ?? runtimeProcessRegistryPath();
+    const ownerAlive = opts.ownerAlive ?? isProcessAlive;
+    const ownerIdentity = opts.ownerIdentity ?? runtimeProcessOwnerIdentity;
+    const childAlive = opts.childAlive ?? isProcessAlive;
+    const commandLine = opts.commandLine ?? processCommandLine;
+    const terminateGroup = opts.terminateGroup ?? terminateProcessGroup;
+    let reaped = 0;
+    mutateRegistry(registryPath, (entries) => {
+        const survivors = [];
+        for (const entry of entries) {
+            if (stateDir !== undefined && entry.stateDir !== stateDir) {
+                survivors.push(entry);
+                continue;
+            }
+            if (ownerAlive(entry.ownerPid)) {
+                const currentOwnerIdentity = ownerIdentity(entry.ownerPid);
+                // Old registry entries have no start identity. Keep the conservative
+                // PID-only behavior for those entries; every newly registered process
+                // is protected against PID reuse.
+                if (!entry.ownerIdentity ||
+                    !currentOwnerIdentity ||
+                    currentOwnerIdentity === entry.ownerIdentity) {
+                    survivors.push(entry);
+                    continue;
+                }
+            }
+            if (!childAlive(entry.pid))
+                continue;
+            if (!commandLine(entry.pid).includes(runtimeProcessTagArg(entry.sessionTag)))
+                continue;
+            if (!terminateGroup(entry.pgid)) {
+                survivors.push(entry);
+                continue;
+            }
+            reaped += 1;
+        }
+        return survivors;
+    });
+    return reaped;
+}
+function validEntry(entry) {
+    return Number.isSafeInteger(entry.pid) && entry.pid > 0 &&
+        Number.isSafeInteger(entry.pgid) && entry.pgid > 0 &&
+        Number.isSafeInteger(entry.ownerPid) && entry.ownerPid > 0 &&
+        (entry.ownerIdentity === undefined ||
+            (typeof entry.ownerIdentity === "string" && entry.ownerIdentity.length > 0)) &&
+        Boolean(entry.sessionTag) && Boolean(entry.stateDir);
+}
+function readRegistry(path) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "object" && entry !== null && validEntry(entry));
+}
+function mutateRegistry(path, mutation) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const lockDir = `${path}.lock`;
+    const deadline = Date.now() + 2_000;
+    while (true) {
+        try {
+            mkdirSync(lockDir, { mode: 0o700 });
+            writeFileSync(join(lockDir, "owner.pid"), JSON.stringify({
+                pid: process.pid,
+                identity: runtimeProcessOwnerIdentity(process.pid),
+            }), { mode: 0o600 });
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                return;
+            let ownerPid = 0;
+            let ownerIdentity = "";
+            try {
+                const rawOwner = readFileSync(join(lockDir, "owner.pid"), "utf8");
+                try {
+                    const parsed = JSON.parse(rawOwner);
+                    ownerPid = typeof parsed.pid === "number" ? parsed.pid : 0;
+                    ownerIdentity = typeof parsed.identity === "string" ? parsed.identity : "";
+                }
+                catch {
+                    // Backward-compatible recovery for a lock written by the earlier
+                    // PID-only implementation.
+                    ownerPid = Number.parseInt(rawOwner, 10);
+                }
+            }
+            catch {
+                // A creator may be between mkdir and marker write; the bounded retry handles it.
+            }
+            const currentOwnerIdentity = ownerPid > 0
+                ? runtimeProcessOwnerIdentity(ownerPid)
+                : "";
+            const staleKnownOwner = ownerPid > 0 && (!isProcessAlive(ownerPid) ||
+                Boolean(ownerIdentity && currentOwnerIdentity && ownerIdentity !== currentOwnerIdentity));
+            let staleUnownedLock = false;
+            if (ownerPid <= 0) {
+                try {
+                    staleUnownedLock = Date.now() - statSync(lockDir).mtimeMs >= 1_000;
+                }
+                catch {
+                    staleUnownedLock = true;
+                }
+            }
+            if (staleKnownOwner || staleUnownedLock) {
+                rmSync(lockDir, { recursive: true, force: true });
+                continue;
+            }
+            if (Date.now() >= deadline)
+                return;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    try {
+        const entries = mutation(readRegistry(path));
+        const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        writeFileSync(temp, `${JSON.stringify(entries)}\n`, { mode: 0o600 });
+        renameSync(temp, path);
+    }
+    finally {
+        rmSync(lockDir, { recursive: true, force: true });
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** Return an OS process-start identity used to distinguish PID reuse. */
+export function runtimeProcessOwnerIdentity(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return "";
+    if (process.platform === "linux") {
+        try {
+            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+            const commandEnd = stat.lastIndexOf(")");
+            if (commandEnd >= 0) {
+                // Fields after ')' begin at proc field 3; starttime is field 22.
+                const startTicks = stat.slice(commandEnd + 2).trim().split(/\s+/)[19];
+                if (startTicks)
+                    return `linux:${startTicks}`;
+            }
+        }
+        catch {
+            return "";
+        }
+    }
+    try {
+        const startedAt = execFileSync("ps", ["-p", String(pid), "-ww", "-o", "lstart="], {
+            encoding: "utf8",
+            timeout: 2_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return startedAt ? `${process.platform}:${startedAt}` : "";
+    }
+    catch {
+        return "";
+    }
+}
+function processCommandLine(pid) {
+    if (process.platform === "linux") {
+        try {
+            return readFileSync(`/proc/${pid}/cmdline`)
+                .toString("utf8")
+                .replaceAll("\0", " ");
+        }
+        catch {
+            // Fall through to ps for macOS and restricted procfs environments.
+        }
+    }
+    try {
+        return execFileSync("ps", ["-p", String(pid), "-ww", "-o", "command="], {
+            encoding: "utf8",
+            timeout: 2_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function listProcesses() {
+    try {
+        return execFileSync("ps", ["-axww", "-o", "pid=,pgid=,command="], {
+            encoding: "utf8",
+            timeout: 5_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        return "";
+    }
+}
+function processGroupId(pid) {
+    try {
+        const value = execFileSync("ps", ["-p", String(pid), "-o", "pgid="], {
+            encoding: "utf8",
+            timeout: 2_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return Number.parseInt(value.trim(), 10) || -1;
+    }
+    catch {
+        return -1;
+    }
+}
+function signalProcessGroup(pgid, signal) {
+    if (process.platform === "win32")
+        return false;
+    try {
+        process.kill(-pgid, signal);
+        return true;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+function terminateProcessGroup(pgid) {
+    if (process.platform === "win32")
+        return false;
+    try {
+        process.kill(-pgid, "SIGTERM");
+        return true;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+export function newRuntimeProcessTag() {
+    return `native-${randomUUID().replaceAll("-", "")}`;
+}

package/dist/codex-app-server/protocol.d.ts

@@ -56,6 +56,21 @@ export interface GetAuthStatusResponse {
     authToken: string | null;
     requiresOpenaiAuth: boolean;
 }
+/** Read the Provider's effective configuration through the app-server rather
+ * than parsing a runtime-specific config file (Traex has used both YAML and
+ * TOML across releases). `cwd` includes project-scoped configuration layers. */
+export interface ConfigReadParams {
+    includeLayers: boolean;
+    cwd?: string | null;
+}
+export interface ConfigReadResponse {
+    config: {
+        model: string | null;
+        model_reasoning_effort: ReasoningEffort | null;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
 export type AskForApproval = "untrusted" | "on-failure" | "on-request" | "never";
 export type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
 export type SandboxPolicy = {
@@ -87,6 +102,16 @@ export interface PermissionProfileModificationParams {
 export type PermissionSelection = string | PermissionProfileSelectionParams;
 /** Open since Codex App Server 0.144; values are advertised by `model/list`. */
 export type ReasoningEffort = string;
+export type CollaborationModeKind = "plan" | "default";
+/** Full Codex-lineage mode snapshot required by the App Server wire protocol. */
+export interface CollaborationMode {
+    mode: CollaborationModeKind;
+    settings: {
+        model: string;
+        reasoning_effort: ReasoningEffort | null;
+        developer_instructions: string | null;
+    };
+}
 export interface ThreadStartParams {
     model?: string | null;
     modelProvider?: string | null;
@@ -102,14 +127,18 @@ export interface ThreadStartParams {
     baseInstructions?: string | null;
     developerInstructions?: string | null;
     ephemeral?: boolean | null;
+    /** Native UI intent for a context-clearing fresh thread. */
+    sessionStartSource?: "clear" | string;
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
-    /** When true, the resume response omits the thread's `turns` backlog (used to
-     *  SUBSCRIBE without re-replaying history). When false/absent, the response
-     *  carries `thread.turns[].items[]` — the backfill the forwarder replays for a
-     *  fresh thread's first turn (reference implementation's `_replay_resume_response`). */
+    /** Suppress rollout history when the caller only needs to load/subscribe. */
     excludeTurns?: boolean;
+    initialTurnsPage?: {
+        limit?: number | null;
+        sortDirection?: "asc" | "desc" | null;
+        itemsView?: "notLoaded" | "summary" | "full" | null;
+    } | null;
 }
 /** One turn in a resumed thread's backlog (`thread/resume` response). */
 export interface ResumedTurn {
@@ -125,6 +154,13 @@ export interface ResumedThread {
     turns?: ResumedTurn[];
     [key: string]: unknown;
 }
+/** Settings selected by the Provider while starting or resuming a thread.
+ * Older app-server builds may omit them, so the bridge treats them as optional
+ * and falls back to `config/read` only for a fresh, not-yet-created thread. */
+export interface ThreadRuntimeSettings {
+    model?: string;
+    reasoningEffort?: ReasoningEffort | null;
+}
 export interface ThreadDescriptor {
     id: string;
     cwd: string;
@@ -155,6 +191,7 @@ export interface TurnStartParams {
     permissions?: PermissionSelection | null;
     model?: string | null;
     effort?: ReasoningEffort | null;
+    collaborationMode?: CollaborationMode | null;
 }
 export interface TurnInterruptParams {
     threadId: string;
@@ -169,7 +206,7 @@ export interface TurnSteerParams {
     expectedTurnId: string;
     input: UserInput[];
 }
-export type TurnStatus = "completed" | "interrupted" | "failed" | "inProgress";
+export type TurnStatus = "completed" | "interrupted" | "cancelled" | "canceled" | "failed" | "errored" | "inProgress";
 export interface TurnPlanStep {
     step: string;
     status: "pending" | "inProgress" | "completed";
@@ -252,7 +289,20 @@ export interface WebSearchItem extends ThreadItemBase {
         type: "other";
     } | null;
 }
-export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | (ThreadItemBase & Record<string, unknown>);
+export interface ImageGenerationItem extends ThreadItemBase {
+    type: "imageGeneration";
+    status: string;
+    revisedPrompt: string | null;
+    /** Base64 image bytes supplied when no durable saved path is available. */
+    result: string;
+    /** Codex App Server guarantees this is absolute when present. */
+    savedPath?: string;
+}
+export interface ImageViewItem extends ThreadItemBase {
+    type: "imageView";
+    path: string;
+}
+export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | ImageGenerationItem | ImageViewItem | (ThreadItemBase & Record<string, unknown>);
 export interface ThreadSummary {
     id?: string;
     threadId?: string;
@@ -302,7 +352,7 @@ export interface ThreadSettingsUpdateParams {
     serviceTier?: string | null;
     effort?: ReasoningEffort | null;
     summary?: string | null;
-    collaborationMode?: Record<string, unknown> | null;
+    collaborationMode?: CollaborationMode | null;
     personality?: string | null;
 }
 export interface ModelListParams {
@@ -476,6 +526,14 @@ export interface QueueStatusNotificationParams {
 export type ServerNotification = {
     method: "thread/started";
     params: ThreadStartedNotificationParams;
+} | {
+    method: "thread/settings/updated";
+    params: {
+        threadId: string;
+        threadSettings: {
+            collaborationMode?: CollaborationMode | null;
+        } & Record<string, unknown>;
+    };
 } | {
     method: "turn/started";
     params: TurnStartedNotificationParams;
@@ -497,6 +555,9 @@ export type ServerNotification = {
 } | {
     method: "item/agentMessage/delta";
     params: AgentMessageDeltaNotificationParams;
+} | {
+    method: "item/plan/delta";
+    params: AgentMessageDeltaNotificationParams;
 } | {
     method: "item/reasoning/summaryTextDelta";
     params: ReasoningSummaryTextDeltaNotificationParams;

package/dist/codex-app-server/transport.d.ts

@@ -49,10 +49,10 @@ export declare class DefaultCodexAppServerProcessSpawner implements CodexAppServ
         cliPath: string;
         args?: string[];
         /**
-         * Extra env merged on top of the allowlisted child env (see
+         * Extra env merged on top of the inherited child env (see
          * {@link createCodexChildEnv}). Used to inject a per-agent retry budget
          * (`OPENAI_MAX_RETRIES` / `OPENAI_TIMEOUT`) into a dedicated app-server.
-         * Merged after the allowlist, so it is intentionally exempt from it — only
+         * Merged after the inherited environment, so it takes precedence — only
          * the specific keys the caller computed are added, never arbitrary env.
          */
         extraEnv?: Record<string, string>;

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

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
+import { join } from "node:path";
+import { teeDiagnosticStream } from "@rynx-ai/core";
 import { createCodexChildEnv } from "../codex-child-env.js";
 const DEFAULT_SPAWN_ARGS = ["app-server", "--listen", "stdio://"];
 /**
@@ -51,6 +53,8 @@ export class DefaultCodexAppServerProcessSpawner {
             stdio: ["pipe", "pipe", "pipe"],
             env: { ...createCodexChildEnv(process.env), ...this.extraEnv },
         });
+        if (process.env.RYNX_RUNTIME_LOG_DIR)
+            teeDiagnosticStream(child.stderr, join(process.env.RYNX_RUNTIME_LOG_DIR, "app-server.stderr.log"));
         if (!child.stdin || !child.stdout) {
             throw new Error("Codex app-server child process is missing stdio handles");
         }

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

@@ -3,11 +3,13 @@ export interface WsRpcChannelOptions {
     cliPath: string;
     /** app-server args WITHOUT `--listen` (the channel appends `--listen ws://…`). */
     baseArgs: string[];
-    /** Extra env merged over the allowlisted codex child env (retry budget etc.). */
+    /** Extra env merged over the inherited codex child env (retry budget etc.). */
     extraEnv?: Record<string, string>;
     logger?: TransportLogger;
     /** Ms to wait for the app-server to accept a connection. */
     readyTimeoutMs?: number;
+    /** Durable per-session runtime state used for targeted crash reconciliation. */
+    stateDir?: string;
 }
 export declare class WsRpcChannel implements RpcChannel {
     private readonly opts;
@@ -16,6 +18,8 @@ export declare class WsRpcChannel implements RpcChannel {
     private lineCb;
     private closeCb;
     private closedEmitted;
+    private processTag;
+    private stopTask;
     private readonly readyTimeoutMs;
     /** The `ws://IP:PORT` the app-server listens on — pass to the TUI's `--remote`. */
     url: string;
@@ -30,6 +34,9 @@ export declare class WsRpcChannel implements RpcChannel {
     start(): Promise<void>;
     send(line: string): Promise<void>;
     stop(signal?: NodeJS.Signals): Promise<void>;
+    private stopOwnedProcess;
+    private signalChild;
+    private unregisterProcess;
     private emitClose;
     private connectWithRetry;
     private tryConnect;