@blaxel/core 0.2.52 → 0.2.53

package/dist/esm-browser/common/autoload.js

@@ -2,6 +2,7 @@ import { client } from "../client/client.gen.js";
 import { interceptors } from "../client/interceptors.js";
 import { responseInterceptors } from "../client/responseInterceptor.js";
 import { client as clientSandbox } from "../sandbox/client/client.gen.js";
+import { initSentry } from "./sentry.js";
 import { settings } from "./settings.js";
 client.setConfig({
     baseUrl: settings.baseUrl,
@@ -18,6 +19,8 @@ for (const interceptor of responseInterceptors) {
     client.interceptors.response.use(interceptor);
     clientSandbox.interceptors.response.use(interceptor);
 }
+// Initialize Sentry for SDK error tracking immediately when module loads
+initSentry();
 // Allow to set custom configuration for browser environment
 export function initialize(config) {
     settings.setConfig(config);

package/dist/esm-browser/common/sentry.js

@@ -0,0 +1,188 @@
+import { settings } from "./settings.js";
+import * as Sentry from "@sentry/node";
+import { makeNodeTransport } from "@sentry/node";
+// Isolated Sentry client for SDK-only error tracking (doesn't interfere with user's Sentry)
+let sentryClient = null;
+const capturedExceptions = new Set();
+let handlersRegistered = false;
+// SDK path patterns to identify errors originating from our SDK
+const SDK_PATTERNS = [
+    "@blaxel/",
+    "blaxel-sdk",
+    "/node_modules/@blaxel/",
+    "/@blaxel/core/",
+    "/@blaxel/telemetry/",
+];
+/**
+ * Check if an error originated from the SDK based on its stack trace.
+ * Returns true if the stack trace contains any SDK-related paths.
+ */
+function isFromSDK(error) {
+    const stack = error.stack || "";
+    return SDK_PATTERNS.some((pattern) => stack.includes(pattern));
+}
+/**
+ * Initialize an isolated Sentry client for SDK error tracking.
+ * This creates a separate Sentry instance that won't interfere with any
+ * Sentry configuration the user might have in their application.
+ */
+export function initSentry() {
+    try {
+        // Check if tracking is disabled
+        if (!settings.tracking) {
+            return;
+        }
+        const dsn = settings.sentryDsn;
+        if (!dsn) {
+            return;
+        }
+        // Create an isolated Sentry client that doesn't touch the global scope
+        // This allows users to have their own Sentry.init() without conflicts
+        sentryClient = new Sentry.NodeClient({
+            dsn,
+            environment: settings.env,
+            release: `sdk-typescript@${settings.version}`,
+            transport: makeNodeTransport,
+            stackParser: Sentry.defaultStackParser,
+            // No integrations - we handle error capturing manually
+            integrations: [],
+            // Disable traces for the SDK client
+            tracesSampleRate: 0,
+            // Filter errors before sending - only send SDK errors
+            beforeSend(event, hint) {
+                if (event.environment !== 'dev' && event.environment !== 'prod') {
+                    return null;
+                }
+                const error = hint.originalException;
+                if (error instanceof Error) {
+                    if (!isFromSDK(error)) {
+                        // Drop errors that don't originate from SDK
+                        return null;
+                    }
+                }
+                return event;
+            },
+        });
+        sentryClient.init();
+        // Set SDK-specific tags
+        const scope = new Sentry.Scope();
+        scope.setTag("blaxel.workspace", settings.workspace);
+        scope.setTag("blaxel.version", settings.version);
+        scope.setTag("blaxel.commit", settings.commit);
+        scope.setClient(sentryClient);
+        // Register process handlers for uncaught errors (Node.js only)
+        // Only register once to prevent memory leaks
+        if (typeof process !== "undefined" &&
+            typeof process.on === "function" &&
+            !handlersRegistered) {
+            handlersRegistered = true;
+            // For SIGTERM/SIGINT, flush before exit
+            const signalHandler = (signal) => {
+                flushSentry(500)
+                    .catch(() => {
+                    // Silently fail
+                })
+                    .finally(() => {
+                    process.exit(signal === "SIGTERM" ? 143 : 130);
+                });
+            };
+            // Uncaught exception handler - only capture SDK errors
+            const uncaughtExceptionHandler = (error) => {
+                if (isFromSDK(error)) {
+                    captureException(error);
+                }
+                // Let the default Node.js behavior handle the process exit
+            };
+            // Unhandled rejection handler - only capture SDK errors
+            const unhandledRejectionHandler = (reason) => {
+                const error = reason instanceof Error ? reason : new Error(String(reason));
+                if (isFromSDK(error)) {
+                    captureException(error);
+                }
+            };
+            process.on("SIGTERM", () => signalHandler("SIGTERM"));
+            process.on("SIGINT", () => signalHandler("SIGINT"));
+            process.on("uncaughtException", uncaughtExceptionHandler);
+            process.on("unhandledRejection", unhandledRejectionHandler);
+            // Intercept console.error to capture SDK errors that are caught and logged
+            const originalConsoleError = console.error;
+            console.error = function (...args) {
+                // Call the original console.error first
+                originalConsoleError.apply(console, args);
+                // Check if any argument is an Error from SDK and capture it
+                for (const arg of args) {
+                    if (arg instanceof Error && isFromSDK(arg)) {
+                        captureException(arg);
+                        break; // Only capture the first SDK error to avoid duplicates
+                    }
+                }
+            };
+        }
+    }
+    catch (error) {
+        // Silently fail - Sentry initialization should never break the SDK
+        if (settings.env !== "production") {
+            console.error("[Blaxel SDK] Error initializing Sentry:", error);
+        }
+    }
+}
+/**
+ * Capture an exception to the SDK's isolated Sentry client.
+ * Only errors originating from SDK code will be captured.
+ *
+ * @param error - The error to capture
+ */
+function captureException(error) {
+    if (sentryClient === null) {
+        return;
+    }
+    // Double-check that error is from SDK (defense in depth)
+    if (!isFromSDK(error)) {
+        return;
+    }
+    try {
+        // Create a unique identifier for this exception to avoid duplicates
+        const errorKey = `${error.name}:${error.message}:${error.stack?.slice(0, 200)}`;
+        if (capturedExceptions.has(errorKey)) {
+            return;
+        }
+        capturedExceptions.add(errorKey);
+        // Clean up old exception keys to prevent memory leak
+        if (capturedExceptions.size > 1000) {
+            capturedExceptions.clear();
+        }
+        // Create a scope with SDK tags and capture the exception
+        const scope = new Sentry.Scope();
+        scope.setTag("blaxel.workspace", settings.workspace);
+        scope.setTag("blaxel.version", settings.version);
+        scope.setTag("blaxel.commit", settings.commit);
+        scope.setClient(sentryClient);
+        scope.captureException(error);
+    }
+    catch {
+        // Silently fail - error capturing should never break the SDK
+    }
+}
+/**
+ * Flush pending Sentry events.
+ * This should be called before the process exits to ensure all events are sent.
+ *
+ * @param timeout - Maximum time in milliseconds to wait for flush (default: 2000)
+ */
+export async function flushSentry(timeout = 2000) {
+    if (sentryClient === null) {
+        return;
+    }
+    try {
+        await sentryClient.flush(timeout);
+    }
+    catch {
+        // Silently fail
+    }
+}
+/**
+ * Check if Sentry is initialized and available.
+ */
+export function isSentryInitialized() {
+    return sentryClient !== null;
+}

package/dist/esm-browser/common/settings.js

@@ -1,24 +1,35 @@
+import yaml from 'yaml';
 import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
-// Function to get package version
-function getPackageVersion() {
+import { fs, os, path } from "../common/node.js";
+// Build info - these placeholders are replaced at build time by build:replace-imports
+const BUILD_VERSION = "0.2.53";
+const BUILD_COMMIT = "1a161063708104c65ae116d189af51e3b9cc5ef7";
+const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
+// Cache for config.yaml tracking value
+let configTrackingValue = null;
+let configTrackingLoaded = false;
+function getConfigTracking() {
+    if (configTrackingLoaded) {
+        return configTrackingValue;
+    }
+    configTrackingLoaded = true;
+    if (os === null || fs === null || path === null) {
+        return null;
+    }
     try {
-        // Check if require is available (CommonJS environment)
-        if (typeof require !== "undefined") {
-            // Try to require package.json (Node.js only, gracefully fails in browser)
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const packageJson = {"version":"0.2.52","commit":"4acd7b5efa6c9e04c5131f55e7a87029c4889b1d"};
-            return packageJson.version || "unknown";
-        }
-        else {
-            // ESM environment - return unknown
-            return "unknown";
+        const homeDir = os.homedir();
+        const config = fs.readFileSync(path.join(homeDir, ".blaxel/config.yaml"), "utf8");
+        const configJson = yaml.parse(config);
+        if (typeof configJson.tracking === 'boolean') {
+            configTrackingValue = configJson.tracking;
+            return configTrackingValue;
         }
     }
     catch {
-        // Fallback for browser environments or if require fails
-        return "unknown";
+        // If any error, return null
     }
+    return null;
 }
 // Function to get OS and architecture
 function getOsArch() {
@@ -52,30 +63,9 @@ function getOsArch() {
     }
     return "browser/unknown";
 }
-// Function to get commit hash
-function getCommitHash() {
-    try {
-        // Check if require is available (CommonJS environment)
-        if (typeof require !== "undefined") {
-            // Try to require package.json and look for commit field (set during build)
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const packageJson = {"version":"0.2.52","commit":"4acd7b5efa6c9e04c5131f55e7a87029c4889b1d"};
-            // Check for commit in various possible locations
-            const commit = packageJson.commit || packageJson.buildInfo?.commit;
-            if (commit) {
-                return commit.length > 7 ? commit.substring(0, 7) : commit;
-            }
-        }
-    }
-    catch {
-        // Fallback for browser environments or if require fails
-    }
-    return "unknown";
-}
 class Settings {
     credentials;
     config;
-    _version = null;
     constructor() {
         this.credentials = authentication();
         this.config = {
@@ -130,18 +120,21 @@ class Settings {
         return this.credentials.token;
     }
     get version() {
-        if (this._version === null) {
-            this._version = getPackageVersion();
-        }
-        return this._version;
+        return BUILD_VERSION || "unknown";
+    }
+    get commit() {
+        const commit = BUILD_COMMIT || "unknown";
+        return commit.length > 7 ? commit.substring(0, 7) : commit;
+    }
+    get sentryDsn() {
+        return BUILD_SENTRY_DSN || "";
     }
     get headers() {
         const osArch = getOsArch();
-        const commitHash = getCommitHash();
         return {
             "x-blaxel-authorization": this.authorization,
             "x-blaxel-workspace": this.workspace || "",
-            "User-Agent": `blaxel/sdk/typescript/${this.version} (${osArch}) blaxel/${commitHash}`,
+            "User-Agent": `blaxel/sdk/typescript/${this.version} (${osArch}) blaxel/${this.commit}`,
         };
     }
     get name() {
@@ -168,6 +161,19 @@ class Settings {
     get loggerType() {
         return env.BL_LOGGER || "http";
     }
+    get tracking() {
+        // Environment variable has highest priority
+        if (env.BL_TRACKING !== undefined) {
+            return env.BL_TRACKING === "true";
+        }
+        // Then check config.yaml
+        const configValue = getConfigTracking();
+        if (configValue !== null) {
+            return configValue;
+        }
+        // Default to true if neither is set
+        return true;
+    }
     async authenticate() {
         await this.credentials.authenticate();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.52",
+  "version": "0.2.53",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -53,6 +53,7 @@
   "dependencies": {
     "@hey-api/client-fetch": "^0.10.0",
     "@modelcontextprotocol/sdk": "^1.20.0",
+    "@sentry/node": "^10.27.0",
     "axios": "^1.9.0",
     "dotenv": "^16.5.0",
     "form-data": "^4.0.2",
@@ -74,18 +75,16 @@
     "vite": "^5.2.0",
     "vitest": "^1.5.0"
   },
-  "commit": "4acd7b5efa6c9e04c5131f55e7a87029c4889b1d",
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",
-    "build": "npm run build:inject-commit && npm run build:cjs && npm run build:esm && npm run build:fix-esm && npm run build:esm-package && npm run build:replace-imports && npm run build:browser",
+    "build": "npm run build:cjs && npm run build:esm && npm run build:fix-esm && npm run build:esm-package && npm run build:replace-imports && npm run build:browser",
     "build:cjs": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.cjs.json",
     "build:esm": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.esm.json",
     "build:fix-esm": "node fix-esm-imports.js",
     "build:esm-package": "echo '{\"type\":\"module\"}' > dist/esm/package.json",
     "build:browser": "node fix-browser-imports.js",
-    "build:inject-commit": "node -e \"const fs=require('fs'),pkg=require('./package.json'),{execSync}=require('child_process');try{const commit=execSync('git rev-parse HEAD',{encoding:'utf8'}).trim();pkg.commit=commit;fs.writeFileSync('./package.json',JSON.stringify(pkg,null,'\\t')+'\\n');console.log('✅ Injected commit:',commit.substring(0,7))}catch(e){console.log('⚠️  Could not inject commit:',e.message)}\"",
-    "build:replace-imports": "node -e \"const fs=require('fs'),path=require('path'),pkg=require('./package.json');const paths=['dist/cjs/common/settings.js','dist/esm/common/settings.js','dist/cjs-browser/common/settings.js','dist/esm-browser/common/settings.js'];paths.forEach(settingsPath=>{if(fs.existsSync(settingsPath)){let content=fs.readFileSync(settingsPath,'utf8');content=content.replace(/require\\(\\\".*?\\/package\\.json\\\"\\)/g,JSON.stringify({version:pkg.version,commit:pkg.commit||'unknown'}));fs.writeFileSync(settingsPath,content);console.log('✅ Replaced imports in',settingsPath);}});\"",
+    "build:replace-imports": "node -e \"const fs=require('fs'),{execSync}=require('child_process'),pkg=require('./package.json');let commit='unknown';try{commit=execSync('git rev-parse HEAD',{encoding:'utf8'}).trim()}catch(e){console.log('⚠️  Could not get commit:',e.message)}const sentryDsn=process.env.SENTRY_DSN||'';const paths=['dist/cjs/common/settings.js','dist/esm/common/settings.js','dist/cjs-browser/common/settings.js','dist/esm-browser/common/settings.js'];paths.forEach(p=>{if(fs.existsSync(p)){let c=fs.readFileSync(p,'utf8');c=c.replace(/__BUILD_VERSION__/g,pkg.version);c=c.replace(/__BUILD_COMMIT__/g,commit);c=c.replace(/__BUILD_SENTRY_DSN__/g,sentryDsn);fs.writeFileSync(p,c);console.log('✅ Injected build info in',p,'(v'+pkg.version+', commit:'+commit.substring(0,7)+')');}});\"",
     "test": "vitest --run",
     "test:watch": "vitest --watch"
   }