@rynx-ai/runtime 0.1.10 → 0.1.11-beta.10

package/dist/index.d.ts

@@ -6,14 +6,13 @@
  */
 export { LocalAgentHost, CodexRuntimeError, SpawnCodexCommandRunner, FileCodexSessionStore, resolveCodexSessionStorePath, } from "./host.js";
 export type { CodexCapabilities, CapabilityResult, CodexRuntimeStatus, } from "./host.js";
-export type { CodexSessionStore, CodexSessionRecord } from "./codex-session-store.js";
-export { ensureCodexResumeRollout } from "./codex/rollout-synth.js";
+export type { ClaudeForkIntent, CodexSessionStore, CodexSessionRecord, } from "./codex-session-store.js";
 export { RunnerManager, TerminalOpenError } from "./runner/manager.js";
 export type { RunnerManagerOptions, RunnerSessionContext, RunnerSessionContextProvider, OpenTerminalOptions, ParentTerminal, } from "./runner/manager.js";
 export type { InjectOutcome, TerminalOpenErrorCode, TerminalRole } from "./runner/protocol.js";
 export type { ResolveInteractionResult, RuntimeInteractionEvent, RuntimeInteractionListener, } from "./interactions.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
-export { TmuxTerminal, isTmuxAvailable } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export type { TerminalAttachment, TmuxTerminalOptions } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/index.js

@@ -5,7 +5,6 @@
  * nothing about any channel.
  */
 export { LocalAgentHost, CodexRuntimeError, SpawnCodexCommandRunner, FileCodexSessionStore, resolveCodexSessionStorePath, } from "./host.js";
-export { ensureCodexResumeRollout } from "./codex/rollout-synth.js";
 // Runner subprocess layer: the parent-side manager (an `AgentExecutor` +
 // `AgentCapabilities` that spawns per-session runner children) plus the wire
 // types. The composition root uses `RunnerManager` in place of `LocalAgentHost`.
@@ -13,5 +12,5 @@ export { RunnerManager, TerminalOpenError } from "./runner/manager.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
 // Live-terminal subsystem (Phase C): tmux-backed terminals + per-runner registry.
-export { TmuxTerminal, isTmuxAvailable } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/models-catalog.d.ts

@@ -1,10 +1,12 @@
 import { type AgentRuntimeId, type AppConfig } from "@rynx-ai/core";
 import type { ModelListResponse } from "./codex-app-server/protocol.js";
 export interface RuntimeModelCatalogDeps {
+    readCodexModels?: () => Promise<unknown>;
     readTraexModels?: () => Promise<unknown>;
+    readTraexDebugModels?: () => Promise<unknown>;
 }
 /**
  * The model list for a runtime, without an execution backend.
- * Falls back to the configured model if live Traex discovery is unavailable.
+ * Falls back to the configured model if local/native discovery is unavailable.
  */
 export declare function listRuntimeModels(config: AppConfig, runtime: AgentRuntimeId, deps?: RuntimeModelCatalogDeps): Promise<ModelListResponse | null>;

package/dist/models-catalog.js

@@ -3,28 +3,51 @@
  *
  * The parent control plane no longer holds an app-server, so `/models` can't be
  * a live `model/list` RPC anymore. Following reference implementation's static-catalog model, we
- * serve a config-derived Codex list and Traex's native `models --json` catalog.
+ * serve Codex's local model cache and Traex's native `models --json` catalog.
  * claude already has its own static list ({@link listClaudeModels}).
  */
 import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { promisify } from "node:util";
-import { resolveRuntimeBinary, resolveRuntimeModel, } from "@rynx-ai/core";
+import { getRuntimeProfile, resolveRuntimeBinary, resolveRuntimeHome, resolveRuntimeModel, } from "@rynx-ai/core";
 import { listClaudeModels } from "./claude/models.js";
 const execFileAsync = promisify(execFile);
 const TRAEX_MODELS_TIMEOUT_MS = 8_000;
 const TRAEX_MODELS_MAX_BYTES = 2 * 1024 * 1024;
 /**
  * The model list for a runtime, without an execution backend.
- * Falls back to the configured model if live Traex discovery is unavailable.
+ * Falls back to the configured model if local/native discovery is unavailable.
  */
 export async function listRuntimeModels(config, runtime, deps = {}) {
     if (runtime === "claude") {
         return listClaudeModels();
     }
+    if (runtime === "codex") {
+        try {
+            const configuredDefault = resolveRuntimeModel(config, runtime).trim();
+            const models = normalizeCodexModels(await (deps.readCodexModels ?? readCodexModels)(), configuredDefault);
+            if (models.length > 0)
+                return { data: models };
+        }
+        catch {
+            // Keep the configured fallback usable before Codex has populated its cache.
+        }
+    }
     if (runtime === "traex") {
         try {
             const value = await (deps.readTraexModels ?? readTraexModels)();
-            const models = normalizeTraexModels(value, resolveRuntimeModel(config, runtime).trim());
+            const configuredDefault = resolveRuntimeModel(config, runtime).trim();
+            const defaultModel = configuredDefault || resolveTraexNativeDefault(await (deps.readTraexDebugModels ?? readTraexDebugModels)());
+            if (!configuredDefault &&
+                (!Array.isArray(value) ||
+                    !value.some((item) => item &&
+                        typeof item === "object" &&
+                        !Array.isArray(item) &&
+                        item.name === defaultModel))) {
+                throw new Error(`Traex native default is missing from the public catalog: ${defaultModel}`);
+            }
+            const models = normalizeTraexModels(value, defaultModel);
             if (models.length > 0)
                 return { data: models };
         }
@@ -38,6 +61,72 @@ export async function listRuntimeModels(config, runtime, deps = {}) {
     }
     return { data: [{ id: model, model, isDefault: true }] };
 }
+async function readCodexModels() {
+    const cachePath = join(resolveRuntimeHome(getRuntimeProfile("codex")), "models_cache.json");
+    return JSON.parse(await readFile(cachePath, "utf8"));
+}
+function normalizeCodexModels(value, configuredDefault) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const entries = value.models;
+    if (!Array.isArray(entries))
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const item of entries) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const record = item;
+        const id = typeof record.slug === "string" ? record.slug.trim() : "";
+        if (!id || seen.has(id) || record.visibility === "hide")
+            continue;
+        seen.add(id);
+        const supportedReasoningEfforts = Array.isArray(record.supported_reasoning_levels)
+            ? record.supported_reasoning_levels.flatMap((raw) => {
+                if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                    return [];
+                const effort = typeof raw.effort === "string"
+                    ? raw.effort.trim()
+                    : "";
+                if (!effort)
+                    return [];
+                const description = raw.description;
+                return [{
+                        reasoningEffort: effort,
+                        ...(typeof description === "string" && description.trim()
+                            ? { description: description.trim() }
+                            : {}),
+                    }];
+            })
+            : [];
+        const displayName = typeof record.display_name === "string"
+            ? record.display_name.trim()
+            : "";
+        const description = typeof record.description === "string"
+            ? record.description.trim()
+            : "";
+        const defaultReasoningEffort = typeof record.default_reasoning_level === "string"
+            ? record.default_reasoning_level.trim()
+            : "";
+        models.push({
+            id,
+            model: id,
+            ...(displayName ? { displayName } : {}),
+            ...(description ? { description } : {}),
+            isDefault: id === configuredDefault,
+            ...(supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts } : {}),
+            ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+        });
+    }
+    if (configuredDefault && !seen.has(configuredDefault)) {
+        models.unshift({
+            id: configuredDefault,
+            model: configuredDefault,
+            isDefault: true,
+        });
+    }
+    return models;
+}
 async function readTraexModels() {
     const { stdout } = await execFileAsync(resolveRuntimeBinary("traex"), ["models", "--json"], {
         encoding: "utf8",
@@ -46,6 +135,38 @@ async function readTraexModels() {
     });
     return JSON.parse(stdout);
 }
+async function readTraexDebugModels() {
+    const { stdout } = await execFileAsync(resolveRuntimeBinary("traex"), ["debug", "models"], {
+        encoding: "utf8",
+        timeout: TRAEX_MODELS_TIMEOUT_MS,
+        maxBuffer: TRAEX_MODELS_MAX_BYTES,
+    });
+    return JSON.parse(stdout);
+}
+function resolveTraexNativeDefault(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Traex debug model catalog is invalid");
+    }
+    const models = value.models;
+    if (!Array.isArray(models)) {
+        throw new Error("Traex debug model catalog is invalid");
+    }
+    const defaults = models.filter((item) => item &&
+        typeof item === "object" &&
+        !Array.isArray(item) &&
+        item.business_metadata &&
+        typeof item.business_metadata === "object" &&
+        item.business_metadata
+            .backend_is_default === true);
+    if (defaults.length !== 1) {
+        throw new Error(`Traex debug model catalog has ${defaults.length} native defaults`);
+    }
+    const name = defaults[0].config_name;
+    if (typeof name !== "string" || !name.trim()) {
+        throw new Error("Traex native default has no config_name");
+    }
+    return name.trim();
+}
 function normalizeTraexModels(value, configuredDefault) {
     if (!Array.isArray(value))
         return [];

package/dist/provider-workspace.d.ts

@@ -0,0 +1,56 @@
+import type { AgentRuntimeId, SandboxMode } from "@rynx-ai/core";
+import type { PermissionProfileSelectionParams, SandboxPolicy } from "./codex-app-server/protocol.js";
+/** Structural view of the immutable Session workspace snapshot. The canonical
+ * type lives in core; keeping the adapter input structural avoids inventing a
+ * second domain model in the Provider layer. */
+export interface ProviderWorkspace {
+    readonly cwd: string;
+    readonly allowedDirs: readonly string[];
+}
+/** Canonical roots projected without mutating the Session snapshot, with the
+ * primary working directory first for every Provider. */
+export declare function providerWorkspaceRoots(workspace: ProviderWorkspace): string[];
+export declare function providerAdditionalDirs(workspace: ProviderWorkspace): string[];
+export declare function sandboxPolicyForWorkspace(mode: SandboxMode, workspace: ProviderWorkspace): SandboxPolicy;
+export declare function codexThreadWorkspaceParams(workspace: ProviderWorkspace): {
+    cwd: string;
+    runtimeWorkspaceRoots: string[];
+};
+export declare function codexTurnWorkspaceParams(workspace: ProviderWorkspace, mode: SandboxMode): {
+    cwd: string;
+    runtimeWorkspaceRoots: string[];
+    sandboxPolicy: SandboxPolicy;
+};
+/** Traex has no runtimeWorkspaceRoots field. For a multi-root writable
+ * workspace, use the bounded named-profile modification supported by Traex
+ * 0.200; never combine it with the legacy sandbox field. */
+export declare function traexThreadWorkspaceParams(workspace: ProviderWorkspace, mode: SandboxMode): {
+    cwd: string;
+    permissions: PermissionProfileSelectionParams;
+} | {
+    cwd: string;
+    sandbox: SandboxMode;
+};
+/** Turn equivalent of {@link traexThreadWorkspaceParams}; `permissions` and
+ * `sandboxPolicy` are intentionally mutually exclusive. */
+export declare function traexTurnWorkspaceParams(workspace: ProviderWorkspace, mode: SandboxMode): {
+    cwd: string;
+    permissions: PermissionProfileSelectionParams;
+} | {
+    cwd: string;
+    sandboxPolicy: SandboxPolicy;
+};
+export declare function threadWorkspaceParams(runtime: Exclude<AgentRuntimeId, "claude">, workspace: ProviderWorkspace, mode: SandboxMode): {
+    cwd: string;
+    permissions: PermissionProfileSelectionParams;
+} | {
+    cwd: string;
+    sandbox: SandboxMode;
+};
+export declare function turnWorkspaceParams(runtime: Exclude<AgentRuntimeId, "claude">, workspace: ProviderWorkspace, mode: SandboxMode): {
+    cwd: string;
+    permissions: PermissionProfileSelectionParams;
+} | {
+    cwd: string;
+    sandboxPolicy: SandboxPolicy;
+};

package/dist/provider-workspace.js

@@ -0,0 +1,83 @@
+/** Canonical roots projected without mutating the Session snapshot, with the
+ * primary working directory first for every Provider. */
+export function providerWorkspaceRoots(workspace) {
+    return [...new Set([workspace.cwd, ...workspace.allowedDirs])];
+}
+export function providerAdditionalDirs(workspace) {
+    return providerWorkspaceRoots(workspace).filter((dir) => dir !== workspace.cwd);
+}
+export function sandboxPolicyForWorkspace(mode, workspace) {
+    switch (mode) {
+        case "read-only":
+            return { type: "readOnly", networkAccess: false };
+        case "workspace-write":
+            return {
+                type: "workspaceWrite",
+                writableRoots: providerWorkspaceRoots(workspace),
+                networkAccess: true,
+                excludeTmpdirEnvVar: false,
+                excludeSlashTmp: false,
+            };
+        case "danger-full-access":
+            return { type: "dangerFullAccess" };
+    }
+}
+export function codexThreadWorkspaceParams(workspace) {
+    return {
+        cwd: workspace.cwd,
+        runtimeWorkspaceRoots: providerWorkspaceRoots(workspace),
+    };
+}
+export function codexTurnWorkspaceParams(workspace, mode) {
+    return {
+        ...codexThreadWorkspaceParams(workspace),
+        sandboxPolicy: sandboxPolicyForWorkspace(mode, workspace),
+    };
+}
+function traexWorkspacePermissions(workspace) {
+    const additionalDirs = providerAdditionalDirs(workspace);
+    if (additionalDirs.length === 0)
+        return undefined;
+    return {
+        type: "profile",
+        id: ":workspace",
+        modifications: additionalDirs.map((path) => ({
+            type: "additionalWritableRoot",
+            path,
+        })),
+    };
+}
+/** Traex has no runtimeWorkspaceRoots field. For a multi-root writable
+ * workspace, use the bounded named-profile modification supported by Traex
+ * 0.200; never combine it with the legacy sandbox field. */
+export function traexThreadWorkspaceParams(workspace, mode) {
+    const permissions = mode === "workspace-write"
+        ? traexWorkspacePermissions(workspace)
+        : undefined;
+    return permissions
+        ? { cwd: workspace.cwd, permissions }
+        : { cwd: workspace.cwd, sandbox: mode };
+}
+/** Turn equivalent of {@link traexThreadWorkspaceParams}; `permissions` and
+ * `sandboxPolicy` are intentionally mutually exclusive. */
+export function traexTurnWorkspaceParams(workspace, mode) {
+    const permissions = mode === "workspace-write"
+        ? traexWorkspacePermissions(workspace)
+        : undefined;
+    return permissions
+        ? { cwd: workspace.cwd, permissions }
+        : {
+            cwd: workspace.cwd,
+            sandboxPolicy: sandboxPolicyForWorkspace(mode, workspace),
+        };
+}
+export function threadWorkspaceParams(runtime, workspace, mode) {
+    return runtime === "traex"
+        ? traexThreadWorkspaceParams(workspace, mode)
+        : { ...codexThreadWorkspaceParams(workspace), sandbox: mode };
+}
+export function turnWorkspaceParams(runtime, workspace, mode) {
+    return runtime === "traex"
+        ? traexTurnWorkspaceParams(workspace, mode)
+        : codexTurnWorkspaceParams(workspace, mode);
+}

package/dist/runner/child.d.ts

@@ -7,12 +7,61 @@
  * per-thread capabilities, answered against the same backend so the parent never
  * needs an app-server of its own.
  */
-import { type AgentCapabilities } from "@rynx-ai/core";
+import { type AgentCapabilities, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import type { SessionEvent } from "@rynx-ai/core";
+import type { TerminalInjector } from "../claude/native-integration.js";
+import type { ResolveInteractionResult } from "../interactions.js";
+import { type InjectOutcome } from "./protocol.js";
 import type { ChildTransport } from "./transport.js";
+/** Re-target the mirror to a freshly minted rynx session (claude `/clear`·`/fork`)
+ *  + record the terminal transfer with the daemon. The child owns the transport,
+ *  so it supplies this to the host. */
+type RetargetMirror = (newSessionId: string, meta: {
+    kind: "clear" | "fork";
+    workspace: SessionWorkspaceSnapshot;
+    execution: ResolvedExecutionSnapshot;
+    parentSessionId?: string;
+}) => void;
+/** Codex-native live-session methods the executor (a `LocalAgentHost`) exposes
+ *  beyond the `AgentExecutor`/`AgentCapabilities` contract. Duck-typed so the
+ *  runner works with any executor (a claude-only host simply lacks them). */
+interface LiveCodexProvider {
+    codexTerminalSpec?(localThreadId: string): Promise<{
+        command: string;
+        args: string[];
+        cwd: string;
+        env?: Record<string, string>;
+        skipTraexStartupPrompts?: boolean;
+    } | null>;
+    ensureLiveCodexSession?(localThreadId: string, emit: (event: SessionEvent) => void, opts: {
+        workspace: SessionWorkspaceSnapshot;
+        execution: ResolvedExecutionSnapshot;
+        retargetMirror?: RetargetMirror;
+    }): Promise<boolean>;
+    waitLiveReady?(localThreadId: string, timeoutMs?: number): Promise<boolean>;
+    waitTerminalReady?(localThreadId: string, timeoutMs?: number): Promise<boolean>;
+    liveSessionError?(localThreadId: string): string | undefined;
+    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    interruptLive?(localThreadId: string): Promise<boolean>;
+    stopLiveCodexSession?(localThreadId: string, opts?: {
+        deferClaudeInteractionCleanup?: boolean;
+    }): void;
+    finalizeStoppedLiveSessions?(): void;
+    resolveInteraction?(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
+    /** claude-native: hand the session's tmux pane injector to the host (which
+     *  doesn't own tmux). No-op for codex sessions (they inject via app-server). */
+    attachTerminalInjector?(localThreadId: string, injector: TerminalInjector): void;
+    /** Internal Provider operation used only by MachineSessionService through
+     * RunnerManager. It is deliberately absent from public AgentCapabilities. */
+    forkSession?(currentLocalThreadId: string, newLocalThreadId: string, options: {
+        workspace: SessionWorkspaceSnapshot;
+        execution: ResolvedExecutionSnapshot;
+    }): Promise<import("@rynx-ai/core").CapabilityResult>;
+}
 export interface RunnerSessionDeps {
     transport: ChildTransport;
     /** The single-backend capability + live co-drive surface (a `LocalAgentHost`). */
-    executor: AgentCapabilities;
+    executor: AgentCapabilities & LiveCodexProvider;
     /** Invoked on a `shutdown` message (default: close transport). */
     onShutdown?: () => void;
 }
@@ -23,6 +72,8 @@ export declare class RunnerSession {
     /** Live terminals hosted by this session, and per-attach client handles. */
     private readonly terminals;
     private readonly attachments;
+    private readonly attachmentThreadIds;
+    private readonly traexStartupWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
     private readonly pendingTerminalOpens;
     private readonly cancelledTerminalOpens;
@@ -42,10 +93,9 @@ export declare class RunnerSession {
     /**
      * Eagerly bring up a session's codex-native live view: start the persistent
      * forwarder connection (which resume-subscribes to mirror every turn) and
-     * launch the detached `codex --remote` TUI, which CREATES the codex thread. The
-     * forwarder's connection sees the TUI's broadcast `thread/started`, binds, and
-     * subscribes — so the TUI is usable immediately (a fresh `--remote` needs no
-     * rollout) and its turns mirror to chat (reference implementation's model).
+     * launch the detached `codex --remote resume` TUI against the thread the
+     * structured runtime created. The forwarder subscribes to that same thread,
+     * so the TUI is usable immediately and its turns mirror to chat.
      */
     private ensureLive;
     private inject;
@@ -54,6 +104,8 @@ export declare class RunnerSession {
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,
      *  so the web attach reuses the same detached pane. */
     private launchCodexPane;
+    private cancelTraexStartupWatcher;
+    private skipTraexStartupPrompts;
     private stopLive;
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */
@@ -64,3 +116,4 @@ export declare class RunnerSession {
     private runCap;
     private dispatchCap;
 }
+export {};