@glasstrace/sdk 0.10.0 → 0.12.0

package/dist/index.js

@@ -2,6 +2,7 @@ import {
   PRESIGNED_THRESHOLD_BYTES,
   collectSourceMaps,
   computeBuildHash,
+  discoverSourceMapFiles,
   installConsoleCapture,
   isAnonymousMode,
   isProductionDisabled,
@@ -11,23 +12,23 @@ import {
   uploadSourceMaps,
   uploadSourceMapsAuto,
   uploadSourceMapsPresigned
-} from "./chunk-KOYJ2UQE.js";
+} from "./chunk-MSMOH6IH.js";
 import {
   buildImportGraph,
   discoverTestFiles,
   extractImports
-} from "./chunk-5MAHIPFH.js";
+} from "./chunk-LW7DPKBA.js";
 import {
   getOrCreateAnonKey,
   readAnonKey
-} from "./chunk-ZRNG36LU.js";
+} from "./chunk-6GRNJ722.js";
 import {
   DEFAULT_CAPTURE_CONFIG,
   GLASSTRACE_ATTRIBUTE_NAMES,
   SdkCachedConfigSchema,
   SdkInitResponseSchema,
   SessionIdSchema
-} from "./chunk-O3Y45VGV.js";
+} from "./chunk-OKIP4SRG.js";
 import {
   INVALID_SPAN_CONTEXT,
   SamplingDecision,
@@ -43,7 +44,9 @@ import {
   isValidTraceId,
   trace
 } from "./chunk-DQ25VOKK.js";
-import "./chunk-PZ5AY32C.js";
+import {
+  __require
+} from "./chunk-NSBPE2FW.js";
 
 // src/errors.ts
 var SdkError = class extends Error {
@@ -56,13 +59,36 @@ var SdkError = class extends Error {
 };
 
 // src/session.ts
-import { createHash } from "crypto";
 var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
+var hashFn = null;
+function fnv1aHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+    hash >>>= 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function getHashFn() {
+  if (hashFn) return hashFn;
+  try {
+    const { createHash } = __require("crypto");
+    hashFn = (input) => createHash("sha256").update(input).digest("hex").slice(0, 16);
+  } catch {
+    hashFn = (input) => {
+      const h1 = fnv1aHash(input);
+      const h2 = fnv1aHash(input + "\0");
+      return (h1 + h2).slice(0, 16);
+    };
+  }
+  return hashFn;
+}
 var cachedGlasstraceEnv = process.env.GLASSTRACE_ENV;
 var cachedPort = process.env.PORT ?? "3000";
 function deriveSessionId(apiKey, origin, date, windowIndex) {
   const input = JSON.stringify([apiKey, origin, date, windowIndex]);
-  const hash = createHash("sha256").update(input).digest("hex").slice(0, 16);
+  const hash = getHashFn()(input);
   return SessionIdSchema.parse(hash);
 }
 function getOrigin() {
@@ -148,21 +174,44 @@ function classifyFetchTarget(url) {
 }
 
 // src/init-client.ts
-import { readFileSync } from "fs";
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { join } from "path";
 var GLASSTRACE_DIR = ".glasstrace";
 var CONFIG_FILE = "config";
 var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
 var INIT_TIMEOUT_MS = 1e4;
+var fsPathAsyncCache;
+async function loadFsPathAsync() {
+  if (fsPathAsyncCache !== void 0) return fsPathAsyncCache;
+  try {
+    const [fs2, path2] = await Promise.all([
+      import("fs/promises"),
+      import("path")
+    ]);
+    fsPathAsyncCache = { fs: fs2, path: path2 };
+    return fsPathAsyncCache;
+  } catch {
+    fsPathAsyncCache = null;
+    return null;
+  }
+}
+function loadFsSyncOrNull() {
+  try {
+    const fs2 = __require("fs");
+    const path2 = __require("path");
+    return { readFileSync: fs2.readFileSync, join: path2.join };
+  } catch {
+    return null;
+  }
+}
 var currentConfig = null;
 var configCacheChecked = false;
 var rateLimitBackoff = false;
 function loadCachedConfig(projectRoot) {
+  const modules = loadFsSyncOrNull();
+  if (!modules) return null;
   const root = projectRoot ?? process.cwd();
-  const configPath = join(root, GLASSTRACE_DIR, CONFIG_FILE);
+  const configPath = modules.join(root, GLASSTRACE_DIR, CONFIG_FILE);
   try {
-    const content = readFileSync(configPath, "utf-8");
+    const content = modules.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(content);
     const cached = SdkCachedConfigSchema.parse(parsed);
     const age = Date.now() - cached.cachedAt;
@@ -182,18 +231,20 @@ function loadCachedConfig(projectRoot) {
   }
 }
 async function saveCachedConfig(response, projectRoot) {
+  const modules = await loadFsPathAsync();
+  if (!modules) return;
   const root = projectRoot ?? process.cwd();
-  const dirPath = join(root, GLASSTRACE_DIR);
-  const configPath = join(dirPath, CONFIG_FILE);
+  const dirPath = modules.path.join(root, GLASSTRACE_DIR);
+  const configPath = modules.path.join(dirPath, CONFIG_FILE);
   try {
-    await mkdir(dirPath, { recursive: true, mode: 448 });
-    await chmod(dirPath, 448);
+    await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+    await modules.fs.chmod(dirPath, 448);
     const cached = {
       response,
       cachedAt: Date.now()
     };
-    await writeFile(configPath, JSON.stringify(cached), { encoding: "utf-8", mode: 384 });
-    await chmod(configPath, 384);
+    await modules.fs.writeFile(configPath, JSON.stringify(cached), { encoding: "utf-8", mode: 384 });
+    await modules.fs.chmod(configPath, 384);
   } catch (err) {
     console.warn(
       `[glasstrace] Failed to cache config to ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -247,69 +298,72 @@ async function sendInitRequest(config, anonKey, sdkVersion, importGraph, healthR
   return SdkInitResponseSchema.parse(body);
 }
 async function writeClaimedKey(newApiKey, projectRoot) {
-  const root = projectRoot ?? process.cwd();
-  const envLocalPath = join(root, ".env.local");
-  let envLocalWritten = false;
-  try {
-    let content;
+  const modules = await loadFsPathAsync();
+  if (modules) {
+    const root = projectRoot ?? process.cwd();
+    const envLocalPath = modules.path.join(root, ".env.local");
+    let envLocalWritten = false;
     try {
-      content = await readFile(envLocalPath, "utf-8");
-      if (/^GLASSTRACE_API_KEY=.*/m.test(content)) {
-        content = content.replace(
-          /^GLASSTRACE_API_KEY=.*$/gm,
-          `GLASSTRACE_API_KEY=${newApiKey}`
-        );
-      } else {
-        if (content.length > 0 && !content.endsWith("\n")) {
-          content += "\n";
+      let content;
+      try {
+        content = await modules.fs.readFile(envLocalPath, "utf-8");
+        if (/^GLASSTRACE_API_KEY=.*/m.test(content)) {
+          content = content.replace(
+            /^GLASSTRACE_API_KEY=.*$/gm,
+            `GLASSTRACE_API_KEY=${newApiKey}`
+          );
+        } else {
+          if (content.length > 0 && !content.endsWith("\n")) {
+            content += "\n";
+          }
+          content += `GLASSTRACE_API_KEY=${newApiKey}
+`;
         }
-        content += `GLASSTRACE_API_KEY=${newApiKey}
+      } catch (readErr) {
+        const code = readErr instanceof Error ? readErr.code : void 0;
+        if (code !== "ENOENT") {
+          throw readErr;
+        }
+        content = `GLASSTRACE_API_KEY=${newApiKey}
 `;
       }
-    } catch (readErr) {
-      const code = readErr instanceof Error ? readErr.code : void 0;
-      if (code !== "ENOENT") {
-        throw readErr;
+      await modules.fs.writeFile(envLocalPath, content, { encoding: "utf-8", mode: 384 });
+      await modules.fs.chmod(envLocalPath, 384);
+      envLocalWritten = true;
+    } catch {
+    }
+    if (envLocalWritten) {
+      try {
+        process.stderr.write(
+          "[glasstrace] Account claimed! API key written to .env.local. Restart your dev server to use it.\n"
+        );
+      } catch {
       }
-      content = `GLASSTRACE_API_KEY=${newApiKey}
-`;
+      return;
     }
-    await writeFile(envLocalPath, content, { encoding: "utf-8", mode: 384 });
-    await chmod(envLocalPath, 384);
-    envLocalWritten = true;
-  } catch {
-  }
-  if (envLocalWritten) {
+    let claimedKeyWritten = false;
     try {
-      process.stderr.write(
-        "[glasstrace] Account claimed! API key written to .env.local. Restart your dev server to use it.\n"
-      );
+      const dirPath = modules.path.join(root, GLASSTRACE_DIR);
+      await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+      await modules.fs.chmod(dirPath, 448);
+      const claimedKeyPath = modules.path.join(dirPath, "claimed-key");
+      await modules.fs.writeFile(claimedKeyPath, newApiKey, {
+        encoding: "utf-8",
+        mode: 384
+      });
+      await modules.fs.chmod(claimedKeyPath, 384);
+      claimedKeyWritten = true;
     } catch {
     }
-    return;
-  }
-  let claimedKeyWritten = false;
-  try {
-    const dirPath = join(root, GLASSTRACE_DIR);
-    await mkdir(dirPath, { recursive: true, mode: 448 });
-    await chmod(dirPath, 448);
-    const claimedKeyPath = join(dirPath, "claimed-key");
-    await writeFile(claimedKeyPath, newApiKey, {
-      encoding: "utf-8",
-      mode: 384
-    });
-    await chmod(claimedKeyPath, 384);
-    claimedKeyWritten = true;
-  } catch {
-  }
-  if (claimedKeyWritten) {
-    try {
-      process.stderr.write(
-        "[glasstrace] Account claimed! API key written to .glasstrace/claimed-key. Copy it to your .env.local file.\n"
-      );
-    } catch {
+    if (claimedKeyWritten) {
+      try {
+        process.stderr.write(
+          "[glasstrace] Account claimed! API key written to .glasstrace/claimed-key. Copy it to your .env.local file.\n"
+        );
+      } catch {
+      }
+      return;
     }
-    return;
   }
   try {
     process.stderr.write(
@@ -408,6 +462,12 @@ function getActiveConfig() {
   }
   return { ...DEFAULT_CAPTURE_CONFIG };
 }
+function getLinkedAccountId() {
+  return currentConfig?.linkedAccountId;
+}
+function getClaimResult() {
+  return currentConfig?.claimResult;
+}
 function _setCurrentConfig(config) {
   currentConfig = config;
 }
@@ -719,7 +779,7 @@ function buildCorsHeaders(origin) {
   }
   return headers;
 }
-function createDiscoveryHandler(getAnonKey, getSessionId) {
+function createDiscoveryHandler(getAnonKey, getSessionId, getClaimState) {
   return async (request) => {
     let url;
     try {
@@ -763,8 +823,16 @@ function createDiscoveryHandler(getAnonKey, getSessionId) {
         );
       }
       const sessionId = getSessionId();
+      const responseBody = { key: anonKey, sessionId };
+      const claimState = getClaimState?.();
+      if (claimState?.claimed) {
+        responseBody.claimed = true;
+        if (claimState.accountHint) {
+          responseBody.accountHint = claimState.accountHint;
+        }
+      }
       return new Response(
-        JSON.stringify({ key: anonKey, sessionId }),
+        JSON.stringify(responseBody),
         {
           status: 200,
           headers: corsHeaders
@@ -3522,9 +3590,15 @@ function registerGlasstrace(options) {
       if (isDiscoveryEnabled(config)) {
         let resolvedAnonKey = null;
         const anonKeyPromise = getOrCreateAnonKey();
+        const getClaimState = () => {
+          if (getLinkedAccountId()) return { claimed: true };
+          if (getClaimResult()) return { claimed: true };
+          return null;
+        };
         discoveryHandler = createDiscoveryHandler(
           async () => resolvedAnonKey,
-          () => sessionManager.getSessionId(getResolvedApiKey())
+          () => sessionManager.getSessionId(getResolvedApiKey()),
+          getClaimState
         );
         if (config.verbose) {
           console.info("[glasstrace] Discovery endpoint registered (key pending).");
@@ -3540,7 +3614,8 @@ function registerGlasstrace(options) {
             if (currentGeneration !== registrationGeneration) return;
             discoveryHandler = createDiscoveryHandler(
               () => Promise.resolve(anonKey),
-              () => sessionManager.getSessionId(getResolvedApiKey())
+              () => sessionManager.getSessionId(getResolvedApiKey()),
+              getClaimState
             );
             await backgroundInit(config, anonKey, currentGeneration);
           } catch (err) {
@@ -3597,7 +3672,7 @@ async function backgroundInit(config, anonKeyForInit, generation) {
   if (config.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const initResult = await performInit(config, anonKeyForInit, "0.10.0");
+  const initResult = await performInit(config, anonKeyForInit, "0.12.0");
   if (generation !== registrationGeneration) return;
   if (initResult?.claimResult) {
     setResolvedApiKey(initResult.claimResult.newApiKey);
@@ -3671,16 +3746,16 @@ async function handleSourceMapUpload(distDir) {
       );
       return;
     }
-    const { collectSourceMaps: collectSourceMaps2, computeBuildHash: computeBuildHash2, uploadSourceMaps: uploadSourceMaps2 } = await import("./source-map-uploader-OA5NCDOK.js");
-    const maps = await collectSourceMaps2(distDir);
-    if (maps.length === 0) {
+    const { discoverSourceMapFiles: discoverSourceMapFiles2, computeBuildHash: computeBuildHash2, uploadSourceMaps: uploadSourceMaps2 } = await import("./source-map-uploader-ZFCYOURS.js");
+    const files = await discoverSourceMapFiles2(distDir);
+    if (files.length === 0) {
       console.info("[glasstrace] No source map files found. Skipping upload.");
       return;
     }
-    const buildHash = await computeBuildHash2(maps);
-    await uploadSourceMaps2(apiKey, endpoint, buildHash, maps);
+    const buildHash = await computeBuildHash2(files);
+    await uploadSourceMaps2(apiKey, endpoint, buildHash, files);
     console.info(
-      `[glasstrace] Uploaded ${String(maps.length)} source map(s) for build ${buildHash}.`
+      `[glasstrace] Uploaded ${String(files.length)} source map(s) for build ${buildHash}.`
     );
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -3722,11 +3797,13 @@ export {
   computeBuildHash,
   createDiscoveryHandler,
   deriveSessionId,
+  discoverSourceMapFiles,
   discoverTestFiles,
   extractImports,
   getActiveConfig,
   getDateString,
   getDiscoveryHandler,
+  getLinkedAccountId,
   getOrCreateAnonKey,
   getOrigin,
   isAnonymousMode,