@glasstrace/sdk 0.7.3 → 0.9.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;
@@ -472,10 +539,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -787,11 +854,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -1034,7 +1101,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path5 = []) => {
+  const processError = (error49, path7 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1044,7 +1111,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1076,8 +1143,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13841,13 +13908,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14824,9 +14891,9 @@ var init_anon_key = __esm({
 });
 
 // src/agent-detection/detect.ts
-async function pathExists(path5, mode = import_node_fs.constants.R_OK) {
+async function pathExists(path7, mode = import_node_fs.constants.R_OK) {
   try {
-    await (0, import_promises2.access)(path5, mode);
+    await (0, import_promises2.access)(path7, mode);
     return true;
   } catch {
     return false;
@@ -15380,11 +15447,11 @@ async function registerViaCli(agent, anonKey) {
           MCP_ENDPOINT
         ]);
         const configPath = agent.mcpConfigPath;
-        if (configPath !== null && fs3.existsSync(configPath)) {
-          const content = fs3.readFileSync(configPath, "utf-8");
+        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";
-            fs3.writeFileSync(
+            fs4.writeFileSync(
               configPath,
               content + appendContent + 'bearer_token_env_var = "GLASSTRACE_API_KEY"\n',
               "utf-8"
@@ -15429,8 +15496,8 @@ async function mcpAdd(options) {
       messages: ["Error: Run `glasstrace init` first to generate an API key."]
     };
   }
-  const markerPath = path3.join(projectRoot, ".glasstrace", "mcp-connected");
-  if (fs3.existsSync(markerPath) && !force) {
+  const markerPath = path4.join(projectRoot, ".glasstrace", "mcp-connected");
+  if (fs4.existsSync(markerPath) && !force) {
     return {
       exitCode: 0,
       results: [],
@@ -15489,7 +15556,7 @@ async function mcpAdd(options) {
       try {
         const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
         await writeMcpConfig(agent, configContent, projectRoot);
-        if (fs3.existsSync(agent.mcpConfigPath)) {
+        if (fs4.existsSync(agent.mcpConfigPath)) {
           const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
           if (infoContent !== "") {
             await injectInfoSection(agent, infoContent, projectRoot);
@@ -15556,13 +15623,13 @@ async function mcpAdd(options) {
   }
   return { exitCode: 0, results, messages };
 }
-var import_node_child_process2, fs3, path3, import_node_util, execFileAsync;
+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");
-    fs3 = __toESM(require("fs"), 1);
-    path3 = __toESM(require("path"), 1);
+    fs4 = __toESM(require("fs"), 1);
+    path4 = __toESM(require("path"), 1);
     import_node_util = require("util");
     init_anon_key();
     init_detect();
@@ -15574,6 +15641,552 @@ var init_mcp_add = __esm({
   }
 });
 
+// src/cli/uninit.ts
+var uninit_exports = {};
+__export(uninit_exports, {
+  findMatchingParen: () => findMatchingParen,
+  isInitCreatedInstrumentation: () => isInitCreatedInstrumentation,
+  processJsonMcpConfig: () => processJsonMcpConfig,
+  processTomlMcpConfig: () => processTomlMcpConfig,
+  removeGlasstraceConfigImport: () => removeGlasstraceConfigImport,
+  removeMarkerSection: () => removeMarkerSection,
+  removeRegisterGlasstrace: () => removeRegisterGlasstrace,
+  runUninit: () => runUninit,
+  unwrapCJSExport: () => unwrapCJSExport,
+  unwrapExport: () => unwrapExport
+});
+function findMatchingParen(text, openPos) {
+  let depth = 0;
+  for (let i = openPos; i < text.length; i++) {
+    if (text[i] === "(") {
+      depth++;
+    } else if (text[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function unwrapExport(content) {
+  const pattern = /export\s+default\s+withGlasstraceConfig\s*\(/;
+  const match = pattern.exec(content);
+  if (!match) {
+    return { content, unwrapped: false };
+  }
+  const openParenIdx = match.index + match[0].length - 1;
+  const closeParenIdx = findMatchingParen(content, openParenIdx);
+  if (closeParenIdx === -1) {
+    return { content, unwrapped: false };
+  }
+  const innerExpr = content.slice(openParenIdx + 1, closeParenIdx).trim();
+  if (innerExpr.length === 0) {
+    return { content, unwrapped: false };
+  }
+  const before = content.slice(0, match.index);
+  const afterClose = content.slice(closeParenIdx + 1);
+  const trailing = afterClose.replace(/^;?\s*/, "");
+  const result = before + `export default ${innerExpr};
+` + trailing;
+  return { content: result, unwrapped: true };
+}
+function unwrapCJSExport(content) {
+  const pattern = /module\.exports\s*=\s*withGlasstraceConfig\s*\(/;
+  const match = pattern.exec(content);
+  if (!match) {
+    return { content, unwrapped: false };
+  }
+  const openParenIdx = match.index + match[0].length - 1;
+  const closeParenIdx = findMatchingParen(content, openParenIdx);
+  if (closeParenIdx === -1) {
+    return { content, unwrapped: false };
+  }
+  const innerExpr = content.slice(openParenIdx + 1, closeParenIdx).trim();
+  if (innerExpr.length === 0) {
+    return { content, unwrapped: false };
+  }
+  const before = content.slice(0, match.index);
+  const afterClose = content.slice(closeParenIdx + 1);
+  const trailing = afterClose.replace(/^;?\s*/, "");
+  const result = before + `module.exports = ${innerExpr};
+` + trailing;
+  return { content: result, unwrapped: true };
+}
+function removeGlasstraceConfigImport(content) {
+  const esmSoleImport = /import\s*\{\s*withGlasstraceConfig\s*\}\s*from\s*["']@glasstrace\/sdk["']\s*;?\s*\n?/;
+  if (esmSoleImport.test(content)) {
+    return content.replace(esmSoleImport, "");
+  }
+  const esmMultiImport = /import\s*\{([^}]*)\}\s*from\s*["']@glasstrace\/sdk["']/;
+  const multiMatch = esmMultiImport.exec(content);
+  if (multiMatch) {
+    const specifiers = multiMatch[1].split(",").map((s) => s.trim()).filter((s) => s !== "" && s !== "withGlasstraceConfig");
+    if (specifiers.length === 0) {
+      return content.replace(
+        /import\s*\{[^}]*\}\s*from\s*["']@glasstrace\/sdk["']\s*;?\s*\n?/,
+        ""
+      );
+    }
+    const newImport = `import { ${specifiers.join(", ")} } from "@glasstrace/sdk"`;
+    return content.replace(multiMatch[0], newImport);
+  }
+  const cjsSoleRequire = /const\s*\{\s*withGlasstraceConfig\s*\}\s*=\s*require\s*\(\s*["']@glasstrace\/sdk["']\s*\)\s*;?\s*\n?/;
+  if (cjsSoleRequire.test(content)) {
+    return content.replace(cjsSoleRequire, "");
+  }
+  const cjsMultiRequire = /const\s*\{([^}]*)\}\s*=\s*require\s*\(\s*["']@glasstrace\/sdk["']\s*\)/;
+  const cjsMultiMatch = cjsMultiRequire.exec(content);
+  if (cjsMultiMatch) {
+    const specifiers = cjsMultiMatch[1].split(",").map((s) => s.trim()).filter((s) => s !== "" && s !== "withGlasstraceConfig");
+    if (specifiers.length === 0) {
+      return content.replace(
+        /const\s*\{[^}]*\}\s*=\s*require\s*\(\s*["']@glasstrace\/sdk["']\s*\)\s*;?\s*\n?/,
+        ""
+      );
+    }
+    const newRequire = `const { ${specifiers.join(", ")} } = require("@glasstrace/sdk")`;
+    return content.replace(cjsMultiMatch[0], newRequire);
+  }
+  return content;
+}
+function cleanLeadingBlankLines(content) {
+  return content.replace(/^\n{2,}/, "\n");
+}
+function isInitCreatedInstrumentation(content) {
+  const lines = content.split("\n");
+  const importLines = lines.filter(
+    (l) => /^\s*import\s/.test(l) && !l.trim().startsWith("//")
+  );
+  const nonGlasstraceImports = importLines.filter(
+    (l) => !l.includes("@glasstrace/sdk")
+  );
+  if (nonGlasstraceImports.length > 0) {
+    return false;
+  }
+  const registerFnRegex = /export\s+(?:async\s+)?function\s+register\s*\([^)]*\)\s*\{/;
+  const match = registerFnRegex.exec(content);
+  if (!match) {
+    return false;
+  }
+  const afterBrace = content.slice(match.index + match[0].length);
+  const closingBraceIdx = findMatchingBrace(content, match.index + match[0].length - 1);
+  if (closingBraceIdx === -1) {
+    return false;
+  }
+  const body = afterBrace.slice(0, closingBraceIdx - (match.index + match[0].length));
+  const bodyLines = body.split("\n");
+  const statements = bodyLines.filter((l) => {
+    const trimmed = l.trim();
+    return trimmed !== "" && !trimmed.startsWith("//");
+  });
+  if (statements.length !== 1) {
+    return false;
+  }
+  if (!/^\s*registerGlasstrace\s*\(\s*\)\s*;?\s*$/.test(statements[0])) {
+    return false;
+  }
+  const beforeFn = content.slice(0, match.index);
+  const afterFn = content.slice(closingBraceIdx + 1);
+  const topLevelBefore = beforeFn.split("\n").filter((l) => {
+    const trimmed = l.trim();
+    return trimmed !== "" && !trimmed.startsWith("//") && !trimmed.startsWith("import ") && !trimmed.startsWith("import{");
+  });
+  const topLevelAfter = afterFn.split("\n").filter((l) => {
+    const trimmed = l.trim();
+    return trimmed !== "" && !trimmed.startsWith("//");
+  });
+  return topLevelBefore.length === 0 && topLevelAfter.length === 0;
+}
+function findMatchingBrace(text, openPos) {
+  let depth = 0;
+  for (let i = openPos; i < text.length; i++) {
+    if (text[i] === "{") {
+      depth++;
+    } else if (text[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function removeRegisterGlasstrace(content) {
+  let result = content;
+  result = result.replace(
+    /[ \t]*\/\/\s*Glasstrace must be registered[^\n]*\n(?:[ \t]*\/\/[^\n]*\n)*[ \t]*registerGlasstrace\s*\(\s*\)\s*;?\s*\n?/g,
+    ""
+  );
+  result = result.replace(
+    /[ \t]*registerGlasstrace\s*\(\s*\)\s*;?\s*\n?/g,
+    ""
+  );
+  const soleImportPattern = /import\s*\{\s*registerGlasstrace\s*\}\s*from\s*["']@glasstrace\/sdk["']\s*;?\s*\n?/;
+  if (soleImportPattern.test(result)) {
+    result = result.replace(soleImportPattern, "");
+  } else {
+    const multiImportPattern = /import\s*\{([^}]*)\}\s*from\s*["']@glasstrace\/sdk["']/;
+    const multiMatch = multiImportPattern.exec(result);
+    if (multiMatch) {
+      const specifiers = multiMatch[1].split(",").map((s) => s.trim()).filter((s) => s !== "" && s !== "registerGlasstrace");
+      if (specifiers.length === 0) {
+        result = result.replace(
+          /import\s*\{[^}]*\}\s*from\s*["']@glasstrace\/sdk["']\s*;?\s*\n?/,
+          ""
+        );
+      } else {
+        const newImport = `import { ${specifiers.join(", ")} } from "@glasstrace/sdk"`;
+        result = result.replace(multiMatch[0], newImport);
+      }
+    }
+  }
+  return cleanLeadingBlankLines(result);
+}
+function removeMarkerSection(content) {
+  const lines = content.split("\n");
+  let startIdx = -1;
+  let endIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "<!-- glasstrace:mcp:start -->" || trimmed === "# glasstrace:mcp:start") {
+      startIdx = i;
+    } else if ((trimmed === "<!-- glasstrace:mcp:end -->" || trimmed === "# glasstrace:mcp:end") && startIdx !== -1) {
+      endIdx = i;
+      break;
+    }
+  }
+  if (startIdx === -1 || endIdx === -1) {
+    return { content, removed: false };
+  }
+  const before = lines.slice(0, startIdx);
+  const after = lines.slice(endIdx + 1);
+  while (before.length > 0 && before[before.length - 1].trim() === "") {
+    before.pop();
+  }
+  const result = [...before, ...after].join("\n");
+  const trimmedResult = result.trimEnd();
+  return {
+    content: trimmedResult.length > 0 ? trimmedResult + "\n" : "",
+    removed: true
+  };
+}
+function processJsonMcpConfig(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { action: "skipped" };
+  }
+  const mcpServers = parsed["mcpServers"];
+  if (!mcpServers || typeof mcpServers !== "object" || !("glasstrace" in mcpServers)) {
+    return { action: "skipped" };
+  }
+  const remainingServers = Object.keys(mcpServers).filter((k) => k !== "glasstrace");
+  const otherTopLevelKeys = Object.keys(parsed).filter((k) => k !== "mcpServers");
+  if (remainingServers.length === 0 && otherTopLevelKeys.length === 0) {
+    return { action: "deleted" };
+  }
+  const { glasstrace: _, ...rest } = mcpServers;
+  void _;
+  if (remainingServers.length > 0) {
+    parsed["mcpServers"] = rest;
+  } else {
+    delete parsed["mcpServers"];
+  }
+  return { action: "removed-key", content: JSON.stringify(parsed, null, 2) + "\n" };
+}
+function processTomlMcpConfig(content) {
+  if (!content.includes("[mcp_servers.glasstrace]")) {
+    return { action: "skipped" };
+  }
+  const lines = content.split("\n");
+  const startIdx = lines.findIndex(
+    (l) => l.trim() === "[mcp_servers.glasstrace]"
+  );
+  if (startIdx === -1) {
+    return { action: "skipped" };
+  }
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^\s*\[/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, startIdx);
+  const after = lines.slice(endIdx);
+  while (before.length > 0 && before[before.length - 1].trim() === "") {
+    before.pop();
+  }
+  const result = [...before, ...after].join("\n").trimEnd();
+  if (result.trim().length === 0) {
+    return { action: "deleted" };
+  }
+  return { action: "removed-section", content: result + "\n" };
+}
+async function runUninit(options) {
+  const { projectRoot, dryRun } = options;
+  const summary = [];
+  const warnings = [];
+  const errors = [];
+  const prefix = dryRun ? "[dry run] " : "";
+  try {
+    let configHandled = false;
+    for (const name of NEXT_CONFIG_NAMES3) {
+      const configPath = path5.join(projectRoot, name);
+      if (!fs5.existsSync(configPath)) {
+        continue;
+      }
+      const content = fs5.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);
+        const final = cleanLeadingBlankLines(cleaned);
+        if (!dryRun) {
+          fs5.writeFileSync(configPath, final, "utf-8");
+        }
+        summary.push(`${prefix}Unwrapped withGlasstraceConfig from ${name}`);
+        configHandled = true;
+        break;
+      } else {
+        warnings.push(
+          `${name} contains withGlasstraceConfig but could not be automatically unwrapped. Please remove withGlasstraceConfig() manually.`
+        );
+        configHandled = true;
+        break;
+      }
+    }
+    if (!configHandled) {
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to process next.config: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const instrPath = path5.join(projectRoot, "instrumentation.ts");
+    if (fs5.existsSync(instrPath)) {
+      const content = fs5.readFileSync(instrPath, "utf-8");
+      if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
+        if (isInitCreatedInstrumentation(content)) {
+          if (!dryRun) {
+            fs5.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");
+            }
+            summary.push(
+              `${prefix}Removed registerGlasstrace() from instrumentation.ts`
+            );
+          }
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to process instrumentation.ts: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const glasstraceDir = path5.join(projectRoot, ".glasstrace");
+    if (fs5.existsSync(glasstraceDir)) {
+      if (!dryRun) {
+        fs5.rmSync(glasstraceDir, { recursive: true, force: true });
+      }
+      summary.push(`${prefix}Removed .glasstrace/ directory`);
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to remove .glasstrace/: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const envPath = path5.join(projectRoot, ".env.local");
+    if (fs5.existsSync(envPath)) {
+      const content = fs5.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) || /^\s*#?\s*GLASSTRACE_COVERAGE_MAP\s*=/.test(trimmed));
+      });
+      if (filtered.length !== lines.length) {
+        const result = filtered.join("\n");
+        if (result.trim().length === 0) {
+          if (!dryRun) {
+            fs5.unlinkSync(envPath);
+          }
+          summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
+        } else {
+          if (!dryRun) {
+            fs5.writeFileSync(envPath, result, "utf-8");
+          }
+          summary.push(`${prefix}Removed GLASSTRACE entries from .env.local`);
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to process .env.local: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const gitignorePath = path5.join(projectRoot, ".gitignore");
+    if (fs5.existsSync(gitignorePath)) {
+      const content = fs5.readFileSync(gitignorePath, "utf-8");
+      const lines = content.split("\n");
+      const mcpGitignoreEntries = /* @__PURE__ */ new Set([
+        ".glasstrace/",
+        ".mcp.json",
+        ".cursor/mcp.json",
+        ".gemini/settings.json",
+        ".codex/config.toml"
+      ]);
+      const filtered = lines.filter(
+        (line) => !mcpGitignoreEntries.has(line.trim())
+      );
+      if (filtered.length !== lines.length) {
+        const result = filtered.join("\n");
+        if (result.trim().length === 0) {
+          if (!dryRun) {
+            fs5.unlinkSync(gitignorePath);
+          }
+          summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
+        } else {
+          if (!dryRun) {
+            fs5.writeFileSync(gitignorePath, result, "utf-8");
+          }
+          summary.push(`${prefix}Removed Glasstrace entries from .gitignore`);
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to process .gitignore: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    for (const configFile of MCP_CONFIG_FILES) {
+      const configPath = path5.join(projectRoot, configFile);
+      if (!fs5.existsSync(configPath)) {
+        continue;
+      }
+      const content = fs5.readFileSync(configPath, "utf-8");
+      const result = processJsonMcpConfig(content);
+      if (result.action === "deleted") {
+        if (!dryRun) {
+          fs5.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");
+        }
+        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 tomlResult = processTomlMcpConfig(content);
+      if (tomlResult.action === "deleted") {
+        if (!dryRun) {
+          fs5.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");
+        }
+        summary.push(`${prefix}Removed glasstrace from .codex/config.toml`);
+      }
+    }
+    const hasWindsurfMarkers = fs5.existsSync(path5.join(projectRoot, ".windsurfrules")) || fs5.existsSync(path5.join(projectRoot, ".windsurf"));
+    if (hasWindsurfMarkers) {
+      const windsurfConfigPath = path5.join(
+        os.homedir(),
+        ".codeium",
+        "windsurf",
+        "mcp_config.json"
+      );
+      if (fs5.existsSync(windsurfConfigPath)) {
+        const content = fs5.readFileSync(windsurfConfigPath, "utf-8");
+        const windsurfResult = processJsonMcpConfig(content);
+        if (windsurfResult.action === "deleted") {
+          if (!dryRun) {
+            fs5.unlinkSync(windsurfConfigPath);
+          }
+          summary.push(`${prefix}Deleted Windsurf MCP config`);
+        } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
+          if (!dryRun) {
+            fs5.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
+          }
+          summary.push(`${prefix}Removed glasstrace from Windsurf MCP config`);
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to process MCP config: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    for (const infoFile of AGENT_INFO_FILES) {
+      const filePath = path5.join(projectRoot, infoFile);
+      if (!fs5.existsSync(filePath)) {
+        continue;
+      }
+      const content = fs5.readFileSync(filePath, "utf-8");
+      const result = removeMarkerSection(content);
+      if (result.removed) {
+        if (result.content.trim().length === 0) {
+          if (!dryRun) {
+            fs5.unlinkSync(filePath);
+          }
+          summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
+        } else {
+          if (!dryRun) {
+            fs5.writeFileSync(filePath, result.content, "utf-8");
+          }
+          summary.push(`${prefix}Removed Glasstrace section from ${infoFile}`);
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(
+      `Failed to process agent info files: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (summary.length === 0 && errors.length === 0) {
+    summary.push("No Glasstrace artifacts found \u2014 nothing to do.");
+  }
+  return { exitCode: errors.length > 0 ? 1 : 0, summary, warnings, errors };
+}
+var fs5, os, path5, NEXT_CONFIG_NAMES3, MCP_CONFIG_FILES, AGENT_INFO_FILES;
+var init_uninit = __esm({
+  "src/cli/uninit.ts"() {
+    "use strict";
+    fs5 = __toESM(require("fs"), 1);
+    os = __toESM(require("os"), 1);
+    path5 = __toESM(require("path"), 1);
+    NEXT_CONFIG_NAMES3 = ["next.config.ts", "next.config.js", "next.config.mjs"];
+    MCP_CONFIG_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json"];
+    AGENT_INFO_FILES = [
+      "CLAUDE.md",
+      "codex.md",
+      ".cursorrules"
+    ];
+  }
+});
+
 // src/cli/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -15581,8 +16194,8 @@ __export(init_exports, {
   runInit: () => runInit
 });
 module.exports = __toCommonJS(init_exports);
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
 var readline = __toESM(require("readline"), 1);
 init_scaffolder();
 
@@ -15761,6 +16374,240 @@ init_detect();
 init_configs();
 init_inject();
 init_constants();
+
+// src/cli/monorepo.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var NEXT_CONFIG_NAMES2 = ["next.config.ts", "next.config.js", "next.config.mjs"];
+function resolveProjectRoot(cwd) {
+  if (hasNextConfig(cwd)) {
+    return { projectRoot: cwd, isMonorepo: false };
+  }
+  if (hasNextDependency(cwd)) {
+    return { projectRoot: cwd, isMonorepo: false };
+  }
+  if (isMonorepoRoot(cwd)) {
+    const apps = findNextJsApps(cwd);
+    if (apps.length === 0) {
+      throw new Error(
+        "This is a monorepo but no Next.js apps were found in workspace packages."
+      );
+    }
+    if (apps.length === 1) {
+      const appDir = apps[0];
+      const relativePath = path3.relative(cwd, appDir);
+      return {
+        projectRoot: appDir,
+        isMonorepo: true,
+        appRelativePath: relativePath
+      };
+    }
+    const appList = apps.map((app) => `  - ${path3.relative(cwd, app)}`).join("\n");
+    throw new Error(
+      `Found multiple Next.js apps:
+${appList}
+Run init from the specific app directory you want to instrument.`
+    );
+  }
+  throw new Error(
+    "No Next.js project found in the current directory.\nRun this command from your Next.js app directory, or from a monorepo root."
+  );
+}
+function hasNextConfig(dir) {
+  return NEXT_CONFIG_NAMES2.some(
+    (name) => fs3.existsSync(path3.join(dir, name))
+  );
+}
+function hasNextDependency(dir) {
+  const packageJsonPath = path3.join(dir, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) return false;
+  try {
+    const content = fs3.readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const deps = pkg["dependencies"];
+    const devDeps = pkg["devDependencies"];
+    if (typeof deps === "object" && deps !== null && "next" in deps) return true;
+    if (typeof devDeps === "object" && devDeps !== null && "next" in devDeps) return true;
+  } catch {
+  }
+  return false;
+}
+function isMonorepoRoot(dir) {
+  if (fs3.existsSync(path3.join(dir, "pnpm-workspace.yaml"))) return true;
+  if (fs3.existsSync(path3.join(dir, "turbo.json"))) return true;
+  if (fs3.existsSync(path3.join(dir, "lerna.json"))) return true;
+  const packageJsonPath = path3.join(dir, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    try {
+      const content = fs3.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg["workspaces"] !== void 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function findNextJsApps(monorepoRoot) {
+  const { includeGlobs, negationPatterns } = collectWorkspaceGlobs(monorepoRoot);
+  if (includeGlobs.length === 0) {
+    throw new Error(
+      'Monorepo detected but no workspace configuration found.\nAdd a "workspaces" field to package.json or create pnpm-workspace.yaml.'
+    );
+  }
+  const workspaceDirs = expandGlobs(monorepoRoot, includeGlobs);
+  const excludedDirs = expandGlobs(monorepoRoot, negationPatterns);
+  const excludedSet = new Set(excludedDirs);
+  const seen = /* @__PURE__ */ new Set();
+  const nextApps = [];
+  for (const dir of workspaceDirs) {
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    if (excludedSet.has(dir)) continue;
+    if (hasNextConfig(dir) || hasNextDependency(dir)) {
+      nextApps.push(dir);
+    }
+  }
+  return nextApps.sort();
+}
+function collectWorkspaceGlobs(root) {
+  const globs = [];
+  const negations = [];
+  const pnpmPath = path3.join(root, "pnpm-workspace.yaml");
+  if (fs3.existsSync(pnpmPath)) {
+    const content = fs3.readFileSync(pnpmPath, "utf-8");
+    const parsed = parsePnpmWorkspaceYaml(content);
+    globs.push(...parsed.includeGlobs);
+    negations.push(...parsed.negationPatterns);
+  }
+  const packageJsonPath = path3.join(root, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    try {
+      const content = fs3.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      globs.push(...parsePackageJsonWorkspaces(pkg));
+    } catch {
+    }
+  }
+  const lernaPath = path3.join(root, "lerna.json");
+  if (fs3.existsSync(lernaPath)) {
+    try {
+      const content = fs3.readFileSync(lernaPath, "utf-8");
+      const lerna = JSON.parse(content);
+      const packages = lerna["packages"];
+      if (Array.isArray(packages)) {
+        for (const pkg of packages) {
+          if (typeof pkg === "string") {
+            globs.push(pkg);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    includeGlobs: [...new Set(globs)],
+    negationPatterns: [...new Set(negations)]
+  };
+}
+function parsePnpmWorkspaceYaml(content) {
+  const lines = content.split("\n");
+  const includeGlobs = [];
+  const negationPatterns = [];
+  let inPackages = false;
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (/^packages\s*:/.test(trimmed)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages && trimmed.length > 0 && !trimmed.startsWith("-") && !rawLine.startsWith(" ") && !rawLine.startsWith("	")) {
+      inPackages = false;
+      continue;
+    }
+    if (!inPackages) continue;
+    const itemMatch = /^\s*-\s+(.+)$/.exec(rawLine);
+    if (!itemMatch) continue;
+    const value = itemMatch[1].trim().replace(/^["']|["']$/g, "");
+    if (value.length === 0) continue;
+    if (value.startsWith("!")) {
+      negationPatterns.push(value.slice(1));
+      continue;
+    }
+    includeGlobs.push(value);
+  }
+  return { includeGlobs, negationPatterns };
+}
+function parsePackageJsonWorkspaces(pkg) {
+  const workspaces = pkg["workspaces"];
+  if (workspaces === void 0 || workspaces === null) return [];
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((w) => typeof w === "string");
+  }
+  if (typeof workspaces === "object") {
+    const obj = workspaces;
+    const packages = obj["packages"];
+    if (Array.isArray(packages)) {
+      return packages.filter((p) => typeof p === "string");
+    }
+  }
+  return [];
+}
+function expandGlobs(root, globs) {
+  const dirs = [];
+  for (const glob of globs) {
+    const cleanGlob = glob.replace(/\/+$/, "");
+    if (cleanGlob.includes("**")) {
+      const prefix = cleanGlob.split("**")[0].replace(/\/+$/, "");
+      const baseDir = path3.join(root, prefix);
+      if (fs3.existsSync(baseDir)) {
+        dirs.push(...walkDirectories(baseDir));
+      }
+    } else if (cleanGlob.includes("*")) {
+      const parts = cleanGlob.split("*");
+      const baseDir = path3.join(root, parts[0].replace(/\/+$/, ""));
+      const suffix = parts.slice(1).join("*");
+      if (!fs3.existsSync(baseDir)) continue;
+      let entries;
+      try {
+        entries = fs3.readdirSync(baseDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (suffix && !entry.name.endsWith(suffix)) continue;
+        dirs.push(path3.join(baseDir, entry.name));
+      }
+    } else {
+      const targetDir = path3.join(root, cleanGlob);
+      if (fs3.existsSync(targetDir) && fs3.statSync(targetDir).isDirectory()) {
+        dirs.push(targetDir);
+      }
+    }
+  }
+  return dirs;
+}
+function walkDirectories(baseDir) {
+  const result = [];
+  let entries;
+  try {
+    entries = fs3.readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    const fullPath = path3.join(baseDir, entry.name);
+    if (fs3.existsSync(path3.join(fullPath, "package.json"))) {
+      result.push(fullPath);
+    }
+    result.push(...walkDirectories(fullPath));
+  }
+  return result;
+}
+
+// src/cli/init.ts
 function meetsNodeVersion(minMajor) {
   const [major] = process.versions.node.split(".").map(Number);
   return major >= minMajor;
@@ -15787,32 +16634,43 @@ async function promptYesNo(question, defaultValue) {
   });
 }
 async function runInit(options) {
-  const { projectRoot, yes, coverageMap } = options;
+  const { yes, coverageMap } = options;
   const summary = [];
   const warnings = [];
   const errors = [];
-  const packageJsonPath = path4.join(projectRoot, "package.json");
-  if (!fs4.existsSync(packageJsonPath)) {
-    errors.push("No package.json found. Run this command from a Node.js project root.");
+  let projectRoot;
+  try {
+    const classification = resolveProjectRoot(options.projectRoot);
+    projectRoot = classification.projectRoot;
+    if (classification.isMonorepo && classification.appRelativePath) {
+      summary.push(`Found Next.js app at ${classification.appRelativePath} \u2014 installing there`);
+    }
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
     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;
+  const packageJsonPath = path6.join(projectRoot, "package.json");
+  if (!fs6.existsSync(packageJsonPath)) {
+    errors.push("No package.json found. Run this command from a Node.js project root.");
+    return { exitCode: 1, summary, warnings, errors };
   }
   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)}`);
@@ -15865,14 +16723,14 @@ async function runInit(options) {
     if (isCI) {
       const genericAgent = {
         name: "generic",
-        mcpConfigPath: path4.join(projectRoot, ".glasstrace", "mcp.json"),
+        mcpConfigPath: path6.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)) {
+      if (genericAgent.mcpConfigPath !== null && fs6.existsSync(genericAgent.mcpConfigPath)) {
         anyConfigWritten = true;
         summary.push("Created .glasstrace/mcp.json (CI mode)");
       }
@@ -15886,14 +16744,14 @@ async function runInit(options) {
         );
         const genericAgent = {
           name: "generic",
-          mcpConfigPath: path4.join(projectRoot, ".glasstrace", "mcp.json"),
+          mcpConfigPath: path6.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)) {
+        if (genericAgent.mcpConfigPath !== null && fs6.existsSync(genericAgent.mcpConfigPath)) {
           anyConfigWritten = true;
         }
         agents = [];
@@ -15903,7 +16761,7 @@ async function runInit(options) {
         try {
           const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
           await writeMcpConfig(agent, configContent, projectRoot);
-          const configExists = agent.mcpConfigPath !== null && fs4.existsSync(agent.mcpConfigPath);
+          const configExists = agent.mcpConfigPath !== null && fs6.existsSync(agent.mcpConfigPath);
           if (!configExists) {
             continue;
           }
@@ -15990,7 +16848,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 ? path4.basename(scriptPath) : void 0;
+var scriptBasename = scriptPath !== void 0 ? path6.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)) {
@@ -16061,6 +16919,38 @@ Usage: glasstrace mcp add [--force] [--dry-run]
     }).catch((err) => {
       process.stderr.write(
         `Fatal error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exit(1);
+    });
+  } else if (subcommand === "uninit") {
+    const remainingArgs = process.argv.slice(3);
+    const dryRun = remainingArgs.includes("--dry-run");
+    Promise.resolve().then(() => (init_uninit(), uninit_exports)).then(({ runUninit: runUninit2 }) => runUninit2({ projectRoot: process.cwd(), dryRun })).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) {
+        process.stderr.write("\n");
+        for (const line of result.summary) {
+          process.stderr.write(`  ${line}
+`);
+        }
+        process.stderr.write("\n");
+      }
+      process.exit(result.exitCode);
+    }).catch((err) => {
+      process.stderr.write(
+        `Fatal error: ${err instanceof Error ? err.message : String(err)}
 `
       );
       process.exit(1);
@@ -16071,6 +16961,7 @@ Usage: glasstrace mcp add [--force] [--dry-run]
 
 Usage:
   glasstrace init [--yes] [--coverage-map]
+  glasstrace uninit [--dry-run]
   glasstrace mcp add [--force] [--dry-run]
 `
     );