@glasstrace/sdk 0.2.3 → 0.4.1

package/dist/chunk-STECO33B.js

@@ -0,0 +1,675 @@
+// src/cli/scaffolder.ts
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+function identityFingerprint(token) {
+  return `sha256:${createHash("sha256").update(token).digest("hex")}`;
+}
+var NEXT_CONFIG_NAMES = ["next.config.ts", "next.config.js", "next.config.mjs"];
+async function scaffoldInstrumentation(projectRoot, force) {
+  const filePath = path.join(projectRoot, "instrumentation.ts");
+  if (fs.existsSync(filePath) && !force) {
+    return false;
+  }
+  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.writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+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 false;
+  }
+  const existing = fs.readFileSync(configPath, "utf-8");
+  if (existing.includes("withGlasstraceConfig")) {
+    return false;
+  }
+  const isESM = configName.endsWith(".ts") || configName.endsWith(".mjs");
+  if (isESM) {
+    const importLine = 'import { withGlasstraceConfig } from "@glasstrace/sdk";\n';
+    const wrapResult2 = wrapExport(existing);
+    if (!wrapResult2.wrapped) {
+      return false;
+    }
+    const modified2 = importLine + "\n" + wrapResult2.content;
+    fs.writeFileSync(configPath, modified2, "utf-8");
+    return true;
+  }
+  const requireLine = 'const { withGlasstraceConfig } = require("@glasstrace/sdk");\n';
+  const wrapResult = wrapCJSExport(existing);
+  if (!wrapResult.wrapped) {
+    return false;
+  }
+  const modified = requireLine + "\n" + wrapResult.content;
+  fs.writeFileSync(configPath, modified, "utf-8");
+  return 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;
+}
+async function scaffoldMcpMarker(projectRoot, anonKey) {
+  const dirPath = path.join(projectRoot, ".glasstrace");
+  const markerPath = path.join(dirPath, "mcp-connected");
+  const keyHash = identityFingerprint(anonKey);
+  if (fs.existsSync(markerPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+      if (existing.keyHash === keyHash) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  fs.mkdirSync(dirPath, { recursive: true, mode: 448 });
+  const marker = JSON.stringify(
+    { keyHash, configuredAt: (/* @__PURE__ */ new Date()).toISOString() },
+    null,
+    2
+  );
+  fs.writeFileSync(markerPath, marker, { mode: 384 });
+  fs.chmodSync(markerPath, 384);
+  return true;
+}
+
+// src/agent-detection/detect.ts
+import { execFile } from "child_process";
+import { access, stat } from "fs/promises";
+import { dirname, join as join2, resolve } from "path";
+import { homedir } from "os";
+import { constants } from "fs";
+var AGENT_RULES = [
+  {
+    name: "claude",
+    markers: [".claude", "CLAUDE.md"],
+    mcpConfigPath: (dir) => join2(dir, ".mcp.json"),
+    infoFilePath: (dir) => join2(dir, "CLAUDE.md"),
+    cliBinary: "claude",
+    registrationCommand: "npx glasstrace mcp add --agent claude"
+  },
+  {
+    name: "codex",
+    markers: ["codex.md", ".codex"],
+    mcpConfigPath: (dir) => join2(dir, ".codex", "config.toml"),
+    infoFilePath: (dir) => join2(dir, "codex.md"),
+    cliBinary: "codex",
+    registrationCommand: "npx glasstrace mcp add --agent codex"
+  },
+  {
+    name: "gemini",
+    markers: [".gemini"],
+    mcpConfigPath: (dir) => join2(dir, ".gemini", "settings.json"),
+    infoFilePath: () => null,
+    cliBinary: "gemini",
+    registrationCommand: "npx glasstrace mcp add --agent gemini"
+  },
+  {
+    name: "cursor",
+    markers: [".cursor", ".cursorrules"],
+    mcpConfigPath: (dir) => join2(dir, ".cursor", "mcp.json"),
+    infoFilePath: (dir) => join2(dir, ".cursorrules"),
+    cliBinary: null,
+    registrationCommand: "npx glasstrace mcp add --agent cursor"
+  },
+  {
+    name: "windsurf",
+    markers: [".windsurfrules", ".windsurf"],
+    mcpConfigPath: () => join2(homedir(), ".codeium", "windsurf", "mcp_config.json"),
+    infoFilePath: (dir) => join2(dir, ".windsurfrules"),
+    cliBinary: null,
+    registrationCommand: "npx glasstrace mcp add --agent windsurf"
+  }
+];
+async function pathExists(path2, mode = constants.R_OK) {
+  try {
+    await access(path2, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findGitRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (await pathExists(join2(current, ".git"), constants.F_OK)) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return resolve(startDir);
+}
+function isCliAvailable(binary) {
+  return new Promise((resolve2) => {
+    const command = process.platform === "win32" ? "where" : "which";
+    execFile(command, [binary], (error) => {
+      resolve2(error === null);
+    });
+  });
+}
+async function detectAgents(projectRoot) {
+  const resolvedRoot = resolve(projectRoot);
+  let rootStat;
+  try {
+    rootStat = await stat(resolvedRoot);
+  } catch (err) {
+    const code = err.code;
+    throw new Error(
+      `projectRoot does not exist: ${resolvedRoot}` + (code ? ` (${code})` : "")
+    );
+  }
+  if (!rootStat.isDirectory()) {
+    throw new Error(`projectRoot is not a directory: ${resolvedRoot}`);
+  }
+  const gitRoot = await findGitRoot(resolvedRoot);
+  const searchDirs = [];
+  let current = resolvedRoot;
+  while (true) {
+    searchDirs.push(current);
+    if (current === gitRoot) {
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const detected = [];
+  const seenAgents = /* @__PURE__ */ new Set();
+  for (const rule of AGENT_RULES) {
+    let foundDir = null;
+    for (const dir of searchDirs) {
+      let markerFound = false;
+      for (const marker of rule.markers) {
+        if (await pathExists(join2(dir, marker))) {
+          markerFound = true;
+          break;
+        }
+      }
+      if (markerFound) {
+        foundDir = dir;
+        break;
+      }
+    }
+    if (foundDir === null) {
+      continue;
+    }
+    if (seenAgents.has(rule.name)) {
+      continue;
+    }
+    seenAgents.add(rule.name);
+    let infoFilePath = rule.infoFilePath(foundDir);
+    if (infoFilePath !== null && !await pathExists(infoFilePath)) {
+      infoFilePath = null;
+    }
+    const cliAvailable = rule.cliBinary ? await isCliAvailable(rule.cliBinary) : false;
+    detected.push({
+      name: rule.name,
+      mcpConfigPath: rule.mcpConfigPath(foundDir),
+      infoFilePath,
+      cliAvailable,
+      registrationCommand: rule.registrationCommand
+    });
+  }
+  detected.push({
+    name: "generic",
+    mcpConfigPath: join2(resolvedRoot, ".glasstrace", "mcp.json"),
+    infoFilePath: null,
+    cliAvailable: false,
+    registrationCommand: null
+  });
+  return detected;
+}
+
+// src/agent-detection/configs.ts
+function generateMcpConfig(agent, endpoint, anonKey) {
+  if (!endpoint || endpoint.trim() === "") {
+    throw new Error("endpoint must not be empty");
+  }
+  if (!anonKey || anonKey.trim() === "") {
+    throw new Error("anonKey must not be empty");
+  }
+  switch (agent.name) {
+    case "claude":
+      return JSON.stringify(
+        {
+          mcpServers: {
+            glasstrace: {
+              type: "http",
+              url: endpoint,
+              headers: {
+                Authorization: `Bearer ${anonKey}`
+              }
+            }
+          }
+        },
+        null,
+        2
+      );
+    case "codex": {
+      const safeEndpoint = endpoint.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      return [
+        "[mcp_servers.glasstrace]",
+        `url = "${safeEndpoint}"`,
+        `bearer_token_env_var = "GLASSTRACE_API_KEY"`,
+        ""
+      ].join("\n");
+    }
+    case "gemini":
+      return JSON.stringify(
+        {
+          mcpServers: {
+            glasstrace: {
+              httpUrl: endpoint,
+              headers: {
+                Authorization: `Bearer ${anonKey}`
+              }
+            }
+          }
+        },
+        null,
+        2
+      );
+    case "cursor":
+      return JSON.stringify(
+        {
+          mcpServers: {
+            glasstrace: {
+              url: endpoint,
+              headers: {
+                Authorization: `Bearer ${anonKey}`
+              }
+            }
+          }
+        },
+        null,
+        2
+      );
+    case "windsurf":
+      return JSON.stringify(
+        {
+          mcpServers: {
+            glasstrace: {
+              serverUrl: endpoint,
+              headers: {
+                Authorization: `Bearer ${anonKey}`
+              }
+            }
+          }
+        },
+        null,
+        2
+      );
+    case "generic":
+      return JSON.stringify(
+        {
+          mcpServers: {
+            glasstrace: {
+              url: endpoint,
+              headers: {
+                Authorization: `Bearer ${anonKey}`
+              }
+            }
+          }
+        },
+        null,
+        2
+      );
+  }
+}
+function htmlMarkers() {
+  return {
+    start: "<!-- glasstrace:mcp:start -->",
+    end: "<!-- glasstrace:mcp:end -->"
+  };
+}
+function hashMarkers() {
+  return {
+    start: "# glasstrace:mcp:start",
+    end: "# glasstrace:mcp:end"
+  };
+}
+function generateInfoSection(agent, endpoint) {
+  if (!endpoint || endpoint.trim() === "") {
+    throw new Error("endpoint must not be empty");
+  }
+  const content = [
+    "",
+    "## Glasstrace MCP Integration",
+    "",
+    `Glasstrace is configured as an MCP server at: ${endpoint}`,
+    "",
+    "Available tools:",
+    "- `glasstrace_submit_trace` - Submit trace data for debugging analysis",
+    "- `glasstrace_get_config` - Retrieve current SDK configuration",
+    "",
+    "To reconfigure, run: `npx glasstrace mcp add`",
+    ""
+  ].join("\n");
+  switch (agent.name) {
+    case "claude": {
+      const m = htmlMarkers();
+      return `${m.start}
+${content}${m.end}
+`;
+    }
+    case "codex": {
+      const m = htmlMarkers();
+      return `${m.start}
+${content}${m.end}
+`;
+    }
+    case "cursor": {
+      const m = hashMarkers();
+      return `${m.start}
+${content}${m.end}
+`;
+    }
+    case "gemini":
+    case "windsurf":
+    case "generic":
+      return "";
+  }
+}
+
+// src/agent-detection/inject.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2, isAbsolute, join as join3 } from "path";
+var HTML_START = "<!-- glasstrace:mcp:start -->";
+var HTML_END = "<!-- glasstrace:mcp:end -->";
+var HASH_START = "# glasstrace:mcp:start";
+var HASH_END = "# glasstrace:mcp:end";
+function isPermissionError(err) {
+  const code = err.code;
+  return code === "EACCES" || code === "EPERM" || code === "EROFS";
+}
+async function writeMcpConfig(agent, content, projectRoot) {
+  if (agent.mcpConfigPath === null) {
+    return;
+  }
+  const configPath = agent.mcpConfigPath;
+  const parentDir = dirname2(configPath);
+  try {
+    await mkdir(parentDir, { recursive: true });
+  } catch (err) {
+    if (isPermissionError(err)) {
+      process.stderr.write(
+        `Warning: cannot create directory ${parentDir}: permission denied
+`
+      );
+      return;
+    }
+    throw err;
+  }
+  try {
+    await writeFile(configPath, content, { mode: 384 });
+  } catch (err) {
+    if (isPermissionError(err)) {
+      process.stderr.write(
+        `Warning: cannot write config file ${configPath}: permission denied
+`
+      );
+      return;
+    }
+    throw err;
+  }
+  try {
+    await chmod(configPath, 384);
+  } catch {
+  }
+}
+function findMarkerBoundaries(lines) {
+  let startIdx = -1;
+  let endIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === HTML_START || trimmed === HASH_START) {
+      startIdx = i;
+    } else if (trimmed === HTML_END || trimmed === HASH_END) {
+      if (startIdx !== -1) {
+        endIdx = i;
+        break;
+      }
+    }
+  }
+  if (startIdx === -1 || endIdx === -1) {
+    return null;
+  }
+  return { startIdx, endIdx };
+}
+async function injectInfoSection(agent, content, projectRoot) {
+  if (agent.infoFilePath === null) {
+    return;
+  }
+  if (content === "") {
+    return;
+  }
+  const filePath = agent.infoFilePath;
+  let existingContent = null;
+  try {
+    existingContent = await readFile(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      if (isPermissionError(err)) {
+        process.stderr.write(
+          `Warning: cannot read info file ${filePath}: permission denied
+`
+        );
+        return;
+      }
+      throw err;
+    }
+  }
+  if (existingContent === null) {
+    try {
+      await mkdir(dirname2(filePath), { recursive: true });
+      await writeFile(filePath, content, "utf-8");
+    } catch (err) {
+      if (isPermissionError(err)) {
+        process.stderr.write(
+          `Warning: cannot write info file ${filePath}: permission denied
+`
+        );
+        return;
+      }
+      throw err;
+    }
+    return;
+  }
+  const lines = existingContent.split("\n");
+  const boundaries = findMarkerBoundaries(lines);
+  let newContent;
+  if (boundaries !== null) {
+    const before = lines.slice(0, boundaries.startIdx);
+    const after = lines.slice(boundaries.endIdx + 1);
+    const contentWithoutTrailingNewline = content.endsWith("\n") ? content.slice(0, -1) : content;
+    newContent = [...before, contentWithoutTrailingNewline, ...after].join("\n");
+  } else {
+    const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
+    newContent = existingContent + separator + content;
+  }
+  try {
+    await writeFile(filePath, newContent, "utf-8");
+  } catch (err) {
+    if (isPermissionError(err)) {
+      process.stderr.write(
+        `Warning: cannot write info file ${filePath}: permission denied
+`
+      );
+      return;
+    }
+    throw err;
+  }
+}
+async function updateGitignore(paths, projectRoot) {
+  const gitignorePath = join3(projectRoot, ".gitignore");
+  const relativePaths = paths.filter((p) => !isAbsolute(p));
+  if (relativePaths.length === 0) {
+    return;
+  }
+  let existingContent = "";
+  try {
+    existingContent = await readFile(gitignorePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      if (isPermissionError(err)) {
+        process.stderr.write(
+          `Warning: cannot read .gitignore: permission denied
+`
+        );
+        return;
+      }
+      throw err;
+    }
+  }
+  const existingLines = existingContent.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  const existingSet = new Set(existingLines);
+  const toAdd = relativePaths.map((p) => p.trim().replace(/\\/g, "/")).filter((p) => p !== "" && !existingSet.has(p));
+  if (toAdd.length === 0) {
+    return;
+  }
+  let updatedContent = existingContent;
+  if (updatedContent.length > 0 && !updatedContent.endsWith("\n")) {
+    updatedContent += "\n";
+  }
+  updatedContent += toAdd.join("\n") + "\n";
+  try {
+    await writeFile(gitignorePath, updatedContent, "utf-8");
+  } catch (err) {
+    if (isPermissionError(err)) {
+      process.stderr.write(
+        `Warning: cannot write .gitignore: permission denied
+`
+      );
+      return;
+    }
+    throw err;
+  }
+}
+
+export {
+  scaffoldInstrumentation,
+  scaffoldNextConfig,
+  scaffoldEnvLocal,
+  addCoverageMapEnv,
+  scaffoldGitignore,
+  scaffoldMcpMarker,
+  detectAgents,
+  generateMcpConfig,
+  generateInfoSection,
+  writeMcpConfig,
+  injectInfoSection,
+  updateGitignore
+};
+//# sourceMappingURL=chunk-STECO33B.js.map