@glasstrace/sdk 0.14.2 → 0.16.0

package/dist/cli/init.js

@@ -1,53 +1,86 @@
 #!/usr/bin/env node
 import {
   resolveProjectRoot
-} from "../chunk-PD2SKFQQ.js";
+} from "../chunk-55FBXXER.js";
 import {
-  buildImportGraph
-} from "../chunk-UPS5BGER.js";
+  buildImportGraph,
+  verifyInitReachable
+} from "../chunk-5C2TJFLB.js";
+import {
+  resolveConfig
+} from "../chunk-VUZCLMIX.js";
 import {
   isInitCreatedInstrumentation,
   removeGlasstraceConfigImport,
   removeRegisterGlasstrace,
   unwrapCJSExport,
   unwrapExport
-} from "../chunk-ARAOZCZT.js";
+} from "../chunk-XNDHQN4S.js";
 import {
-  addCoverageMapEnv,
   detectAgents,
   generateInfoSection,
   generateMcpConfig,
   injectInfoSection,
+  updateGitignore,
+  writeMcpConfig
+} from "../chunk-CTJI2YKA.js";
+import {
+  getOrCreateAnonKey,
+  readAnonKey
+} from "../chunk-TM5NKZTO.js";
+import "../chunk-7JBKXSBU.js";
+import {
+  addCoverageMapEnv,
+  isDevApiKey,
+  mcpConfigMatches,
+  readEnvLocalApiKey,
+  resolveInstrumentationTarget,
   scaffoldEnvLocal,
   scaffoldGitignore,
   scaffoldInstrumentation,
   scaffoldMcpMarker,
-  scaffoldNextConfig,
-  updateGitignore,
-  writeMcpConfig
-} from "../chunk-WV3NIPWJ.js";
-import {
-  getOrCreateAnonKey
-} from "../chunk-ECEN724Y.js";
-import "../chunk-YMEXDDTA.js";
+  scaffoldNextConfig
+} from "../chunk-O63DJKIJ.js";
 import {
   MCP_ENDPOINT,
   NEXT_CONFIG_NAMES,
   formatAgentName
-} from "../chunk-BL3YDC6V.js";
-import {
-  init_esm_shims
-} from "../chunk-BGZ7J74D.js";
+} from "../chunk-DXRZKKSO.js";
+import "../chunk-NSBPE2FW.js";
 
 // src/cli/init.ts
-init_esm_shims();
-import * as fs from "fs";
-import * as path from "path";
-import * as readline from "readline";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
 function meetsNodeVersion(minMajor) {
   const [major] = process.versions.node.split(".").map(Number);
   return major >= 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 prompt = options.prompt ?? promptYesNo;
+  if (!exists(configPath)) return "write";
+  let existingContent;
+  try {
+    existingContent = read(configPath);
+  } catch {
+    return "write";
+  }
+  if (mcpConfigMatches(existingContent, expectedContent)) {
+    return "write";
+  }
+  if (force) {
+    return "force-overwrite";
+  }
+  const answer = await prompt(
+    `Existing MCP config at ${configPath} differs from Glasstrace's template. Overwrite?`,
+    false
+  );
+  return answer ? "force-overwrite" : "skip";
+}
 async function promptYesNo(question, defaultValue) {
   if (!process.stdin.isTTY) {
     return defaultValue;
@@ -77,7 +110,7 @@ async function rollbackSteps(steps, projectRoot, state) {
     try {
       switch (step) {
         case "instrumentation": {
-          const instrPath = path.join(projectRoot, "instrumentation.ts");
+          const instrPath = state?.instrumentationPath ?? path.join(projectRoot, "instrumentation.ts");
           if (fs.existsSync(instrPath)) {
             const content = fs.readFileSync(instrPath, "utf-8");
             if (isInitCreatedInstrumentation(content)) {
@@ -180,32 +213,76 @@ async function runInit(options) {
   }
   const rollbackState = { steps: [] };
   try {
-    const instrPath = path.join(projectRoot, "instrumentation.ts");
-    if (fs.existsSync(instrPath)) {
-      rollbackState.originalInstrumentationContent = fs.readFileSync(instrPath, "utf-8");
+    const preResolved = resolveInstrumentationTarget(projectRoot);
+    if (!preResolved.conflict && preResolved.target !== null) {
+      rollbackState.instrumentationPath = preResolved.target;
+      if (fs.existsSync(preResolved.target)) {
+        rollbackState.originalInstrumentationContent = fs.readFileSync(
+          preResolved.target,
+          "utf-8"
+        );
+      }
     }
-    const instrResult = await scaffoldInstrumentation(projectRoot);
+    const instrResult = await scaffoldInstrumentation(projectRoot, {
+      // `--yes` implies non-interactive automation and must not hang on a
+      // merge confirmation prompt. `--force` skips the prompt explicitly
+      // (DISC-1247 Scenario 2c parity).
+      force: options.force === true || options.yes
+    });
+    if (instrResult.filePath !== void 0) {
+      rollbackState.instrumentationPath = instrResult.filePath;
+    }
+    const relativePath = instrResult.filePath !== void 0 ? path.relative(projectRoot, instrResult.filePath) : "instrumentation.ts";
     switch (instrResult.action) {
       case "created":
-        summary.push("Created instrumentation.ts");
+        summary.push(`Created ${relativePath}`);
         rollbackState.steps.push("instrumentation");
         break;
       case "injected":
-        summary.push("Added registerGlasstrace() to existing instrumentation.ts");
+        summary.push(`Added registerGlasstrace() to existing ${relativePath}`);
+        rollbackState.steps.push("instrumentation");
+        break;
+      case "appended":
+        summary.push(
+          `Appended register() with registerGlasstrace() to ${relativePath}`
+        );
         rollbackState.steps.push("instrumentation");
         break;
       case "already-registered":
-        summary.push("Skipped instrumentation.ts (registerGlasstrace already present)");
+        summary.push(`Skipped ${relativePath} (registerGlasstrace already present)`);
         break;
+      case "skipped":
+        warnings.push(
+          `Preserved ${relativePath} (merge declined; re-run with --force to apply the merge without prompting)`
+        );
+        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";
+        await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
+        errors.push(
+          `Both ${primary} and ${competing} exist. Next.js's loader behavior is undefined when both are present.
+Merge your instrumentation into ${primary} and remove ${competing}, then re-run init.`
+        );
+        return { exitCode: 1, summary, warnings, errors };
+      }
       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'
+          `${relativePath} exists but has no recognizable register() function.
+Add this import at the top of your file:
+
+  import { registerGlasstrace } from "@glasstrace/sdk";
+
+Then add this as the first statement in your register() function:
+
+  registerGlasstrace();
+`
         );
         break;
     }
   } catch (err) {
     await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
-    errors.push(`Failed to write instrumentation.ts: ${err instanceof Error ? err.message : String(err)}`);
+    errors.push(`Failed to write instrumentation file: ${err instanceof Error ? err.message : String(err)}`);
     return { exitCode: 1, summary, warnings, errors };
   }
   try {
@@ -228,10 +305,20 @@ async function runInit(options) {
     return { exitCode: 1, summary, warnings, errors };
   }
   try {
+    const envPathForCheck = path.join(projectRoot, ".env.local");
+    let existingDevKey = false;
+    if (fs.existsSync(envPathForCheck)) {
+      const existingContent = fs.readFileSync(envPathForCheck, "utf-8");
+      existingDevKey = isDevApiKey(readEnvLocalApiKey(existingContent));
+    }
     const envCreated = await scaffoldEnvLocal(projectRoot);
     if (envCreated) {
       summary.push("Updated .env.local with Glasstrace configuration");
       rollbackState.steps.push("env-local");
+    } else if (existingDevKey) {
+      summary.push(
+        "Preserved existing .env.local (GLASSTRACE_API_KEY contains a claimed dev key)"
+      );
     } else {
       summary.push("Skipped .env.local (GLASSTRACE_API_KEY already configured)");
     }
@@ -256,7 +343,11 @@ 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 preExistingAnonKey = await readAnonKey(projectRoot);
     const anonKey = await getOrCreateAnonKey(projectRoot);
+    if (preExistingAnonKey !== null) {
+      summary.push("Preserved existing .glasstrace/anon_key");
+    }
     let anyConfigWritten = false;
     if (isCI) {
       const genericAgent = {
@@ -267,7 +358,14 @@ async function runInit(options) {
         registrationCommand: null
       };
       const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, anonKey);
-      await writeMcpConfig(genericAgent, genericConfig, projectRoot);
+      const decision = await decideMcpConfigAction({
+        configPath: genericAgent.mcpConfigPath,
+        expectedContent: genericConfig,
+        force: true
+      });
+      if (decision !== "skip") {
+        await writeMcpConfig(genericAgent, genericConfig, projectRoot);
+      }
       if (genericAgent.mcpConfigPath !== null && fs.existsSync(genericAgent.mcpConfigPath)) {
         anyConfigWritten = true;
         summary.push("Created .glasstrace/mcp.json (CI mode)");
@@ -298,6 +396,20 @@ async function runInit(options) {
       for (const agent of agents) {
         try {
           const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
+          const decision = await decideMcpConfigAction({
+            configPath: agent.mcpConfigPath,
+            expectedContent: configContent,
+            force: options.force === true || options.yes
+          });
+          if (decision === "skip") {
+            summary.push(
+              `Preserved existing ${agent.mcpConfigPath ?? agent.name} (user declined overwrite)`
+            );
+            if (agent.mcpConfigPath !== null && fs.existsSync(agent.mcpConfigPath)) {
+              anyConfigWritten = true;
+            }
+            continue;
+          }
           await writeMcpConfig(agent, configContent, projectRoot);
           const configExists = agent.mcpConfigPath !== null && fs.existsSync(agent.mcpConfigPath);
           if (!configExists) {
@@ -363,17 +475,76 @@ async function runInit(options) {
       warnings.push(`Import graph scan failed: ${err instanceof Error ? err.message : String(err)}. You can run it later.`);
     }
   }
+  const skipVerify = process.env["GLASSTRACE_SKIP_INIT_VERIFY"] === "1" || process.env["GLASSTRACE_SKIP_INIT_VERIFY"] === "true" || process.env["VITEST"] === "true";
+  if (!skipVerify && !isCI) {
+    const verifyResult = await verifyAnonKeyRegistration(projectRoot);
+    if (verifyResult.outcome === "failed") {
+      errors.push(verifyResult.error);
+      return { exitCode: 2, summary, warnings, errors };
+    }
+    if (verifyResult.outcome === "verified") {
+      summary.push("Verified anon key registration with Glasstrace API");
+    } else {
+      summary.push("Skipped anon key verification (no anon key on disk)");
+    }
+  }
   return { exitCode: 0, summary, warnings, errors };
 }
+async function verifyAnonKeyRegistration(projectRoot) {
+  const anonKey = await readAnonKey(projectRoot);
+  if (anonKey === null) {
+    return { outcome: "skipped" };
+  }
+  let devKey;
+  try {
+    const envPath = path.join(projectRoot, ".env.local");
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, "utf-8");
+      const effective = readEnvLocalApiKey(envContent);
+      if (effective !== null && isDevApiKey(effective)) {
+        devKey = effective;
+      }
+    }
+  } catch {
+  }
+  const baseConfig = resolveConfig({ apiKey: devKey });
+  const config = { ...baseConfig, apiKey: devKey };
+  const sdkVersion = true ? "0.16.0" : "0.0.0-dev";
+  const result = await verifyInitReachable(config, anonKey, sdkVersion);
+  if (result.ok) {
+    return { outcome: "verified" };
+  }
+  const hint = "Run 'npx glasstrace status' or 'npx glasstrace doctor' to diagnose.";
+  switch (result.reason) {
+    case "transport":
+      return {
+        outcome: "failed",
+        error: `Glasstrace init verification failed: fetch failed: ${result.detail}. ${hint}`
+      };
+    case "rejected":
+      return {
+        outcome: "failed",
+        error: `Glasstrace init verification failed: server rejected the key (HTTP ${result.status}). ${hint}`
+      };
+    case "malformed":
+      return {
+        outcome: "failed",
+        error: `Glasstrace init verification failed: server returned malformed response. ${hint}`
+      };
+  }
+}
 function parseArgs(argv) {
   const args = argv.slice(2);
   let yes = false;
   let coverageMap = false;
+  let force = false;
   for (const arg of args) {
     if (arg === "--yes" || arg === "-y") {
       yes = true;
     } else if (arg === "--coverage-map") {
       coverageMap = true;
+    } else if (arg === "--force") {
+      force = true;
     }
   }
   if (!process.stdin.isTTY) {
@@ -382,7 +553,8 @@ function parseArgs(argv) {
   return {
     projectRoot: process.cwd(),
     yes,
-    coverageMap
+    coverageMap,
+    force
   };
 }
 var scriptPath = typeof process !== "undefined" && process.argv[1] !== void 0 ? process.argv[1].replace(/\\/g, "/") : void 0;
@@ -424,47 +596,84 @@ Usage: glasstrace mcp add [--force] [--dry-run]
       process.exit(1);
     }
   } else if (subcommand === void 0 || subcommand === "init" || subcommand.startsWith("-")) {
-    const options = parseArgs(process.argv);
-    runInit(options).then((result) => {
-      if (result.errors.length > 0) {
-        for (const err of result.errors) {
-          process.stderr.write(`Error: ${err}
-`);
-        }
+    const forwardedArgs = process.argv.slice(subcommand === "init" ? 3 : 2);
+    if (forwardedArgs.includes("--validate")) {
+      let validateProjectRoot = process.cwd();
+      try {
+        validateProjectRoot = resolveProjectRoot(validateProjectRoot).projectRoot;
+      } catch {
       }
-      if (result.warnings.length > 0) {
-        for (const warn of result.warnings) {
-          process.stderr.write(`Warning: ${warn}
+      import("./validate.js").then(({ runValidate }) => runValidate({ projectRoot: validateProjectRoot })).then((result) => {
+        for (const line of result.summary) {
+          process.stderr.write(`${line}
 `);
         }
-      }
-      if (result.summary.length > 0) {
-        process.stderr.write("\nGlasstrace initialized successfully!\n\n");
-        for (const line of result.summary) {
-          process.stderr.write(`  - ${line}
+        for (const issue of result.issues) {
+          process.stderr.write(`  - ${issue.message}
 `);
+          if (issue.fix) {
+            process.stderr.write(`      Fix: ${issue.fix}
+`);
+          }
         }
-        process.stderr.write("\nNext steps:\n");
-        process.stderr.write("  1. Start your Next.js dev server\n");
+        process.exit(result.exitCode);
+      }).catch((err) => {
         process.stderr.write(
-          "  2. Glasstrace works immediately in anonymous mode\n"
+          `Fatal error: ${err instanceof Error ? err.message : String(err)}
+`
         );
+        process.exit(1);
+      });
+    } else {
+      const options = parseArgs(process.argv);
+      runInit(options).then((result) => {
+        if (result.errors.length > 0) {
+          for (const err of result.errors) {
+            process.stderr.write(`Error: ${err}
+`);
+          }
+        }
+        if (result.warnings.length > 0) {
+          for (const warn of result.warnings) {
+            process.stderr.write(`Warning: ${warn}
+`);
+          }
+        }
+        if (result.summary.length > 0) {
+          if (result.exitCode === 0) {
+            process.stderr.write("\nGlasstrace initialized successfully!\n\n");
+          } else {
+            process.stderr.write("\nGlasstrace init completed with errors.\n\n");
+          }
+          for (const line of result.summary) {
+            process.stderr.write(`  - ${line}
+`);
+          }
+          if (result.exitCode === 0) {
+            process.stderr.write("\nNext steps:\n");
+            process.stderr.write("  1. Start your Next.js dev server\n");
+            process.stderr.write(
+              "  2. Glasstrace works immediately in anonymous mode\n"
+            );
+            process.stderr.write(
+              "  3. To link to your account, set GLASSTRACE_API_KEY in .env.local\n\n"
+            );
+          }
+        }
+        process.exit(result.exitCode);
+      }).catch((err) => {
         process.stderr.write(
-          "  3. To link to your account, set GLASSTRACE_API_KEY in .env.local\n\n"
-        );
-      }
-      process.exit(result.exitCode);
-    }).catch((err) => {
-      process.stderr.write(
-        `Fatal error: ${err instanceof Error ? err.message : String(err)}
+          `Fatal error: ${err instanceof Error ? err.message : String(err)}
 `
-      );
-      process.exit(1);
-    });
+        );
+        process.exit(1);
+      });
+    }
   } else if (subcommand === "uninit") {
     const remainingArgs = process.argv.slice(3);
     const dryRun = remainingArgs.includes("--dry-run");
-    import("./uninit.js").then(({ runUninit }) => runUninit({ projectRoot: process.cwd(), dryRun })).then((result) => {
+    const force = remainingArgs.includes("--force");
+    import("./uninit.js").then(({ runUninit }) => runUninit({ projectRoot: process.cwd(), dryRun, force })).then((result) => {
       if (result.errors.length > 0) {
         for (const err of result.errors) {
           process.stderr.write(`Error: ${err}
@@ -496,7 +705,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-YILKGQXQ.js")]).then(([{ runStatus }, { resolveProjectRoot: resolve }]) => {
+    Promise.all([import("./status.js"), import("../monorepo-N5Z63XP7.js")]).then(([{ runStatus }, { resolveProjectRoot: resolve }]) => {
       let projectRoot = process.cwd();
       try {
         projectRoot = resolve(projectRoot).projectRoot;
@@ -538,8 +747,8 @@ Usage: glasstrace mcp add [--force] [--dry-run]
       `Unknown command: ${subcommand}
 
 Usage:
-  glasstrace init [--yes] [--coverage-map]
-  glasstrace uninit [--dry-run]
+  glasstrace init [--yes] [--coverage-map] [--force] [--validate]
+  glasstrace uninit [--dry-run] [--force]
   glasstrace status [--json]
   glasstrace mcp add [--force] [--dry-run]
 `
@@ -548,8 +757,10 @@ Usage:
   }
 }
 export {
+  decideMcpConfigAction,
   meetsNodeVersion,
   rollbackSteps,
-  runInit
+  runInit,
+  verifyAnonKeyRegistration
 };
 //# sourceMappingURL=init.js.map