@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.41

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

@@ -1,9 +1,3 @@
-/**
- * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
- * the executor so BOTH the per-turn executor and the persistent session
- * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
- * canonical log, reference implementation's codex-native model) share one mapping.
- */
 import type { AgentEvent } from "@rynx-ai/core";
 import type { ThreadItem } from "./protocol.js";
 export interface CodexMapResult {
@@ -11,8 +5,11 @@ export interface CodexMapResult {
     finalText?: string;
     usage?: Record<string, unknown>;
     turnCompleted?: boolean;
+    turnInterrupted?: boolean;
     fatalError?: Error;
 }
+export declare function codexTurnStatus(turn: unknown): string | undefined;
+export declare function codexResumeTerminalStatus(turn: unknown): "idle" | "failed" | undefined;
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export declare function mapCodexItem(method: string, item: ThreadItem): CodexMapResult;
 /** Map one codex app-server notification to events (+ turn/usage/error signals). */

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

@@ -1,12 +1,105 @@
+/**
+ * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
+ * the executor so BOTH the per-turn executor and the persistent session
+ * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
+ * canonical log, reference implementation's codex-native model) share one mapping.
+ */
+import { extname, isAbsolute } from "node:path";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const CODEX_AUTH_ERROR_FRAGMENTS = [
+    "401",
+    "403",
+    "unauthorized",
+    "authentication",
+    "not logged in",
+    "not authenticated",
+    "log in",
+    "login",
+    "sign in",
+    "re-authenticate",
+    "reauthenticate",
+    "credentials",
+    "access token",
+    "token expired",
+    "expired token",
+    "session expired",
+    "api key",
+];
+const CODEX_REAUTH_HINT = "Codex needs you to re-authenticate. Run `codex login` and retry.";
+function codexErrorMessage(error) {
+    for (const key of ["message", "error", "text", "detail"]) {
+        const value = error[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return "Codex turn ended with an unspecified error.";
+}
+function codexErrorIsAuth(error, message) {
+    const info = error.codexErrorInfo;
+    let variant;
+    let httpStatusCode;
+    if (typeof info === "string") {
+        variant = info;
+    }
+    else if (isRecord(info)) {
+        variant = info.type ?? info.kind ?? info.variant;
+        httpStatusCode = info.httpStatusCode;
+    }
+    if (typeof variant === "string" && variant.toLowerCase() === "unauthorized")
+        return true;
+    if (httpStatusCode === 401 || httpStatusCode === 403)
+        return true;
+    const lowered = message.toLowerCase();
+    return CODEX_AUTH_ERROR_FRAGMENTS.some((fragment) => lowered.includes(fragment));
+}
 function turnError(error, fallback) {
-    if (typeof error === "string" && error.trim())
-        return new Error(error);
-    if (error && typeof error === "object" && "message" in error) {
-        const message = error.message;
-        if (typeof message === "string" && message.trim())
-            return new Error(message);
+    if (!error)
+        return new Error(fallback);
+    const message = codexErrorMessage(error);
+    return new Error(codexErrorIsAuth(error, message)
+        ? `${message}\n\n${CODEX_REAUTH_HINT}`
+        : message);
+}
+export function codexTurnStatus(turn) {
+    if (!isRecord(turn))
+        return undefined;
+    const status = turn.status;
+    if (typeof status === "string")
+        return status;
+    if (!isRecord(status))
+        return undefined;
+    const value = status.type ?? status.status;
+    return typeof value === "string" ? value : undefined;
+}
+export function codexResumeTerminalStatus(turn) {
+    if (terminalTurnError(turn, "turn/completed"))
+        return "failed";
+    const status = codexTurnStatus(turn);
+    if (status === "completed" || status === "interrupted" ||
+        status === "cancelled" || status === "canceled") {
+        return "idle";
+    }
+    if (status === "failed" || status === "errored")
+        return "failed";
+    return undefined;
+}
+function terminalTurnError(turn, method) {
+    if (!isRecord(turn)) {
+        return method === "turn/failed" ? new Error("Codex turn failed") : undefined;
+    }
+    let error = turn.error;
+    if (!isRecord(error) && Array.isArray(turn.items)) {
+        error = turn.items.find((item) => isRecord(item) && item.type === "error");
+    }
+    if (isRecord(error))
+        return turnError(error, "Codex turn failed");
+    const status = codexTurnStatus(turn);
+    if (method === "turn/failed" || status === "failed" || status === "errored") {
+        return turnError(undefined, "Codex turn failed");
     }
-    return new Error(fallback);
+    return undefined;
 }
 function webSearchInput(item) {
     const action = item.action;
@@ -29,6 +122,25 @@ function webSearchInput(item) {
     }
     return { id: item.id, query: item.query };
 }
+function fileChangeSummary(changes) {
+    const lines = [];
+    for (const change of changes) {
+        if (!isRecord(change))
+            continue;
+        if (typeof change.path !== "string")
+            continue;
+        const kind = isRecord(change.kind) && typeof change.kind.type === "string" && change.kind.type
+            ? change.kind.type
+            : "change";
+        lines.push(`${kind} ${change.path}`);
+    }
+    return lines.join("\n");
+}
+function isSupportedAbsoluteImagePath(path) {
+    if (!isAbsolute(path))
+        return false;
+    return [".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"].includes(extname(path).toLowerCase());
+}
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export function mapCodexItem(method, item) {
     const events = [];
@@ -37,20 +149,37 @@ export function mapCodexItem(method, item) {
     switch (item.type) {
         case "commandExecution": {
             const commandItem = item;
+            const id = typeof commandItem.id === "string" ? commandItem.id : "";
+            const command = typeof commandItem.command === "string" ? commandItem.command : "";
+            if (!id || !command)
+                return { events };
+            const exitCode = typeof commandItem.exitCode === "number"
+                ? commandItem.exitCode
+                : null;
+            const rawOutput = commandItem.aggregatedOutput ?? "";
+            const aggregatedOutput = exitCode !== null && exitCode !== 0
+                ? `${rawOutput}${rawOutput ? "\n" : ""}[exit code: ${exitCode}]`
+                : rawOutput;
             events.push({
                 type: "tool",
                 event: isStart ? "on_tool_start" : "on_tool_end",
-                name: "command_execution",
-                input: isStart
-                    ? { id: commandItem.id, command: commandItem.command, cwd: commandItem.cwd }
+                name: "shell",
+                input: isStart || isEnd
+                    ? {
+                        id,
+                        command,
+                        ...(typeof commandItem.cwd === "string" && commandItem.cwd
+                            ? { cwd: commandItem.cwd }
+                            : {}),
+                    }
                     : undefined,
                 output: isEnd
                     ? {
-                        id: commandItem.id,
-                        command: commandItem.command,
+                        id,
+                        command,
                         status: commandItem.status,
-                        aggregatedOutput: commandItem.aggregatedOutput ?? null,
-                        exitCode: commandItem.exitCode ?? null,
+                        aggregatedOutput,
+                        exitCode,
                     }
                     : undefined,
                 data: { method, item },
@@ -58,16 +187,23 @@ export function mapCodexItem(method, item) {
             return { events };
         }
         case "fileChange": {
+            const fileChange = item;
+            const changes = Array.isArray(fileChange.changes) ? fileChange.changes : [];
+            const id = typeof item.id === "string" ? item.id : "";
+            if (!id ||
+                changes.length === 0 ||
+                !changes.some((change) => isRecord(change) && typeof change.path === "string"))
+                return { events };
             events.push({
                 type: "tool",
                 event: isStart ? "on_tool_start" : "on_tool_end",
-                name: "file_change",
-                input: isStart ? { id: item.id } : undefined,
+                name: "apply_patch",
+                input: isStart || isEnd ? { id, changes } : undefined,
                 output: isEnd
                     ? {
-                        id: item.id,
-                        changes: item.changes,
-                        status: item.status,
+                        id,
+                        status: fileChange.status,
+                        aggregatedOutput: fileChangeSummary(changes),
                     }
                     : undefined,
                 data: { method, item },
@@ -113,6 +249,30 @@ export function mapCodexItem(method, item) {
             });
             return { events };
         }
+        case "imageGeneration": {
+            const image = item;
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: "image_generation",
+                input: isStart ? { id: image.id } : undefined,
+                output: isEnd
+                    ? {
+                        id: image.id,
+                        status: image.status,
+                        generatedImage: {
+                            ...(!image.savedPath || !isSupportedAbsoluteImagePath(image.savedPath)
+                                ? { result: image.result }
+                                : {}),
+                            revisedPrompt: image.revisedPrompt,
+                            ...(image.savedPath ? { savedPath: image.savedPath } : {}),
+                        },
+                    }
+                    : undefined,
+                data: { method, item: { ...image, result: image.result ? "[image data omitted]" : "" } },
+            });
+            return { events };
+        }
         case "agentMessage": {
             const text = item.text?.trim() ?? "";
             if (isEnd && text) {
@@ -122,7 +282,11 @@ export function mapCodexItem(method, item) {
             return { events };
         }
         case "plan": {
-            events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, item } });
+            const text = item.text?.trim() ?? "";
+            if (isEnd && text) {
+                events.push({ type: "message_completed", itemId: item.id, text });
+                return { events, finalText: text };
+            }
             return { events };
         }
         case "reasoning": {
@@ -151,23 +315,18 @@ export function mapCodexNotification(method, params) {
             return { events };
         case "turn/started":
             return { events };
-        case "turn/completed": {
+        case "turn/completed":
+        case "turn/failed": {
             const turnPayload = typed.params?.turn;
-            if (turnPayload?.status === "failed") {
-                return {
-                    events,
-                    fatalError: turnError(turnPayload.error, "Codex turn failed"),
-                    turnCompleted: true,
-                };
-            }
-            if (turnPayload?.status === "interrupted") {
-                return {
-                    events,
-                    fatalError: turnError(turnPayload.error, "Codex turn was interrupted"),
-                    turnCompleted: true,
-                };
-            }
-            return { events, turnCompleted: true };
+            const fatalError = terminalTurnError(turnPayload, typed.method);
+            const turnInterrupted = typed.method === "turn/completed" &&
+                ["interrupted", "cancelled", "canceled"].includes(codexTurnStatus(turnPayload) ?? "");
+            return {
+                events,
+                ...(fatalError ? { fatalError } : {}),
+                turnCompleted: true,
+                ...(turnInterrupted ? { turnInterrupted: true } : {}),
+            };
         }
         case "turn/plan/updated": {
             const planParams = typed.params;
@@ -195,6 +354,17 @@ export function mapCodexNotification(method, params) {
             }
             return { events };
         }
+        case "item/plan/delta": {
+            const delta = typed.params.delta ?? "";
+            if (delta) {
+                events.push({
+                    type: "token",
+                    text: delta,
+                    metadata: { source: "app_server", itemId: typed.params.itemId },
+                });
+            }
+            return { events };
+        }
         case "item/reasoning/summaryTextDelta":
         case "item/reasoning/textDelta": {
             const p = typed.params;

package/dist/codex-app-server/mcp-startup.d.ts

@@ -0,0 +1,13 @@
+import type { CodexLineageRuntime } from "../codex-home.js";
+export interface McpStartupPlan {
+    servers: string[];
+    settleTimeoutMs: number;
+}
+/**
+ * Read the MCP table fields needed for startup tracking. Provider config stays
+ * authoritative: malformed TOML disables the synthesized status rather than
+ * preventing the native CLI from reporting its own startup error.
+ */
+export declare function parseMcpStartupToml(input: string): McpStartupPlan | null;
+/** Enabled Provider-configured MCP servers and their synthesized settle window. */
+export declare function readMcpStartupPlan(runtimeHome: string, runtime: CodexLineageRuntime): McpStartupPlan | null;

package/dist/codex-app-server/mcp-startup.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "smol-toml";
+const DEFAULT_SERVER_TIMEOUT_MS = 10_000;
+const SETTLE_GRACE_MS = 15_000;
+const MAX_SETTLE_TIMEOUT_MS = 240_000;
+function configNames(runtime) {
+    return runtime === "codex"
+        ? ["config.toml"]
+        : ["traecli.toml"];
+}
+function isTomlTable(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Read the MCP table fields needed for startup tracking. Provider config stays
+ * authoritative: malformed TOML disables the synthesized status rather than
+ * preventing the native CLI from reporting its own startup error.
+ */
+export function parseMcpStartupToml(input) {
+    let config;
+    try {
+        config = parse(input);
+    }
+    catch {
+        return null;
+    }
+    const servers = config.mcp_servers;
+    if (!isTomlTable(servers))
+        return null;
+    const enabled = Object.entries(servers)
+        .filter(([name, server]) => Boolean(name) && isTomlTable(server) && server.enabled !== false)
+        .sort(([left], [right]) => left.localeCompare(right));
+    if (enabled.length === 0)
+        return null;
+    const slowest = Math.max(DEFAULT_SERVER_TIMEOUT_MS, ...enabled.map(([, server]) => {
+        if (!isTomlTable(server))
+            return DEFAULT_SERVER_TIMEOUT_MS;
+        const seconds = server.startup_timeout_sec;
+        return typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0
+            ? seconds * 1_000
+            : DEFAULT_SERVER_TIMEOUT_MS;
+    }));
+    return {
+        servers: enabled.map(([name]) => name),
+        settleTimeoutMs: Math.min(slowest + SETTLE_GRACE_MS, MAX_SETTLE_TIMEOUT_MS),
+    };
+}
+/** Enabled Provider-configured MCP servers and their synthesized settle window. */
+export function readMcpStartupPlan(runtimeHome, runtime) {
+    for (const name of configNames(runtime)) {
+        try {
+            const plan = parseMcpStartupToml(readFileSync(join(runtimeHome, name), "utf8"));
+            if (plan)
+                return plan;
+        }
+        catch {
+            // Missing/unreadable config: the Provider still owns startup; Rynx simply
+            // cannot synthesize per-server progress for this launch.
+        }
+    }
+    return null;
+}

package/dist/codex-app-server/process-registry.d.ts

@@ -0,0 +1,36 @@
+export interface RuntimeProcessEntry {
+    pid: number;
+    pgid: number;
+    ownerPid: number;
+    /** OS process-start identity. Unlike a PID, this cannot silently refer to a
+     * later process after the launcher crashes and the PID is recycled. */
+    ownerIdentity?: string;
+    sessionTag: string;
+    stateDir: string;
+}
+export declare function runtimeProcessRegistryPath(): string;
+export declare function runtimeProcessTagArg(sessionTag: string): string;
+export declare function runtimeProcessArgv0(cliPath: string, sessionTag: string): string;
+export declare function withRuntimeProcessStateArg(baseArgs: string[], stateDir: string): string[];
+export declare function registerRuntimeProcess(entry: RuntimeProcessEntry, registryPath?: string): void;
+export declare function unregisterRuntimeProcess(sessionTag: string, registryPath?: string): void;
+export interface RuntimeProcessReconcileOptions {
+    registryPath?: string;
+    ownerAlive?: (pid: number) => boolean;
+    ownerIdentity?: (pid: number) => string;
+    childAlive?: (pid: number) => boolean;
+    commandLine?: (pid: number) => string;
+    terminateGroup?: (pgid: number) => boolean;
+}
+export declare function reconcileRuntimeProcesses(opts?: RuntimeProcessReconcileOptions): number;
+export declare function reapRuntimeProcessesForStateDir(stateDir: string, opts?: RuntimeProcessStateReapOptions): number;
+export interface RuntimeProcessStateReapOptions {
+    processListing?: () => string;
+    currentPgid?: () => number;
+    childAlive?: (pid: number) => boolean;
+    signalGroup?: (pgid: number, signal: NodeJS.Signals) => boolean;
+    graceMs?: number;
+}
+/** Return an OS process-start identity used to distinguish PID reuse. */
+export declare function runtimeProcessOwnerIdentity(pid: number): string;
+export declare function newRuntimeProcessTag(): string;