@blaxel/core 0.3.30-preview.323 → 0.3.30

package/dist/cjs-browser/common/lazyInit.js

@@ -37,6 +37,7 @@ exports.ensureAutoloaded = ensureAutoloaded;
 const client_gen_js_1 = require("../client/client.gen.js");
 const client_gen_js_2 = require("../sandbox/client/client.gen.js");
 const controlPlaneFetch_js_1 = require("./controlPlaneFetch.js");
+const posthog_js_1 = require("./posthog.js");
 const sentry_js_1 = require("./sentry.js");
 const settings_js_1 = require("./settings.js");
 let autoloaded = false;
@@ -74,6 +75,13 @@ function ensureAutoloaded() {
     client_gen_js_2.client.setConfig({ baseUrl: settings_js_1.settings.baseUrl });
     // Initialize Sentry for SDK error tracking.
     (0, sentry_js_1.initSentry)();
+    // Track SDK installation (fires once per new version).
+    try {
+        (0, posthog_js_1.trackSDKInstalled)();
+    }
+    catch {
+        // Silently ignore - telemetry should never break the SDK
+    }
     // Background H2 connection warming (Node.js only)
     const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
     /* eslint-disable */

package/dist/cjs-browser/common/posthog.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSTHOG_FLUSH_BUDGET_MS = void 0;
+exports.mergeTelemetryState = mergeTelemetryState;
+exports.createSDKInstallTracker = createSDKInstallTracker;
+exports.trackSDKInstalled = trackSDKInstalled;
+const node_js_1 = require("../common/node.js");
+const settings_js_1 = require("./settings.js");
+// PostHog API key injected at build time via build:replace-imports
+const BUILD_POSTHOG_KEY = "";
+// PostHog API endpoint
+const POSTHOG_HOST = "https://us.i.posthog.com";
+/**
+ * How long a capture may stay outstanding.
+ *
+ * Node keeps the event loop alive while a fetch is pending, so this is what a
+ * short-lived script waits for before it can exit. A capture against
+ * us.i.posthog.com takes ~250-350ms end to end (DNS + TLS handshake + POST), so
+ * a second covers the happy path with headroom. The ceiling matters because a
+ * version is only recorded after a successful delivery: when the endpoint is
+ * unreachable every later run tries again, and networks that silently drop
+ * traffic rather than refusing it would otherwise pay the full timeout each
+ * time.
+ */
+exports.POSTHOG_FLUSH_BUDGET_MS = 1000;
+/** The single per-language entry this SDK owns in the shared telemetry file. */
+const SDK_STATE_KEY = "typescript";
+let telemetryState = null;
+/**
+ * Get the PostHog API key (injected at build time).
+ */
+function getPosthogKey() {
+    const key = BUILD_POSTHOG_KEY;
+    // If the placeholder was not replaced, treat as empty
+    if (!key || key.startsWith("__BUILD_")) {
+        return "";
+    }
+    return key;
+}
+/**
+ * Get the telemetry file path.
+ */
+function getTelemetryPath() {
+    if (node_js_1.os === null || node_js_1.path === null) {
+        return null;
+    }
+    try {
+        return node_js_1.path.join(node_js_1.os.homedir(), ".blaxel", "telemetry.json");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load telemetry state from disk.
+ */
+function loadTelemetryState() {
+    if (telemetryState !== null) {
+        return telemetryState;
+    }
+    telemetryState = { distinct_id: "", sdks: {} };
+    if (node_js_1.fs === null) {
+        return telemetryState;
+    }
+    const telemetryPath = getTelemetryPath();
+    if (!telemetryPath) {
+        return telemetryState;
+    }
+    try {
+        const data = node_js_1.fs.readFileSync(telemetryPath, "utf8");
+        const parsed = JSON.parse(data);
+        telemetryState = {
+            ...parsed,
+            distinct_id: parsed.distinct_id || "",
+            sdks: parsed.sdks || {},
+        };
+    }
+    catch {
+        // File doesn't exist or is invalid - use defaults
+    }
+    return telemetryState;
+}
+/**
+ * Combine this process's telemetry snapshot with what is on disk right now.
+ *
+ * `~/.blaxel/telemetry.json` is shared with the CLI and the Python SDK, and
+ * each of them caches it in memory for the lifetime of its process. Writing
+ * this snapshot back wholesale would roll back anything the others recorded in
+ * the meantime, which makes them re-send their "Installed" event on every later
+ * run. Anything already on disk is at least as fresh as what is held here, so
+ * it wins, except for the fields this process actually owns.
+ */
+function mergeTelemetryState(onDisk, ours) {
+    const merged = { ...ours, ...onDisk };
+    // Only re-assert the one language entry this process owns. Writing back the
+    // whole cached map would roll back a newer version another SDK recorded
+    // after this process started, and that SDK would then re-send its
+    // "Installed" event.
+    const onDiskSdks = typeof onDisk.sdks === "object" && onDisk.sdks !== null ? onDisk.sdks : {};
+    const ownVersion = ours.sdks?.[SDK_STATE_KEY];
+    merged.sdks = {
+        ...onDiskSdks,
+        ...(ownVersion ? { [SDK_STATE_KEY]: ownVersion } : {}),
+    };
+    // distinct_id is shared by every writer, so the first one persisted wins.
+    // Replacing it would split the same user across two PostHog identities.
+    const onDiskId = typeof onDisk.distinct_id === "string" ? onDisk.distinct_id : "";
+    merged.distinct_id = onDiskId || ours.distinct_id;
+    return merged;
+}
+/**
+ * Save telemetry state to disk, preserving concurrent writes from the CLI and
+ * the other SDK.
+ */
+function saveTelemetryState(state) {
+    if (node_js_1.fs === null || node_js_1.path === null || node_js_1.os === null) {
+        return;
+    }
+    const telemetryPath = getTelemetryPath();
+    if (!telemetryPath) {
+        return;
+    }
+    try {
+        const dir = node_js_1.path.dirname(telemetryPath);
+        if (!node_js_1.fs.existsSync(dir)) {
+            node_js_1.fs.mkdirSync(dir, { recursive: true });
+        }
+        // Re-read immediately before writing rather than trusting the snapshot
+        // loaded when this process started.
+        let onDisk = {};
+        try {
+            const parsed = JSON.parse(node_js_1.fs.readFileSync(telemetryPath, "utf8"));
+            if (typeof parsed === "object" && parsed !== null) {
+                onDisk = parsed;
+            }
+        }
+        catch {
+            // No readable file yet - this process's state is all there is.
+        }
+        const merged = mergeTelemetryState(onDisk, state);
+        node_js_1.fs.writeFileSync(telemetryPath, JSON.stringify(merged, null, 2), {
+            mode: 0o600,
+        });
+        // Adopt the persisted identity so events match what other writers use.
+        if (typeof merged.distinct_id === "string" && merged.distinct_id) {
+            state.distinct_id = merged.distinct_id;
+        }
+    }
+    catch {
+        // Silently fail
+    }
+}
+/**
+ * Generate a UUID v4 without external dependencies.
+ */
+function generateUUID() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 10
+    const hex = Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/**
+ * Get or create a persistent distinct ID for PostHog events.
+ */
+function getDistinctID() {
+    const state = loadTelemetryState();
+    if (state.distinct_id) {
+        return state.distinct_id;
+    }
+    state.distinct_id = generateUUID();
+    saveTelemetryState(state);
+    return state.distinct_id;
+}
+/**
+ * Create an SDK install tracker. Exported from this internal module so delivery
+ * and deduplication behavior can be tested without build-time credentials.
+ */
+function createSDKInstallTracker(options) {
+    const pendingVersions = new Set();
+    return function track() {
+        const apiKey = options.getApiKey();
+        if (!apiKey || !options.isTrackingEnabled() || !options.isNode()) {
+            return;
+        }
+        const version = options.getVersion();
+        if (!version ||
+            version === "unknown" ||
+            version === "__BUILD_VERSION__") {
+            return;
+        }
+        const state = options.loadState();
+        const stateKey = SDK_STATE_KEY;
+        if (state.sdks?.[stateKey] === version || pendingVersions.has(version)) {
+            return;
+        }
+        pendingVersions.add(version);
+        return (async () => {
+            try {
+                const payload = {
+                    api_key: apiKey,
+                    event: "Installed SDK",
+                    distinct_id: options.getDistinctId(),
+                    timestamp: new Date().toISOString(),
+                    properties: {
+                        language: "typescript",
+                        sdk: "core",
+                        version,
+                    },
+                };
+                const response = await options.fetch(`${POSTHOG_HOST}/capture/`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(payload),
+                    signal: options.getSignal(),
+                });
+                if (!response.ok) {
+                    return;
+                }
+                state.sdks ??= {};
+                state.sdks[stateKey] = version;
+                options.saveState(state);
+            }
+            catch {
+                // Telemetry must never break the SDK. A later call may retry.
+            }
+            finally {
+                pendingVersions.delete(version);
+            }
+        })();
+    };
+}
+const sdkInstallTracker = createSDKInstallTracker({
+    getApiKey: getPosthogKey,
+    isTrackingEnabled: () => settings_js_1.settings.tracking,
+    getVersion: () => settings_js_1.settings.version,
+    isNode: () => typeof process !== "undefined" && Boolean(process.versions?.node),
+    loadState: loadTelemetryState,
+    saveState: saveTelemetryState,
+    getDistinctId: getDistinctID,
+    fetch: (...args) => globalThis.fetch(...args),
+    getSignal: () => typeof AbortSignal !== "undefined" &&
+        typeof AbortSignal.timeout === "function"
+        ? AbortSignal.timeout(exports.POSTHOG_FLUSH_BUDGET_MS)
+        : undefined,
+});
+/**
+ * Track SDK installation. Fires "Installed SDK" once per new version.
+ * Called during SDK autoload.
+ */
+function trackSDKInstalled() {
+    void sdkInstallTracker();
+}

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

@@ -30,8 +30,8 @@ function missingCredentialsMessage() {
     return "No Blaxel credentials found. Set the BL_API_KEY and BL_WORKSPACE environment variables, or run `bl login`.";
 }
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.3.30-preview.323";
-const BUILD_COMMIT = "999bd1ab9bdf3a42c60a8d62a89f5cb21a520c30";
+const BUILD_VERSION = "0.3.30";
+const BUILD_COMMIT = "e88b0db8a85b1db102dfedce7af3e5f5ebae1f52";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-09-22";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2

package/dist/cjs-browser/types/common/posthog.d.ts

@@ -0,0 +1,51 @@
+/**
+ * How long a capture may stay outstanding.
+ *
+ * Node keeps the event loop alive while a fetch is pending, so this is what a
+ * short-lived script waits for before it can exit. A capture against
+ * us.i.posthog.com takes ~250-350ms end to end (DNS + TLS handshake + POST), so
+ * a second covers the happy path with headroom. The ceiling matters because a
+ * version is only recorded after a successful delivery: when the endpoint is
+ * unreachable every later run tries again, and networks that silently drop
+ * traffic rather than refusing it would otherwise pay the full timeout each
+ * time.
+ */
+export declare const POSTHOG_FLUSH_BUDGET_MS = 1000;
+type TelemetryState = {
+    distinct_id: string;
+    cli?: string;
+    sdks?: Record<string, string>;
+};
+/**
+ * Combine this process's telemetry snapshot with what is on disk right now.
+ *
+ * `~/.blaxel/telemetry.json` is shared with the CLI and the Python SDK, and
+ * each of them caches it in memory for the lifetime of its process. Writing
+ * this snapshot back wholesale would roll back anything the others recorded in
+ * the meantime, which makes them re-send their "Installed" event on every later
+ * run. Anything already on disk is at least as fresh as what is held here, so
+ * it wins, except for the fields this process actually owns.
+ */
+export declare function mergeTelemetryState(onDisk: Record<string, unknown>, ours: TelemetryState): Record<string, unknown>;
+type SDKInstallTrackerOptions = {
+    getApiKey: () => string;
+    isTrackingEnabled: () => boolean;
+    getVersion: () => string;
+    isNode: () => boolean;
+    loadState: () => TelemetryState;
+    saveState: (state: TelemetryState) => void;
+    getDistinctId: () => string;
+    fetch: typeof globalThis.fetch;
+    getSignal: () => AbortSignal | undefined;
+};
+/**
+ * Create an SDK install tracker. Exported from this internal module so delivery
+ * and deduplication behavior can be tested without build-time credentials.
+ */
+export declare function createSDKInstallTracker(options: SDKInstallTrackerOptions): () => Promise<void> | undefined;
+/**
+ * Track SDK installation. Fires "Installed SDK" once per new version.
+ * Called during SDK autoload.
+ */
+export declare function trackSDKInstalled(): void;
+export {};