clipbait 1.6.0 → 1.8.0

package/README.md

@@ -1,38 +1,34 @@
 # clipbait
 
-Turn any video into short viral clips — and auto-clip live streams — from your terminal or an AI agent. Wraps the [Clipbait](https://clipbait.ai) API.
+Official CLI + MCP server for [Clipbait](https://clipbait.ai) — the AI video clipping tool for streamers and clippers.
+
+Let Claude (or any MCP-capable agent) turn long videos into viral vertical clips, check your credits, auto-clip live Twitch streams, and download finished clips to disk — on your Clipbait account. Also works as a plain terminal CLI.
+
+## Requires
+
+- **Node.js 18 or higher.**
+- **A paid Clipbait account.** Generate a key at [app.clipbait.ai/me](https://app.clipbait.ai/me) → **Developers / API**. Keys are prefixed `cbk_live_`.
+
+## Install
+
+### Fastest — one command (auto-configures Claude Code + Claude Desktop)
 
-## Fastest start — one command
 ```bash
 npx clipbait@latest
 ```
-It opens Clipbait so you can grab your key, then installs a **`/clipbait`** slash command and connects the Clipbait MCP server to Claude Code. Then just type in Claude:
-```
-/clipbait https://youtube.com/watch?v=...
-```
 
-## Or use it straight from the terminal
+Opens Clipbait so you can copy your key, then installs a `/clipbait` slash command and wires the MCP server into Claude Code and Claude Desktop for you — no JSON to hand-write. Pass the key inline to skip the prompt: `npx clipbait@latest cbk_live_yourkey`. Restart Claude, then type `/clipbait <video url>`.
+
+### Claude Code
+
 ```bash
-npx clipbait login <your_api_key>     # get it at clipbait.ai → Me → Developers / API
-npx clipbait generate "https://youtube.com/watch?v=..." --aspect 9:16 --max 9
-npx clipbait status <jobId>           # get finished clip URLs
+claude mcp add --transport http clipbait https://app.clipbait.ai/api/mcp --header "X-API-Key: cbk_live_your_key_here"
 ```
 
-## Commands
-| Command | Description |
-|---|---|
-| `clipbait` | One-command Claude Code setup (`/clipbait` + MCP) |
-| `clipbait login <apiKey>` | Save your API key (`~/.clipbait.json`) |
-| `clipbait generate <url> [--aspect 9:16] [--type talking_head] [--max 9]` | Generate clips |
-| `clipbait status <jobId>` | Check a job + get clip URLs |
-| `clipbait jobs` | List recent jobs |
-| `clipbait live <twitchUrl> [--cadence 7]` | Start live auto-clipping (Pro) |
-| `clipbait probe <url>` | Get a video's duration |
-
-Auth via `CLIPBAIT_API_KEY` env var or `~/.clipbait.json`. Requires Node 18+.
-
-## MCP server (Claude Desktop, Cursor, Cline, Windsurf)
-This package is also an MCP server. `npx clipbait@latest` auto-configures **Claude Code**. For other clients, add this to their MCP config:
+### Cursor / Cline / Windsurf / manual
+
+Drop this into the client's MCP config file (runs the local stdio server):
+
 ```json
 {
   "mcpServers": {
@@ -44,6 +40,52 @@ This package is also an MCP server. `npx clipbait@latest` auto-configures **Clau
   }
 }
 ```
-Tools: `generate_clips`, `get_job`, `list_recent_clips`, `get_credits`, `start_live_autoclip`, `probe_video`, and **`download_clip`** (saves a finished clip to your `~/Downloads`).
 
-Using **ChatGPT / claude.ai** (URL connectors, no local process)? Point them at the hosted MCP instead: `https://app.clipbait.ai/api/mcp/<your_api_key>`.
+> **ChatGPT / claude.ai** take a remote URL instead of a local process — point them at `https://app.clipbait.ai/api/mcp/<your_api_key>` (nothing runs on your machine, nothing to update).
+
+## Tools
+
+Seven tools are available to any agent:
+
+| Tool | What it does |
+|---|---|
+| `generate_clips` | Start a clipping job (`videoUrl`, optional `aspectRatio` 9:16\|16:9, `maxClips` 1–20). Returns a job id. |
+| `get_job` | Check a job's status and get finished clip URLs (`jobId`). |
+| `list_recent_clips` | List your recent jobs and clip counts. |
+| `get_credits` | Show credits remaining and your plan. No inputs. |
+| `start_live_autoclip` | Auto-clip a **live** Twitch stream continuously (`channelUrl`, optional `cadenceMin`). Pro plan. |
+| `probe_video` | Get a video's duration before clipping (`url`). |
+| `download_clip` | Save a finished clip to your `~/Downloads/` folder and return the path (`jobId`, `clipIndex` 1-based). Max 500 MB. |
+
+## Terminal usage
+
+```bash
+npx clipbait login cbk_live_your_key
+npx clipbait generate "https://youtube.com/watch?v=..." --aspect 9:16 --max 9
+npx clipbait status <jobId>       # get finished clip URLs
+npx clipbait jobs                 # list recent jobs
+npx clipbait live "https://twitch.tv/somestreamer"
+npx clipbait mcp                  # run the stdio MCP server (used in configs above)
+```
+
+Auth via the `CLIPBAIT_API_KEY` env var or `~/.clipbait.json`.
+
+## Security
+
+- **Never commit your `CLIPBAIT_API_KEY`.** Your agent's config file contains a secret — add it to `.gitignore`, or use a secrets manager (1Password CLI, direnv) instead of inline env vars.
+- If you leak your key, rotate it at [app.clipbait.ai/me](https://app.clipbait.ai/me) immediately — the old key stops working at once.
+- `download_clip` links are presigned and expire in ~1 hour. Save clips promptly.
+
+## Pricing
+
+Requires a **paid Clipbait account**. Clip generation spends credits (1 credit ≈ 1 minute of source video). See [clipbait.ai](https://clipbait.ai).
+
+## Links
+
+- Clipbait: https://clipbait.ai
+- API docs: https://app.clipbait.ai/docs
+- Get an API key: https://app.clipbait.ai/me
+
+## License
+
+MIT

package/index.js

@@ -13,6 +13,7 @@ const path = require("path");
 const CFG = path.join(os.homedir(), ".clipbait.json");
 const BASE = (process.env.CLIPBAIT_API_URL || "https://app.clipbait.ai/api").replace(/\/$/, "");
 const KEY_PAGE = "https://app.clipbait.ai/me";
+const MCP_URL = "https://app.clipbait.ai/api/mcp";
 
 // Shown whenever there's no usable key. Written so an AI agent can relay it
 // verbatim to the user and they'll know exactly what to do.
@@ -74,12 +75,14 @@ function prompt(question) {
 // reads MCP servers from ~/.claude.json under projects[cwd].mcpServers (local
 // scope) and, when present, a top-level mcpServers (user scope) — we write
 // both so it shows up regardless of which directory Claude opens in.
-function writeMcpConfig(mcpUrl) {
+function writeMcpConfig(key) {
   const cfgPath = path.join(os.homedir(), ".claude.json");
   let cfg;
   try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); }
   catch { return false; } // no/unreadable config → caller prints manual steps
-  const entry = { type: "http", url: mcpUrl };
+  // Key travels in an X-API-Key header, not the URL path — keeps it out of the
+  // URL (and request logs). It still lives in the config file, same as any MCP.
+  const entry = { type: "http", url: MCP_URL, headers: { "X-API-Key": key } };
   cfg.mcpServers = cfg.mcpServers || {};
   cfg.mcpServers.clipbait = entry;
   const cwd = process.cwd();
@@ -114,55 +117,97 @@ Do this, conversationally and fast:
 5. Then offer follow-ups and act on them by calling the tools again: regenerate at a different aspect ratio, pull more clips, or probe another video with \`probe_video\`.
 `;
 
+// Claude Desktop config path per-OS.
+function desktopConfigPath() {
+  const home = os.homedir();
+  if (process.platform === "darwin") return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return path.join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+
+// Configure Claude Desktop (stdio) if it's installed. Desktop can't use the
+// remote http MCP, and the local stdio server is what enables download_clip.
+// Returns false (silently) when Claude Desktop isn't present.
+function writeDesktopConfig(key) {
+  const cfgPath = desktopConfigPath();
+  try {
+    if (!fs.existsSync(path.dirname(cfgPath))) return false; // Desktop not installed
+    let cfg = {};
+    try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch { /* new file */ }
+    cfg.mcpServers = cfg.mcpServers || {};
+    cfg.mcpServers.clipbait = { command: "npx", args: ["-y", "clipbait@latest", "mcp"], env: { CLIPBAIT_API_KEY: key } };
+    const tmp = cfgPath + ".clipbait.tmp";
+    fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2));
+    fs.renameSync(tmp, cfgPath);
+    return true;
+  } catch { return false; }
+}
+
 // Interactive one-command setup. Grabs the key (from arg / saved / by opening
 // the browser and prompting), installs the /clipbait command, and connects the
-// MCP server to Claude Code.
+// MCP server to Claude Code and Claude Desktop.
+// Print the exact config for the user/agent to apply, WITHOUT touching any
+// files. Used in non-interactive contexts (an agent ran this): silently
+// rewriting global AI-tool config there reads as a supply-chain attack, so we
+// stay transparent and let the caller apply it with full visibility.
+function printManualConfig(key) {
+  console.log("\nTo connect Clipbait, apply one of these (nothing was written — you're not in an interactive terminal):\n");
+  console.log("Claude Code:");
+  console.log(`    claude mcp add --transport http clipbait ${MCP_URL} --header "X-API-Key: ${key}"\n`);
+  console.log("Claude Desktop / Cursor / Cline / Windsurf — add to the MCP config:");
+  console.log(`    ${JSON.stringify({ mcpServers: { clipbait: { command: "npx", args: ["-y", "clipbait@latest", "mcp"], env: { CLIPBAIT_API_KEY: key } } } })}\n`);
+  console.log(`Tip: run \`npx clipbait@latest\` in a real terminal to apply this automatically.\n`);
+}
+
 async function runSetup(providedKey) {
+  const interactive = !!process.stdin.isTTY;
   let key = providedKey && providedKey.startsWith("cbk_") ? providedKey : loadKey();
 
   if (!key) {
+    if (!interactive) { console.error(NEED_KEY); process.exit(1); }
     console.log("\n⚡ Let's connect Clipbait to Claude.");
-    if (!process.stdin.isTTY) {
-      // No interactive terminal (e.g. an AI agent ran this). Print the full
-      // guidance so the agent can pass it straight to the user.
-      console.error(NEED_KEY);
-      process.exit(1);
-    }
     console.log(`\nOpening ${KEY_PAGE} so you can copy your API key…`);
     openBrowser(KEY_PAGE);
     key = (await prompt("\nPaste your API key (starts with cbk_) and press Enter:\n> ")).trim();
   }
+  if (!key || !key.startsWith("cbk_")) { console.error(NEED_KEY); process.exit(1); }
 
-  if (!key || !key.startsWith("cbk_")) {
-    console.error(NEED_KEY);
-    process.exit(1);
-  }
+  // Non-interactive (agent / pipe): don't silently modify global config. Print
+  // it and let the caller apply it with consent.
+  if (!interactive) { printManualConfig(key); return; }
+
+  // Interactive: announce exactly what will change BEFORE writing anything, so
+  // it never looks like a package quietly registering itself.
+  console.log("\n⚡ Clipbait setup will make these changes on this machine:");
+  console.log("  • save your API key to ~/.clipbait.json");
+  console.log("  • install a /clipbait slash command (~/.claude/commands/clipbait.md)");
+  console.log("  • register the Clipbait MCP server in Claude Code (~/.claude.json)");
+  console.log("  • register it in Claude Desktop, if installed\n");
 
   fs.writeFileSync(CFG, JSON.stringify({ apiKey: key }, null, 2));
-  const mcpUrl = "https://app.clipbait.ai/api/mcp/" + key;
 
-  // 1) Install the /clipbait slash command for Claude Code.
   const cmdDir = path.join(os.homedir(), ".claude", "commands");
   fs.mkdirSync(cmdDir, { recursive: true });
   fs.writeFileSync(path.join(cmdDir, "clipbait.md"), SLASH_COMMAND);
   console.log("✓ Installed the /clipbait command for Claude Code");
 
-  // 2) Register the MCP server with Claude Code. Prefer editing the config
-  // file directly (works everywhere); fall back to the `claude` CLI, then to
-  // printing manual steps.
-  if (writeMcpConfig(mcpUrl)) {
-    console.log("✓ Connected the Clipbait MCP server to Claude Code");
+  if (writeMcpConfig(key)) {
+    console.log("✓ Registered the Clipbait MCP server in Claude Code");
   } else {
     const { spawnSync } = require("child_process");
-    const r = spawnSync("claude", ["mcp", "add", "--transport", "http", "clipbait", mcpUrl], { stdio: "ignore" });
+    const r = spawnSync("claude", ["mcp", "add", "--transport", "http", "clipbait", MCP_URL, "--header", `X-API-Key: ${key}`], { stdio: "ignore" });
     if (!r.error && r.status === 0) {
-      console.log("✓ Connected the Clipbait MCP server to Claude Code");
+      console.log("✓ Registered the Clipbait MCP server in Claude Code");
     } else {
-      console.log("• Couldn't auto-connect the MCP server. Add it manually:");
-      console.log("    claude mcp add --transport http clipbait " + mcpUrl);
+      console.log("• Couldn't auto-register the MCP server. Add it manually:");
+      console.log(`    claude mcp add --transport http clipbait ${MCP_URL} --header "X-API-Key: ${key}"`);
     }
   }
 
+  if (writeDesktopConfig(key)) {
+    console.log("✓ Registered Clipbait in Claude Desktop (quit + reopen it to load)");
+  }
+
   console.log("\n🎬 Done! Restart Claude Code, then type:\n    /clipbait https://youtube.com/watch?v=…\n");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clipbait",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Clipbait CLI + MCP server — turn any video into viral clips, and auto-clip live streams, from your terminal or any AI agent.",
   "bin": { "clipbait": "index.js" },
   "type": "commonjs",