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

package/dist/runner-main.js

@@ -16,7 +16,7 @@
  * active-session display, which tolerate atomic-rename reads). A parent-of-record
  * design (ship-in / emit-out) is the remote-ready follow-up.
  */
-import { loadConfig, } from "@rynx-ai/core";
+import { loadConfig } from "@rynx-ai/core";
 import { FileCodexSessionStore, LocalAgentHost, resolveCodexSessionStorePath, } from "./host.js";
 import { RunnerSession } from "./runner/child.js";
 import { StdioRunnerTransport } from "./runner/transport.js";
@@ -33,15 +33,20 @@ for (const stream of [process.stdout, process.stderr]) {
         throw err;
     });
 }
-function main() {
+async function main() {
     const config = loadConfig();
     const sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config));
+    const sessionId = process.env.RYNX_RUNNER_SESSION;
+    const binding = sessionId ? await sessionStore.get(sessionId) : null;
     const executor = new LocalAgentHost({
         config,
         sessionStore,
         // The manager spawns one child per session and passes its key here so the
         // host's private CODEX_HOME is scoped to this session (see manager.spawnHandle).
-        ...(process.env.RYNX_RUNNER_SESSION ? { sessionId: process.env.RYNX_RUNNER_SESSION } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        ...(binding?.runtimeHomeOwnerSessionId
+            ? { runtimeHomeSessionId: binding.runtimeHomeOwnerSessionId }
+            : {}),
     });
     const transport = new StdioRunnerTransport(process.stdin, process.stdout);
     let runner;
@@ -61,4 +66,7 @@ function main() {
     // as the protocol shutdown before ending the process.
     process.on("SIGTERM", () => runner?.shutdown());
 }
-main();
+void main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/runtime-state-paths.d.ts

@@ -0,0 +1,10 @@
+export declare function runtimeSessionDigest(sessionId: string): string;
+export declare function runtimeSessionStateDir(sessionId: string): string;
+/** Pre-standardization uid-private temp root, read only for opaque directory adoption. */
+export declare function legacyRuntimeStateRoot(): string;
+/**
+ * Adopt a pre-standardization runtime directory without interpreting Provider
+ * files. Rename when possible; cross-device filesystems fall back to an opaque
+ * recursive copy followed by removal.
+ */
+export declare function adoptLegacyRuntimeDirectory(legacyDirectory: string, canonicalDirectory: string): void;

package/dist/runtime-state-paths.js

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, renameSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { rynxRuntimeDir } from "@rynx-ai/core";
+export function runtimeSessionDigest(sessionId) {
+    return createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+}
+export function runtimeSessionStateDir(sessionId) {
+    return join(rynxRuntimeDir(), "sessions", runtimeSessionDigest(sessionId));
+}
+/** Pre-standardization uid-private temp root, read only for opaque directory adoption. */
+export function legacyRuntimeStateRoot() {
+    const uid = typeof process.getuid === "function" ? process.getuid() : "nouid";
+    return join(tmpdir(), `rynx-${uid}`);
+}
+/**
+ * Adopt a pre-standardization runtime directory without interpreting Provider
+ * files. Rename when possible; cross-device filesystems fall back to an opaque
+ * recursive copy followed by removal.
+ */
+export function adoptLegacyRuntimeDirectory(legacyDirectory, canonicalDirectory) {
+    if (existsSync(canonicalDirectory) || !existsSync(legacyDirectory))
+        return;
+    mkdirSync(dirname(canonicalDirectory), { recursive: true, mode: 0o700 });
+    try {
+        renameSync(legacyDirectory, canonicalDirectory);
+        return;
+    }
+    catch {
+        if (existsSync(canonicalDirectory) || !existsSync(legacyDirectory))
+            return;
+    }
+    const stagingDirectory = `${canonicalDirectory}.adopt-${process.pid}-${Date.now().toString(36)}`;
+    try {
+        cpSync(legacyDirectory, stagingDirectory, {
+            recursive: true,
+            errorOnExist: true,
+            force: false,
+        });
+        try {
+            renameSync(stagingDirectory, canonicalDirectory);
+        }
+        catch (error) {
+            if (!existsSync(canonicalDirectory))
+                throw error;
+        }
+        rmSync(legacyDirectory, { recursive: true, force: true });
+    }
+    finally {
+        rmSync(stagingDirectory, { recursive: true, force: true });
+    }
+}

package/dist/terminal/claude-tui.d.ts

@@ -22,6 +22,13 @@ export interface ClaudeTuiArgs {
     appendSystemPrompt?: string;
     /** Resume a specific prior claude session (`--resume <id>`). */
     resume?: string;
+    /** Fork the resumed conversation into a new native Session. */
+    forkSession?: boolean;
+    /** Deterministic native UUID for a fork target. */
+    sessionId?: string;
+    /** Session workspace roots beyond the primary process cwd. Claude accepts
+     * these as one variadic `--add-dir` flag on fresh and resumed launches. */
+    additionalDirs?: string[];
     /** Extra claude args placed before the injected flags (rarely needed). */
     extraArgs?: string[];
 }
@@ -29,4 +36,4 @@ export interface ClaudeTuiArgs {
  * Build the `claude` argv for an interactive, co-drivable TUI:
  * `[..extra] [--resume <id>] [--model <m>] [--append-system-prompt <text>] --settings <json>`.
  */
-export declare function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, extraArgs, }: ClaudeTuiArgs): string[];
+export declare function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, forkSession, sessionId, additionalDirs, extraArgs, }: ClaudeTuiArgs): string[];

package/dist/terminal/claude-tui.js

@@ -2,12 +2,18 @@
  * Build the `claude` argv for an interactive, co-drivable TUI:
  * `[..extra] [--resume <id>] [--model <m>] [--append-system-prompt <text>] --settings <json>`.
  */
-export function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, extraArgs = [], }) {
+export function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, forkSession = false, sessionId, additionalDirs = [], extraArgs = [], }) {
     const args = [...extraArgs];
+    if (additionalDirs.length > 0)
+        args.push("--add-dir", ...additionalDirs);
     if (settingSources !== undefined)
         args.push("--setting-sources", settingSources);
     if (resume)
         args.push("--resume", resume);
+    if (forkSession)
+        args.push("--fork-session");
+    if (sessionId)
+        args.push("--session-id", sessionId);
     if (model)
         args.push("--model", model);
     if (appendSystemPrompt)

package/dist/terminal/codex-tui.d.ts

@@ -29,12 +29,16 @@ export interface CodexRemoteArgs {
     configOverrides?: string[];
     /** Extra codex args that precede the attach flags (e.g. `["--model", "..."]`). */
     codexArgs?: string[];
+    /** Session workspace roots beyond the primary process cwd. Replayed on fresh
+     * launch and resume so the remote TUI uses the same immutable workspace
+     * snapshot as the App Server clients. */
+    additionalDirs?: string[];
 }
 /**
  * Build the `codex` argv tail for an app-server-backed TUI. Mirrors reference implementation's
  * `build_codex_remote_args` exactly: overrides → codexArgs → (resume) → --remote.
  */
-export declare function buildCodexRemoteArgs({ remoteUrl, threadId, configOverrides, codexArgs, }: CodexRemoteArgs): string[];
+export declare function buildCodexRemoteArgs({ remoteUrl, threadId, configOverrides, codexArgs, additionalDirs, }: CodexRemoteArgs): string[];
 export interface LaunchCodexTuiOptions extends CodexRemoteArgs {
     registry: TerminalRegistry;
     /** Terminal id (one codex TUI per session — `terminal_codex_main`). */

package/dist/terminal/codex-tui.js

@@ -2,12 +2,21 @@
  * Build the `codex` argv tail for an app-server-backed TUI. Mirrors reference implementation's
  * `build_codex_remote_args` exactly: overrides → codexArgs → (resume) → --remote.
  */
-export function buildCodexRemoteArgs({ remoteUrl, threadId, configOverrides = [], codexArgs = [], }) {
+export function buildCodexRemoteArgs({ remoteUrl, threadId, configOverrides = [], codexArgs = [], additionalDirs = [], }) {
     const overrideArgs = configOverrides.flatMap((override) => ["-c", override]);
+    const additionalDirArgs = additionalDirs.flatMap((dir) => ["--add-dir", dir]);
     if (threadId === undefined) {
-        return [...overrideArgs, ...codexArgs, "--remote", remoteUrl];
+        return [...overrideArgs, ...codexArgs, ...additionalDirArgs, "--remote", remoteUrl];
     }
-    return [...overrideArgs, ...codexArgs, "resume", "--remote", remoteUrl, threadId];
+    return [
+        ...overrideArgs,
+        ...codexArgs,
+        ...additionalDirArgs,
+        "resume",
+        "--remote",
+        remoteUrl,
+        threadId,
+    ];
 }
 /**
  * Create (idempotently) the codex TUI terminal in the registry, running the real

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.10",
+  "version": "0.1.11-beta.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -26,7 +26,7 @@
   "dependencies": {
     "node-pty": "^1.0.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.10"
+    "@rynx-ai/core": "0.1.11-beta.2"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"

package/dist/codex/rollout-synth.d.ts

@@ -1,42 +0,0 @@
-import { type SessionItem } from "@rynx-ai/core";
-import { type CodexLineageRuntime } from "../codex-home.js";
-export interface SynthesizeRolloutOptions {
-    threadId: string;
-    cwd: string;
-    items: SessionItem[];
-    /** The rynx session (localThreadId) — resolves the per-session private CODEX_HOME
-     *  (`codexHomePath(sessionId)`). Required unless `codexHome` is passed directly. */
-    sessionId?: string;
-    /** Override the private CODEX_HOME (tests, or a pre-resolved home). */
-    codexHome?: string;
-    /** Codex-lineage runtime whose private home/session layout is being written. */
-    runtime?: CodexLineageRuntime;
-    /** Runtime-neutral alias for `codexHome`; preferred for Traex callers. */
-    runtimeHome?: string;
-    /** codex CLI version for `session_meta` (informational for ≥0.133; presence
-     *  matters). */
-    cliVersion?: string;
-    /** `session_meta.model_provider` — an empty/unresolvable value silently drops the
-     *  carried history on resume. Defaults to `openai`. */
-    modelProvider?: string;
-    /** Clock injection (tests). */
-    now?: () => number;
-}
-interface RolloutRecord {
-    timestamp: string;
-    type: "session_meta" | "turn_context" | "response_item" | "event_msg";
-    payload: Record<string, unknown>;
-}
-/** Locate an existing rollout for `threadId` under the runtime's sessions root. */
-export declare function findCodexRollout(runtimeHome: string, threadId: string, runtime?: CodexLineageRuntime): string | null;
-/** Build the ordered rollout records (session_meta first, then per-turn
- *  turn_context + per-item response_item + per-message event_msg). */
-export declare function buildRolloutRecords(opts: SynthesizeRolloutOptions): RolloutRecord[];
-/**
- * Ensure a resumable codex rollout exists for `threadId`. No-op if one is already
- * present (codex owns its own runtime rollouts). Otherwise synthesize one from the
- * session items and write it atomically. Returns `"exists"`, `"written"`, or
- * `"skipped"` (invalid thread id / nothing to carry). Best-effort: never throws.
- */
-export declare function ensureCodexResumeRollout(opts: SynthesizeRolloutOptions): "exists" | "written" | "skipped";
-export {};

package/dist/codex/rollout-synth.js

@@ -1,245 +0,0 @@
-/**
- * Synthesize a codex rollout file from rynx's canonical session log, so
- * `codex --remote resume <threadId>` works when the local rollout is missing
- * (fork / worktree / cross-machine). Ports reference implementation's
- * `_ensure_local_codex_resume_rollout`, adapted to rynx: the daemon (control-api)
- * has BOTH the session items (`SessionLogStore`) and — since the private CODEX_HOME
- * is a deterministic uid-scoped path — the app-server's rollout dir, so this runs
- * entirely daemon-side with no runner round-trip.
- *
- * The record shapes match codex 0.142.5 (empirically captured). The minimal set
- * codex needs to resume with VISIBLE turns is: a `session_meta` first line, then
- * per item a `response_item`, and — critically — an `event_msg` mirror per message
- * (codex ≥0.136 renders an empty thread without them). `turn_context` groups items
- * into turns.
- */
-import { createHash } from "node:crypto";
-import { copyFileSync, mkdirSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
-import { getRuntimeProfile, resolveRuntimeHome, rynxHome, } from "@rynx-ai/core";
-import { legacyCodexHomePath, runtimeHomePath, } from "../codex-home.js";
-/** codex validates the thread id straight into a filename + resume arg. */
-const THREAD_ID_RE = /^[0-9a-fA-F-]+$/;
-function sessionsRoot(runtimeHome, runtime) {
-    return join(runtimeHome, ...getRuntimeProfile(runtime).sessionsSubpath);
-}
-/** Locate an existing rollout for `threadId` under the runtime's sessions root. */
-export function findCodexRollout(runtimeHome, threadId, runtime = "codex") {
-    const root = sessionsRoot(runtimeHome, runtime);
-    const suffix = `-${threadId}.jsonl`;
-    const stack = [root];
-    while (stack.length) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue; // missing dir — fine
-        }
-        for (const e of entries) {
-            const full = join(dir, e.name);
-            if (e.isDirectory())
-                stack.push(full);
-            else if (e.name.startsWith("rollout-") && e.name.endsWith(suffix))
-                return full;
-        }
-    }
-    return null;
-}
-/**
- * Back-compat: before per-session homes, rollouts lived under one shared
- * {@link legacyCodexHomePath}. If a session's rollout is only there, copy it forward
- * into this session's home (preserving the `sessions/YYYY/MM/DD/` layout codex
- * expects) so the per-session app-server can resume it. Best-effort; gated by
- * `RYNX_CODEX_HOME_LEGACY_FALLBACK` (default on; set `0`/`false` to disable).
- */
-function adoptLegacyRollout(runtimeHome, threadId, runtime) {
-    const flag = (process.env.RYNX_RUNTIME_HOME_LEGACY_FALLBACK
-        ?? process.env.RYNX_CODEX_HOME_LEGACY_FALLBACK)?.trim().toLowerCase();
-    if (flag === "0" || flag === "false")
-        return false;
-    const legacy = runtime === "codex"
-        ? legacyCodexHomePath()
-        : resolveRuntimeHome(getRuntimeProfile(runtime));
-    if (legacy === runtimeHome)
-        return false;
-    const src = findCodexRollout(legacy, threadId, runtime);
-    if (!src)
-        return false;
-    const rel = relative(sessionsRoot(legacy, runtime), src);
-    const dst = join(sessionsRoot(runtimeHome, runtime), rel);
-    try {
-        mkdirSync(join(dst, ".."), { recursive: true, mode: 0o700 });
-        copyFileSync(src, dst);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function iso(ms) {
-    return new Date(ms).toISOString();
-}
-/** `resp_codex_<turnId>` → `<turnId>` (rynx derives the responseId from the codex
- *  turn id); anything else is used verbatim as a stable turn key. */
-function turnIdOf(responseId) {
-    return responseId.startsWith("resp_codex_") ? responseId.slice("resp_codex_".length) : responseId;
-}
-function textOf(item) {
-    return item.data.content
-        .filter((part) => "text" in part)
-        .map((part) => part.text)
-        .join("");
-}
-/** Convert one canonical {@link SessionItem} to its codex `response_item` payload,
- *  or null for types codex doesn't carry (reasoning/terminal_command/error). */
-function responseItemPayload(item) {
-    switch (item.type) {
-        case "message": {
-            const apiType = item.data.role === "assistant" ? "output_text" : "input_text";
-            const content = item.data.content.flatMap((part) => "text" in part && part.text
-                ? [{ type: apiType, text: part.text }]
-                : []);
-            if (content.length === 0)
-                return null;
-            return { type: "message", role: item.data.role, content };
-        }
-        case "function_call":
-            return {
-                type: "function_call",
-                name: item.data.name,
-                call_id: item.data.callId,
-                arguments: item.data.arguments,
-            };
-        case "function_call_output":
-            return { type: "function_call_output", call_id: item.data.callId, output: item.data.output };
-        default:
-            return null;
-    }
-}
-/** The `event_msg` mirror for a message (required for a VISIBLE turn on codex ≥0.136). */
-function eventMsgPayload(item, sessionId) {
-    const message = textOf(item).trim();
-    const localImages = item.data.role === "user" && sessionId
-        ? item.data.content.flatMap((part) => part.type === "input_image" ? [resourcePath(sessionId, part)] : [])
-        : [];
-    if (!message && localImages.length === 0)
-        return null;
-    if (item.data.role === "user") {
-        return {
-            type: "user_message",
-            message,
-            images: [],
-            local_images: localImages,
-            text_elements: [],
-        };
-    }
-    if (item.data.role === "assistant") {
-        return { type: "agent_message", message, phase: "final_answer", memory_citation: null };
-    }
-    return null;
-}
-function resourcePath(sessionId, part) {
-    const sessionKey = createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
-    const extension = part.mediaType === "image/png"
-        ? "png"
-        : part.mediaType === "image/jpeg"
-            ? "jpg"
-            : "webp";
-    return join(rynxHome(), "resources", sessionKey, `${part.resourceId}.${extension}`);
-}
-/** Build the ordered rollout records (session_meta first, then per-turn
- *  turn_context + per-item response_item + per-message event_msg). */
-export function buildRolloutRecords(opts) {
-    const now = opts.now ?? (() => Date.now());
-    const modelProvider = opts.modelProvider ?? (opts.runtime === "traex" ? "trae" : "openai");
-    const cliVersion = opts.cliVersion ?? "0.0.0";
-    const metaTs = iso(opts.items[0]?.createdAt ?? now());
-    const records = [
-        {
-            timestamp: metaTs,
-            type: "session_meta",
-            payload: {
-                id: opts.threadId,
-                session_id: opts.threadId,
-                timestamp: metaTs,
-                cwd: opts.cwd,
-                originator: "rynx",
-                cli_version: cliVersion,
-                source: "rynx",
-                thread_source: "user",
-                model_provider: modelProvider,
-            },
-        },
-    ];
-    const seenTurns = new Set();
-    for (const item of opts.items) {
-        const payload = responseItemPayload(item);
-        const eventPayload = item.type === "message"
-            ? eventMsgPayload(item, opts.sessionId)
-            : null;
-        if (!payload && !eventPayload)
-            continue;
-        const ts = iso(item.createdAt);
-        const turnId = turnIdOf(item.responseId);
-        if (!seenTurns.has(turnId)) {
-            seenTurns.add(turnId);
-            records.push({
-                timestamp: ts,
-                type: "turn_context",
-                payload: { turn_id: turnId, cwd: opts.cwd, approval_policy: "on-request" },
-            });
-        }
-        if (payload)
-            records.push({ timestamp: ts, type: "response_item", payload });
-        if (eventPayload)
-            records.push({ timestamp: ts, type: "event_msg", payload: eventPayload });
-    }
-    return records;
-}
-/**
- * Ensure a resumable codex rollout exists for `threadId`. No-op if one is already
- * present (codex owns its own runtime rollouts). Otherwise synthesize one from the
- * session items and write it atomically. Returns `"exists"`, `"written"`, or
- * `"skipped"` (invalid thread id / nothing to carry). Best-effort: never throws.
- */
-export function ensureCodexResumeRollout(opts) {
-    if (!THREAD_ID_RE.test(opts.threadId))
-        return "skipped";
-    const runtime = opts.runtime ?? "codex";
-    const runtimeHome = opts.runtimeHome
-        ?? opts.codexHome
-        ?? (opts.sessionId ? runtimeHomePath(opts.sessionId, runtime) : undefined);
-    if (!runtimeHome)
-        return "skipped"; // no session context → can't locate the home
-    if (findCodexRollout(runtimeHome, opts.threadId, runtime))
-        return "exists";
-    // Back-compat: a pre-per-session rollout may live under the OLD shared home. Copy
-    // it forward into this session's home so the per-session app-server can resume it.
-    if (adoptLegacyRollout(runtimeHome, opts.threadId, runtime))
-        return "exists";
-    const records = buildRolloutRecords(opts);
-    // Nothing but the session_meta header → no history to carry; skip (a fresh
-    // thread resumes fine without a rollout once it has run a turn).
-    if (records.length <= 1)
-        return "skipped";
-    const now = opts.now ?? (() => Date.now());
-    const d = new Date(now());
-    const yyyy = String(d.getUTCFullYear());
-    const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
-    const dd = String(d.getUTCDate()).padStart(2, "0");
-    const stamp = iso(d.getTime()).slice(0, 19).replace(/:/g, "-"); // YYYY-MM-DDTHH-MM-SS
-    const dir = join(sessionsRoot(runtimeHome, runtime), yyyy, mm, dd);
-    const target = join(dir, `rollout-${stamp}-${opts.threadId}.jsonl`);
-    const tmp = `${target}.tmp`;
-    try {
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-        writeFileSync(tmp, records.map((r) => JSON.stringify(r)).join("\n") + "\n");
-        renameSync(tmp, target);
-        return "written";
-    }
-    catch {
-        return "skipped"; // best-effort: a failed synth just leaves resume to fail as before
-    }
-}