@glasstrace/sdk 1.1.0 → 1.1.2

package/dist/cli/init.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   resolveProjectRoot
-} from "../chunk-55FBXXER.js";
+} from "../chunk-2M57EO6U.js";
 import {
   verifyInitReachable
-} from "../chunk-DO2YPMQ5.js";
+} from "../chunk-C567H5EQ.js";
 import {
   buildImportGraph
-} from "../chunk-UGJ3X4CT.js";
+} from "../chunk-DST4UBXU.js";
 import {
   resolveConfig
 } from "../chunk-VUZCLMIX.js";
@@ -21,7 +21,7 @@ import {
   unwrapCJSExport,
   unwrapExport,
   writeDiscoveryFile
-} from "../chunk-LU3PPAOQ.js";
+} from "../chunk-UJ2JC7PZ.js";
 import {
   detectAgents,
   generateInfoSection,
@@ -29,35 +29,406 @@ import {
   injectInfoSection,
   updateGitignore,
   writeMcpConfig
-} from "../chunk-HAU66QBQ.js";
+} from "../chunk-P4OYPFQ5.js";
 import {
+  MCP_ENDPOINT,
   getOrCreateAnonKey,
-  readAnonKey
-} from "../chunk-IP4NMDJK.js";
-import {
-  addCoverageMapEnv,
+  identityFingerprint,
   isDevApiKey,
   mcpConfigMatches,
+  readAnonKey,
   readEnvLocalApiKey,
-  resolveInstrumentationTarget,
-  scaffoldEnvLocal,
-  scaffoldGitignore,
-  scaffoldInstrumentation,
-  scaffoldMcpMarker,
-  scaffoldNextConfig
-} from "../chunk-O63DJKIJ.js";
-import "../chunk-TQ54WLCZ.js";
+  resolveEffectiveMcpCredential,
+  writeMcpMarker
+} from "../chunk-3LILTM3T.js";
+import "../chunk-X5MAXP5T.js";
 import {
-  MCP_ENDPOINT,
   NEXT_CONFIG_NAMES,
   formatAgentName
-} from "../chunk-DXRZKKSO.js";
+} from "../chunk-NB7GJE4S.js";
 import "../chunk-NSBPE2FW.js";
 
 // src/cli/init.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import * as readline from "node:readline";
+
+// src/cli/scaffolder.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as readline from "node:readline";
+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.trim()}${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);
+  }
+  return { injected: true, content: modified };
+}
+var INSTRUMENTATION_FILENAMES = [
+  "instrumentation.ts",
+  "instrumentation.js",
+  "instrumentation.mjs"
+];
+function resolveInstrumentationTarget(projectRoot) {
+  const rootExisting = [];
+  const srcExisting = [];
+  for (const name of INSTRUMENTATION_FILENAMES) {
+    const rootPath = path.join(projectRoot, name);
+    if (isRegularFile(rootPath)) {
+      rootExisting.push(rootPath);
+    }
+    const srcPath = path.join(projectRoot, "src", name);
+    if (isRegularFile(srcPath)) {
+      srcExisting.push(srcPath);
+    }
+  }
+  const existing = [...rootExisting, ...srcExisting];
+  if (rootExisting.length > 0 && srcExisting.length > 0) {
+    return {
+      target: null,
+      layout: null,
+      existing,
+      rootExisting,
+      srcExisting,
+      conflict: true
+    };
+  }
+  if (srcExisting.length > 0) {
+    return {
+      target: srcExisting[0],
+      layout: "src",
+      existing,
+      rootExisting,
+      srcExisting,
+      conflict: false
+    };
+  }
+  if (rootExisting.length > 0) {
+    return {
+      target: rootExisting[0],
+      layout: "root",
+      existing,
+      rootExisting,
+      srcExisting,
+      conflict: false
+    };
+  }
+  const srcDir = path.join(projectRoot, "src");
+  const layout = isDirectory(srcDir) ? "src" : "root";
+  const target = layout === "src" ? path.join(projectRoot, "src", "instrumentation.ts") : path.join(projectRoot, "instrumentation.ts");
+  return {
+    target,
+    layout,
+    existing,
+    rootExisting,
+    srcExisting,
+    conflict: false
+  };
+}
+function isDirectory(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isRegularFile(p) {
+  try {
+    const stat = fs.lstatSync(p);
+    if (stat.isSymbolicLink()) {
+      return fs.statSync(p).isFile();
+    }
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+function appendRegisterFunction(content) {
+  const importLine = 'import { registerGlasstrace } from "@glasstrace/sdk";\n';
+  const functionBlock = "\nexport async function register() {\n  // Glasstrace must be registered before Prisma instrumentation\n  // to ensure all ORM spans are captured correctly.\n  // If you use @prisma/instrumentation, import it after this call.\n  registerGlasstrace();\n}\n";
+  let withImport = content;
+  const hasGlasstraceImport = content.includes("@glasstrace/sdk");
+  if (!hasGlasstraceImport) {
+    withImport = importLine + content;
+  } else {
+    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) {
+        const existingImports = specifiers.trimEnd();
+        const separator = existingImports.endsWith(",") ? " " : ", ";
+        const updatedImport = `import { ${existingImports.trim()}${separator}registerGlasstrace } from "@glasstrace/sdk"`;
+        withImport = content.replace(importMatch[0], updatedImport);
+      }
+    } else {
+      withImport = importLine + content;
+    }
+  }
+  const trailingNewline = withImport.endsWith("\n") ? "" : "\n";
+  return withImport + trailingNewline + functionBlock;
+}
+async function defaultInstrumentationPrompt(question, defaultValue) {
+  if (!process.stdin.isTTY) return defaultValue;
+  const readline2 = await import("node:readline");
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+    rl.question(question + suffix, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") {
+        resolve(defaultValue);
+        return;
+      }
+      resolve(trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+async function scaffoldInstrumentation(projectRoot, options = {}) {
+  const target = resolveInstrumentationTarget(projectRoot);
+  if (target.conflict) {
+    return {
+      action: "conflict",
+      // Point the user at the `src/` variant — modern Next.js apps with a
+      // `src/` directory load from there, so that's the merge target. The
+      // competing path is reported separately for the error message.
+      filePath: target.srcExisting[0],
+      conflictingPath: target.rootExisting[0]
+    };
+  }
+  const filePath = target.target;
+  const layout = target.layout;
+  if (filePath === null || layout === null) {
+    return { action: "unrecognized" };
+  }
+  const force = options.force === true;
+  const prompt = options.prompt ?? defaultInstrumentationPrompt;
+  if (!fs.existsSync(filePath)) {
+    const content = `import { registerGlasstrace } from "@glasstrace/sdk";
+
+export async function register() {
+  // Glasstrace must be registered before Prisma instrumentation
+  // to ensure all ORM spans are captured correctly.
+  // If you use @prisma/instrumentation, import it after this call.
+  registerGlasstrace();
+}
+`;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf-8");
+    return { action: "created", filePath, layout };
+  }
+  const existing = fs.readFileSync(filePath, "utf-8");
+  if (hasRegisterGlasstraceCall(existing)) {
+    return { action: "already-registered", filePath, layout };
+  }
+  if (!force) {
+    const approved = await prompt(
+      `Merge registerGlasstrace() into ${path.relative(projectRoot, filePath)}?`,
+      false
+    );
+    if (!approved) {
+      return { action: "skipped", filePath, layout };
+    }
+  }
+  const injectResult = injectRegisterGlasstrace(existing);
+  if (injectResult.injected) {
+    fs.writeFileSync(filePath, injectResult.content, "utf-8");
+    return { action: "injected", filePath, layout };
+  }
+  const appended = appendRegisterFunction(existing);
+  fs.writeFileSync(filePath, appended, "utf-8");
+  return { action: "appended", filePath, layout };
+}
+async function scaffoldNextConfig(projectRoot) {
+  let configPath;
+  let configName;
+  for (const name of NEXT_CONFIG_NAMES) {
+    const candidate = path.join(projectRoot, name);
+    if (fs.existsSync(candidate)) {
+      configPath = candidate;
+      configName = name;
+      break;
+    }
+  }
+  if (configPath === void 0 || configName === void 0) {
+    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 { 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 { modified: false, reason: "no-export" };
+    }
+    const modified2 = importLine + "\n" + wrapResult2.content;
+    fs.writeFileSync(configPath, modified2, "utf-8");
+    return { modified: true };
+  }
+  const requireLine = 'const { withGlasstraceConfig } = require("@glasstrace/sdk");\n';
+  const wrapResult = wrapCJSExport(existing);
+  if (!wrapResult.wrapped) {
+    return { modified: false, reason: "no-export" };
+  }
+  const modified = requireLine + "\n" + wrapResult.content;
+  fs.writeFileSync(configPath, modified, "utf-8");
+  return { modified: true };
+}
+function wrapExport(content) {
+  const marker = "export default";
+  const idx = content.lastIndexOf(marker);
+  if (idx === -1) {
+    return { content, wrapped: false };
+  }
+  const preamble = content.slice(0, idx);
+  const exprRaw = content.slice(idx + marker.length);
+  const expr = exprRaw.trim().replace(/;?\s*$/, "");
+  if (expr.length === 0) {
+    return { content, wrapped: false };
+  }
+  return {
+    content: preamble + `export default withGlasstraceConfig(${expr});
+`,
+    wrapped: true
+  };
+}
+function wrapCJSExport(content) {
+  const cjsMarker = "module.exports";
+  const cjsIdx = content.lastIndexOf(cjsMarker);
+  if (cjsIdx === -1) {
+    return { content, wrapped: false };
+  }
+  const preamble = content.slice(0, cjsIdx);
+  const afterMarker = content.slice(cjsIdx + cjsMarker.length);
+  const eqMatch = /^\s*=\s*/.exec(afterMarker);
+  if (!eqMatch) {
+    return { content, wrapped: false };
+  }
+  const exprRaw = afterMarker.slice(eqMatch[0].length);
+  const expr = exprRaw.trim().replace(/;?\s*$/, "");
+  if (expr.length === 0) {
+    return { content, wrapped: false };
+  }
+  return {
+    content: preamble + `module.exports = withGlasstraceConfig(${expr});
+`,
+    wrapped: true
+  };
+}
+async function scaffoldEnvLocal(projectRoot) {
+  const filePath = path.join(projectRoot, ".env.local");
+  if (fs.existsSync(filePath)) {
+    const existing = fs.readFileSync(filePath, "utf-8");
+    if (/^\s*#?\s*GLASSTRACE_API_KEY\s*=/m.test(existing)) {
+      return false;
+    }
+    const separator = existing.endsWith("\n") ? "" : "\n";
+    fs.writeFileSync(filePath, existing + separator + "# GLASSTRACE_API_KEY=your_key_here\n", "utf-8");
+    return true;
+  }
+  fs.writeFileSync(filePath, "# GLASSTRACE_API_KEY=your_key_here\n", "utf-8");
+  return true;
+}
+async function addCoverageMapEnv(projectRoot) {
+  const filePath = path.join(projectRoot, ".env.local");
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, "GLASSTRACE_COVERAGE_MAP=true\n", "utf-8");
+    return true;
+  }
+  const existing = fs.readFileSync(filePath, "utf-8");
+  const keyRegex = /^(\s*GLASSTRACE_COVERAGE_MAP\s*=\s*)(.*)$/m;
+  const keyMatch = keyRegex.exec(existing);
+  if (keyMatch) {
+    const currentValue = keyMatch[2].trim();
+    if (currentValue === "true") {
+      return false;
+    }
+    const updated = existing.replace(keyRegex, `${keyMatch[1]}true`);
+    fs.writeFileSync(filePath, updated, "utf-8");
+    return true;
+  }
+  const separator = existing.endsWith("\n") ? "" : "\n";
+  fs.writeFileSync(filePath, existing + separator + "GLASSTRACE_COVERAGE_MAP=true\n", "utf-8");
+  return true;
+}
+async function scaffoldGitignore(projectRoot) {
+  const filePath = path.join(projectRoot, ".gitignore");
+  if (fs.existsSync(filePath)) {
+    const existing = fs.readFileSync(filePath, "utf-8");
+    const lines = existing.split("\n").map((l) => l.trim());
+    if (lines.includes(".glasstrace/")) {
+      return false;
+    }
+    const separator = existing.endsWith("\n") ? "" : "\n";
+    fs.writeFileSync(filePath, existing + separator + ".glasstrace/\n", "utf-8");
+    return true;
+  }
+  fs.writeFileSync(filePath, ".glasstrace/\n", "utf-8");
+  return true;
+}
+
+// src/cli/init.ts
 function meetsNodeVersion(minMajor) {
   const [major] = process.versions.node.split(".").map(Number);
   return major >= minMajor;
@@ -65,8 +436,8 @@ function meetsNodeVersion(minMajor) {
 async function decideMcpConfigAction(options) {
   const { configPath, expectedContent, force } = options;
   if (configPath === null) return "write";
-  const exists = options.existsSync ?? fs.existsSync;
-  const read = options.readFile ?? ((p) => fs.readFileSync(p, "utf-8"));
+  const exists = options.existsSync ?? fs2.existsSync;
+  const read = options.readFile ?? ((p) => fs2.readFileSync(p, "utf-8"));
   const prompt = options.prompt ?? promptYesNo;
   if (!exists(configPath)) return "write";
   let existingContent;
@@ -163,17 +534,17 @@ async function rollbackSteps(steps, projectRoot, state) {
     try {
       switch (step) {
         case "instrumentation": {
-          const instrPath = state?.instrumentationPath ?? path.join(projectRoot, "instrumentation.ts");
-          if (fs.existsSync(instrPath)) {
-            const content = fs.readFileSync(instrPath, "utf-8");
+          const instrPath = state?.instrumentationPath ?? path2.join(projectRoot, "instrumentation.ts");
+          if (fs2.existsSync(instrPath)) {
+            const content = fs2.readFileSync(instrPath, "utf-8");
             if (isInitCreatedInstrumentation(content)) {
-              fs.unlinkSync(instrPath);
+              fs2.unlinkSync(instrPath);
             } else if (state?.originalInstrumentationContent !== void 0) {
-              fs.writeFileSync(instrPath, state.originalInstrumentationContent, "utf-8");
+              fs2.writeFileSync(instrPath, state.originalInstrumentationContent, "utf-8");
             } else {
               const cleaned = removeRegisterGlasstrace(content);
               if (cleaned !== content) {
-                fs.writeFileSync(instrPath, cleaned, "utf-8");
+                fs2.writeFileSync(instrPath, cleaned, "utf-8");
               }
             }
           }
@@ -181,11 +552,11 @@ async function rollbackSteps(steps, projectRoot, state) {
         }
         case "next-config": {
           for (const name of NEXT_CONFIG_NAMES) {
-            const configPath = path.join(projectRoot, name);
-            if (!fs.existsSync(configPath)) {
+            const configPath = path2.join(projectRoot, name);
+            if (!fs2.existsSync(configPath)) {
               continue;
             }
-            const content = fs.readFileSync(configPath, "utf-8");
+            const content = fs2.readFileSync(configPath, "utf-8");
             if (!content.includes("withGlasstraceConfig")) {
               continue;
             }
@@ -193,16 +564,16 @@ async function rollbackSteps(steps, projectRoot, state) {
             const unwrapResult = isESM ? unwrapExport(content) : unwrapCJSExport(content);
             if (unwrapResult.unwrapped) {
               const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
-              fs.writeFileSync(configPath, cleanLeadingBlankLines(cleaned), "utf-8");
+              fs2.writeFileSync(configPath, cleanLeadingBlankLines(cleaned), "utf-8");
             }
             break;
           }
           break;
         }
         case "env-local": {
-          const envPath = path.join(projectRoot, ".env.local");
-          if (fs.existsSync(envPath)) {
-            const content = fs.readFileSync(envPath, "utf-8");
+          const envPath = path2.join(projectRoot, ".env.local");
+          if (fs2.existsSync(envPath)) {
+            const content = fs2.readFileSync(envPath, "utf-8");
             const lines = content.split("\n");
             const filtered = lines.filter((line) => {
               const trimmed = line.trim();
@@ -211,18 +582,18 @@ async function rollbackSteps(steps, projectRoot, state) {
             if (filtered.length !== lines.length) {
               const result = filtered.join("\n");
               if (result.trim().length === 0) {
-                fs.unlinkSync(envPath);
+                fs2.unlinkSync(envPath);
               } else {
-                fs.writeFileSync(envPath, result, "utf-8");
+                fs2.writeFileSync(envPath, result, "utf-8");
               }
             }
           }
           break;
         }
         case "gitignore": {
-          const gitignorePath = path.join(projectRoot, ".gitignore");
-          if (fs.existsSync(gitignorePath)) {
-            const content = fs.readFileSync(gitignorePath, "utf-8");
+          const gitignorePath = path2.join(projectRoot, ".gitignore");
+          if (fs2.existsSync(gitignorePath)) {
+            const content = fs2.readFileSync(gitignorePath, "utf-8");
             const lines = content.split("\n");
             const filtered = lines.filter(
               (line) => line.trim() !== ".glasstrace/"
@@ -230,9 +601,9 @@ async function rollbackSteps(steps, projectRoot, state) {
             if (filtered.length !== lines.length) {
               const result = filtered.join("\n");
               if (result.trim().length === 0) {
-                fs.unlinkSync(gitignorePath);
+                fs2.unlinkSync(gitignorePath);
               } else {
-                fs.writeFileSync(gitignorePath, result, "utf-8");
+                fs2.writeFileSync(gitignorePath, result, "utf-8");
               }
             }
           }
@@ -263,8 +634,8 @@ async function runInit(options) {
     errors.push(err instanceof Error ? err.message : String(err));
     return { exitCode: 1, summary, warnings, errors };
   }
-  const packageJsonPath = path.join(projectRoot, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
+  const packageJsonPath = path2.join(projectRoot, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
     errors.push("No package.json found. Run this command from a Node.js project root.");
     return { exitCode: 1, summary, warnings, errors };
   }
@@ -273,8 +644,8 @@ async function runInit(options) {
     const preResolved = resolveInstrumentationTarget(projectRoot);
     if (!preResolved.conflict && preResolved.target !== null) {
       rollbackState.instrumentationPath = preResolved.target;
-      if (fs.existsSync(preResolved.target)) {
-        rollbackState.originalInstrumentationContent = fs.readFileSync(
+      if (fs2.existsSync(preResolved.target)) {
+        rollbackState.originalInstrumentationContent = fs2.readFileSync(
           preResolved.target,
           "utf-8"
         );
@@ -289,7 +660,7 @@ async function runInit(options) {
     if (instrResult.filePath !== void 0) {
       rollbackState.instrumentationPath = instrResult.filePath;
     }
-    const relativePath = instrResult.filePath !== void 0 ? path.relative(projectRoot, instrResult.filePath) : "instrumentation.ts";
+    const relativePath = instrResult.filePath !== void 0 ? path2.relative(projectRoot, instrResult.filePath) : "instrumentation.ts";
     switch (instrResult.action) {
       case "created":
         summary.push(`Created ${relativePath}`);
@@ -314,8 +685,8 @@ async function runInit(options) {
         );
         break;
       case "conflict": {
-        const primary = instrResult.filePath !== void 0 ? path.relative(projectRoot, instrResult.filePath) : "src/instrumentation.ts";
-        const competing = instrResult.conflictingPath !== void 0 ? path.relative(projectRoot, instrResult.conflictingPath) : "instrumentation.ts";
+        const primary = instrResult.filePath !== void 0 ? path2.relative(projectRoot, instrResult.filePath) : "src/instrumentation.ts";
+        const competing = instrResult.conflictingPath !== void 0 ? path2.relative(projectRoot, instrResult.conflictingPath) : "instrumentation.ts";
         await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
         errors.push(
           `Both ${primary} and ${competing} exist. Next.js's loader behavior is undefined when both are present.
@@ -362,10 +733,10 @@ Then add this as the first statement in your register() function:
     return { exitCode: 1, summary, warnings, errors };
   }
   try {
-    const envPathForCheck = path.join(projectRoot, ".env.local");
+    const envPathForCheck = path2.join(projectRoot, ".env.local");
     let existingDevKey = false;
-    if (fs.existsSync(envPathForCheck)) {
-      const existingContent = fs.readFileSync(envPathForCheck, "utf-8");
+    if (fs2.existsSync(envPathForCheck)) {
+      const existingContent = fs2.readFileSync(envPathForCheck, "utf-8");
       existingDevKey = isDevApiKey(readEnvLocalApiKey(existingContent));
     }
     const envCreated = await scaffoldEnvLocal(projectRoot);
@@ -430,10 +801,10 @@ Then add this as the first statement in your register() function:
           );
           break;
       }
-      const gitignorePath = path.join(projectRoot, ".gitignore");
-      if (fs.existsSync(gitignorePath)) {
+      const gitignorePath = path2.join(projectRoot, ".gitignore");
+      if (fs2.existsSync(gitignorePath)) {
         try {
-          const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+          const gitignoreContent = fs2.readFileSync(gitignorePath, "utf-8");
           if (gitignoreExcludesDiscoveryFile(gitignoreContent, discoveryResult.layout)) {
             warnings.push(
               `Your .gitignore excludes ${relPath} (directly or via a parent rule). The discovery file must be committed for the Glasstrace browser extension to find it in deployed builds. Remove the matching line from .gitignore or add an explicit negation (e.g. \`!` + relPath + "`)."
@@ -450,15 +821,18 @@ Then add this as the first statement in your register() function:
       );
     }
     let anyConfigWritten = false;
+    let anyConfigRewrittenWithBearer = false;
+    const resolved = await resolveEffectiveMcpCredential(projectRoot);
+    const bearer = resolved.effective?.key ?? anonKey;
     if (isCI) {
       const genericAgent = {
         name: "generic",
-        mcpConfigPath: path.join(projectRoot, ".glasstrace", "mcp.json"),
+        mcpConfigPath: path2.join(projectRoot, ".glasstrace", "mcp.json"),
         infoFilePath: null,
         cliAvailable: false,
         registrationCommand: null
       };
-      const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, anonKey);
+      const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, bearer);
       const decision = await decideMcpConfigAction({
         configPath: genericAgent.mcpConfigPath,
         expectedContent: genericConfig,
@@ -466,8 +840,11 @@ Then add this as the first statement in your register() function:
       });
       if (decision !== "skip") {
         await writeMcpConfig(genericAgent, genericConfig, projectRoot);
+        if (genericAgent.mcpConfigPath !== null && fs2.existsSync(genericAgent.mcpConfigPath)) {
+          anyConfigRewrittenWithBearer = true;
+        }
       }
-      if (genericAgent.mcpConfigPath !== null && fs.existsSync(genericAgent.mcpConfigPath)) {
+      if (genericAgent.mcpConfigPath !== null && fs2.existsSync(genericAgent.mcpConfigPath)) {
         anyConfigWritten = true;
         summary.push("Created .glasstrace/mcp.json (CI mode)");
       }
@@ -481,22 +858,23 @@ Then add this as the first statement in your register() function:
         );
         const genericAgent = {
           name: "generic",
-          mcpConfigPath: path.join(projectRoot, ".glasstrace", "mcp.json"),
+          mcpConfigPath: path2.join(projectRoot, ".glasstrace", "mcp.json"),
           infoFilePath: null,
           cliAvailable: false,
           registrationCommand: null
         };
-        const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, anonKey);
+        const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, bearer);
         await writeMcpConfig(genericAgent, genericConfig, projectRoot);
-        if (genericAgent.mcpConfigPath !== null && fs.existsSync(genericAgent.mcpConfigPath)) {
+        if (genericAgent.mcpConfigPath !== null && fs2.existsSync(genericAgent.mcpConfigPath)) {
           anyConfigWritten = true;
+          anyConfigRewrittenWithBearer = true;
         }
         agents = [];
       }
       const configuredNames = [];
       for (const agent of agents) {
         try {
-          const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
+          const configContent = generateMcpConfig(agent, MCP_ENDPOINT, bearer);
           const decision = await decideMcpConfigAction({
             configPath: agent.mcpConfigPath,
             expectedContent: configContent,
@@ -506,17 +884,18 @@ Then add this as the first statement in your register() function:
             summary.push(
               `Preserved existing ${agent.mcpConfigPath ?? agent.name} (user declined overwrite)`
             );
-            if (agent.mcpConfigPath !== null && fs.existsSync(agent.mcpConfigPath)) {
+            if (agent.mcpConfigPath !== null && fs2.existsSync(agent.mcpConfigPath)) {
               anyConfigWritten = true;
             }
             continue;
           }
           await writeMcpConfig(agent, configContent, projectRoot);
-          const configExists = agent.mcpConfigPath !== null && fs.existsSync(agent.mcpConfigPath);
+          const configExists = agent.mcpConfigPath !== null && fs2.existsSync(agent.mcpConfigPath);
           if (!configExists) {
             continue;
           }
           anyConfigWritten = true;
+          anyConfigRewrittenWithBearer = true;
           const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
           if (infoContent !== "") {
             await injectInfoSection(agent, infoContent, projectRoot);
@@ -540,8 +919,13 @@ Then add this as the first statement in your register() function:
       [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".codex/config.toml"],
       projectRoot
     );
-    if (anyConfigWritten) {
-      const markerCreated = await scaffoldMcpMarker(projectRoot, anonKey);
+    if (anyConfigRewrittenWithBearer) {
+      const markerSource = resolved.effective?.source ?? "anon";
+      const markerHash = identityFingerprint(bearer);
+      const markerCreated = await writeMcpMarker(projectRoot, {
+        credentialSource: markerSource,
+        credentialHash: markerHash
+      });
       if (markerCreated) {
         summary.push("Created .glasstrace/mcp-connected marker");
       }
@@ -598,9 +982,9 @@ async function verifyAnonKeyRegistration(projectRoot) {
   }
   let devKey;
   try {
-    const envPath = path.join(projectRoot, ".env.local");
-    if (fs.existsSync(envPath)) {
-      const envContent = fs.readFileSync(envPath, "utf-8");
+    const envPath = path2.join(projectRoot, ".env.local");
+    if (fs2.existsSync(envPath)) {
+      const envContent = fs2.readFileSync(envPath, "utf-8");
       const effective = readEnvLocalApiKey(envContent);
       if (effective !== null && isDevApiKey(effective)) {
         devKey = effective;
@@ -610,7 +994,7 @@ async function verifyAnonKeyRegistration(projectRoot) {
   }
   const baseConfig = resolveConfig({ apiKey: devKey });
   const config = { ...baseConfig, apiKey: devKey };
-  const sdkVersion = true ? "1.1.0" : "0.0.0-dev";
+  const sdkVersion = true ? "1.1.2" : "0.0.0-dev";
   const result = await verifyInitReachable(config, anonKey, sdkVersion);
   if (result.ok) {
     return { outcome: "verified" };
@@ -659,7 +1043,7 @@ function parseArgs(argv) {
   };
 }
 var scriptPath = typeof process !== "undefined" && process.argv[1] !== void 0 ? process.argv[1].replace(/\\/g, "/") : void 0;
-var scriptBasename = scriptPath !== void 0 ? path.basename(scriptPath) : void 0;
+var scriptBasename = scriptPath !== void 0 ? path2.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)) {
@@ -806,7 +1190,7 @@ Usage: glasstrace mcp add [--force] [--dry-run]
   } else if (subcommand === "status") {
     const remainingArgs = process.argv.slice(3);
     const json = remainingArgs.includes("--json");
-    Promise.all([import("./status.js"), import("../monorepo-N5Z63XP7.js")]).then(([{ runStatus }, { resolveProjectRoot: resolve }]) => {
+    Promise.all([import("./status.js"), import("../monorepo-PFVNPQ6X.js")]).then(([{ runStatus }, { resolveProjectRoot: resolve }]) => {
       let projectRoot = process.cwd();
       try {
         projectRoot = resolve(projectRoot).projectRoot;