@glasstrace/sdk 0.19.0 → 0.20.1

package/dist/cli/mcp-add.js

@@ -8,11 +8,11 @@ import {
 } from "../chunk-HAU66QBQ.js";
 import {
   readAnonKey
-} from "../chunk-YPXW2TN3.js";
-import "../chunk-5N2IR4EO.js";
+} from "../chunk-IP4NMDJK.js";
 import {
   scaffoldMcpMarker
 } from "../chunk-O63DJKIJ.js";
+import "../chunk-TQ54WLCZ.js";
 import {
   MCP_ENDPOINT,
   formatAgentName

package/dist/cli/uninit.cjs

@@ -45,9 +45,9 @@ __export(uninit_exports, {
   writeShutdownMarker: () => writeShutdownMarker
 });
 module.exports = __toCommonJS(uninit_exports);
-var fs = __toESM(require("node:fs"), 1);
+var fs2 = __toESM(require("node:fs"), 1);
 var os = __toESM(require("node:os"), 1);
-var path = __toESM(require("node:path"), 1);
+var path2 = __toESM(require("node:path"), 1);
 
 // src/cli/constants.ts
 var NEXT_CONFIG_NAMES = ["next.config.ts", "next.config.js", "next.config.mjs"];
@@ -71,6 +71,97 @@ function isDevApiKey(value) {
   return value.trim().startsWith("gt_dev_");
 }
 
+// src/cli/discovery-file.ts
+var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var WELL_KNOWN_GLASSTRACE_PATH = ".well-known/glasstrace.json";
+function resolveStaticRoot(projectRoot) {
+  if (isSvelteKitProject(projectRoot)) {
+    return {
+      absolutePath: path.join(projectRoot, "static"),
+      layout: "static"
+    };
+  }
+  return {
+    absolutePath: path.join(projectRoot, "public"),
+    layout: "public"
+  };
+}
+function isSvelteKitProject(projectRoot) {
+  const pkgPath = path.join(projectRoot, "package.json");
+  let isEsm = false;
+  try {
+    const pkgContent = fs.readFileSync(pkgPath, "utf-8");
+    const parsed = JSON.parse(pkgContent);
+    isEsm = parsed.type === "module";
+  } catch {
+    return false;
+  }
+  if (!isEsm) return false;
+  const svelteConfigJs = path.join(projectRoot, "svelte.config.js");
+  const svelteConfigTs = path.join(projectRoot, "svelte.config.ts");
+  const appHtml = path.join(projectRoot, "src", "app.html");
+  return fs.existsSync(svelteConfigJs) || fs.existsSync(svelteConfigTs) || fs.existsSync(appHtml);
+}
+function relativeDiscoveryPath(layout) {
+  const rootDir = layout === "static" ? "static" : "public";
+  return `${rootDir}/${WELL_KNOWN_GLASSTRACE_PATH}`;
+}
+function removeDiscoveryFile(projectRoot) {
+  const { layout: inferredLayout } = resolveStaticRoot(projectRoot);
+  const layouts = ["public", "static"];
+  const outcomes = [];
+  for (const layout of layouts) {
+    const staticRoot = path.join(projectRoot, layout);
+    const wellKnownDir = path.join(staticRoot, ".well-known");
+    const filePath = path.join(wellKnownDir, "glasstrace.json");
+    let removed = false;
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        removed = true;
+      }
+    } catch (err) {
+      return {
+        action: "failed",
+        filePath,
+        layout,
+        directoryRemoved: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    let directoryRemoved = false;
+    if (removed) {
+      try {
+        if (fs.existsSync(wellKnownDir)) {
+          const entries = fs.readdirSync(wellKnownDir);
+          if (entries.length === 0) {
+            fs.rmdirSync(wellKnownDir);
+            directoryRemoved = true;
+          }
+        }
+      } catch {
+      }
+    }
+    outcomes.push({ layout, filePath, removed, directoryRemoved });
+  }
+  const removals = outcomes.filter((o) => o.removed);
+  const chosen = (() => {
+    if (removals.length === 0) {
+      return outcomes.find((o) => o.layout === inferredLayout) ?? outcomes[0];
+    }
+    if (removals.length === 1) return removals[0];
+    return removals.find((o) => o.layout === inferredLayout) ?? removals[0];
+  })();
+  const anyDirectoryRemoved = outcomes.some((o) => o.directoryRemoved);
+  return {
+    action: removals.length > 0 ? "removed" : "not-found",
+    filePath: chosen.filePath,
+    layout: chosen.layout,
+    directoryRemoved: chosen.directoryRemoved || anyDirectoryRemoved
+  };
+}
+
 // src/cli/uninit.ts
 var MCP_CONFIG_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json"];
 var AGENT_INFO_FILES = [
@@ -378,24 +469,24 @@ function processTomlMcpConfig(content) {
   return { action: "removed-section", content: result + "\n" };
 }
 function writeShutdownMarker(projectRoot) {
-  const dirPath = path.join(projectRoot, ".glasstrace");
-  if (!fs.existsSync(dirPath)) {
+  const dirPath = path2.join(projectRoot, ".glasstrace");
+  if (!fs2.existsSync(dirPath)) {
     return false;
   }
-  const markerPath = path.join(dirPath, "shutdown-requested");
+  const markerPath = path2.join(dirPath, "shutdown-requested");
   const tmpPath = `${markerPath}.tmp`;
   const body = JSON.stringify({ requestedAt: (/* @__PURE__ */ new Date()).toISOString() });
   try {
-    fs.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    fs2.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
     try {
-      fs.chmodSync(tmpPath, 384);
+      fs2.chmodSync(tmpPath, 384);
     } catch {
     }
-    fs.renameSync(tmpPath, markerPath);
+    fs2.renameSync(tmpPath, markerPath);
     return true;
   } catch {
     try {
-      fs.unlinkSync(tmpPath);
+      fs2.unlinkSync(tmpPath);
     } catch {
     }
     return false;
@@ -436,8 +527,8 @@ async function runUninit(options) {
         summary.push("Wrote .glasstrace/shutdown-requested marker");
       }
     } else {
-      const dirPath = path.join(projectRoot, ".glasstrace");
-      if (fs.existsSync(dirPath)) {
+      const dirPath = path2.join(projectRoot, ".glasstrace");
+      if (fs2.existsSync(dirPath)) {
         summary.push(`${prefix}Would write .glasstrace/shutdown-requested marker`);
       }
     }
@@ -449,11 +540,11 @@ async function runUninit(options) {
   try {
     let configHandled = false;
     for (const name of NEXT_CONFIG_NAMES) {
-      const configPath = path.join(projectRoot, name);
-      if (!fs.existsSync(configPath)) {
+      const configPath = path2.join(projectRoot, name);
+      if (!fs2.existsSync(configPath)) {
         continue;
       }
-      const content = fs.readFileSync(configPath, "utf-8");
+      const content = fs2.readFileSync(configPath, "utf-8");
       if (!content.includes("withGlasstraceConfig")) {
         continue;
       }
@@ -463,7 +554,7 @@ async function runUninit(options) {
         const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
         const final = cleanLeadingBlankLines(cleaned);
         if (!dryRun) {
-          fs.writeFileSync(configPath, final, "utf-8");
+          fs2.writeFileSync(configPath, final, "utf-8");
         }
         summary.push(`${prefix}Unwrapped withGlasstraceConfig from ${name}`);
         configHandled = true;
@@ -484,20 +575,20 @@ async function runUninit(options) {
     );
   }
   try {
-    const instrPath = path.join(projectRoot, "instrumentation.ts");
-    if (fs.existsSync(instrPath)) {
-      const content = fs.readFileSync(instrPath, "utf-8");
+    const instrPath = path2.join(projectRoot, "instrumentation.ts");
+    if (fs2.existsSync(instrPath)) {
+      const content = fs2.readFileSync(instrPath, "utf-8");
       if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
         if (isInitCreatedInstrumentation(content)) {
           if (!dryRun) {
-            fs.unlinkSync(instrPath);
+            fs2.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");
+              fs2.writeFileSync(instrPath, cleaned, "utf-8");
             }
             summary.push(
               `${prefix}Removed registerGlasstrace() from instrumentation.ts`
@@ -512,10 +603,10 @@ async function runUninit(options) {
     );
   }
   try {
-    const glasstraceDir = path.join(projectRoot, ".glasstrace");
-    if (fs.existsSync(glasstraceDir)) {
+    const glasstraceDir = path2.join(projectRoot, ".glasstrace");
+    if (fs2.existsSync(glasstraceDir)) {
       if (!dryRun) {
-        fs.rmSync(glasstraceDir, { recursive: true, force: true });
+        fs2.rmSync(glasstraceDir, { recursive: true, force: true });
       }
       summary.push(`${prefix}Removed .glasstrace/ directory`);
     }
@@ -525,9 +616,38 @@ async function runUninit(options) {
     );
   }
   try {
-    const envPath = path.join(projectRoot, ".env.local");
-    if (fs.existsSync(envPath)) {
-      const content = fs.readFileSync(envPath, "utf-8");
+    if (dryRun) {
+      for (const previewLayout of ["public", "static"]) {
+        const relPath = relativeDiscoveryPath(previewLayout);
+        const absPath = path2.join(projectRoot, relPath);
+        if (fs2.existsSync(absPath)) {
+          summary.push(`${prefix}Would remove ${relPath}`);
+        }
+      }
+    } else {
+      const result = removeDiscoveryFile(projectRoot);
+      if (result.action === "removed") {
+        const relPath = relativeDiscoveryPath(result.layout);
+        summary.push(`Removed ${relPath}`);
+        if (result.directoryRemoved) {
+          const dirRel = relPath.replace(/\/glasstrace\.json$/, "/");
+          summary.push(`Removed empty ${dirRel}`);
+        }
+      } else if (result.action === "failed") {
+        warnings.push(
+          `Failed to remove ${relativeDiscoveryPath(result.layout)}${result.error !== void 0 ? `: ${result.error}` : ""}`
+        );
+      }
+    }
+  } catch (err) {
+    warnings.push(
+      `Failed to remove discovery file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const envPath = path2.join(projectRoot, ".env.local");
+    if (fs2.existsSync(envPath)) {
+      const content = fs2.readFileSync(envPath, "utf-8");
       const existingKey = readEnvLocalApiKey(content);
       const hasDevKey = isDevApiKey(existingKey);
       let proceed = true;
@@ -560,12 +680,12 @@ async function runUninit(options) {
           const result = filtered.join("\n");
           if (result.trim().length === 0) {
             if (!dryRun) {
-              fs.unlinkSync(envPath);
+              fs2.unlinkSync(envPath);
             }
             summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
           } else {
             if (!dryRun) {
-              fs.writeFileSync(envPath, result, "utf-8");
+              fs2.writeFileSync(envPath, result, "utf-8");
             }
             let devKeyAnnotation = "";
             if (devKeyPath === "interactive-confirmed") {
@@ -588,9 +708,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const gitignorePath = path.join(projectRoot, ".gitignore");
-    if (fs.existsSync(gitignorePath)) {
-      const content = fs.readFileSync(gitignorePath, "utf-8");
+    const gitignorePath = path2.join(projectRoot, ".gitignore");
+    if (fs2.existsSync(gitignorePath)) {
+      const content = fs2.readFileSync(gitignorePath, "utf-8");
       const lines = content.split("\n");
       const mcpGitignoreEntries = /* @__PURE__ */ new Set([
         ".glasstrace/",
@@ -606,12 +726,12 @@ async function runUninit(options) {
         const result = filtered.join("\n");
         if (result.trim().length === 0) {
           if (!dryRun) {
-            fs.unlinkSync(gitignorePath);
+            fs2.unlinkSync(gitignorePath);
           }
           summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
         } else {
           if (!dryRun) {
-            fs.writeFileSync(gitignorePath, result, "utf-8");
+            fs2.writeFileSync(gitignorePath, result, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace entries from .gitignore`);
         }
@@ -624,63 +744,63 @@ async function runUninit(options) {
   }
   try {
     for (const configFile of MCP_CONFIG_FILES) {
-      const configPath = path.join(projectRoot, configFile);
-      if (!fs.existsSync(configPath)) {
+      const configPath = path2.join(projectRoot, configFile);
+      if (!fs2.existsSync(configPath)) {
         continue;
       }
-      const content = fs.readFileSync(configPath, "utf-8");
+      const content = fs2.readFileSync(configPath, "utf-8");
       const result = processJsonMcpConfig(content);
       if (result.action === "deleted") {
         if (!dryRun) {
-          fs.unlinkSync(configPath);
+          fs2.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");
+          fs2.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 codexConfigPath = path2.join(projectRoot, ".codex", "config.toml");
+    if (fs2.existsSync(codexConfigPath)) {
+      const content = fs2.readFileSync(codexConfigPath, "utf-8");
       const tomlResult = processTomlMcpConfig(content);
       if (tomlResult.action === "deleted") {
         if (!dryRun) {
-          fs.unlinkSync(codexConfigPath);
+          fs2.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");
+          fs2.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"));
+    const hasWindsurfMarkers = fs2.existsSync(path2.join(projectRoot, ".windsurfrules")) || fs2.existsSync(path2.join(projectRoot, ".windsurf"));
     if (hasWindsurfMarkers) {
-      const windsurfConfigPath = path.join(
+      const windsurfConfigPath = path2.join(
         os.homedir(),
         ".codeium",
         "windsurf",
         "mcp_config.json"
       );
-      if (fs.existsSync(windsurfConfigPath)) {
-        const content = fs.readFileSync(windsurfConfigPath, "utf-8");
+      if (fs2.existsSync(windsurfConfigPath)) {
+        const content = fs2.readFileSync(windsurfConfigPath, "utf-8");
         const windsurfResult = processJsonMcpConfig(content);
         const home = os.homedir();
         const displayPath = windsurfConfigPath.startsWith(home) ? "~" + windsurfConfigPath.slice(home.length) : windsurfConfigPath;
         if (windsurfResult.action === "deleted") {
           if (!dryRun) {
-            fs.unlinkSync(windsurfConfigPath);
+            fs2.unlinkSync(windsurfConfigPath);
           }
           summary.push(
             `${prefix}Deleted global Windsurf config (${displayPath})`
           );
         } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
           if (!dryRun) {
-            fs.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
+            fs2.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
           }
           summary.push(
             `${prefix}Removed glasstrace from global Windsurf config (${displayPath})`
@@ -695,21 +815,21 @@ async function runUninit(options) {
   }
   try {
     for (const infoFile of AGENT_INFO_FILES) {
-      const filePath = path.join(projectRoot, infoFile);
-      if (!fs.existsSync(filePath)) {
+      const filePath = path2.join(projectRoot, infoFile);
+      if (!fs2.existsSync(filePath)) {
         continue;
       }
-      const content = fs.readFileSync(filePath, "utf-8");
+      const content = fs2.readFileSync(filePath, "utf-8");
       const result = removeMarkerSection(content);
       if (result.removed) {
         if (result.content.trim().length === 0) {
           if (!dryRun) {
-            fs.unlinkSync(filePath);
+            fs2.unlinkSync(filePath);
           }
           summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
         } else {
           if (!dryRun) {
-            fs.writeFileSync(filePath, result.content, "utf-8");
+            fs2.writeFileSync(filePath, result.content, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace section from ${infoFile}`);
         }