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

package/dist/claude/settings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Build the single explicit settings document for a rynx-managed Claude
+ * Session. Host/project settings still provide auth, env and permission policy,
+ * but their plugins and hooks are excluded: rynx must be the only owner of
+ * PermissionRequest and AskUserQuestion, and Agent Skills arrive only through
+ * the selected `--plugin-dir`.
+ */
+export declare function buildManagedClaudeSettings(cwd: string, rynxSettings: object, configDir?: string): Record<string, unknown>;

package/dist/claude/settings.js

@@ -0,0 +1,50 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readSettings(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return isRecord(value) ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+function mergeSettings(base, override) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const current = merged[key];
+        merged[key] = isRecord(current) && isRecord(value)
+            ? mergeSettings(current, value)
+            : value;
+    }
+    return merged;
+}
+/**
+ * Build the single explicit settings document for a rynx-managed Claude
+ * Session. Host/project settings still provide auth, env and permission policy,
+ * but their plugins and hooks are excluded: rynx must be the only owner of
+ * PermissionRequest and AskUserQuestion, and Agent Skills arrive only through
+ * the selected `--plugin-dir`.
+ */
+export function buildManagedClaudeSettings(cwd, rynxSettings, configDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude")) {
+    const sources = [
+        join(configDir, "settings.json"),
+        join(cwd, ".claude", "settings.json"),
+        join(cwd, ".claude", "settings.local.json"),
+    ];
+    let inherited = {};
+    for (const source of sources)
+        inherited = mergeSettings(inherited, readSettings(source));
+    // These sources can register competing interaction owners or host Skills.
+    // Rynx injects its own hooks/status line below and selected Skills separately.
+    delete inherited.hooks;
+    delete inherited.statusLine;
+    delete inherited.disableAllHooks;
+    delete inherited.enabledPlugins;
+    delete inherited.extraKnownMarketplaces;
+    return mergeSettings(inherited, rynxSettings);
+}

package/dist/claude/transcript.d.ts

@@ -45,10 +45,10 @@ export declare function parseTranscriptRecord(record: unknown, opts?: ParseTrans
 /**
  * Whether a transcript is a `/fork` (branch) of another session: claude stamps a
  * `forkedFrom: { sessionId }` marker in an early record pointing at the source
- * session (omnigent's `transcript_has_forked_from_marker`). Used to distinguish a
+ * session (reference implementation's `transcript_has_forked_from_marker`). Used to distinguish a
  * fork from an ordinary `resume` (both arrive as `SessionStart source="resume"`).
  * Scans only the head of the file (the marker lands up front). NOTE: unverified on
- * this host — no local transcript carries the marker — so it follows omnigent's shape.
+ * this host — no local transcript carries the marker — so it follows reference implementation's shape.
  */
 export declare function transcriptHasForkedFrom(path: string, currentSessionId?: string): boolean;
 /**

package/dist/claude/transcript.js

@@ -2,7 +2,7 @@
  * Claude Code transcript reader (Phase E, claude-native). Claude Code appends a
  * JSONL transcript per session at
  * `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`; the interactive TUI's
- * stdout is a full-screen UI, so — like omnigent's claude-native — we take the
+ * stdout is a full-screen UI, so — like reference implementation's claude-native — we take the
  * structured story from this file, not the PTY. Each `user`/`assistant` record
  * wraps an Anthropic message (`{ role, content: [blocks] }`), so we map its
  * blocks to the same typed {@link AgentEvent}s the headless executor emits.
@@ -121,6 +121,17 @@ export function parseTranscriptRecord(record, opts) {
         return [];
     const out = [];
     if (rec.type === "assistant" && message.role === "assistant") {
+        // Claude writes this zero-token synthetic filler after an accidental empty
+        // submit. It is transcript bookkeeping, not an assistant response. Filter
+        // by provider provenance and exact shape here, before normalization loses
+        // `model: "<synthetic>"`; a UI string filter could hide legitimate output.
+        if (!rec.isApiErrorMessage &&
+            message.model === "<synthetic>" &&
+            message.content.length === 1 &&
+            message.content[0]?.type === "text" &&
+            message.content[0].text === "No response requested.") {
+            return [];
+        }
         const itemId = message.id;
         const texts = [];
         for (const block of message.content) {
@@ -173,10 +184,10 @@ function isObject(value) {
 /**
  * Whether a transcript is a `/fork` (branch) of another session: claude stamps a
  * `forkedFrom: { sessionId }` marker in an early record pointing at the source
- * session (omnigent's `transcript_has_forked_from_marker`). Used to distinguish a
+ * session (reference implementation's `transcript_has_forked_from_marker`). Used to distinguish a
  * fork from an ordinary `resume` (both arrive as `SessionStart source="resume"`).
  * Scans only the head of the file (the marker lands up front). NOTE: unverified on
- * this host — no local transcript carries the marker — so it follows omnigent's shape.
+ * this host — no local transcript carries the marker — so it follows reference implementation's shape.
  */
 export function transcriptHasForkedFrom(path, currentSessionId) {
     let text;

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

@@ -1,4 +1,5 @@
-import type { SessionItem } from "@rynx-ai/core";
+import { type SessionItem } from "@rynx-ai/core";
+import { type CodexLineageRuntime } from "../codex-home.js";
 export interface SynthesizeRolloutOptions {
     threadId: string;
     cwd: string;
@@ -8,6 +9,10 @@ export interface SynthesizeRolloutOptions {
     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;
@@ -22,8 +27,8 @@ interface RolloutRecord {
     type: "session_meta" | "turn_context" | "response_item" | "event_msg";
     payload: Record<string, unknown>;
 }
-/** Locate an existing rollout for `threadId` under `<codexHome>/sessions/**`. */
-export declare function findCodexRollout(codexHome: string, threadId: string): string | null;
+/** 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[];

package/dist/codex/rollout-synth.js

@@ -1,7 +1,7 @@
 /**
  * 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 omnigent's
+ * (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
@@ -13,14 +13,19 @@
  * (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 { codexHomePath, legacyCodexHomePath } from "../codex-home.js";
+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-]+$/;
-/** Locate an existing rollout for `threadId` under `<codexHome>/sessions/**`. */
-export function findCodexRollout(codexHome, threadId) {
-    const root = join(codexHome, "sessions");
+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) {
@@ -49,18 +54,21 @@ export function findCodexRollout(codexHome, threadId) {
  * 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(codexHome, threadId) {
-    const flag = process.env.RYNX_CODEX_HOME_LEGACY_FALLBACK?.trim().toLowerCase();
+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 = legacyCodexHomePath();
-    if (legacy === codexHome)
+    const legacy = runtime === "codex"
+        ? legacyCodexHomePath()
+        : resolveRuntimeHome(getRuntimeProfile(runtime));
+    if (legacy === runtimeHome)
         return false;
-    const src = findCodexRollout(legacy, threadId);
+    const src = findCodexRollout(legacy, threadId, runtime);
     if (!src)
         return false;
-    const rel = relative(join(legacy, "sessions"), src);
-    const dst = join(codexHome, "sessions", rel);
+    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);
@@ -79,7 +87,10 @@ function turnIdOf(responseId) {
     return responseId.startsWith("resp_codex_") ? responseId.slice("resp_codex_".length) : responseId;
 }
 function textOf(item) {
-    return item.data.content.map((p) => p.text).join("");
+    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). */
@@ -87,9 +98,9 @@ function responseItemPayload(item) {
     switch (item.type) {
         case "message": {
             const apiType = item.data.role === "assistant" ? "output_text" : "input_text";
-            const content = item.data.content
-                .filter((p) => p.text)
-                .map((p) => ({ type: apiType, text: p.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 };
@@ -108,23 +119,41 @@ function responseItemPayload(item) {
     }
 }
 /** The `event_msg` mirror for a message (required for a VISIBLE turn on codex ≥0.136). */
-function eventMsgPayload(item) {
+function eventMsgPayload(item, sessionId) {
     const message = textOf(item).trim();
-    if (!message)
+    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: [], text_elements: [] };
+        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 ?? "openai";
+    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 = [
@@ -147,7 +176,10 @@ export function buildRolloutRecords(opts) {
     const seenTurns = new Set();
     for (const item of opts.items) {
         const payload = responseItemPayload(item);
-        if (!payload)
+        const eventPayload = item.type === "message"
+            ? eventMsgPayload(item, opts.sessionId)
+            : null;
+        if (!payload && !eventPayload)
             continue;
         const ts = iso(item.createdAt);
         const turnId = turnIdOf(item.responseId);
@@ -159,12 +191,10 @@ export function buildRolloutRecords(opts) {
                 payload: { turn_id: turnId, cwd: opts.cwd, approval_policy: "on-request" },
             });
         }
-        records.push({ timestamp: ts, type: "response_item", payload });
-        if (item.type === "message") {
-            const evt = eventMsgPayload(item);
-            if (evt)
-                records.push({ timestamp: ts, type: "event_msg", payload: evt });
-        }
+        if (payload)
+            records.push({ timestamp: ts, type: "response_item", payload });
+        if (eventPayload)
+            records.push({ timestamp: ts, type: "event_msg", payload: eventPayload });
     }
     return records;
 }
@@ -177,14 +207,17 @@ export function buildRolloutRecords(opts) {
 export function ensureCodexResumeRollout(opts) {
     if (!THREAD_ID_RE.test(opts.threadId))
         return "skipped";
-    const codexHome = opts.codexHome ?? (opts.sessionId ? codexHomePath(opts.sessionId) : undefined);
-    if (!codexHome)
+    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(codexHome, opts.threadId))
+    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(codexHome, opts.threadId))
+    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
@@ -197,7 +230,7 @@ export function ensureCodexResumeRollout(opts) {
     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(codexHome, "sessions", yyyy, mm, dd);
+    const dir = join(sessionsRoot(runtimeHome, runtime), yyyy, mm, dd);
     const target = join(dir, `rollout-${stamp}-${opts.threadId}.jsonl`);
     const tmp = `${target}.tmp`;
     try {

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

@@ -1,5 +1,7 @@
+import type { RuntimeUserInput, SessionInteractionResolution } from "@rynx-ai/core";
 import type { AskForApproval, ClientInfo, CollaborationModeListResponse, GetAuthStatusParams, GetAuthStatusResponse, InitializeResponse, ModelListParams, ModelListResponse, ReviewStartParams, ReviewStartResponse, SandboxMode, ThreadForkParams, ThreadGoalClearParams, ThreadGoalGetParams, ThreadGoalGetResponse, ThreadGoalSetParams, ThreadListParams, ThreadListResponse, ResumedThread, ThreadResumeParams, ThreadSettingsUpdateParams, ThreadStartParams, TurnInterruptParams, TurnStartParams, TurnSteerParams, UserInput } from "./protocol.js";
 import { CodexAppServerTransport, type CodexAppServerProcessSpawner, type RpcChannel, type TransportLogger } from "./transport.js";
+import type { ResolveInteractionResult, RuntimeInteractionListener } from "../interactions.js";
 export type ApprovalDecisionPolicy = "auto-approve-session" | "auto-decline" | "auto-cancel";
 export type CodexNotificationListener = (method: string, params: unknown) => void;
 export interface CodexAppServerClientOptions {
@@ -16,36 +18,21 @@ export interface CodexAppServerClientOptions {
      * prompting a human.
      */
     approvalDecisionPolicy?: ApprovalDecisionPolicy;
-    /**
-     * Surface approvals to a user instead of auto-deciding. When true and an
-     * approval listener is set, each request blocks until {@link
-     * CodexAppServerClient.resolveApproval} is called (or a timeout falls back to
-     * {@link approvalDecisionPolicy}).
-     */
-    interactiveApprovals?: boolean;
-}
-/** A codex approval decision (superset of exec + patch decision enums). */
-export type ApprovalDecision = "acceptForSession" | "accept" | "decline" | "cancel";
-/** A pending approval surfaced to the user, awaiting {@link CodexAppServerClient.resolveApproval}. */
-export interface ApprovalRequest {
-    approvalId: string;
-    kind: "exec" | "patch";
-    command?: string;
-    cwd?: string;
-    diff?: string;
 }
 export declare class CodexAppServerClient {
     readonly transport: CodexAppServerTransport;
     private readonly logger;
     private readonly clientInfo;
     private readonly approvalDecisionPolicy;
-    private readonly interactiveApprovals;
     private readonly channel;
     private readonly notificationSubscribers;
-    private approvalListener;
-    private readonly pendingApprovals;
+    private interactionListener;
+    private connectionListener;
+    private connectionState;
+    private readonly pendingInteractions;
+    private readonly settledInteractions;
     private initializeResponse;
-    constructor({ spawner, channel, logger, clientInfo, approvalDecisionPolicy, interactiveApprovals, }: CodexAppServerClientOptions);
+    constructor({ spawner, channel, logger, clientInfo, approvalDecisionPolicy, }: CodexAppServerClientOptions);
     /**
      * The multi-client endpoint a `codex --remote` TUI can attach to, when this
      * client runs over a {@link WsRpcChannel}. `undefined` for the default stdio
@@ -101,27 +88,26 @@ export declare class CodexAppServerClient {
     private dispatchNotification;
     private handleServerRequest;
     /**
-     * Register the listener that surfaces interactive approval requests. Set by
-     * the executor for the duration of a run so requests reach its event stream
-     * (and thus the web / Lark approval card).
-     */
-    setApprovalRequestListener(listener: ((request: ApprovalRequest) => void) | null): void;
-    /**
-     * Deliver a user's decision for a pending interactive approval. Returns false
-     * if the approval id is unknown (already resolved, timed out, or auto-decided).
-     */
-    resolveApproval(approvalId: string, decision: ApprovalDecision): boolean;
-    /**
-     * Interactive approval path: surface the request and block the codex
-     * server-request until the user decides (or the timeout falls back to the
-     * auto policy). When interactive approvals are off, decide immediately.
+     * Register the provider-neutral interaction listener. A request is inserted
+     * into the pending map before the listener is invoked, so a synchronous
+     * resolver still wins correctly.
      */
-    private handleApproval;
+    setInteractionListener(listener: RuntimeInteractionListener | null): void;
+    /** Observe the underlying app-server connection independently from any one
+     * interaction. A disconnected client that never received the duplicate
+     * native request still has to count as unavailable during host failover. */
+    setConnectionListener(listener: ((state: "connected" | "disconnected") => void) | null): void;
+    private setConnectionState;
+    resolveInteraction(interactionId: string, resolution: SessionInteractionResolution): ResolveInteractionResult;
+    /** Cancel every pending request owned by this connection without replying. */
+    cancelInteractions(reason?: string): void;
+    private handleInteraction;
     private autoApprovalDecision;
-    private respondCommandApproval;
-    private respondFileChangeApproval;
-    private declineDecisionForApprovals;
-    private respondNotSupported;
+    private resolveByProvider;
+    private handleServerRequestResponseDelivery;
+    private cancelPendingInteractions;
+    private emitInteraction;
+    private rememberSettled;
 }
 export interface BuildSandboxPolicyOptions {
     mode: SandboxMode;
@@ -135,4 +121,5 @@ export interface BuildSandboxPolicyOptions {
  */
 export declare function buildSandboxPolicy(options: BuildSandboxPolicyOptions): Record<string, unknown>;
 export declare function buildTextUserInput(message: string): UserInput[];
+export declare function buildRuntimeUserInput(input: RuntimeUserInput): UserInput[];
 export type { AskForApproval };