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

package/dist/claude/session-status.js

@@ -0,0 +1,163 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const STATUS_TO_RUNNER = {
+    busy: "running",
+    waiting: "running",
+    idle: "idle",
+    shell: "idle",
+    running: "running",
+    completed: "idle",
+    failed: "idle",
+    error: "idle",
+    done: "idle",
+};
+const SCAN_FRESHNESS_MS = 120_000;
+const DEFAULT_MAX_RESOLVE_ATTEMPTS = 40;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonRecord(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function matchesSession(record, expectedSessionId) {
+    if (record.kind !== "interactive")
+        return false;
+    return expectedSessionId === undefined || record.sessionId === expectedSessionId;
+}
+export function claudeSessionsDir(configDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude")) {
+    return join(configDir, "sessions");
+}
+export function resolveClaudeSessionStatusFile({ panePid, expectedSessionId, configDir, now = Date.now(), }) {
+    const directory = claudeSessionsDir(configDir);
+    if (panePid !== undefined) {
+        const candidate = join(directory, `${panePid}.json`);
+        const record = readJsonRecord(candidate);
+        if (record && matchesSession(record, expectedSessionId))
+            return candidate;
+    }
+    if (!expectedSessionId)
+        return undefined;
+    try {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".json"))
+                continue;
+            const candidate = join(directory, entry.name);
+            let modifiedAt;
+            try {
+                modifiedAt = statSync(candidate).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (now - modifiedAt > SCAN_FRESHNESS_MS)
+                continue;
+            const record = readJsonRecord(candidate);
+            if (record && matchesSession(record, expectedSessionId))
+                return candidate;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+export function readClaudeSessionStatus(path) {
+    const record = readJsonRecord(path);
+    if (!record || typeof record.status !== "string")
+        return undefined;
+    const runnerStatus = STATUS_TO_RUNNER[record.status];
+    if (!runnerStatus)
+        return undefined;
+    const updatedAt = record.statusUpdatedAt;
+    const waitingFor = record.status === "waiting" ? record.waitingFor : undefined;
+    return {
+        runnerStatus,
+        rawStatus: record.status,
+        ...(Number.isSafeInteger(updatedAt) ? { statusUpdatedAt: updatedAt } : {}),
+        ...(typeof waitingFor === "string" && waitingFor ? { blockedOn: waitingFor } : {}),
+    };
+}
+export class ClaudeSessionStatusPoller {
+    options;
+    path;
+    attempts = 0;
+    exhausted = false;
+    lastMtime;
+    lastEdge;
+    lastStatus;
+    constructor(options) {
+        this.options = options;
+    }
+    get active() {
+        return this.path !== undefined && !this.exhausted;
+    }
+    get status() {
+        return this.lastStatus;
+    }
+    tick() {
+        if (this.exhausted)
+            return;
+        if (!this.path) {
+            this.tryResolve();
+            if (!this.path)
+                return;
+        }
+        this.readAndPublish();
+    }
+    retire() {
+        this.exhausted = true;
+    }
+    resync() {
+        if (!this.active)
+            return;
+        this.lastMtime = undefined;
+        this.lastEdge = undefined;
+    }
+    tryResolve() {
+        this.attempts += 1;
+        this.path = resolveClaudeSessionStatusFile({
+            panePid: this.options.panePid(),
+            expectedSessionId: this.options.sessionId(),
+            ...(this.options.configDir ? { configDir: this.options.configDir } : {}),
+            now: this.options.now?.() ?? Date.now(),
+        });
+        if (!this.path &&
+            this.attempts >= (this.options.maxResolveAttempts ?? DEFAULT_MAX_RESOLVE_ATTEMPTS)) {
+            this.exhausted = true;
+        }
+    }
+    readAndPublish() {
+        if (!this.path)
+            return;
+        let mtime;
+        try {
+            mtime = statSync(this.path).mtimeMs;
+        }
+        catch {
+            this.exhausted = true;
+            return;
+        }
+        if (this.lastMtime === mtime)
+            return;
+        this.lastMtime = mtime;
+        const status = readClaudeSessionStatus(this.path);
+        if (!status) {
+            this.lastStatus = undefined;
+            this.lastEdge = undefined;
+            return;
+        }
+        this.lastStatus = status;
+        const edge = `${status.runnerStatus}\0${status.blockedOn ?? ""}`;
+        if (edge === this.lastEdge)
+            return;
+        this.lastEdge = edge;
+        this.options.onStatus(status);
+    }
+}

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

@@ -23,15 +23,25 @@
  */
 import type { AgentEvent, UserContentPart } from "@rynx-ai/core";
 import type { CodexAppServerClient } from "./client.js";
+import type { McpStartupPlan } from "./mcp-startup.js";
 import type { ResumedTurn } from "./protocol.js";
 export interface CodexForwarderSink {
     /** A turn began. `turnId` is codex's turn id, used to derive a stable
      *  `responseId`. Start a fresh normalizer/response. */
     onTurnStart(turnId?: string): void;
+    /** The observer received the provider's authoritative `turn/started` edge.
+     * Unlike `onTurnStart`, this is not fired early by turn/start acceptance. */
+    onTurnObserved?(turnId?: string): void;
     /** One mapped event within the current turn. */
     onEvent(event: AgentEvent): void;
+    /** Provider startup is session status, not a model item. Hosts that already
+     * published the response can forward it without synthesizing another start. */
+    onStatus?(note: string | undefined, statusKind?: "startup"): void;
     /** The current turn finished; `usage` is the runtime's raw snapshot if any. */
-    onTurnEnd(usage?: Record<string, unknown>): void;
+    onTurnEnd(usage?: Record<string, unknown>, reason?: "superseded"): void;
+    /** Resume proved that the newest turn is terminal even though its live edge
+     * was missed. This updates session state without replaying historical items. */
+    onRecoveredTurnStatus?(status: "idle" | "failed", turnId: string | undefined, error?: Error): void;
     /** A turn failed on the runtime. */
     onTurnError(error: Error): void;
     /** The user's turn text (sourced from codex's `userMessage` item), so a
@@ -58,6 +68,9 @@ export interface CodexSessionForwarderOptions {
     assistantMessageGraceMs?: number;
     /** Surface Traex's provider-capacity queue as a canonical running status. */
     surfaceQueueStatus?: boolean;
+    /** Provider-configured MCP servers. Their startup round is synthesized because
+     * Codex currently sends per-server edges only to the thread-owning TUI. */
+    mcpStartup?: McpStartupPlan | null;
 }
 export declare class CodexSessionForwarder {
     private readonly client;
@@ -69,9 +82,16 @@ export declare class CodexSessionForwarder {
     private currentThreadIdValue;
     private activeSignaled;
     private completionTimer;
+    /** Turn id retained only for late-item dedup while a terminal response waits
+     * for its bounded output-ordering grace. It is not an active provider turn. */
+    private pendingCompletionTurnId;
     private assistantMessageTimer;
     private deferredAssistantMessage;
     private pendingCompletion;
+    private readonly pendingMcpServers;
+    private readonly failedMcpServers;
+    private mcpStartupTimer;
+    private lastMcpStatusNote;
     /** Completed-item dedup keys already mirrored (live vs resume backfill). Key =
      *  `threadId:turnId:item.id`; anonymous items use a per-(thread,turn) position
      *  counter. Mirrors reference implementation `_completed_item_key` + `synced_item_keys`. */
@@ -83,12 +103,29 @@ export declare class CodexSessionForwarder {
     /** Begin mirroring. Idempotent. */
     start(): void;
     stop(): void;
-    /** True while a turn is open — injection uses `turn/steer` then, else `turn/start`. */
+    /** True while the provider owns an active turn, including the short interval
+     * between injection acceptance and observer confirmation. */
     isTurnOpen(): boolean;
     /** The current turn's codex id (only meaningful while {@link isTurnOpen}). */
     currentTurnId(): string | null;
+    /**
+     * Record a turn accepted by the injection connection before the independent
+     * observer receives `turn/started`. This closes the read-decide-RPC-write race:
+     * another web message arriving in that window must steer this turn, not start
+     * a second one.
+     */
+    noteTurnAccepted(turnId: string): void;
+    hasPendingMcpStartup(): boolean;
+    /** Mark and return the startup servers cancelled by a web Stop. */
+    cancelMcpStartup(): string[];
+    /** Diagnostic suffix for an injection failure during Provider startup. */
+    mcpStartupDetail(): string | null;
     /** The bound codex thread id captured from `thread/started` (null until then). */
     threadId(): string | null;
+    /** Seed an already-persisted/resumed thread binding. The bridge retains this
+     * state even when app-server does not rebroadcast `thread/started`, so
+     * terminal-boundary recovery must know it too. */
+    noteThreadBound(threadId: string): void;
     /**
      * Replay the backlog turns from a `thread/resume` response as if they were live
      * `item/completed` notifications — the fresh-thread first-turn backfill. Each
@@ -97,11 +134,25 @@ export declare class CodexSessionForwarder {
      * not doubled.
      */
     replayBackfill(turns: ResumedTurn[]): void;
+    /** Reconcile only the exact active turn after an observer resume. Historical
+     * items are intentionally not replayed on an existing-thread reconnect. */
+    reconcileActiveTurn(turn: ResumedTurn | undefined): boolean;
+    /** Reconcile an observer reconnect from the explicit resume snapshot. An
+     * identified active turn must match exactly; with no active turn, only the
+     * newest explicit terminal status is published and no history is replayed. */
+    reconcileResumeTurns(turns: ResumedTurn[]): boolean;
+    /** Fail an open response exactly once when its observer or terminal exits. */
+    failOpenTurn(error: Error): boolean;
     private handle;
     private scheduleCompletion;
     private refreshCompletionGrace;
     private flushPendingCompletion;
     private settle;
+    private handleMcpStartupStatus;
+    private settleMcpStartup;
+    private clearMcpStartupTimer;
+    private emitMcpStartupStatus;
+    private emitMcpStatus;
     /** Map + emit one completed codex item, deduped by a TOTAL key and routing the
      *  user echo to {@link CodexForwarderSink.onUserMessage}. Shared by live + backfill. */
     private processCompletedItem;
@@ -118,4 +169,17 @@ export declare class CodexSessionForwarder {
     private completedItemKey;
     private advanceAnonCounter;
     private ensureTurn;
+    /** Start (or confirm) the app-server's authoritative active turn. A newer
+     * start supersedes an older response whose terminal edge arrived late; a
+     * pending Traex completion is flushed first so its final item grace remains
+     * intact. */
+    private beginTurn;
+    /** Active-turn clearing contract:
+     *
+     * - an identified active turn is closed only by the same id;
+     * - an id-less boundary cannot close an identified active turn;
+     * - with no observed active turn, an identified boundary may recover a
+     *   missed start only when it carries the currently-bound thread id. */
+    private terminalBoundaryMatchesActiveTurn;
+    private notificationMatchesCurrentThread;
 }