march-cli 0.1.0

package/src/provider/config-command.mjs

@@ -0,0 +1,129 @@
+import { createInterface } from "node:readline";
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
+import { globalConfigJsonPath, upsertProviderProfile } from "../config/config-json.mjs";
+import { getMarchAuthPath } from "../auth/storage.mjs";
+import { selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+import { PROVIDER_PRESETS } from "./presets.mjs";
+
+export { formatSelectionList, selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+
+export async function runProviderConfigCommand({
+  homeDir,
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+  readSecret = readLine,
+  authStorage = AuthStorage.create(getMarchAuthPath(homeDir)),
+} = {}) {
+  const preset = await select({
+    input,
+    output,
+    message: "Choose provider to configure",
+    items: PROVIDER_PRESETS.map((item) => ({ label: item.label, value: item })),
+  });
+  if (!preset) {
+    output.write("Provider configuration cancelled.\n");
+    return 1;
+  }
+
+  const authMethod = preset.authMethods.length === 1
+    ? preset.authMethods[0]
+    : await select({
+      input,
+      output,
+      message: "Choose auth method",
+      items: preset.authMethods.map((method) => ({ label: formatAuthMethod(method), value: method })),
+    });
+  if (!authMethod) {
+    output.write("Provider configuration cancelled.\n");
+    return 1;
+  }
+
+  if (authMethod === "oauth") {
+    return runOAuthConfig({ preset, authStorage, input, output, homeDir });
+  }
+
+  if (authMethod !== "apiKey") {
+    output.write(`Unsupported auth method: ${authMethod}\n`);
+    return 1;
+  }
+
+  const apiKey = String(await readSecret({ input, output, prompt: `${preset.apiKeyLabel}: ` }) ?? "").trim();
+  if (!apiKey) {
+    output.write("API key is required.\n");
+    return 1;
+  }
+
+  const path = globalConfigJsonPath(homeDir);
+  upsertProviderProfile({
+    path,
+    id: preset.id,
+    type: preset.type,
+    auth: { method: "apiKey", apiKey },
+  });
+  output.write(`Saved provider: ${preset.label}\n`);
+  output.write(`Config: ${path}\n`);
+  return 0;
+}
+
+function formatAuthMethod(method) {
+  if (method === "apiKey") return "API key";
+  if (method === "oauth") return "OAuth / subscription";
+  return method;
+}
+
+async function runOAuthConfig({ preset, authStorage, input, output, homeDir }) {
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`Logging in to ${preset.label}...\n`);
+    await authStorage.login(preset.type, {
+      onAuth: (info) => {
+        output.write(`\nOpen this URL in your browser:\n${info.url}\n`);
+        if (info.instructions) output.write(`${info.instructions}\n`);
+        output.write("\n");
+      },
+      onPrompt: (prompt) => ask(rl, `${prompt.message}${prompt.placeholder ? ` (${prompt.placeholder})` : ""}: `),
+      onManualCodeInput: () => ask(rl, "Paste redirect URL or code: "),
+      onProgress: (message) => output.write(`${message}\n`),
+      onSelect: async (prompt) => selectOAuthOption({ prompt, rl, output }),
+    });
+    output.write(`\nCredentials saved to ${getMarchAuthPath(homeDir)}\n`);
+    return 0;
+  } catch (error) {
+    output.write(`OAuth login failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  } finally {
+    rl.close();
+  }
+}
+
+async function selectOAuthOption({ prompt, rl, output }) {
+  output.write(`${prompt.message}\n`);
+  for (let i = 0; i < prompt.options.length; i++) {
+    const option = prompt.options[i];
+    output.write(`  ${i + 1}. ${option.label} (${option.id})\n`);
+  }
+  const answer = await ask(rl, `Enter option id or number (1-${prompt.options.length}): `);
+  return resolveSelection(answer, prompt.options);
+}
+
+function resolveSelection(answer, options) {
+  const trimmed = answer.trim();
+  const index = Number.parseInt(trimmed, 10);
+  if (Number.isInteger(index) && String(index) === trimmed && index >= 1 && index <= options.length) {
+    return options[index - 1].id;
+  }
+  return options.some((option) => option.id === trimmed) ? trimmed : undefined;
+}
+
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function readLine({ input = process.stdin, output = process.stdout, prompt }) {
+  const rl = createInterface({ input, output });
+  return new Promise((resolve) => rl.question(prompt, (answer) => {
+    rl.close();
+    resolve(answer);
+  }));
+}

package/src/provider/presets.mjs

@@ -0,0 +1,72 @@
+import { getProviders } from "@earendil-works/pi-ai";
+import { getOAuthProviders } from "@earendil-works/pi-ai/oauth";
+import { registerSuperGrokOAuthProvider } from "../supergrok/oauth-provider.mjs";
+
+registerSuperGrokOAuthProvider();
+
+const PROVIDER_LABELS = {
+  anthropic: "Anthropic",
+  "amazon-bedrock": "Amazon Bedrock",
+  "azure-openai-responses": "Azure OpenAI Responses",
+  cerebras: "Cerebras",
+  "cloudflare-ai-gateway": "Cloudflare AI Gateway",
+  "cloudflare-workers-ai": "Cloudflare Workers AI",
+  deepseek: "DeepSeek",
+  fireworks: "Fireworks",
+  google: "Google Gemini",
+  "google-vertex": "Google Vertex AI",
+  groq: "Groq",
+  huggingface: "Hugging Face",
+  "kimi-coding": "Kimi For Coding",
+  mistral: "Mistral",
+  minimax: "MiniMax",
+  "minimax-cn": "MiniMax (China)",
+  moonshotai: "Moonshot AI",
+  "moonshotai-cn": "Moonshot AI (China)",
+  opencode: "OpenCode Zen",
+  "opencode-go": "OpenCode Go",
+  openai: "OpenAI",
+  "openai-codex": "OpenAI Codex",
+  openrouter: "OpenRouter",
+  "supergrok-oauth": "SuperGrok OAuth (xAI Subscription)",
+  "vercel-ai-gateway": "Vercel AI Gateway",
+  xai: "xAI",
+  "xai-oauth": "xAI OAuth (SuperGrok compatible)",
+  zai: "ZAI",
+  xiaomi: "Xiaomi MiMo",
+  "xiaomi-token-plan-cn": "Xiaomi MiMo Token Plan (China)",
+  "xiaomi-token-plan-ams": "Xiaomi MiMo Token Plan (Amsterdam)",
+  "xiaomi-token-plan-sgp": "Xiaomi MiMo Token Plan (Singapore)",
+};
+
+export const PROVIDER_PRESETS = buildProviderPresets();
+
+export function buildProviderPresets() {
+  const oauthProviderIds = new Set(getOAuthProviders().map((provider) => provider.id));
+  const ids = new Set([...getProviders(), ...oauthProviderIds]);
+  return [...ids].map((id) => {
+    const label = getProviderLabel(id);
+    return {
+      id,
+      label,
+      type: id,
+      authMethods: getAuthMethods(id, oauthProviderIds),
+      apiKeyLabel: `${label} API key`,
+    };
+  }).sort((a, b) => a.label.localeCompare(b.label));
+}
+
+export function getProviderPreset(id) {
+  return PROVIDER_PRESETS.find((preset) => preset.id === id || preset.type === id) ?? null;
+}
+
+export function getProviderLabel(id) {
+  return PROVIDER_LABELS[id] ?? id;
+}
+
+function getAuthMethods(id, oauthProviderIds) {
+  const methods = [];
+  if (oauthProviderIds.has(id)) methods.push("oauth");
+  methods.push("apiKey");
+  return methods;
+}

package/src/session/attachment-display.mjs

@@ -0,0 +1,16 @@
+import { basename } from "node:path";
+
+const ATTACHMENT_MARKER_RE = /@\.march\/attachments\/[^\s"'`<>)]+/g;
+
+export function formatAttachmentMarkerForDisplay(marker) {
+  const name = formatAttachmentDisplayName(basename(String(marker || "").replace(/\\/g, "/")) || "image");
+  return `[image: ${name}]`;
+}
+
+export function formatMessageAttachmentsForDisplay(text) {
+  return String(text || "").replace(ATTACHMENT_MARKER_RE, (marker) => formatAttachmentMarkerForDisplay(marker));
+}
+
+export function formatAttachmentDisplayName(name) {
+  return String(name || "image").replace(/^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z_/, "");
+}

package/src/session/attachment-references.mjs

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { extname, join, relative, resolve } from "node:path";
+import { getAttachmentRoot, imageExtensionForMime } from "./attachments.mjs";
+
+const ATTACHMENT_MARKER_RE = /@\.march\/attachments\/[^\s"'`<>)]+/g;
+
+const IMAGE_MIME_BY_EXT = Object.freeze({
+  ".gif": "image/gif",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+});
+
+export function resolveImageAttachmentReferences({ text, projectMarchDir } = {}) {
+  if (!text || !projectMarchDir) return { images: [], references: [] };
+
+  const seen = new Set();
+  const images = [];
+  const references = [];
+  for (const marker of String(text).match(ATTACHMENT_MARKER_RE) || []) {
+    if (seen.has(marker)) continue;
+    seen.add(marker);
+
+    const relativePath = marker.slice("@.march/".length);
+    const path = assertInsideAttachmentRoot(join(projectMarchDir, relativePath), projectMarchDir);
+    if (!existsSync(path)) continue;
+
+    const mimeType = readSupportedAttachmentMimeType(path) ?? mimeTypeForPath(path);
+    if (!mimeType) continue;
+
+    const data = readFileSync(path).toString("base64");
+    images.push({ type: "image", mimeType, data });
+    references.push({ marker, path, mimeType });
+  }
+
+  return { images, references };
+}
+
+function readSupportedAttachmentMimeType(path) {
+  const metadataPath = path.replace(/\.[^.\\/]+$/, ".json");
+  if (!existsSync(metadataPath)) return null;
+  try {
+    const metadata = JSON.parse(readFileSync(metadataPath, "utf8"));
+    if (typeof metadata.mimeType !== "string") return null;
+    imageExtensionForMime(metadata.mimeType);
+    return metadata.mimeType;
+  } catch {
+    return null;
+  }
+}
+
+function mimeTypeForPath(path) {
+  return IMAGE_MIME_BY_EXT[extname(path).toLowerCase()] ?? null;
+}
+
+function assertInsideAttachmentRoot(path, projectMarchDir) {
+  const root = resolve(getAttachmentRoot(projectMarchDir));
+  const resolvedPath = resolve(path);
+  const rel = relative(root, resolvedPath);
+  if (rel.startsWith("..") || rel === "" || resolve(root, rel) !== resolvedPath) {
+    throw new Error("attachment marker escaped attachments root");
+  }
+  return resolvedPath;
+}

package/src/session/attachments.mjs

@@ -0,0 +1,140 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { basename, join, relative, resolve } from "node:path";
+
+export const ATTACHMENT_STORE_VERSION = 1;
+
+const IMAGE_EXTENSIONS = Object.freeze({
+  "image/gif": "gif",
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/webp": "webp",
+});
+
+export function getAttachmentRoot(projectMarchDir) {
+  if (!projectMarchDir) throw new Error("projectMarchDir is required");
+  return join(projectMarchDir, "attachments");
+}
+
+export function getSessionAttachmentDir({ projectMarchDir, sessionId }) {
+  return join(getAttachmentRoot(projectMarchDir), sanitizePathSegment(sessionId || "session"));
+}
+
+export function saveImageAttachment({
+  projectMarchDir,
+  sessionId,
+  data,
+  mimeType,
+  source = "unknown",
+  now = new Date(),
+  id = randomUUID().slice(0, 8),
+} = {}) {
+  const ext = imageExtensionForMime(mimeType);
+  const buffer = toBuffer(data);
+  if (buffer.length === 0) throw new Error("attachment data is empty");
+
+  const dir = getSessionAttachmentDir({ projectMarchDir, sessionId });
+  mkdirSync(dir, { recursive: true });
+
+  const createdAt = now.toISOString();
+  const stem = `${formatTimestampForFile(createdAt)}_${sanitizePathSegment(id)}`;
+  const path = assertInsideRoot(resolve(dir, `${stem}.${ext}`), getAttachmentRoot(projectMarchDir));
+  const metadataPath = assertInsideRoot(resolve(dir, `${stem}.json`), getAttachmentRoot(projectMarchDir));
+  writeFileSync(path, buffer);
+
+  const metadata = {
+    version: ATTACHMENT_STORE_VERSION,
+    sessionId: sessionId || null,
+    source,
+    mimeType,
+    sizeBytes: buffer.length,
+    createdAt,
+    filename: basename(path),
+    relativePath: toProjectMarchRelative(projectMarchDir, path),
+  };
+  writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+  return {
+    path,
+    metadataPath,
+    relativePath: metadata.relativePath,
+    metadata,
+  };
+}
+
+export function saveGeneratedImageAttachment({
+  projectMarchDir,
+  data,
+  mimeType,
+  now = new Date(),
+  id = randomUUID().slice(0, 8),
+} = {}) {
+  const ext = imageExtensionForMime(mimeType);
+  const buffer = toBuffer(data);
+  if (buffer.length === 0) throw new Error("attachment data is empty");
+
+  const dir = assertInsideRoot(resolve(getAttachmentRoot(projectMarchDir), "generated"), getAttachmentRoot(projectMarchDir));
+  mkdirSync(dir, { recursive: true });
+
+  const createdAt = now.toISOString();
+  const stem = `${formatTimestampForFile(createdAt)}_${sanitizePathSegment(id)}`;
+  const path = assertInsideRoot(resolve(dir, `${stem}.${ext}`), getAttachmentRoot(projectMarchDir));
+  const metadataPath = assertInsideRoot(resolve(dir, `${stem}.json`), getAttachmentRoot(projectMarchDir));
+  writeFileSync(path, buffer);
+
+  const metadata = {
+    version: ATTACHMENT_STORE_VERSION,
+    sessionId: null,
+    source: "image_generate",
+    mimeType,
+    sizeBytes: buffer.length,
+    createdAt,
+    filename: basename(path),
+    relativePath: toProjectMarchRelative(projectMarchDir, path),
+  };
+  writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+  return {
+    path,
+    metadataPath,
+    relativePath: metadata.relativePath,
+    marker: `@.march/${metadata.relativePath}`,
+    metadata,
+  };
+}
+
+export function imageExtensionForMime(mimeType) {
+  const ext = IMAGE_EXTENSIONS[String(mimeType || "").toLowerCase()];
+  if (!ext) throw new Error(`unsupported image mime type: ${mimeType || "unknown"}`);
+  return ext;
+}
+
+export function sanitizePathSegment(value) {
+  return String(value || "value")
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/^[._-]+|[._-]+$/g, "")
+    .slice(0, 80) || "value";
+}
+
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof Uint8Array) return Buffer.from(data);
+  if (typeof data === "string") return Buffer.from(data, "base64");
+  throw new Error("attachment data must be a Buffer, Uint8Array, or base64 string");
+}
+
+function formatTimestampForFile(isoString) {
+  return isoString.replace(/[:.]/g, "-");
+}
+
+function assertInsideRoot(path, root) {
+  const resolvedRoot = resolve(root);
+  const resolvedPath = resolve(path);
+  const rel = relative(resolvedRoot, resolvedPath);
+  if (rel.startsWith("..") || rel === "" || resolve(resolvedRoot, rel) !== resolvedPath) {
+    throw new Error("attachment path escaped attachments root");
+  }
+  return resolvedPath;
+}
+
+function toProjectMarchRelative(projectMarchDir, path) {
+  return relative(resolve(projectMarchDir), resolve(path)).replace(/\\/g, "/");
+}

package/src/session/persist.mjs

@@ -0,0 +1 @@
+// Legacy session persistence removed. All sessions use pi JSONL format.

package/src/session/pi-manager.mjs

@@ -0,0 +1,34 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+
+export function getPiSessionDir(projectMarchDir) {
+  return join(projectMarchDir, "pi-sessions");
+}
+
+export function createPiSessionManager({ cwd, projectMarchDir }) {
+  const sessionDir = getPiSessionDir(projectMarchDir);
+  mkdirSync(sessionDir, { recursive: true });
+  return SessionManager.create(cwd, sessionDir);
+}
+
+export function resolvePiSessionManager({ cwd, projectMarchDir, enabled = false }) {
+  if (!enabled) return null;
+  return createPiSessionManager({ cwd, projectMarchDir });
+}
+
+export async function listPiSessionInfos({ cwd, projectMarchDir }) {
+  const sessionDir = getPiSessionDir(projectMarchDir);
+  const sessions = await SessionManager.list(cwd, sessionDir);
+  return sessions.map((session) => ({
+    id: session.id,
+    path: session.path,
+    savedAt: session.modified?.toISOString?.() ?? "",
+    createdAt: session.created?.toISOString?.() ?? "",
+    cwd: session.cwd,
+    name: session.name,
+    turnCount: session.messageCount,
+    firstMessage: session.firstMessage,
+    parentSessionPath: session.parentSessionPath ?? null,
+  }));
+}

package/src/session/session-utils.mjs

@@ -0,0 +1,16 @@
+/**
+ * Shared session utility functions.
+ */
+export function formatSessionId(namespace, sessionName) {
+  if (!namespace && !sessionName) return "default";
+  if (!sessionName) return namespace;
+  if (!namespace) return sessionName;
+  return `${namespace}/${sessionName}`;
+}
+
+export function parseSessionId(sessionId) {
+  if (!sessionId || sessionId === "default") return { namespace: "", sessionName: "default" };
+  const idx = sessionId.indexOf("/");
+  if (idx === -1) return { namespace: "", sessionName: sessionId };
+  return { namespace: sessionId.slice(0, idx), sessionName: sessionId.slice(idx + 1) };
+}

package/src/session/sidecar-sync.mjs

@@ -0,0 +1,19 @@
+import { savePiSessionSidecar } from "./sidecar.mjs";
+
+export function syncPiSessionSidecar({ enabled = false, projectMarchDir, engine, sessionStats, metadata = {} }) {
+  if (!enabled || !projectMarchDir || !sessionStats?.persisted || !sessionStats.sessionFile) {
+    return null;
+  }
+
+  return savePiSessionSidecar({
+    projectMarchDir,
+    sessionRef: sessionStats.sessionFile,
+    engine,
+    metadata: {
+      sessionId: sessionStats.sessionId,
+      sessionFile: sessionStats.sessionFile,
+      runtimeHost: Boolean(sessionStats.runtimeHost),
+      ...metadata,
+    },
+  });
+}

package/src/session/sidecar.mjs

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+export const PI_SIDECAR_VERSION = 1;
+
+export function getPiSidecarDir(projectMarchDir) {
+  return join(projectMarchDir, "pi-sidecars");
+}
+
+export function getPiSidecarPath(projectMarchDir, sessionRef) {
+  return join(getPiSidecarDir(projectMarchDir), `${normalizeSessionRef(sessionRef)}.json`);
+}
+
+export function captureContextSidecar(engine, metadata = {}) {
+  return {
+    version: PI_SIDECAR_VERSION,
+    savedAt: new Date().toISOString(),
+    ...metadata,
+    cwd: engine.cwd,
+    modelId: engine.modelId,
+    provider: engine.provider,
+    sessionName: engine.sessionName ?? "",
+    thinkingLevel: engine.thinkingLevel,
+    namespace: engine.namespace,
+    turns: engine.turns,
+  };
+}
+
+export function savePiSessionSidecar({ projectMarchDir, sessionRef, engine, metadata = {} }) {
+  return savePiSessionSidecarState({
+    projectMarchDir,
+    sessionRef,
+    state: captureContextSidecar(engine, metadata),
+  });
+}
+
+export function savePiSessionSidecarState({ projectMarchDir, sessionRef, state }) {
+  const sidecarDir = getPiSidecarDir(projectMarchDir);
+  mkdirSync(sidecarDir, { recursive: true });
+  validateSidecarState(state);
+  const path = getPiSidecarPath(projectMarchDir, sessionRef);
+  writeFileSync(path, JSON.stringify(state, null, 2), "utf8");
+  return { path, state };
+}
+
+export function loadPiSessionSidecar({ projectMarchDir, sessionRef }) {
+  const path = getPiSidecarPath(projectMarchDir, sessionRef);
+  if (!existsSync(path)) return null;
+  const state = JSON.parse(readFileSync(path, "utf8"));
+  if (!isValidSidecarState(state)) {
+    throw new Error("Invalid pi session sidecar");
+  }
+  return { path, state };
+}
+
+function validateSidecarState(state) {
+  if (!isValidSidecarState(state)) throw new Error("Invalid pi session sidecar");
+}
+
+function isValidSidecarState(state) {
+  return state?.version === PI_SIDECAR_VERSION && Boolean(state.cwd) && Array.isArray(state.turns);
+}
+
+function normalizeSessionRef(sessionRef) {
+  const ref = basename(String(sessionRef).trim()).replace(/\.jsonl$/i, "");
+  if (!ref || ref === "." || ref === "..") throw new Error("Invalid pi session reference");
+  return ref.replace(/[^a-zA-Z0-9._-]/g, "_");
+}

package/src/session/transcript.mjs

@@ -0,0 +1,83 @@
+import { readFileSync } from "node:fs";
+
+export const DEFAULT_TRANSCRIPT_TURN_LIMIT = 20;
+
+export function loadPiSessionTranscriptTurns(sessionPath, { limit = DEFAULT_TRANSCRIPT_TURN_LIMIT } = {}) {
+  const entries = readPiSessionEntries(sessionPath);
+  const turns = [];
+  let current = null;
+
+  for (const entry of entries) {
+    if (entry?.type !== "message") continue;
+    const message = entry.message;
+    if (message?.role === "user") {
+      current = { userMessage: extractMessageText(message), assistantMessage: "" };
+      turns.push(current);
+      continue;
+    }
+    if (message?.role === "assistant") {
+      const text = extractMessageText(message);
+      if (!current) {
+        current = { userMessage: "", assistantMessage: text };
+        turns.push(current);
+      } else if (current.assistantMessage) {
+        current.assistantMessage += `\n\n${text}`;
+      } else {
+        current.assistantMessage = text;
+      }
+    }
+  }
+
+  const normalized = turns
+    .filter((turn) => turn.userMessage || turn.assistantMessage)
+    .map((turn, index) => ({ index: index + 1, ...turn }));
+  return normalized.slice(-Math.max(0, limit));
+}
+
+export function writeTranscriptToOutput(output, turns) {
+  if (!Array.isArray(turns) || turns.length === 0) return;
+  for (const turn of turns) {
+    if (turn.userMessage) {
+      output.writeln("You");
+      for (const line of String(turn.userMessage).split(/\r?\n/)) output.writeln(line);
+    }
+    if (turn.assistantMessage) {
+      output.writeln("");
+      output.writeln("March");
+      output.writeMarkdown(String(turn.assistantMessage));
+      output.ensureNewline();
+      output.sealCurrentText();
+    }
+    output.writeln("");
+  }
+}
+
+function readPiSessionEntries(sessionPath) {
+  const text = readFileSync(sessionPath, "utf8");
+  const entries = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // Ignore partial or malformed JSONL entries; transcript restore is best effort.
+    }
+  }
+  return entries;
+}
+
+function extractMessageText(message) {
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part?.type === "text" || part?.type === "input_text") return part.text ?? "";
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}