stow-cli 2.0.4 → 2.1.0

package/dist/files-TDIGJDN3.js

@@ -0,0 +1,185 @@
+import {
+  validateBucketName,
+  validateFileKey
+} from "./chunk-OHAFRKN5.js";
+import {
+  formatBytes,
+  formatTable,
+  outputJson
+} from "./chunk-ELSDWMEB.js";
+import {
+  createStow
+} from "./chunk-5LU25QZK.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-TOADDO2F.js";
+
+// src/commands/files.ts
+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 (options.json) {
+    outputJson(data);
+    return;
+  }
+  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] ?? f.lastModified
+  ]);
+  console.log(formatTable(["Key", "Size", "Modified"], rows));
+  if (data.nextCursor) {
+    console.log("\n(more files available \u2014 use --limit to see more)");
+  }
+}
+async function getFile(bucket, key, options) {
+  const stow = createStow();
+  const file = await stow.getFile(key, { bucket });
+  if (options.json) {
+    outputJson(file);
+    return;
+  }
+  console.log(
+    formatTable(
+      ["Field", "Value"],
+      [
+        ["Key", file.key],
+        ["Size", formatBytes(file.size)],
+        ["Type", file.contentType],
+        ["Created", file.createdAt],
+        ["URL", file.url ?? "(private)"],
+        [
+          "Dimensions",
+          file.width && file.height ? `${file.width}\xD7${file.height}` : "\u2014"
+        ],
+        ["Duration", file.duration ? `${file.duration}s` : "\u2014"],
+        ["Embedding", file.embeddingStatus ?? "\u2014"]
+      ]
+    )
+  );
+  if (file.metadata && Object.keys(file.metadata).length > 0) {
+    console.log("\nMetadata:");
+    for (const [k, v] of Object.entries(file.metadata)) {
+      console.log(`  ${k}: ${v}`);
+    }
+  }
+}
+async function updateFile(bucket, key, options) {
+  validateBucketName(bucket);
+  validateFileKey(key);
+  if (!options.metadata || options.metadata.length === 0) {
+    console.error("Error: At least one -m key=value pair is required.");
+    process.exit(1);
+  }
+  const metadata = {};
+  for (const pair of options.metadata) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) {
+      console.error(`Error: Invalid metadata format '${pair}'. Use key=value.`);
+      process.exit(1);
+    }
+    metadata[pair.slice(0, idx)] = pair.slice(idx + 1);
+  }
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "updateFile",
+          details: { bucket, key, metadata }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const stow = createStow();
+  const file = await stow.updateFileMetadata(key, metadata, { bucket });
+  if (options.json) {
+    outputJson(file);
+    return;
+  }
+  console.log(`Updated ${key}`);
+}
+async function enrichFile(bucket, key) {
+  const stow = createStow();
+  const results = await Promise.allSettled([
+    stow.generateTitle(key, { bucket }),
+    stow.generateDescription(key, { bucket }),
+    stow.generateAltText(key, { bucket })
+  ]);
+  const labels = ["Title", "Description", "Alt text"];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const label = labels[i];
+    if (result.status === "fulfilled") {
+      console.log(`  ${label}: triggered`);
+    } else {
+      console.error(`  ${label}: failed \u2014 ${result.reason}`);
+    }
+  }
+  const succeeded = results.filter((r) => r.status === "fulfilled").length;
+  console.log(
+    `
+Enriched ${key}: ${succeeded}/${results.length} tasks dispatched`
+  );
+}
+async function listMissing(bucket, type, options) {
+  const validTypes = ["dimensions", "embeddings", "colors"];
+  if (!validTypes.includes(type)) {
+    console.error(
+      `Error: Invalid type '${type}'. Must be one of: ${validTypes.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const parsedLimit = options.limit ? Number.parseInt(options.limit, 10) : null;
+  const baseUrl = getBaseUrl();
+  const apiKey = getApiKey();
+  const params = new URLSearchParams({
+    bucket,
+    missing: type,
+    ...parsedLimit && Number.isFinite(parsedLimit) && parsedLimit > 0 ? { limit: String(parsedLimit) } : {}
+  });
+  const res = await fetch(`${baseUrl}/files?${params}`, {
+    headers: { "x-api-key": apiKey }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error ?? `HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  if (options.json) {
+    outputJson(data);
+    return;
+  }
+  if (data.files.length === 0) {
+    console.log(`No files missing ${type} in bucket '${bucket}'.`);
+    return;
+  }
+  const rows = data.files.map((f) => [
+    f.key,
+    formatBytes(f.size),
+    f.lastModified.split("T")[0] ?? f.lastModified
+  ]);
+  console.log(formatTable(["Key", "Size", "Modified"], rows));
+  console.log(`
+${data.files.length} files missing ${type}`);
+}
+export {
+  enrichFile,
+  getFile,
+  listFiles,
+  listMissing,
+  updateFile
+};

package/dist/mcp-RZT4TJEX.js

@@ -0,0 +1,190 @@
+import {
+  createStow
+} from "./chunk-5LU25QZK.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/mcp.ts
+import { z } from "zod";
+async function startMcpServer() {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const server = new McpServer({
+    name: "stow",
+    version: "2.0.4"
+  });
+  server.tool(
+    "stow_whoami",
+    "Show current user and organization",
+    {},
+    async () => {
+      const stow = createStow();
+      const result = await stow.whoami();
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool("stow_buckets_list", "List all buckets", {}, async () => {
+    const stow = createStow();
+    const result = await stow.listBuckets();
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+  server.tool(
+    "stow_files_list",
+    "List files in a bucket",
+    {
+      bucket: z.string().describe("Bucket name"),
+      limit: z.number().optional().describe("Max results (default 50)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.listFiles({
+        bucket: params.bucket,
+        limit: params.limit
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_files_get",
+    "Get file details",
+    {
+      bucket: z.string().describe("Bucket name"),
+      key: z.string().describe("File key")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.getFile(params.key, {
+        bucket: params.bucket
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_search_text",
+    "Search files by text query",
+    {
+      query: z.string().describe("Search query"),
+      bucket: z.string().optional().describe("Bucket name (optional)"),
+      limit: z.number().optional().describe("Max results (default 10)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.search.text({
+        query: params.query,
+        bucket: params.bucket,
+        limit: params.limit
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_search_similar",
+    "Find visually similar files",
+    {
+      fileKey: z.string().describe("File key to find similar files for"),
+      bucket: z.string().optional().describe("Bucket name (optional)"),
+      limit: z.number().optional().describe("Max results (default 10)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.search.similar({
+        fileKey: params.fileKey,
+        bucket: params.bucket,
+        limit: params.limit
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_search_color",
+    "Search files by hex color",
+    {
+      hex: z.string().describe("Hex color code (e.g. #ff0000)"),
+      bucket: z.string().optional().describe("Bucket name (optional)"),
+      limit: z.number().optional().describe("Max results (default 10)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.search.color({
+        hex: params.hex,
+        bucket: params.bucket,
+        limit: params.limit
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_search_diverse",
+    "Get a diverse set of files from a bucket",
+    {
+      bucket: z.string().optional().describe("Bucket name (optional)"),
+      limit: z.number().optional().describe("Max results (default 10)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.search.diverse({
+        bucket: params.bucket,
+        limit: params.limit
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_search_image",
+    "Search by image URL or existing file key",
+    {
+      url: z.string().optional().describe("Image URL to search by"),
+      fileKey: z.string().optional().describe("Existing file key to search by"),
+      bucket: z.string().optional().describe("Bucket name (optional)"),
+      limit: z.number().optional().describe("Max results (default 12)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const input = {};
+      if (params.url) input.url = params.url;
+      if (params.fileKey) input.fileKey = params.fileKey;
+      const result = await stow.search.image(input, {
+        bucket: params.bucket,
+        limit: params.limit ?? 12
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool("stow_tags_list", "List all tags", {}, async () => {
+    const stow = createStow();
+    const result = await stow.tags.list();
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+  server.tool(
+    "stow_anchors_list",
+    "List anchors in a bucket",
+    {
+      bucket: z.string().optional().describe("Bucket name (optional)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.anchors.list({ bucket: params.bucket });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stow_anchors_create",
+    "Create a text anchor for semantic search",
+    {
+      text: z.string().describe("Anchor text to embed"),
+      label: z.string().optional().describe("Human-readable label (optional)")
+    },
+    async (params) => {
+      const stow = createStow();
+      const result = await stow.anchors.create({
+        text: params.text,
+        label: params.label
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  startMcpServer
+};

package/dist/tags-MCFL5M2J.js

@@ -0,0 +1,82 @@
+import {
+  validateInput
+} from "./chunk-OHAFRKN5.js";
+import {
+  formatTable,
+  outputJson
+} from "./chunk-ELSDWMEB.js";
+import {
+  createStow
+} from "./chunk-5LU25QZK.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/tags.ts
+async function listTags(options) {
+  const stow = createStow();
+  const data = await stow.tags.list();
+  if (options.json) {
+    outputJson(data);
+    return;
+  }
+  if (data.tags.length === 0) {
+    console.log("No tags yet. Create one with: stow tags create <name>");
+    return;
+  }
+  const rows = data.tags.map((t) => [t.name, t.slug, t.color ?? "\u2014", t.id]);
+  console.log(formatTable(["Name", "Slug", "Color", "ID"], rows));
+}
+async function createTag(name, options) {
+  validateInput(name, "tag name");
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "createTag",
+          details: {
+            name,
+            color: options.color ?? null
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const stow = createStow();
+  const tag = await stow.tags.create({
+    name,
+    ...options.color ? { color: options.color } : {}
+  });
+  if (options.json) {
+    outputJson(tag);
+    return;
+  }
+  console.log(`Created tag: ${tag.name}`);
+}
+async function deleteTag(id, options = {}) {
+  validateInput(id, "tag id");
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "deleteTag",
+          details: { id }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const stow = createStow();
+  await stow.tags.delete(id);
+  console.log(`Deleted tag: ${id}`);
+}
+export {
+  createTag,
+  deleteTag,
+  listTags
+};

package/dist/upload-5TAWJU5N.js

@@ -0,0 +1,126 @@
+import {
+  validateBucketName
+} from "./chunk-OHAFRKN5.js";
+import {
+  formatBytes
+} from "./chunk-ELSDWMEB.js";
+import {
+  createStow
+} from "./chunk-5LU25QZK.js";
+import "./chunk-TOADDO2F.js";
+
+// src/commands/upload.ts
+import { existsSync, readFileSync, statSync } 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) {
+  if (options.bucket) {
+    validateBucketName(options.bucket);
+  }
+  const resolvedPath = resolve(filePath);
+  if (!existsSync(resolvedPath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const filename = basename(resolvedPath);
+  const contentType = getContentType(filename);
+  const size = statSync(resolvedPath).size;
+  if (options.dryRun) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          action: "upload",
+          details: {
+            file: resolvedPath,
+            filename,
+            contentType,
+            size,
+            bucket: options.bucket ?? null
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const buffer = readFileSync(resolvedPath);
+  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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stow-cli",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "type": "module",
   "description": "CLI for Stow file storage",
   "license": "MIT",
@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "@howells/stow-server": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "clipboardy": "^5.3.1",
     "commander": "^14.0.3",
     "ink": "^6.8.0",
@@ -37,7 +38,8 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "open": "^11.0.0",
-    "react": "^19.2.4"
+    "react": "^19.2.4",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@stow/typescript-config": "workspace:*",