@lotics/cli 0.185.0 → 0.186.0

package/dist/src/cli.js

@@ -44182,6 +44182,66 @@ function transportErrorMessage(status, parsed) {
   return status < 500 || authored ? jsonMessage : gatewayErrorMessage(status);
 }
 
+// ../shared/src/multipart_parts.ts
+var DEFAULT_MAX_RETRIES = 5;
+var MAX_RETRY_DELAY_MS = 15e3;
+var TIMEOUT_BASE_MS = 3e4;
+var TIMEOUT_PER_MB_MS = 15e3;
+function partTimeoutMs(partSizeBytes) {
+  return TIMEOUT_BASE_MS + Math.ceil(partSizeBytes / (1024 * 1024)) * TIMEOUT_PER_MB_MS;
+}
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var PermanentPartError = class extends Error {
+};
+function isRetryableStatus(status) {
+  return status >= 500 || status === 408 || status === 429;
+}
+function partErrorFor(partNumber, status) {
+  const message2 = `part ${partNumber} rejected by storage (${status})`;
+  return isRetryableStatus(status) ? new Error(message2) : new PermanentPartError(message2);
+}
+async function uploadParts(options) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const concurrency = Math.max(1, options.concurrency ?? 1);
+  const done = [...options.alreadyUploaded ?? []];
+  const finished = new Set(done.map((part) => part.part_number));
+  const queue = options.parts.filter((part) => !finished.has(part.part_number));
+  const uploadOne = async (part) => {
+    const bytes = options.partBytes(part);
+    for (let attempt = 1; ; attempt += 1) {
+      options.signal?.throwIfAborted();
+      try {
+        const timeout = AbortSignal.timeout(partTimeoutMs(bytes));
+        const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+        const etag = await options.putPart(part, await options.readPart(part), signal);
+        if (!etag) {
+          throw new PermanentPartError(`part ${part.part_number} stored without an ETag`);
+        }
+        return { part_number: part.part_number, etag };
+      } catch (error52) {
+        if (options.signal?.aborted) throw error52;
+        if (error52 instanceof PermanentPartError) throw error52;
+        if (attempt >= maxRetries) {
+          options.onExhausted?.({ partNumber: part.part_number, attempts: attempt, error: error52 });
+          throw error52;
+        }
+        options.onRetry?.({ partNumber: part.part_number, attempt, error: error52 });
+        const base = 1e3 * 2 ** (attempt - 1);
+        await sleep(Math.min(base + Math.random() * base * 0.5, MAX_RETRY_DELAY_MS));
+      }
+    }
+  };
+  const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+    for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
+      const part = await uploadOne(next);
+      done.push(part);
+      options.onPartUploaded?.(part);
+    }
+  });
+  await Promise.all(workers);
+  return done.sort((a, b) => a.part_number - b.part_number);
+}
+
 // src/client.ts
 import crypto from "node:crypto";
 import fs2 from "node:fs";
@@ -44301,6 +44361,7 @@ function getMimeType(filename) {
   const ext = path2.extname(filename).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
+var MULTIPART_THRESHOLD_BYTES = 8 * 1024 * 1024;
 var API_BASE_URL = process.env.LOTICS_API_URL ?? "https://api.lotics.ai";
 var WEB_APP_URL = "https://lotics.ai";
 async function fetchOfficialStarters() {
@@ -45077,15 +45138,118 @@ var LoticsClient = class {
     );
   }
   async uploadFiles(filePaths, options) {
-    const items = [];
+    const small = [];
+    const large = [];
     for (let i2 = 0; i2 < filePaths.length; i2++) {
       const absolutePath = path2.resolve(filePaths[i2]);
-      items.push({
-        bytes: await fs2.promises.readFile(absolutePath),
-        filename: options?.filenames?.[i2] ?? path2.basename(absolutePath)
+      const filename = options?.filenames?.[i2] ?? path2.basename(absolutePath);
+      const { size: size2 } = await fs2.promises.stat(absolutePath);
+      if (size2 >= MULTIPART_THRESHOLD_BYTES) {
+        large.push({ absolutePath, filename, size: size2 });
+      } else {
+        small.push({ bytes: await fs2.promises.readFile(absolutePath), filename });
+      }
+    }
+    const files = [];
+    const errors2 = [];
+    if (small.length > 0) {
+      const result = await this.uploadFileBytes(small);
+      files.push(...result.files);
+      errors2.push(...result.errors);
+    }
+    for (const item of large) {
+      try {
+        files.push(await this.uploadLargeFile(item));
+      } catch (error52) {
+        errors2.push({
+          filename: item.filename,
+          error: error52 instanceof Error ? error52.message : String(error52)
+        });
+      }
+    }
+    return { files, errors: errors2 };
+  }
+  /**
+   * Store one file by handing its bytes straight to object storage.
+   *
+   * The API mints presigned part URLs and registers the row; the bytes go
+   * directly from disk to the bucket and never enter the API process. That is
+   * what makes the ceiling "what a workspace may store" rather than "what one
+   * request may cost the server" — the reason `POST /v1/files` and the ticketed
+   * upload are both capped far lower, and the reason this exists at all.
+   *
+   * Parts are read one at a time rather than streamed as a request body: a part
+   * is bounded (the server picks 5–10 MiB), a `fetch` body needs a length the
+   * bucket will check anyway, and reading a slice keeps peak memory at one part
+   * instead of one file.
+   *
+   * The PUT loop itself — retry, backoff, part timeout, ordering — is
+   * `@lotics/shared/multipart_parts`, shared with the browser client so the
+   * hardening cannot exist on one side only.
+   */
+  async uploadLargeFile(input) {
+    const mimeType = getMimeType(input.filename);
+    const init = await this.request("POST", "/v1/files/multipart/init", {
+      filename: input.filename,
+      mime_type: mimeType,
+      file_size: input.size
+    });
+    const partLength = (part) => Math.min(init.part_size, input.size - (part.part_number - 1) * init.part_size);
+    const handle = await fs2.promises.open(input.absolutePath, "r");
+    let uploaded;
+    try {
+      uploaded = await uploadParts({
+        parts: init.parts,
+        partBytes: partLength,
+        // Sequential. Peak memory is then one part rather than one file, which
+        // is the property that lets this run against a 2 GiB upload at all;
+        // raising it trades that for wall-clock, and no upload has asked yet.
+        concurrency: 1,
+        putPart: async (part, body, signal) => {
+          const response = await fetch(part.url, { method: "PUT", body, signal });
+          if (!response.ok) throw partErrorFor(part.part_number, response.status);
+          return response.headers.get("etag") ?? "";
+        },
+        readPart: async (part) => {
+          const offset = (part.part_number - 1) * init.part_size;
+          const length2 = partLength(part);
+          const buffer = Buffer.alloc(length2);
+          let filled = 0;
+          while (filled < length2) {
+            const { bytesRead } = await handle.read(buffer, filled, length2 - filled, offset + filled);
+            if (bytesRead === 0) {
+              throw new Error(
+                `${input.filename} ended after ${offset + filled} bytes, short of the ${input.size} it reported \u2014 it changed while uploading`
+              );
+            }
+            filled += bytesRead;
+          }
+          return buffer;
+        }
+      });
+    } catch (error52) {
+      await this.request("POST", "/v1/files/multipart/abort", {
+        upload_id: init.upload_id,
+        file_storage_key: init.file_storage_key
+      }).catch(() => {
       });
+      throw error52;
+    } finally {
+      await handle.close();
+    }
+    const result = await this.request("POST", "/v1/files/multipart/complete", {
+      file_id: init.file_id,
+      upload_id: init.upload_id,
+      file_storage_key: init.file_storage_key,
+      filename: input.filename,
+      mime_type: mimeType,
+      parts: uploaded
+    });
+    const stored = result.files[0];
+    if (!stored) {
+      throw new Error(result.errors[0]?.error ?? "upload completed but stored no file");
     }
-    return this.uploadFileBytes(items);
+    return stored;
   }
   /**
    * Store files from bytes the caller already holds — the path for a caller that
@@ -45711,7 +45875,7 @@ function resultSideEffects(result) {
 }
 
 // src/version.ts
-var VERSION = "0.185.0";
+var VERSION = "0.186.0";
 
 // src/timezone.ts
 function machineTimezone() {
@@ -103240,7 +103404,7 @@ import { readFileSync, writeFileSync, existsSync as existsSync2, mkdtempSync, rm
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join2, dirname, resolve, extname, basename } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { setTimeout as sleep } from "node:timers/promises";
+import { setTimeout as sleep2 } from "node:timers/promises";
 var HERE = dirname(fileURLToPath2(import.meta.url));
 function fail3(msg) {
   console.error(msg);
@@ -103372,7 +103536,7 @@ async function runPreviewCommand(filePath, flags) {
         const p = parseInt(readFileSync(portFile, "utf8").split("\n")[0], 10);
         if (p) cdpPort = p;
       }
-      if (!cdpPort) await sleep(100);
+      if (!cdpPort) await sleep2(100);
     }
     if (!cdpPort) throw new Error("Chrome did not expose a debugging port (launch failed?).");
     let target;
@@ -103382,7 +103546,7 @@ async function runPreviewCommand(filePath, flags) {
         target = list2.find((t) => t.type === "page");
       } catch {
       }
-      if (!target?.webSocketDebuggerUrl) await sleep(100);
+      if (!target?.webSocketDebuggerUrl) await sleep2(100);
     }
     if (!target?.webSocketDebuggerUrl) throw new Error("No Chrome page target available.");
     const cdp = await cdpConnect(target.webSocketDebuggerUrl);
@@ -103404,7 +103568,7 @@ async function runPreviewCommand(filePath, flags) {
         if (v.warnings?.length) warnings.push(...v.warnings);
         break;
       }
-      await sleep(75);
+      await sleep2(75);
     }
     if (!done) throw new Error("Render timed out (page never signaled completion).");
     if (err2) throw new Error(`Render engine error: ${err2}`);

package/dist/src/client.d.ts

@@ -968,6 +968,7 @@ export declare class LoticsClient {
     uploadFiles(filePaths: string[], options?: {
         filenames?: string[];
     }): Promise<FileUploadResult>;
+    private uploadLargeFile;
     /**
      * Store files from bytes the caller already holds — the path for a caller that
      * never had them on disk (an email attachment decoded in memory, a generated