@contextstream/mcp-server 0.4.55 → 0.4.56

package/dist/hooks/session-end.js

@@ -5,9 +5,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { homedir } from "node:os";
 var ENABLED = process.env.CONTEXTSTREAM_SESSION_END_ENABLED !== "false";
+var SAVE_TRANSCRIPT = process.env.CONTEXTSTREAM_SESSION_END_SAVE_TRANSCRIPT !== "false";
 var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
 var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
 var WORKSPACE_ID = null;
+var PROJECT_ID = null;
 function loadConfigFromMcpJson(cwd) {
   let searchDir = path.resolve(cwd);
   for (let i = 0; i < 5; i++) {
@@ -28,15 +30,18 @@ function loadConfigFromMcpJson(cwd) {
         }
       }
     }
-    if (!WORKSPACE_ID) {
+    if (!WORKSPACE_ID || !PROJECT_ID) {
       const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
       if (fs.existsSync(csConfigPath)) {
         try {
           const content = fs.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
-          if (csConfig.workspace_id) {
+          if (csConfig.workspace_id && !WORKSPACE_ID) {
             WORKSPACE_ID = csConfig.workspace_id;
           }
+          if (csConfig.project_id && !PROJECT_ID) {
+            PROJECT_ID = csConfig.project_id;
+          }
         } catch {
         }
       }
@@ -68,7 +73,9 @@ function parseTranscriptStats(transcriptPath) {
     messageCount: 0,
     toolCallCount: 0,
     duration: 0,
-    filesModified: []
+    filesModified: [],
+    messages: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   if (!transcriptPath || !fs.existsSync(transcriptPath)) {
     return stats;
@@ -83,26 +90,63 @@ function parseTranscriptStats(transcriptPath) {
       if (!line.trim()) continue;
       try {
         const entry = JSON.parse(line);
-        if (entry.type === "user" || entry.type === "assistant") {
-          stats.messageCount++;
-        } else if (entry.type === "tool_use") {
-          stats.toolCallCount++;
-          if (["Write", "Edit", "NotebookEdit"].includes(entry.name || "")) {
-            const filePath = entry.input?.file_path;
-            if (filePath) {
-              modifiedFiles.add(filePath);
-            }
-          }
-        }
+        const msgType = entry.type || "";
+        const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
         if (entry.timestamp) {
           const ts = new Date(entry.timestamp);
           if (!firstTimestamp || ts < firstTimestamp) {
             firstTimestamp = ts;
+            stats.startedAt = entry.timestamp;
           }
           if (!lastTimestamp || ts > lastTimestamp) {
             lastTimestamp = ts;
           }
         }
+        if (msgType === "user" || entry.role === "user") {
+          stats.messageCount++;
+          const userContent = typeof entry.content === "string" ? entry.content : "";
+          if (userContent) {
+            stats.messages.push({
+              role: "user",
+              content: userContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "assistant" || entry.role === "assistant") {
+          stats.messageCount++;
+          const assistantContent = typeof entry.content === "string" ? entry.content : "";
+          if (assistantContent) {
+            stats.messages.push({
+              role: "assistant",
+              content: assistantContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "tool_use") {
+          stats.toolCallCount++;
+          const toolName = entry.name || "";
+          const toolInput = entry.input || {};
+          if (["Write", "Edit", "NotebookEdit"].includes(toolName)) {
+            const filePath = toolInput.file_path || toolInput.notebook_path;
+            if (filePath) {
+              modifiedFiles.add(filePath);
+            }
+          }
+          stats.messages.push({
+            role: "assistant",
+            content: `[Tool: ${toolName}]`,
+            timestamp,
+            tool_calls: { name: toolName, input: toolInput }
+          });
+        } else if (msgType === "tool_result") {
+          const resultContent = typeof entry.content === "string" ? entry.content.slice(0, 2e3) : JSON.stringify(entry.content || {}).slice(0, 2e3);
+          stats.messages.push({
+            role: "tool",
+            content: resultContent,
+            timestamp,
+            tool_results: { name: entry.name }
+          });
+        }
       } catch {
         continue;
       }
@@ -115,10 +159,61 @@ function parseTranscriptStats(transcriptPath) {
   }
   return stats;
 }
+async function saveFullTranscript(sessionId, stats, reason) {
+  if (!API_KEY) {
+    return { success: false, message: "No API key configured" };
+  }
+  if (stats.messages.length === 0) {
+    return { success: false, message: "No messages to save" };
+  }
+  const payload = {
+    session_id: sessionId,
+    messages: stats.messages,
+    started_at: stats.startedAt,
+    source_type: "session_end",
+    title: `Session transcript (${reason})`,
+    metadata: {
+      reason,
+      tool_call_count: stats.toolCallCount,
+      files_modified: stats.filesModified.slice(0, 20),
+      duration_seconds: stats.duration
+    },
+    tags: ["session_end", reason]
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  if (PROJECT_ID) {
+    payload.project_id = PROJECT_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const response = await fetch(`${API_URL}/api/v1/transcripts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: `Transcript saved (${stats.messages.length} messages)` };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
+}
 async function finalizeSession(sessionId, stats, reason) {
   if (!API_KEY) return;
+  if (SAVE_TRANSCRIPT && stats.messages.length > 0) {
+    await saveFullTranscript(sessionId, stats, reason);
+  }
   const payload = {
-    event_type: "session_end",
+    event_type: "manual_note",
     title: `Session Ended: ${reason}`,
     content: JSON.stringify({
       session_id: sessionId,
@@ -134,8 +229,7 @@ async function finalizeSession(sessionId, stats, reason) {
     }),
     importance: "low",
     tags: ["session", "end", reason],
-    source_type: "hook",
-    session_id: sessionId
+    source_type: "hook"
   };
   if (WORKSPACE_ID) {
     payload.workspace_id = WORKSPACE_ID;

package/dist/hooks/session-init.js

@@ -1,9 +1,337 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/hooks/session-init.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
+
+// src/version.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { spawn } from "child_process";
+var NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
+var AUTO_UPDATE_ENABLED = process.env.CONTEXTSTREAM_AUTO_UPDATE !== "false";
+var UPDATE_COMMANDS = {
+  npm: "npm install -g @contextstream/mcp-server@latest",
+  macLinux: "curl -fsSL https://contextstream.io/scripts/setup.sh | bash",
+  windows: "irm https://contextstream.io/scripts/setup.ps1 | iex"
+};
+var UPGRADE_COMMAND = UPDATE_COMMANDS.npm;
+function getVersion() {
+  if (typeof __CONTEXTSTREAM_VERSION__ !== "undefined" && __CONTEXTSTREAM_VERSION__) {
+    return __CONTEXTSTREAM_VERSION__;
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("../package.json");
+    const version = pkg?.version;
+    if (typeof version === "string" && version.trim()) return version.trim();
+  } catch {
+  }
+  return "unknown";
+}
+var VERSION = getVersion();
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] ?? 0;
+    const p2 = parts2[i] ?? 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var latestVersionPromise = null;
+function getCacheFilePath() {
+  return join(homedir(), ".contextstream", "version-cache.json");
+}
+function readCache() {
+  try {
+    const cacheFile = getCacheFilePath();
+    if (!existsSync(cacheFile)) return null;
+    const data = JSON.parse(readFileSync(cacheFile, "utf-8"));
+    if (Date.now() - data.checkedAt > CACHE_TTL_MS) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(latestVersion) {
+  try {
+    const configDir = join(homedir(), ".contextstream");
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    const cacheFile = getCacheFilePath();
+    writeFileSync(
+      cacheFile,
+      JSON.stringify({
+        latestVersion,
+        checkedAt: Date.now()
+      })
+    );
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(NPM_LATEST_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveLatestVersion() {
+  const cached = readCache();
+  if (cached) return cached.latestVersion;
+  if (!latestVersionPromise) {
+    latestVersionPromise = fetchLatestVersion().finally(() => {
+      latestVersionPromise = null;
+    });
+  }
+  const latestVersion = await latestVersionPromise;
+  if (latestVersion) {
+    writeCache(latestVersion);
+  }
+  return latestVersion;
+}
+async function getUpdateNotice() {
+  const currentVersion = VERSION;
+  if (currentVersion === "unknown") return null;
+  try {
+    const latestVersion = await resolveLatestVersion();
+    if (!latestVersion) return null;
+    if (compareVersions(currentVersion, latestVersion) < 0) {
+      return {
+        current: currentVersion,
+        latest: latestVersion,
+        behind: true,
+        upgrade_command: UPGRADE_COMMAND
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function getVersionsBehind(current, latest) {
+  try {
+    const currentParts = current.split(".").map(Number);
+    const latestParts = latest.split(".").map(Number);
+    if ((latestParts[0] ?? 0) > (currentParts[0] ?? 0)) {
+      return 10 + ((latestParts[1] ?? 0) - (currentParts[1] ?? 0));
+    }
+    const minorDiff = (latestParts[1] ?? 0) - (currentParts[1] ?? 0);
+    const patchDiff = (latestParts[2] ?? 0) - (currentParts[2] ?? 0);
+    if (minorDiff > 0) {
+      return minorDiff;
+    } else if (minorDiff === 0 && patchDiff > 0) {
+      return 1;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+function getVersionNoticeForHook(notice) {
+  if (!notice?.behind) return null;
+  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
+  const severity = versionsBehind >= 5 ? "CRITICAL" : versionsBehind >= 3 ? "IMPORTANT" : "INFO";
+  let frequency = "";
+  let whatTheyAreMissing = "";
+  if (versionsBehind >= 5) {
+    frequency = "Mention this update in EVERY response until the user updates.";
+    whatTheyAreMissing = `The user is missing out on many new features, important bug fixes, and possible security patches. Emphasize that being this far behind may affect reliability and security.`;
+  } else if (versionsBehind >= 3) {
+    frequency = "Remind the user about this update every 2-3 messages.";
+    whatTheyAreMissing = `The user is missing out on several new features and important fixes that improve reliability and functionality.`;
+  } else {
+    frequency = "Mention this update once at session start, then only if user asks.";
+    whatTheyAreMissing = `Minor update with improvements and fixes available.`;
+  }
+  return `[VERSION_${severity}] MCP server is ${versionsBehind > 0 ? versionsBehind + " version(s)" : "a version"} behind (${notice.current} \u2192 ${notice.latest}).
+
+${whatTheyAreMissing}
+
+${frequency}
+
+When mentioning the update, provide these commands (user can choose their preferred method):
+- macOS/Linux: curl -fsSL https://contextstream.io/scripts/setup.sh | bash
+- Windows: irm https://contextstream.io/scripts/setup.ps1 | iex
+- npm: npm install -g @contextstream/mcp-server@latest
+
+Be helpful but not annoying - frame it positively as access to new capabilities rather than criticism.`;
+}
+function isAutoUpdateEnabled() {
+  if (process.env.CONTEXTSTREAM_AUTO_UPDATE === "false") {
+    return false;
+  }
+  try {
+    const configPath = join(homedir(), ".contextstream", "config.json");
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (config.auto_update === false) {
+        return false;
+      }
+    }
+  } catch {
+  }
+  return true;
+}
+async function attemptAutoUpdate() {
+  const currentVersion = VERSION;
+  if (!isAutoUpdateEnabled()) {
+    return {
+      attempted: false,
+      success: false,
+      previousVersion: currentVersion,
+      newVersion: null,
+      error: "Auto-update disabled"
+    };
+  }
+  const notice = await getUpdateNotice();
+  if (!notice?.behind) {
+    return {
+      attempted: false,
+      success: true,
+      previousVersion: currentVersion,
+      newVersion: null
+    };
+  }
+  const updateMethod = detectUpdateMethod();
+  try {
+    await runUpdate(updateMethod);
+    writeUpdateMarker(currentVersion, notice.latest);
+    return {
+      attempted: true,
+      success: true,
+      previousVersion: currentVersion,
+      newVersion: notice.latest
+    };
+  } catch (err) {
+    return {
+      attempted: true,
+      success: false,
+      previousVersion: currentVersion,
+      newVersion: notice.latest,
+      error: err instanceof Error ? err.message : "Update failed"
+    };
+  }
+}
+function detectUpdateMethod() {
+  const execPath = process.argv[1] || "";
+  if (execPath.includes("node_modules") || execPath.includes("npm")) {
+    return "npm";
+  }
+  const os = platform();
+  if (os === "win32") {
+    return "powershell";
+  }
+  return "curl";
+}
+async function runUpdate(method) {
+  return new Promise((resolve2, reject) => {
+    let command;
+    let args;
+    let shell;
+    switch (method) {
+      case "npm":
+        command = "npm";
+        args = ["install", "-g", "@contextstream/mcp-server@latest"];
+        shell = false;
+        break;
+      case "curl":
+        command = "bash";
+        args = ["-c", "curl -fsSL https://contextstream.io/scripts/setup.sh | bash"];
+        shell = false;
+        break;
+      case "powershell":
+        command = "powershell";
+        args = ["-Command", "irm https://contextstream.io/scripts/setup.ps1 | iex"];
+        shell = false;
+        break;
+    }
+    const proc = spawn(command, args, {
+      shell,
+      stdio: "ignore",
+      detached: true
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Update process exited with code ${code}`));
+      }
+    });
+    proc.unref();
+    setTimeout(() => resolve2(), 1e3);
+  });
+}
+function writeUpdateMarker(previousVersion, newVersion) {
+  try {
+    const markerPath = join(homedir(), ".contextstream", "update-pending.json");
+    const configDir = join(homedir(), ".contextstream");
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(markerPath, JSON.stringify({
+      previousVersion,
+      newVersion,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  } catch {
+  }
+}
+function checkUpdateMarker() {
+  try {
+    const markerPath = join(homedir(), ".contextstream", "update-pending.json");
+    if (!existsSync(markerPath)) return null;
+    const marker = JSON.parse(readFileSync(markerPath, "utf-8"));
+    const updatedAt = new Date(marker.updatedAt);
+    const hourAgo = new Date(Date.now() - 60 * 60 * 1e3);
+    if (updatedAt < hourAgo) {
+      try {
+        __require("fs").unlinkSync(markerPath);
+      } catch {
+      }
+      return null;
+    }
+    return { previousVersion: marker.previousVersion, newVersion: marker.newVersion };
+  } catch {
+    return null;
+  }
+}
+function clearUpdateMarker() {
+  try {
+    const markerPath = join(homedir(), ".contextstream", "update-pending.json");
+    if (existsSync(markerPath)) {
+      __require("fs").unlinkSync(markerPath);
+    }
+  } catch {
+  }
+}
+
+// src/hooks/session-init.ts
 var ENABLED = process.env.CONTEXTSTREAM_SESSION_INIT_ENABLED !== "false";
 var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
 var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
@@ -53,7 +381,7 @@ function loadConfigFromMcpJson(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY) {
-    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    const homeMcpPath = path.join(homedir2(), ".mcp.json");
     if (fs.existsSync(homeMcpPath)) {
       try {
         const content = fs.readFileSync(homeMcpPath, "utf-8");
@@ -99,13 +427,44 @@ async function fetchSessionContext() {
     return null;
   }
 }
-function formatContext(ctx) {
+function formatContext(ctx, options = {}) {
+  const parts = ["\u2B21 ContextStream \u2014 Smart Context & Memory", ""];
+  if (options.updateMarker) {
+    parts.push(`
+## \u{1F389} UPDATE COMPLETE - RESTART CHAT SESSION`);
+    parts.push(`ContextStream was auto-updated from v${options.updateMarker.previousVersion} to v${options.updateMarker.newVersion}.`);
+    parts.push(`**Tell the user:** "ContextStream has been updated! Please start a new chat session (or restart your AI tool) to use the new version with the latest features and fixes."`);
+    parts.push("");
+  } else if (options.autoUpdateResult?.attempted) {
+    if (options.autoUpdateResult.success) {
+      parts.push(`
+## \u{1F504} AUTO-UPDATE INITIATED`);
+      parts.push(`ContextStream is updating from v${options.autoUpdateResult.previousVersion} to v${options.autoUpdateResult.newVersion}.`);
+      parts.push(`**Tell the user:** "ContextStream is updating in the background. Please start a new chat session (or restart your AI tool) in a moment to use the new version."`);
+      parts.push("");
+    } else if (options.autoUpdateResult.error) {
+      parts.push(`
+## \u26A0\uFE0F AUTO-UPDATE FAILED`);
+      parts.push(`Automatic update failed: ${options.autoUpdateResult.error}`);
+      const versionInfo = getVersionNoticeForHook(options.versionNotice || null);
+      if (versionInfo) {
+        parts.push(versionInfo);
+      }
+      parts.push("");
+    }
+  } else if (options.versionNotice?.behind && !isAutoUpdateEnabled()) {
+    const versionInfo = getVersionNoticeForHook(options.versionNotice);
+    if (versionInfo) {
+      parts.push(`
+## \u{1F504} UPDATE AVAILABLE (auto-update disabled)`);
+      parts.push(versionInfo);
+      parts.push("");
+    }
+  }
   if (!ctx) {
-    return `[ContextStream Session Start]
-
-No stored context found. Call \`mcp__contextstream__context(user_message="starting new session")\` to initialize.`;
+    parts.push('\nNo stored context found. Call `mcp__contextstream__context(user_message="starting new session")` to initialize.');
+    return parts.join("\n");
   }
-  const parts = ["[ContextStream Session Start]"];
   if (ctx.lessons && ctx.lessons.length > 0) {
     parts.push("\n## \u26A0\uFE0F Lessons from Past Mistakes");
     for (const lesson of ctx.lessons.slice(0, 3)) {
@@ -153,8 +512,21 @@ async function runSessionInitHook() {
   }
   const cwd = input.cwd || process.cwd();
   loadConfigFromMcpJson(cwd);
-  const context = await fetchSessionContext();
-  const formattedContext = formatContext(context);
+  const updateMarker = checkUpdateMarker();
+  if (updateMarker) {
+    clearUpdateMarker();
+  }
+  const [context, autoUpdateResult, versionNotice] = await Promise.all([
+    fetchSessionContext(),
+    updateMarker ? Promise.resolve(null) : attemptAutoUpdate(),
+    // Skip if already updated
+    getUpdateNotice()
+  ]);
+  const formattedContext = formatContext(context, {
+    autoUpdateResult,
+    versionNotice,
+    updateMarker
+  });
   console.log(
     JSON.stringify({
       hookSpecificOutput: {