@lacrous/omnicloud 0.2.32 → 0.2.34

package/dist/index.cjs

@@ -77,6 +77,51 @@ var OmniCloudError = class extends Error {
   details;
 };
 var DEFAULT_RETRY = { attempts: 3, baseDelayMs: 300 };
+function randomId() {
+  return globalThis.crypto.randomUUID().replace(/-/g, "");
+}
+function multipartHead(boundary, fields, fileName) {
+  const parts = fields.map(
+    ([name, value]) => `--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}\r
+`
+  );
+  const safeName = fileName.replace(/["\\\r\n]/g, "_");
+  parts.push(
+    `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${safeName}"\r
+Content-Type: application/octet-stream\r
+\r
+`
+  );
+  return parts.join("");
+}
+function nodeMultipartStream(head, file, tail) {
+  const encoder = new TextEncoder();
+  const iterator = file[Symbol.asyncIterator]();
+  let sentHead = false;
+  return new ReadableStream({
+    async pull(controller) {
+      if (!sentHead) {
+        sentHead = true;
+        controller.enqueue(encoder.encode(head));
+        return;
+      }
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.enqueue(encoder.encode(tail));
+        controller.close();
+        return;
+      }
+      controller.enqueue(typeof value === "string" ? encoder.encode(value) : new Uint8Array(value));
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(resolve, ms);
@@ -368,10 +413,13 @@ var FilesApi = class {
   async upload(input, options = {}) {
     const attempts = Math.max(1, (options.retry ?? 2) + 1);
     let lastError;
-    const blob = await toBlob(input);
+    const source = input.path !== void 0 && this.canStreamFromDisk() ? { kind: "path", path: input.path } : { kind: "blob", blob: await toBlob(input) };
     for (let attempt = 1; attempt <= attempts; attempt += 1) {
       try {
-        return await this.uploadOnce(blob, input.name, options);
+        if (source.kind === "path") {
+          return await this.uploadPathOnce(source.path, input.name, options);
+        }
+        return await this.uploadOnce(source.blob, input.name, options);
       } catch (error) {
         lastError = error;
         if (options.signal?.aborted) throw error;
@@ -381,6 +429,46 @@ var FilesApi = class {
     }
     throw lastError;
   }
+  canStreamFromDisk() {
+    return typeof XMLHttpRequest !== "function" && typeof ReadableStream === "function";
+  }
+  /**
+   * Node: streams a file from disk as a multipart body. The file is re-opened on
+   * every attempt, so a retry sends the same bytes without holding them in memory.
+   */
+  async uploadPathOnce(path, name, options) {
+    const { createReadStream, statSync } = await import("fs");
+    const size = statSync(path).size;
+    const boundary = `omnicloud-${randomId()}`;
+    const fields = [];
+    if (options.folderId) fields.push(["folderId", options.folderId]);
+    const head = multipartHead(boundary, fields, name);
+    const tail = `\r
+--${boundary}--\r
+`;
+    const body = nodeMultipartStream(head, createReadStream(path), tail);
+    const response = await this.client.fetchImpl(`${this.client.baseUrl}/api/files`, {
+      method: "POST",
+      headers: {
+        ...this.client.defaultHeaders,
+        "Content-Type": `multipart/form-data; boundary=${boundary}`,
+        "Content-Length": String(Buffer.byteLength(head) + size + Buffer.byteLength(tail))
+      },
+      body,
+      credentials: "include",
+      duplex: "half"
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      const error = safeJsonParse(text)?.error;
+      throw new OmniCloudError(
+        response.status,
+        error?.code ?? "UPLOAD_FAILED",
+        error?.message ?? `Upload failed (${response.status})`
+      );
+    }
+    return JSON.parse(text).file;
+  }
   async uploadOnce(blob, name, options) {
     const form = new FormData();
     form.append("file", blob, name);
@@ -1381,6 +1469,9 @@ async function resolveItemQuery(folders, userId, input) {
 // ../core/src/services/auth-session-service.ts
 var import_node_crypto3 = require("crypto");
 
+// ../core/src/services/api-token-service.ts
+var import_node_crypto4 = require("crypto");
+
 // ../core/src/services/version-retention.ts
 function versionsToPrune(versions, currentVersionId, policy, now) {
   const historical = versions.filter((version) => version.id !== currentVersionId).sort((a, b) => b.versionNumber - a.versionNumber);
@@ -1502,7 +1593,7 @@ function sanitizeFileName(name) {
 }
 
 // ../core/src/utils/request-fingerprint.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 function uploadRequestFingerprint(input) {
   const contentHash = input.spooled?.sha256 ?? sha256Hex(input.data ?? Buffer.alloc(0));
   const canonical = JSON.stringify({
@@ -1512,7 +1603,7 @@ function uploadRequestFingerprint(input) {
     contentHash,
     size: input.spooled?.size ?? input.data?.byteLength ?? 0
   });
-  return (0, import_node_crypto4.createHash)("sha256").update(canonical).digest("hex");
+  return (0, import_node_crypto5.createHash)("sha256").update(canonical).digest("hex");
 }
 
 // ../core/src/services/file-service.ts
@@ -2747,7 +2838,7 @@ var RecentService = class {
 };
 
 // ../core/src/utils/spool.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_os = require("os");
@@ -2756,16 +2847,16 @@ var import_node_stream2 = require("stream");
 var import_promises2 = require("stream/promises");
 
 // ../core/src/utils/secret-box.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("crypto");
 
 // ../telegram/src/client.ts
 var import_telegram = require("telegram");
 var import_sessions = require("telegram/sessions/index.js");
 
 // ../telegram/src/errors.ts
-var import_errors12 = require("telegram/errors/index.js");
+var import_errors13 = require("telegram/errors/index.js");
 function isTelegramRpcError(error) {
-  return error instanceof import_errors12.RPCError;
+  return error instanceof import_errors13.RPCError;
 }
 function isPasswordRequiredError(error) {
   return isTelegramRpcError(error) && error.errorMessage === "SESSION_PASSWORD_NEEDED";
@@ -3390,7 +3481,7 @@ var TelegramStorageProvider = class {
 };
 
 // ../telegram/src/connection.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var import_telegram3 = require("telegram");
 var import_uploads2 = require("telegram/client/uploads.js");
 var import_Password = require("telegram/Password.js");
@@ -3478,7 +3569,7 @@ var TelegramConnectionService = class {
         needsPassword: false,
         failure: null
       };
-      const flowId = (0, import_node_crypto7.randomUUID)();
+      const flowId = (0, import_node_crypto8.randomUUID)();
       const token = await this.exportQrToken(client);
       this.qrFlows.set(flowId, flow);
       this.watchQrApproval(flowId, flow);