@glasstrace/sdk 1.1.2 → 1.2.0

package/dist/cli/validate.js

@@ -2,7 +2,7 @@ import {
   identityFingerprint,
   readMcpMarker,
   resolveEffectiveMcpCredential
-} from "../chunk-3LILTM3T.js";
+} from "../chunk-TWTWRJ25.js";
 import "../chunk-X5MAXP5T.js";
 import "../chunk-NSBPE2FW.js";
 

package/dist/index.cjs

@@ -17398,6 +17398,208 @@ function sleep(ms, scheduler, signal) {
 // src/mcp-runtime.ts
 var import_node_crypto = require("node:crypto");
 init_dist();
+
+// src/atomic-write.ts
+function parentDir(filePath) {
+  const lastSlash = filePath.lastIndexOf("/");
+  const lastBackslash = filePath.lastIndexOf("\\");
+  const lastSep = Math.max(lastSlash, lastBackslash);
+  if (lastSep < 0) return ".";
+  if (lastSep === 0) return filePath.slice(0, 1);
+  return filePath.slice(0, lastSep);
+}
+var PARENT_FSYNC_SWALLOWED_CODES = /* @__PURE__ */ new Set([
+  "EISDIR",
+  "EINVAL",
+  "EPERM",
+  "ENOTSUP"
+]);
+function errnoCodeOf(err) {
+  if (err === null || typeof err !== "object") return void 0;
+  const code = err.code;
+  return typeof code === "string" ? code : void 0;
+}
+function defaultTmpPath(targetPath) {
+  return `${targetPath}.tmp`;
+}
+var fsPromisesCache;
+var fsSyncCache;
+async function loadFsPromises() {
+  if (fsPromisesCache !== void 0) {
+    if (fsPromisesCache === null) {
+      throw new Error(
+        "node:fs/promises is unavailable in this environment; atomicWriteFile cannot be used here."
+      );
+    }
+    return fsPromisesCache;
+  }
+  try {
+    fsPromisesCache = await import("node:fs/promises");
+    return fsPromisesCache;
+  } catch {
+    fsPromisesCache = null;
+    throw new Error(
+      "node:fs/promises is unavailable in this environment; atomicWriteFile cannot be used here."
+    );
+  }
+}
+function loadFsSync() {
+  if (fsSyncCache !== void 0) {
+    if (fsSyncCache === null) {
+      throw new Error(
+        "node:fs is unavailable in this environment; atomicWriteFileSync cannot be used here."
+      );
+    }
+    return fsSyncCache;
+  }
+  try {
+    fsSyncCache = require("node:fs");
+    return fsSyncCache;
+  } catch {
+    fsSyncCache = null;
+    throw new Error(
+      "node:fs is unavailable in this environment; atomicWriteFileSync cannot be used here."
+    );
+  }
+}
+async function atomicWriteFile(targetPath, payload, options = {}) {
+  return atomicWriteFileWithTmp(targetPath, defaultTmpPath(targetPath), payload, options);
+}
+async function atomicWriteFileWithTmp(targetPath, tmpPath, payload, options = {}) {
+  const mode = options.mode ?? 384;
+  const encoding = options.encoding ?? "utf-8";
+  const fsp = await loadFsPromises();
+  let handle = null;
+  try {
+    if (typeof payload === "string") {
+      await fsp.writeFile(tmpPath, payload, { encoding, mode });
+    } else {
+      await fsp.writeFile(tmpPath, payload, { mode });
+    }
+    await fsp.chmod(tmpPath, mode);
+    handle = await fsp.open(tmpPath, "r");
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    await fsp.rename(tmpPath, targetPath);
+  } catch (err) {
+    if (handle !== null) {
+      try {
+        await handle.close();
+      } catch {
+      }
+    }
+    await removeTmpResidueAsync(fsp, tmpPath);
+    throw err;
+  }
+  await fsyncParentDirAsync(targetPath, fsp);
+}
+async function removeTmpResidueAsync(fsp, tmpPath) {
+  try {
+    await fsp.unlink(tmpPath);
+    return;
+  } catch (err) {
+    const code = errnoCodeOf(err);
+    if (code !== "EISDIR" && code !== "EPERM") {
+      return;
+    }
+  }
+  try {
+    await fsp.rmdir(tmpPath);
+  } catch {
+  }
+}
+async function fsyncParentDirAsync(targetPath, fsp) {
+  const parent = parentDir(targetPath);
+  let handle = null;
+  try {
+    handle = await fsp.open(parent, "r");
+    await handle.sync();
+  } catch (err) {
+    const code = errnoCodeOf(err);
+    if (code !== void 0 && PARENT_FSYNC_SWALLOWED_CODES.has(code)) {
+      return;
+    }
+    throw err;
+  } finally {
+    if (handle !== null) {
+      try {
+        await handle.close();
+      } catch {
+      }
+    }
+  }
+}
+function atomicWriteFileSync(targetPath, payload, options = {}) {
+  atomicWriteFileSyncWithTmp(targetPath, defaultTmpPath(targetPath), payload, options);
+}
+function atomicWriteFileSyncWithTmp(targetPath, tmpPath, payload, options = {}) {
+  const mode = options.mode ?? 384;
+  const encoding = options.encoding ?? "utf-8";
+  const fs3 = loadFsSync();
+  let fd = null;
+  try {
+    if (typeof payload === "string") {
+      fs3.writeFileSync(tmpPath, payload, { encoding, mode });
+    } else {
+      fs3.writeFileSync(tmpPath, payload, { mode });
+    }
+    fs3.chmodSync(tmpPath, mode);
+    fd = fs3.openSync(tmpPath, "r");
+    fs3.fsyncSync(fd);
+    fs3.closeSync(fd);
+    fd = null;
+    fs3.renameSync(tmpPath, targetPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        fs3.closeSync(fd);
+      } catch {
+      }
+    }
+    removeTmpResidueSync(fs3, tmpPath);
+    throw err;
+  }
+  fsyncParentDirSyncWithFs(targetPath, fs3);
+}
+function removeTmpResidueSync(fs3, tmpPath) {
+  try {
+    fs3.unlinkSync(tmpPath);
+    return;
+  } catch (err) {
+    const code = errnoCodeOf(err);
+    if (code !== "EISDIR" && code !== "EPERM") {
+      return;
+    }
+  }
+  try {
+    fs3.rmdirSync(tmpPath);
+  } catch {
+  }
+}
+function fsyncParentDirSyncWithFs(targetPath, fs3) {
+  const parent = parentDir(targetPath);
+  let fd = null;
+  try {
+    fd = fs3.openSync(parent, "r");
+    fs3.fsyncSync(fd);
+  } catch (err) {
+    const code = errnoCodeOf(err);
+    if (code !== void 0 && PARENT_FSYNC_SWALLOWED_CODES.has(code)) {
+      return;
+    }
+    throw err;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs3.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/mcp-runtime.ts
 var MCP_ENDPOINT = "https://api.glasstrace.dev/mcp";
 var fsPathCache2;
 async function loadFsPath2() {
@@ -17611,7 +17813,6 @@ async function refreshGenericMcpConfigAtRuntime(projectRoot, effective, anonKeyO
   if (!modules) return { action: "absent" };
   const dirPath = modules.path.join(projectRoot, GLASSTRACE_DIR2);
   const configPath = modules.path.join(dirPath, MCP_CONFIG_FILE);
-  const tmpPath = configPath + ".tmp";
   let existing;
   try {
     existing = await modules.fs.readFile(configPath, "utf-8");
@@ -17628,18 +17829,12 @@ async function refreshGenericMcpConfigAtRuntime(projectRoot, effective, anonKeyO
   }
   const replacement = genericMcpConfigContent(MCP_ENDPOINT, effective.key);
   try {
-    await modules.fs.writeFile(tmpPath, replacement, { mode: 384 });
-    await modules.fs.chmod(tmpPath, 384);
-    await modules.fs.rename(tmpPath, configPath);
+    await atomicWriteFile(configPath, replacement, { mode: 384 });
     await writeMcpMarker(projectRoot, {
       credentialSource: effective.source,
       credentialHash: identityFingerprint(effective.key)
     });
   } catch {
-    try {
-      await modules.fs.unlink(tmpPath);
-    } catch {
-    }
     return { action: "preserved" };
   }
   emitRefreshNudge(effective.source);
@@ -17712,7 +17907,6 @@ async function saveCachedConfig(response, projectRoot) {
   const root = projectRoot ?? process.cwd();
   const dirPath = modules.path.join(root, GLASSTRACE_DIR3);
   const configPath = modules.path.join(dirPath, CONFIG_FILE);
-  const tmpPath = `${configPath}.tmp`;
   try {
     await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
     await modules.fs.chmod(dirPath, 448);
@@ -17720,20 +17914,10 @@ async function saveCachedConfig(response, projectRoot) {
       response,
       cachedAt: Date.now()
     };
-    await modules.fs.writeFile(tmpPath, JSON.stringify(cached2), {
+    await atomicWriteFile(configPath, JSON.stringify(cached2), {
       encoding: "utf-8",
       mode: 384
     });
-    try {
-      await modules.fs.chmod(tmpPath, 384);
-      await modules.fs.rename(tmpPath, configPath);
-    } catch (renameErr) {
-      try {
-        await modules.fs.unlink(tmpPath);
-      } catch {
-      }
-      throw renameErr;
-    }
     await modules.fs.chmod(configPath, 384);
   } catch (err) {
     console.warn(
@@ -22000,8 +22184,51 @@ async function runRegistrationPath(config2, sessionManager) {
 // src/context-manager.ts
 var import_node_async_hooks = require("node:async_hooks");
 init_esm();
+var GLASSTRACE_BRAND = 1;
+var GUARD = /* @__PURE__ */ Symbol.for("glasstrace.context-manager.installed");
+var OTEL_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api.1");
+function isOtelContextManager(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.active === "function" && typeof candidate.with === "function" && typeof candidate.bind === "function" && typeof candidate.enable === "function" && typeof candidate.disable === "function";
+}
+function isInstallationRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (candidate.glasstraceContextManagerBrand !== GLASSTRACE_BRAND) return false;
+  return candidate.manager === null || isOtelContextManager(candidate.manager);
+}
+function getOtelRegisteredContextManager() {
+  const otelSlot = globalThis[OTEL_API_KEY];
+  if (typeof otelSlot !== "object" || otelSlot === null) return void 0;
+  const ctx = otelSlot.context;
+  return isOtelContextManager(ctx) ? ctx : void 0;
+}
 function installContextManager() {
   try {
+    const slot = globalThis;
+    const existing = slot[GUARD];
+    const otelCurrent = getOtelRegisteredContextManager();
+    if (isInstallationRecord(existing) && existing.manager !== null && existing.manager === otelCurrent) {
+      return true;
+    }
+    if (isInstallationRecord(existing) && existing.manager === null && otelCurrent !== void 0) {
+      return false;
+    }
+    if (isInstallationRecord(existing) && existing.manager !== null) {
+      const reSuccess = context.setGlobalContextManager(existing.manager);
+      if (!reSuccess) {
+        console.warn(
+          "[glasstrace] Another context manager is already registered. Trace context propagation may not work as expected."
+        );
+      }
+      const reRecord = {
+        glasstraceContextManagerBrand: GLASSTRACE_BRAND,
+        manager: reSuccess ? existing.manager : null
+      };
+      slot[GUARD] = reRecord;
+      return reSuccess;
+    }
     const als = new import_node_async_hooks.AsyncLocalStorage();
     const contextManager = {
       active: () => als.getStore() ?? ROOT_CONTEXT,
@@ -22022,6 +22249,11 @@ function installContextManager() {
         "[glasstrace] Another context manager is already registered. Trace context propagation may not work as expected."
       );
     }
+    const record2 = {
+      glasstraceContextManagerBrand: GLASSTRACE_BRAND,
+      manager: success2 ? contextManager : null
+    };
+    slot[GUARD] = record2;
     return success2;
   } catch {
     return false;
@@ -22211,12 +22443,10 @@ function writeStateNow() {
     };
     const dir = (0, import_node_path.join)(_projectRoot, ".glasstrace");
     const filePath = (0, import_node_path.join)(dir, "runtime-state.json");
-    const tmpPath = (0, import_node_path.join)(dir, "runtime-state.json.tmp");
     (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
-    (0, import_node_fs.writeFileSync)(tmpPath, JSON.stringify(runtimeState, null, 2) + "\n", {
+    atomicWriteFileSync(filePath, JSON.stringify(runtimeState, null, 2) + "\n", {
       mode: 384
     });
-    (0, import_node_fs.renameSync)(tmpPath, filePath);
   } catch (err) {
     sdkLog(
       "warn",
@@ -22255,7 +22485,7 @@ function registerGlasstrace(options) {
     setCoreState(CoreState.REGISTERING);
     startRuntimeStateWriter({
       projectRoot: process.cwd(),
-      sdkVersion: "1.1.2"
+      sdkVersion: "1.2.0"
     });
     const config2 = resolveConfig(options);
     if (config2.verbose) {
@@ -22421,8 +22651,8 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   if (config2.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const healthReport = collectHealthReport("1.1.2");
-  const initResult = await performInit(config2, anonKeyForInit, "1.1.2", healthReport);
+  const healthReport = collectHealthReport("1.2.0");
+  const initResult = await performInit(config2, anonKeyForInit, "1.2.0", healthReport);
   if (generation !== registrationGeneration) return;
   const currentState = getCoreState();
   if (currentState === CoreState.SHUTTING_DOWN || currentState === CoreState.SHUTDOWN) {
@@ -22445,7 +22675,7 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   }
   maybeInstallConsoleCapture();
   if (didLastInitSucceed()) {
-    startHeartbeat(config2, anonKeyForInit, "1.1.2", generation, (newApiKey, accountId) => {
+    startHeartbeat(config2, anonKeyForInit, "1.2.0", generation, (newApiKey, accountId) => {
       setAuthState(AuthState.CLAIMING);
       emitLifecycleEvent("auth:claim_started", { accountId });
       setResolvedApiKey(newApiKey);