@neta-art/cohub-cli 10.7.0 → 10.8.1

package/dist/runtime/harnesses/claude-transcript.js

@@ -0,0 +1,138 @@
+import { record } from "../json-rpc.js";
+import { iso } from "../native/transcript.js";
+import { chainBranch, extendTurn, readChainedLines, startTurn } from "./chained-transcript.js";
+import { array, text } from "./process.js";
+import { streamContent, streamUsage } from "./stream-json.js";
+const COMMAND = /^<command-name>\s*([^<]*)<\/command-name>/;
+const COMMAND_ARGS = /<command-args>([\s\S]*?)<\/command-args>/;
+const BASH_INPUT = /^<bash-input>([\s\S]*?)<\/bash-input>/;
+/** Output of a local command or `!` shell, recorded as a user message but never sent as a prompt. */
+const LOCAL_OUTPUT = /^<(?:local-command-(?:stdout|stderr|caveat)|bash-(?:stdout|stderr))>/;
+const INTERRUPTED = "[Request interrupted by user";
+export const CLAUDE_REPLY_ENDED = ["end_turn", "stop_sequence", "max_tokens", "refusal", "aborted", "error"];
+const nonEmpty = (block) => !(block.type === "text" && !block.text) && !(block.type === "thinking" && !block.thinking);
+/** A local `/command` or `!shell` is shown as typed; one that never reached the model is no Turn. */
+function prompt(value) {
+    const content = typeof value === "string" ? [{ type: "text", text: value }] : streamContent(value).filter((block) => block.type === "text" || block.type === "image");
+    const first = content.find((block) => block.type === "text")?.text.trimStart() ?? "";
+    if (LOCAL_OUTPUT.test(first) || first.startsWith(INTERRUPTED))
+        return null;
+    const command = COMMAND.exec(first);
+    if (command)
+        return { content: [{ type: "text", text: `${command[1]?.trim() ?? ""} ${COMMAND_ARGS.exec(first)?.[1]?.trim() ?? ""}`.trim() }], local: true };
+    const bash = BASH_INPUT.exec(first);
+    if (bash)
+        return { content: [{ type: "text", text: `!${bash[1] ?? ""}` }], local: true };
+    const visible = content.filter(nonEmpty);
+    return visible.length ? { content: visible, local: false } : null;
+}
+/**
+ * Claude Code appends one record per content block, linked by `parentUuid` (`logicalParentUuid`
+ * across a compaction). A Turn starts at a prompt; its tool results and an interruption share the
+ * prompt's `promptId`. Interactive sessions record each end (`turn_duration`), `-p` sessions do not.
+ */
+export async function readClaudeTranscript(path, nativeSessionId, signal) {
+    const read = await readChainedLines(path, signal);
+    const branch = chainBranch(read.lines, (value) => value.isSidechain === true ? "" : text(value.uuid), (value) => text(value.parentUuid) || text(value.logicalParentUuid));
+    const turns = [];
+    const owners = new Map();
+    const messageIds = new Map();
+    let cwd = "", cloudSessionId = "";
+    let current = null;
+    let promptId = "", local = false, interrupted = false, completedAt = "";
+    const finish = () => {
+        if (!current)
+            return;
+        // A local command that never reached the model is not a conversation Turn.
+        if (local && !current.messages.length) {
+            current = null;
+            return;
+        }
+        const last = current.messages.at(-1);
+        const status = interrupted || !last || last.stopReason === "tool_use" ? "interrupted" : last.stopReason === "error" ? "failed" : "completed";
+        current.result = { messages: current.messages, completedAt: completedAt || current.startedAt, status };
+        turns.push(current);
+        current = null;
+    };
+    for (const line of branch) {
+        const value = line.value;
+        cwd ||= text(value.cwd);
+        if (value.type === "user") {
+            const message = record(value.message);
+            const results = array(message.content).map(record).filter((block) => block.type === "tool_result");
+            const opened = value.isMeta === true || value.isCompactSummary === true || results.length ? null : prompt(message.content);
+            if (opened && !(current && text(value.promptId) && text(value.promptId) === promptId)) {
+                finish();
+                const cohub = record(value.cohub);
+                cloudSessionId ||= text(cohub.sessionId);
+                // Cohub sends its Turn id as the prompt's record id; a projected record names its Turn.
+                current = startTurn(line, text(value.uuid), turns.at(-1)?.key ?? null, opened.content, text(cohub.turnId) || text(value.uuid));
+                promptId = text(value.promptId);
+                local = opened.local;
+                interrupted = false;
+                completedAt = current.startedAt;
+                owners.clear();
+                messageIds.clear();
+                continue;
+            }
+            if (!current)
+                continue;
+            for (const block of results) {
+                const id = text(block.tool_use_id);
+                const owner = owners.get(id);
+                if (!owner)
+                    continue;
+                owner.content.push({ type: "tool_result", tool_use_id: id, content: typeof block.content === "string" ? block.content : streamContent(block.content), is_error: block.is_error === true });
+            }
+            if (array(message.content).some((block) => text(record(block).text).startsWith(INTERRUPTED)) || text(message.content).startsWith(INTERRUPTED)) {
+                interrupted = true;
+                current.ended = true;
+            }
+            completedAt = iso(value.timestamp);
+            extendTurn(current, line, true);
+            continue;
+        }
+        if (!current)
+            continue;
+        if (value.type === "assistant") {
+            const native = record(value.message);
+            const id = text(native.id);
+            let target = current.messages.at(-1);
+            if (!target || !id || messageIds.get(target) !== id) {
+                target = { content: [], provider: null, model: null, stopReason: null, errorMessage: null };
+                current.messages.push(target);
+                messageIds.set(target, id);
+            }
+            const content = streamContent(native.content).filter(nonEmpty);
+            for (const block of content) {
+                const index = block.type === "tool_use" ? target.content.findIndex((existing) => existing.type === "tool_use" && existing.id === block.id) : -1;
+                if (index >= 0)
+                    target.content[index] = block;
+                else
+                    target.content.push(block);
+                if (block.type === "tool_use")
+                    owners.set(block.id, target);
+            }
+            const model = text(native.model);
+            if (model && model !== "<synthetic>")
+                target.model = model;
+            if (text(native.stop_reason))
+                target.stopReason = text(native.stop_reason);
+            const usage = streamUsage(native.usage, undefined);
+            if (usage)
+                target.usage = usage;
+            if (value.isApiErrorMessage === true) {
+                target.stopReason = "error";
+                target.errorMessage = content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n") || "API error";
+            }
+            completedAt = iso(value.timestamp);
+            extendTurn(current, line, true);
+            continue;
+        }
+        if (value.type === "system" && value.subtype === "turn_duration")
+            current.ended = true;
+        extendTurn(current, line, false);
+    }
+    finish();
+    return { nativeSessionId, cwd, ...(cloudSessionId ? { cloudSessionId } : {}), turns, prefixes: read.prefixes };
+}

package/dist/runtime/harnesses/claude.js

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { JsonRpcProcess, record } from "../json-rpc.js";
 import { copyNativeArchive } from "../native/archive.js";
 import { projectChainedSession, projectionMeta, projectionToolId, rebindSessionId } from "./chained-projection.js";
+import { chainedSessionHeader, projectDirectory, projectTranscript } from "./chained-transcript.js";
+import { CLAUDE_REPLY_ENDED, readClaudeTranscript } from "./claude-transcript.js";
 import { array, harnessCommand, text } from "./process.js";
 import { DEFAULT_MODEL, runStreamJson, streamJsonHelp, streamJsonModel } from "./stream-json.js";
 const MAX_PROJECT_NAME = 200;
@@ -23,6 +25,9 @@ export function claudeProjectName(cwd) {
     return `${name.slice(0, MAX_PROJECT_NAME)}-${Math.abs(hash).toString(36)}`;
 }
 export const claudeProjectDirectory = (cwd) => join(dataRoot(), "projects", claudeProjectName(cwd));
+const projectsRoot = () => join(dataRoot(), "projects");
+/** Every subdirectory's project name starts with this; a hashed long name keeps its first 200 units. */
+const projectPrefix = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-").slice(0, MAX_PROJECT_NAME);
 const profile = {
     harness: "claude",
     label: "Claude Code",
@@ -31,6 +36,7 @@ const profile = {
     dataRoot,
     projectDirectory: claudeProjectDirectory,
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    promptUuid: true,
 };
 function anthropicBlock(block) {
     if (block.type === "text")
@@ -149,5 +155,17 @@ export const claudeHarness = {
             },
         },
     },
-    nativeSync: false,
+    transcript: {
+        roots: () => [projectsRoot()],
+        acceptsDirectory: (path, root, cwd) => projectDirectory(path, root, projectPrefix(cwd)),
+        acceptsTranscript: (path, cwd) => projectTranscript(path, projectsRoot(), projectPrefix(cwd)),
+        header: (path, signal) => chainedSessionHeader(path, "claude", signal),
+        read: (path, signal) => readClaudeTranscript(path, basename(path, ".jsonl"), signal),
+        boundaries: ['"promptSource"', '"subtype":"turn_duration"', '"interruptedMessageId"', '"isApiErrorMessage":true', ...CLAUDE_REPLY_ENDED.map((reason) => `"stop_reason":"${reason}"`)],
+        turnEndRecorded: false,
+        replyEnded: (turn) => CLAUDE_REPLY_ENDED.includes(turn.messages.at(-1)?.stopReason ?? ""),
+        userFinalMarked: false,
+        globalTurnKeys: false,
+        marksCohubTurns: true,
+    },
 };

package/dist/runtime/harnesses/codex.js

@@ -223,7 +223,7 @@ export const codexHarness = {
         turnEndRecorded: true,
         userFinalMarked: true,
         globalTurnKeys: true,
+        marksCohubTurns: true,
         archiveSource: (path, cacheDirectory) => ensurePlainCodexRollout(path, cacheDirectory),
     },
-    nativeSync: true,
 };

package/dist/runtime/harnesses/cursor-transcript.d.ts

@@ -0,0 +1,37 @@
+import type { NativeTranscript } from "../native/transcript.js";
+import type { SessionHeader } from "./types.js";
+/** Chats (`store.db` and `meta.json`) live under the config directory, transcripts under the data directory. */
+export declare const cursorConfigDirectory: () => string;
+export declare const cursorProjectsRoot: () => string;
+export declare const cursorChatsRoot: () => string;
+/** Cursor's project name for a workspace path. */
+export declare const cursorProjectName: (cwd: string) => string;
+export declare const cursorTranscriptPath: (nativeSessionId: string, cwd: string) => string;
+/** A chat's store directory is keyed by the MD5 of the directory the CLI ran in. */
+export declare const cursorChatDirectory: (nativeSessionId: string, cwd: string) => string;
+export declare function acceptsCursorDirectory(path: string, root: string, cwd: string): boolean;
+export declare function acceptsCursorTranscript(path: string, cwd: string): boolean;
+/**
+ * The directory a project name stands for, matched against real directories. On Windows the name
+ * starts with the drive letter and matching ignores case. Several directories with the same name
+ * (`a/b` and `a-b`) cannot be told apart, so none is chosen.
+ */
+type Entry = {
+    name: string;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+};
+export declare function projectDirectory(name: string, platform?: NodeJS.Platform, list?: (directory: string) => Promise<Entry[]>): Promise<string | null>;
+/**
+ * The transcript does not name its project. A CLI chat's `meta.json` does; the IDE writes the same
+ * transcripts without one, so its project name is resolved to the directory it stands for.
+ */
+export declare function cursorSessionHeader(path: string): Promise<SessionHeader | null>;
+/**
+ * Cursor writes the model's messages without ids or times: a prompt (`<user_query>`, or a bare text
+ * that no other user line follows), one line per reply step with its tool calls (results are not
+ * recorded), and `turn_ended` after every Turn. A user line followed by another is context. A Turn
+ * is keyed by the file's checksum through its prompt, so a rewritten history never reuses a key.
+ */
+export declare function readCursorTranscript(path: string, nativeSessionId: string, signal?: AbortSignal): Promise<NativeTranscript>;
+export {};

package/dist/runtime/harnesses/cursor-transcript.js

@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto";
+import { readdirSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { record } from "../json-rpc.js";
+import { extendTurn, readChainedLines } from "./chained-transcript.js";
+import { array, missing, text } from "./process.js";
+const TRANSCRIPTS = "agent-transcripts";
+const USER_QUERY = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+const TIMESTAMP = /<timestamp>([^<]*)<\/timestamp>/;
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+/** Chats (`store.db` and `meta.json`) live under the config directory, transcripts under the data directory. */
+export const cursorConfigDirectory = () => process.env.CURSOR_CONFIG_DIR?.trim()
+    || (process.env.XDG_CONFIG_HOME?.trim() ? join(process.env.XDG_CONFIG_HOME.trim(), "cursor") : join(homedir(), ".cursor"));
+const dataDirectory = () => process.env.CURSOR_DATA_DIR?.trim() || join(homedir(), ".cursor");
+export const cursorProjectsRoot = () => join(dataDirectory(), "projects");
+export const cursorChatsRoot = () => join(cursorConfigDirectory(), "chats");
+/** Cursor's project name for a workspace path. */
+export const cursorProjectName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+/** Windows reuses a project folder whose name differs only in case, and file events name that folder. */
+function projectFolder(cwd) {
+    const name = cursorProjectName(cwd);
+    if (process.platform !== "win32")
+        return name;
+    try {
+        return readdirSync(cursorProjectsRoot()).find((entry) => entry.toLowerCase() === name.toLowerCase()) ?? name;
+    }
+    catch {
+        return name;
+    }
+}
+export const cursorTranscriptPath = (nativeSessionId, cwd) => join(cursorProjectsRoot(), projectFolder(cwd), TRANSCRIPTS, nativeSessionId, `${nativeSessionId}.jsonl`);
+/** A chat's store directory is keyed by the MD5 of the directory the CLI ran in. */
+export const cursorChatDirectory = (nativeSessionId, cwd) => join(cursorChatsRoot(), createHash("md5").update(resolve(cwd)).digest("hex"), nativeSessionId);
+/** A chat's project never changes, so its header is read once. */
+const headers = new Map();
+/** `<project>/agent-transcripts/<id>/<id>.jsonl`; a subdirectory's project name extends its parent's. Sub-agent files are skipped. */
+function transcriptParts(path, root) {
+    const parts = relative(root, path).split(sep);
+    return parts.length && !parts[0]?.startsWith("..") ? parts : null;
+}
+/** Windows paths ignore case, so a terminal opened as `c:\\users` names the same project as `C:\\Users`. */
+const fold = (value, platform) => platform === "win32" ? value.toLowerCase() : value;
+const ownsProject = (name, cwd, platform = process.platform) => {
+    const project = fold(cursorProjectName(cwd), platform), own = fold(name ?? "", platform);
+    return own === project || own.startsWith(`${project}-`);
+};
+export function acceptsCursorDirectory(path, root, cwd) {
+    const parts = transcriptParts(path, root);
+    if (!parts || parts.length > 3 || !ownsProject(parts[0], cwd))
+        return false;
+    return parts.length === 1 || parts[1] === TRANSCRIPTS;
+}
+export function acceptsCursorTranscript(path, cwd) {
+    const parts = transcriptParts(path, cursorProjectsRoot());
+    return parts?.length === 4 && ownsProject(parts[0], cwd) && parts[1] === TRANSCRIPTS && parts[3] === `${parts[2]}.jsonl`;
+}
+export async function projectDirectory(name, platform = process.platform, list = (directory) => readdir(directory, { withFileTypes: true })) {
+    const paths = platform === "win32" ? win32 : posix;
+    const drive = platform === "win32" ? /^([A-Za-z])(?:-(.*))?$/.exec(name) : null;
+    if (platform === "win32" && !drive)
+        return null;
+    const found = [];
+    const walk = async (directory, rest) => {
+        if (found.length > 1)
+            return;
+        if (!rest) {
+            found.push(directory);
+            return;
+        }
+        const entries = await list(directory).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const part = fold(cursorProjectName(entry.name), platform);
+            if (part && (fold(rest, platform) === part || fold(rest, platform).startsWith(`${part}-`)))
+                await walk(paths.join(directory, entry.name), rest.slice(part.length + 1));
+        }
+    };
+    await (drive ? walk(`${drive[1]?.toUpperCase()}:\\`, drive[2] ?? "") : walk("/", name));
+    return found.length === 1 ? found[0] ?? null : null;
+}
+/**
+ * The transcript does not name its project. A CLI chat's `meta.json` does; the IDE writes the same
+ * transcripts without one, so its project name is resolved to the directory it stands for.
+ */
+export async function cursorSessionHeader(path) {
+    const nativeSessionId = basename(path, ".jsonl");
+    if (basename(dirname(path)) !== nativeSessionId)
+        return null;
+    const known = headers.get(nativeSessionId);
+    if (known)
+        return known;
+    let header = null;
+    const hashes = await readdir(cursorChatsRoot()).catch((error) => { if (missing(error))
+        return []; throw error; });
+    for (const hash of hashes) {
+        const meta = await readFile(join(cursorChatsRoot(), hash, nativeSessionId, "meta.json"), "utf8").then((raw) => record(JSON.parse(raw)), () => null);
+        if (!meta || !text(meta.cwd))
+            continue;
+        header = { harness: "cursor", nativeSessionId, cwd: text(meta.cwd), thread: meta.isSubagent === true ? "spawned" : "user" };
+        break;
+    }
+    const project = basename(dirname(dirname(dirname(path))));
+    const cwd = header ? null : await projectDirectory(project);
+    header ??= cwd ? { harness: "cursor", nativeSessionId, cwd, thread: "user" } : null;
+    if (header)
+        headers.set(nativeSessionId, header);
+    return header;
+}
+/** "Saturday, Aug 01, 2026, 9:30 AM (UTC+8)": minutes only, so Turn times are approximate. */
+function promptTime(value) {
+    const match = /^\w+, (\w{3}) (\d{1,2}), (\d{4}), (\d{1,2}):(\d{2}) (AM|PM) \(UTC(?:([+-])(\d{1,2})(?::(\d{2}))?)?\)$/.exec(value.trim());
+    const month = MONTHS.indexOf(match?.[1] ?? "");
+    if (!match || month < 0)
+        return null;
+    const hour = Number(match[4]) % 12 + (match[6] === "PM" ? 12 : 0);
+    const offset = (match[7] === "-" ? -1 : 1) * (Number(match[8] ?? 0) * 60 + Number(match[9] ?? 0));
+    const time = Date.UTC(Number(match[3]), month, Number(match[2]), hour, Number(match[5])) - offset * 60_000;
+    return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+const blocks = (value) => array(record(record(value).message).content).map(record);
+/**
+ * Cursor writes the model's messages without ids or times: a prompt (`<user_query>`, or a bare text
+ * that no other user line follows), one line per reply step with its tool calls (results are not
+ * recorded), and `turn_ended` after every Turn. A user line followed by another is context. A Turn
+ * is keyed by the file's checksum through its prompt, so a rewritten history never reuses a key.
+ */
+export async function readCursorTranscript(path, nativeSessionId, signal) {
+    const read = await readChainedLines(path, signal);
+    const modified = (await stat(path)).mtime.toISOString();
+    const turns = [];
+    let current = null;
+    for (const [index, line] of read.lines.entries()) {
+        const value = line.value;
+        if (value.role === "user") {
+            const raw = blocks(value).map((block) => text(block.text)).join("\n");
+            // A bare text is a prompt only once a reply or end follows it; until then it may be context.
+            const next = read.lines[index + 1]?.value;
+            const query = USER_QUERY.exec(raw)?.[1] ?? (next && next.role !== "user" ? raw.replace(TIMESTAMP, "").trim() : null);
+            if (!query)
+                continue;
+            const startedAt = promptTime(TIMESTAMP.exec(raw)?.[1] ?? "") ?? current?.startedAt ?? modified;
+            current = {
+                key: line.sha256, parentKey: turns.at(-1)?.key ?? null, userContent: [{ type: "text", text: query }], messages: [], startedAt,
+                startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null,
+            };
+            turns.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        if (value.role === "assistant") {
+            const content = blocks(value).flatMap((block, position) => {
+                if (block.type === "text")
+                    return text(block.text) ? [{ type: "text", text: text(block.text) }] : [];
+                if (block.type !== "tool_use")
+                    return [];
+                return [{ type: "tool_use", id: `cursor_${line.sha256.slice(0, 24)}_${position}`, name: text(block.name) || "tool", input: record(block.input) }];
+            });
+            if (content.length)
+                current.messages.push({ content, provider: null, model: null, stopReason: content.some((block) => block.type === "tool_use") ? "tool_use" : "stop", errorMessage: null });
+            extendTurn(current, line, true);
+            continue;
+        }
+        if (value.type === "turn_ended" && !current.result) {
+            const status = text(value.status) || "success";
+            const last = current.messages.at(-1);
+            if (last && status === "error")
+                Object.assign(last, { stopReason: "error", errorMessage: text(value.error) || "Turn failed" });
+            if (last && status === "aborted")
+                last.stopReason = "aborted";
+            current.result = { messages: current.messages, completedAt: modified, status: status === "error" ? "failed" : status === "aborted" ? "interrupted" : "completed" };
+            current.ended = true;
+            extendTurn(current, line, false);
+        }
+    }
+    // A Turn ends no later than the next one starts.
+    turns.forEach((turn, index) => { if (turn.result)
+        turn.result.completedAt = turns[index + 1]?.startedAt ?? modified; });
+    return { nativeSessionId, cwd: (await cursorSessionHeader(path))?.cwd ?? "", turns, prefixes: read.prefixes };
+}

package/dist/runtime/harnesses/cursor.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeExecutionEvent, RuntimeMessage } from "@neta-art/cohub";
+import { type JsonRecord } from "../json-rpc.js";
+import type { HarnessModel, LocalHarnessAdapter } from "./types.js";
+/** The process a Cursor CLI invocation runs, and the variables its launcher would set. */
+export declare function cursorCommand(executable: string, args: string[], cwd: string): {
+    command: [string, string[]];
+    env: Record<string, string>;
+};
+/** `cursor-agent models`: `<id> - <name> (current, default)` per line. */
+export declare function cursorModels(output: string): HarnessModel[];
+/**
+ * Maps `--output-format stream-json --stream-partial-output` onto Cohub's streaming protocol. A reply
+ * step ends once its tool calls returned. Cursor repeats a step's streamed text as one line right
+ * before a tool call, question or retry (with a timestamp) and at the end (without one); such a line
+ * is held until the next event says whether it was a repeat.
+ */
+export declare function cursorTranslator(emit: (event: RuntimeExecutionEvent) => void, identity: {
+    model: string | null;
+}): {
+    result: () => RuntimeMessage | null;
+    last: () => RuntimeMessage;
+    push(event: JsonRecord): boolean;
+};
+export declare const cursorHarness: LocalHarnessAdapter;