@glasstrace/sdk 0.11.0 → 0.12.1

package/dist/cli/init.cjs

@@ -14845,16 +14845,33 @@ var init_dist = __esm({
 });
 
 // src/anon-key.ts
+async function loadFsPath() {
+  if (fsPathCache !== void 0) return fsPathCache;
+  try {
+    const [fs7, path7] = await Promise.all([
+      import("fs/promises"),
+      import("path")
+    ]);
+    fsPathCache = { fs: fs7, path: path7 };
+    return fsPathCache;
+  } catch {
+    fsPathCache = null;
+    return null;
+  }
+}
 async function readAnonKey(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const keyPath = (0, import_node_path.join)(root, GLASSTRACE_DIR, ANON_KEY_FILE);
-  try {
-    const content = await (0, import_promises.readFile)(keyPath, "utf-8");
-    const result = AnonApiKeySchema.safeParse(content);
-    if (result.success) {
-      return result.data;
+  const modules = await loadFsPath();
+  if (modules) {
+    const keyPath = modules.path.join(root, GLASSTRACE_DIR, ANON_KEY_FILE);
+    try {
+      const content = await modules.fs.readFile(keyPath, "utf-8");
+      const result = AnonApiKeySchema.safeParse(content);
+      if (result.success) {
+        return result.data;
+      }
+    } catch {
     }
-  } catch {
   }
   const cached2 = ephemeralKeyCache.get(root);
   if (cached2 !== void 0) {
@@ -14864,8 +14881,6 @@ async function readAnonKey(projectRoot) {
 }
 async function getOrCreateAnonKey(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const dirPath = (0, import_node_path.join)(root, GLASSTRACE_DIR);
-  const keyPath = (0, import_node_path.join)(dirPath, ANON_KEY_FILE);
   const existingKey = await readAnonKey(root);
   if (existingKey !== null) {
     return existingKey;
@@ -14875,9 +14890,16 @@ async function getOrCreateAnonKey(projectRoot) {
     return cached2;
   }
   const newKey = createAnonApiKey();
+  const modules = await loadFsPath();
+  if (!modules) {
+    ephemeralKeyCache.set(root, newKey);
+    return newKey;
+  }
+  const dirPath = modules.path.join(root, GLASSTRACE_DIR);
+  const keyPath = modules.path.join(dirPath, ANON_KEY_FILE);
   try {
-    await (0, import_promises.mkdir)(dirPath, { recursive: true, mode: 448 });
-    await (0, import_promises.writeFile)(keyPath, newKey, { flag: "wx", mode: 384 });
+    await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+    await modules.fs.writeFile(keyPath, newKey, { flag: "wx", mode: 384 });
     return newKey;
   } catch (err) {
     const code = err.code;
@@ -14892,8 +14914,8 @@ async function getOrCreateAnonKey(projectRoot) {
         }
       }
       try {
-        await (0, import_promises.writeFile)(keyPath, newKey, { mode: 384 });
-        await (0, import_promises.chmod)(keyPath, 384);
+        await modules.fs.writeFile(keyPath, newKey, { mode: 384 });
+        await modules.fs.chmod(keyPath, 384);
         return newKey;
       } catch {
       }
@@ -14905,12 +14927,10 @@ async function getOrCreateAnonKey(projectRoot) {
     return newKey;
   }
 }
-var import_promises, import_node_path, GLASSTRACE_DIR, ANON_KEY_FILE, ephemeralKeyCache;
+var GLASSTRACE_DIR, ANON_KEY_FILE, fsPathCache, ephemeralKeyCache;
 var init_anon_key = __esm({
   "src/anon-key.ts"() {
     "use strict";
-    import_promises = require("fs/promises");
-    import_node_path = require("path");
     init_dist();
     GLASSTRACE_DIR = ".glasstrace";
     ANON_KEY_FILE = "anon_key";
@@ -14921,25 +14941,25 @@ var init_anon_key = __esm({
 // src/agent-detection/detect.ts
 async function pathExists(path7, mode = import_node_fs.constants.R_OK) {
   try {
-    await (0, import_promises2.access)(path7, mode);
+    await (0, import_promises.access)(path7, mode);
     return true;
   } catch {
     return false;
   }
 }
 async function findGitRoot(startDir) {
-  let current = (0, import_node_path2.resolve)(startDir);
+  let current = (0, import_node_path.resolve)(startDir);
   while (true) {
-    if (await pathExists((0, import_node_path2.join)(current, ".git"), import_node_fs.constants.F_OK)) {
+    if (await pathExists((0, import_node_path.join)(current, ".git"), import_node_fs.constants.F_OK)) {
       return current;
     }
-    const parent = (0, import_node_path2.dirname)(current);
+    const parent = (0, import_node_path.dirname)(current);
     if (parent === current) {
       break;
     }
     current = parent;
   }
-  return (0, import_node_path2.resolve)(startDir);
+  return (0, import_node_path.resolve)(startDir);
 }
 function isCliAvailable(binary) {
   return new Promise((resolve2) => {
@@ -14950,10 +14970,10 @@ function isCliAvailable(binary) {
   });
 }
 async function detectAgents(projectRoot) {
-  const resolvedRoot = (0, import_node_path2.resolve)(projectRoot);
+  const resolvedRoot = (0, import_node_path.resolve)(projectRoot);
   let rootStat;
   try {
-    rootStat = await (0, import_promises2.stat)(resolvedRoot);
+    rootStat = await (0, import_promises.stat)(resolvedRoot);
   } catch (err) {
     const code = err.code;
     throw new Error(
@@ -14971,7 +14991,7 @@ async function detectAgents(projectRoot) {
     if (current === gitRoot) {
       break;
     }
-    const parent = (0, import_node_path2.dirname)(current);
+    const parent = (0, import_node_path.dirname)(current);
     if (parent === current) {
       break;
     }
@@ -14984,7 +15004,7 @@ async function detectAgents(projectRoot) {
     for (const dir of searchDirs) {
       let markerFound = false;
       for (const marker of rule.markers) {
-        if (await pathExists((0, import_node_path2.join)(dir, marker))) {
+        if (await pathExists((0, import_node_path.join)(dir, marker))) {
           markerFound = true;
           break;
         }
@@ -15016,43 +15036,43 @@ async function detectAgents(projectRoot) {
   }
   detected.push({
     name: "generic",
-    mcpConfigPath: (0, import_node_path2.join)(resolvedRoot, ".glasstrace", "mcp.json"),
+    mcpConfigPath: (0, import_node_path.join)(resolvedRoot, ".glasstrace", "mcp.json"),
     infoFilePath: null,
     cliAvailable: false,
     registrationCommand: null
   });
   return detected;
 }
-var import_node_child_process, import_promises2, import_node_path2, import_node_os, import_node_fs, AGENT_RULES;
+var import_node_child_process, import_promises, import_node_path, import_node_os, import_node_fs, AGENT_RULES;
 var init_detect = __esm({
   "src/agent-detection/detect.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
-    import_promises2 = require("fs/promises");
-    import_node_path2 = require("path");
+    import_promises = require("fs/promises");
+    import_node_path = require("path");
     import_node_os = require("os");
     import_node_fs = require("fs");
     AGENT_RULES = [
       {
         name: "claude",
         markers: [".claude", "CLAUDE.md"],
-        mcpConfigPath: (dir) => (0, import_node_path2.join)(dir, ".mcp.json"),
-        infoFilePath: (dir) => (0, import_node_path2.join)(dir, "CLAUDE.md"),
+        mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".mcp.json"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, "CLAUDE.md"),
         cliBinary: "claude",
         registrationCommand: "npx glasstrace mcp add --agent claude"
       },
       {
         name: "codex",
         markers: ["codex.md", ".codex"],
-        mcpConfigPath: (dir) => (0, import_node_path2.join)(dir, ".codex", "config.toml"),
-        infoFilePath: (dir) => (0, import_node_path2.join)(dir, "codex.md"),
+        mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".codex", "config.toml"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, "codex.md"),
         cliBinary: "codex",
         registrationCommand: "npx glasstrace mcp add --agent codex"
       },
       {
         name: "gemini",
         markers: [".gemini"],
-        mcpConfigPath: (dir) => (0, import_node_path2.join)(dir, ".gemini", "settings.json"),
+        mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".gemini", "settings.json"),
         infoFilePath: () => null,
         cliBinary: "gemini",
         registrationCommand: "npx glasstrace mcp add --agent gemini"
@@ -15060,16 +15080,16 @@ var init_detect = __esm({
       {
         name: "cursor",
         markers: [".cursor", ".cursorrules"],
-        mcpConfigPath: (dir) => (0, import_node_path2.join)(dir, ".cursor", "mcp.json"),
-        infoFilePath: (dir) => (0, import_node_path2.join)(dir, ".cursorrules"),
+        mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".cursor", "mcp.json"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, ".cursorrules"),
         cliBinary: null,
         registrationCommand: "npx glasstrace mcp add --agent cursor"
       },
       {
         name: "windsurf",
         markers: [".windsurfrules", ".windsurf"],
-        mcpConfigPath: () => (0, import_node_path2.join)((0, import_node_os.homedir)(), ".codeium", "windsurf", "mcp_config.json"),
-        infoFilePath: (dir) => (0, import_node_path2.join)(dir, ".windsurfrules"),
+        mcpConfigPath: () => (0, import_node_path.join)((0, import_node_os.homedir)(), ".codeium", "windsurf", "mcp_config.json"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, ".windsurfrules"),
         cliBinary: null,
         registrationCommand: "npx glasstrace mcp add --agent windsurf"
       }
@@ -15254,9 +15274,9 @@ async function writeMcpConfig(agent, content, projectRoot) {
     return;
   }
   const configPath = agent.mcpConfigPath;
-  const parentDir = (0, import_node_path3.dirname)(configPath);
+  const parentDir = (0, import_node_path2.dirname)(configPath);
   try {
-    await (0, import_promises3.mkdir)(parentDir, { recursive: true });
+    await (0, import_promises2.mkdir)(parentDir, { recursive: true });
   } catch (err) {
     if (isPermissionError(err)) {
       process.stderr.write(
@@ -15268,7 +15288,7 @@ async function writeMcpConfig(agent, content, projectRoot) {
     throw err;
   }
   try {
-    await (0, import_promises3.writeFile)(configPath, content, { mode: 384 });
+    await (0, import_promises2.writeFile)(configPath, content, { mode: 384 });
   } catch (err) {
     if (isPermissionError(err)) {
       process.stderr.write(
@@ -15280,7 +15300,7 @@ async function writeMcpConfig(agent, content, projectRoot) {
     throw err;
   }
   try {
-    await (0, import_promises3.chmod)(configPath, 384);
+    await (0, import_promises2.chmod)(configPath, 384);
   } catch {
   }
 }
@@ -15313,7 +15333,7 @@ async function injectInfoSection(agent, content, projectRoot) {
   const filePath = agent.infoFilePath;
   let existingContent = null;
   try {
-    existingContent = await (0, import_promises3.readFile)(filePath, "utf-8");
+    existingContent = await (0, import_promises2.readFile)(filePath, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") {
@@ -15329,8 +15349,8 @@ async function injectInfoSection(agent, content, projectRoot) {
   }
   if (existingContent === null) {
     try {
-      await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(filePath), { recursive: true });
-      await (0, import_promises3.writeFile)(filePath, content, "utf-8");
+      await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(filePath), { recursive: true });
+      await (0, import_promises2.writeFile)(filePath, content, "utf-8");
     } catch (err) {
       if (isPermissionError(err)) {
         process.stderr.write(
@@ -15356,7 +15376,7 @@ async function injectInfoSection(agent, content, projectRoot) {
     newContent = existingContent + separator + content;
   }
   try {
-    await (0, import_promises3.writeFile)(filePath, newContent, "utf-8");
+    await (0, import_promises2.writeFile)(filePath, newContent, "utf-8");
   } catch (err) {
     if (isPermissionError(err)) {
       process.stderr.write(
@@ -15369,14 +15389,14 @@ async function injectInfoSection(agent, content, projectRoot) {
   }
 }
 async function updateGitignore(paths, projectRoot) {
-  const gitignorePath = (0, import_node_path3.join)(projectRoot, ".gitignore");
-  const relativePaths = paths.filter((p) => !(0, import_node_path3.isAbsolute)(p));
+  const gitignorePath = (0, import_node_path2.join)(projectRoot, ".gitignore");
+  const relativePaths = paths.filter((p) => !(0, import_node_path2.isAbsolute)(p));
   if (relativePaths.length === 0) {
     return;
   }
   let existingContent = "";
   try {
-    existingContent = await (0, import_promises3.readFile)(gitignorePath, "utf-8");
+    existingContent = await (0, import_promises2.readFile)(gitignorePath, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") {
@@ -15402,7 +15422,7 @@ async function updateGitignore(paths, projectRoot) {
   }
   updatedContent += toAdd.join("\n") + "\n";
   try {
-    await (0, import_promises3.writeFile)(gitignorePath, updatedContent, "utf-8");
+    await (0, import_promises2.writeFile)(gitignorePath, updatedContent, "utf-8");
   } catch (err) {
     if (isPermissionError(err)) {
       process.stderr.write(
@@ -15414,12 +15434,12 @@ async function updateGitignore(paths, projectRoot) {
     throw err;
   }
 }
-var import_promises3, import_node_path3, HTML_START, HTML_END, HASH_START, HASH_END;
+var import_promises2, import_node_path2, HTML_START, HTML_END, HASH_START, HASH_END;
 var init_inject = __esm({
   "src/agent-detection/inject.ts"() {
     "use strict";
-    import_promises3 = require("fs/promises");
-    import_node_path3 = require("path");
+    import_promises2 = require("fs/promises");
+    import_node_path2 = require("path");
     HTML_START = "<!-- glasstrace:mcp:start -->";
     HTML_END = "<!-- glasstrace:mcp:end -->";
     HASH_START = "# glasstrace:mcp:start";
@@ -15427,236 +15447,6 @@ var init_inject = __esm({
   }
 });
 
-// src/cli/mcp-add.ts
-var mcp_add_exports = {};
-__export(mcp_add_exports, {
-  mcpAdd: () => mcpAdd
-});
-async function registerViaCli(agent, anonKey) {
-  if (!agent.cliAvailable) {
-    return false;
-  }
-  try {
-    switch (agent.name) {
-      case "claude": {
-        const payload = JSON.stringify({
-          type: "http",
-          url: MCP_ENDPOINT,
-          headers: { Authorization: `Bearer ${anonKey}` }
-        });
-        await execFileAsync("claude", [
-          "mcp",
-          "add-json",
-          "glasstrace",
-          payload,
-          "--scope",
-          "project"
-        ]);
-        return true;
-      }
-      case "codex": {
-        await execFileAsync("codex", [
-          "mcp",
-          "add",
-          "glasstrace",
-          "--url",
-          MCP_ENDPOINT
-        ]);
-        const configPath = agent.mcpConfigPath;
-        if (configPath !== null && fs4.existsSync(configPath)) {
-          const content = fs4.readFileSync(configPath, "utf-8");
-          if (!content.includes("bearer_token_env_var")) {
-            const appendContent = content.endsWith("\n") ? "" : "\n";
-            fs4.writeFileSync(
-              configPath,
-              content + appendContent + 'bearer_token_env_var = "GLASSTRACE_API_KEY"\n',
-              "utf-8"
-            );
-          }
-        }
-        process.stderr.write(
-          "  Note: Set GLASSTRACE_API_KEY environment variable for Codex authentication.\n"
-        );
-        return true;
-      }
-      case "gemini": {
-        await execFileAsync("gemini", [
-          "mcp",
-          "add",
-          "--transport",
-          "http",
-          "--header",
-          `Authorization: Bearer ${anonKey}`,
-          "glasstrace",
-          MCP_ENDPOINT
-        ]);
-        return true;
-      }
-      default:
-        return false;
-    }
-  } catch {
-    return false;
-  }
-}
-async function mcpAdd(options) {
-  const force = options?.force ?? false;
-  const dryRun = options?.dryRun ?? false;
-  const projectRoot = process.cwd();
-  const messages = [];
-  const anonKey = await readAnonKey(projectRoot);
-  if (anonKey === null) {
-    return {
-      exitCode: 1,
-      results: [],
-      messages: ["Error: Run `glasstrace init` first to generate an API key."]
-    };
-  }
-  const markerPath = path4.join(projectRoot, ".glasstrace", "mcp-connected");
-  if (fs4.existsSync(markerPath) && !force) {
-    return {
-      exitCode: 0,
-      results: [],
-      messages: ["MCP already configured. Use --force to reconfigure."]
-    };
-  }
-  const agents = await detectAgents(projectRoot);
-  const detectedNonGeneric = agents.filter((a) => a.name !== "generic");
-  const targetAgents = detectedNonGeneric.length > 0 ? detectedNonGeneric : agents.filter((a) => a.name === "generic");
-  if (dryRun) {
-    messages.push("Dry run: would perform the following actions:", "");
-    for (const agent of targetAgents) {
-      const name = formatAgentName(agent.name);
-      if (agent.cliAvailable) {
-        messages.push(
-          `  ${name}: Register via CLI (${agent.name} mcp add)`
-        );
-      } else if (agent.mcpConfigPath !== null) {
-        messages.push(
-          `  ${name}: Write config to ${agent.mcpConfigPath}`
-        );
-      }
-      if (agent.infoFilePath !== null) {
-        messages.push(
-          `  ${name}: Inject info section into ${agent.infoFilePath}`
-        );
-      }
-    }
-    messages.push(
-      "",
-      "  Update .gitignore with MCP config paths",
-      "  Create .glasstrace/mcp-connected marker"
-    );
-    return { exitCode: 0, results: [], messages };
-  }
-  const results = [];
-  for (const agent of targetAgents) {
-    const name = formatAgentName(agent.name);
-    if (agent.name !== "generic") {
-      const cliSuccess = await registerViaCli(agent, anonKey);
-      if (cliSuccess) {
-        const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
-        if (infoContent !== "") {
-          await injectInfoSection(agent, infoContent, projectRoot);
-        }
-        results.push({
-          agent: agent.name,
-          success: true,
-          method: "cli",
-          message: `${name}: Registered via CLI`
-        });
-        continue;
-      }
-    }
-    if (agent.mcpConfigPath !== null) {
-      try {
-        const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
-        await writeMcpConfig(agent, configContent, projectRoot);
-        if (fs4.existsSync(agent.mcpConfigPath)) {
-          const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
-          if (infoContent !== "") {
-            await injectInfoSection(agent, infoContent, projectRoot);
-          }
-          results.push({
-            agent: agent.name,
-            success: true,
-            method: "file",
-            message: `${name}: Configured via ${agent.mcpConfigPath}`
-          });
-          continue;
-        }
-        results.push({
-          agent: agent.name,
-          success: false,
-          method: "file",
-          message: `${name}: Failed to write config to ${agent.mcpConfigPath} (permission denied)`
-        });
-        continue;
-      } catch (err) {
-        results.push({
-          agent: agent.name,
-          success: false,
-          method: "file",
-          message: `${name}: Failed - ${err instanceof Error ? err.message : String(err)}`
-        });
-        continue;
-      }
-    }
-    results.push({
-      agent: agent.name,
-      success: false,
-      method: "skipped",
-      message: `${name}: No registration method available`
-    });
-  }
-  await updateGitignore(
-    [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".codex/config.toml"],
-    projectRoot
-  );
-  const anySuccess = results.some((r) => r.success);
-  if (anySuccess) {
-    await scaffoldMcpMarker(projectRoot, anonKey);
-  }
-  messages.push("", "MCP registration summary:");
-  for (const result of results) {
-    const icon = result.success ? "+" : "-";
-    messages.push(`  [${icon}] ${result.message}`);
-  }
-  if (results.length === 0) {
-    messages.push(
-      "  No agents detected. Place agent marker files (e.g., CLAUDE.md, .cursor/) in your project."
-    );
-  }
-  if (!anySuccess && results.length > 0) {
-    messages.push(
-      "",
-      "All agent registrations failed. Check errors above."
-    );
-    return { exitCode: 1, results, messages };
-  }
-  if (anySuccess) {
-    messages.push("", "MCP registration complete.");
-  }
-  return { exitCode: 0, results, messages };
-}
-var import_node_child_process2, fs4, path4, import_node_util, execFileAsync;
-var init_mcp_add = __esm({
-  "src/cli/mcp-add.ts"() {
-    "use strict";
-    import_node_child_process2 = require("child_process");
-    fs4 = __toESM(require("fs"), 1);
-    path4 = __toESM(require("path"), 1);
-    import_node_util = require("util");
-    init_anon_key();
-    init_detect();
-    init_configs();
-    init_inject();
-    init_scaffolder();
-    init_constants();
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
-  }
-});
-
 // src/cli/uninit.ts
 var uninit_exports = {};
 __export(uninit_exports, {
@@ -15981,11 +15771,11 @@ async function runUninit(options) {
   try {
     let configHandled = false;
     for (const name of NEXT_CONFIG_NAMES) {
-      const configPath = path5.join(projectRoot, name);
-      if (!fs5.existsSync(configPath)) {
+      const configPath = path4.join(projectRoot, name);
+      if (!fs4.existsSync(configPath)) {
         continue;
       }
-      const content = fs5.readFileSync(configPath, "utf-8");
+      const content = fs4.readFileSync(configPath, "utf-8");
       if (!content.includes("withGlasstraceConfig")) {
         continue;
       }
@@ -15995,7 +15785,7 @@ async function runUninit(options) {
         const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
         const final = cleanLeadingBlankLines(cleaned);
         if (!dryRun) {
-          fs5.writeFileSync(configPath, final, "utf-8");
+          fs4.writeFileSync(configPath, final, "utf-8");
         }
         summary.push(`${prefix}Unwrapped withGlasstraceConfig from ${name}`);
         configHandled = true;
@@ -16016,20 +15806,20 @@ async function runUninit(options) {
     );
   }
   try {
-    const instrPath = path5.join(projectRoot, "instrumentation.ts");
-    if (fs5.existsSync(instrPath)) {
-      const content = fs5.readFileSync(instrPath, "utf-8");
+    const instrPath = path4.join(projectRoot, "instrumentation.ts");
+    if (fs4.existsSync(instrPath)) {
+      const content = fs4.readFileSync(instrPath, "utf-8");
       if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
         if (isInitCreatedInstrumentation(content)) {
           if (!dryRun) {
-            fs5.unlinkSync(instrPath);
+            fs4.unlinkSync(instrPath);
           }
           summary.push(`${prefix}Deleted instrumentation.ts (init-created)`);
         } else {
           const cleaned = removeRegisterGlasstrace(content);
           if (cleaned !== content) {
             if (!dryRun) {
-              fs5.writeFileSync(instrPath, cleaned, "utf-8");
+              fs4.writeFileSync(instrPath, cleaned, "utf-8");
             }
             summary.push(
               `${prefix}Removed registerGlasstrace() from instrumentation.ts`
@@ -16044,10 +15834,10 @@ async function runUninit(options) {
     );
   }
   try {
-    const glasstraceDir = path5.join(projectRoot, ".glasstrace");
-    if (fs5.existsSync(glasstraceDir)) {
+    const glasstraceDir = path4.join(projectRoot, ".glasstrace");
+    if (fs4.existsSync(glasstraceDir)) {
       if (!dryRun) {
-        fs5.rmSync(glasstraceDir, { recursive: true, force: true });
+        fs4.rmSync(glasstraceDir, { recursive: true, force: true });
       }
       summary.push(`${prefix}Removed .glasstrace/ directory`);
     }
@@ -16057,9 +15847,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const envPath = path5.join(projectRoot, ".env.local");
-    if (fs5.existsSync(envPath)) {
-      const content = fs5.readFileSync(envPath, "utf-8");
+    const envPath = path4.join(projectRoot, ".env.local");
+    if (fs4.existsSync(envPath)) {
+      const content = fs4.readFileSync(envPath, "utf-8");
       const lines = content.split("\n");
       const filtered = lines.filter((line) => {
         const trimmed = line.trim();
@@ -16069,12 +15859,12 @@ async function runUninit(options) {
         const result = filtered.join("\n");
         if (result.trim().length === 0) {
           if (!dryRun) {
-            fs5.unlinkSync(envPath);
+            fs4.unlinkSync(envPath);
           }
           summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
         } else {
           if (!dryRun) {
-            fs5.writeFileSync(envPath, result, "utf-8");
+            fs4.writeFileSync(envPath, result, "utf-8");
           }
           summary.push(`${prefix}Removed GLASSTRACE entries from .env.local`);
         }
@@ -16086,9 +15876,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const gitignorePath = path5.join(projectRoot, ".gitignore");
-    if (fs5.existsSync(gitignorePath)) {
-      const content = fs5.readFileSync(gitignorePath, "utf-8");
+    const gitignorePath = path4.join(projectRoot, ".gitignore");
+    if (fs4.existsSync(gitignorePath)) {
+      const content = fs4.readFileSync(gitignorePath, "utf-8");
       const lines = content.split("\n");
       const mcpGitignoreEntries = /* @__PURE__ */ new Set([
         ".glasstrace/",
@@ -16104,12 +15894,12 @@ async function runUninit(options) {
         const result = filtered.join("\n");
         if (result.trim().length === 0) {
           if (!dryRun) {
-            fs5.unlinkSync(gitignorePath);
+            fs4.unlinkSync(gitignorePath);
           }
           summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
         } else {
           if (!dryRun) {
-            fs5.writeFileSync(gitignorePath, result, "utf-8");
+            fs4.writeFileSync(gitignorePath, result, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace entries from .gitignore`);
         }
@@ -16122,63 +15912,63 @@ async function runUninit(options) {
   }
   try {
     for (const configFile of MCP_CONFIG_FILES) {
-      const configPath = path5.join(projectRoot, configFile);
-      if (!fs5.existsSync(configPath)) {
+      const configPath = path4.join(projectRoot, configFile);
+      if (!fs4.existsSync(configPath)) {
         continue;
       }
-      const content = fs5.readFileSync(configPath, "utf-8");
+      const content = fs4.readFileSync(configPath, "utf-8");
       const result = processJsonMcpConfig(content);
       if (result.action === "deleted") {
         if (!dryRun) {
-          fs5.unlinkSync(configPath);
+          fs4.unlinkSync(configPath);
         }
         summary.push(`${prefix}Deleted ${configFile}`);
       } else if (result.action === "removed-key" && result.content !== void 0) {
         if (!dryRun) {
-          fs5.writeFileSync(configPath, result.content, "utf-8");
+          fs4.writeFileSync(configPath, result.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from ${configFile}`);
       }
     }
-    const codexConfigPath = path5.join(projectRoot, ".codex", "config.toml");
-    if (fs5.existsSync(codexConfigPath)) {
-      const content = fs5.readFileSync(codexConfigPath, "utf-8");
+    const codexConfigPath = path4.join(projectRoot, ".codex", "config.toml");
+    if (fs4.existsSync(codexConfigPath)) {
+      const content = fs4.readFileSync(codexConfigPath, "utf-8");
       const tomlResult = processTomlMcpConfig(content);
       if (tomlResult.action === "deleted") {
         if (!dryRun) {
-          fs5.unlinkSync(codexConfigPath);
+          fs4.unlinkSync(codexConfigPath);
         }
         summary.push(`${prefix}Deleted .codex/config.toml`);
       } else if (tomlResult.action === "removed-section" && tomlResult.content !== void 0) {
         if (!dryRun) {
-          fs5.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
+          fs4.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from .codex/config.toml`);
       }
     }
-    const hasWindsurfMarkers = fs5.existsSync(path5.join(projectRoot, ".windsurfrules")) || fs5.existsSync(path5.join(projectRoot, ".windsurf"));
+    const hasWindsurfMarkers = fs4.existsSync(path4.join(projectRoot, ".windsurfrules")) || fs4.existsSync(path4.join(projectRoot, ".windsurf"));
     if (hasWindsurfMarkers) {
-      const windsurfConfigPath = path5.join(
+      const windsurfConfigPath = path4.join(
         os.homedir(),
         ".codeium",
         "windsurf",
         "mcp_config.json"
       );
-      if (fs5.existsSync(windsurfConfigPath)) {
-        const content = fs5.readFileSync(windsurfConfigPath, "utf-8");
+      if (fs4.existsSync(windsurfConfigPath)) {
+        const content = fs4.readFileSync(windsurfConfigPath, "utf-8");
         const windsurfResult = processJsonMcpConfig(content);
         const home = os.homedir();
         const displayPath = windsurfConfigPath.startsWith(home) ? "~" + windsurfConfigPath.slice(home.length) : windsurfConfigPath;
         if (windsurfResult.action === "deleted") {
           if (!dryRun) {
-            fs5.unlinkSync(windsurfConfigPath);
+            fs4.unlinkSync(windsurfConfigPath);
           }
           summary.push(
             `${prefix}Deleted global Windsurf config (${displayPath})`
           );
         } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
           if (!dryRun) {
-            fs5.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
+            fs4.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
           }
           summary.push(
             `${prefix}Removed glasstrace from global Windsurf config (${displayPath})`
@@ -16193,21 +15983,21 @@ async function runUninit(options) {
   }
   try {
     for (const infoFile of AGENT_INFO_FILES) {
-      const filePath = path5.join(projectRoot, infoFile);
-      if (!fs5.existsSync(filePath)) {
+      const filePath = path4.join(projectRoot, infoFile);
+      if (!fs4.existsSync(filePath)) {
         continue;
       }
-      const content = fs5.readFileSync(filePath, "utf-8");
+      const content = fs4.readFileSync(filePath, "utf-8");
       const result = removeMarkerSection(content);
       if (result.removed) {
         if (result.content.trim().length === 0) {
           if (!dryRun) {
-            fs5.unlinkSync(filePath);
+            fs4.unlinkSync(filePath);
           }
           summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
         } else {
           if (!dryRun) {
-            fs5.writeFileSync(filePath, result.content, "utf-8");
+            fs4.writeFileSync(filePath, result.content, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace section from ${infoFile}`);
         }
@@ -16223,13 +16013,13 @@ async function runUninit(options) {
   }
   return { exitCode: errors.length > 0 ? 1 : 0, summary, warnings, errors };
 }
-var fs5, os, path5, MCP_CONFIG_FILES, AGENT_INFO_FILES;
+var fs4, os, path4, MCP_CONFIG_FILES, AGENT_INFO_FILES;
 var init_uninit = __esm({
   "src/cli/uninit.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"), 1);
+    fs4 = __toESM(require("fs"), 1);
     os = __toESM(require("os"), 1);
-    path5 = __toESM(require("path"), 1);
+    path4 = __toESM(require("path"), 1);
     init_constants();
     MCP_CONFIG_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json"];
     AGENT_INFO_FILES = [
@@ -16240,10 +16030,241 @@ var init_uninit = __esm({
   }
 });
 
+// src/cli/mcp-add.ts
+var mcp_add_exports = {};
+__export(mcp_add_exports, {
+  mcpAdd: () => mcpAdd
+});
+async function registerViaCli(agent, anonKey) {
+  if (!agent.cliAvailable) {
+    return false;
+  }
+  try {
+    switch (agent.name) {
+      case "claude": {
+        const payload = JSON.stringify({
+          type: "http",
+          url: MCP_ENDPOINT,
+          headers: { Authorization: `Bearer ${anonKey}` }
+        });
+        await execFileAsync("claude", [
+          "mcp",
+          "add-json",
+          "glasstrace",
+          payload,
+          "--scope",
+          "project"
+        ]);
+        return true;
+      }
+      case "codex": {
+        await execFileAsync("codex", [
+          "mcp",
+          "add",
+          "glasstrace",
+          "--url",
+          MCP_ENDPOINT
+        ]);
+        const configPath = agent.mcpConfigPath;
+        if (configPath !== null && fs5.existsSync(configPath)) {
+          const content = fs5.readFileSync(configPath, "utf-8");
+          if (!content.includes("bearer_token_env_var")) {
+            const appendContent = content.endsWith("\n") ? "" : "\n";
+            fs5.writeFileSync(
+              configPath,
+              content + appendContent + 'bearer_token_env_var = "GLASSTRACE_API_KEY"\n',
+              "utf-8"
+            );
+          }
+        }
+        process.stderr.write(
+          "  Note: Set GLASSTRACE_API_KEY environment variable for Codex authentication.\n"
+        );
+        return true;
+      }
+      case "gemini": {
+        await execFileAsync("gemini", [
+          "mcp",
+          "add",
+          "--transport",
+          "http",
+          "--header",
+          `Authorization: Bearer ${anonKey}`,
+          "glasstrace",
+          MCP_ENDPOINT
+        ]);
+        return true;
+      }
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}
+async function mcpAdd(options) {
+  const force = options?.force ?? false;
+  const dryRun = options?.dryRun ?? false;
+  const projectRoot = process.cwd();
+  const messages = [];
+  const anonKey = await readAnonKey(projectRoot);
+  if (anonKey === null) {
+    return {
+      exitCode: 1,
+      results: [],
+      messages: ["Error: Run `glasstrace init` first to generate an API key."]
+    };
+  }
+  const markerPath = path5.join(projectRoot, ".glasstrace", "mcp-connected");
+  if (fs5.existsSync(markerPath) && !force) {
+    return {
+      exitCode: 0,
+      results: [],
+      messages: ["MCP already configured. Use --force to reconfigure."]
+    };
+  }
+  const agents = await detectAgents(projectRoot);
+  const detectedNonGeneric = agents.filter((a) => a.name !== "generic");
+  const targetAgents = detectedNonGeneric.length > 0 ? detectedNonGeneric : agents.filter((a) => a.name === "generic");
+  if (dryRun) {
+    messages.push("Dry run: would perform the following actions:", "");
+    for (const agent of targetAgents) {
+      const name = formatAgentName(agent.name);
+      if (agent.cliAvailable) {
+        messages.push(
+          `  ${name}: Register via CLI (${agent.name} mcp add)`
+        );
+      } else if (agent.mcpConfigPath !== null) {
+        messages.push(
+          `  ${name}: Write config to ${agent.mcpConfigPath}`
+        );
+      }
+      if (agent.infoFilePath !== null) {
+        messages.push(
+          `  ${name}: Inject info section into ${agent.infoFilePath}`
+        );
+      }
+    }
+    messages.push(
+      "",
+      "  Update .gitignore with MCP config paths",
+      "  Create .glasstrace/mcp-connected marker"
+    );
+    return { exitCode: 0, results: [], messages };
+  }
+  const results = [];
+  for (const agent of targetAgents) {
+    const name = formatAgentName(agent.name);
+    if (agent.name !== "generic") {
+      const cliSuccess = await registerViaCli(agent, anonKey);
+      if (cliSuccess) {
+        const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
+        if (infoContent !== "") {
+          await injectInfoSection(agent, infoContent, projectRoot);
+        }
+        results.push({
+          agent: agent.name,
+          success: true,
+          method: "cli",
+          message: `${name}: Registered via CLI`
+        });
+        continue;
+      }
+    }
+    if (agent.mcpConfigPath !== null) {
+      try {
+        const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
+        await writeMcpConfig(agent, configContent, projectRoot);
+        if (fs5.existsSync(agent.mcpConfigPath)) {
+          const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
+          if (infoContent !== "") {
+            await injectInfoSection(agent, infoContent, projectRoot);
+          }
+          results.push({
+            agent: agent.name,
+            success: true,
+            method: "file",
+            message: `${name}: Configured via ${agent.mcpConfigPath}`
+          });
+          continue;
+        }
+        results.push({
+          agent: agent.name,
+          success: false,
+          method: "file",
+          message: `${name}: Failed to write config to ${agent.mcpConfigPath} (permission denied)`
+        });
+        continue;
+      } catch (err) {
+        results.push({
+          agent: agent.name,
+          success: false,
+          method: "file",
+          message: `${name}: Failed - ${err instanceof Error ? err.message : String(err)}`
+        });
+        continue;
+      }
+    }
+    results.push({
+      agent: agent.name,
+      success: false,
+      method: "skipped",
+      message: `${name}: No registration method available`
+    });
+  }
+  await updateGitignore(
+    [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".codex/config.toml"],
+    projectRoot
+  );
+  const anySuccess = results.some((r) => r.success);
+  if (anySuccess) {
+    await scaffoldMcpMarker(projectRoot, anonKey);
+  }
+  messages.push("", "MCP registration summary:");
+  for (const result of results) {
+    const icon = result.success ? "+" : "-";
+    messages.push(`  [${icon}] ${result.message}`);
+  }
+  if (results.length === 0) {
+    messages.push(
+      "  No agents detected. Place agent marker files (e.g., CLAUDE.md, .cursor/) in your project."
+    );
+  }
+  if (!anySuccess && results.length > 0) {
+    messages.push(
+      "",
+      "All agent registrations failed. Check errors above."
+    );
+    return { exitCode: 1, results, messages };
+  }
+  if (anySuccess) {
+    messages.push("", "MCP registration complete.");
+  }
+  return { exitCode: 0, results, messages };
+}
+var import_node_child_process2, fs5, path5, import_node_util, execFileAsync;
+var init_mcp_add = __esm({
+  "src/cli/mcp-add.ts"() {
+    "use strict";
+    import_node_child_process2 = require("child_process");
+    fs5 = __toESM(require("fs"), 1);
+    path5 = __toESM(require("path"), 1);
+    import_node_util = require("util");
+    init_anon_key();
+    init_detect();
+    init_configs();
+    init_inject();
+    init_scaffolder();
+    init_constants();
+    execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+  }
+});
+
 // src/cli/init.ts
 var init_exports = {};
 __export(init_exports, {
   meetsNodeVersion: () => meetsNodeVersion,
+  rollbackSteps: () => rollbackSteps,
   runInit: () => runInit
 });
 module.exports = __toCommonJS(init_exports);
@@ -16661,6 +16682,7 @@ function walkDirectories(baseDir) {
 }
 
 // src/cli/init.ts
+init_uninit();
 function meetsNodeVersion(minMajor) {
   const [major] = process.versions.node.split(".").map(Number);
   return major >= minMajor;
@@ -16686,6 +16708,94 @@ async function promptYesNo(question, defaultValue) {
     });
   });
 }
+function cleanLeadingBlankLines2(content) {
+  return content.replace(/^\n{2,}/, "\n");
+}
+async function rollbackSteps(steps, projectRoot, state) {
+  for (const step of [...steps].reverse()) {
+    try {
+      switch (step) {
+        case "instrumentation": {
+          const instrPath = path6.join(projectRoot, "instrumentation.ts");
+          if (fs6.existsSync(instrPath)) {
+            const content = fs6.readFileSync(instrPath, "utf-8");
+            if (isInitCreatedInstrumentation(content)) {
+              fs6.unlinkSync(instrPath);
+            } else if (state?.originalInstrumentationContent !== void 0) {
+              fs6.writeFileSync(instrPath, state.originalInstrumentationContent, "utf-8");
+            } else {
+              const cleaned = removeRegisterGlasstrace(content);
+              if (cleaned !== content) {
+                fs6.writeFileSync(instrPath, cleaned, "utf-8");
+              }
+            }
+          }
+          break;
+        }
+        case "next-config": {
+          for (const name of NEXT_CONFIG_NAMES) {
+            const configPath = path6.join(projectRoot, name);
+            if (!fs6.existsSync(configPath)) {
+              continue;
+            }
+            const content = fs6.readFileSync(configPath, "utf-8");
+            if (!content.includes("withGlasstraceConfig")) {
+              continue;
+            }
+            const isESM = name.endsWith(".ts") || name.endsWith(".mjs");
+            const unwrapResult = isESM ? unwrapExport(content) : unwrapCJSExport(content);
+            if (unwrapResult.unwrapped) {
+              const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
+              fs6.writeFileSync(configPath, cleanLeadingBlankLines2(cleaned), "utf-8");
+            }
+            break;
+          }
+          break;
+        }
+        case "env-local": {
+          const envPath = path6.join(projectRoot, ".env.local");
+          if (fs6.existsSync(envPath)) {
+            const content = fs6.readFileSync(envPath, "utf-8");
+            const lines = content.split("\n");
+            const filtered = lines.filter((line) => {
+              const trimmed = line.trim();
+              return !/^\s*#?\s*GLASSTRACE_API_KEY\s*=/.test(trimmed);
+            });
+            if (filtered.length !== lines.length) {
+              const result = filtered.join("\n");
+              if (result.trim().length === 0) {
+                fs6.unlinkSync(envPath);
+              } else {
+                fs6.writeFileSync(envPath, result, "utf-8");
+              }
+            }
+          }
+          break;
+        }
+        case "gitignore": {
+          const gitignorePath = path6.join(projectRoot, ".gitignore");
+          if (fs6.existsSync(gitignorePath)) {
+            const content = fs6.readFileSync(gitignorePath, "utf-8");
+            const lines = content.split("\n");
+            const filtered = lines.filter(
+              (line) => line.trim() !== ".glasstrace/"
+            );
+            if (filtered.length !== lines.length) {
+              const result = filtered.join("\n");
+              if (result.trim().length === 0) {
+                fs6.unlinkSync(gitignorePath);
+              } else {
+                fs6.writeFileSync(gitignorePath, result, "utf-8");
+              }
+            }
+          }
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+}
 async function runInit(options) {
   const { yes, coverageMap } = options;
   const summary = [];
@@ -16707,14 +16817,21 @@ async function runInit(options) {
     errors.push("No package.json found. Run this command from a Node.js project root.");
     return { exitCode: 1, summary, warnings, errors };
   }
+  const rollbackState = { steps: [] };
   try {
+    const instrPath = path6.join(projectRoot, "instrumentation.ts");
+    if (fs6.existsSync(instrPath)) {
+      rollbackState.originalInstrumentationContent = fs6.readFileSync(instrPath, "utf-8");
+    }
     const instrResult = await scaffoldInstrumentation(projectRoot);
     switch (instrResult.action) {
       case "created":
         summary.push("Created instrumentation.ts");
+        rollbackState.steps.push("instrumentation");
         break;
       case "injected":
         summary.push("Added registerGlasstrace() to existing instrumentation.ts");
+        rollbackState.steps.push("instrumentation");
         break;
       case "already-registered":
         summary.push("Skipped instrumentation.ts (registerGlasstrace already present)");
@@ -16726,6 +16843,7 @@ async function runInit(options) {
         break;
     }
   } catch (err) {
+    await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
     errors.push(`Failed to write instrumentation.ts: ${err instanceof Error ? err.message : String(err)}`);
     return { exitCode: 1, summary, warnings, errors };
   }
@@ -16733,6 +16851,7 @@ async function runInit(options) {
     const configResult = await scaffoldNextConfig(projectRoot);
     if (configResult?.modified) {
       summary.push("Wrapped next.config with withGlasstraceConfig()");
+      rollbackState.steps.push("next-config");
     } else if (configResult === null) {
       warnings.push("No next.config.* found. You may need to create one for Next.js projects.");
     } else if (configResult.reason === "already-wrapped") {
@@ -16743,6 +16862,7 @@ async function runInit(options) {
       warnings.push("next.config has no recognizable export pattern \u2014 add withGlasstraceConfig() manually");
     }
   } catch (err) {
+    await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
     errors.push(`Failed to modify next.config: ${err instanceof Error ? err.message : String(err)}`);
     return { exitCode: 1, summary, warnings, errors };
   }
@@ -16750,10 +16870,12 @@ async function runInit(options) {
     const envCreated = await scaffoldEnvLocal(projectRoot);
     if (envCreated) {
       summary.push("Updated .env.local with Glasstrace configuration");
+      rollbackState.steps.push("env-local");
     } else {
       summary.push("Skipped .env.local (GLASSTRACE_API_KEY already configured)");
     }
   } catch (err) {
+    await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
     errors.push(`Failed to update .env.local: ${err instanceof Error ? err.message : String(err)}`);
     return { exitCode: 1, summary, warnings, errors };
   }
@@ -16761,10 +16883,12 @@ async function runInit(options) {
     const gitignoreUpdated = await scaffoldGitignore(projectRoot);
     if (gitignoreUpdated) {
       summary.push("Updated .gitignore with .glasstrace/");
+      rollbackState.steps.push("gitignore");
     } else {
       summary.push("Skipped .gitignore (.glasstrace/ already listed)");
     }
   } catch (err) {
+    await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
     errors.push(`Failed to update .gitignore: ${err instanceof Error ? err.message : String(err)}`);
     return { exitCode: 1, summary, warnings, errors };
   }
@@ -17024,6 +17148,7 @@ Usage:
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   meetsNodeVersion,
+  rollbackSteps,
   runInit
 });
 //# sourceMappingURL=init.cjs.map