@blaxel/core 0.3.34 → 0.3.35-preview.343

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.34";
-const BUILD_COMMIT = "e1289af07e1a5c5efeb0af7b397d2c2fd138d89f";
+const BUILD_VERSION = "0.3.35-preview.343";
+const BUILD_COMMIT = "e66e8bf5e0039bfc9727326f22348a237c42d737";
 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/sandbox/filesystem/copy-no-overwrite.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFileExistsError = void 0;
+/**
+ * Thrown by `cp(..., { noOverwrite: true })` when the sandbox API reports that the
+ * final target already exists (HTTP 409, code `FILE_ALREADY_EXISTS`). The target is
+ * left unchanged. Paths are the original request strings, not the resolved child path.
+ */
+class SandboxFileExistsError extends Error {
+    source;
+    destination;
+    code = "FILE_ALREADY_EXISTS";
+    constructor(source, destination, options) {
+        super(`Could not copy ${source} to ${destination}: destination already exists`, options);
+        this.source = source;
+        this.destination = destination;
+        this.name = "SandboxFileExistsError";
+    }
+}
+exports.SandboxFileExistsError = SandboxFileExistsError;

package/dist/cjs-browser/sandbox/filesystem/filesystem.js

@@ -9,6 +9,7 @@ const transient_retry_js_1 = require("../../common/transient-retry.js");
 const shell_js_1 = require("../../common/shell.js");
 const action_js_1 = require("../action.js");
 const index_js_1 = require("../client/index.js");
+const copy_no_overwrite_js_1 = require("./copy-no-overwrite.js");
 // Multipart upload constants
 const MULTIPART_THRESHOLD = 5 * 1024 * 1024; // 5MB
 const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB per part
@@ -380,7 +381,10 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             return result.data;
         });
     }
-    async cp(source, destination, { maxWait = 180000 } = {}) {
+    async cp(source, destination, { maxWait = 180000, noOverwrite = false } = {}) {
+        if (noOverwrite) {
+            return this.copyNoOverwrite(source, destination, maxWait);
+        }
         // Quote both paths so the shell that runs this command treats them as
         // single literal arguments instead of interpreting metacharacters in them.
         let process = await this.process.exec({
@@ -396,6 +400,50 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             destination,
         };
     }
+    // One request: the sandbox API copies with exclusive creates and answers 409
+    // FILE_ALREADY_EXISTS when the final target exists. Not retried: a POST copy
+    // may have created entries before a connection reset.
+    // maxWait bounds the request like the default path's wait; -1 waits indefinitely.
+    async copyNoOverwrite(source, destination, maxWait) {
+        if (!source || !destination) {
+            throw new RangeError("source and destination must be nonempty paths");
+        }
+        if (!Number.isFinite(maxWait) || (maxWait < 0 && maxWait !== -1)) {
+            throw new RangeError("maxWait must be -1 or finite and non-negative");
+        }
+        const controller = new AbortController();
+        const timeoutError = new Error(`Could not copy ${source} to ${destination} within ${maxWait} ms; the sandbox may still be copying`);
+        const timeout = maxWait === -1 ? undefined : setTimeout(() => controller.abort(timeoutError), maxWait);
+        let result;
+        try {
+            result = await this.client.post({
+                url: "/filesystem-copy",
+                body: { source, destination, noOverwrite: true },
+                headers: { "Content-Type": "application/json" },
+                baseUrl: this.url,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            // Fetch implementations differ in what they reject with on abort.
+            if (controller.signal.aborted)
+                throw timeoutError;
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        const { response, data, error } = result;
+        if (response.status === 409 && error?.code === "FILE_ALREADY_EXISTS") {
+            throw new copy_no_overwrite_js_1.SandboxFileExistsError(source, destination, { cause: error });
+        }
+        if (response.status === 404 && !error?.code && !error?.error) {
+            // An older sandbox API has no copy endpoint. Never fall back to an overwriting copy.
+            throw new Error("cp with noOverwrite needs a newer sandbox API: this sandbox has no /filesystem-copy endpoint; update its image");
+        }
+        this.handleResponseError(response, data, error);
+        return { message: "Files copied", source, destination };
+    }
     watch(path, callback, options) {
         path = this.formatPath(path);
         let closed = false;

package/dist/cjs-browser/sandbox/filesystem/index.js

@@ -14,5 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFileExistsError = void 0;
 __exportStar(require("./filesystem.js"), exports);
+var copy_no_overwrite_js_1 = require("./copy-no-overwrite.js");
+Object.defineProperty(exports, "SandboxFileExistsError", { enumerable: true, get: function () { return copy_no_overwrite_js_1.SandboxFileExistsError; } });
 __exportStar(require("./types.js"), exports);

package/dist/cjs-browser/types/sandbox/filesystem/copy-no-overwrite.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Thrown by `cp(..., { noOverwrite: true })` when the sandbox API reports that the
+ * final target already exists (HTTP 409, code `FILE_ALREADY_EXISTS`). The target is
+ * left unchanged. Paths are the original request strings, not the resolved child path.
+ */
+export declare class SandboxFileExistsError extends Error {
+    readonly source: string;
+    readonly destination: string;
+    readonly code: "FILE_ALREADY_EXISTS";
+    constructor(source: string, destination: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/cjs-browser/types/sandbox/filesystem/filesystem.d.ts

@@ -32,9 +32,11 @@ export declare class SandboxFileSystem extends SandboxAction {
     search(query: string, path?: string, options?: FilesystemSearchOptions): Promise<FuzzySearchResponse>;
     find(path: string, options?: FilesystemFindOptions): Promise<FindResponse>;
     grep(query: string, path?: string, options?: FilesystemGrepOptions): Promise<ContentSearchResponse>;
-    cp(source: string, destination: string, { maxWait }?: {
+    cp(source: string, destination: string, { maxWait, noOverwrite }?: {
         maxWait?: number;
+        noOverwrite?: boolean;
     }): Promise<CopyResponse>;
+    private copyNoOverwrite;
     watch(path: string, callback: (fileEvent: WatchEvent) => void | Promise<void>, options?: {
         onError?: (error: Error) => void;
         /** Called on each server keepalive (every ~30s). Use it to detect a silent, dead stream. */

package/dist/cjs-browser/types/sandbox/filesystem/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./filesystem.js";
+export { SandboxFileExistsError } from "./copy-no-overwrite.js";
 export * from "./types.js";