makaron-cli 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,341 @@
+# makaron-cli
+
+Talk to **Makaron Agent** from the terminal — create projects, edit images, generate videos, and compose music.
+
+Zero dependencies. Single file. Works with `npx`.
+
+## Install
+
+```bash
+npx makaron-cli          # run directly (always latest)
+# or
+npm install -g makaron-cli
+```
+
+## Authentication
+
+### API Key (recommended for agents)
+
+Set the `MAKARON_API_KEY` environment variable. That's it — no login step needed.
+
+```bash
+export MAKARON_API_KEY=mk_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+npx makaron-cli list
+```
+
+Get your API key from the Makaron dashboard (Settings → API Keys), or ask your admin to generate one.
+
+### Interactive login (humans)
+
+```bash
+npx makaron-cli login
+# Enter email + password → token saved to ~/.makaron/auth.json
+```
+
+The CLI checks `MAKARON_API_KEY` first, then falls back to the saved session in `~/.makaron/auth.json`.
+
+## Commands
+
+### `list` — Show all projects
+
+```bash
+npx makaron-cli list
+```
+
+Output:
+```
+📁 12 projects
+
+  abc123def  My Photo                        3 snaps  2h ago
+  xyz789ghi  Sunset Edit                     5 snaps  1d ago
+```
+
+### `create` — Create a new project
+
+```bash
+# From local image file(s)
+npx makaron-cli create --image photo.jpg
+npx makaron-cli create --image img1.jpg --image img2.jpg
+
+# From URL(s)
+npx makaron-cli create --image-url https://example.com/photo.jpg
+
+# Empty project (for text-to-image)
+npx makaron-cli create --title "My New Project"
+```
+
+Output:
+```
+✅ Project created
+   ID: abc123def456
+   Images: 1
+   [1] https://sdyrtztrjgmmpnirswxt.supabase.co/storage/v1/object/public/images/...
+   URL: https://www.makaron.app/projects/abc123def456
+```
+
+### `chat` — Send a message to Makaron Agent
+
+This is the main command. The Agent can edit images, generate videos, compose music, and create designs.
+
+```bash
+npx makaron-cli chat --project <id> "make it look cinematic"
+```
+
+The Agent streams its response in real-time:
+- **Text** → stdout (pipe-friendly)
+- **Status/progress** → stderr
+- **Images, videos, music** → URLs printed to stderr
+
+```bash
+# Add extra reference images to the project before chatting
+npx makaron-cli chat --project <id> --image ref.jpg "use this style"
+```
+
+After the Agent finishes, the CLI automatically polls for any pending video/music tasks until they complete.
+
+### `abort` — Stop a running Agent
+
+```bash
+npx makaron-cli abort <runId>
+```
+
+Press `Ctrl+C` during `chat` to abort automatically.
+
+### `edit` — AI image editing (direct MCP tool call)
+
+Unlike `chat` (which uses the Agent with project context), `edit` directly calls the image generation model for one-shot results.
+
+```bash
+# Text-to-image (no input image)
+npx makaron-cli edit "a cyberpunk cityscape at night, neon reflections"
+
+# Edit an existing image
+npx makaron-cli edit --image photo.jpg "add cinematic warm lighting"
+
+# With model and skill
+npx makaron-cli edit --image photo.jpg --model openai --skill captions "add elegant title"
+
+# With reference images (up to 3)
+npx makaron-cli edit --image photo.jpg --ref style1.jpg --ref style2.jpg "match this style"
+
+# Specify output path and aspect ratio
+npx makaron-cli edit --out result.jpg --aspect 9:16 "vertical poster design"
+```
+
+Options:
+- `--image <file|url>` — input image (omit for text-to-image)
+- `--model gemini|qwen|openai|pony|wai` — model selection (default: auto)
+- `--skill enhance|creative|wild|captions` — activate skill template
+- `--ref <file|url>` — reference image (repeatable, up to 3)
+- `--aspect <ratio>` — target aspect ratio (e.g. `4:5`, `1:1`, `16:9`)
+- `--out <path>` — output file path (default: `makaron-output-{timestamp}.jpg`)
+
+Output: saves image to local file, prints the file path to stdout.
+
+### `video` — Video generation
+
+```bash
+# Write a video script from images
+npx makaron-cli video script --image img1.jpg --image img2.jpg "cinematic story"
+npx makaron-cli video script --image img1.jpg --image img2.jpg --lang zh "电影感故事"
+
+# Submit video rendering (images must be public URLs)
+npx makaron-cli video create --script "Shot 1..." --image https://...img1.jpg --duration 10
+npx makaron-cli video create --script-file script.txt --image https://...jpg --model seedance
+
+# Check status
+npx makaron-cli video status <taskId>
+```
+
+Options for `video create`:
+- `--script "..."` or `--script-file <path>` — video script
+- `--image <url>` — public image URL (repeatable, up to 7)
+- `--duration 3|5|7|10|15` — seconds (omit for smart mode)
+- `--aspect 9:16|16:9|1:1` — aspect ratio
+- `--model kling|seedance` — video model (default: kling)
+
+### `music` — Music generation
+
+```bash
+# Generate instrumental music
+npx makaron-cli music create "gentle piano, warm strings, cinematic"
+
+# With vocals and style
+npx makaron-cli music create --vocals --style "lo-fi, ambient" "rainy day vibes"
+
+# Check status
+npx makaron-cli music status <taskId>
+```
+
+Options for `music create`:
+- `--vocals` — include vocals (default: instrumental only)
+- `--style "genre"` — genre/mood tags
+
+## Example: Full workflow
+
+```bash
+# 1. Login (once)
+npx makaron-cli login
+
+# 2. Create a project from a photo
+npx makaron-cli create --image my-photo.jpg
+# → ID: proj_abc123
+
+# 3. Edit the image
+npx makaron-cli chat --project proj_abc123 "add dramatic lighting and film grain"
+
+# 4. Generate a video from the result
+npx makaron-cli chat --project proj_abc123 "make a 5 second cinematic video"
+
+# 5. Add background music
+npx makaron-cli chat --project proj_abc123 "add epic orchestral background music"
+```
+
+## Agent Integration Guide
+
+For AI agents (Claude Code, Cursor, etc.) calling this CLI programmatically:
+
+### Setup (one-time)
+
+```bash
+export MAKARON_API_KEY=mk_live_your_key_here
+npx makaron-cli list   # verify it works
+```
+
+### Best practices
+
+1. **Always capture the project ID** from `create` output — you need it for all `chat` commands
+2. **One instruction per `chat` call** — the Agent handles complex requests, but single clear instructions work best
+3. **Check results via the URL** — every project has a web URL at `https://www.makaron.app/projects/<id>`
+4. **Video generation takes 2-5 minutes** — the CLI auto-polls and prints the URL when done
+5. **Music generation takes ~60 seconds** — also auto-polled
+
+### What the Agent can do
+
+| Capability | Example prompt |
+|-----------|---------------|
+| Image editing | "make the sky more dramatic" |
+| Style transfer | "convert to oil painting style" |
+| Add elements | "add a cat sitting on the table" |
+| Remove elements | "remove the person in the background" |
+| Text-to-image | "generate a cyberpunk cityscape" (on empty project) |
+| Video from image | "create a 5 second video" |
+| Video with script | "make a video: camera slowly zooms in while leaves fall" |
+| Background music | "add calm piano music" |
+| Design/motion graphics | "create an Instagram story with animated text" |
+
+### Output parsing
+
+- **stdout** = Agent's text response (markdown)
+- **stderr** = progress, tool calls, result URLs
+- Key patterns in stderr:
+  - `🖼️  Image: <url>` — generated/edited image URL
+  - `🎬 Video done (<seconds>s): <url>` — completed video URL
+  - `🎵 Music done (<seconds>s): <url>` — completed music URL
+  - `🎨 Design published: <description>` — motion graphic/design created
+  - `🔗  <url>` — project web URL (always last)
+
+### Environment variables
+
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `MAKARON_API_KEY` | API key (`mk_live_xxx`) | — |
+| `MAKARON_URL` | API endpoint override | `https://www.makaron.app` |
+
+## Viewing results
+
+All generated content (images, videos, designs) is saved to the project and visible at:
+
+```
+https://www.makaron.app/projects/<project-id>
+```
+
+Open this URL in a browser to see the timeline of all edits, play videos, and download assets.
+
+## Admin: Skill Marketplace Operations
+
+Admin commands require an API key with admin privileges. Ask your admin to run `makaron admin set-admin <your-email>` to grant access.
+
+### List all marketplace skills
+
+```bash
+npx makaron-cli admin skills
+```
+
+### Upload assets to Storage
+
+```bash
+# Upload cover image (3:4 aspect ratio recommended)
+npx makaron-cli admin upload cover.jpg marketplace/covers/skill-name.jpg
+
+# Upload before photo
+npx makaron-cli admin upload before.jpg marketplace/before/before-name.jpg
+
+# Upload skill zip
+npx makaron-cli admin upload skill.zip marketplace/skills/skill-name.zip
+```
+
+Storage paths follow this convention:
+- Covers: `marketplace/covers/<skill-name>.jpg` (or `.mp4` for video covers)
+- Before images: `marketplace/before/<name>.jpg`
+- Skill zips: `marketplace/skills/<skill-name>.zip`
+
+### Add a new skill to marketplace
+
+```bash
+npx makaron-cli admin skills add '{
+  "labels": {"zh": "中文名", "en": "English Name"},
+  "image": "https://sdyrtztrjgmmpnirswxt.supabase.co/storage/v1/object/public/images/marketplace/covers/skill-name.jpg",
+  "prompt": "Default prompt shown to users",
+  "skill_path": "https://sdyrtztrjgmmpnirswxt.supabase.co/storage/v1/object/public/images/marketplace/skills/skill-name.zip",
+  "image_count": 2,
+  "sort_order": 10,
+  "is_active": true,
+  "before_images": ["https://sdyrtztrjgmmpnirswxt.supabase.co/storage/v1/object/public/images/marketplace/before/before-name.jpg"]
+}'
+```
+
+### Update / delete a skill
+
+```bash
+npx makaron-cli admin skills update <id> '{"sort_order": 5, "is_active": false}'
+npx makaron-cli admin skills delete <id>
+```
+
+### Download skill from share link
+
+```bash
+# From share code
+npx makaron-cli admin fetch-skill 4c4cbd57
+
+# From full URL
+npx makaron-cli admin fetch-skill https://www.makaron.app/s/4c4cbd57
+
+# → Creates ./skill-name/ directory with SKILL.md + assets/
+```
+
+### End-to-end skill launch workflow
+
+0. **Get skill from share link** — `npx makaron-cli admin fetch-skill <code>`
+1. **Read SKILL.md** — understand the skill's variables, prompt template, and output format
+2. **Generate before photo** — use Makaron MCP `makaron_edit_image` to generate a plain selfie (no phone in frame, natural light)
+3. **Generate cover photo** — use `makaron_edit_image` following the SKILL.md variables/style closely. Match gender pairing (female idol → male fan, male idol → female fan)
+4. **Package zip** — `zip skill-name.zip SKILL.md` (video reference URLs go in SKILL.md metadata, not in the zip)
+5. **Upload all assets**:
+   ```bash
+   npx makaron-cli admin upload cover.jpg marketplace/covers/skill-name.jpg
+   npx makaron-cli admin upload before.jpg marketplace/before/skill-name-before.jpg
+   npx makaron-cli admin upload skill-name.zip marketplace/skills/skill-name.zip
+   ```
+6. **Add to marketplace**:
+   ```bash
+   npx makaron-cli admin skills add '{"labels":{"zh":"...","en":"..."},"image":"<cover_url>","skill_path":"<zip_url>","before_images":["<before_url>"],"image_count":2,"sort_order":10,"is_active":true}'
+   ```
+7. **Verify** — visit https://www.makaron.app/home and confirm the skill appears, can be clicked, and works
+
+### Cover image guidelines
+
+- Target aspect ratio: **3:4** (marketplace cards use `object-fit: cover`)
+- 16:9 images will be severely cropped — resize or stack two 16:9 images vertically
+- Video covers (`.mp4`) are supported — auto-play in the card
+- Before photo should match the person in the cover (hair, clothing, accessories)

package/bin/makaron.mjs

@@ -83,23 +83,54 @@ function getAuthCookie() {
     console.error('Not logged in. Run: npx makaron-cli login');
     process.exit(1);
   }
-  return { cookie: buildCookie(auth), baseUrl: auth._baseUrl || BASE_URL };
+  return { cookie: buildCookie(auth), baseUrl: process.env.MAKARON_URL || auth._baseUrl || BASE_URL };
+}
+
+function getAuth() {
+  const apiKey = process.env.MAKARON_API_KEY;
+  if (apiKey) {
+    return {
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+      baseUrl: process.env.MAKARON_URL || DEFAULT_URL,
+    };
+  }
+  const auth = loadAuth();
+  if (!auth) {
+    console.error('Not logged in. Set MAKARON_API_KEY or run: npx makaron-cli login');
+    process.exit(1);
+  }
+  return {
+    headers: { 'Cookie': buildCookie(auth) },
+    baseUrl: process.env.MAKARON_URL || auth._baseUrl || BASE_URL,
+  };
 }
 
 // ─── SSE Consumer ────────────────────────────────────────────────────────────
 
-async function streamAgent(baseUrl, cookie, projectId, prompt) {
+async function abortRun(baseUrl, headers, runId) {
+  try {
+    await fetch(`${baseUrl}/api/agent/abort`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...headers },
+      body: JSON.stringify({ runId }),
+    });
+  } catch { /* best effort */ }
+}
+
+async function streamAgent(baseUrl, headers, projectId, prompt) {
+  const controller = new AbortController();
   const res = await fetch(`${baseUrl}/api/agent`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
-      'Cookie': cookie,
+      ...headers,
     },
     body: JSON.stringify({
       projectId,
       prompt,
       headless: true,
     }),
+    signal: controller.signal,
   });
 
   if (!res.ok) {
@@ -112,6 +143,15 @@ async function streamAgent(baseUrl, cookie, projectId, prompt) {
   const decoder = new TextDecoder();
   let buffer = '';
 
+  // Ctrl+C → abort agent on server, then exit
+  const sigintHandler = async () => {
+    process.stderr.write('\n⏹️  Aborting...\n');
+    controller.abort();
+    if (runId) await abortRun(baseUrl, headers, runId);
+    process.exit(0);
+  };
+  process.on('SIGINT', sigintHandler);
+
   const results = { images: [], designs: [], animationTasks: [], musicTasks: [], text: '' };
 
   while (true) {
@@ -139,7 +179,9 @@ async function streamAgent(baseUrl, cookie, projectId, prompt) {
 
         case 'tool_call':
           process.stderr.write(`\n🔧 ${event.tool}`);
-          if (event.input?.editPrompt) process.stderr.write(`: ${event.input.editPrompt.substring(0, 80)}`);
+          if (event.input?.editPrompt) process.stderr.write(`\n   editPrompt: ${event.input.editPrompt}`);
+          if (event.input?.model) process.stderr.write(`\n   model: ${event.input.model}`);
+          if (event.input?.skill) process.stderr.write(`\n   skill: ${event.input.skill}`);
           if (event.input?.description) process.stderr.write(`: ${event.input.description.substring(0, 80)}`);
           process.stderr.write('\n');
           break;
@@ -179,20 +221,21 @@ async function streamAgent(baseUrl, cookie, projectId, prompt) {
     }
   }
 
+  process.removeListener('SIGINT', sigintHandler);
   if (results.text) process.stdout.write('\n');
   return { runId, results };
 }
 
 // ─── Async Task Polling ──────────────────────────────────────────────────────
 
-async function pollVideo(baseUrl, cookie, taskId) {
+async function pollVideo(baseUrl, headers, taskId) {
   process.stderr.write(`🎬 Waiting for video ${taskId}...\n`);
   const start = Date.now();
   while (true) {
     await new Promise(r => setTimeout(r, 10_000));
     const elapsed = Math.round((Date.now() - start) / 1000);
     try {
-      const res = await fetch(`${baseUrl}/api/animate/${taskId}`, { headers: { 'Cookie': cookie } });
+      const res = await fetch(`${baseUrl}/api/animate/${taskId}`, { headers });
       if (!res.ok) continue;
       const data = await res.json();
       if (data.videoUrl) { process.stderr.write(`\r🎬 Video done (${elapsed}s): ${data.videoUrl}\n`); return data.videoUrl; }
@@ -203,14 +246,14 @@ async function pollVideo(baseUrl, cookie, taskId) {
   }
 }
 
-async function pollMusic(baseUrl, cookie, taskId) {
+async function pollMusic(baseUrl, headers, taskId) {
   process.stderr.write(`🎵 Waiting for music ${taskId}...\n`);
   const start = Date.now();
   while (true) {
     await new Promise(r => setTimeout(r, 5_000));
     const elapsed = Math.round((Date.now() - start) / 1000);
     try {
-      const res = await fetch(`${baseUrl}/api/music/${taskId}`, { headers: { 'Cookie': cookie } });
+      const res = await fetch(`${baseUrl}/api/music/${taskId}`, { headers });
       if (!res.ok) continue;
       const data = await res.json();
       const trackUrl = data.audioUrl || data.tracks?.[0]?.audioUrl;
@@ -235,7 +278,7 @@ async function pollMusic(baseUrl, cookie, taskId) {
 
 // ─── Create Project ──────────────────────────────────────────────────────────
 
-async function createProject(baseUrl, cookie, opts) {
+async function createProject(baseUrl, headers, opts) {
   const body = {};
   if (opts.imageUrls?.length) {
     body.imageUrls = opts.imageUrls;
@@ -254,7 +297,7 @@ async function createProject(baseUrl, cookie, opts) {
 
   const res = await fetch(`${baseUrl}/api/projects/create`, {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'Cookie': cookie },
+    headers: { 'Content-Type': 'application/json', ...headers },
     body: JSON.stringify(body),
   });
 
@@ -273,8 +316,8 @@ async function createProject(baseUrl, cookie, opts) {
 
 // ─── List Projects ───────────────────────────────────────────────────────────
 
-async function listProjects(baseUrl, cookie) {
-  const res = await fetch(`${baseUrl}/api/projects/list`, { headers: { 'Cookie': cookie } });
+async function listProjects(baseUrl, headers) {
+  const res = await fetch(`${baseUrl}/api/projects/list`, { headers });
   if (!res.ok) { console.error('List failed:', await res.text()); process.exit(1); }
   const { projects } = await res.json();
   if (!projects.length) { console.log('No projects yet. Create one with: makaron create --image <file>'); return; }
@@ -294,6 +337,43 @@ function timeSince(date) {
   return `${Math.floor(s / 86400)}d ago`;
 }
 
+// ─── MCP Tool Caller ─────────────────────────────────────────────────────────
+
+async function callMcpTool(baseUrl, headers, toolName, args) {
+  const res = await fetch(`${baseUrl}/api/mcp`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Accept': 'application/json, text/event-stream', ...headers },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: toolName, arguments: args } }),
+  });
+  if (!res.ok) { console.error(`MCP error ${res.status}:`, await res.text()); process.exit(1); }
+  const data = await res.json();
+  if (data.error) { console.error(`MCP error:`, data.error.message); process.exit(1); }
+  return data.result;
+}
+
+function imageToArg(imgPath) {
+  if (imgPath.startsWith('http://') || imgPath.startsWith('https://')) return imgPath;
+  const buf = fs.readFileSync(imgPath);
+  const ext = imgPath.split('.').pop()?.toLowerCase();
+  const mime = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp' }[ext] || 'image/jpeg';
+  return `data:${mime};base64,${buf.toString('base64')}`;
+}
+
+function saveMcpImage(result, outputPath) {
+  const content = result?.content || [];
+  const textBlock = content.find(c => c.type === 'text');
+  const imageBlock = content.find(c => c.type === 'image');
+  if (textBlock) process.stderr.write(`${textBlock.text}\n`);
+  if (imageBlock) {
+    const out = outputPath || `makaron-output-${Date.now()}.jpg`;
+    fs.writeFileSync(out, Buffer.from(imageBlock.data, 'base64'));
+    console.log(out);
+    return out;
+  }
+  if (textBlock) console.log(textBlock.text);
+  return null;
+}
+
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 const args = process.argv.slice(2);
@@ -302,7 +382,7 @@ const command = args[0];
 if (command === 'login') {
   await login();
 } else if (command === 'create') {
-  const { cookie, baseUrl } = getAuthCookie();
+  const { headers, baseUrl } = getAuth();
   const opts = { images: [], imageUrls: [] };
   for (let i = 1; i < args.length; i++) {
     if (args[i] === '--image' && args[i + 1]) opts.images.push(args[++i]);
@@ -315,9 +395,9 @@ if (command === 'login') {
     console.error('Usage: makaron create --image <file> [--image <file2>] or --title "name"');
     process.exit(1);
   }
-  await createProject(baseUrl, cookie, opts);
+  await createProject(baseUrl, headers, opts);
 } else if (command === 'chat') {
-  const { cookie, baseUrl } = getAuthCookie();
+  const { headers, baseUrl } = getAuth();
   let projectId = null;
   const chatImages = [];
   const promptParts = [];
@@ -339,7 +419,7 @@ if (command === 'login') {
     });
     const res = await fetch(`${baseUrl}/api/projects/create`, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Cookie': cookie },
+      headers: { 'Content-Type': 'application/json', ...headers },
       body: JSON.stringify({ imageBase64s: base64s, _addToProject: projectId }),
     });
     if (res.ok) {
@@ -349,16 +429,264 @@ if (command === 'login') {
       process.stderr.write(`⚠️ Failed to upload images: ${await res.text()}\n`);
     }
   }
-  const { results } = await streamAgent(baseUrl, cookie, projectId, prompt);
+  const { results } = await streamAgent(baseUrl, headers, projectId, prompt);
   process.stderr.write('\n━━━ Results ━━━\n');
   for (const img of results.images) process.stderr.write(`🖼️  Image: ${img.imageUrl}\n`);
   for (const d of results.designs) process.stderr.write(`🎨  ${d.desc}\n`);
   process.stderr.write(`🔗  ${APP_URL}/projects/${projectId}\n`);
-  for (const task of results.animationTasks) await pollVideo(baseUrl, cookie, task.taskId);
-  for (const task of results.musicTasks) await pollMusic(baseUrl, cookie, task.taskId);
+  for (const task of results.animationTasks) await pollVideo(baseUrl, headers, task.taskId);
+  for (const task of results.musicTasks) await pollMusic(baseUrl, headers, task.taskId);
 } else if (command === 'list' || command === 'ls') {
-  const { cookie, baseUrl } = getAuthCookie();
-  await listProjects(baseUrl, cookie);
+  const { headers, baseUrl } = getAuth();
+  await listProjects(baseUrl, headers);
+} else if (command === 'abort') {
+  const { headers, baseUrl } = getAuth();
+  const runId = args[1];
+  if (!runId) {
+    console.error('Usage: makaron abort <runId>');
+    process.exit(1);
+  }
+  const res = await fetch(`${baseUrl}/api/agent/abort`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...headers },
+    body: JSON.stringify({ runId }),
+  });
+  if (res.ok) {
+    console.log(`✅ Run ${runId} aborted`);
+  } else {
+    console.error(`❌ Abort failed:`, await res.text());
+  }
+} else if (command === 'edit') {
+  const { headers, baseUrl } = getAuth();
+  const editArgs = {};
+  const promptParts = [];
+  let outputPath = null;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--image' && args[i + 1]) editArgs.image = imageToArg(args[++i]);
+    else if (args[i] === '--model' && args[i + 1]) editArgs.model = args[++i];
+    else if (args[i] === '--skill' && args[i + 1]) editArgs.skill = args[++i];
+    else if (args[i] === '--ref' && args[i + 1]) {
+      editArgs.referenceImages = editArgs.referenceImages || [];
+      editArgs.referenceImages.push(imageToArg(args[++i]));
+    }
+    else if (args[i] === '--aspect' && args[i + 1]) editArgs.aspectRatio = args[++i];
+    else if (args[i] === '--out' && args[i + 1]) outputPath = args[++i];
+    else promptParts.push(args[i]);
+  }
+  editArgs.editPrompt = promptParts.join(' ');
+  if (!editArgs.editPrompt) { console.error('Usage: makaron edit [--image <file|url>] [--model gemini|qwen|openai] [--skill enhance|creative|wild|captions] [--ref <file>] [--out <file>] "prompt"'); process.exit(1); }
+  process.stderr.write('🎨 Generating...\n');
+  const result = await callMcpTool(baseUrl, headers, 'makaron_edit_image', editArgs);
+  saveMcpImage(result, outputPath);
+
+} else if (command === 'video') {
+  const { headers, baseUrl } = getAuth();
+  const sub = args[1];
+
+  if (sub === 'script') {
+    const images = [];
+    const promptParts = [];
+    let language = 'en';
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === '--image' && args[i + 1]) images.push(imageToArg(args[++i]));
+      else if (args[i] === '--lang' && args[i + 1]) language = args[++i];
+      else promptParts.push(args[i]);
+    }
+    if (!images.length) { console.error('Usage: makaron video script --image <file> [--image <file>] [--lang en|zh] "direction"'); process.exit(1); }
+    process.stderr.write('🎬 Writing script...\n');
+    const result = await callMcpTool(baseUrl, headers, 'makaron_write_video_script', { images, userRequest: promptParts.join(' ') || undefined, language });
+    const text = result?.content?.find(c => c.type === 'text')?.text;
+    if (text) console.log(text);
+
+  } else if (sub === 'create') {
+    const images = [];
+    let script = '', duration = undefined, aspectRatio = undefined, videoModel = undefined;
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === '--image' && args[i + 1]) images.push(args[++i]);
+      else if (args[i] === '--script' && args[i + 1]) script = args[++i];
+      else if (args[i] === '--script-file' && args[i + 1]) script = fs.readFileSync(args[++i], 'utf-8');
+      else if (args[i] === '--duration' && args[i + 1]) duration = Number(args[++i]);
+      else if (args[i] === '--aspect' && args[i + 1]) aspectRatio = args[++i];
+      else if (args[i] === '--model' && args[i + 1]) videoModel = args[++i];
+    }
+    if (!images.length || !script) { console.error('Usage: makaron video create --script "..." --image <url> [--duration 10] [--aspect 9:16] [--model kling|seedance]'); process.exit(1); }
+    process.stderr.write('🎬 Submitting video...\n');
+    const vArgs = { script, images };
+    if (duration) vArgs.duration = duration;
+    if (aspectRatio) vArgs.aspectRatio = aspectRatio;
+    if (videoModel) vArgs.videoModel = videoModel;
+    const result = await callMcpTool(baseUrl, headers, 'makaron_create_video', vArgs);
+    const text = result?.content?.find(c => c.type === 'text')?.text;
+    if (text) console.log(text);
+
+  } else if (sub === 'status') {
+    const taskId = args[2];
+    if (!taskId) { console.error('Usage: makaron video status <taskId>'); process.exit(1); }
+    const result = await callMcpTool(baseUrl, headers, 'makaron_get_video_status', { taskId });
+    const text = result?.content?.find(c => c.type === 'text')?.text;
+    if (text) console.log(text);
+
+  } else {
+    console.log(`Video commands:
+  video script --image <file> [--image <file>] "direction"   Write video script
+  video create --script "..." --image <url> [--duration 10]  Submit video task
+  video status <taskId>                                      Check video status
+`);
+  }
+
+} else if (command === 'music') {
+  const { headers, baseUrl } = getAuth();
+  const sub = args[1];
+
+  if (sub === 'create') {
+    const promptParts = [];
+    let instrumental = true, style = undefined;
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === '--vocals') instrumental = false;
+      else if (args[i] === '--style' && args[i + 1]) style = args[++i];
+      else promptParts.push(args[i]);
+    }
+    const prompt = promptParts.join(' ');
+    if (!prompt) { console.error('Usage: makaron music create [--vocals] [--style "lo-fi"] "gentle piano"'); process.exit(1); }
+    process.stderr.write('🎵 Generating music...\n');
+    const mArgs = { prompt, instrumental };
+    if (style) mArgs.style = style;
+    const result = await callMcpTool(baseUrl, headers, 'makaron_create_music', mArgs);
+    const text = result?.content?.find(c => c.type === 'text')?.text;
+    if (text) console.log(text);
+
+  } else if (sub === 'status') {
+    const taskId = args[2];
+    if (!taskId) { console.error('Usage: makaron music status <taskId>'); process.exit(1); }
+    const result = await callMcpTool(baseUrl, headers, 'makaron_get_music_status', { taskId });
+    const text = result?.content?.find(c => c.type === 'text')?.text;
+    if (text) console.log(text);
+
+  } else {
+    console.log(`Music commands:
+  music create [--vocals] [--style "genre"] "description"    Generate music
+  music status <taskId>                                      Check music status
+`);
+  }
+
+} else if (command === 'admin') {
+  const { headers, baseUrl } = getAuth();
+  const sub = args[1];
+
+  if (sub === 'skills') {
+    const action = args[2]; // add, update, delete, or none (list)
+    if (!action) {
+      // List all skills
+      const res = await fetch(`${baseUrl}/api/admin/home-skills`, { headers });
+      if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+      const skills = await res.json();
+      console.log(`📋 ${skills.length} skills\n`);
+      for (const s of skills) {
+        const label = s.labels?.en || s.labels?.zh || '(no label)';
+        const active = s.is_active ? '✅' : '❌';
+        const hasZip = s.skill_path ? '📦' : '  ';
+        console.log(`  ${active} ${hasZip} ${String(s.sort_order).padStart(3)}  ${s.id}  ${label}`);
+      }
+    } else if (action === 'add') {
+      const json = args.slice(3).join(' ');
+      if (!json) { console.error('Usage: makaron admin skills add \'{"labels":...,"image":"..."}\''); process.exit(1); }
+      let body;
+      try { body = JSON.parse(json); } catch { console.error('Invalid JSON'); process.exit(1); }
+      const res = await fetch(`${baseUrl}/api/admin/home-skills`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json', ...headers }, body: JSON.stringify(body),
+      });
+      if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+      const data = await res.json();
+      console.log(`✅ Skill created: ${data.id}`);
+    } else if (action === 'update') {
+      const id = args[3];
+      const json = args.slice(4).join(' ');
+      if (!id || !json) { console.error('Usage: makaron admin skills update <id> \'{"field":"value"}\''); process.exit(1); }
+      let body;
+      try { body = JSON.parse(json); } catch { console.error('Invalid JSON'); process.exit(1); }
+      body.id = id;
+      const res = await fetch(`${baseUrl}/api/admin/home-skills`, {
+        method: 'PUT', headers: { 'Content-Type': 'application/json', ...headers }, body: JSON.stringify(body),
+      });
+      if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+      console.log(`✅ Skill ${id} updated`);
+    } else if (action === 'delete') {
+      const id = args[3];
+      if (!id) { console.error('Usage: makaron admin skills delete <id>'); process.exit(1); }
+      const res = await fetch(`${baseUrl}/api/admin/home-skills`, {
+        method: 'DELETE', headers: { 'Content-Type': 'application/json', ...headers }, body: JSON.stringify({ id }),
+      });
+      if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+      console.log(`✅ Skill ${id} deleted`);
+    } else {
+      console.error(`Unknown action: ${action}. Use: add, update, delete, or omit to list.`);
+      process.exit(1);
+    }
+
+  } else if (sub === 'upload') {
+    const filePath = args[2];
+    const storagePath = args[3];
+    if (!filePath || !storagePath) { console.error('Usage: makaron admin upload <local-file> <storage-path>'); process.exit(1); }
+    if (!fs.existsSync(filePath)) { console.error(`File not found: ${filePath}`); process.exit(1); }
+
+    const buf = fs.readFileSync(filePath);
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const mimeMap = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp', mp4: 'video/mp4', zip: 'application/zip' };
+    const mime = mimeMap[ext] || 'application/octet-stream';
+
+    const formData = new FormData();
+    formData.append('file', new Blob([buf], { type: mime }), path.basename(filePath));
+    formData.append('path', storagePath);
+
+    const res = await fetch(`${baseUrl}/api/admin/upload`, { method: 'POST', headers, body: formData });
+    if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+    const { url } = await res.json();
+    console.log(`✅ Uploaded: ${url}`);
+
+  } else if (sub === 'fetch-skill') {
+    const code = args[2];
+    if (!code) { console.error('Usage: makaron admin fetch-skill <share-code>'); process.exit(1); }
+    // Extract code from full URL if given (e.g., https://www.makaron.app/s/4c4cbd57)
+    const shareCode = code.includes('/s/') ? code.split('/s/').pop() : code;
+
+    const res = await fetch(`${baseUrl}/api/skills/share/${shareCode}/download?format=json`, { headers });
+    if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+    const { skillName, files } = await res.json();
+
+    // Create output directory
+    const outDir = path.resolve(skillName);
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+    for (const f of files) {
+      const filePath = path.join(outDir, f.path);
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(filePath, Buffer.from(f.data, 'base64'));
+    }
+
+    console.log(`✅ Skill "${skillName}" downloaded to ./${skillName}/`);
+    console.log(`   Files: ${files.map(f => f.path).join(', ')}`);
+
+  } else if (sub === 'set-admin') {
+    const email = args[2];
+    if (!email) { console.error('Usage: makaron admin set-admin <email>'); process.exit(1); }
+    const res = await fetch(`${baseUrl}/api/admin/set-admin`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json', ...headers }, body: JSON.stringify({ email }),
+    });
+    if (!res.ok) { console.error(`Error ${res.status}:`, await res.text()); process.exit(1); }
+    console.log(`✅ ${email} is now admin`);
+
+  } else {
+    console.log(`Admin commands:
+  admin skills                         List all marketplace skills
+  admin skills add '<json>'            Add a new skill
+  admin skills update <id> '<json>'    Update a skill
+  admin skills delete <id>             Delete a skill
+  admin upload <file> <storage-path>   Upload file to Storage
+  admin fetch-skill <code|url>         Download skill from share link
+  admin set-admin <email>              Grant admin access to a user
+`);
+  }
 } else {
   console.log(`Makaron CLI — Talk to Makaron Agent from the terminal
 
@@ -370,8 +698,16 @@ Commands:
   create --title "name"              Create empty project (text-to-image)
   chat --project <id> "message"      Chat with Makaron Agent
   chat --project <id> --image <file> "message"  Add image + chat
+  abort <runId>                      Abort a running Agent
+
+  edit [--image <file>] "prompt"     AI image edit / text-to-image
+  video script|create|status         Video generation
+  music create|status                Music generation
+
+  admin                              Admin commands (skills, upload, set-admin)
 
 Environment:
+  MAKARON_API_KEY  API key (mk_live_xxx) — recommended for agents
   MAKARON_URL      API base (default: ${DEFAULT_URL})
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makaron-cli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Talk to Makaron Agent from the terminal — create projects, edit images, generate videos",
   "type": "module",
   "bin": {
@@ -9,7 +9,14 @@
   "files": [
     "bin/"
   ],
-  "keywords": ["makaron", "ai", "image-editing", "video", "cli", "agent"],
+  "keywords": [
+    "makaron",
+    "ai",
+    "image-editing",
+    "video",
+    "cli",
+    "agent"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",