@rynx-ai/runtime 0.1.0

package/dist/claude/trust.js

@@ -0,0 +1,85 @@
+/**
+ * Pre-accept Claude Code's first-run TUI gates so a daemon-spawned `claude`
+ * never blocks on a prompt nobody is at the terminal to answer.
+ *
+ * On a fresh context Claude blocks on prompts that do NOT fire any hook (so we
+ * can't auto-answer them in-band):
+ *   - global onboarding (theme/login) → top-level `hasCompletedOnboarding`
+ *   - per-dir "trust this folder?" → `projects[<abs cwd>].hasTrustDialogAccepted`
+ *   - "Allow external CLAUDE.md imports?" (the one that bit us — the global
+ *     `~/.claude/CLAUDE.md` imports files outside the cwd) →
+ *     `projects[<abs cwd>].hasClaudeMdExternalIncludesApproved`
+ *
+ * We seed just these keys idempotently and preserve all other `~/.claude.json`
+ * state (the user's onboarding choices, project history, MCP config, OAuth
+ * account). This does NOT skip per-tool permission prompts — those are hookable
+ * and handled elsewhere; only the unhookable startup gates are pre-accepted.
+ *
+ * Concurrency: a read-modify-write of a file Claude also rewrites. We run it
+ * once before spawning (Claude isn't writing for this session yet) and replace
+ * atomically; a last-writer-wins race only re-shows a prompt, which a relaunch
+ * clears.
+ */
+import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+const PROJECT_TRUST_KEYS = {
+    hasTrustDialogAccepted: true,
+    hasClaudeMdExternalIncludesApproved: true,
+    hasClaudeMdExternalIncludesWarningShown: true,
+};
+function claudeConfigJsonPath() {
+    const dir = process.env.CLAUDE_CONFIG_DIR?.trim();
+    return dir ? join(dir, ".claude.json") : join(homedir(), ".claude.json");
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Ensure `cwd` is pre-trusted in `~/.claude.json`. Idempotent; throws (rather
+ * than clobbering) if an existing config isn't shaped as expected. Opt out with
+ * `RYNX_CLAUDE_PRESEED_TRUST=0`.
+ */
+export function ensureProjectTrusted(cwd, configPath = claudeConfigJsonPath()) {
+    const flag = process.env.RYNX_CLAUDE_PRESEED_TRUST;
+    if (flag === "0" || flag === "false")
+        return;
+    let data = {};
+    if (existsSync(configPath)) {
+        const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+        if (!isPlainObject(parsed)) {
+            throw new Error(`${configPath} is not a JSON object; refusing to overwrite.`);
+        }
+        data = parsed;
+    }
+    let changed = false;
+    if (data.hasCompletedOnboarding !== true) {
+        data.hasCompletedOnboarding = true;
+        changed = true;
+    }
+    if (data.projects === undefined)
+        data.projects = {};
+    if (!isPlainObject(data.projects)) {
+        throw new Error(`${configPath} 'projects' is not a JSON object; refusing to overwrite.`);
+    }
+    const projects = data.projects;
+    const key = resolve(cwd);
+    if (projects[key] === undefined)
+        projects[key] = {};
+    if (!isPlainObject(projects[key])) {
+        throw new Error(`${configPath} projects[${key}] is not a JSON object; refusing to overwrite.`);
+    }
+    const entry = projects[key];
+    for (const [k, v] of Object.entries(PROJECT_TRUST_KEYS)) {
+        if (entry[k] !== v) {
+            entry[k] = v;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return;
+    const tmp = join(dirname(configPath), `.${basename(configPath)}.${process.pid}.tmp`);
+    writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });
+    chmodSync(tmp, 0o600); // pin owner-only even under a permissive umask
+    renameSync(tmp, configPath);
+}

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

@@ -0,0 +1,37 @@
+import type { SessionItem } from "@rynx-ai/core";
+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 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 `<codexHome>/sessions/**`. */
+export declare function findCodexRollout(codexHome: string, threadId: string): 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

@@ -0,0 +1,212 @@
+/**
+ * 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
+ * `_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 { copyFileSync, mkdirSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { codexHomePath, legacyCodexHomePath } 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");
+    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(codexHome, threadId) {
+    const flag = process.env.RYNX_CODEX_HOME_LEGACY_FALLBACK?.trim().toLowerCase();
+    if (flag === "0" || flag === "false")
+        return false;
+    const legacy = legacyCodexHomePath();
+    if (legacy === codexHome)
+        return false;
+    const src = findCodexRollout(legacy, threadId);
+    if (!src)
+        return false;
+    const rel = relative(join(legacy, "sessions"), src);
+    const dst = join(codexHome, "sessions", 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.map((p) => p.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
+                .filter((p) => p.text)
+                .map((p) => ({ type: apiType, text: p.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) {
+    const message = textOf(item).trim();
+    if (!message)
+        return null;
+    if (item.data.role === "user") {
+        return { type: "user_message", message, images: [], local_images: [], text_elements: [] };
+    }
+    if (item.data.role === "assistant") {
+        return { type: "agent_message", message, phase: "final_answer", memory_citation: null };
+    }
+    return null;
+}
+/** 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 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);
+        if (!payload)
+            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" },
+            });
+        }
+        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 });
+        }
+    }
+    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 codexHome = opts.codexHome ?? (opts.sessionId ? codexHomePath(opts.sessionId) : undefined);
+    if (!codexHome)
+        return "skipped"; // no session context → can't locate the home
+    if (findCodexRollout(codexHome, opts.threadId))
+        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))
+        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(codexHome, "sessions", 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
+    }
+}

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

@@ -0,0 +1,138 @@
+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";
+export type ApprovalDecisionPolicy = "auto-approve-session" | "auto-decline" | "auto-cancel";
+export type CodexNotificationListener = (method: string, params: unknown) => void;
+export interface CodexAppServerClientOptions {
+    /** Default stdio transport. Mutually exclusive with {@link channel}. */
+    spawner?: CodexAppServerProcessSpawner;
+    /** Alternate I/O channel (e.g. a {@link WsRpcChannel} for co-drive). */
+    channel?: RpcChannel;
+    logger?: TransportLogger;
+    clientInfo?: ClientInfo;
+    /**
+     * What to do when the server asks for a command / file approval. Defaults
+     * to `auto-approve-session`, which matches the existing bridge behaviour
+     * of running everything inside `--sandbox workspace-write` without ever
+     * 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 initializeResponse;
+    constructor({ spawner, channel, logger, clientInfo, approvalDecisionPolicy, interactiveApprovals, }: 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
+     * transport (single client — not co-drivable). Available after the transport
+     * has started (post `ensureInitialized`).
+     */
+    terminalRemoteUrl(): string | undefined;
+    ensureInitialized(): Promise<InitializeResponse>;
+    getAuthStatus(params?: GetAuthStatusParams): Promise<GetAuthStatusResponse>;
+    threadStart(params: ThreadStartParams): Promise<{
+        threadId: string;
+    }>;
+    threadResume(params: ThreadResumeParams): Promise<{
+        threadId: string;
+        thread: ResumedThread;
+    }>;
+    turnStart(params: TurnStartParams): Promise<{
+        turnId: string;
+    }>;
+    turnInterrupt(params: TurnInterruptParams): Promise<void>;
+    /**
+     * Inject additional user input into the currently running turn. Returns the
+     * active turn id (may differ from `expectedTurnId`). Fails if no matching
+     * active turn exists, so callers should treat errors as best-effort.
+     */
+    turnSteer(params: TurnSteerParams): Promise<{
+        turnId: string;
+    }>;
+    /** List local conversation/thread history (newest first by default). */
+    threadList(params?: ThreadListParams): Promise<ThreadListResponse>;
+    /** Fork an existing thread into a new one, optionally overriding settings. */
+    threadFork(params: ThreadForkParams): Promise<{
+        thread: {
+            id: string;
+        };
+    } & Record<string, unknown>>;
+    /** Update per-thread settings (model / mode / personality / sandbox …). */
+    threadSettingsUpdate(params: ThreadSettingsUpdateParams): Promise<Record<string, unknown>>;
+    /** List the models the local Codex install exposes. */
+    modelList(params?: ModelListParams): Promise<ModelListResponse>;
+    /** List the available collaboration-mode presets (experimental). */
+    collaborationModeList(): Promise<CollaborationModeListResponse>;
+    /** Set (or update) the thread's tracked goal. */
+    threadGoalSet(params: ThreadGoalSetParams): Promise<Record<string, unknown>>;
+    /** Read the thread's current goal. */
+    threadGoalGet(params: ThreadGoalGetParams): Promise<ThreadGoalGetResponse>;
+    /** Clear the thread's tracked goal. */
+    threadGoalClear(params: ThreadGoalClearParams): Promise<Record<string, unknown>>;
+    /** Start a non-interactive code review on the thread. */
+    reviewStart(params: ReviewStartParams): Promise<ReviewStartResponse>;
+    onNotification(listener: CodexNotificationListener): () => void;
+    stop(): Promise<void>;
+    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.
+     */
+    private handleApproval;
+    private autoApprovalDecision;
+    private respondCommandApproval;
+    private respondFileChangeApproval;
+    private declineDecisionForApprovals;
+    private respondNotSupported;
+}
+export interface BuildSandboxPolicyOptions {
+    mode: SandboxMode;
+    cwd: string;
+    allowedRoots: string[];
+}
+/**
+ * Construct a SandboxPolicy compatible with the App Server turn/start params
+ * from the env-configured mode and the allowlist of writable roots. The
+ * shape mirrors `SandboxPolicy` in `codex-app-server` generated types.
+ */
+export declare function buildSandboxPolicy(options: BuildSandboxPolicyOptions): Record<string, unknown>;
+export declare function buildTextUserInput(message: string): UserInput[];
+export type { AskForApproval };