stow-cli 1.0.3 → 2.0.1

package/dist/upload-B2PGW3AN.js

@@ -0,0 +1,125 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiRequest,
+  apiUpload
+} from "./chunk-FEMMZ4YZ.js";
+import "./chunk-2AORPTQB.js";
+
+// src/commands/upload.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { basename, resolve } from "path";
+var CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  txt: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript"
+};
+function getContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  return CONTENT_TYPES[ext || ""] || "application/octet-stream";
+}
+function readFile(filePath) {
+  const resolvedPath = resolve(filePath);
+  if (!existsSync(resolvedPath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const buffer = readFileSync(resolvedPath);
+  const filename = basename(resolvedPath);
+  const contentType = getContentType(filename);
+  return { buffer, filename, contentType };
+}
+async function uploadDrop(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const contentHash = createHash("sha256").update(buffer).digest("hex");
+  const presign = await apiRequest("/api/drops/presign", {
+    method: "POST",
+    body: JSON.stringify({
+      filename,
+      contentType,
+      contentHash,
+      size: buffer.length
+    })
+  });
+  if (!presign.isDuplicate && presign.uploadUrl) {
+    const putRes = await fetch(presign.uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body: new Uint8Array(buffer)
+    });
+    if (!putRes.ok) {
+      throw new Error(`Upload to storage failed (${putRes.status})`);
+    }
+  }
+  const result = await apiRequest("/api/drops/presign/confirm", {
+    method: "POST",
+    body: JSON.stringify({
+      shortId: presign.shortId,
+      contentHash,
+      size: buffer.length,
+      contentType,
+      filename,
+      contentBlobId: presign.contentBlobId
+    })
+  });
+  if (options.quiet) {
+    console.log(result.url);
+  } else {
+    console.error("Done!");
+    console.log("");
+    console.log(result.url);
+  }
+}
+async function uploadFile(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  let path = "/api/upload";
+  if (options.bucket) {
+    path += `?bucket=${encodeURIComponent(options.bucket)}`;
+  }
+  const result = await apiUpload(
+    path,
+    buffer,
+    filename,
+    contentType
+  );
+  if (options.quiet) {
+    console.log(result.url);
+  } else {
+    console.error("Done!");
+    console.log("");
+    console.log(result.url);
+  }
+}
+export {
+  uploadDrop,
+  uploadFile
+};

package/dist/{upload-ESYKBYHA.js → upload-DQDBDIDI.js}

@@ -1,6 +1,6 @@
 import {
   formatBytes
-} from "./chunk-ELSDWMEB.js";
+} from "./chunk-ZDVARBCV.js";
 import {
   createStow
 } from "./chunk-JYOMHKFS.js";

package/dist/upload-FGNGNPC3.js

@@ -0,0 +1,93 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiUpload
+} from "./chunk-FEMMZ4YZ.js";
+import "./chunk-2AORPTQB.js";
+
+// src/commands/upload.ts
+import { existsSync, readFileSync } from "fs";
+import { basename, resolve } from "path";
+var CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  txt: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript"
+};
+function getContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  return CONTENT_TYPES[ext || ""] || "application/octet-stream";
+}
+function readFile(filePath) {
+  const resolvedPath = resolve(filePath);
+  if (!existsSync(resolvedPath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const buffer = readFileSync(resolvedPath);
+  const filename = basename(resolvedPath);
+  const contentType = getContentType(filename);
+  return { buffer, filename, contentType };
+}
+async function uploadDrop(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const result = await apiUpload("/api/drops/upload", buffer, filename, contentType);
+  if (options.quiet) {
+    console.log(result.url);
+  } else {
+    console.error("Done!");
+    console.log("");
+    console.log(result.url);
+  }
+}
+async function uploadFile(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  let path = "/api/upload";
+  if (options.bucket) {
+    path += `?bucket=${encodeURIComponent(options.bucket)}`;
+  }
+  const result = await apiUpload(
+    path,
+    buffer,
+    filename,
+    contentType
+  );
+  if (options.quiet) {
+    console.log(result.url);
+  } else {
+    console.error("Done!");
+    console.log("");
+    console.log(result.url);
+  }
+}
+export {
+  uploadDrop,
+  uploadFile
+};

package/dist/upload-HKUPWTK2.js

@@ -0,0 +1,173 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiRequest
+} from "./chunk-LYCXXF2T.js";
+import "./chunk-OZ7QQTIZ.js";
+
+// src/commands/upload.ts
+import { existsSync, readFileSync } from "fs";
+import { createHash } from "crypto";
+import { basename, resolve } from "path";
+var CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  txt: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript"
+};
+function getContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  return CONTENT_TYPES[ext || ""] || "application/octet-stream";
+}
+function readFile(filePath) {
+  const resolvedPath = resolve(filePath);
+  if (!existsSync(resolvedPath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const buffer = readFileSync(resolvedPath);
+  const filename = basename(resolvedPath);
+  const contentType = getContentType(filename);
+  return { buffer, filename, contentType };
+}
+async function uploadToPresignedUrl(uploadUrl, contentType, buffer) {
+  const putRes = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "Content-Type": contentType },
+    body: new Uint8Array(buffer)
+  });
+  if (!putRes.ok) {
+    throw new Error(`Upload to storage failed (${putRes.status})`);
+  }
+}
+async function runUploadPipeline(options) {
+  const presign = await apiRequest(options.presignPath, {
+    method: "POST",
+    body: JSON.stringify(options.presignBody)
+  });
+  const resolved = options.resolvePresign(presign);
+  if ("dedupedUrl" in resolved) {
+    return { url: resolved.dedupedUrl, deduped: true };
+  }
+  await uploadToPresignedUrl(
+    resolved.uploadUrl,
+    options.contentType,
+    options.buffer
+  );
+  const confirm = await apiRequest(resolved.confirmPath, {
+    method: "POST",
+    body: JSON.stringify(resolved.confirmBody)
+  });
+  return { url: options.getResultUrl(confirm), deduped: false };
+}
+function printUploadResult(url, options, opts) {
+  if (options.quiet) {
+    console.log(url);
+    return;
+  }
+  console.error(opts?.deduped ? "Done! (deduped)" : "Done!");
+  console.log("");
+  console.log(url);
+}
+function withBucket(path, bucket) {
+  if (!bucket) {
+    return path;
+  }
+  const joiner = path.includes("?") ? "&" : "?";
+  return `${path}${joiner}bucket=${encodeURIComponent(bucket)}`;
+}
+async function uploadDrop(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const result = await runUploadPipeline({
+    presignPath: "/api/drops/presign",
+    presignBody: {
+      filename,
+      contentType,
+      size: buffer.length
+    },
+    contentType,
+    buffer,
+    resolvePresign: (presign) => ({
+      uploadUrl: presign.uploadUrl,
+      confirmPath: presign.confirmUrl || "/api/drops/presign/confirm",
+      confirmBody: {
+        shortId: presign.shortId,
+        r2Key: presign.r2Key,
+        size: buffer.length,
+        contentType,
+        filename,
+        ...presign.uploadToken ? { uploadToken: presign.uploadToken } : {}
+      }
+    }),
+    getResultUrl: (confirm) => confirm.url
+  });
+  printUploadResult(result.url, options, { deduped: result.deduped });
+}
+async function uploadFile(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const contentHash = createHash("sha256").update(buffer).digest("hex");
+  const result = await runUploadPipeline({
+    presignPath: withBucket("/api/presign", options.bucket),
+    presignBody: {
+      filename,
+      contentType,
+      size: buffer.length,
+      contentHash
+    },
+    contentType,
+    buffer,
+    resolvePresign: (presign) => {
+      if ("dedupe" in presign && presign.dedupe) {
+        return { dedupedUrl: presign.url };
+      }
+      return {
+        uploadUrl: presign.uploadUrl,
+        confirmPath: withBucket(
+          presign.confirmUrl || "/api/presign/confirm",
+          options.bucket
+        ),
+        confirmBody: {
+          fileKey: presign.fileKey,
+          size: buffer.length,
+          contentType,
+          filename,
+          contentHash,
+          skipVerify: true
+        }
+      };
+    },
+    getResultUrl: (confirm) => confirm.url
+  });
+  printUploadResult(result.url, options, { deduped: result.deduped });
+}
+export {
+  uploadDrop,
+  uploadFile
+};

package/dist/upload-JDVSJVWK.js

@@ -0,0 +1,173 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiRequest
+} from "./chunk-R5CCBTXZ.js";
+import "./chunk-2AORPTQB.js";
+
+// src/commands/upload.ts
+import { existsSync, readFileSync } from "fs";
+import { createHash } from "crypto";
+import { basename, resolve } from "path";
+var CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  txt: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript"
+};
+function getContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  return CONTENT_TYPES[ext || ""] || "application/octet-stream";
+}
+function readFile(filePath) {
+  const resolvedPath = resolve(filePath);
+  if (!existsSync(resolvedPath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const buffer = readFileSync(resolvedPath);
+  const filename = basename(resolvedPath);
+  const contentType = getContentType(filename);
+  return { buffer, filename, contentType };
+}
+async function uploadToPresignedUrl(uploadUrl, contentType, buffer) {
+  const putRes = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "Content-Type": contentType },
+    body: new Uint8Array(buffer)
+  });
+  if (!putRes.ok) {
+    throw new Error(`Upload to storage failed (${putRes.status})`);
+  }
+}
+async function runUploadPipeline(options) {
+  const presign = await apiRequest(options.presignPath, {
+    method: "POST",
+    body: JSON.stringify(options.presignBody)
+  });
+  const resolved = options.resolvePresign(presign);
+  if ("dedupedUrl" in resolved) {
+    return { url: resolved.dedupedUrl, deduped: true };
+  }
+  await uploadToPresignedUrl(
+    resolved.uploadUrl,
+    options.contentType,
+    options.buffer
+  );
+  const confirm = await apiRequest(resolved.confirmPath, {
+    method: "POST",
+    body: JSON.stringify(resolved.confirmBody)
+  });
+  return { url: options.getResultUrl(confirm), deduped: false };
+}
+function printUploadResult(url, options, opts) {
+  if (options.quiet) {
+    console.log(url);
+    return;
+  }
+  console.error(opts?.deduped ? "Done! (deduped)" : "Done!");
+  console.log("");
+  console.log(url);
+}
+function withBucket(path, bucket) {
+  if (!bucket) {
+    return path;
+  }
+  const joiner = path.includes("?") ? "&" : "?";
+  return `${path}${joiner}bucket=${encodeURIComponent(bucket)}`;
+}
+async function uploadDrop(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const result = await runUploadPipeline({
+    presignPath: "/api/drops/presign",
+    presignBody: {
+      filename,
+      contentType,
+      size: buffer.length
+    },
+    contentType,
+    buffer,
+    resolvePresign: (presign) => ({
+      uploadUrl: presign.uploadUrl,
+      confirmPath: presign.confirmUrl || "/api/drops/presign/confirm",
+      confirmBody: {
+        shortId: presign.shortId,
+        r2Key: presign.r2Key,
+        size: buffer.length,
+        contentType,
+        filename,
+        ...presign.uploadToken ? { uploadToken: presign.uploadToken } : {}
+      }
+    }),
+    getResultUrl: (confirm) => confirm.url
+  });
+  printUploadResult(result.url, options, { deduped: result.deduped });
+}
+async function uploadFile(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const contentHash = createHash("sha256").update(buffer).digest("hex");
+  const result = await runUploadPipeline({
+    presignPath: withBucket("/api/presign", options.bucket),
+    presignBody: {
+      filename,
+      contentType,
+      size: buffer.length,
+      contentHash
+    },
+    contentType,
+    buffer,
+    resolvePresign: (presign) => {
+      if ("dedupe" in presign && presign.dedupe) {
+        return { dedupedUrl: presign.url };
+      }
+      return {
+        uploadUrl: presign.uploadUrl,
+        confirmPath: withBucket(
+          presign.confirmUrl || "/api/presign/confirm",
+          options.bucket
+        ),
+        confirmBody: {
+          fileKey: presign.fileKey,
+          size: buffer.length,
+          contentType,
+          filename,
+          contentHash,
+          skipVerify: true
+        }
+      };
+    },
+    getResultUrl: (confirm) => confirm.url
+  });
+  printUploadResult(result.url, options, { deduped: result.deduped });
+}
+export {
+  uploadDrop,
+  uploadFile
+};

package/dist/upload-K4H7ZVRW.js

@@ -0,0 +1,98 @@
+import {
+  formatBytes
+} from "./chunk-MHRMBH4Y.js";
+import {
+  apiUpload
+} from "./chunk-YRHPOFJT.js";
+import "./chunk-2AORPTQB.js";
+
+// src/commands/upload.ts
+import { readFileSync, existsSync } from "fs";
+import { basename, resolve } from "path";
+var CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  txt: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript"
+};
+function getContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  return CONTENT_TYPES[ext || ""] || "application/octet-stream";
+}
+function readFile(filePath) {
+  const resolvedPath = resolve(filePath);
+  if (!existsSync(resolvedPath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const buffer = readFileSync(resolvedPath);
+  const filename = basename(resolvedPath);
+  const contentType = getContentType(filename);
+  return { buffer, filename, contentType };
+}
+async function uploadDrop(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const result = await apiUpload(
+    "/api/drops/upload",
+    buffer,
+    filename,
+    contentType
+  );
+  if (options.quiet) {
+    console.log(result.url);
+  } else {
+    console.error("Done!");
+    console.log("");
+    console.log(result.url);
+  }
+}
+async function uploadFile(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  let path = "/api/upload";
+  if (options.bucket) {
+    path += `?bucket=${encodeURIComponent(options.bucket)}`;
+  }
+  const result = await apiUpload(
+    path,
+    buffer,
+    filename,
+    contentType
+  );
+  if (options.quiet) {
+    console.log(result.url);
+  } else {
+    console.error("Done!");
+    console.log("");
+    console.log(result.url);
+  }
+}
+export {
+  uploadDrop,
+  uploadFile
+};