@glasstrace/sdk 0.19.0 → 0.20.1

package/dist/{chunk-XNDHQN4S.js → chunk-LU3PPAOQ.js}

@@ -2,14 +2,215 @@ import {
   isDevApiKey,
   readEnvLocalApiKey
 } from "./chunk-O63DJKIJ.js";
+import {
+  AnonApiKeySchema
+} from "./chunk-TQ54WLCZ.js";
 import {
   NEXT_CONFIG_NAMES
 } from "./chunk-DXRZKKSO.js";
 
 // src/cli/uninit.ts
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
+import * as path2 from "node:path";
+
+// src/cli/discovery-file.ts
+import * as fs from "node:fs";
 import * as path from "node:path";
+var WELL_KNOWN_GLASSTRACE_PATH = ".well-known/glasstrace.json";
+var DISCOVERY_FILE_VERSION = 1;
+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 readExistingDiscoveryFile(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const obj = parsed;
+  const versionRaw = obj.version;
+  if (typeof versionRaw !== "number" || !Number.isInteger(versionRaw) || versionRaw < 1) {
+    return null;
+  }
+  const keyResult = AnonApiKeySchema.safeParse(obj.key);
+  if (!keyResult.success) {
+    return null;
+  }
+  const extras = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "version" || k === "key") continue;
+    extras[k] = v;
+  }
+  return { key: keyResult.data, extras };
+}
+function serializeDiscoveryPayload(key, extras) {
+  const payload = {
+    version: DISCOVERY_FILE_VERSION,
+    key,
+    ...extras
+  };
+  return JSON.stringify(payload, null, 2) + "\n";
+}
+function writeDiscoveryFile(projectRoot, anonKey) {
+  const { absolutePath: staticRoot, layout } = resolveStaticRoot(projectRoot);
+  const wellKnownDir = path.join(staticRoot, ".well-known");
+  const filePath = path.join(wellKnownDir, "glasstrace.json");
+  let existingAction;
+  let extras = {};
+  if (fs.existsSync(filePath)) {
+    const existing = readExistingDiscoveryFile(filePath);
+    if (existing === null) {
+      existingAction = "skipped-foreign";
+    } else if (existing.key === anonKey) {
+      return {
+        action: "skipped-matches",
+        filePath,
+        layout
+      };
+    } else {
+      extras = existing.extras;
+      existingAction = "updated-stale";
+    }
+  } else {
+    existingAction = "created";
+  }
+  const tmpPath = `${filePath}.tmp-${process.pid}`;
+  const needsWindowsReplace = process.platform === "win32" && fs.existsSync(filePath);
+  const backupPath = needsWindowsReplace ? `${filePath}.bak-${process.pid}` : null;
+  try {
+    fs.mkdirSync(wellKnownDir, { recursive: true });
+    const payload = serializeDiscoveryPayload(anonKey, extras);
+    fs.writeFileSync(tmpPath, payload, { encoding: "utf-8" });
+    if (backupPath !== null) {
+      fs.renameSync(filePath, backupPath);
+      try {
+        fs.renameSync(tmpPath, filePath);
+      } catch (renameErr) {
+        try {
+          fs.renameSync(backupPath, filePath);
+        } catch {
+        }
+        throw renameErr;
+      }
+      try {
+        fs.unlinkSync(backupPath);
+      } catch {
+      }
+    } else {
+      fs.renameSync(tmpPath, filePath);
+    }
+    return { action: existingAction, filePath, layout };
+  } catch (err) {
+    try {
+      if (fs.existsSync(tmpPath)) {
+        fs.unlinkSync(tmpPath);
+      }
+    } catch {
+    }
+    return {
+      action: "failed",
+      filePath,
+      layout,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+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 = [
   "CLAUDE.md",
@@ -316,24 +517,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;
@@ -374,8 +575,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`);
       }
     }
@@ -387,11 +588,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;
       }
@@ -401,7 +602,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;
@@ -422,20 +623,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`
@@ -450,10 +651,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`);
     }
@@ -463,9 +664,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;
@@ -498,12 +728,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") {
@@ -526,9 +756,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/",
@@ -544,12 +774,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`);
         }
@@ -562,63 +792,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})`
@@ -633,21 +863,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}`);
         }
@@ -665,6 +895,10 @@ async function runUninit(options) {
 }
 
 export {
+  resolveStaticRoot,
+  relativeDiscoveryPath,
+  writeDiscoveryFile,
+  removeDiscoveryFile,
   skipString,
   findMatchingDelimiter,
   findMatchingParen,
@@ -679,4 +913,4 @@ export {
   writeShutdownMarker,
   runUninit
 };
-//# sourceMappingURL=chunk-XNDHQN4S.js.map
+//# sourceMappingURL=chunk-LU3PPAOQ.js.map