stow-cli 1.0.0

package/dist/app-2A2CFVBC.js

@@ -0,0 +1,249 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  createStow
+} from "./chunk-JYOMHKFS.js";
+import "./chunk-OZ7QQTIZ.js";
+
+// src/interactive/app.tsx
+import { render } from "ink";
+import { useEffect as useEffect3, useState as useState3 } from "react";
+
+// src/interactive/components/bucket-list.tsx
+import { Box as Box3, Text as Text3, useApp, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { useEffect, useState } from "react";
+
+// src/interactive/components/header.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ path, email, size }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", width: "100%", children: [
+      /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+        "STOW",
+        path ? ` > ${path}` : ""
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: size || email || "" })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(50) })
+  ] });
+}
+
+// src/interactive/components/status-bar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function StatusBar({ hints }) {
+  return /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: hints.map((h, i) => /* @__PURE__ */ jsx2(Box2, { marginRight: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    "[",
+    h.key,
+    "]",
+    h.label,
+    i < hints.length - 1 ? "" : ""
+  ] }) }, h.key)) });
+}
+
+// src/interactive/components/bucket-list.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function toBucket(result) {
+  return {
+    id: result.id,
+    name: result.name,
+    description: result.description ?? null,
+    fileCount: result.fileCount ?? 0,
+    isPublic: result.isPublic ?? false,
+    usageBytes: result.usageBytes ?? 0
+  };
+}
+function BucketList({ onSelect, email }) {
+  const { exit } = useApp();
+  const [buckets, setBuckets] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [cursor, setCursor] = useState(0);
+  useEffect(() => {
+    const stow = createStow();
+    stow.listBuckets().then((data) => {
+      setBuckets(data.buckets.map(toBucket));
+      setLoading(false);
+    }).catch((err) => {
+      setError(err instanceof Error ? err.message : String(err));
+      setLoading(false);
+    });
+  }, []);
+  useInput((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+    } else if (key.downArrow) {
+      setCursor((c) => Math.min(buckets.length - 1, c + 1));
+    } else if (key.return && buckets.length > 0) {
+      onSelect(buckets[cursor]);
+    }
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Spinner, { type: "dots" }),
+      " Loading buckets..."
+    ] }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Header, { email }),
+    buckets.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "No buckets yet. Press 'n' to create one." }) : buckets.map((b, i) => /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: i === cursor ? "cyan" : void 0, children: [
+      i === cursor ? "\u25B8 " : "  ",
+      b.name.padEnd(20),
+      `${b.fileCount} files`.padEnd(14),
+      formatBytes(b.usageBytes)
+    ] }) }, b.id)),
+    /* @__PURE__ */ jsx3(
+      StatusBar,
+      {
+        hints: [
+          { key: "\u2191\u2193", label: "navigate" },
+          { key: "\u21B5", label: "open" },
+          { key: "q", label: "uit" }
+        ]
+      }
+    )
+  ] });
+}
+
+// src/interactive/components/file-list.tsx
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import Spinner2 from "ink-spinner";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function FileList({ bucket, onBack }) {
+  const [files, setFiles] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [cursor, setCursor] = useState2(0);
+  const [nextCursor, setNextCursor] = useState2(null);
+  const [copied, setCopied] = useState2(false);
+  useEffect2(() => {
+    loadFiles();
+  }, []);
+  function loadFiles(pageCursor) {
+    setLoading(true);
+    const stow = createStow();
+    stow.listFiles({
+      bucket: bucket.name,
+      ...pageCursor ? { cursor: pageCursor } : {}
+    }).then((data) => {
+      setFiles(
+        (prev) => pageCursor ? [...prev, ...data.files] : data.files
+      );
+      setNextCursor(data.nextCursor);
+      setLoading(false);
+    }).catch((err) => {
+      setError(err instanceof Error ? err.message : String(err));
+      setLoading(false);
+    });
+  }
+  useInput2((input, key) => {
+    if (key.escape || key.backspace || key.leftArrow && !loading) {
+      onBack();
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+    } else if (key.downArrow) {
+      setCursor((c) => {
+        const next = Math.min(files.length - 1, c + 1);
+        if (next >= files.length - 3 && nextCursor && !loading) {
+          loadFiles(nextCursor);
+        }
+        return next;
+      });
+    } else if (input === "c" && files.length > 0) {
+      import("clipboardy").then(({ default: clipboard }) => {
+        clipboard.write(files[cursor].url).then(() => {
+          setCopied(true);
+          setTimeout(() => setCopied(false), 2e3);
+        });
+      });
+    }
+  });
+  if (error) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+        "Error: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press Esc to go back." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Header, { path: bucket.name, size: formatBytes(bucket.usageBytes) }),
+    loading && files.length === 0 && /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Spinner2, { type: "dots" }),
+      " Loading files..."
+    ] }),
+    !loading && files.length === 0 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "No files in this bucket." }),
+    files.length > 0 && files.map((f, i) => /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: i === cursor ? "cyan" : void 0, children: [
+      i === cursor ? "\u25B8 " : "  ",
+      f.key.padEnd(28),
+      formatBytes(f.size).padEnd(10),
+      f.lastModified.split("T")[0]
+    ] }) }, f.key)),
+    loading && files.length > 0 && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      /* @__PURE__ */ jsx4(Spinner2, { type: "dots" }),
+      " Loading more..."
+    ] }),
+    copied && /* @__PURE__ */ jsx4(Text4, { color: "green", children: "Copied URL to clipboard!" }),
+    /* @__PURE__ */ jsx4(
+      StatusBar,
+      {
+        hints: [
+          { key: "\u2191\u2193", label: "navigate" },
+          { key: "c", label: "opy url" },
+          { key: "\u2190", label: "back" }
+        ]
+      }
+    )
+  ] });
+}
+
+// src/interactive/app.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function App() {
+  const [screen, setScreen] = useState3({ type: "buckets" });
+  const [email, setEmail] = useState3();
+  useEffect3(() => {
+    const stow = createStow();
+    stow.whoami().then((data) => setEmail(data.user.email)).catch(() => {
+    });
+  }, []);
+  if (screen.type === "files") {
+    return /* @__PURE__ */ jsx5(
+      FileList,
+      {
+        bucket: screen.bucket,
+        onBack: () => setScreen({ type: "buckets" })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx5(
+    BucketList,
+    {
+      email,
+      onSelect: (bucket) => setScreen({ type: "files", bucket })
+    }
+  );
+}
+function startInteractive() {
+  render(/* @__PURE__ */ jsx5(App, {}));
+}
+export {
+  startInteractive
+};

package/dist/chunk-JYOMHKFS.js

@@ -0,0 +1,17 @@
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-OZ7QQTIZ.js";
+
+// src/lib/stow.ts
+import { StowServer } from "@howells/stow-server";
+function createStow() {
+  return new StowServer({
+    apiKey: getApiKey(),
+    baseUrl: getBaseUrl()
+  });
+}
+
+export {
+  createStow
+};

package/dist/chunk-OZ7QQTIZ.js

@@ -0,0 +1,23 @@
+// src/lib/config.ts
+var DEFAULT_BASE_URL = "https://app.stow.sh";
+function getApiKey() {
+  const key = process.env.STOW_API_KEY;
+  if (!key) {
+    console.error("Error: STOW_API_KEY environment variable not set");
+    console.error("");
+    console.error("Set your API key:");
+    console.error("  export STOW_API_KEY=stow_...");
+    console.error("");
+    console.error("Get an API key at https://stow.sh/dashboard/api-keys");
+    process.exit(1);
+  }
+  return key;
+}
+function getBaseUrl() {
+  return process.env.STOW_API_URL || DEFAULT_BASE_URL;
+}
+
+export {
+  getApiKey,
+  getBaseUrl
+};

package/dist/chunk-ZDVARBCV.js

@@ -0,0 +1,43 @@
+// src/lib/format.ts
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / 1024 ** i).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+function formatTable(headers, rows) {
+  if (rows.length === 0) {
+    return "";
+  }
+  const widths = headers.map((h, i) => {
+    const dataMax = rows.reduce(
+      (max, row) => Math.max(max, (row[i] || "").length),
+      0
+    );
+    return Math.max(h.length, dataMax);
+  });
+  const pad = (str, width) => str.padEnd(width);
+  const sep = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+  const lines = [];
+  lines.push(headers.map((h, i) => pad(h, widths[i])).join("  "));
+  lines.push(sep);
+  for (const row of rows) {
+    lines.push(row.map((cell, i) => pad(cell || "", widths[i])).join("  "));
+  }
+  return lines.join("\n");
+}
+function usageBar(used, total, width = 20) {
+  const ratio = Math.min(used / total, 1);
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  const pct = Math.round(ratio * 100);
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}] ${pct}%`;
+}
+
+export {
+  formatBytes,
+  formatTable,
+  usageBar
+};

package/dist/cli.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { StowError } from "@howells/stow-server";
+import { Command } from "commander";
+
+// src/lib/cli-docs.ts
+var CLI_DOCS = {
+  root: {
+    description: "CLI for Stow file storage",
+    usage: "stow [command] [options]",
+    examples: [
+      "stow whoami",
+      "stow upload ./photo.jpg --bucket photos",
+      "stow drop ./screenshot.png",
+      "stow buckets",
+      "stow files photos --limit 50"
+    ],
+    notes: [
+      "Set STOW_API_KEY before running commands that call the API.",
+      "Set STOW_API_URL to target a non-default environment."
+    ]
+  },
+  drop: {
+    description: "Upload a file and get a short URL (quick share)",
+    usage: "stow drop <file> [options]",
+    examples: ["stow drop ./video.mp4", "stow drop ./notes.txt --quiet"]
+  },
+  upload: {
+    description: "Upload a file to a bucket",
+    usage: "stow upload <file> [options]",
+    examples: [
+      "stow upload ./logo.png --bucket brand-assets",
+      "stow upload ./clip.mov --quiet"
+    ]
+  },
+  buckets: {
+    description: "List your buckets",
+    usage: "stow buckets",
+    examples: ["stow buckets"]
+  },
+  bucketsCreate: {
+    description: "Create a new bucket",
+    usage: "stow buckets create <name> [options]",
+    examples: [
+      "stow buckets create photos",
+      'stow buckets create docs --description "Product docs"',
+      "stow buckets create public-media --public"
+    ]
+  },
+  bucketsRename: {
+    description: "Rename a bucket",
+    usage: "stow buckets rename <name> <new-name> [options]",
+    examples: ["stow buckets rename old-name new-name --yes"],
+    notes: ["Renaming a bucket can break existing public URLs."]
+  },
+  bucketsDelete: {
+    description: "Delete a bucket by ID",
+    usage: "stow buckets delete <id>",
+    examples: ["stow buckets delete 8f3d1ab4-..."]
+  },
+  files: {
+    description: "List files in a bucket",
+    usage: "stow files <bucket> [options]",
+    examples: [
+      "stow files photos",
+      "stow files photos --search avatars/ --limit 100"
+    ]
+  },
+  drops: {
+    description: "List your drops with usage info",
+    usage: "stow drops",
+    examples: ["stow drops"]
+  },
+  dropsDelete: {
+    description: "Delete a drop by ID",
+    usage: "stow drops delete <id>",
+    examples: ["stow drops delete drop_abc123"]
+  },
+  delete: {
+    description: "Delete a file from a bucket",
+    usage: "stow delete <bucket> <key>",
+    examples: ["stow delete photos hero/banner.png"]
+  },
+  whoami: {
+    description: "Show account info, usage stats, and API key details",
+    usage: "stow whoami",
+    examples: ["stow whoami"]
+  },
+  open: {
+    description: "Open a bucket in the browser",
+    usage: "stow open <bucket>",
+    examples: ["stow open photos"]
+  },
+  interactive: {
+    description: "Launch interactive TUI mode",
+    usage: "stow --interactive",
+    examples: ["stow", "stow --interactive"]
+  }
+};
+function renderCommandHelp(key) {
+  const doc = CLI_DOCS[key];
+  const lines = [
+    "",
+    `Usage: ${doc.usage}`,
+    "",
+    "Examples:",
+    ...doc.examples.map((example) => `  ${example}`)
+  ];
+  if (doc.notes?.length) {
+    lines.push("", "Notes:", ...doc.notes.map((note) => `  ${note}`));
+  }
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var VERSION = "1.0.0";
+function handleError(err) {
+  if (err instanceof StowError) {
+    console.error(`Error: ${err.message}`);
+  } else if (err instanceof Error) {
+    console.error(`Error: ${err.message}`);
+  } else {
+    console.error(`Error: ${err}`);
+  }
+  process.exit(1);
+}
+var program = new Command();
+program.name("stow").description(CLI_DOCS.root.description).version(VERSION).addHelpText("after", renderCommandHelp("root"));
+program.command("drop").description(CLI_DOCS.drop.description).argument("<file>", "File to upload").option("-q, --quiet", "Only output the URL").addHelpText("after", renderCommandHelp("drop")).action(async (file, options) => {
+  try {
+    const { uploadDrop } = await import("./upload-DQDBDIDI.js");
+    await uploadDrop(file, options);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("upload").description(CLI_DOCS.upload.description).argument("<file>", "File to upload").option("-b, --bucket <name>", "Bucket name or ID").option("-q, --quiet", "Only output the URL").addHelpText("after", renderCommandHelp("upload")).action(
+  async (file, options) => {
+    try {
+      const { uploadFile } = await import("./upload-DQDBDIDI.js");
+      await uploadFile(file, options);
+    } catch (err) {
+      handleError(err);
+    }
+  }
+);
+var bucketsCmd = program.command("buckets").description(CLI_DOCS.buckets.description).addHelpText("after", renderCommandHelp("buckets")).action(async () => {
+  try {
+    const { listBuckets } = await import("./list-KEQPJY7I.js");
+    await listBuckets();
+  } catch (err) {
+    handleError(err);
+  }
+});
+bucketsCmd.command("create").description(CLI_DOCS.bucketsCreate.description).argument("<name>", "Bucket name").option("-d, --description <text>", "Bucket description").option("--public", "Make bucket public").addHelpText("after", renderCommandHelp("bucketsCreate")).action(
+  async (name, options) => {
+    try {
+      const { createBucket } = await import("./list-KEQPJY7I.js");
+      await createBucket(name, options);
+    } catch (err) {
+      handleError(err);
+    }
+  }
+);
+bucketsCmd.command("rename").description(CLI_DOCS.bucketsRename.description).argument("<name>", "Current bucket name").argument("<new-name>", "New bucket name").option("-y, --yes", "Skip confirmation warning").addHelpText("after", renderCommandHelp("bucketsRename")).action(async (name, newName, options) => {
+  try {
+    const { renameBucket } = await import("./list-KEQPJY7I.js");
+    await renameBucket(name, newName, options);
+  } catch (err) {
+    handleError(err);
+  }
+});
+bucketsCmd.command("delete").description(CLI_DOCS.bucketsDelete.description).argument("<id>", "Bucket ID").addHelpText("after", renderCommandHelp("bucketsDelete")).action(async (id) => {
+  try {
+    const { deleteBucket } = await import("./list-KEQPJY7I.js");
+    await deleteBucket(id);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("files").description(CLI_DOCS.files.description).argument("<bucket>", "Bucket name").option("-s, --search <prefix>", "Filter by prefix").option("-l, --limit <count>", "Max files to return").addHelpText("after", renderCommandHelp("files")).action(
+  async (bucket, options) => {
+    try {
+      const { listFiles } = await import("./list-KEQPJY7I.js");
+      await listFiles(bucket, options);
+    } catch (err) {
+      handleError(err);
+    }
+  }
+);
+var dropsCmd = program.command("drops").description(CLI_DOCS.drops.description).addHelpText("after", renderCommandHelp("drops")).action(async () => {
+  try {
+    const { listDrops } = await import("./list-KEQPJY7I.js");
+    await listDrops();
+  } catch (err) {
+    handleError(err);
+  }
+});
+dropsCmd.command("delete").description(CLI_DOCS.dropsDelete.description).argument("<id>", "Drop ID").addHelpText("after", renderCommandHelp("dropsDelete")).action(async (id) => {
+  try {
+    const { deleteDrop } = await import("./list-KEQPJY7I.js");
+    await deleteDrop(id);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("delete").description(CLI_DOCS.delete.description).argument("<bucket>", "Bucket name").argument("<key>", "File key").addHelpText("after", renderCommandHelp("delete")).action(async (bucket, key) => {
+  try {
+    const { deleteFile } = await import("./delete-NAV6P5O5.js");
+    await deleteFile(bucket, key);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("whoami").description(CLI_DOCS.whoami.description).addHelpText("after", renderCommandHelp("whoami")).action(async () => {
+  try {
+    const { whoami } = await import("./whoami-754O5IML.js");
+    await whoami();
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("open").description(CLI_DOCS.open.description).argument("<bucket>", "Bucket name").addHelpText("after", renderCommandHelp("open")).action(async (bucket) => {
+  try {
+    const { openBucket } = await import("./open-F3LHXI3R.js");
+    await openBucket(bucket);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.option("-i, --interactive", CLI_DOCS.interactive.description).addHelpText("after", renderCommandHelp("interactive"));
+program.parse();
+var opts = program.opts();
+var args = process.argv.slice(2);
+if (args.length === 0 || args.length === 1 && opts.interactive) {
+  import("./app-2A2CFVBC.js").then(({ startInteractive }) => startInteractive()).catch(handleError);
+}

package/dist/delete-NAV6P5O5.js

@@ -0,0 +1,14 @@
+import {
+  createStow
+} from "./chunk-JYOMHKFS.js";
+import "./chunk-OZ7QQTIZ.js";
+
+// src/commands/delete.ts
+async function deleteFile(bucket, key) {
+  const stow = createStow();
+  await stow.deleteFile(key, { bucket });
+  console.log(`Deleted: ${key} from ${bucket}`);
+}
+export {
+  deleteFile
+};

package/dist/list-KEQPJY7I.js

@@ -0,0 +1,109 @@
+import {
+  formatBytes,
+  formatTable,
+  usageBar
+} from "./chunk-ZDVARBCV.js";
+import {
+  createStow
+} from "./chunk-JYOMHKFS.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-F3LHXI3R.js

@@ -0,0 +1,15 @@
+import {
+  getBaseUrl
+} from "./chunk-OZ7QQTIZ.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-DQDBDIDI.js

@@ -0,0 +1,92 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  createStow
+} from "./chunk-JYOMHKFS.js";
+import "./chunk-OZ7QQTIZ.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 };
+}
+function printUploadResult(url, options, opts) {
+  if (options.quiet) {
+    console.log(url);
+    return;
+  }
+  console.error(opts?.deduped ? "Done! (deduped)" : "Done!");
+  console.log("");
+  console.log(url);
+}
+async function uploadDrop(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const stow = createStow();
+  const result = await stow.drop(buffer, {
+    filename,
+    contentType
+  });
+  printUploadResult(result.url, options);
+}
+async function uploadFile(filePath, options) {
+  const { buffer, filename, contentType } = readFile(filePath);
+  if (!options.quiet) {
+    console.error(`Uploading ${filename} (${formatBytes(buffer.length)})...`);
+  }
+  const stow = createStow();
+  const result = await stow.uploadFile(buffer, {
+    ...options.bucket ? { bucket: options.bucket } : {},
+    filename,
+    contentType
+  });
+  printUploadResult(result.url ?? result.key, options, {
+    deduped: result.deduped
+  });
+}
+export {
+  uploadDrop,
+  uploadFile
+};

package/dist/whoami-754O5IML.js

@@ -0,0 +1,28 @@
+import {
+  formatBytes
+} from "./chunk-ZDVARBCV.js";
+import {
+  createStow
+} from "./chunk-JYOMHKFS.js";
+import "./chunk-OZ7QQTIZ.js";
+
+// src/commands/whoami.ts
+async function whoami() {
+  const stow = createStow();
+  const data = await stow.whoami();
+  console.log(`Account: ${data.user.email}`);
+  console.log("");
+  console.log(`Buckets:  ${data.stats.bucketCount}`);
+  console.log(`Files:    ${data.stats.totalFiles}`);
+  console.log(`Storage:  ${formatBytes(data.stats.totalBytes)}`);
+  if (data.key) {
+    console.log("");
+    console.log(`API Key:  ${data.key.name}`);
+    console.log(`Scope:    ${data.key.scope}`);
+    const perms = Object.entries(data.key.permissions).filter(([, v]) => v).map(([k]) => k);
+    console.log(`Perms:    ${perms.join(", ")}`);
+  }
+}
+export {
+  whoami
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "stow-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "CLI for Stow file storage",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/howells/stow.git",
+    "directory": "packages/stow-cli"
+  },
+  "homepage": "https://stow.sh",
+  "keywords": [
+    "stow",
+    "file-storage",
+    "cli",
+    "upload"
+  ],
+  "bin": {
+    "stow": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --shims",
+    "dev": "tsup src/cli.ts --format esm --shims --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@howells/stow-server": "workspace:*",
+    "clipboardy": "^5.3.0",
+    "commander": "^14.0.3",
+    "ink": "^6.8.0",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "open": "^11.0.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@stow/typescript-config": "workspace:*",
+    "@types/node": "^25.3.0",
+    "@types/react": "19.2.14",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}