@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/claude/session-status.d.ts

@@ -0,0 +1,39 @@
+export type ClaudeRunnerStatus = "running" | "idle";
+export interface ClaudeSessionStatus {
+    runnerStatus: ClaudeRunnerStatus;
+    rawStatus: string;
+    statusUpdatedAt?: number;
+    blockedOn?: string;
+}
+export declare function claudeSessionsDir(configDir?: string): string;
+export declare function resolveClaudeSessionStatusFile({ panePid, expectedSessionId, configDir, now, }: {
+    panePid?: number;
+    expectedSessionId?: string;
+    configDir?: string;
+    now?: number;
+}): string | undefined;
+export declare function readClaudeSessionStatus(path: string): ClaudeSessionStatus | undefined;
+export declare class ClaudeSessionStatusPoller {
+    private readonly options;
+    private path?;
+    private attempts;
+    private exhausted;
+    private lastMtime?;
+    private lastEdge?;
+    private lastStatus?;
+    constructor(options: {
+        onStatus: (status: ClaudeSessionStatus) => void;
+        panePid: () => number | undefined;
+        sessionId: () => string | undefined;
+        configDir?: string;
+        maxResolveAttempts?: number;
+        now?: () => number;
+    });
+    get active(): boolean;
+    get status(): ClaudeSessionStatus | undefined;
+    tick(): void;
+    retire(): void;
+    resync(): void;
+    private tryResolve;
+    private readAndPublish;
+}

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/claude/transcript-clone.d.ts

@@ -0,0 +1,18 @@
+export interface ClonedClaudeTranscript {
+    transcriptPath: string;
+    prefixBytes?: number;
+}
+/** Claude names a project's transcript directory by replacing every
+ * non-alphanumeric character in its absolute cwd with `-`. */
+export declare function claudeProjectDirectoryName(cwd: string): string;
+/**
+ * Copy an existing Claude transcript into the target workspace under the
+ * target native Session id. The copy is fully committed before Claude starts,
+ * so the caller can seed its forwarder at the returned exact byte boundary.
+ */
+export declare function cloneClaudeTranscript({ sourceClaudeSessionId, targetClaudeSessionId, targetCwd, projectsRoot, }: {
+    sourceClaudeSessionId: string;
+    targetClaudeSessionId: string;
+    targetCwd: string;
+    projectsRoot?: string;
+}): Promise<ClonedClaudeTranscript | null>;