@glasstrace/sdk 0.9.1 → 0.10.0

package/dist/index.js

@@ -1,20 +1,33 @@
+import {
+  PRESIGNED_THRESHOLD_BYTES,
+  collectSourceMaps,
+  computeBuildHash,
+  installConsoleCapture,
+  isAnonymousMode,
+  isProductionDisabled,
+  maybeShowMcpNudge,
+  readEnvVars,
+  resolveConfig,
+  uploadSourceMaps,
+  uploadSourceMapsAuto,
+  uploadSourceMapsPresigned
+} from "./chunk-KOYJ2UQE.js";
 import {
   buildImportGraph,
   discoverTestFiles,
   extractImports
-} from "./chunk-Y6V7BTF3.js";
+} from "./chunk-5MAHIPFH.js";
+import {
+  getOrCreateAnonKey,
+  readAnonKey
+} from "./chunk-ZRNG36LU.js";
 import {
   DEFAULT_CAPTURE_CONFIG,
   GLASSTRACE_ATTRIBUTE_NAMES,
-  PresignedUploadResponseSchema,
   SdkCachedConfigSchema,
   SdkInitResponseSchema,
-  SessionIdSchema,
-  SourceMapManifestResponseSchema,
-  SourceMapUploadResponseSchema,
-  getOrCreateAnonKey,
-  readAnonKey
-} from "./chunk-PQWAKVQ5.js";
+  SessionIdSchema
+} from "./chunk-O3Y45VGV.js";
 import {
   INVALID_SPAN_CONTEXT,
   SamplingDecision,
@@ -42,56 +55,6 @@ var SdkError = class extends Error {
   }
 };
 
-// src/env-detection.ts
-var DEFAULT_ENDPOINT = "https://api.glasstrace.dev";
-function readEnvVars() {
-  return {
-    GLASSTRACE_API_KEY: process.env.GLASSTRACE_API_KEY?.trim() || void 0,
-    GLASSTRACE_FORCE_ENABLE: process.env.GLASSTRACE_FORCE_ENABLE,
-    GLASSTRACE_ENV: process.env.GLASSTRACE_ENV,
-    GLASSTRACE_COVERAGE_MAP: process.env.GLASSTRACE_COVERAGE_MAP,
-    NODE_ENV: process.env.NODE_ENV,
-    VERCEL_ENV: process.env.VERCEL_ENV
-  };
-}
-function resolveConfig(options) {
-  const env = readEnvVars();
-  return {
-    apiKey: options?.apiKey ?? env.GLASSTRACE_API_KEY,
-    endpoint: options?.endpoint ?? DEFAULT_ENDPOINT,
-    forceEnable: options?.forceEnable ?? env.GLASSTRACE_FORCE_ENABLE === "true",
-    verbose: options?.verbose ?? false,
-    environment: env.GLASSTRACE_ENV,
-    coverageMapEnabled: env.GLASSTRACE_COVERAGE_MAP === "true",
-    nodeEnv: env.NODE_ENV,
-    vercelEnv: env.VERCEL_ENV
-  };
-}
-function isProductionDisabled(config) {
-  if (config.forceEnable) {
-    return false;
-  }
-  if (config.nodeEnv === "production") {
-    return true;
-  }
-  if (config.vercelEnv === "production") {
-    return true;
-  }
-  return false;
-}
-function isAnonymousMode(config) {
-  if (config.apiKey === void 0) {
-    return true;
-  }
-  if (config.apiKey.trim() === "") {
-    return true;
-  }
-  if (config.apiKey.startsWith("gt_anon_")) {
-    return true;
-  }
-  return false;
-}
-
 // src/session.ts
 import { createHash } from "crypto";
 var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
@@ -2230,7 +2193,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path3) {
+function appendResourcePathToUrl(url, path2) {
   try {
     new URL(url);
   } catch {
@@ -2240,11 +2203,11 @@ function appendResourcePathToUrl(url, path3) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path3;
+  url += path2;
   try {
     new URL(url);
   } catch {
-    diag.warn(`Configuration: Provided URL appended with '${path3}' is not a valid URL, using 'undefined' instead of '${url}'`);
+    diag.warn(`Configuration: Provided URL appended with '${path2}' is not a valid URL, using 'undefined' instead of '${url}'`);
     return void 0;
   }
   return url;
@@ -3488,112 +3451,6 @@ async function configureOtel(config, sessionManager) {
   registerShutdownHooks(provider);
 }
 
-// src/nudge/error-nudge.ts
-import { existsSync } from "fs";
-import { join as join2 } from "path";
-var hasFired = false;
-function sanitize(input) {
-  return input.replace(/[\x00-\x1f\x7f]/g, "");
-}
-function maybeShowMcpNudge(errorSummary) {
-  if (hasFired) {
-    return;
-  }
-  const config = resolveConfig();
-  if (isProductionDisabled(config)) {
-    hasFired = true;
-    return;
-  }
-  let markerExists = false;
-  try {
-    const markerPath = join2(process.cwd(), ".glasstrace", "mcp-connected");
-    markerExists = existsSync(markerPath);
-  } catch {
-    markerExists = false;
-  }
-  if (markerExists) {
-    hasFired = true;
-    return;
-  }
-  hasFired = true;
-  const safe = sanitize(errorSummary);
-  process.stderr.write(
-    `[glasstrace] Error captured: ${safe}
-  Debug with AI: ask your agent "What's the latest Glasstrace error?"
-  Not connected? Run: npx glasstrace mcp add
-`
-  );
-}
-
-// src/console-capture.ts
-var isGlasstraceLog = false;
-var originalError = null;
-var originalWarn = null;
-var installed = false;
-var otelApi = null;
-function formatArgs(args) {
-  return args.map((arg) => {
-    if (typeof arg === "string") return arg;
-    if (arg instanceof Error) return arg.stack ?? arg.message;
-    try {
-      return JSON.stringify(arg);
-    } catch {
-      return String(arg);
-    }
-  }).join(" ");
-}
-function isSdkMessage(args) {
-  return typeof args[0] === "string" && args[0].startsWith("[glasstrace]");
-}
-async function installConsoleCapture() {
-  if (installed) return;
-  try {
-    otelApi = await import("./esm-POMEQPKL.js");
-  } catch {
-    otelApi = null;
-  }
-  originalError = console.error;
-  originalWarn = console.warn;
-  installed = true;
-  console.error = (...args) => {
-    originalError.apply(console, args);
-    if (isGlasstraceLog || isSdkMessage(args)) return;
-    if (otelApi) {
-      const span = otelApi.trace.getSpan(otelApi.context.active());
-      if (span) {
-        const formattedMessage = formatArgs(args);
-        span.addEvent("console.error", {
-          "console.message": formattedMessage
-        });
-        try {
-          maybeShowMcpNudge(formattedMessage);
-        } catch {
-        }
-      }
-    }
-  };
-  console.warn = (...args) => {
-    originalWarn.apply(console, args);
-    if (isGlasstraceLog || isSdkMessage(args)) return;
-    if (otelApi) {
-      const span = otelApi.trace.getSpan(otelApi.context.active());
-      if (span) {
-        span.addEvent("console.warn", {
-          "console.message": formatArgs(args)
-        });
-      }
-    }
-  };
-}
-function sdkLog(level, message) {
-  isGlasstraceLog = true;
-  try {
-    console[level](message);
-  } finally {
-    isGlasstraceLog = false;
-  }
-}
-
 // src/register.ts
 var consoleCaptureInstalled = false;
 var discoveryHandler = null;
@@ -3604,6 +3461,12 @@ function registerGlasstrace(options) {
     if (isRegistered) {
       return;
     }
+    if (typeof process === "undefined" || typeof process.versions?.node !== "string") {
+      console.warn(
+        "[glasstrace] SDK requires a Node.js runtime. Edge Runtime, browser, and Deno without Node compat are not supported. Glasstrace is disabled in this environment."
+      );
+      return;
+    }
     const config = resolveConfig(options);
     if (config.verbose) {
       console.info("[glasstrace] Config resolved.");
@@ -3734,7 +3597,7 @@ async function backgroundInit(config, anonKeyForInit, generation) {
   if (config.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const initResult = await performInit(config, anonKeyForInit, "0.9.1");
+  const initResult = await performInit(config, anonKeyForInit, "0.10.0");
   if (generation !== registrationGeneration) return;
   if (initResult?.claimResult) {
     setResolvedApiKey(initResult.claimResult.newApiKey);
@@ -3761,241 +3624,11 @@ function isDiscoveryEnabled(config) {
   return false;
 }
 
-// src/source-map-uploader.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-import * as crypto from "crypto";
-import { execFileSync } from "child_process";
-async function collectSourceMaps(buildDir) {
-  const results = [];
-  try {
-    await walkDir(buildDir, buildDir, results);
-  } catch {
-    return [];
-  }
-  return results;
-}
-async function walkDir(baseDir, currentDir, results) {
-  let entries;
-  try {
-    entries = await fs2.readdir(currentDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const fullPath = path2.join(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDir(baseDir, fullPath, results);
-    } else if (entry.isFile() && entry.name.endsWith(".map")) {
-      try {
-        const content = await fs2.readFile(fullPath, "utf-8");
-        const relativePath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
-        const compiledPath = relativePath.replace(/\.map$/, "");
-        results.push({ filePath: compiledPath, content });
-      } catch {
-      }
-    }
-  }
-}
-async function computeBuildHash(maps) {
-  try {
-    const sha = execFileSync("git", ["rev-parse", "HEAD"], { encoding: "utf-8" }).trim();
-    if (sha) {
-      return sha;
-    }
-  } catch {
-  }
-  const sortedMaps = [...maps ?? []].sort(
-    (a, b) => a.filePath.localeCompare(b.filePath)
-  );
-  const hashInput = sortedMaps.map((m) => `${m.filePath}
-${m.content.length}
-${m.content}`).join("");
-  const hash = crypto.createHash("sha256").update(hashInput).digest("hex");
-  return hash;
-}
-async function uploadSourceMaps(apiKey, endpoint, buildHash, maps) {
-  const body = {
-    apiKey,
-    buildHash,
-    files: maps.map((m) => ({
-      filePath: m.filePath,
-      sourceMap: m.content
-    }))
-  };
-  const baseUrl = stripTrailingSlashes(endpoint);
-  const response = await fetch(`${baseUrl}/v1/source-maps`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    try {
-      await response.text();
-    } catch {
-    }
-    throw new Error(
-      `Source map upload failed: ${String(response.status)} ${response.statusText}`
-    );
-  }
-  const json = await response.json();
-  return SourceMapUploadResponseSchema.parse(json);
-}
-var PRESIGNED_THRESHOLD_BYTES = 45e5;
-function stripTrailingSlashes(url) {
-  let result = url;
-  while (result.endsWith("/")) {
-    result = result.slice(0, -1);
-  }
-  return result;
-}
-async function requestPresignedTokens(apiKey, endpoint, buildHash, files) {
-  const baseUrl = stripTrailingSlashes(endpoint);
-  const response = await fetch(`${baseUrl}/v1/source-maps/presign`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({ buildHash, files })
-  });
-  if (!response.ok) {
-    try {
-      await response.text();
-    } catch {
-    }
-    throw new Error(
-      `Presigned token request failed: ${String(response.status)} ${response.statusText}`
-    );
-  }
-  const json = await response.json();
-  return PresignedUploadResponseSchema.parse(json);
-}
-async function uploadToBlob(clientToken, pathname, content) {
-  let mod;
-  try {
-    mod = await import("@vercel/blob/client");
-  } catch (err) {
-    const code = err.code;
-    if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
-      throw new Error(
-        "Presigned upload requires @vercel/blob. Install it: npm install @vercel/blob"
-      );
-    }
-    throw err;
-  }
-  const result = await mod.put(pathname, new Blob([content]), {
-    access: "public",
-    token: clientToken
-  });
-  return { url: result.url, size: Buffer.byteLength(content, "utf-8") };
-}
-async function submitManifest(apiKey, endpoint, uploadId, buildHash, files) {
-  const baseUrl = stripTrailingSlashes(endpoint);
-  const response = await fetch(`${baseUrl}/v1/source-maps/manifest`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({ uploadId, buildHash, files })
-  });
-  if (!response.ok) {
-    try {
-      await response.text();
-    } catch {
-    }
-    throw new Error(
-      `Source map manifest submission failed: ${String(response.status)} ${response.statusText}`
-    );
-  }
-  const json = await response.json();
-  return SourceMapManifestResponseSchema.parse(json);
-}
-async function uploadSourceMapsPresigned(apiKey, endpoint, buildHash, maps, blobUploader = uploadToBlob) {
-  if (maps.length === 0) {
-    throw new Error("No source maps to upload");
-  }
-  const presigned = await requestPresignedTokens(
-    apiKey,
-    endpoint,
-    buildHash,
-    maps.map((m) => ({
-      filePath: m.filePath,
-      sizeBytes: Buffer.byteLength(m.content, "utf-8")
-    }))
-  );
-  const mapsByPath = new Map(maps.map((m) => [m.filePath, m]));
-  if (mapsByPath.size !== maps.length) {
-    throw new Error("Duplicate filePath entries in source maps");
-  }
-  for (const token of presigned.files) {
-    if (!mapsByPath.has(token.filePath)) {
-      throw new Error(
-        `Presigned token for "${token.filePath}" has no matching source map entry`
-      );
-    }
-  }
-  const CONCURRENCY = 5;
-  const uploadResults = [];
-  for (let i = 0; i < presigned.files.length; i += CONCURRENCY) {
-    const chunk = presigned.files.slice(i, i + CONCURRENCY);
-    const chunkResults = await Promise.all(
-      chunk.map(async (token) => {
-        const entry = mapsByPath.get(token.filePath);
-        const result = await blobUploader(token.clientToken, token.pathname, entry.content);
-        return {
-          filePath: token.filePath,
-          sizeBytes: result.size,
-          blobUrl: result.url
-        };
-      })
-    );
-    uploadResults.push(...chunkResults);
-  }
-  return submitManifest(apiKey, endpoint, presigned.uploadId, buildHash, uploadResults);
-}
-async function uploadSourceMapsAuto(apiKey, endpoint, buildHash, maps, options) {
-  if (maps.length === 0) {
-    throw new Error("No source maps to upload");
-  }
-  const totalBytes = maps.reduce(
-    (sum, m) => sum + Buffer.byteLength(m.content, "utf-8"),
-    0
-  );
-  if (totalBytes < PRESIGNED_THRESHOLD_BYTES) {
-    return uploadSourceMaps(apiKey, endpoint, buildHash, maps);
-  }
-  const checkAvailable = options?.checkBlobAvailable ?? (async () => {
-    try {
-      await import("@vercel/blob/client");
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  const blobAvailable = await checkAvailable();
-  if (blobAvailable) {
-    return uploadSourceMapsPresigned(
-      apiKey,
-      endpoint,
-      buildHash,
-      maps,
-      options?.blobUploader
-    );
-  }
-  sdkLog(
-    "warn",
-    `[glasstrace] Build exceeds 4.5MB (${totalBytes} bytes). Install @vercel/blob for presigned uploads to avoid serverless body size limits. Falling back to legacy upload.`
-  );
-  return uploadSourceMaps(apiKey, endpoint, buildHash, maps);
-}
-
 // src/config-wrapper.ts
 function withGlasstraceConfig(nextConfig) {
+  if (typeof process === "undefined" || typeof process.versions?.node !== "string") {
+    return nextConfig != null ? { ...nextConfig } : {};
+  }
   const config = nextConfig != null ? { ...nextConfig } : {};
   const existingExperimental = config.experimental ?? {};
   config.experimental = { ...existingExperimental, serverSourceMaps: true };
@@ -4038,13 +3671,14 @@ async function handleSourceMapUpload(distDir) {
       );
       return;
     }
-    const maps = await collectSourceMaps(distDir);
+    const { collectSourceMaps: collectSourceMaps2, computeBuildHash: computeBuildHash2, uploadSourceMaps: uploadSourceMaps2 } = await import("./source-map-uploader-OA5NCDOK.js");
+    const maps = await collectSourceMaps2(distDir);
     if (maps.length === 0) {
       console.info("[glasstrace] No source map files found. Skipping upload.");
       return;
     }
-    const buildHash = await computeBuildHash(maps);
-    await uploadSourceMaps(apiKey, endpoint, buildHash, maps);
+    const buildHash = await computeBuildHash2(maps);
+    await uploadSourceMaps2(apiKey, endpoint, buildHash, maps);
     console.info(
       `[glasstrace] Uploaded ${String(maps.length)} source map(s) for build ${buildHash}.`
     );