agentel 0.2.8 → 0.3.1

package/src/source-watch.js

@@ -0,0 +1,293 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+// Filesystem events are triggers, not data: an event only marks its source
+// dirty, so watcher memory stays O(sources) no matter how fast agents write.
+// The first event for a source opens a fixed-delay coalesce window and later
+// events fold into it, so a continuously writing session cannot starve its
+// own import (a trailing-edge debounce would).
+const DEFAULT_COALESCE_MS = 3 * 1000;
+// SQLite-backed stores churn their WAL while the app is open, including for
+// state unrelated to conversations, so they get a wider window.
+const SQLITE_COALESCE_MS = 20 * 1000;
+// Roots that don't exist yet (tool not installed) or whose watcher died are
+// re-checked on this cadence.
+const WATCH_RETRY_MS = 5 * 60 * 1000;
+
+function homeDir(env = process.env) {
+  return env.HOME || env.USERPROFILE || os.homedir();
+}
+
+function geminiHome(env, home) {
+  return env.AGENTLOG_GEMINI_HOME_DIR || env.GEMINI_HOME || path.join(home, ".gemini");
+}
+
+function claudeAppSupportRoot(env, home) {
+  return env.CLAUDE_APP_SUPPORT || path.join(home, "Library", "Application Support", "Claude");
+}
+
+function root(dir, options = {}) {
+  return {
+    dir: path.resolve(dir),
+    recursive: options.recursive !== false,
+    filter: options.filter || null,
+    coalesceMs: options.coalesceMs || DEFAULT_COALESCE_MS
+  };
+}
+
+function sqliteStateDbFilter(name) {
+  return path.basename(name).startsWith("state.vscdb");
+}
+
+// Watch roots per import source, mirroring the importer path resolution in
+// src/importers.js (including its env overrides) without loading that module:
+// the supervisor process should stay small, and a root that drifts slightly
+// from what the importer reads only costs a no-op import or falls back to the
+// heartbeat poll. Sources with no entry (aider scans whole project trees;
+// watching those would fire on every git operation in every repo) stay on the
+// polling cadence.
+function watchRootsForSource(source, env = process.env) {
+  const home = homeDir(env);
+  switch (source) {
+    case "codex-cli":
+    case "codex-desktop":
+    case "codex-sdk": {
+      const codexHome = env.CODEX_HOME || path.join(home, ".codex");
+      return [root(path.join(codexHome, "sessions")), root(path.join(codexHome, "archived_sessions"))];
+    }
+    case "claude":
+      return [root(path.join(home, ".claude", "projects"))];
+    case "claude-code-desktop":
+      return [root(path.join(claudeAppSupportRoot(env, home), "claude-code-sessions"))];
+    case "claude-cowork":
+      return [root(path.join(claudeAppSupportRoot(env, home), "local-agent-mode-sessions"))];
+    case "gemini-cli":
+      // Antigravity homes live inside the Gemini home; exclude them so an
+      // Antigravity session doesn't ping the Gemini importer.
+      return [root(geminiHome(env, home), { filter: (name) => !name.startsWith("antigravity") })];
+    case "antigravity":
+      return [root(env.AGENTLOG_ANTIGRAVITY_HOME_DIR || path.join(geminiHome(env, home), "antigravity"))];
+    case "antigravity-cli":
+      return [root(env.AGENTLOG_ANTIGRAVITY_CLI_HOME_DIR || path.join(geminiHome(env, home), "antigravity-cli"))];
+    case "antigravity-ide":
+      return [root(env.AGENTLOG_ANTIGRAVITY_IDE_HOME_DIR || path.join(geminiHome(env, home), "antigravity-ide"))];
+    case "devin-cli": {
+      const db = env.AGENTLOG_DEVIN_SESSIONS_DB || path.join(home, ".local", "share", "devin", "cli", "sessions.db");
+      return [root(path.dirname(db), { recursive: false, coalesceMs: SQLITE_COALESCE_MS })];
+    }
+    case "devin-desktop": {
+      const appRoots = [
+        path.join(home, "Library", "Application Support", "Devin"),
+        path.join(home, ".config", "Devin")
+      ];
+      return appRoots.flatMap((appRoot) => [
+        root(path.join(appRoot, "User", "acp-events")),
+        root(path.join(appRoot, "User", "globalStorage"), {
+          recursive: false,
+          filter: sqliteStateDbFilter,
+          coalesceMs: SQLITE_COALESCE_MS
+        })
+      ]);
+    }
+    case "windsurf": {
+      const windsurfHome =
+        env.AGENTLOG_WINDSURF_HOME_DIR ||
+        env.AGENTLOG_CODEIUM_WINDSURF_HOME_DIR ||
+        path.join(env.AGENTLOG_CODEIUM_HOME_DIR || path.join(home, ".codeium"), "windsurf");
+      return [root(windsurfHome)];
+    }
+    case "copilot-cli": {
+      if (env.AGENTLOG_COPILOT_SESSION_STATE_DIR) return [root(env.AGENTLOG_COPILOT_SESSION_STATE_DIR)];
+      const copilotHome = env.AGENTLOG_COPILOT_HOME || env.COPILOT_HOME || path.join(home, ".copilot");
+      return [root(path.join(copilotHome, "session-state"))];
+    }
+    case "factory": {
+      if (env.AGENTLOG_FACTORY_SESSIONS_DIR) return [root(env.AGENTLOG_FACTORY_SESSIONS_DIR)];
+      return [root(path.join(env.FACTORY_HOME_OVERRIDE || home, ".factory", "sessions"))];
+    }
+    case "grok-build": {
+      if (env.AGENTLOG_GROK_SESSIONS_DIR) return [root(env.AGENTLOG_GROK_SESSIONS_DIR)];
+      const grokHome = env.AGENTLOG_GROK_HOME || env.GROK_HOME || path.join(home, ".grok");
+      return [root(path.join(grokHome, "sessions"))];
+    }
+    case "pi": {
+      const explicit = env.AGENTLOG_PI_SESSION_DIR || env.PI_CODING_AGENT_SESSION_DIR;
+      if (explicit) return [root(explicit)];
+      const agentDir = env.PI_CODING_AGENT_DIR || path.join(home, ".pi", "agent");
+      return [root(path.join(agentDir, "sessions"))];
+    }
+    case "cursor": {
+      const globalStorage =
+        env.AGENTLOG_CURSOR_GLOBAL_STORAGE_DIR ||
+        path.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
+      const workspaceStorage =
+        env.AGENTLOG_CURSOR_WORKSPACE_STORAGE_DIR ||
+        path.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+      return [
+        root(globalStorage, { recursive: false, filter: sqliteStateDbFilter, coalesceMs: SQLITE_COALESCE_MS }),
+        root(workspaceStorage, { filter: sqliteStateDbFilter, coalesceMs: SQLITE_COALESCE_MS })
+      ];
+    }
+    case "cline": {
+      // VS Code variants only; JetBrains installs rely on the heartbeat poll.
+      const appData = env.APPDATA || env.AppData;
+      return [
+        path.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev"),
+        path.join(home, "Library", "Application Support", "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev"),
+        path.join(home, ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev"),
+        appData ? path.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev") : ""
+      ]
+        .filter(Boolean)
+        .map((dir) => root(dir));
+    }
+    case "opencode-cli":
+    case "opencode-desktop":
+    case "opencode-web": {
+      const configured = env.AGENTLOG_OPENCODE_DATA_DIR || env.OPENCODE_DATA_DIR;
+      if (configured) return [root(configured)];
+      const cliRoot = path.join(home, ".local", "share", "opencode");
+      if (source === "opencode-cli") return [root(cliRoot)];
+      const desktopRoots = [
+        path.join(home, "Library", "Application Support", "ai.opencode.desktop"),
+        path.join(home, "Library", "Application Support", "opencode"),
+        path.join(home, ".local", "share", "ai.opencode.app"),
+        path.join(home, "Library", "Application Support", "ai.opencode.app")
+      ];
+      const roots = source === "opencode-web" ? [cliRoot, ...desktopRoots] : desktopRoots;
+      return roots.map((dir) => root(dir));
+    }
+    default:
+      return [];
+  }
+}
+
+// Watches the source roots and reports dirty sources after their coalesce
+// window. Roots are deduped so sources sharing a directory (codex-cli and
+// codex-desktop both read ~/.codex/sessions) share one OS watch. Returns a
+// handle: isWatched(source) tells the supervisor whether the source can rely
+// on events (true while roots are merely missing — nothing to import then
+// either — false once a watch attempt errors), refresh() retries missing or
+// dead watches, close() tears everything down.
+function startSourceWatchers(sources, env, onSourceDirty, options = {}) {
+  const coalesceOverrideMs = options.coalesceMs || 0;
+  const retryMs = options.retryMs || WATCH_RETRY_MS;
+  const onLog = typeof options.onLog === "function" ? options.onLog : () => {};
+
+  const byDir = new Map();
+  const sourcesWithRoots = new Set();
+  const failedSources = new Set();
+  for (const source of sources || []) {
+    for (const entry of watchRootsForSource(source, env)) {
+      sourcesWithRoots.add(source);
+      const existing = byDir.get(entry.dir);
+      if (existing) {
+        existing.recursive = existing.recursive || entry.recursive;
+        existing.subscribers.push({ source, filter: entry.filter, coalesceMs: entry.coalesceMs });
+      } else {
+        byDir.set(entry.dir, {
+          dir: entry.dir,
+          recursive: entry.recursive,
+          watcher: null,
+          subscribers: [{ source, filter: entry.filter, coalesceMs: entry.coalesceMs }]
+        });
+      }
+    }
+  }
+
+  const timers = new Map();
+  let closed = false;
+
+  function markDirty(source, coalesceMs) {
+    if (closed || timers.has(source)) return;
+    const timer = setTimeout(() => {
+      timers.delete(source);
+      if (!closed) onSourceDirty(source);
+    }, coalesceOverrideMs || coalesceMs);
+    if (typeof timer.unref === "function") timer.unref();
+    timers.set(source, timer);
+  }
+
+  function handleEvent(entry, filename) {
+    const name = typeof filename === "string" ? filename : "";
+    for (const subscriber of entry.subscribers) {
+      // A null filename means the platform couldn't say what changed; treat
+      // it as a match rather than risk missing activity.
+      if (subscriber.filter && name && !subscriber.filter(name)) continue;
+      markDirty(subscriber.source, subscriber.coalesceMs);
+    }
+  }
+
+  function markEntryFailed(entry, error) {
+    for (const subscriber of entry.subscribers) failedSources.add(subscriber.source);
+    onLog(`watch failed for ${entry.dir}: ${error.message}`);
+  }
+
+  function attach(entry) {
+    if (entry.watcher || closed) return;
+    let stat = null;
+    try {
+      stat = fs.statSync(entry.dir);
+    } catch {
+      return; // Missing root: nothing to import from it yet; refresh retries.
+    }
+    if (!stat.isDirectory()) return;
+    try {
+      const watcher = fs.watch(entry.dir, { recursive: entry.recursive, persistent: false });
+      watcher.on("change", (eventType, filename) => handleEvent(entry, filename));
+      watcher.on("error", () => {
+        // Watches die when the root is replaced; refresh re-attaches.
+        try {
+          watcher.close();
+        } catch {}
+        entry.watcher = null;
+      });
+      entry.watcher = watcher;
+    } catch (error) {
+      markEntryFailed(entry, error);
+    }
+  }
+
+  function refresh() {
+    if (closed) return;
+    for (const entry of byDir.values()) attach(entry);
+  }
+
+  refresh();
+  const retryTimer = setInterval(refresh, retryMs);
+  if (typeof retryTimer.unref === "function") retryTimer.unref();
+
+  return {
+    isWatched(source) {
+      return sourcesWithRoots.has(source) && !failedSources.has(source);
+    },
+    activeWatchCount() {
+      let count = 0;
+      for (const entry of byDir.values()) if (entry.watcher) count += 1;
+      return count;
+    },
+    refresh,
+    close() {
+      closed = true;
+      clearInterval(retryTimer);
+      for (const timer of timers.values()) clearTimeout(timer);
+      timers.clear();
+      for (const entry of byDir.values()) {
+        if (!entry.watcher) continue;
+        try {
+          entry.watcher.close();
+        } catch {}
+        entry.watcher = null;
+      }
+    }
+  };
+}
+
+module.exports = {
+  DEFAULT_COALESCE_MS,
+  SQLITE_COALESCE_MS,
+  startSourceWatchers,
+  watchRootsForSource
+};

package/src/sources.js

@@ -15,7 +15,7 @@ const SOURCE_GROUPS = [
     sources: [
       { source: "claude", provider: "claude_code", label: "Claude Code CLI" },
       { source: "claude-code-desktop", provider: "claude_desktop", sourceType: "claude-code-desktop-metadata", label: "Claude Code Desktop" },
-      { source: "claude-workspace", provider: "claude_desktop", sourceType: "claude-workspace-desktop", label: "Claude Workspace" },
+      { source: "claude-cowork", provider: "claude_desktop", sourceType: "claude-workspace-desktop", label: "Claude Cowork" },
       { source: "claude-web", provider: "claude_web", label: "Claude.ai" },
       { source: "claude-sdk", provider: "claude_sdk", label: "Claude SDK jobs" }
     ]
@@ -24,19 +24,42 @@ const SOURCE_GROUPS = [
     group: "Google",
     sources: [
       { source: "gemini-cli", provider: "gemini_cli", label: "Gemini CLI" },
-      { source: "antigravity", provider: "antigravity", label: "Antigravity" }
+      { source: "antigravity-cli", provider: "antigravity_cli", sourceType: "antigravity-cli-transcript-log", label: "Antigravity CLI" },
+      { source: "antigravity", provider: "antigravity", label: "Antigravity 2.0" },
+      { source: "antigravity-ide", provider: "antigravity_ide", sourceType: "antigravity-ide-transcript-log", label: "Antigravity IDE" }
     ]
   },
   {
     group: "Cognition",
     sources: [
-      { source: "devin-cli", provider: "devin", sourceType: "devin-cli-history", label: "Devin CLI" }
+      { source: "devin-cli", provider: "devin", sourceType: "devin-cli-history", label: "Devin CLI" },
+      { source: "devin-desktop", provider: "devin", sourceType: "devin-desktop-acp-events", label: "Devin Desktop" },
+      { source: "windsurf", provider: "windsurf", sourceType: "windsurf-cascade-brain", label: "Windsurf" }
+    ]
+  },
+  {
+    group: "GitHub",
+    sources: [
+      { source: "copilot-cli", provider: "copilot", sourceType: "copilot-cli-history", label: "GitHub Copilot CLI" }
+    ]
+  },
+  {
+    group: "Factory",
+    sources: [
+      { source: "factory", provider: "factory", sourceType: "factory-droid-history", label: "Factory Droid" }
+    ]
+  },
+  {
+    group: "xAI",
+    sources: [
+      { source: "grok-build", provider: "grok", sourceType: "grok-build-history", label: "Grok Build" }
     ]
   },
   {
     group: "Other",
     sources: [
       { source: "cursor", provider: "cursor", label: "Cursor" },
+      { source: "pi", provider: "pi", sourceType: "pi-cli-history", label: "pi" },
       { source: "cline", provider: "cline", sourceType: "cline-task-history", label: "Cline" },
       { source: "opencode-cli", provider: "opencode", sourceType: "opencode-cli-history", label: "OpenCode CLI" },
       { source: "opencode-desktop", provider: "opencode", sourceType: "opencode-desktop-history", label: "OpenCode Desktop" },
@@ -46,23 +69,28 @@ const SOURCE_GROUPS = [
   }
 ];
 
-const DISABLED_IMPORT_SOURCES = new Set(["windsurf"]);
+const DISABLED_IMPORT_SOURCES = new Set();
 
-const DISABLED_IMPORT_SOURCE_MESSAGES = {
-  windsurf:
-    "Windsurf import is disabled because current Cascade transcripts are encrypted binary stores. agentlog can detect those sessions, but cannot archive readable conversation text yet."
-};
+const DISABLED_IMPORT_SOURCE_MESSAGES = {};
 
 const IMPORT_SOURCE_ORDER = [
   "codex-cli",
   "codex-desktop",
   "claude",
   "claude-code-desktop",
-  "claude-workspace",
+  "claude-cowork",
   "gemini-cli",
+  "antigravity-cli",
   "antigravity",
+  "antigravity-ide",
   "devin-cli",
+  "devin-desktop",
+  "windsurf",
+  "copilot-cli",
+  "factory",
+  "grok-build",
   "cursor",
+  "pi",
   "cline",
   "opencode-cli",
   "opencode-desktop",
@@ -70,17 +98,38 @@ const IMPORT_SOURCE_ORDER = [
   "aider"
 ];
 
+const IMPORT_SOURCE_ALIASES = {
+  "claude-workspace": "claude-cowork",
+  claude_workspace: "claude-cowork",
+  claude_cowork: "claude-cowork"
+};
+
 const HISTORY_PROVIDER_OPTIONS = SOURCE_GROUPS.flatMap((group) => group.sources);
 
+function canonicalImportSource(source) {
+  const value = String(source || "").trim();
+  return IMPORT_SOURCE_ALIASES[value] || value;
+}
+
 function enabledImportSources(sources) {
-  return (sources || []).filter((source) => !DISABLED_IMPORT_SOURCES.has(source));
+  const seen = new Set();
+  const result = [];
+  for (const rawSource of sources || []) {
+    const source = canonicalImportSource(rawSource);
+    if (!source || seen.has(source) || DISABLED_IMPORT_SOURCES.has(source)) continue;
+    seen.add(source);
+    result.push(source);
+  }
+  return result;
 }
 
 function sourceLabel(source) {
-  return HISTORY_PROVIDER_OPTIONS.find((item) => item.source === source)?.label || { opencode: "OpenCode" }[source] || source;
+  const canonical = canonicalImportSource(source);
+  return HISTORY_PROVIDER_OPTIONS.find((item) => item.source === canonical)?.label || { opencode: "OpenCode" }[canonical] || canonical;
 }
 
 module.exports = {
+  canonicalImportSource,
   DISABLED_IMPORT_SOURCE_MESSAGES,
   DISABLED_IMPORT_SOURCES,
   HISTORY_PROVIDER_OPTIONS,