@glasstrace/sdk 0.7.2 → 0.8.0

package/dist/cli/init.cjs

@@ -35,12 +35,68 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 function identityFingerprint(token) {
   return `sha256:${(0, import_node_crypto.createHash)("sha256").update(token).digest("hex")}`;
 }
-async function scaffoldInstrumentation(projectRoot, force) {
-  const filePath = path.join(projectRoot, "instrumentation.ts");
-  if (fs.existsSync(filePath) && !force) {
-    return false;
+function hasRegisterGlasstraceCall(content) {
+  return content.split("\n").some((line) => {
+    const uncommented = line.replace(/\/\/.*$/, "");
+    return /\bregisterGlasstrace\s*\(/.test(uncommented);
+  });
+}
+function injectRegisterGlasstrace(content) {
+  if (hasRegisterGlasstraceCall(content)) {
+    return { injected: false, content };
+  }
+  const registerFnRegex = /export\s+(?:async\s+)?function\s+register\s*\([^)]*\)\s*\{/;
+  const match = registerFnRegex.exec(content);
+  if (!match) {
+    return { injected: false, content };
+  }
+  const afterBrace = content.slice(match.index + match[0].length);
+  const indentMatch = /\n([ \t]+)/.exec(afterBrace);
+  const indent = indentMatch ? indentMatch[1] : "  ";
+  const importLine = 'import { registerGlasstrace } from "@glasstrace/sdk";\n';
+  const hasGlasstraceImport = content.includes("@glasstrace/sdk");
+  const insertPoint = match.index + match[0].length;
+  const callInjection = `
+${indent}// Glasstrace must be registered before other instrumentation
+${indent}registerGlasstrace();
+`;
+  let modified;
+  if (hasGlasstraceImport) {
+    const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']@glasstrace\/sdk["']/;
+    const importMatch = importRegex.exec(content);
+    if (importMatch) {
+      const specifiers = importMatch[1];
+      const alreadyImported = specifiers.split(",").some((s) => s.trim() === "registerGlasstrace");
+      if (alreadyImported) {
+        modified = content.slice(0, insertPoint) + callInjection + content.slice(insertPoint);
+      } else {
+        const existingImports = specifiers.trimEnd();
+        const separator = existingImports.endsWith(",") ? " " : ", ";
+        const updatedImport = `import {${existingImports}${separator}registerGlasstrace} from "@glasstrace/sdk"`;
+        modified = content.replace(importMatch[0], updatedImport);
+        const newMatch = registerFnRegex.exec(modified);
+        if (newMatch) {
+          const newInsertPoint = newMatch.index + newMatch[0].length;
+          modified = modified.slice(0, newInsertPoint) + callInjection + modified.slice(newInsertPoint);
+        }
+      }
+    } else {
+      modified = importLine + content;
+      const newMatch = registerFnRegex.exec(modified);
+      if (newMatch) {
+        const newInsertPoint = newMatch.index + newMatch[0].length;
+        modified = modified.slice(0, newInsertPoint) + callInjection + modified.slice(newInsertPoint);
+      }
+    }
+  } else {
+    modified = importLine + content.slice(0, insertPoint) + callInjection + content.slice(insertPoint);
   }
-  const content = `import { registerGlasstrace } from "@glasstrace/sdk";
+  return { injected: true, content: modified };
+}
+async function scaffoldInstrumentation(projectRoot) {
+  const filePath = path.join(projectRoot, "instrumentation.ts");
+  if (!fs.existsSync(filePath)) {
+    const content = `import { registerGlasstrace } from "@glasstrace/sdk";
 
 export async function register() {
   // Glasstrace must be registered before Prisma instrumentation
@@ -49,8 +105,19 @@ export async function register() {
   registerGlasstrace();
 }
 `;
-  fs.writeFileSync(filePath, content, "utf-8");
-  return true;
+    fs.writeFileSync(filePath, content, "utf-8");
+    return { action: "created" };
+  }
+  const existing = fs.readFileSync(filePath, "utf-8");
+  if (hasRegisterGlasstraceCall(existing)) {
+    return { action: "already-registered" };
+  }
+  const result = injectRegisterGlasstrace(existing);
+  if (result.injected) {
+    fs.writeFileSync(filePath, result.content, "utf-8");
+    return { action: "injected" };
+  }
+  return { action: "unrecognized" };
 }
 async function scaffoldNextConfig(projectRoot) {
   let configPath;
@@ -64,31 +131,34 @@ async function scaffoldNextConfig(projectRoot) {
     }
   }
   if (configPath === void 0 || configName === void 0) {
-    return false;
+    return null;
   }
   const existing = fs.readFileSync(configPath, "utf-8");
+  if (existing.trim().length === 0) {
+    return { modified: false, reason: "empty-file" };
+  }
   if (existing.includes("withGlasstraceConfig")) {
-    return false;
+    return { modified: false, reason: "already-wrapped" };
   }
   const isESM = configName.endsWith(".ts") || configName.endsWith(".mjs");
   if (isESM) {
     const importLine = 'import { withGlasstraceConfig } from "@glasstrace/sdk";\n';
     const wrapResult2 = wrapExport(existing);
     if (!wrapResult2.wrapped) {
-      return false;
+      return { modified: false, reason: "no-export" };
     }
     const modified2 = importLine + "\n" + wrapResult2.content;
     fs.writeFileSync(configPath, modified2, "utf-8");
-    return true;
+    return { modified: true };
   }
   const requireLine = 'const { withGlasstraceConfig } = require("@glasstrace/sdk");\n';
   const wrapResult = wrapCJSExport(existing);
   if (!wrapResult.wrapped) {
-    return false;
+    return { modified: false, reason: "no-export" };
   }
   const modified = requireLine + "\n" + wrapResult.content;
   fs.writeFileSync(configPath, modified, "utf-8");
-  return true;
+  return { modified: true };
 }
 function wrapExport(content) {
   const marker = "export default";
@@ -14608,6 +14678,14 @@ var init_zod = __esm({
 });
 
 // ../protocol/dist/index.js
+function randomHex(byteCount) {
+  const bytes = new Uint8Array(byteCount);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function createAnonApiKey() {
+  return AnonApiKeySchema.parse(`gt_anon_${randomHex(24)}`);
+}
 function createBuildHash(hash2) {
   return BuildHashSchema.parse(hash2);
 }
@@ -14761,6 +14839,44 @@ async function readAnonKey(projectRoot) {
   }
   return null;
 }
+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;
+  }
+  const cached2 = ephemeralKeyCache.get(root);
+  if (cached2 !== void 0) {
+    return cached2;
+  }
+  const newKey = createAnonApiKey();
+  try {
+    await (0, import_promises.mkdir)(dirPath, { recursive: true, mode: 448 });
+    await (0, import_promises.writeFile)(keyPath, newKey, { flag: "wx", mode: 384 });
+    return newKey;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EEXIST") {
+      const winnerKey = await readAnonKey(root);
+      if (winnerKey !== null) {
+        return winnerKey;
+      }
+      try {
+        await (0, import_promises.writeFile)(keyPath, newKey, { mode: 384 });
+        await (0, import_promises.chmod)(keyPath, 384);
+        return newKey;
+      } catch {
+      }
+    }
+    ephemeralKeyCache.set(root, newKey);
+    console.warn(
+      `[glasstrace] Failed to persist anonymous key to ${keyPath}: ${err instanceof Error ? err.message : String(err)}. Using ephemeral key.`
+    );
+    return newKey;
+  }
+}
 var import_promises, import_node_path, GLASSTRACE_DIR, ANON_KEY_FILE, ephemeralKeyCache;
 var init_anon_key = __esm({
   "src/anon-key.ts"() {
@@ -15052,8 +15168,11 @@ function generateInfoSection(agent, endpoint) {
     `Glasstrace is configured as an MCP server at: ${endpoint}`,
     "",
     "Available tools:",
-    "- `glasstrace_submit_trace` - Submit trace data for debugging analysis",
-    "- `glasstrace_get_config` - Retrieve current SDK configuration",
+    "- `get_latest_error` - Get the most recent error trace from the current session",
+    "- `get_trace` - Get a specific trace by ID or URL pattern",
+    "- `get_root_cause` - Get the full span tree and root cause analysis for an error",
+    "- `get_test_suggestions` - Get test suggestions based on recent errors",
+    "- `get_session_timeline` - Get the timeline of all traces in the current session",
     "",
     "To reconfigure, run: `npx glasstrace mcp add`",
     ""
@@ -15525,6 +15644,7 @@ var init_mcp_add = __esm({
 // src/cli/init.ts
 var init_exports = {};
 __export(init_exports, {
+  meetsNodeVersion: () => meetsNodeVersion,
   runInit: () => runInit
 });
 module.exports = __toCommonJS(init_exports);
@@ -15708,6 +15828,10 @@ init_detect();
 init_configs();
 init_inject();
 init_constants();
+function meetsNodeVersion(minMajor) {
+  const [major] = process.versions.node.split(".").map(Number);
+  return major >= minMajor;
+}
 async function promptYesNo(question, defaultValue) {
   if (!process.stdin.isTTY) {
     return defaultValue;
@@ -15739,41 +15863,40 @@ 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 instrumentationPath = path4.join(projectRoot, "instrumentation.ts");
-  const instrumentationExists = fs4.existsSync(instrumentationPath);
-  let shouldWriteInstrumentation = true;
-  if (instrumentationExists && !yes) {
-    shouldWriteInstrumentation = await promptYesNo(
-      "instrumentation.ts already exists. Overwrite?",
-      false
-    );
-  } else if (instrumentationExists && yes) {
-    shouldWriteInstrumentation = false;
-  }
   try {
-    const created = await scaffoldInstrumentation(projectRoot, shouldWriteInstrumentation && instrumentationExists);
-    if (created) {
-      summary.push("Created instrumentation.ts");
-    } else if (instrumentationExists) {
-      summary.push("Skipped instrumentation.ts (already exists)");
+    const instrResult = await scaffoldInstrumentation(projectRoot);
+    switch (instrResult.action) {
+      case "created":
+        summary.push("Created instrumentation.ts");
+        break;
+      case "injected":
+        summary.push("Added registerGlasstrace() to existing instrumentation.ts");
+        break;
+      case "already-registered":
+        summary.push("Skipped instrumentation.ts (registerGlasstrace already present)");
+        break;
+      case "unrecognized":
+        warnings.push(
+          'instrumentation.ts exists but has no recognizable register() function.\nAdd this import at the top of your file:\n\n  import { registerGlasstrace } from "@glasstrace/sdk";\n\nThen add this as the first statement in your register() function:\n\n  registerGlasstrace();\n'
+        );
+        break;
     }
   } catch (err) {
     errors.push(`Failed to write instrumentation.ts: ${err instanceof Error ? err.message : String(err)}`);
     return { exitCode: 1, summary, warnings, errors };
   }
   try {
-    const wrapped = await scaffoldNextConfig(projectRoot);
-    if (wrapped) {
+    const configResult = await scaffoldNextConfig(projectRoot);
+    if (configResult?.modified) {
       summary.push("Wrapped next.config with withGlasstraceConfig()");
+    } 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") {
+      summary.push("Skipped next.config (already contains withGlasstraceConfig)");
+    } else if (configResult.reason === "empty-file") {
+      warnings.push("next.config is empty \u2014 add a Next.js configuration export to enable wrapping");
     } else {
-      const hasNextConfig = ["next.config.ts", "next.config.js", "next.config.mjs"].some(
-        (name) => fs4.existsSync(path4.join(projectRoot, name))
-      );
-      if (hasNextConfig) {
-        summary.push("Skipped next.config (already contains withGlasstraceConfig)");
-      } else {
-        warnings.push("No next.config.* found. You may need to create one for Next.js projects.");
-      }
+      warnings.push("next.config has no recognizable export pattern \u2014 add withGlasstraceConfig() manually");
     }
   } catch (err) {
     errors.push(`Failed to modify next.config: ${err instanceof Error ? err.message : String(err)}`);
@@ -15804,10 +15927,30 @@ async function runInit(options) {
   const ciEnv = process.env["CI"];
   const isCI = typeof ciEnv === "string" && ciEnv.trim() !== "" && ciEnv.toLowerCase() !== "false" && ciEnv.trim() !== "0" || process.env["GITHUB_ACTIONS"] === "true";
   try {
-    const anonKey = await readAnonKey(projectRoot);
-    if (anonKey !== null) {
-      let anyConfigWritten = false;
-      if (isCI) {
+    const anonKey = await getOrCreateAnonKey(projectRoot);
+    let anyConfigWritten = false;
+    if (isCI) {
+      const genericAgent = {
+        name: "generic",
+        mcpConfigPath: path4.join(projectRoot, ".glasstrace", "mcp.json"),
+        infoFilePath: null,
+        cliAvailable: false,
+        registrationCommand: null
+      };
+      const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, anonKey);
+      await writeMcpConfig(genericAgent, genericConfig, projectRoot);
+      if (genericAgent.mcpConfigPath !== null && fs4.existsSync(genericAgent.mcpConfigPath)) {
+        anyConfigWritten = true;
+        summary.push("Created .glasstrace/mcp.json (CI mode)");
+      }
+    } else {
+      let agents;
+      try {
+        agents = await detectAgents(projectRoot);
+      } catch (detectErr) {
+        warnings.push(
+          `Agent detection failed: ${detectErr instanceof Error ? detectErr.message : String(detectErr)}. Writing generic config only.`
+        );
         const genericAgent = {
           name: "generic",
           mcpConfigPath: path4.join(projectRoot, ".glasstrace", "mcp.json"),
@@ -15819,71 +15962,47 @@ async function runInit(options) {
         await writeMcpConfig(genericAgent, genericConfig, projectRoot);
         if (genericAgent.mcpConfigPath !== null && fs4.existsSync(genericAgent.mcpConfigPath)) {
           anyConfigWritten = true;
-          summary.push("Created .glasstrace/mcp.json (CI mode)");
         }
-      } else {
-        let agents;
+        agents = [];
+      }
+      const configuredNames = [];
+      for (const agent of agents) {
         try {
-          agents = await detectAgents(projectRoot);
-        } catch (detectErr) {
+          const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
+          await writeMcpConfig(agent, configContent, projectRoot);
+          const configExists = agent.mcpConfigPath !== null && fs4.existsSync(agent.mcpConfigPath);
+          if (!configExists) {
+            continue;
+          }
+          anyConfigWritten = true;
+          const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
+          if (infoContent !== "") {
+            await injectInfoSection(agent, infoContent, projectRoot);
+          }
+          if (agent.name !== "generic") {
+            configuredNames.push(formatAgentName(agent.name));
+          }
+        } catch (agentErr) {
           warnings.push(
-            `Agent detection failed: ${detectErr instanceof Error ? detectErr.message : String(detectErr)}. Writing generic config only.`
+            `Failed to configure MCP for ${agent.name}: ${agentErr instanceof Error ? agentErr.message : String(agentErr)}`
           );
-          const genericAgent = {
-            name: "generic",
-            mcpConfigPath: path4.join(projectRoot, ".glasstrace", "mcp.json"),
-            infoFilePath: null,
-            cliAvailable: false,
-            registrationCommand: null
-          };
-          const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, anonKey);
-          await writeMcpConfig(genericAgent, genericConfig, projectRoot);
-          if (genericAgent.mcpConfigPath !== null && fs4.existsSync(genericAgent.mcpConfigPath)) {
-            anyConfigWritten = true;
-          }
-          agents = [];
-        }
-        const configuredNames = [];
-        for (const agent of agents) {
-          try {
-            const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
-            await writeMcpConfig(agent, configContent, projectRoot);
-            const configExists = agent.mcpConfigPath !== null && fs4.existsSync(agent.mcpConfigPath);
-            if (!configExists) {
-              continue;
-            }
-            anyConfigWritten = true;
-            const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
-            if (infoContent !== "") {
-              await injectInfoSection(agent, infoContent, projectRoot);
-            }
-            if (agent.name !== "generic") {
-              configuredNames.push(formatAgentName(agent.name));
-            }
-          } catch (agentErr) {
-            warnings.push(
-              `Failed to configure MCP for ${agent.name}: ${agentErr instanceof Error ? agentErr.message : String(agentErr)}`
-            );
-          }
-        }
-        if (configuredNames.length > 0) {
-          summary.push(`Configured MCP for: ${configuredNames.join(", ")}`);
-        } else if (anyConfigWritten) {
-          summary.push("Created .glasstrace/mcp.json (generic config)");
         }
       }
-      await updateGitignore(
-        [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".codex/config.toml"],
-        projectRoot
-      );
-      if (anyConfigWritten) {
-        const markerCreated = await scaffoldMcpMarker(projectRoot, anonKey);
-        if (markerCreated) {
-          summary.push("Created .glasstrace/mcp-connected marker");
-        }
+      if (configuredNames.length > 0) {
+        summary.push(`Configured MCP for: ${configuredNames.join(", ")}`);
+      } else if (anyConfigWritten) {
+        summary.push("Created .glasstrace/mcp.json (generic config)");
+      }
+    }
+    await updateGitignore(
+      [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".codex/config.toml"],
+      projectRoot
+    );
+    if (anyConfigWritten) {
+      const markerCreated = await scaffoldMcpMarker(projectRoot, anonKey);
+      if (markerCreated) {
+        summary.push("Created .glasstrace/mcp-connected marker");
       }
-    } else {
-      warnings.push("No anonymous key found. Skipping MCP auto-configuration. Run init again after the SDK has generated a key.");
     }
   } catch (mcpErr) {
     warnings.push(
@@ -15941,6 +16060,13 @@ var scriptPath = typeof process !== "undefined" && process.argv[1] !== void 0 ?
 var scriptBasename = scriptPath !== void 0 ? path4.basename(scriptPath) : void 0;
 var isDirectExecution = scriptPath !== void 0 && (scriptPath.endsWith("/cli/init.js") || scriptPath.endsWith("/cli/init.ts") || scriptBasename === "glasstrace");
 if (isDirectExecution) {
+  if (!meetsNodeVersion(20)) {
+    process.stderr.write(
+      `Error: @glasstrace/sdk requires Node.js >= 20. Current version: ${process.version}
+`
+    );
+    process.exit(1);
+  }
   const subcommand = process.argv[2];
   if (subcommand === "mcp") {
     if (process.argv[3] === "add") {
@@ -16020,6 +16146,7 @@ Usage:
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  meetsNodeVersion,
   runInit
 });
 //# sourceMappingURL=init.cjs.map