@glasstrace/sdk 0.10.0 → 0.12.0

package/dist/cli/mcp-add.cjs

@@ -38,10 +38,6 @@ var fs2 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 
-// src/anon-key.ts
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
-
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -13885,7 +13881,9 @@ var SdkInitResponseSchema = external_exports.object({
 });
 var DiscoveryResponseSchema = external_exports.object({
   key: AnonApiKeySchema,
-  sessionId: SessionIdSchema
+  sessionId: SessionIdSchema,
+  claimed: external_exports.boolean().optional(),
+  accountHint: external_exports.string().optional()
 });
 var SourceMapUploadResponseSchema = external_exports.object({
   success: external_exports.literal(true),
@@ -13936,17 +13934,35 @@ var SourceMapManifestResponseSchema = external_exports.object({
 // src/anon-key.ts
 var GLASSTRACE_DIR = ".glasstrace";
 var ANON_KEY_FILE = "anon_key";
+var fsPathCache;
+async function loadFsPath() {
+  if (fsPathCache !== void 0) return fsPathCache;
+  try {
+    const [fs3, path3] = await Promise.all([
+      import("fs/promises"),
+      import("path")
+    ]);
+    fsPathCache = { fs: fs3, path: path3 };
+    return fsPathCache;
+  } catch {
+    fsPathCache = null;
+    return null;
+  }
+}
 var ephemeralKeyCache = /* @__PURE__ */ new Map();
 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) {
@@ -13957,31 +13973,31 @@ async function readAnonKey(projectRoot) {
 
 // src/agent-detection/detect.ts
 var import_node_child_process = require("child_process");
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
 var import_node_os = require("os");
 var import_node_fs = require("fs");
 var 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"
@@ -13989,41 +14005,41 @@ var AGENT_RULES = [
   {
     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"
   }
 ];
 async function pathExists(path3, mode = import_node_fs.constants.R_OK) {
   try {
-    await (0, import_promises2.access)(path3, mode);
+    await (0, import_promises.access)(path3, 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) => {
@@ -14034,10 +14050,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(
@@ -14055,7 +14071,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;
     }
@@ -14068,7 +14084,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;
         }
@@ -14100,7 +14116,7 @@ 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
@@ -14271,8 +14287,8 @@ ${content}${m.end}
 }
 
 // src/agent-detection/inject.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
 var HTML_START = "<!-- glasstrace:mcp:start -->";
 var HTML_END = "<!-- glasstrace:mcp:end -->";
 var HASH_START = "# glasstrace:mcp:start";
@@ -14286,9 +14302,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(
@@ -14300,7 +14316,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(
@@ -14312,7 +14328,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 {
   }
 }
@@ -14345,7 +14361,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") {
@@ -14361,8 +14377,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(
@@ -14388,7 +14404,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(
@@ -14401,14 +14417,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") {
@@ -14434,7 +14450,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(