@rynx-ai/runtime 0.1.11-beta.37 → 0.1.11-beta.39

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>;

package/dist/claude/transcript-clone.js

@@ -0,0 +1,497 @@
+import { randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, open, readdir, realpath, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { getRuntimeProfile, resolveRuntimeSessionsRoot, } from "@rynx-ai/core";
+const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Claude names a project's transcript directory by replacing every
+ * non-alphanumeric character in its absolute cwd with `-`. */
+export function claudeProjectDirectoryName(cwd) {
+    return path.resolve(cwd).replace(/[^A-Za-z0-9]/g, "-");
+}
+/**
+ * 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 async function cloneClaudeTranscript({ sourceClaudeSessionId, targetClaudeSessionId, targetCwd, projectsRoot = resolveRuntimeSessionsRoot(getRuntimeProfile("claude")), }) {
+    if (!CLAUDE_SESSION_ID_RE.test(sourceClaudeSessionId) ||
+        !CLAUDE_SESSION_ID_RE.test(targetClaudeSessionId)) {
+        return null;
+    }
+    const resolvedTargetCwd = await realpath(targetCwd).catch(() => path.resolve(targetCwd));
+    const targetDirectory = path.join(projectsRoot, claudeProjectDirectoryName(resolvedTargetCwd));
+    const targetPath = path.join(targetDirectory, `${targetClaudeSessionId}.jsonl`);
+    const sourcePath = await findClaudeTranscript(projectsRoot, sourceClaudeSessionId, targetPath);
+    if (!sourcePath)
+        return null;
+    await mkdir(targetDirectory, { recursive: true, mode: 0o700 });
+    const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+    let targetHandle;
+    try {
+        targetHandle = await open(temporaryPath, "wx", 0o600);
+        const sourceLines = createInterface({
+            input: createReadStream(sourcePath, { encoding: "utf8" }),
+            crlfDelay: Infinity,
+        });
+        let lineNumber = 0;
+        for await (const line of sourceLines) {
+            lineNumber += 1;
+            if (!line.trim()) {
+                await targetHandle.write("\n");
+                continue;
+            }
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch (error) {
+                throw new Error(`cannot clone malformed Claude transcript ${sourcePath}: line ${lineNumber} is not valid JSON`, { cause: error });
+            }
+            if (isRecord(record)) {
+                if (typeof record.cwd === "string")
+                    record.cwd = resolvedTargetCwd;
+                if (typeof record.sessionId === "string") {
+                    record.sessionId = targetClaudeSessionId;
+                }
+                sanitizeClonedToolResultRecord(record);
+            }
+            // readline returns a complete final record even when the source omitted
+            // its final newline. Always terminate it before Claude can append.
+            await targetHandle.write(`${JSON.stringify(record)}\n`);
+        }
+        await targetHandle.sync();
+        await targetHandle.close();
+        targetHandle = undefined;
+        await rename(temporaryPath, targetPath);
+        let prefixBytes;
+        try {
+            prefixBytes = (await stat(targetPath)).size;
+        }
+        catch {
+            // The clone is already atomically committed. The caller still resumes
+            // it and falls back to live-EOF seeding if this measurement is unavailable.
+        }
+        return {
+            transcriptPath: targetPath,
+            ...(prefixBytes === undefined ? {} : { prefixBytes }),
+        };
+    }
+    finally {
+        await targetHandle?.close().catch(() => undefined);
+        await rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}
+const MIN_IMAGE_BYTES = 16;
+const MAX_INVALID_IMAGE_REPLAY_CHARS = 8 * 1024;
+const MIN_UNTOLD_BINARY_CHARS = 64;
+const MIN_REDACTABLE_DATA_URI_PAYLOAD = 128;
+const BINARY_BLOCK_TYPES = new Set(["image", "document", "file"]);
+const NON_BINARY_SOURCE_TYPES = new Set(["text", "url", "content", "file"]);
+const INLINE_BASE64_DATA_URI_RE = /data:([^;,\s]*)(?:;[^;,\r\n]*)*;base64,[ \t]?([A-Za-z0-9+/=_-]+)/gi;
+/** Repair a pre-fix Claude record whose image payload is duplicated in both
+ * tool_result content and toolUseResult metadata. The model keeps one
+ * structured image; replay-only metadata is redacted. */
+function sanitizeClonedToolResultRecord(record) {
+    const message = asRecord(record.message);
+    if (!message || !Array.isArray(message.content))
+        return;
+    for (const value of message.content) {
+        const block = asRecord(value);
+        if (!block || block.type !== "tool_result")
+            continue;
+        const content = block.content;
+        let normalized;
+        if (typeof content === "string") {
+            const collapsed = stripUnparseableImageOutput(content);
+            normalized = rehydrateToolResult(collapsed);
+            if (collapsed !== content && normalized.blocks) {
+                block.content = normalized.blocks;
+                record.toolUseResult = JSON.stringify(redactBinaryPayloads(normalized.blocks));
+                continue;
+            }
+        }
+        else if (Array.isArray(content)) {
+            normalized = blocksFromParsedList(content);
+        }
+        else {
+            continue;
+        }
+        const blocks = normalized.blocks;
+        if (!blocks)
+            continue;
+        const payloads = imagePayloadsInBlocks(blocks);
+        if (normalized.droppedOversizedImage && payloads.length === 0) {
+            block.content = blocks;
+            record.toolUseResult = JSON.stringify(redactBinaryPayloads(blocks));
+            continue;
+        }
+        if (payloads.length === 0)
+            continue;
+        block.content = blocks;
+        const metadata = record.toolUseResult;
+        const metadataText = typeof metadata === "string"
+            ? metadata
+            : metadata === undefined
+                ? ""
+                : JSON.stringify(metadata);
+        if (!carriesAnyPayload(metadataText, payloads))
+            continue;
+        let candidate = typeof metadata === "string"
+            ? jsonSafeRedactedToolUseResult(metadata)
+            : redactBinaryPayloads(metadata);
+        const candidateText = typeof candidate === "string"
+            ? candidate
+            : JSON.stringify(candidate);
+        if (carriesAnyPayload(candidateText, payloads)) {
+            candidate = JSON.stringify(redactBinaryPayloads(blocks));
+        }
+        record.toolUseResult = candidate;
+    }
+}
+function stripUnparseableImageOutput(output) {
+    const hasErrorPrefix = output.startsWith("Error: ");
+    const body = hasErrorPrefix ? output.slice("Error: ".length) : output;
+    if (body.includes("\n") ||
+        !/^\s*[\[{]/.test(body) ||
+        !/"type"\s*:\s*"image"/.test(body) ||
+        !/"data"\s*:/.test(body)) {
+        return output;
+    }
+    try {
+        JSON.parse(body);
+        return output;
+    }
+    catch {
+        const blocks = [];
+        if (hasErrorPrefix)
+            blocks.push({ type: "text", text: "Error:" });
+        blocks.push({ type: "text", text: imageOmittedPlaceholder(undefined) });
+        return JSON.stringify(blocks);
+    }
+}
+function rehydrateToolResult(output) {
+    const direct = rehydrateToolResultShape(output);
+    if (direct.blocks || !output.startsWith("Error: "))
+        return direct;
+    const nested = rehydrateToolResultShape(output.slice("Error: ".length));
+    if (!nested.blocks ||
+        (imagePayloadsInBlocks(nested.blocks).length === 0 && !nested.droppedOversizedImage)) {
+        return direct;
+    }
+    return {
+        blocks: [{ type: "text", text: "Error:" }, ...nested.blocks],
+        ...(nested.droppedOversizedImage ? { droppedOversizedImage: true } : {}),
+    };
+}
+function rehydrateToolResultShape(output) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        parsed = undefined;
+    }
+    if (Array.isArray(parsed))
+        return blocksFromParsedList(parsed);
+    if (isRecord(parsed)) {
+        const image = canonicalImageBlock(parsed);
+        if (image)
+            return { blocks: [image] };
+        if (oversizedInvalidImage(parsed)) {
+            return {
+                blocks: [{ type: "text", text: imageOmittedPlaceholder(imageMediaType(parsed)) }],
+                droppedOversizedImage: true,
+            };
+        }
+        return { blocks: null };
+    }
+    if (parsed !== undefined)
+        return { blocks: null };
+    const blocks = [];
+    let textLines = [];
+    let foundImage = false;
+    let droppedOversizedImage = false;
+    const flushText = () => {
+        if (textLines.length === 0)
+            return;
+        const text = textLines.join("\n");
+        textLines = [];
+        if (text)
+            blocks.push({ type: "text", text });
+    };
+    for (const line of output.split("\n")) {
+        let candidate;
+        try {
+            candidate = JSON.parse(line);
+        }
+        catch {
+            candidate = undefined;
+        }
+        const image = isRecord(candidate) ? canonicalImageBlock(candidate) : null;
+        if (image) {
+            flushText();
+            blocks.push(image);
+            foundImage = true;
+            continue;
+        }
+        if (isRecord(candidate) && oversizedInvalidImage(candidate)) {
+            flushText();
+            blocks.push({ type: "text", text: imageOmittedPlaceholder(imageMediaType(candidate)) });
+            foundImage = true;
+            droppedOversizedImage = true;
+            continue;
+        }
+        if (candidate === undefined &&
+            line.trimStart().startsWith("{") &&
+            holdsClippedImagePayload(line)) {
+            flushText();
+            blocks.push({ type: "text", text: imageOmittedPlaceholder(undefined) });
+            foundImage = true;
+            droppedOversizedImage = true;
+            continue;
+        }
+        textLines.push(line);
+    }
+    flushText();
+    return foundImage ? { blocks, droppedOversizedImage } : { blocks: null };
+}
+function blocksFromParsedList(values) {
+    if (values.length === 0)
+        return { blocks: null };
+    const blocks = [];
+    let droppedOversizedImage = false;
+    for (const value of values) {
+        const block = asRecord(value);
+        if (!block)
+            return { blocks: null };
+        if (block.type === "text") {
+            blocks.push(block);
+            continue;
+        }
+        if (block.type !== "image")
+            return { blocks: null };
+        const image = canonicalImageBlock(block);
+        if (image) {
+            blocks.push(image);
+            continue;
+        }
+        if (!oversizedInvalidImage(block))
+            return { blocks: null };
+        blocks.push({ type: "text", text: imageOmittedPlaceholder(imageMediaType(block)) });
+        droppedOversizedImage = true;
+    }
+    return { blocks, droppedOversizedImage };
+}
+function canonicalImageBlock(value) {
+    if (value.type !== "image")
+        return null;
+    const source = asRecord(value.source);
+    if (source) {
+        const data = typeof source.data === "string" ? source.data : undefined;
+        if (!data)
+            return value;
+        const mediaType = typeof source.media_type === "string"
+            ? source.media_type
+            : undefined;
+        const canonical = mediaType
+            ? canonicalImagePayload(data, mediaType)
+            : whitespaceNormalizedBase64(data);
+        const normalized = canonical ?? whitespaceNormalizedBase64(data);
+        return normalized && normalized !== data
+            ? { ...value, source: { ...source, data: normalized } }
+            : value;
+    }
+    const data = typeof value.data === "string" ? value.data : undefined;
+    const mediaType = typeof value.mimeType === "string" ? value.mimeType : undefined;
+    if (!data || !mediaType)
+        return null;
+    const canonical = canonicalImagePayload(data, mediaType);
+    if (!canonical)
+        return null;
+    return {
+        type: "image",
+        source: { type: "base64", media_type: mediaType, data: canonical },
+    };
+}
+function whitespaceNormalizedBase64(data) {
+    const compact = data.replace(/\s+/g, "");
+    if (!compact || compact === data || !/^[A-Za-z0-9+/]*={0,2}$/.test(compact))
+        return null;
+    const padded = compact.padEnd(Math.ceil(compact.length / 4) * 4, "=");
+    return strictBase64Bytes(padded) ? padded : null;
+}
+function canonicalImagePayload(data, mediaType) {
+    const compact = data.replace(/\s+/g, "");
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(compact))
+        return null;
+    const padded = compact.padEnd(Math.ceil(compact.length / 4) * 4, "=");
+    const bytes = strictBase64Bytes(padded);
+    if (!bytes)
+        return null;
+    if (bytes.length < MIN_IMAGE_BYTES)
+        return null;
+    const valid = mediaType === "image/png"
+        ? bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+        : mediaType === "image/jpeg"
+            ? bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff
+            : mediaType === "image/gif"
+                ? (bytes.subarray(0, 6).toString("ascii") === "GIF87a" ||
+                    bytes.subarray(0, 6).toString("ascii") === "GIF89a")
+                : mediaType === "image/webp"
+                    ? bytes.subarray(0, 4).toString("ascii") === "RIFF" &&
+                        bytes.subarray(8, 12).toString("ascii") === "WEBP"
+                    : false;
+    return valid ? padded : null;
+}
+function strictBase64Bytes(padded) {
+    // Node's base64 decoder is intentionally forgiving (it accepts malformed
+    // padding and silently truncates some tails). Claude/Python validate=True is
+    // not, so validate complete quartets before decoding.
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(padded)) {
+        return null;
+    }
+    try {
+        return Buffer.from(padded, "base64");
+    }
+    catch {
+        return null;
+    }
+}
+function oversizedInvalidImage(value) {
+    if (value.type !== "image")
+        return false;
+    // Anthropic source-shaped blocks have always been passed through; only a
+    // rejected MCP bare data/mimeType object is eligible for collapse.
+    if (asRecord(value.source))
+        return false;
+    const data = typeof value.data === "string" ? value.data : undefined;
+    return Boolean(data && data.length > MAX_INVALID_IMAGE_REPLAY_CHARS);
+}
+function imageMediaType(value) {
+    const source = asRecord(value.source);
+    return typeof source?.media_type === "string"
+        ? source.media_type
+        : typeof value.mimeType === "string"
+            ? value.mimeType
+            : undefined;
+}
+function imagePayloadsInBlocks(blocks) {
+    const payloads = [];
+    for (const block of blocks) {
+        const source = asRecord(block.source);
+        if (typeof source?.data === "string" && source.data)
+            payloads.push(source.data);
+    }
+    return payloads;
+}
+function redactBinaryPayloads(value) {
+    if (Array.isArray(value))
+        return value.map(redactBinaryPayloads);
+    if (typeof value === "string") {
+        return value.replace(INLINE_BASE64_DATA_URI_RE, (match, mediaType, payload) => payload.length >= MIN_REDACTABLE_DATA_URI_PAYLOAD
+            ? binaryPayloadOmitted(mediaType)
+            : match);
+    }
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    const copy = { ...record };
+    if (typeof copy.type === "string" && BINARY_BLOCK_TYPES.has(copy.type)) {
+        redactDataField(copy);
+        const source = asRecord(copy.source);
+        if (source) {
+            const sourceCopy = { ...source };
+            if (typeof sourceCopy.type !== "string" ||
+                !NON_BINARY_SOURCE_TYPES.has(sourceCopy.type)) {
+                redactDataField(sourceCopy);
+            }
+            copy.source = sourceCopy;
+        }
+    }
+    for (const [key, nested] of Object.entries(copy)) {
+        copy[key] = redactBinaryPayloads(nested);
+    }
+    return copy;
+}
+function redactDataField(record) {
+    const data = typeof record.data === "string" ? record.data : undefined;
+    if (!data || !isBase64Payload(data))
+        return;
+    const mediaType = typeof record.media_type === "string" ? record.media_type : "";
+    record.data = binaryPayloadOmitted(mediaType);
+}
+function isBase64Payload(value) {
+    const compact = value.replace(/\s+/g, "");
+    return Boolean(compact &&
+        /^[A-Za-z0-9+/=_-]+$/.test(compact) &&
+        (compact.includes("=") || compact.length % 4 === 0 || compact.length >= MIN_UNTOLD_BINARY_CHARS));
+}
+function binaryPayloadOmitted(mediaType) {
+    const label = mediaType || "binary";
+    return `[${label} payload omitted from toolUseResult; kept in the tool_result content]`;
+}
+function jsonSafeRedactedToolUseResult(output) {
+    try {
+        const parsed = JSON.parse(output);
+        const redacted = redactBinaryPayloads(parsed);
+        return JSON.stringify(redacted) === JSON.stringify(parsed)
+            ? output
+            : JSON.stringify(redacted);
+    }
+    catch {
+        return JSON.stringify(output);
+    }
+}
+function carriesAnyPayload(text, payloads) {
+    const compact = text.replace(/\\+[nrtf]/g, "").replace(/[\\\s]+/g, "");
+    return payloads.some((payload) => compact.includes(payload) || compact.includes(payload.replace(/=+$/, "")));
+}
+function imageOmittedPlaceholder(mediaType) {
+    const label = mediaType ? `${mediaType} image` : "image";
+    return `[${label} omitted from history to save context — re-run the tool call above (e.g. Read the same path) to view it again]`;
+}
+function holdsClippedImagePayload(value) {
+    return /"type"\s*:\s*"image"/.test(value) && /"data"\s*:/.test(value);
+}
+async function findClaudeTranscript(projectsRoot, claudeSessionId, excludedPath) {
+    let entries;
+    try {
+        entries = await readdir(projectsRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw error;
+    }
+    const filename = `${claudeSessionId}.jsonl`;
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidate = path.join(projectsRoot, entry.name, filename);
+        if (path.resolve(candidate) === path.resolve(excludedPath))
+            continue;
+        try {
+            const details = await stat(candidate);
+            if (details.isFile())
+                matches.push({ path: candidate, mtimeMs: details.mtimeMs });
+        }
+        catch (error) {
+            if (!isMissingFileError(error))
+                throw error;
+        }
+    }
+    matches.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    return matches[0]?.path ?? null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function isMissingFileError(error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}

package/dist/claude/transcript.d.ts

@@ -3,6 +3,17 @@ import type { AgentEvent, TerminalCommandData } from "@rynx-ai/core";
  *  `<project>/<sessionId>/subagents/agent-<agentId>.jsonl`, alongside the parent
  *  `<sessionId>.jsonl`. Derive that path from the parent transcript path. */
 export declare function subagentTranscriptPath(parentTranscriptPath: string, agentId: string): string;
+export interface TerminalCommandFragments {
+    command?: string;
+    stdout?: string;
+    stderr?: string;
+    /** Marker presence, not output truthiness: Claude can record an empty
+     * stdout tag as the authoritative completion half of a split command. */
+    hasOutput: boolean;
+}
+/** Parse either half of Claude's shell-mode record. Newer and older Claude
+ * builds may split `<bash-input>` from the later stdout/stderr record. */
+export declare function parseTerminalCommandFragments(content: string): TerminalCommandFragments | undefined;
 /**
  * Parse a claude local-command (`!` bash mode) user record's string content into
  * a {@link TerminalCommandData}. Claude records the command and its captured
@@ -37,13 +48,25 @@ export declare function parseTranscriptLine(line: string, opts?: ParseTranscript
 export declare function parseTranscriptRecord(record: unknown, opts?: ParseTranscriptOptions): AgentEvent[];
 /**
  * Whether a transcript is a `/fork` (branch) of another session: claude stamps a
- * `forkedFrom: { sessionId }` marker in an early record pointing at the source
+ * `forkedFrom: { sessionId }` marker on copied records pointing at the source
  * 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 reference implementation's shape.
+ * The marker must belong to the announced target and expected source; sample
+ * the first and last 200 records because long copied histories can place it at
+ * either edge.
  */
-export declare function transcriptHasForkedFrom(path: string, currentSessionId?: string): boolean;
+export declare function transcriptHasForkedFrom(path: string, claudeSessionId: string, sourceClaudeSessionId?: string): boolean;
+/** Claude versions without a copied-record marker still persist `/fork` and
+ * `/branch` as a recent top-level local command. Match only the new native
+ * Session and the hook's narrow time window. */
+export declare function transcriptHasRecentLocalCommand(path: string, claudeSessionId: string, recordedAtMs: number, commandNames?: ReadonlySet<string>): boolean;
+/** Wait briefly for Claude to flush either fork signal after SessionStart.
+ * The observer hook calls this before recording the edge, allowing a
+ * one-second late-marker window without delaying ordinary transcript polling. */
+export declare function waitForTranscriptForkSignal(path: string, claudeSessionId: string, sourceClaudeSessionId: string, recordedAtMs: number, options?: {
+    timeoutMs?: number;
+    pollMs?: number;
+}): Promise<boolean>;
 /**
  * Read a sub-agent (Task) transcript in full and map it to {@link AgentEvent}s
  * tagged with `parentToolUseId`. Called once the parent Task tool_result arrives