@lotics/cli 0.184.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.184.0";
+var VERSION = "0.186.0";
 
 // src/timezone.ts
 function machineTimezone() {
@@ -45998,9 +46162,11 @@ var COMMANDS = [
       "                                       shipping: agent schemas vs the live app, workflow",
       "                                       declarations and BODIES vs what is live, aliases",
       "                                       the code calls but nothing bound, undeclared",
-      "                                       capabilities, query drift. Plus the one rule no",
-      "                                       deploy runs: a concrete id or an id-shaped",
-      "                                       placeholder in source a starter would ship.",
+      "                                       capabilities, query drift. Plus two rules no",
+      "                                       deploy runs: every body typechecked against",
+      "                                       the pulled types, and a concrete id or an",
+      "                                       id-shaped placeholder in source a starter",
+      "                                       would ship.",
       "                                       Exits 1 on any of it, so CI can gate on it",
       "  lotics app workflow set <alias>      Push the edited src/workflows/<alias>.ts body",
       "                                       through set_app_workflow (server verifies)",
@@ -71205,11 +71371,8 @@ function subsetIssues(bodySource, offset) {
   ];
 }
 async function loadProjectTypescript(projectDir) {
-  const requireFromProject = createRequire(path8.join(projectDir, "package.json"));
-  let resolved;
-  try {
-    resolved = requireFromProject.resolve("typescript");
-  } catch {
+  const resolved = resolveProjectTypescript(projectDir);
+  if (resolved === null) {
     throw new Error(
       `Could not resolve 'typescript' from ${projectDir}. 'lotics app workflow check' type-checks bodies with the app's own compiler \u2014 run 'npm install' (the scaffold ships typescript as a devDependency).`
     );
@@ -71217,6 +71380,14 @@ async function loadProjectTypescript(projectDir) {
   const mod2 = await import(pathToImportUrl(resolved));
   return mod2.default ?? mod2;
 }
+function resolveProjectTypescript(projectDir) {
+  const requireFromProject = createRequire(path8.join(projectDir, "package.json"));
+  try {
+    return requireFromProject.resolve("typescript");
+  } catch {
+    return null;
+  }
+}
 function pathToImportUrl(p) {
   const resolved = path8.resolve(p);
   const prefixed = resolved.startsWith("/") ? resolved : `/${resolved}`;
@@ -73079,13 +73250,35 @@ async function appCheck(client, args = {}) {
   warnIfUndescribed(app);
   const unportable = scanProjectForIds(projectDir);
   reportPortabilityIds(unportable);
-  if (!nothingPending(pending) || unportable.length > 0) {
+  const bodiesFailing = await countFailingWorkflowBodies(client, projectDir, meta3);
+  if (!nothingPending(pending) || unportable.length > 0 || bodiesFailing > 0) {
     process.exit(1);
   }
   console.error(
-    "Checked the app's bindings, capabilities, agent schemas and id portability \u2014 nothing blocking."
+    "Checked the app's bindings, capabilities, agent schemas, workflow bodies and id portability \u2014 nothing blocking."
   );
 }
+async function countFailingWorkflowBodies(client, projectDir, meta3) {
+  const bound = Object.keys(meta3.workflows ?? {});
+  const typed = bound.filter((alias) => fs8.existsSync(workflowGlobalsPath(projectDir, alias)));
+  const untyped = bound.filter((alias) => !typed.includes(alias));
+  if (untyped.length > 0) {
+    console.error(
+      `\u26A0 Not type-checked, no local types for: ${untyped.join(", ")}. Run 'lotics app codegen' to write .lotics/workflows/<alias>.globals.d.ts.`
+    );
+  }
+  const toCheck = await collectWorkflowBodyChecks(projectDir, meta3, typed, client);
+  if (toCheck.length === 0) return 0;
+  if (resolveProjectTypescript(projectDir) === null) {
+    console.error(
+      `\u26A0 ${toCheck.length} workflow bod${toCheck.length === 1 ? "y" : "ies"} not type-checked \u2014 no 'typescript' in this project's node_modules. Run 'npm install', then 'lotics app workflow check'.`
+    );
+    return 0;
+  }
+  const results = checkWorkflowBodies(await loadProjectTypescript(projectDir), toCheck);
+  printWorkflowCheckResults(projectDir, results);
+  return results.filter((r) => r.issues.length > 0).length;
+}
 async function pushPendingBindings(client, projectDir, pending) {
   const plan = [
     ...pending.queries.map((alias) => `query ${alias}`),
@@ -73974,6 +74167,18 @@ async function appWorkflowCheck(args) {
     console.error(`App ${meta3.app_id} has no bound workflows to check.`);
     return;
   }
+  const toCheck = await collectWorkflowBodyChecks(projectDir, meta3, aliases, args.client);
+  if (toCheck.length === 0) {
+    console.error("No workflow bodies to check (every bound alias was skipped).");
+    return;
+  }
+  const tsApi = await loadProjectTypescript(projectDir);
+  const results = checkWorkflowBodies(tsApi, toCheck);
+  printWorkflowCheckResults(projectDir, results);
+  const failed = results.filter((r) => r.issues.length > 0);
+  if (failed.length > 0) process.exit(1);
+}
+async function collectWorkflowBodyChecks(projectDir, meta3, aliases, client) {
   const toCheck = [];
   for (const alias of aliases) {
     const bodyPath = workflowFilePath(projectDir, alias);
@@ -73994,14 +74199,14 @@ async function appWorkflowCheck(args) {
   }
   for (const { alias, declaration } of staleWorkflowGlobals(projectDir, meta3.workflows ?? {})) {
     if (!toCheck.some((c) => c.alias === alias)) continue;
-    if (!args.client) {
+    if (!client) {
       console.error(
         `\u26A0 "${alias}" \u2014 package.json declares inputs/outputs the local types were not built from, and they cannot be refreshed here (no credentials). Checked against the older types, so a newly declared input will read as a type error that set_app_workflow will accept.`
       );
       continue;
     }
     try {
-      await refreshWorkflowTypes(args.client, projectDir, meta3.app_id, alias, declaration);
+      await refreshWorkflowTypes(client, projectDir, meta3.app_id, alias, declaration);
       console.error(`Refreshed workflow types for ${alias} \u2014 package.json had moved on.`);
     } catch (err2) {
       console.error(
@@ -74009,15 +74214,7 @@ async function appWorkflowCheck(args) {
       );
     }
   }
-  if (toCheck.length === 0) {
-    console.error("No workflow bodies to check (every bound alias was skipped).");
-    return;
-  }
-  const tsApi = await loadProjectTypescript(projectDir);
-  const results = checkWorkflowBodies(tsApi, toCheck);
-  printWorkflowCheckResults(projectDir, results);
-  const failed = results.filter((r) => r.issues.length > 0);
-  if (failed.length > 0) process.exit(1);
+  return toCheck;
 }
 function printWorkflowCheckResults(projectDir, results) {
   let totalErrors = 0;
@@ -103207,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);
@@ -103339,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;
@@ -103349,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);
@@ -103371,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