stow-cli 1.0.0 → 1.0.2

package/dist/list-DQRU6QHO.js

@@ -0,0 +1,106 @@
+import {
+  formatBytes,
+  formatTable,
+  usageBar
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiRequest
+} from "./chunk-R5CCBTXZ.js";
+import "./chunk-2AORPTQB.js";
+
+// src/commands/list.ts
+async function listBuckets() {
+  const data = await apiRequest("/api/buckets");
+  if (data.buckets.length === 0) {
+    console.log("No buckets yet. Create one with: stow buckets create <name>");
+    return;
+  }
+  const rows = data.buckets.map((b) => [
+    b.name,
+    b.isPublic ? "public" : "private",
+    `${b.fileCount} files`,
+    formatBytes(b.usageBytes),
+    b.description || ""
+  ]);
+  console.log(
+    formatTable(["Name", "Access", "Files", "Size", "Description"], rows)
+  );
+}
+async function createBucket(name, options) {
+  const body = { name };
+  if (options.description) {
+    body.description = options.description;
+  }
+  if (options.public) {
+    body.isPublic = true;
+  }
+  const data = await apiRequest("/api/buckets", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  console.log(`Created bucket: ${data.bucket.name}`);
+}
+async function renameBucket(name, newName, options) {
+  if (!options.yes) {
+    console.error(
+      "Warning: Renaming a bucket will break any existing URLs using the old name."
+    );
+    console.error("Use --yes to skip this warning.");
+  }
+  const data = await apiRequest(
+    `/api/buckets/_?bucket=${encodeURIComponent(name)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify({ name: newName })
+    }
+  );
+  console.log(`Renamed bucket: ${name} \u2192 ${data.bucket.name}`);
+}
+async function listFiles(bucket, options) {
+  const params = new URLSearchParams({ bucket });
+  if (options.search) {
+    params.set("prefix", options.search);
+  }
+  if (options.limit) {
+    params.set("limit", options.limit);
+  }
+  const data = await apiRequest(`/api/files?${params}`);
+  if (data.files.length === 0) {
+    console.log(`No files in bucket '${bucket}'.`);
+    return;
+  }
+  const rows = data.files.map((f) => [
+    f.key,
+    formatBytes(f.size),
+    f.lastModified.split("T")[0]
+  ]);
+  console.log(formatTable(["Key", "Size", "Modified"], rows));
+  if (data.nextCursor) {
+    console.log("\n(more files available \u2014 use --limit to see more)");
+  }
+}
+async function listDrops() {
+  const data = await apiRequest("/api/drops");
+  if (data.drops.length === 0) {
+    console.log("No drops yet. Create one with: stow drop <file>");
+    return;
+  }
+  const rows = data.drops.map((d) => [
+    d.filename,
+    formatBytes(Number(d.size)),
+    d.contentType,
+    d.url
+  ]);
+  console.log(formatTable(["Filename", "Size", "Type", "URL"], rows));
+  console.log(
+    `
+Storage: ${usageBar(data.usage.bytes, data.usage.limit)}  ${formatBytes(data.usage.bytes)} / ${formatBytes(data.usage.limit)}`
+  );
+}
+export {
+  createBucket,
+  listBuckets,
+  listDrops,
+  listFiles,
+  renameBucket
+};

package/dist/list-I5A6LTHX.js

@@ -0,0 +1,106 @@
+import {
+  formatBytes,
+  formatTable,
+  usageBar
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiRequest
+} from "./chunk-LYCXXF2T.js";
+import "./chunk-OZ7QQTIZ.js";
+
+// src/commands/list.ts
+async function listBuckets() {
+  const data = await apiRequest("/api/buckets");
+  if (data.buckets.length === 0) {
+    console.log("No buckets yet. Create one with: stow buckets create <name>");
+    return;
+  }
+  const rows = data.buckets.map((b) => [
+    b.name,
+    b.isPublic ? "public" : "private",
+    `${b.fileCount} files`,
+    formatBytes(b.usageBytes),
+    b.description || ""
+  ]);
+  console.log(
+    formatTable(["Name", "Access", "Files", "Size", "Description"], rows)
+  );
+}
+async function createBucket(name, options) {
+  const body = { name };
+  if (options.description) {
+    body.description = options.description;
+  }
+  if (options.public) {
+    body.isPublic = true;
+  }
+  const data = await apiRequest("/api/buckets", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  console.log(`Created bucket: ${data.bucket.name}`);
+}
+async function renameBucket(name, newName, options) {
+  if (!options.yes) {
+    console.error(
+      "Warning: Renaming a bucket will break any existing URLs using the old name."
+    );
+    console.error("Use --yes to skip this warning.");
+  }
+  const data = await apiRequest(
+    `/api/buckets/_?bucket=${encodeURIComponent(name)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify({ name: newName })
+    }
+  );
+  console.log(`Renamed bucket: ${name} \u2192 ${data.bucket.name}`);
+}
+async function listFiles(bucket, options) {
+  const params = new URLSearchParams({ bucket });
+  if (options.search) {
+    params.set("prefix", options.search);
+  }
+  if (options.limit) {
+    params.set("limit", options.limit);
+  }
+  const data = await apiRequest(`/api/files?${params}`);
+  if (data.files.length === 0) {
+    console.log(`No files in bucket '${bucket}'.`);
+    return;
+  }
+  const rows = data.files.map((f) => [
+    f.key,
+    formatBytes(f.size),
+    f.lastModified.split("T")[0]
+  ]);
+  console.log(formatTable(["Key", "Size", "Modified"], rows));
+  if (data.nextCursor) {
+    console.log("\n(more files available \u2014 use --limit to see more)");
+  }
+}
+async function listDrops() {
+  const data = await apiRequest("/api/drops");
+  if (data.drops.length === 0) {
+    console.log("No drops yet. Create one with: stow drop <file>");
+    return;
+  }
+  const rows = data.drops.map((d) => [
+    d.filename,
+    formatBytes(Number(d.size)),
+    d.contentType,
+    d.url
+  ]);
+  console.log(formatTable(["Filename", "Size", "Type", "URL"], rows));
+  console.log(
+    `
+Storage: ${usageBar(data.usage.bytes, data.usage.limit)}  ${formatBytes(data.usage.bytes)} / ${formatBytes(data.usage.limit)}`
+  );
+}
+export {
+  createBucket,
+  listBuckets,
+  listDrops,
+  listFiles,
+  renameBucket
+};

package/dist/list-Z3MPT6MI.js

@@ -0,0 +1,109 @@
+import {
+  createStow
+} from "./chunk-JYOMHKFS.js";
+import {
+  formatBytes,
+  formatTable,
+  usageBar
+} from "./chunk-ZDVARBCV.js";
+import "./chunk-OZ7QQTIZ.js";
+
+// src/commands/list.ts
+async function listBuckets() {
+  const stow = createStow();
+  const data = await stow.listBuckets();
+  if (data.buckets.length === 0) {
+    console.log("No buckets yet. Create one with: stow buckets create <name>");
+    return;
+  }
+  const rows = data.buckets.map((b) => [
+    b.name,
+    b.isPublic ? "public" : "private",
+    `${b.fileCount ?? 0} files`,
+    formatBytes(b.usageBytes ?? 0),
+    b.description || ""
+  ]);
+  console.log(
+    formatTable(["Name", "Access", "Files", "Size", "Description"], rows)
+  );
+}
+async function createBucket(name, options) {
+  const stow = createStow();
+  const bucket = await stow.createBucket({
+    name,
+    ...options.description ? { description: options.description } : {},
+    ...options.public ? { isPublic: true } : {}
+  });
+  console.log(`Created bucket: ${bucket.name}`);
+}
+async function renameBucket(name, newName, options) {
+  if (!options.yes) {
+    console.error(
+      "Warning: Renaming a bucket will break any existing URLs using the old name."
+    );
+    console.error("Use --yes to skip this warning.");
+  }
+  const stow = createStow();
+  const bucket = await stow.renameBucket(name, newName);
+  console.log(`Renamed bucket: ${name} \u2192 ${bucket.name}`);
+}
+async function listFiles(bucket, options) {
+  const stow = createStow();
+  const parsedLimit = options.limit ? Number.parseInt(options.limit, 10) : null;
+  const data = await stow.listFiles({
+    bucket,
+    ...options.search ? { prefix: options.search } : {},
+    ...parsedLimit && Number.isFinite(parsedLimit) && parsedLimit > 0 ? { limit: parsedLimit } : {}
+  });
+  if (data.files.length === 0) {
+    console.log(`No files in bucket '${bucket}'.`);
+    return;
+  }
+  const rows = data.files.map((f) => [
+    f.key,
+    formatBytes(f.size),
+    f.lastModified.split("T")[0]
+  ]);
+  console.log(formatTable(["Key", "Size", "Modified"], rows));
+  if (data.nextCursor) {
+    console.log("\n(more files available \u2014 use --limit to see more)");
+  }
+}
+async function listDrops() {
+  const stow = createStow();
+  const data = await stow.listDrops();
+  if (data.drops.length === 0) {
+    console.log("No drops yet. Create one with: stow drop <file>");
+    return;
+  }
+  const rows = data.drops.map((d) => [
+    d.filename,
+    formatBytes(Number(d.size)),
+    d.contentType,
+    d.url
+  ]);
+  console.log(formatTable(["Filename", "Size", "Type", "URL"], rows));
+  console.log(
+    `
+Storage: ${usageBar(data.usage.bytes, data.usage.limit)}  ${formatBytes(data.usage.bytes)} / ${formatBytes(data.usage.limit)}`
+  );
+}
+async function deleteBucket(id) {
+  const stow = createStow();
+  await stow.deleteBucket(id);
+  console.log(`Deleted bucket: ${id}`);
+}
+async function deleteDrop(id) {
+  const stow = createStow();
+  await stow.deleteDrop(id);
+  console.log(`Deleted drop: ${id}`);
+}
+export {
+  createBucket,
+  deleteBucket,
+  deleteDrop,
+  listBuckets,
+  listDrops,
+  listFiles,
+  renameBucket
+};

package/dist/open-2YNHG3MA.js

@@ -0,0 +1,15 @@
+import {
+  getBaseUrl
+} from "./chunk-2AORPTQB.js";
+
+// src/commands/open.ts
+async function openBucket(bucket) {
+  const baseUrl = getBaseUrl();
+  const url = `${baseUrl}/dashboard/buckets/${encodeURIComponent(bucket)}`;
+  const { default: open } = await import("open");
+  await open(url);
+  console.log(`Opened: ${url}`);
+}
+export {
+  openBucket
+};

package/dist/upload-3NS5O3UL.js

@@ -0,0 +1,120 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  apiRequest,
+  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 presign = await apiRequest("/api/drops/presign", {
+    method: "POST",
+    body: JSON.stringify({
+      filename,
+      contentType,
+      size: buffer.length
+    })
+  });
+  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,
+      r2Key: presign.r2Key,
+      size: buffer.length,
+      contentType,
+      filename,
+      ...presign.uploadToken ? { uploadToken: presign.uploadToken } : {}
+    })
+  });
+  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-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-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
+};