agentel 0.2.8 → 0.3.0

package/src/collector.js

@@ -29,6 +29,11 @@ function startCollector(env = process.env, options = {}) {
         writeJsonResponse(res, { partialSuccess: {}, agentlog: { stored: record.file } });
       })
       .catch((error) => {
+        if (error && error.code === "PAYLOAD_TOO_LARGE") {
+          writeJsonResponse(res, { error: error.message }, 413);
+          res.once("finish", () => req.destroy());
+          return;
+        }
         writeJsonResponse(res, { error: error.message }, 500);
       });
   });
@@ -80,12 +85,44 @@ function writeTelemetryPayload(req, body, env = process.env) {
   return { file: payloadFile };
 }
 
-function collectBody(req) {
+// OTLP batches from local agents are typically well under a megabyte; the cap
+// only exists so a misconfigured or hostile client cannot balloon collector
+// memory with one unbounded request body.
+const COLLECTOR_MAX_BODY_BYTES = 32 * 1024 * 1024;
+
+function collectBody(req, maxBytes = COLLECTOR_MAX_BODY_BYTES) {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve(Buffer.concat(chunks)));
-    req.on("error", reject);
+    let received = 0;
+    const cleanup = () => {
+      req.removeListener("data", onData);
+      req.removeListener("end", onEnd);
+      req.removeListener("error", onError);
+    };
+    const onData = (chunk) => {
+      received += chunk.length;
+      if (received > maxBytes) {
+        // Stop buffering but leave the socket alive so the 413 response can
+        // still be written; the handler destroys the connection afterwards.
+        cleanup();
+        const error = new Error(`request body exceeds ${maxBytes} bytes`);
+        error.code = "PAYLOAD_TOO_LARGE";
+        reject(error);
+        return;
+      }
+      chunks.push(chunk);
+    };
+    const onEnd = () => {
+      cleanup();
+      resolve(Buffer.concat(chunks));
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    req.on("data", onData);
+    req.on("end", onEnd);
+    req.on("error", onError);
   });
 }
 
@@ -108,6 +145,7 @@ function looksLikeJson(body) {
 }
 
 module.exports = {
+  collectBody,
   startCollector,
   writeTelemetryPayload
 };

package/src/config.js

@@ -4,7 +4,7 @@ const crypto = require("crypto");
 const os = require("os");
 const path = require("path");
 const { ensureBaseDirs, paths, readJson, writeJson } = require("./paths");
-const { IMPORT_SOURCE_ORDER, enabledImportSources } = require("./sources");
+const { IMPORT_SOURCE_ORDER, canonicalImportSource, enabledImportSources } = require("./sources");
 
 function defaultConfig(env = process.env) {
   const p = paths(env);
@@ -53,6 +53,14 @@ function defaultConfig(env = process.env) {
       webChatsDefaultScope: "local",
       revealCache: true
     },
+    artifacts: {
+      // Copy images/PDFs referenced by tool calls (screenshots in /tmp etc.)
+      // into the archive before they are deleted. Off by default because it
+      // grows the archive beyond conversation text.
+      enabled: false,
+      maxFileBytes: 25 * 1024 * 1024,
+      maxSessionBytes: 100 * 1024 * 1024
+    },
     createdAt: new Date().toISOString()
   };
 }
@@ -72,7 +80,8 @@ function loadConfig(env = process.env) {
     sync: { ...defaults.sync, ...(cfg.sync || {}) },
     index: { ...defaults.index, ...(cfg.index || {}) },
     imports: { ...defaults.imports, ...(cfg.imports || {}) },
-    privacy: { ...defaults.privacy, ...(cfg.privacy || {}) }
+    privacy: { ...defaults.privacy, ...(cfg.privacy || {}) },
+    artifacts: { ...defaults.artifacts, ...(cfg.artifacts || {}) }
   };
   merged.imports.sources = enabledImportSources(merged.imports.sources);
   return merged;
@@ -271,9 +280,10 @@ function normalizeImportSources(value) {
       .split(/[,\s]+/)
       .map((item) => item.trim())
       .filter(Boolean);
-  const selected = new Set(raw);
+  const canonicalRaw = raw.map(canonicalImportSource);
+  const selected = new Set(canonicalRaw);
   const ordered = IMPORT_SOURCE_ORDER.filter((source) => selected.has(source));
-  const extras = raw.filter((source) => !ordered.includes(source));
+  const extras = canonicalRaw.filter((source) => !ordered.includes(source));
   return enabledImportSources([...ordered, ...extras]);
 }
 
@@ -288,6 +298,7 @@ module.exports = {
   effectiveImportSources,
   getConfigKey,
   initConfig,
+  defaultDeviceName,
   loadConfig,
   normalizeRemoteEndpointInput,
   saveConfig,

package/src/diffs.js

@@ -0,0 +1,156 @@
+"use strict";
+
+const MAX_STRUCTURED_PATCH_HUNKS = 2000;
+const MAX_STRUCTURED_PATCH_LINES = 50000;
+const MAX_STRUCTURED_DIFF_CHARS = 2 * 1024 * 1024;
+
+function normalizeStructuredPatch(value) {
+  if (!Array.isArray(value) || !value.length) return [];
+  const hunks = [];
+  let lineCount = 0;
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object") continue;
+    const lines = Array.isArray(raw.lines)
+      ? raw.lines.map((line) => String(line == null ? "" : line)).filter((line) => /^[ +\\-]/.test(line))
+      : [];
+    if (!lines.length) continue;
+    lineCount += lines.length;
+    if (lineCount > MAX_STRUCTURED_PATCH_LINES) break;
+    const hunk = {
+      oldStart: positiveInt(raw.oldStart ?? raw.old_start) || 1,
+      newStart: positiveInt(raw.newStart ?? raw.new_start) || 1,
+      lines
+    };
+    const file = firstString(raw.file, raw.path, raw.filePath, raw.filename);
+    if (file) hunk.file = file;
+    if (Number.isFinite(Number(raw.oldLines ?? raw.old_lines))) hunk.oldLines = Math.max(0, Math.floor(Number(raw.oldLines ?? raw.old_lines)));
+    if (Number.isFinite(Number(raw.newLines ?? raw.new_lines))) hunk.newLines = Math.max(0, Math.floor(Number(raw.newLines ?? raw.new_lines)));
+    hunks.push(hunk);
+    if (hunks.length >= MAX_STRUCTURED_PATCH_HUNKS) break;
+  }
+  return hunks;
+}
+
+function structuredPatchFromToolArguments(args) {
+  if (!args) return [];
+  if (typeof args === "string") return structuredPatchFromDiffText(args);
+  if (Array.isArray(args)) {
+    const hunks = [];
+    for (const item of args) {
+      hunks.push(...structuredPatchFromToolArguments(item));
+      if (hunks.length >= MAX_STRUCTURED_PATCH_HUNKS) break;
+    }
+    return hunks.slice(0, MAX_STRUCTURED_PATCH_HUNKS);
+  }
+  if (typeof args !== "object") return [];
+  const existing = normalizeStructuredPatch(args.structuredPatch || args.structured_patch);
+  if (existing.length) return existing;
+  const hunks = [];
+  for (const key of ["diff", "patch", "input", "text", "content"]) {
+    if (typeof args[key] === "string") hunks.push(...structuredPatchFromDiffText(args[key], { defaultFile: firstString(args.path, args.file, args.file_path, args.filePath) }));
+    if (hunks.length >= MAX_STRUCTURED_PATCH_HUNKS) break;
+  }
+  if (!hunks.length) {
+    for (const key of ["changes", "edits", "hunks", "diffs", "fileDiffs", "file_diffs"]) {
+      if (args[key] != null) hunks.push(...structuredPatchFromToolArguments(args[key]));
+      if (hunks.length >= MAX_STRUCTURED_PATCH_HUNKS) break;
+    }
+  }
+  return hunks.slice(0, MAX_STRUCTURED_PATCH_HUNKS);
+}
+
+function structuredPatchFromDiffText(diff, options = {}) {
+  const text = String(diff || "");
+  if (!text.trim() || text.length > MAX_STRUCTURED_DIFF_CHARS) return [];
+  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const hunkRe = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/;
+  const hunks = [];
+  let current = null;
+  let currentFile = firstString(options.defaultFile);
+  let lineCount = 0;
+
+  const finish = () => {
+    if (!current || !current.lines.length) {
+      current = null;
+      return;
+    }
+    hunks.push(current);
+    current = null;
+  };
+
+  for (const rawLine of lines) {
+    const line = String(rawLine);
+    const hunk = hunkRe.exec(line);
+    if (hunk) {
+      finish();
+      current = {
+        oldStart: Number(hunk[1]),
+        newStart: Number(hunk[3]),
+        oldLines: hunk[2] == null ? 1 : Number(hunk[2]),
+        newLines: hunk[4] == null ? 1 : Number(hunk[4]),
+        lines: []
+      };
+      if (currentFile) current.file = currentFile;
+      continue;
+    }
+
+    const nextFile = diffMetadataFile(line);
+    if (nextFile) {
+      finish();
+      currentFile = nextFile;
+      continue;
+    }
+    if (line.startsWith("\")) continue;
+
+    if (!current) continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) current.lines.push(line);
+    else if (line.startsWith("-") && !line.startsWith("---")) current.lines.push(line);
+    else if (line.startsWith(" ")) current.lines.push(line);
+    else current.lines.push(" " + line);
+    lineCount += 1;
+    if (lineCount > MAX_STRUCTURED_PATCH_LINES || hunks.length >= MAX_STRUCTURED_PATCH_HUNKS) break;
+  }
+  finish();
+  return normalizeStructuredPatch(hunks);
+}
+
+function diffMetadataFile(line) {
+  const text = String(line || "");
+  const git = text.match(/^diff --git\s+a\/(.+?)\s+b\/(.+)$/);
+  if (git) return stripDiffFilePrefix(git[2]);
+  const update = text.match(/^\*\*\*\s+(?:Update|Add|Delete)\s+File:\s+(.+)$/);
+  if (update) return update[1].trim();
+  const plus = text.match(/^\+\+\+\s+(.+)$/);
+  if (plus) {
+    const file = stripDiffFilePrefix(plus[1]);
+    return file === "/dev/null" ? "" : file;
+  }
+  return "";
+}
+
+function stripDiffFilePrefix(value) {
+  let text = String(value || "").trim();
+  if (!text) return "";
+  text = text.split(/\t/)[0].trim();
+  if ((text.startsWith("a/") || text.startsWith("b/")) && text.length > 2) return text.slice(2);
+  return text;
+}
+
+function positiveInt(value) {
+  const number = Math.floor(Number(value));
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+module.exports = {
+  normalizeStructuredPatch,
+  structuredPatchFromDiffText,
+  structuredPatchFromToolArguments
+};

package/src/doctor.js

@@ -9,6 +9,7 @@ const { discoverCliHistory } = require("./importers");
 const { canonicalSourceType, parserVersionForSource } = require("./parser-versions");
 const { paths, readJson } = require("./paths");
 const { hasRemoteTarget } = require("./sync");
+const { CLAUDE_CODE_REPAIR_COMMAND, CLAUDE_CODE_REPAIR_PREVIEW_COMMAND, summarizeUnavailableSourceSessions, unavailableSourceSessions } = require("./unavailable-sources");
 
 function runDoctor(env = process.env, options = {}) {
   reportProgress(options, "Doctor", "checking configuration", 1, 5);
@@ -30,6 +31,14 @@ function runDoctor(env = process.env, options = {}) {
   reportProgress(options, "Doctor", "checking parser versions", 4, 5);
   const parsers = parserVersionHealth(env);
   add(checks, "parser versions", parsers.outdated.length === 0, parserVersionSummary(parsers), parserVersionRemediation(parsers));
+  const unavailableSources = summarizeUnavailableSourceSessions(unavailableSourceSessions(env), { env });
+  add(
+    checks,
+    "unavailable sources",
+    unavailableSources.totalSessions === 0,
+    unavailableSourceSummary(unavailableSources),
+    unavailableSourceRemediation(unavailableSources)
+  );
 
   reportProgress(options, "Doctor", "discovering local sources", 5, 5);
   const discovery = discoverCliHistory(env, { onProgress: options.onProgress });
@@ -49,6 +58,7 @@ function runDoctor(env = process.env, options = {}) {
       trackedFiles: Object.keys(importState.files || {}).length
     },
     coverage,
+    unavailableSources,
     parsers,
     recommendations
   };
@@ -62,11 +72,18 @@ function sourceCoverage(discovery, cfg) {
     coverageRow("codex-sdk", "Codex SDK jobs", discovery.codexSdk, configured),
     coverageRow("claude", "Claude Code CLI", discovery.claude, configured),
     coverageRow("claude-code-desktop", "Claude Code Desktop", discovery.claudeCodeDesktop, configured),
-    coverageRow("claude-workspace", "Claude Workspace", discovery.claudeWorkspace, configured),
+    coverageRow("claude-cowork", "Claude Cowork", discovery.claudeWorkspace, configured),
     coverageRow("claude-sdk", "Claude SDK jobs", discovery.claudeSdk, configured),
     coverageRow("gemini-cli", "Gemini CLI", discovery.geminiCli, configured),
-    coverageRow("antigravity", "Antigravity", discovery.antigravity, configured),
+    coverageRow("antigravity-cli", "Antigravity CLI", discovery.antigravityCli, configured),
+    coverageRow("antigravity", "Antigravity 2.0", discovery.antigravity, configured),
+    coverageRow("antigravity-ide", "Antigravity IDE", discovery.antigravityIde, configured),
     coverageRow("devin-cli", "Devin CLI", discovery.devinCli, configured),
+    coverageRow("devin-desktop", "Devin Desktop", discovery.devinDesktop, configured),
+    coverageRow("copilot-cli", "GitHub Copilot CLI", discovery.copilotCli, configured),
+    coverageRow("factory", "Factory Droid", discovery.factory, configured),
+    coverageRow("grok-build", "Grok Build", discovery.grokBuild, configured),
+    coverageRow("pi", "pi", discovery.pi, configured),
     coverageRow("cursor", "Cursor", discovery.cursor, configured),
     coverageRow("cline", "Cline", discovery.cline, configured),
     coverageRow("opencode-cli", "OpenCode CLI", discovery.opencodeCli, configured),
@@ -86,7 +103,8 @@ function coverageRow(source, label, result = {}, configured) {
     label,
     configured: configured.has(source)
       || (source === "claude-code-desktop" && configured.has("claude-desktop"))
-      || (source === "claude-workspace" && configured.has("claude-desktop"))
+      || (source === "claude-cowork" && configured.has("claude-desktop"))
+      || (source === "claude-cowork" && configured.has("claude-workspace"))
       || (source.startsWith("opencode-") && configured.has("opencode")),
     sessions: result?.sessions || 0,
     oldest: result?.oldest || "",
@@ -145,6 +163,20 @@ function parserVersionRemediation(parsers) {
   return "Run the affected import commands listed in Recommendations.";
 }
 
+function unavailableSourceSummary(summary) {
+  if (!summary?.totalSessions) return "no preserved archives depend on missing source files";
+  const missing = summary.totalMissingSources ? `; ${summary.totalMissingSources} missing source path${summary.totalMissingSources === 1 ? "" : "s"}` : "";
+  return `${summary.totalSessions} preserved unavailable source session${summary.totalSessions === 1 ? "" : "s"}${missing}`;
+}
+
+function unavailableSourceRemediation(summary) {
+  if (!summary?.totalSessions) return "";
+  if (summary.claudeCodeRepair?.restoreCount) {
+    return `Run \`${CLAUDE_CODE_REPAIR_PREVIEW_COMMAND}\`, then \`${CLAUDE_CODE_REPAIR_COMMAND} --yes\`, then \`agentlog update --yes --since all --sources claude\`.`;
+  }
+  return "Restore the missing source application history from backup, then run `agentlog update --yes --since all`; otherwise keep the preserved archive as historical data.";
+}
+
 function buildRecommendations(checks, coverage, parsers) {
   const recommendations = [];
   for (const check of checks) {
@@ -199,12 +231,17 @@ function parserUpdateCommand(sourceType) {
     "cli-history": "claude",
     "claude-sdk-history": "claude-sdk",
     "claude-code-desktop-metadata": "claude-code-desktop",
-    "claude-workspace-desktop": "claude-workspace",
+    "claude-workspace-desktop": "claude-cowork",
     "cursor-workspace-sqlite": "cursor",
     "cursor-global-sqlite": "cursor",
     "cursor-raw-sqlite-salvage": "cursor",
     "cursor-agent-transcripts": "cursor",
     "devin-cli-history": "devin-cli",
+    "devin-desktop-acp-events": "devin-desktop",
+    "copilot-cli-history": "copilot-cli",
+    "factory-droid-history": "factory",
+    "grok-build-history": "grok-build",
+    "pi-cli-history": "pi",
     "gemini-cli-history": "gemini-cli",
     "cline-task-history": "cline",
     "opencode-cli-history": "opencode-cli",
@@ -215,7 +252,13 @@ function parserUpdateCommand(sourceType) {
     "opencode-history": "opencode",
     "opencode-sqlite-history": "opencode",
     "aider-chat-history": "aider",
-    "antigravity-history": "antigravity"
+    "antigravity-history": "antigravity",
+    "antigravity-transcript-log": "antigravity",
+    "antigravity-brain": "antigravity",
+    "antigravity-cli-transcript-log": "antigravity-cli",
+    "antigravity-cli-brain": "antigravity-cli",
+    "antigravity-ide-transcript-log": "antigravity-ide",
+    "antigravity-ide-brain": "antigravity-ide"
   }[canonicalSourceType(sourceType)];
   return source ? `agentlog import --source ${source} --since all` : "";
 }

package/src/importers/claude.js

@@ -50,7 +50,20 @@ function assistantMessages(event, message, provider, context, timestamp, content
     toolCalls: toolCalls.length ? toolCalls : undefined
   };
   const result = [];
-  if (thinking) result.push(supplementaryMessage(provider, "Claude thinking", thinking, timestamp, "thinking", metadata.model));
+  const hasVisibleAssistantWork = Boolean(text || toolCalls.length);
+  if (thinking) {
+    result.push(
+      supplementaryMessage(
+        provider,
+        "Claude thinking",
+        thinking,
+        timestamp,
+        "thinking",
+        metadata.model,
+        hasVisibleAssistantWork ? {} : compactMetadata({ ...metadata, toolCalls: undefined })
+      )
+    );
+  }
   if (text || toolCalls.length) result.push({ role: "assistant", content: text, timestamp, metadata });
   return result;
 }
@@ -102,6 +115,7 @@ function claudeEventMetadata(event) {
     parentToolUseID: firstString(event.parentToolUseID, event.parent_tool_use_id),
     toolUseID: firstString(event.toolUseID, event.tool_use_id),
     isSidechain: typeof event.isSidechain === "boolean" ? event.isSidechain : undefined,
+    isMeta: typeof event.isMeta === "boolean" ? event.isMeta : (typeof event.payload?.isMeta === "boolean" ? event.payload.isMeta : undefined),
     isVisibleInTranscriptOnly: typeof event.isVisibleInTranscriptOnly === "boolean" ? event.isVisibleInTranscriptOnly : undefined,
     isCompactSummary: typeof event.isCompactSummary === "boolean" ? event.isCompactSummary : undefined,
     userType: firstString(event.userType, event.user_type),
@@ -133,13 +147,14 @@ function claudeApiErrorMetadata(event) {
   });
 }
 
-function supplementaryMessage(provider, title, content, timestamp, summaryKind, model = "") {
+function supplementaryMessage(provider, title, content, timestamp, summaryKind, model = "", metadata = {}) {
   return {
     role: "assistant",
     content: `### ${title}\n\n${String(content || "").trim()}`,
     timestamp,
     metadata: {
       provider,
+      ...compactMetadata(metadata),
       eventType: `claude-${summaryKind}`,
       supplementary: true,
       summaryKind,
@@ -236,6 +251,15 @@ function remoteFileHistorySnapshotMessage(event, provider, timestamp) {
   const snapshotTimestamp = timestamp || eventTimestamp(snapshot);
   const backups = snapshot.trackedFileBackups && typeof snapshot.trackedFileBackups === "object" ? snapshot.trackedFileBackups : {};
   const paths = Object.keys(backups).sort();
+  const backupEntries = paths.map((filePath) => {
+    const backup = backups[filePath] && typeof backups[filePath] === "object" ? backups[filePath] : {};
+    return compactMetadata({
+      path: filePath,
+      backupFileName: firstString(backup.backupFileName, backup.backup_file_name) || undefined,
+      version: numberValue(backup.version) ?? undefined,
+      backupTime: firstString(backup.backupTime, backup.backup_time) || undefined
+    });
+  });
   const action = event.isSnapshotUpdate ? "updated" : "recorded";
   const target = paths.length ? `: ${namesPreview(paths)}` : "";
   return remoteContextMessage(provider, event, snapshotTimestamp, "remote_control_file_history", `Remote Control file history snapshot ${action}${target}`, {
@@ -244,7 +268,8 @@ function remoteFileHistorySnapshotMessage(event, provider, timestamp) {
       isSnapshotUpdate: typeof event.isSnapshotUpdate === "boolean" ? event.isSnapshotUpdate : undefined,
       timestamp: snapshotTimestamp || undefined,
       backupFileCount: paths.length || undefined,
-      paths: paths.length ? paths : undefined
+      paths: paths.length ? paths : undefined,
+      backups: backupEntries.length ? backupEntries : undefined
     })
   });
 }
@@ -454,10 +479,32 @@ function normalizeToolResult(part, provider, event, context = {}) {
     collapsed: output.split("\n").length > 18,
     status: part.is_error ? "error" : "completed",
     sourceToolUseID: firstString(event?.sourceToolUseID, event?.source_tool_use_id) || undefined,
-    structuredContent: event?.mcpMeta?.structuredContent && typeof event.mcpMeta.structuredContent === "object" ? event.mcpMeta.structuredContent : undefined
+    structuredContent: event?.mcpMeta?.structuredContent && typeof event.mcpMeta.structuredContent === "object" ? event.mcpMeta.structuredContent : undefined,
+    structuredPatch: sanitizeStructuredPatch(event?.toolUseResult?.structuredPatch)
   });
 }
 
+// Claude Code's Edit/Write results include jsdiff-style hunks with absolute
+// file line numbers; keep them so viewers can render numbered diffs.
+function sanitizeStructuredPatch(hunks) {
+  if (!Array.isArray(hunks) || !hunks.length) return undefined;
+  const sanitized = [];
+  for (const hunk of hunks) {
+    if (!hunk || typeof hunk !== "object" || !Array.isArray(hunk.lines)) continue;
+    const oldStart = Number(hunk.oldStart);
+    const newStart = Number(hunk.newStart);
+    if (!Number.isFinite(oldStart) || !Number.isFinite(newStart)) continue;
+    sanitized.push({
+      oldStart,
+      oldLines: Number(hunk.oldLines) || 0,
+      newStart,
+      newLines: Number(hunk.newLines) || 0,
+      lines: hunk.lines.map((line) => String(line ?? ""))
+    });
+  }
+  return sanitized.length ? sanitized : undefined;
+}
+
 function extractToolResultOutput(part, eventToolUseResult) {
   const direct = extractText(part.content ?? part.output ?? part.result ?? part.text);
   const extra = extractText(eventToolUseResult?.stdout ?? eventToolUseResult?.stderr ?? eventToolUseResult?.output ?? eventToolUseResult?.content);