haansi 0.1.1 → 0.1.2

package/dist/haansi.js

@@ -65,8 +65,10 @@ async function validateToken(token, apiUrl) {
 async function init() {
   const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL;
   console.log("Haansi CLI \u2014 Setup\n");
-  console.log(`You can generate an API token at https://app.haansi.co/settings/tokens
-`);
+  console.log(
+    `You can generate an API token at https://app.haansi.co/settings/tokens
+`
+  );
   const token = await prompt("Paste your Haansi API token: ");
   if (!token) {
     console.error("Error: No token provided.");
@@ -938,6 +940,43 @@ var init_ingester = __esm({
       /**
        * Mark a session as processed and persist state.
        */
+      /**
+       * Return the number of lines already uploaded for this session (0 if unknown).
+       */
+      getUploadedLineCount(sessionId) {
+        const state = this.loadState();
+        return state.processed[sessionId]?.uploadedLineCount ?? 0;
+      }
+      /**
+       * Return whether this session was previously finalized.
+       */
+      isFinalized(sessionId) {
+        const state = this.loadState();
+        return state.processed[sessionId]?.finalized ?? false;
+      }
+      /**
+       * Return all session IDs that are tracked but not yet finalized.
+       * These are sessions that were previously uploaded as open and may
+       * need finalization if they no longer appear in the scan results.
+       */
+      getOpenSessionIds() {
+        const state = this.loadState();
+        return Object.values(state.processed).filter((r) => r.finalized === false).map((r) => r.sessionId);
+      }
+      /**
+       * Mark a session as finalized without re-reading its file.
+       * Used when a previously-open session is no longer receiving new lines.
+       */
+      markFinalized(sessionId) {
+        const state = this.loadState();
+        const record2 = state.processed[sessionId];
+        if (record2) {
+          record2.finalized = true;
+          record2.processedAt = (/* @__PURE__ */ new Date()).toISOString();
+          state.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.saveState(state);
+        }
+      }
       markProcessed(session, status, extras) {
         const state = this.loadState();
         state.processed[session.sessionId] = {
@@ -1002,17 +1041,22 @@ function resolveToken() {
   }
   return null;
 }
-async function uploadSession(sessionId, jsonlContent, apiUrl, token) {
-  const body = (0, import_zlib.gzipSync)(Buffer.from(jsonlContent, "utf-8"));
+async function uploadSession(sessionId, jsonlContent, apiUrl, token, isOpen) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/x-ndjson",
+    "x-session-id": sessionId,
+    "x-session-open": isOpen ? "true" : "false"
+  };
+  let body;
+  if (jsonlContent.length > 0) {
+    body = (0, import_zlib.gzipSync)(Buffer.from(jsonlContent, "utf-8"));
+    headers["Content-Encoding"] = "gzip";
+  }
   const response = await fetch(`${apiUrl}/api/v1/sessions/raw`, {
     method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/x-ndjson",
-      "Content-Encoding": "gzip",
-      "x-session-id": sessionId
-    },
-    body
+    headers,
+    body: body ? new Uint8Array(body) : void 0
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
@@ -1033,39 +1077,97 @@ async function collect(options) {
     projectPath: options.projectPath
   });
   const scanResult = options.projectPath ? await ingester.scan({ forceAll: options.forceAll }) : await ingester.scanAll({ forceAll: options.forceAll });
-  const toUpload = [...scanResult.newSessions, ...scanResult.updatedSessions];
-  const sessions = options.limit ? toUpload.slice(0, options.limit) : toUpload;
-  if (sessions.length === 0) {
-    logger3.info("No new sessions to upload");
-    return { uploaded: 0, skipped: scanResult.unchangedCount, errors: 0 };
-  }
-  logger3.info(`Uploading ${sessions.length} session(s)`, {
-    apiUrl,
-    dryRun: options.dryRun ?? false
-  });
+  const activeSessions = [
+    ...scanResult.newSessions,
+    ...scanResult.updatedSessions
+  ];
+  const activeSessionIds = new Set(activeSessions.map((s) => s.sessionId));
+  const sessions = options.limit ? activeSessions.slice(0, options.limit) : activeSessions;
   let uploaded = 0;
   let errors = 0;
-  for (const session of sessions) {
-    const shortId = session.sessionId.slice(0, 8);
-    try {
-      const rawContent = (0, import_fs4.readFileSync)(session.filePath, "utf-8");
-      const scrubbed = edgeScrub(rawContent);
-      if (options.dryRun) {
+  if (sessions.length > 0) {
+    logger3.info(`Uploading ${sessions.length} active session(s)`, {
+      apiUrl,
+      dryRun: options.dryRun ?? false
+    });
+    for (const session of sessions) {
+      const shortId = session.sessionId.slice(0, 8);
+      try {
+        const rawContent = (0, import_fs4.readFileSync)(session.filePath, "utf-8");
+        const allLines = rawContent.split("\n").filter((l) => l.trim().length > 0);
+        const totalLines = allLines.length;
+        let uploadedLineCount = ingester.getUploadedLineCount(
+          session.sessionId
+        );
+        const wasPreviouslyFinalized = ingester.isFinalized(session.sessionId);
+        if (wasPreviouslyFinalized && totalLines > uploadedLineCount) {
+          uploadedLineCount = 0;
+        }
+        if (totalLines < uploadedLineCount) {
+          uploadedLineCount = 0;
+        }
+        const deltaLines = allLines.slice(uploadedLineCount);
+        if (deltaLines.length === 0) {
+          continue;
+        }
+        const deltaContent = edgeScrub(deltaLines.join("\n") + "\n");
+        if (options.dryRun) {
+          logger3.info(
+            `[dry-run] Would upload delta for session ${shortId} (${deltaLines.length} new lines, open)`
+          );
+          uploaded++;
+          continue;
+        }
+        await uploadSession(
+          session.sessionId,
+          deltaContent,
+          apiUrl,
+          token,
+          true
+        );
+        ingester.markProcessed(session, "pending", {
+          uploadedLineCount: totalLines,
+          finalized: false
+        });
+        uploaded++;
         logger3.info(
-          `[dry-run] Would upload session ${shortId} (${rawContent.length} bytes)`
+          `delta uploaded session ${shortId} (${deltaLines.length} new lines, open)`
         );
+      } catch (err) {
+        errors++;
+        logger3.error(`Failed to upload session ${shortId}`, {
+          err: err.message
+        });
+      }
+    }
+  }
+  const openSessionIds = ingester.getOpenSessionIds();
+  const toFinalize = openSessionIds.filter((id) => !activeSessionIds.has(id));
+  if (toFinalize.length > 0) {
+    logger3.info(`Finalizing ${toFinalize.length} idle session(s)`);
+    for (const sessionId of toFinalize) {
+      const shortId = sessionId.slice(0, 8);
+      try {
+        if (options.dryRun) {
+          logger3.info(`[dry-run] Would finalize session ${shortId}`);
+          uploaded++;
+          continue;
+        }
+        await uploadSession(sessionId, "", apiUrl, token, false);
+        ingester.markFinalized(sessionId);
         uploaded++;
-        continue;
+        logger3.info(`finalized session ${shortId}`);
+      } catch (err) {
+        errors++;
+        logger3.error(`Failed to finalize session ${shortId}`, {
+          err: err.message
+        });
       }
-      await uploadSession(session.sessionId, scrubbed, apiUrl, token);
-      ingester.markProcessed(session, "pending", {});
-      uploaded++;
-      logger3.info(`Uploaded session ${shortId}`);
-    } catch (err) {
-      errors++;
-      logger3.error(`Failed to upload session ${shortId}`, { err: err.message });
     }
   }
+  if (sessions.length === 0 && toFinalize.length === 0) {
+    logger3.info("No new sessions to upload");
+  }
   return { uploaded, skipped: scanResult.unchangedCount, errors };
 }
 async function main2() {
@@ -31991,6 +32093,25 @@ function resolveToken2() {
   }
   return null;
 }
+function triggerCollectInBackground() {
+  if (isCollecting) return;
+  isCollecting = true;
+  collect({}).then(({ uploaded, skipped, errors }) => {
+    console.error(
+      `[mcp-server] Collection done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
+    );
+    lastCollectTime = Date.now();
+  }).catch((err) => {
+    console.error("[mcp-server] Collection error:", err.message);
+  }).finally(() => {
+    isCollecting = false;
+  });
+}
+function maybeCollect() {
+  if (Date.now() - lastCollectTime >= COLLECT_COOLDOWN_MS) {
+    triggerCollectInBackground();
+  }
+}
 async function apiGet(path) {
   const response = await fetch(`${API_URL}/api/v1${path}`, {
     headers: { Authorization: `Bearer ${TOKEN}` }
@@ -32005,6 +32126,7 @@ async function main4() {
   try {
     await apiGet("/sessions/recent?limit=1");
     console.error("[mcp-server] API connection ok");
+    triggerCollectInBackground();
   } catch (err) {
     console.error(
       "[mcp-server] WARNING: API connection check failed:",
@@ -32015,7 +32137,7 @@ async function main4() {
   await mcpServer.connect(transport);
   console.error("[mcp-server] haansi-solutions MCP server running on stdio");
 }
-var import_dotenv4, import_path5, import_fs5, import_os4, DEFAULT_API_URL3, CREDENTIALS_FILE3, API_URL, TOKEN, mcpServer, server;
+var import_dotenv4, import_path5, import_fs5, import_os4, DEFAULT_API_URL3, CREDENTIALS_FILE3, API_URL, TOKEN, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
 var init_mcp_server2 = __esm({
   "../service-capture/claude-sessions/mcp-server.ts"() {
     "use strict";
@@ -32023,6 +32145,7 @@ var init_mcp_server2 = __esm({
     import_path5 = require("path");
     import_fs5 = require("fs");
     import_os4 = require("os");
+    init_collector();
     init_mcp();
     init_stdio2();
     init_types2();
@@ -32037,6 +32160,9 @@ var init_mcp_server2 = __esm({
       );
       process.exit(1);
     }
+    isCollecting = false;
+    lastCollectTime = 0;
+    COLLECT_COOLDOWN_MS = 5 * 60 * 1e3;
     mcpServer = new McpServer(
       { name: "haansi-solutions", version: "0.2.0" },
       { capabilities: { tools: {} } }
@@ -32079,6 +32205,7 @@ var init_mcp_server2 = __esm({
       ]
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      maybeCollect();
       const { name, arguments: args } = request.params;
       console.error(`[mcp-server] Tool: ${name}`);
       try {
@@ -32150,7 +32277,9 @@ async function setupMcp() {
     try {
       config6 = JSON.parse((0, import_node_fs2.readFileSync)(CLAUDE_JSON, "utf-8"));
     } catch {
-      console.error(`Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`);
+      console.error(
+        `Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`
+      );
     }
   }
   if (!config6.mcpServers) {
@@ -32162,7 +32291,9 @@ async function setupMcp() {
   };
   (0, import_node_fs2.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
   console.log(`MCP server configured in ${CLAUDE_JSON}`);
-  console.log("Restart Claude Code to activate the haansi-solutions MCP server.");
+  console.log(
+    "Restart Claude Code to activate the haansi-solutions MCP server."
+  );
 }
 var import_node_fs2, import_node_path2, import_node_os2, CLAUDE_JSON;
 var init_setup_mcp = __esm({
@@ -32184,7 +32315,9 @@ function findHaansiBin() {
   try {
     return (0, import_node_child_process.execSync)("which haansi", { encoding: "utf-8" }).trim();
   } catch {
-    throw new Error("Could not find haansi in PATH. Make sure it is installed globally (npm install -g haansi).");
+    throw new Error(
+      "Could not find haansi in PATH. Make sure it is installed globally (npm install -g haansi)."
+    );
   }
 }
 function buildPlist(haansiPath) {
@@ -32255,7 +32388,12 @@ var init_setup_daemon = __esm({
     import_node_path3 = require("node:path");
     import_node_os3 = require("node:os");
     PLIST_LABEL = "co.haansi.daemon";
-    PLIST_PATH = (0, import_node_path3.join)((0, import_node_os3.homedir)(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+    PLIST_PATH = (0, import_node_path3.join)(
+      (0, import_node_os3.homedir)(),
+      "Library",
+      "LaunchAgents",
+      `${PLIST_LABEL}.plist`
+    );
     LOG_FILE = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi", "daemon.log");
   }
 });
@@ -32297,7 +32435,11 @@ async function list(options) {
       apiUrl
     );
   } else {
-    data = await apiGet2(`/sessions/recent?limit=${options.limit}`, token, apiUrl);
+    data = await apiGet2(
+      `/sessions/recent?limit=${options.limit}`,
+      token,
+      apiUrl
+    );
   }
   if (!data.results || data.results.length === 0) {
     console.log("No solutions found. Run `haansi collect` to upload sessions.");
@@ -32336,9 +32478,16 @@ async function run2() {
       const limitIdx = process.argv.indexOf("--limit");
       const limit = limitIdx !== -1 ? parseInt(process.argv[limitIdx + 1], 10) : void 0;
       const projectPath = process.env.CLAUDE_PROJECT_PATH || void 0;
-      const { uploaded, skipped, errors } = await collect2({ forceAll, dryRun, limit, projectPath });
-      console.log(`
-Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`);
+      const { uploaded, skipped, errors } = await collect2({
+        forceAll,
+        dryRun,
+        limit,
+        projectPath
+      });
+      console.log(
+        `
+Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
+      );
       if (errors > 0) process.exit(1);
       break;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haansi",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Haansi CLI - Session collector and MCP server for Claude Code",
   "bin": {
     "haansi": "./dist/haansi.js"