@contextstream/mcp-server 0.3.30 → 0.3.32

package/README.md

@@ -47,7 +47,9 @@ npx -y @contextstream/mcp-server setup
 ```
 
 Notes:
-- Uses browser/device login by default and creates an API key for you (stored locally in the config files it writes).
+- Uses browser/device login by default and creates an API key for you.
+- To avoid re-auth prompts on subsequent runs, the wizard saves that API key to `~/.contextstream/credentials.json` (and also writes it into the MCP config files it generates). Delete that file to force a fresh login.
+- Codex CLI MCP config is global-only (`~/.codex/config.toml`), so the wizard will always write Codex config globally when selected.
 - Some tools still require UI/CLI-based MCP setup (the wizard will tell you when it can’t write a config).
 - Preview changes without writing files: `npx -y @contextstream/mcp-server setup --dry-run`
 

package/dist/index.js

@@ -487,8 +487,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -604,11 +604,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -4138,9 +4138,9 @@ var BASE_DELAY = 1e3;
 async function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function request(config, path6, options = {}) {
+async function request(config, path7, options = {}) {
   const { apiUrl, apiKey, jwt, userAgent } = config;
-  const apiPath = path6.startsWith("/api/") ? path6 : `/api/v1${path6}`;
+  const apiPath = path7.startsWith("/api/") ? path7 : `/api/v1${path7}`;
   const url = `${apiUrl.replace(/\/$/, "")}${apiPath}`;
   const maxRetries = options.retries ?? MAX_RETRIES;
   const baseDelay = options.retryDelay ?? BASE_DELAY;
@@ -4641,6 +4641,29 @@ function unwrapApiResponse(result) {
   }
   return result;
 }
+function normalizeNodeType(input) {
+  const t = String(input ?? "").trim().toLowerCase();
+  switch (t) {
+    case "fact":
+    case "insight":
+    case "note":
+      return "Fact";
+    case "decision":
+      return "Decision";
+    case "preference":
+      return "Preference";
+    case "constraint":
+      return "Constraint";
+    case "habit":
+      return "Habit";
+    case "lesson":
+      return "Lesson";
+    default:
+      throw new Error(
+        `Invalid node_type: ${JSON.stringify(input)} (expected one of fact|decision|preference|constraint|habit|lesson)`
+      );
+  }
+}
 var ContextStreamClient = class {
   constructor(config) {
     this.config = config;
@@ -4721,13 +4744,19 @@ var ContextStreamClient = class {
     const result = await request(this.config, "/workspaces", { body: input });
     return unwrapApiResponse(result);
   }
-  updateWorkspace(workspaceId, input) {
+  async updateWorkspace(workspaceId, input) {
     uuidSchema.parse(workspaceId);
-    return request(this.config, `/workspaces/${workspaceId}`, { method: "PUT", body: input });
+    const result = await request(this.config, `/workspaces/${workspaceId}`, { method: "PUT", body: input });
+    globalCache.delete(CacheKeys.workspace(workspaceId));
+    globalCache.delete(`workspace_overview:${workspaceId}`);
+    return result;
   }
-  deleteWorkspace(workspaceId) {
+  async deleteWorkspace(workspaceId) {
     uuidSchema.parse(workspaceId);
-    return request(this.config, `/workspaces/${workspaceId}`, { method: "DELETE" });
+    const result = await request(this.config, `/workspaces/${workspaceId}`, { method: "DELETE" });
+    globalCache.delete(CacheKeys.workspace(workspaceId));
+    globalCache.delete(`workspace_overview:${workspaceId}`);
+    return result;
   }
   listProjects(params) {
     const withDefaults = this.withDefaults(params || {});
@@ -4743,13 +4772,19 @@ var ContextStreamClient = class {
     const result = await request(this.config, "/projects", { body: payload });
     return unwrapApiResponse(result);
   }
-  updateProject(projectId, input) {
+  async updateProject(projectId, input) {
     uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}`, { method: "PUT", body: input });
+    const result = await request(this.config, `/projects/${projectId}`, { method: "PUT", body: input });
+    globalCache.delete(CacheKeys.project(projectId));
+    globalCache.delete(`project_overview:${projectId}`);
+    return result;
   }
-  deleteProject(projectId) {
+  async deleteProject(projectId) {
     uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}`, { method: "DELETE" });
+    const result = await request(this.config, `/projects/${projectId}`, { method: "DELETE" });
+    globalCache.delete(CacheKeys.project(projectId));
+    globalCache.delete(`project_overview:${projectId}`);
+    return result;
   }
   indexProject(projectId) {
     uuidSchema.parse(projectId);
@@ -4818,7 +4853,24 @@ var ContextStreamClient = class {
     return request(this.config, `/memory/events/workspace/${withDefaults.workspace_id}${suffix}`, { method: "GET" });
   }
   createKnowledgeNode(body) {
-    return request(this.config, "/memory/nodes", { body: this.withDefaults(body) });
+    const withDefaults = this.withDefaults(body);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for creating knowledge nodes");
+    }
+    const summary = String(withDefaults.title ?? "").trim() || String(withDefaults.content ?? "").trim().slice(0, 120) || "Untitled";
+    const details = String(withDefaults.content ?? "").trim();
+    const apiBody = {
+      workspace_id: withDefaults.workspace_id,
+      project_id: withDefaults.project_id,
+      node_type: normalizeNodeType(withDefaults.node_type),
+      summary,
+      details: details || void 0,
+      valid_from: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (withDefaults.relations && withDefaults.relations.length) {
+      apiBody.context = { relations: withDefaults.relations };
+    }
+    return request(this.config, "/memory/nodes", { body: apiBody });
   }
   listKnowledgeNodes(params) {
     const withDefaults = this.withDefaults(params || {});
@@ -4957,7 +5009,7 @@ var ContextStreamClient = class {
   }
   deleteMemoryEvent(eventId) {
     uuidSchema.parse(eventId);
-    return request(this.config, `/memory/events/${eventId}`, { method: "DELETE" });
+    return request(this.config, `/memory/events/${eventId}`, { method: "DELETE" }).then((r) => r === "" || r == null ? { success: true } : r);
   }
   distillMemoryEvent(eventId) {
     uuidSchema.parse(eventId);
@@ -4969,15 +5021,47 @@ var ContextStreamClient = class {
   }
   updateKnowledgeNode(nodeId, body) {
     uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}`, { method: "PUT", body });
+    const apiBody = {};
+    if (body.title !== void 0) apiBody.summary = body.title;
+    if (body.content !== void 0) apiBody.details = body.content;
+    if (body.relations && body.relations.length) apiBody.context = { relations: body.relations };
+    return request(this.config, `/memory/nodes/${nodeId}`, { method: "PUT", body: apiBody });
   }
   deleteKnowledgeNode(nodeId) {
     uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}`, { method: "DELETE" });
+    return request(this.config, `/memory/nodes/${nodeId}`, { method: "DELETE" }).then((r) => r === "" || r == null ? { success: true } : r);
   }
   supersedeKnowledgeNode(nodeId, body) {
     uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}/supersede`, { body });
+    return (async () => {
+      const existingResp = await this.getKnowledgeNode(nodeId);
+      const existing = unwrapApiResponse(existingResp);
+      if (!existing || !existing.workspace_id) {
+        throw new Error("Failed to load existing node before superseding");
+      }
+      const createdResp = await this.createKnowledgeNode({
+        workspace_id: existing.workspace_id,
+        project_id: existing.project_id ?? void 0,
+        node_type: existing.node_type,
+        title: existing.summary ?? "Superseded node",
+        content: body.new_content
+      });
+      const created = unwrapApiResponse(createdResp);
+      if (!created?.id) {
+        throw new Error("Failed to create replacement node for supersede");
+      }
+      await request(this.config, `/memory/nodes/${nodeId}/supersede`, { body: { superseded_by: created.id } });
+      return {
+        success: true,
+        data: {
+          status: "superseded",
+          old_node_id: nodeId,
+          new_node_id: created.id,
+          reason: body.reason ?? null
+        },
+        error: null
+      };
+    })();
   }
   memoryTimeline(workspaceId) {
     uuidSchema.parse(workspaceId);
@@ -5842,9 +5926,9 @@ var ContextStreamClient = class {
           candidateParts.push("## Relevant Code\n");
           currentChars += 18;
           const codeEntries = code.results.map((c) => {
-            const path6 = c.file_path || "file";
+            const path7 = c.file_path || "file";
             const content = c.content?.slice(0, 150) || "";
-            return { path: path6, entry: `\u2022 ${path6}: ${content}...
+            return { path: path7, entry: `\u2022 ${path7}: ${content}...
 ` };
           });
           for (const c of codeEntries) {
@@ -6776,6 +6860,8 @@ function getVersion() {
 var VERSION = getVersion();
 
 // src/tools.ts
+var LESSON_DEDUP_WINDOW_MS = 2 * 60 * 1e3;
+var recentLessonCaptures = /* @__PURE__ */ new Map();
 function formatContent(data) {
   return JSON.stringify(data, null, 2);
 }
@@ -6785,6 +6871,35 @@ function toStructured(data) {
   }
   return void 0;
 }
+function normalizeLessonField(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function buildLessonSignature(input, workspaceId, projectId) {
+  return [
+    workspaceId,
+    projectId || "global",
+    input.category,
+    input.title,
+    input.trigger,
+    input.impact,
+    input.prevention
+  ].map(normalizeLessonField).join("|");
+}
+function isDuplicateLessonCapture(signature) {
+  const now = Date.now();
+  for (const [key, ts] of recentLessonCaptures) {
+    if (now - ts > LESSON_DEDUP_WINDOW_MS) {
+      recentLessonCaptures.delete(key);
+    }
+  }
+  const last = recentLessonCaptures.get(signature);
+  if (last && now - last < LESSON_DEDUP_WINDOW_MS) {
+    recentLessonCaptures.set(signature, now);
+    return true;
+  }
+  recentLessonCaptures.set(signature, now);
+  return false;
+}
 function registerTools(server, client, sessionManager) {
   const upgradeUrl = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
   const defaultProTools = /* @__PURE__ */ new Set([
@@ -7936,26 +8051,26 @@ Optionally generates AI editor rules for automatic ContextStream usage.`,
       const result = await client.associateWorkspace(input);
       let rulesGenerated = [];
       if (input.generate_editor_rules) {
-        const fs4 = await import("fs");
-        const path6 = await import("path");
+        const fs5 = await import("fs");
+        const path7 = await import("path");
         for (const editor of getAvailableEditors()) {
           const rule = generateRuleContent(editor, {
             workspaceName: input.workspace_name,
             workspaceId: input.workspace_id
           });
           if (rule) {
-            const filePath = path6.join(input.folder_path, rule.filename);
+            const filePath = path7.join(input.folder_path, rule.filename);
             try {
               let existingContent = "";
               try {
-                existingContent = fs4.readFileSync(filePath, "utf-8");
+                existingContent = fs5.readFileSync(filePath, "utf-8");
               } catch {
               }
               if (!existingContent) {
-                fs4.writeFileSync(filePath, rule.content);
+                fs5.writeFileSync(filePath, rule.content);
                 rulesGenerated.push(rule.filename);
               } else if (!existingContent.includes("ContextStream Integration")) {
-                fs4.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
+                fs5.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
                 rulesGenerated.push(rule.filename + " (appended)");
               }
             } catch {
@@ -8041,26 +8156,26 @@ Behavior:
       });
       let rulesGenerated = [];
       if (input.generate_editor_rules) {
-        const fs4 = await import("fs");
-        const path6 = await import("path");
+        const fs5 = await import("fs");
+        const path7 = await import("path");
         for (const editor of getAvailableEditors()) {
           const rule = generateRuleContent(editor, {
             workspaceName: newWorkspace.name || input.workspace_name,
             workspaceId: newWorkspace.id
           });
           if (!rule) continue;
-          const filePath = path6.join(folderPath, rule.filename);
+          const filePath = path7.join(folderPath, rule.filename);
           try {
             let existingContent = "";
             try {
-              existingContent = fs4.readFileSync(filePath, "utf-8");
+              existingContent = fs5.readFileSync(filePath, "utf-8");
             } catch {
             }
             if (!existingContent) {
-              fs4.writeFileSync(filePath, rule.content);
+              fs5.writeFileSync(filePath, rule.content);
               rulesGenerated.push(rule.filename);
             } else if (!existingContent.includes("ContextStream Integration")) {
-              fs4.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
+              fs5.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
               rulesGenerated.push(rule.filename + " (appended)");
             }
           } catch {
@@ -8202,6 +8317,25 @@ The lesson will be tagged with 'lesson' and stored with structured metadata for
           isError: true
         };
       }
+      const lessonSignature = buildLessonSignature({
+        title: input.title,
+        category: input.category,
+        trigger: input.trigger,
+        impact: input.impact,
+        prevention: input.prevention
+      }, workspaceId, projectId);
+      if (isDuplicateLessonCapture(lessonSignature)) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u2139\uFE0F Duplicate lesson capture ignored: "${input.title}" was already recorded recently.`
+          }],
+          structuredContent: {
+            deduped: true,
+            title: input.title
+          }
+        };
+      }
       const lessonContent = [
         `## ${input.title}`,
         "",
@@ -8460,8 +8594,8 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       })
     },
     async (input) => {
-      const fs4 = await import("fs");
-      const path6 = await import("path");
+      const fs5 = await import("fs");
+      const path7 = await import("path");
       const editors = input.editors?.includes("all") || !input.editors ? getAvailableEditors() : input.editors.filter((e) => e !== "all");
       const results = [];
       for (const editor of editors) {
@@ -8476,7 +8610,7 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
           results.push({ editor, filename: "", status: "unknown editor" });
           continue;
         }
-        const filePath = path6.join(input.folder_path, rule.filename);
+        const filePath = path7.join(input.folder_path, rule.filename);
         if (input.dry_run) {
           results.push({
             editor,
@@ -8488,15 +8622,15 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
           try {
             let existingContent = "";
             try {
-              existingContent = fs4.readFileSync(filePath, "utf-8");
+              existingContent = fs5.readFileSync(filePath, "utf-8");
             } catch {
             }
             if (existingContent && !existingContent.includes("ContextStream Integration")) {
               const updatedContent = existingContent + "\n\n" + rule.content;
-              fs4.writeFileSync(filePath, updatedContent);
+              fs5.writeFileSync(filePath, updatedContent);
               results.push({ editor, filename: rule.filename, status: "appended to existing" });
             } else {
-              fs4.writeFileSync(filePath, rule.content);
+              fs5.writeFileSync(filePath, rule.content);
               results.push({ editor, filename: rule.filename, status: "created" });
             }
           } catch (err) {
@@ -9166,8 +9300,8 @@ var SessionManager = class {
   /**
    * Set the folder path hint (can be passed from tools that know the workspace path)
    */
-  setFolderPath(path6) {
-    this.folderPath = path6;
+  setFolderPath(path7) {
+    this.folderPath = path7;
   }
   /**
    * Mark that context_smart has been called in this session
@@ -9234,11 +9368,11 @@ var SessionManager = class {
     }
     if (this.ideRoots.length === 0) {
       const cwd = process.cwd();
-      const fs4 = await import("fs");
+      const fs5 = await import("fs");
       const projectIndicators = [".git", "package.json", "Cargo.toml", "pyproject.toml", ".contextstream"];
       const hasProjectIndicator = projectIndicators.some((f) => {
         try {
-          return fs4.existsSync(`${cwd}/${f}`);
+          return fs5.existsSync(`${cwd}/${f}`);
         } catch {
           return false;
         }
@@ -9416,15 +9550,79 @@ var SessionManager = class {
 
 // src/index.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
 
 // src/setup.ts
+import * as fs4 from "node:fs/promises";
+import * as path6 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+// src/credentials.ts
 import * as fs3 from "node:fs/promises";
 import * as path5 from "node:path";
 import { homedir } from "node:os";
-import { stdin, stdout } from "node:process";
-import { createInterface } from "node:readline/promises";
+function normalizeApiUrl(input) {
+  return String(input ?? "").trim().replace(/\/+$/, "");
+}
+function credentialsFilePath() {
+  return path5.join(homedir(), ".contextstream", "credentials.json");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readSavedCredentials() {
+  const filePath = credentialsFilePath();
+  try {
+    const raw = await fs3.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) return null;
+    const version = parsed.version;
+    if (version !== 1) return null;
+    const apiUrl = typeof parsed.api_url === "string" ? normalizeApiUrl(parsed.api_url) : "";
+    const apiKey = typeof parsed.api_key === "string" ? parsed.api_key.trim() : "";
+    if (!apiUrl || !apiKey) return null;
+    const email = typeof parsed.email === "string" ? parsed.email.trim() : "";
+    const createdAt = typeof parsed.created_at === "string" ? parsed.created_at : "";
+    const updatedAt = typeof parsed.updated_at === "string" ? parsed.updated_at : "";
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      version: 1,
+      api_url: apiUrl,
+      api_key: apiKey,
+      email: email || void 0,
+      created_at: createdAt || now,
+      updated_at: updatedAt || now
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeSavedCredentials(input) {
+  const filePath = credentialsFilePath();
+  await fs3.mkdir(path5.dirname(filePath), { recursive: true });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await readSavedCredentials();
+  const value = {
+    version: 1,
+    api_url: normalizeApiUrl(input.apiUrl),
+    api_key: input.apiKey.trim(),
+    email: input.email?.trim() || void 0,
+    created_at: existing?.created_at || now,
+    updated_at: now
+  };
+  const body = JSON.stringify(value, null, 2) + "\n";
+  await fs3.writeFile(filePath, body, { encoding: "utf8", mode: 384 });
+  try {
+    await fs3.chmod(filePath, 384);
+  } catch {
+  }
+  return { path: filePath, value };
+}
+
+// src/setup.ts
 var EDITOR_LABELS = {
   codex: "Codex CLI",
   claude: "Claude Code",
@@ -9435,6 +9633,9 @@ var EDITOR_LABELS = {
   roo: "Roo Code",
   aider: "Aider"
 };
+function supportsProjectMcpConfig(editor) {
+  return editor === "cursor" || editor === "claude" || editor === "kilo" || editor === "roo";
+}
 function normalizeInput(value) {
   return value.trim();
 }
@@ -9459,42 +9660,42 @@ function parseNumberList(input, max) {
 }
 async function fileExists(filePath) {
   try {
-    await fs3.stat(filePath);
+    await fs4.stat(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function upsertTextFile(filePath, content, marker) {
-  await fs3.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs4.mkdir(path6.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   if (!exists) {
-    await fs3.writeFile(filePath, content, "utf8");
+    await fs4.writeFile(filePath, content, "utf8");
     return "created";
   }
-  const existing = await fs3.readFile(filePath, "utf8").catch(() => "");
+  const existing = await fs4.readFile(filePath, "utf8").catch(() => "");
   if (existing.includes(marker)) return "skipped";
   const joined = existing.trimEnd() + "\n\n" + content.trim() + "\n";
-  await fs3.writeFile(filePath, joined, "utf8");
+  await fs4.writeFile(filePath, joined, "utf8");
   return "appended";
 }
 function globalRulesPathForEditor(editor) {
-  const home = homedir();
+  const home = homedir2();
   switch (editor) {
     case "codex":
-      return path5.join(home, ".codex", "AGENTS.md");
+      return path6.join(home, ".codex", "AGENTS.md");
     case "claude":
-      return path5.join(home, ".claude", "CLAUDE.md");
+      return path6.join(home, ".claude", "CLAUDE.md");
     case "windsurf":
-      return path5.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
+      return path6.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
     case "cline":
-      return path5.join(home, "Documents", "Cline", "Rules", "contextstream.md");
+      return path6.join(home, "Documents", "Cline", "Rules", "contextstream.md");
     case "kilo":
-      return path5.join(home, ".kilocode", "rules", "contextstream.md");
+      return path6.join(home, ".kilocode", "rules", "contextstream.md");
     case "roo":
-      return path5.join(home, ".roo", "rules", "contextstream.md");
+      return path6.join(home, ".roo", "rules", "contextstream.md");
     case "aider":
-      return path5.join(home, ".aider.conf.yml");
+      return path6.join(home, ".aider.conf.yml");
     case "cursor":
       return null;
     default:
@@ -9541,11 +9742,11 @@ function tryParseJsonLike(raw) {
   }
 }
 async function upsertJsonMcpConfig(filePath, server) {
-  await fs3.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs4.mkdir(path6.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs3.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs4.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -9555,16 +9756,16 @@ async function upsertJsonMcpConfig(filePath, server) {
   const before = JSON.stringify(root.mcpServers.contextstream ?? null);
   root.mcpServers.contextstream = server;
   const after = JSON.stringify(root.mcpServers.contextstream ?? null);
-  await fs3.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs4.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 async function upsertJsonVsCodeMcpConfig(filePath, server) {
-  await fs3.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs4.mkdir(path6.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs3.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs4.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -9574,25 +9775,25 @@ async function upsertJsonVsCodeMcpConfig(filePath, server) {
   const before = JSON.stringify(root.servers.contextstream ?? null);
   root.servers.contextstream = server;
   const after = JSON.stringify(root.servers.contextstream ?? null);
-  await fs3.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs4.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 function claudeDesktopConfigPath() {
-  const home = homedir();
+  const home = homedir2();
   if (process.platform === "darwin") {
-    return path5.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path6.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path5.join(home, "AppData", "Roaming");
-    return path5.join(appData, "Claude", "claude_desktop_config.json");
+    const appData = process.env.APPDATA || path6.join(home, "AppData", "Roaming");
+    return path6.join(appData, "Claude", "claude_desktop_config.json");
   }
   return null;
 }
 async function upsertCodexTomlConfig(filePath, params) {
-  await fs3.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs4.mkdir(path6.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
-  const existing = exists ? await fs3.readFile(filePath, "utf8").catch(() => "") : "";
+  const existing = exists ? await fs4.readFile(filePath, "utf8").catch(() => "") : "";
   const marker = "[mcp_servers.contextstream]";
   const envMarker = "[mcp_servers.contextstream.env]";
   const block = `
@@ -9607,15 +9808,15 @@ CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
 `;
   if (!exists) {
-    await fs3.writeFile(filePath, block.trimStart(), "utf8");
+    await fs4.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
   }
   if (!existing.includes(marker)) {
-    await fs3.writeFile(filePath, existing.trimEnd() + block, "utf8");
+    await fs4.writeFile(filePath, existing.trimEnd() + block, "utf8");
     return "updated";
   }
   if (!existing.includes(envMarker)) {
-    await fs3.writeFile(filePath, existing.trimEnd() + "\n\n" + envMarker + `
+    await fs4.writeFile(filePath, existing.trimEnd() + "\n\n" + envMarker + `
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
 `, "utf8");
@@ -9656,18 +9857,18 @@ CONTEXTSTREAM_API_KEY = "${params.apiKey}"
   }
   const updated = out.join("\n");
   if (updated === existing) return "skipped";
-  await fs3.writeFile(filePath, updated, "utf8");
+  await fs4.writeFile(filePath, updated, "utf8");
   return "updated";
 }
 async function discoverProjectsUnderFolder(parentFolder) {
-  const entries = await fs3.readdir(parentFolder, { withFileTypes: true });
-  const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path5.join(parentFolder, e.name));
+  const entries = await fs4.readdir(parentFolder, { withFileTypes: true });
+  const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path6.join(parentFolder, e.name));
   const projects = [];
   for (const dir of candidates) {
-    const hasGit = await fileExists(path5.join(dir, ".git"));
-    const hasPkg = await fileExists(path5.join(dir, "package.json"));
-    const hasCargo = await fileExists(path5.join(dir, "Cargo.toml"));
-    const hasPyProject = await fileExists(path5.join(dir, "pyproject.toml"));
+    const hasGit = await fileExists(path6.join(dir, ".git"));
+    const hasPkg = await fileExists(path6.join(dir, "package.json"));
+    const hasCargo = await fileExists(path6.join(dir, "Cargo.toml"));
+    const hasPyProject = await fileExists(path6.join(dir, "pyproject.toml"));
     if (hasGit || hasPkg || hasCargo || hasPyProject) projects.push(dir);
   }
   return projects;
@@ -9691,16 +9892,32 @@ async function runSetupWizard(args) {
     console.log("This configures ContextStream MCP + rules for your AI editor(s).");
     if (dryRun) console.log("DRY RUN: no files will be written.\n");
     else console.log("");
-    const apiUrlDefault = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    const apiUrl = normalizeInput(
-      await rl.question(`ContextStream API URL [${apiUrlDefault}]: `)
-    ) || apiUrlDefault;
+    const savedCreds = await readSavedCredentials();
+    const apiUrlDefault = normalizeApiUrl(process.env.CONTEXTSTREAM_API_URL || savedCreds?.api_url || "https://api.contextstream.io");
+    const apiUrl = normalizeApiUrl(
+      normalizeInput(await rl.question(`ContextStream API URL [${apiUrlDefault}]: `)) || apiUrlDefault
+    );
     let apiKey = normalizeInput(process.env.CONTEXTSTREAM_API_KEY || "");
+    let apiKeySource = apiKey ? "env" : "unknown";
     if (apiKey) {
       const confirm = normalizeInput(
         await rl.question(`Use CONTEXTSTREAM_API_KEY from environment (${maskApiKey(apiKey)})? [Y/n]: `)
       );
-      if (confirm.toLowerCase() === "n" || confirm.toLowerCase() === "no") apiKey = "";
+      if (confirm.toLowerCase() === "n" || confirm.toLowerCase() === "no") {
+        apiKey = "";
+        apiKeySource = "unknown";
+      }
+    }
+    if (!apiKey && savedCreds?.api_key && normalizeApiUrl(savedCreds.api_url) === apiUrl) {
+      const confirm = normalizeInput(
+        await rl.question(
+          `Use saved API key from ${credentialsFilePath()} (${maskApiKey(savedCreds.api_key)})? [Y/n]: `
+        )
+      );
+      if (!(confirm.toLowerCase() === "n" || confirm.toLowerCase() === "no")) {
+        apiKey = savedCreds.api_key;
+        apiKeySource = "saved";
+      }
     }
     if (!apiKey) {
       console.log("\nAuthentication:");
@@ -9711,6 +9928,7 @@ async function runSetupWizard(args) {
         console.log("\nYou need a ContextStream API key to continue.");
         console.log("Create one here (then paste it): https://app.contextstream.io/settings/api-keys\n");
         apiKey = normalizeInput(await rl.question("CONTEXTSTREAM_API_KEY: "));
+        apiKeySource = "paste";
       } else {
         const anonClient = new ContextStreamClient(buildClientConfig({ apiUrl }));
         let device;
@@ -9773,6 +9991,7 @@ Code: ${device.user_code}`);
           throw new Error("API key creation returned an unexpected response.");
         }
         apiKey = createdKey.secret_key.trim();
+        apiKeySource = "browser";
         console.log(`
 Created API key: ${maskApiKey(apiKey)}
 `);
@@ -9789,6 +10008,17 @@ Created API key: ${maskApiKey(apiKey)}
     const email = typeof me?.data?.email === "string" ? me.data.email : typeof me?.email === "string" ? me.email : void 0;
     console.log(`Authenticated as: ${email || "unknown user"} (${maskApiKey(apiKey)})
 `);
+    if (!dryRun && (apiKeySource === "browser" || apiKeySource === "paste")) {
+      try {
+        const saved = await writeSavedCredentials({ apiUrl, apiKey, email });
+        console.log(`Saved API key for future runs: ${saved.path} (${maskApiKey(apiKey)})
+`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`Warning: failed to save API key for future runs (${credentialsFilePath()}): ${msg}
+`);
+      }
+    }
     let workspaceId;
     let workspaceName;
     console.log("Workspace setup:");
@@ -9851,6 +10081,8 @@ Created API key: ${maskApiKey(apiKey)}
     const selectedRaw = normalizeInput(await rl.question("Editors [all]: ")) || "all";
     const selectedNums = parseNumberList(selectedRaw, editors.length);
     const selectedEditors = selectedNums.length ? selectedNums.map((n) => editors[n - 1]) : editors;
+    const hasCodex = selectedEditors.includes("codex");
+    const hasProjectMcpEditors = selectedEditors.some((e) => supportsProjectMcpConfig(e));
     console.log("\nInstall rules as:");
     console.log("  1) Global");
     console.log("  2) Project");
@@ -9858,20 +10090,31 @@ Created API key: ${maskApiKey(apiKey)}
     const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 3): ")) || "3";
     const scope = scopeChoice === "1" ? "global" : scopeChoice === "2" ? "project" : "both";
     console.log("\nInstall MCP server config as:");
-    console.log("  1) Global");
-    console.log("  2) Project");
-    console.log("  3) Both");
-    console.log("  4) Skip (rules only)");
-    const mcpChoice = normalizeInput(await rl.question("Choose [1/2/3/4] (default 3): ")) || "3";
-    const mcpScope = mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
+    if (hasCodex && !hasProjectMcpEditors) {
+      console.log("  1) Global (Codex CLI supports global config only)");
+      console.log("  2) Skip (rules only)");
+    } else {
+      console.log("  1) Global");
+      console.log("  2) Project");
+      console.log("  3) Both");
+      console.log("  4) Skip (rules only)");
+      if (hasCodex) {
+        console.log("  Note: Codex CLI does not support per-project MCP config; it will be configured globally if selected.");
+      }
+    }
+    const mcpChoiceDefault = hasCodex && !hasProjectMcpEditors ? "1" : "3";
+    const mcpChoice = normalizeInput(await rl.question(`Choose [${hasCodex && !hasProjectMcpEditors ? "1/2" : "1/2/3/4"}] (default ${mcpChoiceDefault}): `)) || mcpChoiceDefault;
+    const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
     const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey });
     const vsCodeServer = buildContextStreamVsCodeServer({ apiUrl, apiKey });
-    if (mcpScope === "global" || mcpScope === "both") {
+    const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
+    if (needsGlobalMcpConfig) {
       console.log("\nInstalling global MCP config...");
       for (const editor of selectedEditors) {
+        if (mcpScope === "project" && editor !== "codex") continue;
         try {
           if (editor === "codex") {
-            const filePath = path5.join(homedir(), ".codex", "config.toml");
+            const filePath = path6.join(homedir2(), ".codex", "config.toml");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -9883,7 +10126,7 @@ Created API key: ${maskApiKey(apiKey)}
             continue;
           }
           if (editor === "windsurf") {
-            const filePath = path5.join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+            const filePath = path6.join(homedir2(), ".codeium", "windsurf", "mcp_config.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -9915,7 +10158,7 @@ Created API key: ${maskApiKey(apiKey)}
             continue;
           }
           if (editor === "cursor") {
-            const filePath = path5.join(homedir(), ".cursor", "mcp.json");
+            const filePath = path6.join(homedir2(), ".cursor", "mcp.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -9969,12 +10212,12 @@ Created API key: ${maskApiKey(apiKey)}
       }
     }
     const projectPaths = /* @__PURE__ */ new Set();
-    const needsProjects = scope === "project" || scope === "both" || mcpScope === "project" || mcpScope === "both";
+    const needsProjects = scope === "project" || scope === "both" || (mcpScope === "project" || mcpScope === "both") && hasProjectMcpEditors;
     if (needsProjects) {
       console.log("\nProject setup...");
       const addCwd = normalizeInput(await rl.question(`Add current folder as a project? [Y/n] (${process.cwd()}): `));
       if (addCwd.toLowerCase() !== "n" && addCwd.toLowerCase() !== "no") {
-        projectPaths.add(path5.resolve(process.cwd()));
+        projectPaths.add(path6.resolve(process.cwd()));
       }
       while (true) {
         console.log("\n  1) Add another project path");
@@ -9984,13 +10227,13 @@ Created API key: ${maskApiKey(apiKey)}
         if (choice === "3") break;
         if (choice === "1") {
           const p = normalizeInput(await rl.question("Project folder path: "));
-          if (p) projectPaths.add(path5.resolve(p));
+          if (p) projectPaths.add(path6.resolve(p));
           continue;
         }
         if (choice === "2") {
           const parent = normalizeInput(await rl.question("Parent folder path: "));
           if (!parent) continue;
-          const parentAbs = path5.resolve(parent);
+          const parentAbs = path6.resolve(parent);
           const projects2 = await discoverProjectsUnderFolder(parentAbs);
           if (projects2.length === 0) {
             console.log(`No projects detected under ${parentAbs} (looked for .git/package.json/Cargo.toml/pyproject.toml).`);
@@ -10020,21 +10263,21 @@ Applying to ${projects.length} project(s)...`);
             workspace_name: workspaceName,
             create_parent_mapping: createParentMapping
           });
-          writeActions.push({ kind: "workspace-config", target: path5.join(projectPath, ".contextstream", "config.json"), status: "created" });
+          writeActions.push({ kind: "workspace-config", target: path6.join(projectPath, ".contextstream", "config.json"), status: "created" });
           console.log(`- Linked workspace in ${projectPath}`);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           console.log(`- Failed to link workspace in ${projectPath}: ${message}`);
         }
       } else if (workspaceId && workspaceId !== "dry-run" && workspaceName && dryRun) {
-        writeActions.push({ kind: "workspace-config", target: path5.join(projectPath, ".contextstream", "config.json"), status: "dry-run" });
+        writeActions.push({ kind: "workspace-config", target: path6.join(projectPath, ".contextstream", "config.json"), status: "dry-run" });
       }
       if (mcpScope === "project" || mcpScope === "both") {
         for (const editor of selectedEditors) {
           try {
             if (editor === "cursor") {
-              const cursorPath = path5.join(projectPath, ".cursor", "mcp.json");
-              const vscodePath = path5.join(projectPath, ".vscode", "mcp.json");
+              const cursorPath = path6.join(projectPath, ".cursor", "mcp.json");
+              const vscodePath = path6.join(projectPath, ".vscode", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: cursorPath, status: "dry-run" });
                 writeActions.push({ kind: "mcp-config", target: vscodePath, status: "dry-run" });
@@ -10047,7 +10290,7 @@ Applying to ${projects.length} project(s)...`);
               continue;
             }
             if (editor === "claude") {
-              const mcpPath = path5.join(projectPath, ".mcp.json");
+              const mcpPath = path6.join(projectPath, ".mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: mcpPath, status: "dry-run" });
               } else {
@@ -10057,7 +10300,7 @@ Applying to ${projects.length} project(s)...`);
               continue;
             }
             if (editor === "kilo") {
-              const kiloPath = path5.join(projectPath, ".kilocode", "mcp.json");
+              const kiloPath = path6.join(projectPath, ".kilocode", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: kiloPath, status: "dry-run" });
               } else {
@@ -10067,7 +10310,7 @@ Applying to ${projects.length} project(s)...`);
               continue;
             }
             if (editor === "roo") {
-              const rooPath = path5.join(projectPath, ".roo", "mcp.json");
+              const rooPath = path6.join(projectPath, ".roo", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: rooPath, status: "dry-run" });
               } else {
@@ -10087,11 +10330,11 @@ Applying to ${projects.length} project(s)...`);
         const rule = generateRuleContent(editor, {
           workspaceName,
           workspaceId: workspaceId && workspaceId !== "dry-run" ? workspaceId : void 0,
-          projectName: path5.basename(projectPath),
+          projectName: path6.basename(projectPath),
           mode
         });
         if (!rule) continue;
-        const filePath = path5.join(projectPath, rule.filename);
+        const filePath = path6.join(projectPath, rule.filename);
         if (dryRun) {
           writeActions.push({ kind: "rules", target: filePath, status: "dry-run" });
           continue;
@@ -10124,8 +10367,8 @@ Applying to ${projects.length} project(s)...`);
 
 // src/index.ts
 function showFirstRunMessage() {
-  const configDir = join5(homedir2(), ".contextstream");
-  const starShownFile = join5(configDir, ".star-shown");
+  const configDir = join6(homedir3(), ".contextstream");
+  const starShownFile = join6(configDir, ".star-shown");
   if (existsSync2(starShownFile)) {
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextstream/mcp-server",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",