stow-cli 2.1.0 → 2.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/app-Q6EW7VSM.js

@@ -0,0 +1,249 @@
+import {
+  formatBytes
+} from "./chunk-FZGOTXTE.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 [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/backfill-EVZT7RH6.js

@@ -0,0 +1,67 @@
+import {
+  adminRequest
+} from "./chunk-QF7PVPWQ.js";
+import {
+  output
+} from "./chunk-P2BKGBQE.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-ZHP3LBLC.js

@@ -0,0 +1,137 @@
+import {
+  parseJsonInput
+} from "./chunk-3BLL5SQJ.js";
+import {
+  validateBucketName
+} from "./chunk-PLZFHPLC.js";
+import {
+  isJsonOutput,
+  output
+} from "./chunk-P2BKGBQE.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
+};

package/dist/chunk-3BLL5SQJ.js

@@ -0,0 +1,27 @@
+// src/lib/parse-json-input.ts
+function parseJsonInput(jsonStr, flagValues) {
+  if (!jsonStr) return flagValues;
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    throw new Error(`Invalid JSON in --input-json: ${jsonStr.slice(0, 100)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("--input-json must be a JSON object");
+  }
+  return { ...parsed, ...stripUndefined(flagValues) };
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export {
+  parseJsonInput
+};

package/dist/chunk-FZGOTXTE.js

@@ -0,0 +1,45 @@
+// 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] ?? 0)).join("  "));
+  lines.push(sep);
+  for (const row of rows) {
+    lines.push(
+      row.map((cell, i) => pad(cell || "", widths[i] ?? 0)).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/chunk-P2BKGBQE.js

@@ -0,0 +1,136 @@
+// src/lib/sanitize-response.ts
+var INJECTION_PATTERNS = [
+  // Direct instruction injection
+  /\b(?:ignore|disregard|forget)\b.*\b(?:previous|above|prior)\b.*\b(?:instructions?|rules?|context)\b/i,
+  // System prompt extraction attempts
+  /\b(?:reveal|show|print|output|display)\b.*\b(?:system\s*prompt|instructions?|rules?)\b/i,
+  // Role hijacking
+  /\byou\s+are\s+(?:now|a)\b/i,
+  // Tool/action injection
+  /\b(?:execute|run|call)\b.*\b(?:command|tool|function|bash|shell)\b/i,
+  // Markdown/XML injection that could affect agent parsing
+  /<\/?(?:system|user|assistant|tool_use|tool_result)\b/i
+];
+var USER_CONTENT_FIELDS = /* @__PURE__ */ new Set([
+  "originalFilename",
+  "filename",
+  "name",
+  "description",
+  "label",
+  "text",
+  "slug",
+  "webhookUrl"
+]);
+function detectInjection(value) {
+  return INJECTION_PATTERNS.some((pattern) => pattern.test(value));
+}
+function sanitizeValue(value) {
+  if (detectInjection(value)) {
+    return `[FLAGGED: potential prompt injection] ${value}`;
+  }
+  return value;
+}
+function sanitizeResponse(data) {
+  if (data === null || data === void 0) return data;
+  if (typeof data === "string") {
+    return sanitizeValue(data);
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => sanitizeResponse(item));
+  }
+  if (typeof data === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(
+      data
+    )) {
+      if (USER_CONTENT_FIELDS.has(key) && typeof value === "string") {
+        result[key] = sanitizeValue(value);
+      } else if (typeof value === "object" && value !== null) {
+        result[key] = sanitizeResponse(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return data;
+}
+
+// src/lib/output.ts
+var _forceHuman = false;
+var _globalFields;
+var _globalNdjson = false;
+function setForceHuman(value) {
+  _forceHuman = value;
+}
+function setGlobalFields(fields) {
+  _globalFields = fields;
+}
+function setGlobalNdjson(value) {
+  _globalNdjson = value;
+}
+function isJsonOutput() {
+  if (_forceHuman) return false;
+  return !process.stdout.isTTY;
+}
+function output(data, humanFormatter, options) {
+  const sanitized = sanitizeResponse(data);
+  const masked = applyFieldMask(sanitized, _globalFields);
+  if (_globalNdjson && Array.isArray(masked)) {
+    outputNdjson(masked);
+    return;
+  }
+  if (options?.json || isJsonOutput()) {
+    console.log(JSON.stringify(masked, null, 2));
+  } else if (humanFormatter && !_globalFields) {
+    console.log(humanFormatter());
+  } else {
+    console.log(JSON.stringify(masked, null, 2));
+  }
+}
+function outputError(error, code, details) {
+  if (isJsonOutput()) {
+    console.error(
+      JSON.stringify({ error, ...code ? { code } : {}, ...details })
+    );
+  } else {
+    console.error(`Error: ${error}`);
+  }
+  process.exit(1);
+}
+function outputNdjson(items) {
+  for (const item of items) {
+    const sanitized = sanitizeResponse(item);
+    console.log(JSON.stringify(sanitized));
+  }
+}
+function applyFieldMask(data, fields) {
+  if (!fields) return data;
+  const fieldSet = new Set(fields.split(",").map((f) => f.trim()));
+  if (Array.isArray(data)) {
+    return data.map((item) => pickFields(item, fieldSet));
+  }
+  if (typeof data === "object" && data !== null) {
+    return pickFields(data, fieldSet);
+  }
+  return data;
+}
+function pickFields(obj, fieldSet) {
+  if (typeof obj !== "object" || obj === null) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (fieldSet.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export {
+  setForceHuman,
+  setGlobalFields,
+  setGlobalNdjson,
+  isJsonOutput,
+  output,
+  outputError
+};