stow-cli 2.2.0 → 2.2.3

package/README.md

@@ -31,11 +31,11 @@ stow search text 'sunset beach' -b photos
 
 Stow CLI uses environment variables for authentication:
 
-| Variable | Required | Description |
-|---|---|---|
-| `STOW_API_KEY` | Yes | Your Stow API key (get one at `app.stow.sh/dashboard/api-keys`) |
-| `STOW_API_URL` | No | Override the default API URL (`https://api.stow.sh`) |
-| `STOW_ADMIN_SECRET` | No | Required for `admin` commands only |
+| Variable            | Required | Description                                                     |
+| ------------------- | -------- | --------------------------------------------------------------- |
+| `STOW_API_KEY`      | Yes      | Your Stow API key (get one at `app.stow.sh/dashboard/api-keys`) |
+| `STOW_API_URL`      | No       | Override the default API URL (`https://api.stow.sh`)            |
+| `STOW_ADMIN_SECRET` | No       | Required for `admin` commands only                              |
 
 ## Commands
 
@@ -352,11 +352,11 @@ stow search text 'landscape' -b photos --json | jq length
 
 ## Environment Variables
 
-| Variable | Default | Description |
-|---|---|---|
-| `STOW_API_KEY` | -- | API key for authentication |
-| `STOW_API_URL` | `https://api.stow.sh` | API base URL |
-| `STOW_ADMIN_SECRET` | -- | Secret for admin commands |
+| Variable            | Default               | Description                |
+| ------------------- | --------------------- | -------------------------- |
+| `STOW_API_KEY`      | --                    | API key for authentication |
+| `STOW_API_URL`      | `https://api.stow.sh` | API base URL               |
+| `STOW_ADMIN_SECRET` | --                    | Secret for admin commands  |
 
 ## License
 

package/dist/app-ZIHTOHXL.js

@@ -0,0 +1,255 @@
+import {
+  formatBytes
+} from "./chunk-PE6V3MVP.js";
+import {
+  createStow
+} from "./chunk-5LU25QZK.js";
+import "./chunk-TOADDO2F.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 [errorMessage, setErrorMessage] = useState(null);
+  const [cursor, setCursor] = useState(0);
+  useEffect(() => {
+    async function loadBuckets() {
+      try {
+        const stow = createStow();
+        const data = await stow.listBuckets();
+        setBuckets(data.buckets.map(toBucket));
+      } catch (error) {
+        setErrorMessage(error instanceof Error ? error.message : String(error));
+      } finally {
+        setLoading(false);
+      }
+    }
+    loadBuckets();
+  }, []);
+  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 (errorMessage) {
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "Error: ",
+      errorMessage
+    ] }) });
+  }
+  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 [errorMessage, setErrorMessage] = useState2(null);
+  const [cursor, setCursor] = useState2(0);
+  const [nextCursor, setNextCursor] = useState2(null);
+  const [copied, setCopied] = useState2(false);
+  async function loadFiles(pageCursor) {
+    setLoading(true);
+    try {
+      const stow = createStow();
+      const data = await stow.listFiles({
+        bucket: bucket.name,
+        ...pageCursor ? { cursor: pageCursor } : {}
+      });
+      setFiles((prev) => pageCursor ? [...prev, ...data.files] : data.files);
+      setNextCursor(data.nextCursor);
+    } catch (error) {
+      setErrorMessage(error instanceof Error ? error.message : String(error));
+    } finally {
+      setLoading(false);
+    }
+  }
+  useEffect2(() => {
+    loadFiles();
+  }, []);
+  async function copyCurrentFileUrl() {
+    const currentFile = files[cursor];
+    if (!currentFile) {
+      return;
+    }
+    if (!currentFile.url) {
+      setErrorMessage("Selected file has no URL");
+      return;
+    }
+    const { default: clipboard } = await import("clipboardy");
+    await clipboard.write(currentFile.url);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2e3);
+  }
+  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) {
+      copyCurrentFileUrl();
+    }
+  });
+  if (errorMessage) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+        "Error: ",
+        errorMessage
+      ] }),
+      /* @__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(() => {
+    async function loadEmail() {
+      const stow = createStow();
+      try {
+        const data = await stow.whoami();
+        setEmail(data.user.email);
+      } catch {
+      }
+    }
+    loadEmail();
+  }, []);
+  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/backfill-BG65X4TP.js

@@ -0,0 +1,65 @@
+import {
+  adminRequest
+} from "./chunk-QF7PVPWQ.js";
+import {
+  output
+} from "./chunk-KPIQZBTO.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/admin/backfill.ts
+async function runBackfill(type, options) {
+  const parsedLimit = options.limit ? Number.parseInt(options.limit, 10) : null;
+  const body = {};
+  if (options.bucket) {
+    body.bucketId = options.bucket;
+  }
+  if (parsedLimit && parsedLimit > 0) {
+    body.limit = parsedLimit;
+  }
+  if (options.dryRun) {
+    body.dryRun = true;
+  }
+  const result = await adminRequest({
+    method: "POST",
+    path: `/internal/files/${type}/backfill`,
+    body
+  });
+  output(
+    result,
+    () => {
+      const lines = [];
+      if (result.dryRun) {
+        lines.push(`[dry run] ${result.remaining} files need ${type} processing`);
+        return lines.join("\n");
+      }
+      lines.push(`Enqueued: ${result.enqueued ?? 0}`);
+      lines.push(`Remaining: ${result.remaining}`);
+      if (result.errors && result.errors.length > 0) {
+        lines.push(`
+Errors (${result.errors.length}):`);
+        for (const err of result.errors) {
+          lines.push(`  ${err.fileId}: ${err.error}`);
+        }
+      }
+      if (result.nextCursor) {
+        lines.push("\n(more files available -- run again to continue)");
+      }
+      return lines.join("\n");
+    },
+    { json: options.json }
+  );
+}
+async function backfillDimensions(options) {
+  await runBackfill("dimensions", options);
+}
+async function backfillColors(options) {
+  await runBackfill("colors", options);
+}
+async function backfillEmbeddings(options) {
+  await runBackfill("embeddings", options);
+}
+export {
+  backfillColors,
+  backfillDimensions,
+  backfillEmbeddings
+};

package/dist/backfill-JCNPLFJU.js

@@ -0,0 +1,67 @@
+import {
+  adminRequest
+} from "./chunk-QF7PVPWQ.js";
+import {
+  output
+} from "./chunk-5BVMPHKH.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/admin/backfill.ts
+async function runBackfill(type, options) {
+  const parsedLimit = options.limit ? Number.parseInt(options.limit, 10) : null;
+  const body = {};
+  if (options.bucket) {
+    body.bucketId = options.bucket;
+  }
+  if (parsedLimit && parsedLimit > 0) {
+    body.limit = parsedLimit;
+  }
+  if (options.dryRun) {
+    body.dryRun = true;
+  }
+  const result = await adminRequest({
+    method: "POST",
+    path: `/internal/files/${type}/backfill`,
+    body
+  });
+  output(
+    result,
+    () => {
+      const lines = [];
+      if (result.dryRun) {
+        lines.push(
+          `[dry run] ${result.remaining} files need ${type} processing`
+        );
+        return lines.join("\n");
+      }
+      lines.push(`Enqueued: ${result.enqueued ?? 0}`);
+      lines.push(`Remaining: ${result.remaining}`);
+      if (result.errors && result.errors.length > 0) {
+        lines.push(`
+Errors (${result.errors.length}):`);
+        for (const err of result.errors) {
+          lines.push(`  ${err.fileId}: ${err.error}`);
+        }
+      }
+      if (result.nextCursor) {
+        lines.push("\n(more files available -- run again to continue)");
+      }
+      return lines.join("\n");
+    },
+    { json: options.json }
+  );
+}
+async function backfillDimensions(options) {
+  await runBackfill("dimensions", options);
+}
+async function backfillColors(options) {
+  await runBackfill("colors", options);
+}
+async function backfillEmbeddings(options) {
+  await runBackfill("embeddings", options);
+}
+export {
+  backfillColors,
+  backfillDimensions,
+  backfillEmbeddings
+};

package/dist/backfill-KW46AEAL.js

@@ -0,0 +1,67 @@
+import {
+  adminRequest
+} from "./chunk-QF7PVPWQ.js";
+import {
+  output
+} from "./chunk-RH4BOSYB.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/admin/backfill.ts
+async function runBackfill(type, options) {
+  const parsedLimit = options.limit ? Number.parseInt(options.limit, 10) : null;
+  const body = {};
+  if (options.bucket) {
+    body.bucketId = options.bucket;
+  }
+  if (parsedLimit && parsedLimit > 0) {
+    body.limit = parsedLimit;
+  }
+  if (options.dryRun) {
+    body.dryRun = true;
+  }
+  const result = await adminRequest({
+    method: "POST",
+    path: `/internal/files/${type}/backfill`,
+    body
+  });
+  output(
+    result,
+    () => {
+      const lines = [];
+      if (result.dryRun) {
+        lines.push(
+          `[dry run] ${result.remaining} files need ${type} processing`
+        );
+        return lines.join("\n");
+      }
+      lines.push(`Enqueued: ${result.enqueued ?? 0}`);
+      lines.push(`Remaining: ${result.remaining}`);
+      if (result.errors && result.errors.length > 0) {
+        lines.push(`
+Errors (${result.errors.length}):`);
+        for (const err of result.errors) {
+          lines.push(`  ${err.fileId}: ${err.error}`);
+        }
+      }
+      if (result.nextCursor) {
+        lines.push("\n(more files available -- run again to continue)");
+      }
+      return lines.join("\n");
+    },
+    { json: options.json }
+  );
+}
+async function backfillDimensions(options) {
+  await runBackfill("dimensions", options);
+}
+async function backfillColors(options) {
+  await runBackfill("colors", options);
+}
+async function backfillEmbeddings(options) {
+  await runBackfill("embeddings", options);
+}
+export {
+  backfillColors,
+  backfillDimensions,
+  backfillEmbeddings
+};

package/dist/backfill-VAORMLMY.js

@@ -0,0 +1,67 @@
+import {
+  adminRequest
+} from "./chunk-QF7PVPWQ.js";
+import {
+  output
+} from "./chunk-5IX3ASXH.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/admin/backfill.ts
+async function runBackfill(type, options) {
+  const parsedLimit = options.limit ? Number.parseInt(options.limit, 10) : null;
+  const body = {};
+  if (options.bucket) {
+    body.bucketId = options.bucket;
+  }
+  if (parsedLimit && parsedLimit > 0) {
+    body.limit = parsedLimit;
+  }
+  if (options.dryRun) {
+    body.dryRun = true;
+  }
+  const result = await adminRequest({
+    method: "POST",
+    path: `/internal/files/${type}/backfill`,
+    body
+  });
+  output(
+    result,
+    () => {
+      const lines = [];
+      if (result.dryRun) {
+        lines.push(
+          `[dry run] ${result.remaining} files need ${type} processing`
+        );
+        return lines.join("\n");
+      }
+      lines.push(`Enqueued: ${result.enqueued ?? 0}`);
+      lines.push(`Remaining: ${result.remaining}`);
+      if (result.errors && result.errors.length > 0) {
+        lines.push(`
+Errors (${result.errors.length}):`);
+        for (const err of result.errors) {
+          lines.push(`  ${err.fileId}: ${err.error}`);
+        }
+      }
+      if (result.nextCursor) {
+        lines.push("\n(more files available -- run again to continue)");
+      }
+      return lines.join("\n");
+    },
+    { json: options.json }
+  );
+}
+async function backfillDimensions(options) {
+  await runBackfill("dimensions", options);
+}
+async function backfillColors(options) {
+  await runBackfill("colors", options);
+}
+async function backfillEmbeddings(options) {
+  await runBackfill("embeddings", options);
+}
+export {
+  backfillColors,
+  backfillDimensions,
+  backfillEmbeddings
+};

package/dist/buckets-AFNX7FV3.js

@@ -0,0 +1,137 @@
+import {
+  parseJsonInput
+} from "./chunk-3BLL5SQJ.js";
+import {
+  validateBucketName
+} from "./chunk-PLZFHPLC.js";
+import {
+  isJsonOutput,
+  output
+} from "./chunk-5IX3ASXH.js";
+import {
+  formatBytes,
+  formatTable
+} from "./chunk-FZGOTXTE.js";
+import {
+  createStow
+} from "./chunk-5LU25QZK.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/buckets.ts
+async function listBuckets() {
+  const stow = createStow();
+  const data = await stow.listBuckets();
+  if (data.buckets.length === 0) {
+    if (isJsonOutput()) {
+      output(data);
+    } else {
+      console.log(
+        "No buckets yet. Create one with: stow buckets create <name>"
+      );
+    }
+    return;
+  }
+  output(data, () => {
+    const rows = data.buckets.map((b) => [
+      b.name,
+      b.isPublic ? "public" : "private",
+      b.searchable ? "yes" : "no",
+      `${b.fileCount ?? 0} files`,
+      formatBytes(b.usageBytes ?? 0),
+      b.description || ""
+    ]);
+    return formatTable(
+      ["Name", "Access", "Search", "Files", "Size", "Description"],
+      rows
+    );
+  });
+}
+async function createBucket(name, options) {
+  const input = parseJsonInput(options.inputJson, {
+    name,
+    description: options.description,
+    public: options.public
+  });
+  validateBucketName(input.name);
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "createBucket",
+          details: {
+            name: input.name,
+            description: input.description ?? null,
+            isPublic: input.public ?? false
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const stow = createStow();
+  const bucket = await stow.createBucket({
+    name: input.name,
+    ...input.description ? { description: input.description } : {},
+    ...input.public ? { isPublic: true } : {}
+  });
+  console.log(`Created bucket: ${bucket.name}`);
+}
+async function renameBucket(name, newName, options) {
+  const input = parseJsonInput(
+    options.inputJson,
+    { name, newName }
+  );
+  validateBucketName(input.name);
+  validateBucketName(input.newName);
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "renameBucket",
+          details: { name: input.name, newName: input.newName }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  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(input.name, input.newName);
+  console.log(`Renamed bucket: ${input.name} \u2192 ${bucket.name}`);
+}
+async function deleteBucket(id, options = {}) {
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "deleteBucket",
+          details: { id }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const stow = createStow();
+  await stow.deleteBucket(id);
+  console.log(`Deleted bucket: ${id}`);
+}
+export {
+  createBucket,
+  deleteBucket,
+  listBuckets,
+  renameBucket
+};