codesesh 0.10.0 → 0.12.0

package/dist/{dist-GZSUB4NY.js → dist-TZTL6VP4.js}

@@ -25,6 +25,7 @@ import {
   createProjectScopeMatcher,
   createRegisteredAgents,
   deleteBookmark,
+  ensureSessionTagsSync,
   estimateCostForTokens,
   estimateTokenCost,
   extractFileActivityOccurrences,
@@ -39,7 +40,9 @@ import {
   firstVisibleLine,
   getAgentByName,
   getAgentInfoMap,
+  getAgentLastFullSyncAt,
   getCacheInfo,
+  getCachePath2,
   getCursorDataPath,
   getParsedSession,
   getPricingRegistry,
@@ -59,7 +62,9 @@ import {
   loadCachedSessionData,
   loadCachedSessions,
   markAgentCacheInitialized,
+  markAgentFullSyncCompleted,
   matchesProjectScope,
+  matchesScanWindow,
   normalizeGitRemote,
   normalizeTitleText,
   openDb,
@@ -83,6 +88,7 @@ import {
   searchFileActivitySessions,
   searchSessions,
   sessionSignature,
+  setFtsIntegrityCheckedPath,
   skipped,
   skippedSession,
   sortSessions,
@@ -93,7 +99,7 @@ import {
   toLocalDateKey,
   upsertBookmark,
   withEstimatedSessionCost
-} from "./chunk-ZQMIB7QO.js";
+} from "./chunk-GCOAE7KI.js";
 export {
   BaseAgent,
   BookmarkStorageUnavailableError,
@@ -120,6 +126,7 @@ export {
   createProjectScopeMatcher,
   createRegisteredAgents,
   deleteBookmark,
+  ensureSessionTagsSync,
   estimateCostForTokens,
   estimateTokenCost,
   extractFileActivityOccurrences,
@@ -134,7 +141,9 @@ export {
   firstVisibleLine,
   getAgentByName,
   getAgentInfoMap,
+  getAgentLastFullSyncAt,
   getCacheInfo,
+  getCachePath2 as getCachePath,
   getCursorDataPath,
   getParsedSession,
   getPricingRegistry,
@@ -154,7 +163,9 @@ export {
   loadCachedSessionData,
   loadCachedSessions,
   markAgentCacheInitialized,
+  markAgentFullSyncCompleted,
   matchesProjectScope,
+  matchesScanWindow,
   normalizeGitRemote,
   normalizeTitleText,
   openDb,
@@ -178,6 +189,7 @@ export {
   searchFileActivitySessions,
   searchSessions,
   sessionSignature,
+  setFtsIntegrityCheckedPath,
   skipped,
   skippedSession,
   sortSessions,
@@ -189,4 +201,4 @@ export {
   upsertBookmark,
   withEstimatedSessionCost
 };
-//# sourceMappingURL=dist-GZSUB4NY.js.map
+//# sourceMappingURL=dist-TZTL6VP4.js.map

package/dist/index.js

@@ -14,6 +14,7 @@ import {
   extractSessionFileActivity,
   filterSessions,
   getAgentInfoMap,
+  getAgentLastFullSyncAt,
   getCursorDataPath,
   getSessionActivityTime,
   getSessionAgentName,
@@ -27,6 +28,7 @@ import {
   listSessionFileActivity,
   loadCachedSessionData,
   loadCachedSessions,
+  markAgentFullSyncCompleted,
   matchesProjectScope,
   parseSearchQuery,
   perf,
@@ -40,7 +42,7 @@ import {
   sortSessions,
   startOfLocalDay,
   upsertBookmark
-} from "./chunk-ZQMIB7QO.js";
+} from "./chunk-GCOAE7KI.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -899,11 +901,12 @@ async function createServer(port, store, options = {}) {
     app.get("/*", serveStatic({ root: webDistPath, path: "index.html" }));
   }
   const attempts = Math.max(1, options.portFallbackAttempts ?? 1);
+  const hostname = options.hostname ?? "127.0.0.1";
   let server = null;
   let actualPort = port;
   for (let offset = 0; offset < attempts; offset += 1) {
     const candidatePort = port + offset;
-    server = serve({ fetch: app.fetch, port: candidatePort });
+    server = serve({ fetch: app.fetch, port: candidatePort, hostname });
     try {
       await waitForListening(server);
       actualPort = getListeningPort(server, candidatePort);
@@ -925,8 +928,17 @@ async function createServer(port, store, options = {}) {
       throw new Error(getServerStartupErrorMessage(error, candidatePort));
     }
   }
-  const url = `http://localhost:${actualPort}`;
-  appLogger.info("server.listen", { port: actualPort, requested_port: port, url });
+  const isLoopback = hostname === "127.0.0.1" || hostname === "localhost";
+  const url = isLoopback ? `http://localhost:${actualPort}` : `http://${hostname}:${actualPort}`;
+  appLogger.info("server.listen", { port: actualPort, requested_port: port, hostname, url });
+  if (!isLoopback) {
+    appLogger.warn("server.listen.exposed", { hostname, port: actualPort });
+    console.warn(
+      `
+\u26A0 \u670D\u52A1\u76D1\u542C ${hostname}\uFF0C\u5C40\u57DF\u7F51\u5185\u5176\u4ED6\u8BBE\u5907\u53EF\u8BFB\u53D6\u4F60\u7684\u5168\u90E8 AI \u4F1A\u8BDD\u8BB0\u5F55\uFF08\u65E0\u9274\u6743\uFF09\u3002
+`
+    );
+  }
   return {
     url,
     shutdown: async () => {
@@ -1049,6 +1061,8 @@ function resolveAgentWatchTargets(agentName) {
         { root: roots.opencodeRoot, path: join2(roots.opencodeRoot, "opencode.db") },
         { root: "data/opencode", path: "data/opencode/opencode.db" }
       ];
+    case "zcode":
+      return roots.zcodeRoot ? [{ root: roots.zcodeRoot, path: join2(roots.zcodeRoot, "cli", "db", "db.sqlite") }] : [];
     default:
       return [];
   }
@@ -1270,8 +1284,11 @@ var SessionWatcher = class {
 var REFRESH_DEBOUNCE_MS = 200;
 var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
 var PENDING_REFRESH_DELAY_MS = 100;
+var MAX_ADAPTIVE_REFRESH_DELAY_MS = 3e4;
+var ADAPTIVE_REFRESH_DELAY_MULTIPLIER = 4;
 var NEW_SESSION_EVENT_WINDOW_MS = 250;
 var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
+var BACKFILL_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function buildRefreshDiff(agentName, previousSessions, nextSessions, candidateChangedIds = []) {
   const { changes, removedSessionIds, counts } = computeSessionDiff(
     previousSessions,
@@ -1355,13 +1372,12 @@ var LiveScanStore = class {
     completedAgents: [],
     agentStatuses: {},
     totalAgents: 0,
-    updatedAt: Date.now()
+    updatedAt: Date.now(),
+    backfill: { active: false, pendingAgents: [], completedAgents: [] }
   };
-  refreshTimers = /* @__PURE__ */ new Map();
-  refreshTimestamps = /* @__PURE__ */ new Map();
-  refreshInFlight = /* @__PURE__ */ new Set();
-  pendingRefreshes = /* @__PURE__ */ new Set();
-  pendingRefreshPathCounts = /* @__PURE__ */ new Map();
+  backfillQueue = [];
+  backfillRunning = false;
+  refreshStates = /* @__PURE__ */ new Map();
   watcher = null;
   pendingEvent = null;
   pendingEventTimer = null;
@@ -1369,6 +1385,24 @@ var LiveScanStore = class {
   searchIndexWorker = null;
   pendingSearchIndexJobs = [];
   shuttingDown = false;
+  /** Set once a search-index worker in this process has completed the FTS integrity check. */
+  ftsIntegrityChecked = false;
+  getRefreshState(agentName) {
+    let state = this.refreshStates.get(agentName);
+    if (!state) {
+      state = {
+        timer: null,
+        timerDeadline: 0,
+        inFlight: false,
+        pendingRerun: false,
+        lastRefreshAt: 0,
+        lastRefreshDurationMs: 0,
+        pendingPathCount: 0
+      };
+      this.refreshStates.set(agentName, state);
+    }
+    return state;
+  }
   async initialize() {
     const startedAt = performance.now();
     const deferInitialRefresh = this.storeOptions.deferInitialRefresh === true;
@@ -1425,10 +1459,7 @@ var LiveScanStore = class {
       this.watcher = new SessionWatcher();
       this.watcher.onAgentsChanged((agentNames) => {
         for (const agentName of agentNames) {
-          this.pendingRefreshPathCounts.set(
-            agentName,
-            (this.pendingRefreshPathCounts.get(agentName) ?? 0) + 1
-          );
+          this.getRefreshState(agentName).pendingPathCount += 1;
           const delayMs = (this.byAgent[agentName]?.length ?? 0) === 0 ? EMPTY_AGENT_REFRESH_DEBOUNCE_MS : REFRESH_DEBOUNCE_MS;
           this.scheduleRefresh(agentName, delayMs);
         }
@@ -1450,6 +1481,11 @@ var LiveScanStore = class {
       if (agentNames.length === 0) {
         this.finishScanBatch();
       }
+      for (const agent of this.agents) {
+        if (this.needsBackfill(agent)) {
+          this.enqueueBackfill(agent.name);
+        }
+      }
     }, 0);
   }
   getSnapshot() {
@@ -1471,7 +1507,12 @@ var LiveScanStore = class {
           agentName,
           { ...status }
         ])
-      )
+      ),
+      backfill: {
+        ...this.scanStatus.backfill,
+        pendingAgents: [...this.scanStatus.backfill.pendingAgents],
+        completedAgents: [...this.scanStatus.backfill.completedAgents]
+      }
     };
   }
   subscribe(listener) {
@@ -1488,11 +1529,13 @@ var LiveScanStore = class {
   }
   async shutdown() {
     this.shuttingDown = true;
-    for (const timer of this.refreshTimers.values()) {
-      clearTimeout(timer);
+    for (const state of this.refreshStates.values()) {
+      if (state.timer) {
+        clearTimeout(state.timer);
+        state.timer = null;
+        state.timerDeadline = 0;
+      }
     }
-    this.refreshTimers.clear();
-    this.pendingRefreshPathCounts.clear();
     if (this.pendingEventTimer) {
       clearTimeout(this.pendingEventTimer);
       this.pendingEventTimer = null;
@@ -1553,6 +1596,7 @@ var LiveScanStore = class {
       ])
     );
     this.updateScanStatus({
+      ...this.scanStatus,
       active: uniqueAgentNames.length > 0,
       phase: uniqueAgentNames.length > 0 ? phase : "idle",
       pendingAgents: uniqueAgentNames,
@@ -1678,6 +1722,108 @@ var LiveScanStore = class {
       completedAt: now
     });
   }
+  updateBackfillStatus(patch) {
+    this.updateScanStatus({
+      ...this.scanStatus,
+      backfill: { ...this.scanStatus.backfill, ...patch },
+      updatedAt: Date.now()
+    });
+  }
+  /**
+   * Only FileSystemSessionSource agents pay the O(history) enumeration cost this
+   * guards against: database agents already do a cheap single-file mtime check.
+   * With no startup window configured, the regular refresh path already walks
+   * full history, so backfill would be redundant.
+   */
+  needsBackfill(agent) {
+    if (this.startupScanOptions.from == null && this.startupScanOptions.to == null) return false;
+    if (!(agent instanceof FileSystemSessionSource)) return false;
+    if (!agent.isAvailable()) return false;
+    const lastSyncAt = getAgentLastFullSyncAt(agent.name);
+    return lastSyncAt == null || Date.now() - lastSyncAt > BACKFILL_INTERVAL_MS;
+  }
+  enqueueBackfill(agentName) {
+    if (this.backfillQueue.includes(agentName) || this.scanStatus.backfill.currentAgent === agentName) {
+      return;
+    }
+    this.backfillQueue.push(agentName);
+    this.updateBackfillStatus({ active: true, pendingAgents: [...this.backfillQueue] });
+    this.pumpBackfillQueue();
+  }
+  pumpBackfillQueue() {
+    if (this.backfillRunning) return;
+    const agentName = this.backfillQueue.shift();
+    if (!agentName) return;
+    this.backfillRunning = true;
+    this.updateBackfillStatus({ currentAgent: agentName, pendingAgents: [...this.backfillQueue] });
+    void this.runBackfill(agentName).finally(() => {
+      this.backfillRunning = false;
+      this.updateBackfillStatus({
+        currentAgent: void 0,
+        completedAgents: [.../* @__PURE__ */ new Set([...this.scanStatus.backfill.completedAgents, agentName])],
+        active: this.backfillQueue.length > 0
+      });
+      this.pumpBackfillQueue();
+    });
+  }
+  /** Unbounded per-source sync to reconcile the full session history, not just the display window. */
+  async runBackfill(agentName) {
+    const startedAt = performance.now();
+    const agent = this.agents.find((item) => item.name === agentName);
+    if (!agent || !(agent instanceof FileSystemSessionSource) || !agent.isAvailable()) {
+      return;
+    }
+    const cached = loadCachedSessions(agentName);
+    const baseline = cached?.sessions ?? this.byAgent[agentName] ?? [];
+    const meta = cached?.meta ?? buildAgentCacheMeta(agent);
+    if (cached) {
+      restoreAgentCacheMeta(agent, cached.meta);
+    }
+    try {
+      const result = await this.scanAgentInWorker(
+        agent,
+        baseline,
+        null,
+        {},
+        { sourceSync: true, meta }
+      );
+      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
+      const fullSessions = attachMissingProjectIdentities(result.sessions);
+      const filtered = this.applyFilters(fullSessions);
+      const diff = buildRefreshDiff(
+        agentName,
+        this.byAgent[agentName] ?? [],
+        filtered,
+        result.changedIds ?? []
+      );
+      this.byAgent[agentName] = sortSessions(filtered);
+      this.rebuildSessions();
+      await this.enqueueSearchIndexJobs("scan.backfill", [
+        {
+          kind: "full",
+          context: "scan.backfill",
+          agentName,
+          sessions: fullSessions,
+          meta: buildAgentCacheMeta(agent),
+          saveCache: true
+        }
+      ]);
+      markAgentFullSyncCompleted(agentName);
+      if (diff.event) {
+        diff.event.totalSessions = this.sessions.length;
+        this.emit(diff.event);
+      }
+      appLogger.info("scan.backfill.done", {
+        agent: agentName,
+        duration_ms: Math.round(performance.now() - startedAt),
+        sessions: fullSessions.length,
+        changed: result.changedIds?.length ?? 0
+      });
+    } catch (error) {
+      appLogger.error("scan.backfill.error", { agent: agentName, error });
+      console.error(`[${agentName}] Backfill failed:`, error);
+    }
+  }
   queueEvent(event) {
     this.pendingEvent = this.pendingEvent ? mergeEvents(this.pendingEvent, event) : event;
     if (this.pendingEventTimer) {
@@ -1811,7 +1957,8 @@ var LiveScanStore = class {
         jobs: batch.jobs,
         agentNames: [],
         sessionsByAgent: {},
-        metaByAgent: {}
+        metaByAgent: {},
+        skipFtsIntegrityCheck: this.ftsIntegrityChecked
       }
     });
     worker.unref();
@@ -1825,6 +1972,7 @@ var LiveScanStore = class {
           sessions: message.sessions
         });
         settled = true;
+        this.ftsIntegrityChecked = true;
         batch.resolve();
       }
     });
@@ -1871,7 +2019,7 @@ var LiveScanStore = class {
     this.byAgent = {};
     for (const agent of this.agents) {
       this.byAgent[agent.name] = sortSessions(result.byAgent[agent.name] ?? []);
-      this.refreshTimestamps.set(agent.name, result.cacheTimestamps?.[agent.name] ?? Date.now());
+      this.getRefreshState(agent.name).lastRefreshAt = result.cacheTimestamps?.[agent.name] ?? Date.now();
     }
     this.rebuildSessions();
   }
@@ -1901,25 +2049,41 @@ var LiveScanStore = class {
       console.error("[search] Background index sync failed:", error);
     }
   }
+  /**
+   * Throttles rather than debounces: a pending timer only gets replaced by a
+   * request with an earlier deadline. Plain debounce (reset on every call)
+   * would let a steady stream of events — each arriving before the adaptive
+   * backoff elapses — push the deadline out forever and starve the refresh.
+   */
   scheduleRefresh(agentName, delayMs = REFRESH_DEBOUNCE_MS) {
-    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: delayMs });
-    const existing = this.refreshTimers.get(agentName);
-    if (existing) {
-      clearTimeout(existing);
+    const state = this.getRefreshState(agentName);
+    const adaptiveDelayMs = Math.min(
+      state.lastRefreshDurationMs * ADAPTIVE_REFRESH_DELAY_MULTIPLIER,
+      MAX_ADAPTIVE_REFRESH_DELAY_MS
+    );
+    const effectiveDelayMs = Math.max(delayMs, adaptiveDelayMs);
+    const deadline = Date.now() + effectiveDelayMs;
+    if (state.timer !== null) {
+      if (deadline >= state.timerDeadline) {
+        return;
+      }
+      clearTimeout(state.timer);
     }
-    const timer = setTimeout(() => {
-      this.refreshTimers.delete(agentName);
+    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: effectiveDelayMs });
+    state.timerDeadline = deadline;
+    state.timer = setTimeout(() => {
+      state.timer = null;
       void this.refreshAgent(agentName);
-    }, delayMs);
-    this.refreshTimers.set(agentName, timer);
+    }, effectiveDelayMs);
   }
   async refreshAgent(agentName) {
-    if (this.refreshInFlight.has(agentName)) {
+    const state = this.getRefreshState(agentName);
+    if (state.inFlight) {
       appLogger.debug("scan.refresh.pending", { agent: agentName });
-      this.pendingRefreshes.add(agentName);
+      state.pendingRerun = true;
       return;
     }
-    this.refreshInFlight.add(agentName);
+    state.inFlight = true;
     this.beginAgentScan(agentName);
     try {
       await this.runRefresh(agentName);
@@ -1927,17 +2091,19 @@ var LiveScanStore = class {
       appLogger.error("scan.refresh.error", { agent: agentName, error });
       console.error(`[${agentName}] Session refresh failed:`, error);
     } finally {
-      this.refreshInFlight.delete(agentName);
+      state.inFlight = false;
       this.finishAgentScan(agentName);
-      if (this.pendingRefreshes.delete(agentName)) {
+      if (state.pendingRerun) {
+        state.pendingRerun = false;
         this.scheduleRefresh(agentName, PENDING_REFRESH_DELAY_MS);
       }
     }
   }
   async runRefresh(agentName) {
     const startedAt = performance.now();
-    const pendingPathCount = this.pendingRefreshPathCounts.get(agentName) ?? 0;
-    this.pendingRefreshPathCounts.delete(agentName);
+    const state = this.getRefreshState(agentName);
+    const pendingPathCount = state.pendingPathCount;
+    state.pendingPathCount = 0;
     const agent = this.agents.find((item) => item.name === agentName);
     if (!agent) {
       appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
@@ -1946,7 +2112,7 @@ var LiveScanStore = class {
     const previousSessions = this.byAgent[agentName] ?? [];
     const cached = loadCachedSessions(agentName);
     const refreshBaseline = cached?.sessions ?? previousSessions;
-    const cacheTimestamp = cached?.timestamp ?? this.refreshTimestamps.get(agentName) ?? 0;
+    const cacheTimestamp = cached?.timestamp ?? state.lastRefreshAt;
     if (cached) {
       restoreAgentCacheMeta(agent, cached.meta);
     }
@@ -1969,24 +2135,29 @@ var LiveScanStore = class {
     availabilityDuration = performance.now() - availabilityStartedAt;
     if (!isAvailable) {
       nextSessions = [];
-      this.refreshTimestamps.set(agentName, Date.now());
+      state.lastRefreshAt = Date.now();
     } else if (!isInitialized) {
       this.setScanPhase("initializing");
       const scanStartedAt = performance.now();
-      const result = await this.scanAgentInWorker(agent, previousSessions, null, {});
+      const result = await this.scanAgentInWorker(
+        agent,
+        previousSessions,
+        null,
+        this.startupScanOptions
+      );
       nextSessions = result.sessions;
       agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
-      this.refreshTimestamps.set(agentName, Date.now());
+      state.lastRefreshAt = Date.now();
     } else if (cached && agent instanceof FileSystemSessionSource) {
       const scanStartedAt = performance.now();
       const result = await this.scanAgentInWorker(
         agent,
         cached.sessions,
         null,
-        {},
+        this.startupScanOptions,
         {
           sourceSync: true,
           meta: cached.meta
@@ -2003,7 +2174,7 @@ var LiveScanStore = class {
         preciseChangedIds
       );
       scanDuration = performance.now() - scanStartedAt;
-      this.refreshTimestamps.set(agentName, Date.now());
+      state.lastRefreshAt = Date.now();
       if (preciseChangedIds.length === 0) {
         appLogger.debug("scan.refresh.unchanged", {
           agent: agentName,
@@ -2016,7 +2187,7 @@ var LiveScanStore = class {
         agent.checkForChanges(cacheTimestamp, refreshBaseline)
       );
       checkDuration = performance.now() - checkStartedAt;
-      this.refreshTimestamps.set(agentName, checkResult.timestamp);
+      state.lastRefreshAt = checkResult.timestamp;
       if (!checkResult.hasChanges) {
         appLogger.debug("scan.refresh.unchanged", {
           agent: agentName,
@@ -2047,7 +2218,7 @@ var LiveScanStore = class {
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
-      this.refreshTimestamps.set(agentName, Date.now());
+      state.lastRefreshAt = Date.now();
     }
     nextSessions = attachMissingProjectIdentities(nextSessions);
     const filterStartedAt = performance.now();
@@ -2108,9 +2279,11 @@ var LiveScanStore = class {
       event.totalSessions = this.sessions.length;
       this.emit(event);
     }
+    const totalDurationMs = performance.now() - startedAt;
+    state.lastRefreshDurationMs = totalDurationMs;
     appLogger.info("scan.refresh.done", {
       agent: agentName,
-      duration_ms: Math.round(performance.now() - startedAt),
+      duration_ms: Math.round(totalDurationMs),
       sessions: nextSessions.length,
       new_sessions: event?.newSessions ?? 0,
       updated_sessions: event?.updatedSessions ?? 0,
@@ -2199,6 +2372,11 @@ var main = defineCommand({
       description: "HTTP server port",
       default: String(DEFAULT_PORT)
     },
+    host: {
+      type: "string",
+      description: "HTTP server bind address (default 127.0.0.1, local access only)",
+      default: "127.0.0.1"
+    },
     agent: {
       type: "string",
       alias: "a",
@@ -2276,7 +2454,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-GZSUB4NY.js");
+      const { clearCache: clear } = await import("./dist-TZTL6VP4.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");
@@ -2365,7 +2543,8 @@ var main = defineCommand({
         defaultSessionFrom: listDefaultFrom,
         defaultSessionTo: listDefaultTo,
         defaultSessionDays: listDefaultDays,
-        portFallbackAttempts: explicitPort ? 1 : DEFAULT_PORT_FALLBACK_ATTEMPTS
+        portFallbackAttempts: explicitPort ? 1 : DEFAULT_PORT_FALLBACK_ATTEMPTS,
+        hostname: args.host
       });
     } catch (error) {
       console.error(getServerStartupErrorMessage(error, port));