@glasstrace/sdk 0.7.3 → 0.9.0

package/dist/cli/mcp-add.js

@@ -8,7 +8,7 @@ import {
   scaffoldMcpMarker,
   updateGitignore,
   writeMcpConfig
-} from "../chunk-CKK6VKKC.js";
+} from "../chunk-UGHMMOM4.js";
 import {
   readAnonKey
 } from "../chunk-QW6W4CSA.js";

package/dist/cli/uninit.cjs

@@ -0,0 +1,583 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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
+});
+module.exports = __toCommonJS(uninit_exports);
+var fs = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var NEXT_CONFIG_NAMES = ["next.config.ts", "next.config.js", "next.config.mjs"];
+var MCP_CONFIG_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json"];
+var AGENT_INFO_FILES = [
+  "CLAUDE.md",
+  "codex.md",
+  ".cursorrules"
+];
+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_NAMES) {
+      const configPath = path.join(projectRoot, name);
+      if (!fs.existsSync(configPath)) {
+        continue;
+      }
+      const content = fs.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) {
+          fs.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 = path.join(projectRoot, "instrumentation.ts");
+    if (fs.existsSync(instrPath)) {
+      const content = fs.readFileSync(instrPath, "utf-8");
+      if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
+        if (isInitCreatedInstrumentation(content)) {
+          if (!dryRun) {
+            fs.unlinkSync(instrPath);
+          }
+          summary.push(`${prefix}Deleted instrumentation.ts (init-created)`);
+        } else {
+          const cleaned = removeRegisterGlasstrace(content);
+          if (cleaned !== content) {
+            if (!dryRun) {
+              fs.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 = path.join(projectRoot, ".glasstrace");
+    if (fs.existsSync(glasstraceDir)) {
+      if (!dryRun) {
+        fs.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 = path.join(projectRoot, ".env.local");
+    if (fs.existsSync(envPath)) {
+      const content = fs.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) {
+            fs.unlinkSync(envPath);
+          }
+          summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
+        } else {
+          if (!dryRun) {
+            fs.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 = path.join(projectRoot, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.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) {
+            fs.unlinkSync(gitignorePath);
+          }
+          summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
+        } else {
+          if (!dryRun) {
+            fs.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 = path.join(projectRoot, configFile);
+      if (!fs.existsSync(configPath)) {
+        continue;
+      }
+      const content = fs.readFileSync(configPath, "utf-8");
+      const result = processJsonMcpConfig(content);
+      if (result.action === "deleted") {
+        if (!dryRun) {
+          fs.unlinkSync(configPath);
+        }
+        summary.push(`${prefix}Deleted ${configFile}`);
+      } else if (result.action === "removed-key" && result.content !== void 0) {
+        if (!dryRun) {
+          fs.writeFileSync(configPath, result.content, "utf-8");
+        }
+        summary.push(`${prefix}Removed glasstrace from ${configFile}`);
+      }
+    }
+    const codexConfigPath = path.join(projectRoot, ".codex", "config.toml");
+    if (fs.existsSync(codexConfigPath)) {
+      const content = fs.readFileSync(codexConfigPath, "utf-8");
+      const tomlResult = processTomlMcpConfig(content);
+      if (tomlResult.action === "deleted") {
+        if (!dryRun) {
+          fs.unlinkSync(codexConfigPath);
+        }
+        summary.push(`${prefix}Deleted .codex/config.toml`);
+      } else if (tomlResult.action === "removed-section" && tomlResult.content !== void 0) {
+        if (!dryRun) {
+          fs.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
+        }
+        summary.push(`${prefix}Removed glasstrace from .codex/config.toml`);
+      }
+    }
+    const hasWindsurfMarkers = fs.existsSync(path.join(projectRoot, ".windsurfrules")) || fs.existsSync(path.join(projectRoot, ".windsurf"));
+    if (hasWindsurfMarkers) {
+      const windsurfConfigPath = path.join(
+        os.homedir(),
+        ".codeium",
+        "windsurf",
+        "mcp_config.json"
+      );
+      if (fs.existsSync(windsurfConfigPath)) {
+        const content = fs.readFileSync(windsurfConfigPath, "utf-8");
+        const windsurfResult = processJsonMcpConfig(content);
+        if (windsurfResult.action === "deleted") {
+          if (!dryRun) {
+            fs.unlinkSync(windsurfConfigPath);
+          }
+          summary.push(`${prefix}Deleted Windsurf MCP config`);
+        } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
+          if (!dryRun) {
+            fs.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 = path.join(projectRoot, infoFile);
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+      const content = fs.readFileSync(filePath, "utf-8");
+      const result = removeMarkerSection(content);
+      if (result.removed) {
+        if (result.content.trim().length === 0) {
+          if (!dryRun) {
+            fs.unlinkSync(filePath);
+          }
+          summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
+        } else {
+          if (!dryRun) {
+            fs.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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findMatchingParen,
+  isInitCreatedInstrumentation,
+  processJsonMcpConfig,
+  processTomlMcpConfig,
+  removeGlasstraceConfigImport,
+  removeMarkerSection,
+  removeRegisterGlasstrace,
+  runUninit,
+  unwrapCJSExport,
+  unwrapExport
+});
+//# sourceMappingURL=uninit.cjs.map