deepline 0.3.294 → 0.3.296

package/dist/cli/chunk-AQRTLPHZ.js

@@ -0,0 +1,735 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk7D6QG5KFjs = require('./chunk-7D6QG5KF.js');
+
+// src/cli/commands/sessions.ts
+
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('path');
+var _zlib = require('zlib');
+var _crypto = require('crypto');
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var UUID_IN_TEXT_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+var MAX_SESSION_UPLOAD_BYTES = 35e5;
+var MAX_DIRECT_SESSION_DECODED_BYTES = 50 * 1024 * 1024;
+var CHUNK_SIZE_BYTES = 25e5;
+var MAX_EVENT_STRING_CHARS = 8e3;
+var MAX_EVENT_LIST_ITEMS = 40;
+var MAX_EVENT_OBJECT_KEYS = 80;
+var TRUNCATION_MARKER = "...[truncated]";
+var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
+function homeDir() {
+  return _optionalChain([process, 'access', _ => _.env, 'access', _2 => _2.HOME, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()]) || _os.homedir.call(void 0, );
+}
+function detectShellContext() {
+  const shellPath = _optionalChain([process, 'access', _5 => _5.env, 'access', _6 => _6.SHELL, 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]) || _optionalChain([process, 'access', _9 => _9.env, 'access', _10 => _10.ComSpec, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]) || _optionalChain([process, 'access', _13 => _13.env, 'access', _14 => _14.COMSPEC, 'optionalAccess', _15 => _15.trim, 'call', _16 => _16()]) || "";
+  return {
+    shell: shellPath ? _path.basename.call(void 0, shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell_path: shellPath || null,
+    os: _os.platform.call(void 0, ),
+    cwd: process.cwd()
+  };
+}
+function claudeProjectsRoot() {
+  return _path.join.call(void 0, homeDir(), ".claude", "projects");
+}
+function codexSessionsRoot() {
+  return _path.join.call(void 0, homeDir(), ".codex", "sessions");
+}
+function listClaudeSessionFiles() {
+  const root = claudeProjectsRoot();
+  if (!_fs.existsSync.call(void 0, root)) return [];
+  const projectDirs = readDirectoryNames(root);
+  const files = [];
+  for (const projectDir of projectDirs) {
+    const fullProjectDir = _path.join.call(void 0, root, projectDir);
+    for (const fileName of readDirectoryNames(fullProjectDir)) {
+      if (fileName.endsWith(".jsonl")) {
+        const filePath = _path.join.call(void 0, fullProjectDir, fileName);
+        const sessionId = sessionIdFromClaudeFilePath(filePath);
+        const stat = statIfReadable(filePath);
+        if (sessionId && stat) {
+          files.push({
+            agent: "claude",
+            sessionId,
+            filePath,
+            mtimeMs: stat.mtimeMs
+          });
+        }
+      }
+    }
+  }
+  return files;
+}
+function listCodexSessionFiles() {
+  const root = codexSessionsRoot();
+  if (!_fs.existsSync.call(void 0, root)) return [];
+  const files = [];
+  for (const filePath of listJsonlFilesRecursive(root, 5)) {
+    const stat = statIfReadable(filePath);
+    if (!stat) continue;
+    const sessionId = _nullishCoalesce(sessionIdFromCodexFilePath(filePath), () => ( readCodexSessionId(filePath)));
+    if (!sessionId) continue;
+    files.push({ agent: "codex", sessionId, filePath, mtimeMs: stat.mtimeMs });
+  }
+  return files;
+}
+function listSessionFiles(agent) {
+  const files = [];
+  if (agent === "auto" || agent === "claude") {
+    files.push(...listClaudeSessionFiles());
+  }
+  if (agent === "auto" || agent === "codex") {
+    files.push(...listCodexSessionFiles());
+  }
+  return files;
+}
+function readDirectoryNames(dir) {
+  try {
+    return _fs.readdirSync.call(void 0, dir);
+  } catch (e) {
+    return [];
+  }
+}
+function listJsonlFilesRecursive(root, maxDepth) {
+  const files = [];
+  function visit(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = _fs.readdirSync.call(void 0, dir, { withFileTypes: true });
+    } catch (e2) {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = _path.join.call(void 0, dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(fullPath, depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  visit(root, 0);
+  return files;
+}
+function statIfReadable(filePath) {
+  try {
+    return _fs.statSync.call(void 0, filePath);
+  } catch (e3) {
+    return null;
+  }
+}
+function newestSessionFile(agent) {
+  let newest = null;
+  for (const candidate of listSessionFiles(agent)) {
+    if (!newest || candidate.mtimeMs > newest.mtimeMs) {
+      newest = candidate;
+    }
+  }
+  return newest;
+}
+function sessionIdFromClaudeFilePath(filePath) {
+  return _path.basename.call(void 0, filePath, ".jsonl");
+}
+function sessionIdFromCodexFilePath(filePath) {
+  const match = _path.basename.call(void 0, filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  return _nullishCoalesce(_optionalChain([match, 'optionalAccess', _17 => _17[0]]), () => ( null));
+}
+function readCodexSessionId(filePath) {
+  try {
+    for (const line of normalizedJsonLines(_fs.readFileSync.call(void 0, filePath)).slice(
+      0,
+      20
+    )) {
+      const parsed = parseJsonLine(line);
+      if (!parsed || typeof parsed !== "object") continue;
+      const record = parsed;
+      const payload = record.payload && typeof record.payload === "object" ? record.payload : null;
+      const id = record.type === "session_meta" && typeof _optionalChain([payload, 'optionalAccess', _18 => _18.id]) === "string" ? payload.id : null;
+      if (id && UUID_RE.test(id)) return id;
+    }
+  } catch (e4) {
+    return null;
+  }
+  return null;
+}
+function sessionSearchDescription(agent) {
+  if (agent === "claude") return "~/.claude/projects/*/<session-id>.jsonl";
+  if (agent === "codex") return "~/.codex/sessions/**/*.jsonl";
+  return "~/.claude/projects/*/<session-id>.jsonl or ~/.codex/sessions/**/*.jsonl";
+}
+function parseSessionAgent(value) {
+  const normalized = String(value || "auto").trim().toLowerCase();
+  if (normalized === "auto" || normalized === "claude" || normalized === "codex") {
+    return normalized;
+  }
+  throw new Error("Invalid --agent value. Expected auto, claude, or codex.");
+}
+function parseSessionRating(value) {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "poor") return "bad";
+  if (normalized === "good" || normalized === "bad" || normalized === "neutral") {
+    return normalized;
+  }
+  throw new Error("Invalid --rating value. Expected good, poor, or neutral.");
+}
+function findSessionFile(sessionId, agent) {
+  if (!UUID_RE.test(sessionId)) {
+    throw new Error(
+      "Invalid session ID format. Expected a UUID such as 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca."
+    );
+  }
+  for (const candidate of listSessionFiles(agent)) {
+    if (candidate.sessionId === sessionId) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveSessionTargets(input) {
+  const agent = parseSessionAgent(input.agent);
+  const targets = [];
+  if (input.currentSession) {
+    const currentFile = newestSessionFile(agent);
+    if (!currentFile) {
+      throw new Error(
+        `No session files found in ${sessionSearchDescription(agent)}.`
+      );
+    }
+    targets.push({
+      sessionId: currentFile.sessionId,
+      label: `${currentFile.agent}-session-${currentFile.sessionId}`,
+      filePath: currentFile.filePath,
+      agent: currentFile.agent
+    });
+  }
+  for (const [index, sessionId] of (_nullishCoalesce(input.sessionIds, () => ( []))).entries()) {
+    const candidate = findSessionFile(sessionId, agent);
+    if (!candidate) {
+      throw new Error(
+        `Session file not found in ${sessionSearchDescription(agent)}: ${sessionId}`
+      );
+    }
+    targets.push({
+      sessionId,
+      label: _nullishCoalesce(_optionalChain([input, 'access', _19 => _19.labels, 'optionalAccess', _20 => _20[index]]), () => ( `${candidate.agent}-session-${sessionId}`)),
+      filePath: candidate.filePath,
+      agent: candidate.agent
+    });
+  }
+  if (targets.length === 0) {
+    throw new Error("One of --session-id or --current-session is required.");
+  }
+  return targets;
+}
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch (e5) {
+    return null;
+  }
+}
+function normalizedJsonLines(raw) {
+  return raw.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function stripNoiseEvents(raw) {
+  const lines = [];
+  for (const line of normalizedJsonLines(raw)) {
+    const parsed = parseJsonLine(line);
+    if (parsed && typeof parsed === "object" && NOISE_EVENT_TYPES.has(String(_nullishCoalesce(parsed.type, () => ( ""))))) {
+      continue;
+    }
+    lines.push(line);
+  }
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function messageContentKey(value) {
+  const message = value.message;
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  return content.map((block) => {
+    if (!block || typeof block !== "object") return String(block);
+    const record = block;
+    const type = String(_nullishCoalesce(record.type, () => ( "")));
+    if (type === "tool_use") {
+      return `tool_use:${String(_nullishCoalesce(record.name, () => ( "")))}:${String(_nullishCoalesce(record.id, () => ( "")))}`;
+    }
+    if (type === "tool_result") {
+      return `tool_result:${String(_nullishCoalesce(record.tool_use_id, () => ( "")))}`;
+    }
+    return String(_nullishCoalesce(record.text, () => ( type)));
+  }).join("\n");
+}
+function dedupConsecutiveEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const output = [];
+  let index = 0;
+  while (index < parsedEvents.length) {
+    const event = parsedEvents[index];
+    if (!event || typeof event !== "object") {
+      output.push(_nullishCoalesce(rawLines[index], () => ( "")));
+      index += 1;
+      continue;
+    }
+    const record = event;
+    const eventType = String(_nullishCoalesce(record.type, () => ( "")));
+    const eventKey = messageContentKey(record);
+    if (!["user", "assistant"].includes(eventType) || !eventKey) {
+      output.push(_nullishCoalesce(rawLines[index], () => ( "")));
+      index += 1;
+      continue;
+    }
+    let runCount = 1;
+    let cursor = index + 1;
+    while (cursor < parsedEvents.length) {
+      const next = parsedEvents[cursor];
+      if (!next || typeof next !== "object") break;
+      const nextRecord = next;
+      if (String(_nullishCoalesce(nextRecord.type, () => ( ""))) !== eventType || messageContentKey(nextRecord) !== eventKey) {
+        break;
+      }
+      runCount += 1;
+      cursor += 1;
+    }
+    if (runCount > 1) {
+      record._repeat_count = runCount;
+      record._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
+      output.push(JSON.stringify(record));
+      index = cursor;
+      continue;
+    }
+    output.push(_nullishCoalesce(rawLines[index], () => ( "")));
+    index += 1;
+  }
+  return Buffer.from(output.length > 0 ? `${output.join("\n")}
+` : "", "utf8");
+}
+function compactEventValue(value) {
+  if (typeof value === "string") {
+    if (value.length <= MAX_EVENT_STRING_CHARS) return value;
+    return `${value.slice(0, MAX_EVENT_STRING_CHARS - TRUNCATION_MARKER.length)}${TRUNCATION_MARKER}`;
+  }
+  if (Array.isArray(value)) {
+    const compacted = value.slice(0, MAX_EVENT_LIST_ITEMS).map(compactEventValue);
+    if (value.length > MAX_EVENT_LIST_ITEMS) {
+      compacted.push(
+        `${TRUNCATION_MARKER} ${value.length - MAX_EVENT_LIST_ITEMS} more item(s)`
+      );
+    }
+    return compacted;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    const compacted = {};
+    for (const [key, item] of entries.slice(0, MAX_EVENT_OBJECT_KEYS)) {
+      compacted[key] = compactEventValue(item);
+    }
+    if (entries.length > MAX_EVENT_OBJECT_KEYS) {
+      compacted._truncated_keys = entries.length - MAX_EVENT_OBJECT_KEYS;
+    }
+    return compacted;
+  }
+  return value;
+}
+function selectiveCompactToolResults(raw) {
+  const lines = [];
+  for (const line of normalizedJsonLines(raw)) {
+    const parsed = parseJsonLine(line);
+    if (!parsed || typeof parsed !== "object") {
+      lines.push(line);
+      continue;
+    }
+    const record = parsed;
+    if (record.type === "user") {
+      const message = record.message;
+      const content = message && typeof message === "object" ? message.content : null;
+      if (Array.isArray(content)) {
+        message.content = content.map(
+          (block) => block && typeof block === "object" && block.type === "tool_result" ? compactEventValue(block) : block
+        );
+      }
+    }
+    lines.push(JSON.stringify(record));
+  }
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function compactCodexEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const isCodex = parsedEvents.some(
+    (event) => event && typeof event === "object" && event.type === "session_meta"
+  );
+  if (!isCodex) return raw;
+  let lastTokenCountIndex = -1;
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") return;
+    const payload = event.payload;
+    if (payload && typeof payload === "object" && payload.type === "token_count") {
+      lastTokenCountIndex = index;
+    }
+  });
+  const lines = [];
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") {
+      lines.push(_nullishCoalesce(rawLines[index], () => ( "")));
+      return;
+    }
+    const record = event;
+    if (record.type === "world_state") return;
+    const payload = record.payload;
+    const payloadType = payload && typeof payload === "object" ? String(_nullishCoalesce(payload.type, () => ( ""))) : "";
+    if (payloadType === "token_count" && index !== lastTokenCountIndex) return;
+    if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output" || payloadType === "tool_search_output") {
+      const record_payload = payload;
+      record_payload.output = compactEventValue(record_payload.output);
+      lines.push(JSON.stringify(record));
+      return;
+    }
+    lines.push(_nullishCoalesce(rawLines[index], () => ( "")));
+  });
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function prepareSessionBuffer(raw) {
+  return selectiveCompactToolResults(
+    dedupConsecutiveEvents(compactCodexEvents(stripNoiseEvents(raw)))
+  );
+}
+function buildSessionUploadContent(raw) {
+  const prepared = prepareSessionBuffer(raw);
+  const encoded = _zlib.gzipSync.call(void 0, prepared).toString("base64");
+  if (encoded.length <= MAX_SESSION_UPLOAD_BYTES && prepared.length <= MAX_DIRECT_SESSION_DECODED_BYTES) {
+    return { encodedContent: encoded, needsChunking: false };
+  }
+  return { encodedContent: encoded, needsChunking: true };
+}
+async function uploadPayload(path, payload) {
+  const { http } = _chunk7D6QG5KFjs.getAuthedHttpClient.call(void 0, );
+  return await http.post(path, payload);
+}
+async function uploadChunkedSessions(sessions, options) {
+  const uploadId = _crypto.randomUUID.call(void 0, );
+  for (const session of sessions) {
+    const bytes = Buffer.from(session.encodedContent, "base64");
+    const chunks = [];
+    for (let offset = 0; offset < bytes.length; offset += CHUNK_SIZE_BYTES) {
+      chunks.push(bytes.subarray(offset, offset + CHUNK_SIZE_BYTES));
+    }
+    process.stderr.write(
+      `Uploading ${session.label} in ${chunks.length} chunk(s)...
+`
+    );
+    for (const [index, chunk] of chunks.entries()) {
+      await uploadPayload("/api/v2/cli/send-session/chunk", {
+        upload_id: uploadId,
+        session_id: session.sessionId,
+        index,
+        total_chunks: chunks.length,
+        data: chunk.toString("base64")
+      });
+    }
+  }
+  const response = await uploadPayload("/api/v2/cli/send-session/finalize", {
+    upload_id: uploadId,
+    session_ids: sessions.map((session) => session.sessionId),
+    labels: sessions.map((session) => session.label),
+    environments: sessions.map(() => detectShellContext()),
+    ...options.rating ? { rating: options.rating } : {}
+  });
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ...response,
+      ok: true,
+      uploaded: sessions.length,
+      render: {
+        sections: [
+          {
+            title: "sessions send",
+            lines: ["Session uploaded to #internal-reports (chunked)."]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+async function handleSessionsSend(options) {
+  const rating = parseSessionRating(options.rating);
+  if (options.file) {
+    const filePath = _path.resolve.call(void 0, options.file);
+    if (!_fs.existsSync.call(void 0, filePath)) {
+      throw new Error(`File not found: ${options.file}`);
+    }
+    const response2 = await uploadPayload("/api/v2/cli/send-session", {
+      file: _fs.readFileSync.call(void 0, filePath).toString("base64"),
+      filename: _path.basename.call(void 0, filePath),
+      ...rating ? { rating } : {}
+    });
+    _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+      {
+        ...response2,
+        ok: true,
+        filename: _path.basename.call(void 0, filePath),
+        render: {
+          sections: [
+            {
+              title: "sessions send",
+              lines: [
+                `File '${_path.basename.call(void 0, filePath)}' uploaded to #internal-reports.`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+    return;
+  }
+  const targets = resolveSessionTargets({
+    sessionIds: options.sessionId,
+    labels: options.label,
+    currentSession: options.currentSession,
+    agent: options.agent
+  });
+  const built = targets.map((target) => {
+    const upload = buildSessionUploadContent(_fs.readFileSync.call(void 0, target.filePath));
+    return { ...target, ...upload };
+  });
+  if (built.some((session) => session.needsChunking)) {
+    await uploadChunkedSessions(built, { json: options.json, rating });
+    return;
+  }
+  const response = built.length === 1 && !_optionalChain([options, 'access', _21 => _21.label, 'optionalAccess', _22 => _22.length]) ? await uploadPayload("/api/v2/cli/send-session", {
+    session_id: _optionalChain([built, 'access', _23 => _23[0], 'optionalAccess', _24 => _24.sessionId]),
+    content: _optionalChain([built, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.encodedContent]),
+    environment: detectShellContext(),
+    ...rating ? { rating } : {}
+  }) : await uploadPayload("/api/v2/cli/send-session", {
+    sessions: built.map((session) => ({
+      session_id: session.sessionId,
+      content: session.encodedContent,
+      label: session.label,
+      environment: detectShellContext()
+    })),
+    environment: detectShellContext(),
+    ...rating ? { rating } : {}
+  });
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ...response,
+      ok: true,
+      uploaded: built.length,
+      render: {
+        sections: [
+          {
+            title: "sessions send",
+            lines: ["Session uploaded to #internal-reports."]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function loadViewerAssets() {
+  const cliEntry = _optionalChain([process, 'access', _27 => _27.argv, 'access', _28 => _28[1], 'optionalAccess', _29 => _29.trim, 'call', _30 => _30()]) ? _fs.realpathSync.call(void 0, _path.resolve.call(void 0, process.argv[1])) : null;
+  const candidateRoots = [
+    ...cliEntry ? [
+      _path.join.call(void 0, _path.dirname.call(void 0, _path.dirname.call(void 0, cliEntry)), "viewer"),
+      _path.join.call(void 0, 
+        _path.dirname.call(void 0, _path.dirname.call(void 0, _path.dirname.call(void 0, cliEntry))),
+        "src",
+        "lib",
+        "cli",
+        "viewer"
+      )
+    ] : [],
+    _path.join.call(void 0, process.cwd(), "packages", "sdk", "assets", "viewer")
+  ];
+  for (const root of candidateRoots) {
+    try {
+      const cssPath = _path.join.call(void 0, root, "viewer.css");
+      const jsPath = _path.join.call(void 0, root, "viewer.js");
+      if (!_fs.existsSync.call(void 0, cssPath) || !_fs.existsSync.call(void 0, jsPath)) continue;
+      return {
+        css: _fs.readFileSync.call(void 0, cssPath, "utf8"),
+        js: _fs.readFileSync.call(void 0, jsPath, "utf8")
+      };
+    } catch (e6) {
+      continue;
+    }
+  }
+  throw new Error(
+    `Session viewer assets not found. Reinstall the CLI or build its viewer assets. Searched: ${candidateRoots.join(", ")}`
+  );
+}
+function parsePreparedEvents(buffer) {
+  return normalizedJsonLines(buffer).map((line) => {
+    const parsed = parseJsonLine(line);
+    return _nullishCoalesce(parsed, () => ( line));
+  });
+}
+function escapeJsonForHtmlScript(json) {
+  return json.replace(/</g, "\\u003c");
+}
+async function handleSessionsRender(options) {
+  const targets = resolveSessionTargets({
+    sessionIds: options.sessionId,
+    labels: options.label,
+    currentSession: options.currentSession,
+    agent: options.agent
+  });
+  let outputPath = options.output ? _path.resolve.call(void 0, options.output) : "";
+  if (!outputPath) {
+    const outputDir = _path.join.call(void 0, process.cwd(), "deepline", "data");
+    _fs.mkdirSync.call(void 0, outputDir, { recursive: true });
+    outputPath = _path.join.call(void 0, 
+      outputDir,
+      targets.length > 1 ? "session-viewer.html" : `session-${_optionalChain([targets, 'access', _31 => _31[0], 'optionalAccess', _32 => _32.sessionId])}.html`
+    );
+  } else {
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, outputPath), { recursive: true });
+  }
+  const sessions = targets.map((target) => ({
+    label: target.label,
+    events: parsePreparedEvents(
+      prepareSessionBuffer(_fs.readFileSync.call(void 0, target.filePath))
+    )
+  }));
+  const { css, js } = loadViewerAssets();
+  const refreshMeta = options.autoRefresh ? `<meta http-equiv="refresh" content="${Number.parseInt(options.autoRefresh, 10)}">` : "";
+  const rawJson = escapeJsonForHtmlScript(JSON.stringify(sessions));
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+${refreshMeta}
+<title>Session Viewer</title>
+<style>${css}</style>
+</head>
+<body>
+<div class="layout">
+  <div class="sidebar hidden" id="sidebar"></div>
+  <div class="run-sidebar hidden" id="run-sidebar"></div>
+  <div class="main" id="main-content"></div>
+</div>
+<script type="application/json" id="raw-sessions">${rawJson}</script>
+<script>${js}</script>
+</body>
+</html>`;
+  _fs.writeFileSync.call(void 0, outputPath, html, "utf8");
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    {
+      ok: true,
+      file: outputPath,
+      session_count: targets.length,
+      render: {
+        sections: [
+          {
+            title: "sessions render",
+            lines: [`Rendered session viewer: ${outputPath}`]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function collectOption(value, previous) {
+  previous.push(value);
+  return previous;
+}
+function registerSessionsCommands(program) {
+  const sessions = program.command("sessions").description("Upload and render local agent session transcripts.").addHelpText(
+    "after",
+    `
+Notes:
+  Session commands operate on local Claude and Codex JSONL files under
+  ~/.claude/projects and ~/.codex/sessions. send uploads a compacted transcript
+  or file to Deepline. render writes a local HTML viewer.
+
+Examples:
+  deepline sessions send --current-session --json
+  deepline sessions send --agent codex --current-session --json
+  deepline sessions send --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca
+  deepline sessions render --current-session --output session.html
+`
+  );
+  registerSessionSendRenderCommands(sessions, "sessions");
+}
+function registerSessionSendRenderCommands(parent, familyName) {
+  parent.command("send").description("Upload session transcript(s) or a local file to Deepline.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline ${familyName} send --current-session --json
+  deepline ${familyName} send --agent codex --current-session --json
+  deepline ${familyName} send --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca --label "pilot run"
+  deepline ${familyName} send --current-session --rating poor --json   # tag the session as one that went poorly
+  deepline ${familyName} send --file ./debug.log --json
+`
+  ).option(
+    "--session-id <uuid>",
+    "Claude or Codex session UUID. Repeat for multiple sessions.",
+    collectOption,
+    []
+  ).option(
+    "--label <label>",
+    "Label for the preceding session id",
+    collectOption,
+    []
+  ).option(
+    "--agent <auto|claude|codex>",
+    "Limit transcript discovery to one agent runtime",
+    "auto"
+  ).option("--current-session", "Use the newest local agent session JSONL").option("--file <path>", "Upload a raw local file instead of a session").option(
+    "--rating <good|poor|neutral>",
+    "Tag the upload by outcome, not tone, so Deepline can filter sessions: good = the user's goal was met without product problems; poor = the goal was missed, or a product failure, bug, or avoidable friction (including a substantial workaround) got in the way; neutral = partly met or unclear."
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleSessionsSend);
+  parent.command("render").description("Render local session transcript(s) to an HTML viewer.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline ${familyName} render --current-session
+  deepline ${familyName} render --agent codex --current-session
+  deepline ${familyName} render --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca --output session.html
+  deepline ${familyName} render --current-session --auto-refresh 5 --json
+`
+  ).option(
+    "--session-id <uuid>",
+    "Claude or Codex session UUID. Repeat for multiple sessions.",
+    collectOption,
+    []
+  ).option(
+    "--label <label>",
+    "Label for the preceding session id",
+    collectOption,
+    []
+  ).option(
+    "--agent <auto|claude|codex>",
+    "Limit transcript discovery to one agent runtime",
+    "auto"
+  ).option("--current-session", "Use the newest local agent session JSONL").option("--auto-refresh <seconds>", "Add a browser auto-refresh interval").option("-o, --output <path>", "Output HTML path").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleSessionsRender);
+}
+
+
+
+
+exports.registerSessionsCommands = registerSessionsCommands; exports.registerSessionSendRenderCommands = registerSessionSendRenderCommands;