@blaxel/core 0.3.29 → 0.3.30-preview.324

package/dist/esm-browser/client/sdk.gen.js

@@ -508,6 +508,22 @@ export const createDriveAccessToken = (options) => {
         ...options
     });
 };
+/**
+ * Delete a folder and its contents
+ * Deletes a folder and all its contents directly in drive storage. This is synchronous and non-atomic. If it times out or fails, some contents may have been deleted; retry the same path to finish cleanup. An absent folder succeeds. The drive root and internal metadata cannot be deleted.
+ */
+export const deleteDriveFolder = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives/{driveName}/folders',
+        ...options
+    });
+};
 /**
  * Get drive by external ID
  * Returns a drive matching the given external ID. If no drive is found, returns 404.
@@ -2060,6 +2076,74 @@ export const getSandboxScheduleMetrics = (options) => {
         ...options
     });
 };
+/**
+ * Delete secret by query
+ * Deletes a secret by name (query parameter) from the workspace.
+ */
+export const deleteSecretByQuery = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/secrets',
+        ...options
+    });
+};
+/**
+ * List secrets
+ * Lists the secrets of the workspace. Values are write-only and never returned.
+ */
+export const listSecrets = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/secrets',
+        ...options
+    });
+};
+/**
+ * Upsert secret
+ * Creates or updates a secret by name. Each call stores a new immutable version; the latest version is the one resolved by the proxy.
+ */
+export const upsertSecret = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/secrets',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+/**
+ * Delete secret
+ * Deletes a secret and all its versions from the workspace.
+ */
+export const deleteSecret = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/secrets/{secretName}',
+        ...options
+    });
+};
 /**
  * List service accounts
  * Returns all service accounts in the workspace. Service accounts are machine identities for external systems to authenticate with Blaxel via OAuth or API keys.

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

@@ -1,6 +1,7 @@
 import { client } from "../client/client.gen.js";
 import { client as clientSandbox } from "../sandbox/client/client.gen.js";
 import { controlPlaneFetch } from "./controlPlaneFetch.js";
+import { trackSDKInstalled } from "./posthog.js";
 import { initSentry } from "./sentry.js";
 import { settings } from "./settings.js";
 let autoloaded = false;
@@ -38,6 +39,13 @@ export function ensureAutoloaded() {
     clientSandbox.setConfig({ baseUrl: settings.baseUrl });
     // Initialize Sentry for SDK error tracking.
     initSentry();
+    // Track SDK installation (fires once per new version).
+    try {
+        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/esm-browser/common/posthog.js

@@ -0,0 +1,250 @@
+import { fs, os, path } from "../common/node.js";
+import { settings } from "./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.
+ */
+export const 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 (os === null || path === null) {
+        return null;
+    }
+    try {
+        return path.join(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 (fs === null) {
+        return telemetryState;
+    }
+    const telemetryPath = getTelemetryPath();
+    if (!telemetryPath) {
+        return telemetryState;
+    }
+    try {
+        const data = 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.
+ */
+export 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 (fs === null || path === null || os === null) {
+        return;
+    }
+    const telemetryPath = getTelemetryPath();
+    if (!telemetryPath) {
+        return;
+    }
+    try {
+        const dir = path.dirname(telemetryPath);
+        if (!fs.existsSync(dir)) {
+            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(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);
+        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.
+ */
+export 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.tracking,
+    getVersion: () => 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(POSTHOG_FLUSH_BUDGET_MS)
+        : undefined,
+});
+/**
+ * Track SDK installation. Fires "Installed SDK" once per new version.
+ * Called during SDK autoload.
+ */
+export function trackSDKInstalled() {
+    void sdkInstallTracker();
+}

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

@@ -24,8 +24,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.29";
-const BUILD_COMMIT = "c1f5d1cffc5e85565febbbe0737df89947f2caa5";
+const BUILD_VERSION = "0.3.30-preview.324";
+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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blaxel/core",
-	"version": "0.3.29",
+	"version": "0.3.30-preview.324",
 	"description": "Blaxel Core SDK for TypeScript",
 	"license": "MIT",
 	"author": "Blaxel, INC (https://blaxel.ai)",
@@ -14,7 +14,7 @@
 		"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: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)+')');}});\"",
+		"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 posthogKey=process.env.POSTHOG_KEY||'';const settingsPaths=['dist/cjs/common/settings.js','dist/esm/common/settings.js','dist/cjs-browser/common/settings.js','dist/esm-browser/common/settings.js'];settingsPaths.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)+')');}});const posthogPaths=['dist/cjs/common/posthog.js','dist/esm/common/posthog.js','dist/cjs-browser/common/posthog.js','dist/esm-browser/common/posthog.js'];posthogPaths.forEach(p=>{if(fs.existsSync(p)){let c=fs.readFileSync(p,'utf8');c=c.replace(/__BUILD_POSTHOG_KEY__/g,posthogKey);fs.writeFileSync(p,c);console.log('✅ Injected PostHog key in',p);}});\"",
 		"test": "vitest --run",
 		"test:watch": "vitest --watch"
 	},