batchedits 1.0.0 → 1.1.0

package/README.md

@@ -1,47 +1,66 @@
-# `batchedits`
+# BatchEdits CLI
 
-Official JS SDK, React Embed Widgets, and CLI for **BatchEdits AI Bulk Video Editor**.
-
-## Installation
+Edit up to 50 videos at once from your terminal or AI agent (Claude Code, OpenClaw, Hermes, Codex): auto captions in 99+ languages, silence removal, 9:16 crops, zoom on key moments and AI clips from long videos.
 
 ```bash
-npm install batchedits
+npx batchedits login
+npx batchedits style create "Shorts" --crop 9:16 --silence --captions --zoom
+npx batchedits run ./raw --style "Shorts" --out ./edited
 ```
 
-## React Usage
+`run` uploads every video in `./raw`, edits them all with your style, waits, and saves the results to `./edited`.
 
-```tsx
-import { EditWithBatchEditsButton } from 'batchedits/react';
-
-export function App() {
-  return (
-    <EditWithBatchEditsButton
-      videoUrl="https://example.com/video.mp4"
-      webhookUrl="https://example.com/api/webhooks/batchedits"
-      theme="gradient"
-      mode="popup"
-      onComplete={(data) => console.log('Edited video:', data.editedVideoUrl)}
-    />
-  );
-}
+Needs Node.js 18.17+ and a [BatchEdits](https://batchedits.com) account (7-day free trial, $0 today). Full docs: https://batchedits.com/docs/cli
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `login` / `logout` / `whoami` | Sign in through your browser; check the connection |
+| `styles` | List your styles |
+| `actions` | List editing actions and their settings |
+| `style create <name> [--captions] [--emojis] [--silence] [--repeats] [--crop 9:16] [--zoom] [--clips [n]]` | Create a style from flags |
+| `upload <files or folders…>` | Upload up to 50 videos, print their ids |
+| `process <ids…> --style <name> [--yes]` | Edit videos (1 credit each, 1 per AI clip) |
+| `status [ids…] [--watch]` | Show status, or wait until done |
+| `download <ids…> [--out dir]` | Save finished videos (and their AI clips) |
+| `run <files or folders…> --style <name> [--out dir] [--yes]` | All of the above in one go |
+
+Every command has `--help` with an example, and `--json` for machine-readable output.
+
+## Sign in
+
+- `batchedits login` opens BatchEdits in your browser to approve the CLI, then stores the login in `~/.config/batchedits`. The token is never printed, so agents can run commands without seeing it.
+- On servers and CI, set `BATCHEDITS_API_KEY` (Dashboard → Settings → API keys).
+
+## Using it from an AI agent
+
+Agents on your machine can run the CLI directly. Add this to the agent's instructions:
+
+```
+Edit videos with `npx batchedits` (run `npx batchedits --help`). List styles with `styles --json`,
+then `run <folder> --style "<name>" --out <folder> --yes --json`. Processing uses credits:
+confirm with the user before passing --yes. Exit code 5 = needs --yes, 3 = sign in first.
 ```
 
-## Vanilla JavaScript Usage
+For ChatGPT, claude.ai and other remote agents, connect the MCP server: https://batchedits.com/docs/mcp
+
+Exit codes: `0` done · `1` error · `2` usage · `3` sign in needed · `4` some videos failed · `5` needs `--yes`.
+
+## SDK and React widgets
 
-```javascript
-import { openModal } from 'batchedits';
+The same package exports an embed SDK and React components for adding a BatchEdits editor to your app:
 
-openModal({
-  videoUrl: 'https://example.com/video.mp4',
-  mode: 'popup',
-  onComplete: (data) => {
-    console.log('Video editing complete!', data.editedVideoUrl);
-  }
-});
+```tsx
+import { EditWithBatchEditsButton } from "batchedits/react";
+
+<EditWithBatchEditsButton videoUrl="https://example.com/video.mp4" mode="popup" onComplete={(d) => console.log(d.editedVideoUrl)} />
 ```
 
-## CLI Usage
+```js
+import { openModal } from "batchedits";
 
-```bash
-npx batchedits --help
+openModal({ videoUrl: "https://example.com/video.mp4", mode: "popup", onComplete: (data) => console.log(data.editedVideoUrl) });
 ```
+
+MIT licensed.

package/dist/cli.js

@@ -1,8 +1,698 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/cli.ts
-console.log("\u{1F680} BatchEdits CLI v1.0.0");
-console.log("Commands available:");
-console.log("  batchedits edit <videoUrl>   - Launch BatchEdits CLI video editor");
-console.log("  batchedits init              - Generate BatchEdits config");
+var import_node_util = require("util");
+
+// src/cli/api.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+
+// src/cli/output.ts
+var EXIT = {
+  OK: 0,
+  ERROR: 1,
+  USAGE: 2,
+  AUTH: 3,
+  /** Some items failed (e.g. one video in a batch). */
+  PARTIAL: 4,
+  /** Needs confirmation: re-run with --yes. */
+  CONFIRM: 5
+};
+var CliError = class extends Error {
+  constructor(message, code = EXIT.ERROR, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+  }
+};
+var jsonMode = false;
+function setJsonMode(on) {
+  jsonMode = on;
+}
+function isJson() {
+  return jsonMode;
+}
+function say(line = "") {
+  if (!jsonMode) process.stdout.write(line + "\n");
+}
+function info(line) {
+  process.stderr.write(line + "\n");
+}
+function printJson(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function table(rows, columns) {
+  if (rows.length === 0) return;
+  const cell = (v) => v === null || v === void 0 ? "" : String(v);
+  const widths = columns.map((c) => Math.min(60, Math.max(c.length, ...rows.map((r) => cell(r[c]).length))));
+  const line = (vals) => vals.map((v, i) => v.slice(0, widths[i]).padEnd(widths[i])).join("  ").trimEnd();
+  say(line(columns.map((c) => c.toUpperCase())));
+  for (const r of rows) say(line(columns.map((c) => cell(r[c]))));
+}
+
+// src/cli/auth.ts
+var import_node_crypto = __toESM(require("crypto"));
+var import_node_http = __toESM(require("http"));
+var import_node_child_process = require("child_process");
+
+// src/cli/config.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var DEFAULT_HOST = "https://batchedits.com";
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME || import_node_path.default.join(import_node_os.default.homedir(), ".config");
+  return import_node_path.default.join(base, "batchedits");
+}
+function authFile() {
+  return import_node_path.default.join(configDir(), "auth.json");
+}
+function readAuth() {
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(authFile(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeAuth(auth) {
+  import_node_fs.default.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  import_node_fs.default.writeFileSync(authFile(), JSON.stringify(auth, null, 2), { mode: 384 });
+}
+function clearAuth() {
+  try {
+    import_node_fs.default.unlinkSync(authFile());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveHost(flag) {
+  const host = flag || process.env.BATCHEDITS_HOST || readAuth()?.host || DEFAULT_HOST;
+  return host.replace(/\/+$/, "");
+}
+
+// src/cli/auth.ts
+async function discover(host) {
+  const res = await fetch(`${host}/.well-known/oauth-authorization-server`);
+  if (!res.ok) throw new CliError(`Couldn't reach ${host} (${res.status}).`);
+  return await res.json();
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    (0, import_node_child_process.spawn)(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+var base64url = (b) => b.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+async function login(host) {
+  const meta = await discover(host);
+  const server = import_node_http.default.createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const port = server.address().port;
+  const redirectUri = `http://127.0.0.1:${port}/callback`;
+  try {
+    const reg = await fetch(meta.registration_endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ client_name: "BatchEdits CLI", redirect_uris: [redirectUri] })
+    });
+    if (!reg.ok) throw new CliError(`Couldn't register the CLI with ${host} (${reg.status}).`);
+    const client = await reg.json();
+    const verifier = base64url(import_node_crypto.default.randomBytes(32));
+    const challenge = base64url(import_node_crypto.default.createHash("sha256").update(verifier).digest());
+    const state = base64url(import_node_crypto.default.randomBytes(16));
+    const authorizeUrl = new URL(meta.authorization_endpoint);
+    authorizeUrl.search = new URLSearchParams({
+      response_type: "code",
+      client_id: client.client_id,
+      redirect_uri: redirectUri,
+      state,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      scope: "videos.read videos.write offline_access"
+    }).toString();
+    info("Opening your browser to sign in to BatchEdits\u2026");
+    info(`If it doesn't open, visit:
+  ${authorizeUrl}`);
+    openBrowser(authorizeUrl.toString());
+    const code = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new CliError("Login timed out after 5 minutes.", EXIT.AUTH)), 5 * 6e4);
+      server.on("request", (req, res) => {
+        const url = new URL(req.url || "/", redirectUri);
+        if (url.pathname !== "/callback") {
+          res.writeHead(404).end();
+          return;
+        }
+        const ok = url.searchParams.get("state") === state && url.searchParams.get("code");
+        res.writeHead(ok ? 200 : 400, { "Content-Type": "text/html" }).end(
+          ok ? "<h2>You're signed in to the BatchEdits CLI.</h2><p>You can close this tab.</p>" : "<h2>Login failed.</h2><p>Run <code>batchedits login</code> again.</p>"
+        );
+        clearTimeout(timer);
+        if (ok) resolve(url.searchParams.get("code"));
+        else reject(new CliError(url.searchParams.get("error_description") || "Login was cancelled or failed.", EXIT.AUTH));
+      });
+    });
+    const tokens = await tokenRequest(meta.token_endpoint, {
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      code_verifier: verifier,
+      client_id: client.client_id,
+      client_secret: client.client_secret
+    });
+    const auth = {
+      host,
+      clientId: client.client_id,
+      clientSecret: client.client_secret,
+      redirectUri,
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      expiresAt: tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0
+    };
+    writeAuth(auth);
+    return auth;
+  } finally {
+    server.close();
+  }
+}
+async function tokenRequest(endpoint, params) {
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params).toString()
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.access_token) {
+    throw new CliError(`Sign-in failed: ${body.error_description || body.error || res.status}.`, EXIT.AUTH, "Run: batchedits login");
+  }
+  return body;
+}
+async function getToken(host) {
+  const apiKey = process.env.BATCHEDITS_API_KEY?.trim();
+  if (apiKey) return apiKey;
+  const auth = readAuth();
+  if (!auth || auth.host !== host) {
+    throw new CliError("Not signed in.", EXIT.AUTH, "Run: batchedits login   (or set BATCHEDITS_API_KEY)");
+  }
+  if (!auth.expiresAt || auth.expiresAt - Date.now() > 6e4) return auth.accessToken;
+  if (!auth.refreshToken) throw new CliError("Your login expired.", EXIT.AUTH, "Run: batchedits login");
+  const meta = await discover(host);
+  const tokens = await tokenRequest(meta.token_endpoint, {
+    grant_type: "refresh_token",
+    refresh_token: auth.refreshToken,
+    client_id: auth.clientId,
+    client_secret: auth.clientSecret
+  });
+  writeAuth({
+    ...auth,
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token ?? auth.refreshToken,
+    expiresAt: tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0
+  });
+  return tokens.access_token;
+}
+
+// src/cli/api.ts
+var BatchEdits = class {
+  constructor(host, version) {
+    this.host = host;
+    this.version = version;
+  }
+  async connect() {
+    if (this.client) return this.client;
+    this.token = await getToken(this.host);
+    const transport = new import_streamableHttp.StreamableHTTPClientTransport(new URL(`${this.host}/api/mcp`), {
+      requestInit: { headers: { Authorization: `Bearer ${this.token}` } }
+    });
+    const client = new import_client.Client({ name: "batchedits-cli", version: this.version });
+    try {
+      await client.connect(transport);
+    } catch (err) {
+      if (String(err?.message).includes("401")) throw new CliError("Your login isn't valid any more.", EXIT.AUTH, "Run: batchedits login");
+      throw new CliError(`Couldn't connect to ${this.host}: ${err?.message ?? err}`);
+    }
+    this.client = client;
+    return client;
+  }
+  async close() {
+    await this.client?.close().catch(() => {
+    });
+  }
+  /** Calls a tool and returns its structured result; tool errors become CliErrors with the server's message. */
+  async call(name, args = {}) {
+    const client = await this.connect();
+    const res = await client.callTool({ name, arguments: args });
+    if (res.isError) {
+      const text = (res.content ?? []).map((c) => c.text).filter(Boolean).join(" ").replace(/^Error:\s*/, "");
+      throw new CliError(text || `${name} failed.`, EXIT.ERROR, creditsHint(text, this.host));
+    }
+    return res.structuredContent ?? {};
+  }
+  async styles() {
+    return (await this.call("get_styles")).styles ?? [];
+  }
+  async videos(limit = 100) {
+    return (await this.call("list_videos", { limit })).videos ?? [];
+  }
+  /** Uploads one local file (multipart, one per request so a failure only costs that file). */
+  async upload(file) {
+    await this.connect();
+    const form = new FormData();
+    const blob = typeof import_node_fs2.default.openAsBlob === "function" ? await import_node_fs2.default.openAsBlob(file) : new Blob([new Uint8Array(import_node_fs2.default.readFileSync(file))]);
+    form.append("videos", blob, import_node_path2.default.basename(file));
+    const res = await fetch(`${this.host}/api/mcp/upload`, { method: "POST", headers: { Authorization: `Bearer ${this.token}` }, body: form });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || !body.videos?.[0]) {
+      if (res.status === 401) throw new CliError("Your login isn't valid any more.", EXIT.AUTH, "Run: batchedits login");
+      if (res.status === 413) throw new CliError(`${import_node_path2.default.basename(file)} is too large to upload.`);
+      throw new CliError(`Upload failed for ${import_node_path2.default.basename(file)}: ${body.error ?? res.status}`);
+    }
+    return body.videos[0];
+  }
+  /** Streams a download link to `dir`, never overwriting an existing file. */
+  async download(url, name, dir) {
+    import_node_fs2.default.mkdirSync(dir, { recursive: true });
+    const ext = import_node_path2.default.extname(name) || ".mp4";
+    const stem = import_node_path2.default.basename(name, import_node_path2.default.extname(name));
+    let out = import_node_path2.default.join(dir, `${stem}${ext}`);
+    for (let n = 2; import_node_fs2.default.existsSync(out); n++) out = import_node_path2.default.join(dir, `${stem}-${n}${ext}`);
+    const res = await fetch(url);
+    if (!res.ok || !res.body) throw new CliError(`Download failed for ${name} (${res.status}).`);
+    await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), import_node_fs2.default.createWriteStream(out));
+    return out;
+  }
+};
+function creditsHint(message, host) {
+  if (/credit/i.test(message)) return `Start your free trial or upgrade: ${host}/onboarding/pricing`;
+  return void 0;
+}
+
+// src/cli/commands.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_promises2 = __toESM(require("readline/promises"));
+var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".m4v", ".avi", ".mkv", ".webm", ".mp3", ".wav", ".m4a"]);
+var MAX_BATCH = 50;
+var DONE = /* @__PURE__ */ new Set(["completed", "failed"]);
+function expandFiles(inputs) {
+  const files = [];
+  for (const input of inputs) {
+    if (!import_node_fs3.default.existsSync(input)) throw new CliError(`No such file or folder: ${input}`, EXIT.USAGE);
+    if (import_node_fs3.default.statSync(input).isDirectory()) {
+      for (const f of import_node_fs3.default.readdirSync(input).sort()) {
+        const p = import_node_path3.default.join(input, f);
+        if (import_node_fs3.default.statSync(p).isFile() && VIDEO_EXTS.has(import_node_path3.default.extname(f).toLowerCase())) files.push(p);
+      }
+    } else {
+      files.push(input);
+    }
+  }
+  if (files.length === 0) throw new CliError("No video or audio files found.", EXIT.USAGE, `Supported: ${Array.from(VIDEO_EXTS).join(" ")}`);
+  if (files.length > MAX_BATCH) throw new CliError(`${files.length} files: upload up to ${MAX_BATCH} at a time.`, EXIT.USAGE, "Split the folder and run once per part.");
+  return files;
+}
+async function resolveStyle(api, ref) {
+  if (typeof ref !== "string" || !ref) throw new CliError("--style is required.", EXIT.USAGE, "List them with: batchedits styles");
+  const styles = await api.styles();
+  const style = styles.find((s) => s.id === ref) ?? styles.find((s) => s.name.toLowerCase() === ref.toLowerCase());
+  if (!style) throw new CliError(`No style named "${ref}".`, EXIT.USAGE, `Available: ${styles.map((s) => `"${s.name}"`).join(", ") || "none"}. Create one with: batchedits style create`);
+  return style;
+}
+async function confirm(flags, question) {
+  if (flags.yes) return;
+  if (!process.stdin.isTTY || isJson()) throw new CliError(question, EXIT.CONFIRM, "Re-run with --yes to confirm.");
+  const rl = import_promises2.default.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+  rl.close();
+  if (answer !== "y" && answer !== "yes") throw new CliError("Cancelled. Nothing was processed.", EXIT.ERROR);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function withClips(all, ids) {
+  const wanted = new Set(ids);
+  return all.filter((v) => wanted.has(v.id) || v.clipOf && wanted.has(v.clipOf));
+}
+function settled(v, group) {
+  if (v.splitIntoClips) return group.filter((c) => c.clipOf === v.id).every((c) => DONE.has(c.status));
+  return DONE.has(v.status);
+}
+async function watch(api, ids, intervalSec) {
+  let last = "";
+  for (; ; ) {
+    const group = withClips(await api.videos(), ids);
+    const missing = ids.filter((id) => !group.some((v) => v.id === id));
+    if (missing.length) throw new CliError(`Unknown video id(s): ${missing.join(", ")}`, EXIT.USAGE, "List your videos with: batchedits status");
+    const done = group.filter((v) => settled(v, group)).length;
+    const line = `${done}/${group.length} done \xB7 ${group.map((v) => `${v.name.slice(0, 24)}: ${v.splitIntoClips ? `split into ${v.splitIntoClips} clips` : v.progressMessage || v.status}`).join(" \xB7 ")}`;
+    if (line !== last) info(line);
+    last = line;
+    if (group.every((v) => settled(v, group))) return group;
+    await sleep(intervalSec * 1e3);
+  }
+}
+function printVideos(videos) {
+  if (isJson()) return printJson({ videos });
+  if (videos.length === 0) return say("No videos.");
+  table(
+    videos.map((v) => ({
+      id: v.id,
+      name: v.name,
+      status: v.splitIntoClips ? `split (${v.splitIntoClips} clips)` : v.status,
+      detail: v.errorMessage || v.progressMessage || (v.clipOf ? `clip of ${v.clipOf.slice(0, 8)}` : "")
+    })),
+    ["id", "name", "status", "detail"]
+  );
+}
+async function downloadAll(api, videos, out) {
+  const ready = videos.filter((v) => v.status === "completed" && !v.splitIntoClips);
+  if (ready.length === 0) return { saved: [], notReady: videos.filter((v) => !v.splitIntoClips).map((v) => ({ id: v.id, status: v.status })) };
+  const res = await api.call("download_videos", { videoIds: ready.map((v) => v.id) });
+  const saved = [];
+  for (const link of res.links ?? []) {
+    const file = await api.download(link.url, link.name, out);
+    info(`Saved ${file}`);
+    saved.push({ id: link.id, file });
+  }
+  return { saved, notReady: res.notReady ?? [] };
+}
+var commands = {
+  login: {
+    summary: "Sign in through your browser",
+    usage: "batchedits login [--host <url>]",
+    help: "Opens BatchEdits in your browser to approve the CLI, then stores the login in ~/.config/batchedits.\nThe token is never printed, so agents can run commands without seeing it.\nOn servers and CI, set BATCHEDITS_API_KEY instead (Dashboard \u2192 Settings \u2192 API keys).",
+    async run({ host }) {
+      await login(host);
+      if (isJson()) printJson({ loggedIn: true, host });
+      else say(`Signed in to ${host}. Try: batchedits styles`);
+      return EXIT.OK;
+    }
+  },
+  logout: {
+    summary: "Remove the stored login",
+    usage: "batchedits logout",
+    help: "Deletes ~/.config/batchedits/auth.json. BATCHEDITS_API_KEY, if set, still works.",
+    async run() {
+      const removed = clearAuth();
+      if (isJson()) printJson({ loggedOut: removed });
+      else say(removed ? "Signed out." : "You weren't signed in.");
+      return EXIT.OK;
+    }
+  },
+  whoami: {
+    summary: "Check that you're signed in",
+    usage: "batchedits whoami",
+    help: "Shows how the CLI is authenticated and checks the connection.",
+    async run({ api, host }) {
+      const via = process.env.BATCHEDITS_API_KEY ? "BATCHEDITS_API_KEY" : readAuth() ? `login (${authFile()})` : "nothing";
+      const styles = await api.styles();
+      if (isJson()) printJson({ host, auth: via, styles: styles.length });
+      else say(`Connected to ${host} via ${via}. ${styles.length} styles available.`);
+      return EXIT.OK;
+    }
+  },
+  styles: {
+    summary: "List your editing styles",
+    usage: "batchedits styles",
+    help: "Lists saved and built-in styles. Use a style's name or id with --style.\nExample: batchedits styles",
+    async run({ api }) {
+      const styles = await api.styles();
+      if (isJson()) printJson({ styles });
+      else if (styles.length === 0) say("No styles yet. Create one with: batchedits style create");
+      else table(styles.map((s) => ({ name: s.name, id: s.id, actions: (s.actions ?? []).map((a) => a.name).join(", ") })), ["name", "id", "actions"]);
+      return EXIT.OK;
+    }
+  },
+  actions: {
+    summary: "List editing actions and their settings",
+    usage: "batchedits actions",
+    help: "Lists the actions a style can use (captions, silence removal, crop, zoom, AI clips) and their params.",
+    async run({ api }) {
+      const { actions } = await api.call("list_actions");
+      if (isJson()) printJson({ actions });
+      else table(actions.map((a) => ({ name: a.name, params: a.params ?? a.description ?? "" })), ["name", "params"]);
+      return EXIT.OK;
+    }
+  },
+  "style create": {
+    summary: "Create a style from simple flags",
+    usage: "batchedits style create <name> [--captions] [--emojis] [--silence] [--crop 9:16] [--zoom] [--clips [n]] [--repeats]",
+    help: [
+      "Creates a reusable style. Order of edits: crop, silence, repeats, captions, zoom, AI clips.",
+      "  --captions      Auto captions (word-by-word highlight)",
+      "  --emojis        Add AI-picked emojis to the captions",
+      "  --silence       Remove silences and dead air",
+      "  --repeats       Remove repeated takes of the same sentence",
+      "  --crop <ratio>  Crop every video, e.g. 9:16, 1:1, 4:5",
+      "  --zoom          Zoom in on key moments",
+      "  --clips [n]     Cut long videos into n short clips (default 10; 1 credit per clip)",
+      'Example: batchedits style create "Shorts" --crop 9:16 --silence --captions --zoom'
+    ].join("\n"),
+    async run({ api, positionals, flags }) {
+      const name = positionals.join(" ").trim();
+      if (!name) throw new CliError("Give the style a name.", EXIT.USAGE, 'Example: batchedits style create "Shorts" --captions --silence');
+      const { actions } = await api.call("list_actions");
+      const byName = new Map(actions.map((a) => [a.name, a.id]));
+      const wanted = [];
+      if (typeof flags.crop === "string") wanted.push({ name: "crop_video", customParams: { aspectRatio: flags.crop } });
+      if (flags.silence) wanted.push({ name: "remove_silence" });
+      if (flags.repeats) wanted.push({ name: "remove_repeated_sentences" });
+      if (flags.captions || flags.emojis) wanted.push({ name: "add_captions", customParams: flags.emojis ? { emojis: true } : void 0 });
+      if (flags.zoom) wanted.push({ name: "punch_zoom" });
+      if (flags.clips) wanted.push({ name: "ai_clips", customParams: typeof flags.clips === "string" ? { maxClips: Number(flags.clips) } : void 0 });
+      if (wanted.length === 0) throw new CliError("Pick at least one edit.", EXIT.USAGE, "See: batchedits style create --help");
+      const missing = wanted.filter((w) => !byName.has(w.name)).map((w) => w.name);
+      if (missing.length) throw new CliError(`This server doesn't support: ${missing.join(", ")}.`);
+      const res = await api.call("create_style", {
+        name,
+        actions: wanted.map((w) => ({ id: byName.get(w.name), ...w.customParams ? { customParams: w.customParams } : {} }))
+      });
+      if (isJson()) printJson({ styleId: res.styleId, name });
+      else say(`Created style "${name}" (${res.styleId}). Use it with: --style "${name}"`);
+      return EXIT.OK;
+    }
+  },
+  upload: {
+    summary: "Upload local videos (up to 50)",
+    usage: "batchedits upload <files or folders\u2026>",
+    help: "Uploads videos or audio and prints their ids. A folder uploads the media files inside it.\nExample: batchedits upload ./raw",
+    async run({ api, positionals }) {
+      const files = expandFiles(positionals);
+      const uploaded = [];
+      for (let i = 0; i < files.length; i++) {
+        info(`Uploading ${i + 1}/${files.length}: ${import_node_path3.default.basename(files[i])}`);
+        uploaded.push({ ...await api.upload(files[i]), file: files[i] });
+      }
+      if (isJson()) printJson({ videos: uploaded });
+      else {
+        table(uploaded, ["id", "name"]);
+        say(`
+Next: batchedits process ${uploaded.map((v) => v.id).join(" ")} --style "<name>"`);
+      }
+      return EXIT.OK;
+    }
+  },
+  process: {
+    summary: "Edit videos with a style (uses credits)",
+    usage: "batchedits process <video ids\u2026> --style <name|id> [--yes]",
+    help: 'Queues each video with the style. Each video uses 1 credit; with AI clips each clip uses 1.\nAsks before spending credits; agents and scripts pass --yes.\nExample: batchedits process 3f2a\u2026 9c1d\u2026 --style "Shorts" --yes',
+    async run({ api, positionals, flags }) {
+      if (positionals.length === 0) throw new CliError("Give the video ids to process.", EXIT.USAGE, "Find them with: batchedits status");
+      const style = await resolveStyle(api, flags.style);
+      const clips = (style.actions ?? []).some((a) => a.name === "ai_clips");
+      await confirm(flags, `Edit ${positionals.length} video${positionals.length === 1 ? "" : "s"} with "${style.name}"? This uses ${positionals.length} credit${positionals.length === 1 ? "" : "s"}${clips ? ", plus 1 per AI clip" : ""}.`);
+      const results = [];
+      for (const videoId of positionals) {
+        try {
+          const r = await api.call("process_video", { videoId, styleId: style.id });
+          results.push({ videoId, status: r.status ?? "queued" });
+        } catch (err) {
+          if (err instanceof CliError && err.hint && results.length === 0) throw err;
+          results.push({ videoId, error: err?.message ?? String(err) });
+        }
+      }
+      if (isJson()) printJson({ style: style.name, results });
+      else {
+        table(results.map((r) => ({ id: r.videoId, result: r.error ?? r.status })), ["id", "result"]);
+        say(`
+Next: batchedits status ${positionals.join(" ")} --watch`);
+      }
+      return results.some((r) => r.error) ? EXIT.PARTIAL : EXIT.OK;
+    }
+  },
+  status: {
+    summary: "Show video status (or --watch until done)",
+    usage: "batchedits status [video ids\u2026] [--watch] [--interval 10]",
+    help: "Without ids: your 20 newest videos. With --watch: waits until every given video (and its AI clips) is done.\nExample: batchedits status 3f2a\u2026 --watch",
+    async run({ api, positionals, flags }) {
+      if (flags.watch) {
+        if (positionals.length === 0) throw new CliError("--watch needs video ids.", EXIT.USAGE);
+        const group = await watch(api, positionals, Number(flags.interval) || 10);
+        printVideos(group);
+        return group.some((v) => v.status === "failed") ? EXIT.PARTIAL : EXIT.OK;
+      }
+      const all = await api.videos();
+      printVideos(positionals.length ? withClips(all, positionals) : all.slice(0, 20));
+      return EXIT.OK;
+    }
+  },
+  download: {
+    summary: "Download finished videos",
+    usage: "batchedits download <video ids\u2026> [--out ./edited]",
+    help: "Saves every finished video (and AI clips cut from it) to --out (default ./edited). Unfinished ones are listed.\nExample: batchedits download 3f2a\u2026 --out ./edited",
+    async run({ api, positionals, flags }) {
+      if (positionals.length === 0) throw new CliError("Give the video ids to download.", EXIT.USAGE);
+      const group = withClips(await api.videos(), positionals);
+      const { saved, notReady } = await downloadAll(api, group, typeof flags.out === "string" ? flags.out : "edited");
+      if (isJson()) printJson({ saved, notReady });
+      else {
+        say(`Downloaded ${saved.length} video${saved.length === 1 ? "" : "s"}.`);
+        for (const n of notReady) say(`Not ready: ${n.id} (${n.status})`);
+      }
+      return notReady.length ? EXIT.PARTIAL : EXIT.OK;
+    }
+  },
+  run: {
+    summary: "Upload, edit, wait and download in one go",
+    usage: "batchedits run <files or folders\u2026> --style <name|id> [--out ./edited] [--yes]",
+    help: 'Uploads up to 50 videos, edits them with the style, waits, and downloads the results.\nExample: batchedits run ./raw --style "Shorts" --out ./edited --yes',
+    async run(ctx) {
+      const { api, positionals, flags } = ctx;
+      const files = expandFiles(positionals);
+      const style = await resolveStyle(api, flags.style);
+      const clips = (style.actions ?? []).some((a) => a.name === "ai_clips");
+      await confirm(flags, `Edit ${files.length} video${files.length === 1 ? "" : "s"} with "${style.name}"? This uses ${files.length} credit${files.length === 1 ? "" : "s"}${clips ? ", plus 1 per AI clip" : ""}.`);
+      const ids = [];
+      for (let i = 0; i < files.length; i++) {
+        info(`Uploading ${i + 1}/${files.length}: ${import_node_path3.default.basename(files[i])}`);
+        ids.push((await api.upload(files[i])).id);
+      }
+      for (const videoId of ids) await api.call("process_video", { videoId, styleId: style.id });
+      info(`Editing ${ids.length} video${ids.length === 1 ? "" : "s"} with "${style.name}"\u2026`);
+      const group = await watch(api, ids, Number(flags.interval) || 10);
+      const { saved, notReady } = await downloadAll(api, group, typeof flags.out === "string" ? flags.out : "edited");
+      const failed = group.filter((v) => v.status === "failed");
+      if (isJson()) printJson({ style: style.name, videoIds: ids, saved, failed: failed.map((v) => ({ id: v.id, error: v.errorMessage })), notReady });
+      else {
+        say(`Done: ${saved.length} edited video${saved.length === 1 ? "" : "s"} in ${typeof flags.out === "string" ? flags.out : "edited"}/`);
+        for (const v of failed) say(`Failed: ${v.name}${v.errorMessage ? ` (${v.errorMessage})` : ""}`);
+      }
+      return failed.length || notReady.length ? EXIT.PARTIAL : EXIT.OK;
+    }
+  }
+};
+
+// src/cli.ts
+var VERSION = true ? "1.1.0" : "dev";
+var FLAG_OPTIONS = {
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" },
+  json: { type: "boolean" },
+  yes: { type: "boolean", short: "y" },
+  host: { type: "string" },
+  style: { type: "string", short: "s" },
+  out: { type: "string", short: "o" },
+  watch: { type: "boolean", short: "w" },
+  interval: { type: "string" },
+  captions: { type: "boolean" },
+  emojis: { type: "boolean" },
+  silence: { type: "boolean" },
+  repeats: { type: "boolean" },
+  crop: { type: "string" },
+  zoom: { type: "boolean" },
+  clips: { type: "string" }
+};
+function mainHelp() {
+  const names = Object.keys(commands);
+  const width = Math.max(...names.map((n) => n.length));
+  return [
+    `BatchEdits CLI ${VERSION}: edit up to 50 videos at once.`,
+    "",
+    "Usage: batchedits <command> [options]",
+    "",
+    "Commands:",
+    ...names.map((n) => `  ${n.padEnd(width)}  ${commands[n].summary}`),
+    "",
+    "Options: --json (machine-readable output)  --yes (confirm credit use)  --host <url>  -h, --help",
+    "Auth: batchedits login, or set BATCHEDITS_API_KEY.",
+    "",
+    "Quick start:",
+    "  batchedits login",
+    '  batchedits style create "Shorts" --crop 9:16 --silence --captions --zoom',
+    '  batchedits run ./raw --style "Shorts" --out ./edited',
+    "",
+    "Exit codes: 0 ok \xB7 1 error \xB7 2 usage \xB7 3 sign in needed \xB7 4 some videos failed \xB7 5 needs --yes"
+  ].join("\n");
+}
+function normalizeArgv(argv) {
+  return argv.flatMap((a, i) => a === "--clips" && (argv[i + 1] === void 0 || argv[i + 1].startsWith("-")) ? ["--clips="] : [a]);
+}
+async function main() {
+  const { values, positionals } = (0, import_node_util.parseArgs)({ args: normalizeArgv(process.argv.slice(2)), options: FLAG_OPTIONS, allowPositionals: true, strict: true });
+  const flags = values;
+  if (flags.clips === "") flags.clips = true;
+  setJsonMode(Boolean(flags.json));
+  if (flags.version) {
+    console.log(VERSION);
+    return EXIT.OK;
+  }
+  const two = positionals.slice(0, 2).join(" ");
+  const name = commands[two] ? two : positionals[0];
+  const command = name ? commands[name] : void 0;
+  if (!command) {
+    if (name) info(`Unknown command: ${name}
+`);
+    console.log(mainHelp());
+    return name ? EXIT.USAGE : EXIT.OK;
+  }
+  if (flags.help) {
+    console.log(`${command.usage}
+
+${command.help}`);
+    return EXIT.OK;
+  }
+  const host = resolveHost(typeof flags.host === "string" ? flags.host : void 0);
+  const api = new BatchEdits(host, VERSION);
+  try {
+    return await command.run({ api, host, positionals: positionals.slice(name.split(" ").length), flags });
+  } finally {
+    await api.close();
+  }
+}
+main().then(
+  (code) => process.exit(code),
+  (err) => {
+    const e = err instanceof CliError ? err : new CliError(err?.message ?? String(err), err?.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" ? EXIT.USAGE : EXIT.ERROR);
+    if (isJson()) printJson({ error: e.message, hint: e.hint ?? null, exitCode: e.code });
+    else info(`Error: ${e.message}${e.hint ? `
+${e.hint}` : ""}`);
+    process.exit(e.code);
+  }
+);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "batchedits",
-  "version": "1.0.0",
-  "description": "Official SDK, React Embed Widgets, and CLI for BatchEdits AI Bulk Video Editor",
+  "version": "1.1.0",
+  "description": "BatchEdits CLI, SDK and React widgets: edit up to 50 videos at once from your terminal or AI agent (Claude Code, OpenClaw, Hermes)",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -24,7 +24,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/react.tsx src/cli.ts --format cjs,esm --dts --clean",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -33,7 +34,13 @@
     "auto-captions",
     "react-widget",
     "embed",
-    "cli"
+    "cli",
+    "mcp",
+    "ai-agent",
+    "claude-code",
+    "openclaw",
+    "bulk-video-editor",
+    "silence-remover"
   ],
   "author": "BatchEdits",
   "license": "MIT",
@@ -53,5 +60,11 @@
     "@types/react": "^18.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1"
+  },
+  "engines": {
+    "node": ">=18.17"
   }
 }

package/dist/cli.d.mts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/cli.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/cli.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-console.log("\u{1F680} BatchEdits CLI v1.0.0");
-console.log("Commands available:");
-console.log("  batchedits edit <videoUrl>   - Launch BatchEdits CLI video editor");
-console.log("  batchedits init              - Generate BatchEdits config");