skillfree 0.1.0

package/SKILL.md

@@ -0,0 +1,37 @@
+# SkillFree Skill
+
+## 功能
+
+SkillFree 是一个统一的 AI 能力调用层。通过一个 API Key，调用图像生成、语音合成、视频生成、智能对话等多种 AI 能力。
+
+## 使用方式
+
+```bash
+# 对话（1 积分）
+skillfree pilot --type chat --prompt "帮我写一首诗"
+
+# 图像生成（5 积分）
+skillfree pilot --type image --prompt "赛博朋克的上海" --output ./out.png
+
+# 语音合成（2 积分）
+skillfree pilot --type tts --text "你好，龙虾" --output hello.mp3
+
+# 视频生成（20 积分）
+skillfree pilot --type video --prompt "海浪拍打礁石" --output ./video.mp4
+```
+
+## 配置
+
+```bash
+export SKILLFREE_API_KEY=sk-sf-xxxxxxxx
+```
+
+或通过登录：
+
+```bash
+skillfree auth login
+```
+
+## 充值
+
+充多少用多少，积分永不过期：https://skillfree.ai/billing

package/bin/skillfree.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// skillfree CLI 入口
+
+const { program } = require('commander')
+const pkg = require('../package.json')
+
+program
+  .name('skillfree')
+  .description('🦞 一个 API，满足所有龙虾技能需求')
+  .version(pkg.version)
+
+// ── auth ──────────────────────────────────────────────────────────────────────
+const auth = program.command('auth').description('账号管理')
+auth
+  .command('login')
+  .description('登录并保存 API Key')
+  .action(async () => {
+    const { authLogin } = require('../scripts/commands/auth')
+    await authLogin()
+  })
+auth
+  .command('status')
+  .description('查看当前登录状态和积分')
+  .action(async () => {
+    const { authStatus } = require('../scripts/commands/auth')
+    await authStatus()
+  })
+
+// ── pilot ─────────────────────────────────────────────────────────────────────
+program
+  .command('pilot')
+  .description('AI 智能调度，支持 chat / image / tts / stt / video / music')
+  .option('--type <type>',    '调用类型: chat | image | tts | stt | video | music', 'chat')
+  .option('--prompt <text>',  '输入提示词')
+  .option('--text <text>',    '文字内容（tts 用）')
+  .option('--file <path>',    '输入文件路径（stt 用）')
+  .option('--output <path>',  '输出文件路径')
+  .option('--model <model>',  '指定模型（可选）')
+  .option('--voice <voice>',  'TTS 声音（默认 nova）')
+  .option('--size <size>',    '图像尺寸（默认 1024x1024）')
+  .option('--duration <sec>', '视频/音乐时长（秒）')
+  .action(async (flags) => {
+    const { pilot } = require('../scripts/commands/pilot')
+    await pilot(flags).catch(e => { console.error('❌', e.message); process.exit(1) })
+  })
+
+// ── chat (快捷方式) ───────────────────────────────────────────────────────────
+program
+  .command('chat <prompt>')
+  .description('快捷对话（等同于 pilot --type chat）')
+  .option('--model <model>', '指定模型')
+  .action(async (prompt, flags) => {
+    const { pilot } = require('../scripts/commands/pilot')
+    await pilot({ type: 'chat', prompt, ...flags }).catch(e => { console.error('❌', e.message); process.exit(1) })
+  })
+
+// ── balance ───────────────────────────────────────────────────────────────────
+program
+  .command('balance')
+  .description('查看积分余额')
+  .action(async () => {
+    const { authStatus } = require('../scripts/commands/auth')
+    await authStatus()
+  })
+
+program.parse(process.argv)

package/install.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# install.sh — SkillFree 一键安装脚本
+# curl -fsSL https://skillfree.ai/install.sh | bash
+
+set -e
+
+CYAN='\033[0;36m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; RED='\033[0;31m'; NC='\033[0m'
+info()    { echo -e "${CYAN}[SkillFree]${NC} $*"; }
+success() { echo -e "${GREEN}[SkillFree]${NC} ✓ $*"; }
+warn()    { echo -e "${YELLOW}[SkillFree]${NC} ⚠ $*"; }
+err()     { echo -e "${RED}[SkillFree]${NC} ✗ $*"; exit 1; }
+
+echo ""
+echo -e "${CYAN}🦞 SkillFree 安装程序${NC}"
+echo -e "   一个 API，满足所有龙虾技能需求"
+echo ""
+
+# ── 1. 检查 Node.js ──────────────────────────────────────────────────────────
+if ! command -v node &>/dev/null; then
+  err "需要 Node.js 18+，请先安装：https://nodejs.org"
+fi
+NODE_VER=$(node -e "process.stdout.write(process.versions.node.split('.')[0])")
+[ "$NODE_VER" -lt 18 ] && err "Node.js 版本过低（当前 v$NODE_VER），需要 18+"
+
+# ── 2. 安装 CLI 包 ────────────────────────────────────────────────────────────
+info "安装 skillfree CLI..."
+npm install -g skillfree --quiet 2>/dev/null \
+  || npx --yes skillfree --version &>/dev/null \
+  || warn "全局安装需要权限，尝试 sudo npm install -g skillfree"
+success "CLI 安装完成"
+
+# ── 3. 输入 API Key ───────────────────────────────────────────────────────────
+echo ""
+echo -e "  请前往 ${CYAN}https://skillfree.ai/dashboard${NC} 获取 API Key"
+read -rp "  输入你的 API Key (sk-sf-...): " API_KEY
+
+if [[ -z "$API_KEY" || "$API_KEY" != sk-sf-* ]]; then
+  warn "未输入有效 Key，跳过配置（稍后可运行 skillfree auth login）"
+else
+  # ── 4. 写入环境变量 ─────────────────────────────────────────────────────────
+  SHELL_RC="$HOME/.zshrc"
+  [[ "$SHELL" == *bash* ]] && SHELL_RC="$HOME/.bashrc"
+  if ! grep -q "SKILLFREE_API_KEY" "$SHELL_RC" 2>/dev/null; then
+    echo "" >> "$SHELL_RC"
+    echo "# SkillFree" >> "$SHELL_RC"
+    echo "export SKILLFREE_API_KEY=\"$API_KEY\"" >> "$SHELL_RC"
+  else
+    sed -i.bak "s/export SKILLFREE_API_KEY=.*/export SKILLFREE_API_KEY=\"$API_KEY\"/" "$SHELL_RC"
+  fi
+  export SKILLFREE_API_KEY="$API_KEY"
+  success "API Key 已写入 $SHELL_RC"
+
+  # ── 5. 自动配置各 AI 工具 ────────────────────────────────────────────────────
+  SKILL_SRC_DIR="$HOME/.skillfree/skill"
+  mkdir -p "$SKILL_SRC_DIR"
+
+  # 下载 SKILL.md（龙虾技能描述）
+  curl -fsSL "https://skillfree.ai/skill/SKILL.md" -o "$SKILL_SRC_DIR/SKILL.md" 2>/dev/null \
+    || echo "# SkillFree\nUse skillfree CLI for AI tasks." > "$SKILL_SRC_DIR/SKILL.md"
+
+  # OpenClaw
+  for dir in "$HOME/.agents/skills" "$HOME/.openclaw/workspace/skills"; do
+    if [ -d "$dir" ]; then
+      mkdir -p "$dir/skillfree"
+      cp "$SKILL_SRC_DIR/SKILL.md" "$dir/skillfree/SKILL.md"
+      echo "SKILLFREE_API_KEY=$API_KEY" > "$dir/skillfree/.env"
+      success "OpenClaw 配置完成 → $dir/skillfree/"
+    fi
+  done
+
+  # Claude Code
+  if [ -d "$HOME/.claude" ]; then
+    mkdir -p "$HOME/.claude/skills/skillfree"
+    cp "$SKILL_SRC_DIR/SKILL.md" "$HOME/.claude/skills/skillfree/SKILL.md"
+    success "Claude Code 配置完成 → ~/.claude/skills/skillfree/"
+  fi
+
+  # Codex CLI
+  if [ -d "$HOME/.codex" ]; then
+    mkdir -p "$HOME/.codex/skills/skillfree"
+    cp "$SKILL_SRC_DIR/SKILL.md" "$HOME/.codex/skills/skillfree/SKILL.md"
+    success "Codex 配置完成 → ~/.codex/skills/skillfree/"
+  fi
+
+  # Continue.dev
+  if [ -d "$HOME/.continue" ]; then
+    mkdir -p "$HOME/.continue/skills/skillfree"
+    cp "$SKILL_SRC_DIR/SKILL.md" "$HOME/.continue/skills/skillfree/SKILL.md"
+    success "Continue.dev 配置完成 → ~/.continue/skills/skillfree/"
+  fi
+fi
+
+# ── 6. 完成 ───────────────────────────────────────────────────────────────────
+echo ""
+echo -e "${GREEN}🎉 安装完成！${NC}"
+echo ""
+echo -e "  ${CYAN}快速开始：${NC}"
+echo -e "  $ skillfree pilot --type chat --prompt \"你好龙虾\""
+echo -e "  $ skillfree pilot --type image --prompt \"赛博朋克的上海\" --output ./img.png"
+echo ""
+echo -e "  ${CYAN}充值积分：${NC} https://skillfree.ai/billing"
+echo -e "  ${CYAN}查看文档：${NC} https://skillfree.ai/docs"
+echo ""

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "skillfree",
+  "version": "0.1.0",
+  "description": "🦞 一个 API，满足所有龙虾技能需求",
+  "main": "bin/skillfree.js",
+  "bin": {
+    "skillfree": "./bin/skillfree.js"
+  },
+  "scripts": {
+    "test": "node bin/skillfree.js --help"
+  },
+  "keywords": ["ai", "skillfree", "openclaw", "claude", "llm"],
+  "homepage": "https://skillfree.tech",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ChongC1990/skillfree"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.0.0"
+  }
+}

package/scripts/commands/auth.js

@@ -0,0 +1,59 @@
+const readline = require('readline')
+const { saveConfig, BASE_URL } = require('../lib/client')
+
+async function authLogin() {
+  console.log(`\n🦞 SkillFree 登录`)
+  console.log(`   控制台：${BASE_URL}/app\n`)
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  const ask = (q) => new Promise(resolve => rl.question(q, resolve))
+
+  console.log('请前往控制台 → API Keys → 创建 Key，然后粘贴到此处。')
+  const key = (await ask('API Key (sk-sf-...): ')).trim()
+  rl.close()
+
+  if (!key.startsWith('sk-sf-')) {
+    console.error('❌ 格式不正确，Key 应以 sk-sf- 开头')
+    process.exit(1)
+  }
+
+  // 验证 key 是否有效
+  process.stdout.write('验证中...')
+  try {
+    const res = await fetch(`${BASE_URL}/v1/balance`, {
+      headers: { 'Authorization': `Bearer ${key}` }
+    })
+    if (!res.ok) throw new Error(res.status)
+    const data = await res.json()
+    saveConfig({ apiKey: key })
+    console.log(` ✅\n`)
+    console.log(`🎉 登录成功！当前积分：${data.credits}`)
+    console.log(`\n快速开始：`)
+    console.log(`  skillfree pilot --type chat --prompt "你好"`)
+  } catch (e) {
+    console.log(` ❌\nAPI Key 无效，请重新检查`)
+    process.exit(1)
+  }
+}
+
+async function authStatus() {
+  const { getApiKey, BASE_URL } = require('../lib/client')
+  const key = getApiKey()
+  if (!key) {
+    console.log('未登录。运行: skillfree auth login')
+    return
+  }
+  const res = await fetch(`${BASE_URL}/v1/balance`, {
+    headers: { 'Authorization': `Bearer ${key}` }
+  })
+  if (!res.ok) {
+    console.log('API Key 已失效，请重新登录')
+    return
+  }
+  const data = await res.json()
+  console.log(`✅ 已登录`)
+  console.log(`   剩余积分：${data.credits}`)
+  console.log(`   Key：${key.slice(0, 10)}****${key.slice(-4)}`)
+}
+
+module.exports = { authLogin, authStatus }

package/scripts/commands/chat.js

@@ -0,0 +1,32 @@
+const { run } = require('./run')
+
+/**
+ * Chat completion command
+ * @param {object} params - Chat parameters
+ * @param {string} params.model - Model in "vendor/model" format
+ * @param {string} [params.prompt] - Simple prompt (converted to messages)
+ * @param {Array} [params.messages] - Full messages array
+ * @param {string} [params.system] - System prompt
+ * @param {boolean} [params.stream] - Enable streaming
+ * @param {number} [params.maxTokens] - Max tokens
+ * @param {number} [params.temperature] - Temperature
+ * @returns {Promise<object|AsyncGenerator>} Chat response or stream
+ */
+async function chat(params) {
+  let messages = params.messages
+  if (!messages && params.prompt) {
+    messages = [{ role: 'user', content: params.prompt }]
+  }
+  if (!messages) {
+    throw new Error('Either --prompt or --messages is required')
+  }
+
+  const inputs = { messages }
+  if (params.system) inputs.system = params.system
+  if (params.maxTokens) inputs.max_tokens = params.maxTokens
+  if (params.temperature !== undefined) inputs.temperature = params.temperature
+
+  return run({ model: params.model, inputs, stream: params.stream })
+}
+
+module.exports = { chat }

package/scripts/commands/image.js

@@ -0,0 +1,92 @@
+const { run } = require('./run')
+
+/**
+ * Image generation command
+ * @param {object} params - Image parameters
+ * @param {string} params.model - Model in "vendor/model" format
+ * @param {string} params.prompt - Image generation prompt
+ * @param {string} [params.size] - Image size (e.g., "1024x1024")
+ * @param {string} [params.output] - Output file path
+ * @returns {Promise<object>} Image generation result
+ */
+async function image(params) {
+  if (!params.prompt) {
+    throw new Error('--prompt is required for image generation')
+  }
+
+  const [vendor] = params.model.split('/')
+  const inputs = {}
+
+  if (vendor === 'vertex') {
+    inputs.messages = [{ role: 'user', content: params.prompt }]
+  } else if (vendor === 'mm') {
+    // MM uses prompt and size in "1024*1536" format
+    inputs.prompt = params.prompt
+    if (params.size) {
+      // Convert "1024x1536" to "1024*1536" if needed
+      inputs.size = params.size.replace('x', '*')
+    }
+  } else {
+    inputs.prompt = params.prompt
+    if (params.size) inputs.size = params.size
+  }
+
+  return run({ model: params.model, inputs, output: params.output })
+}
+
+/**
+ * Image upscale command (FAL creative-upscaler)
+ * @param {object} params - Upscale parameters
+ * @param {string} params.imageUrl - URL of image to upscale
+ * @param {number} [params.scale] - Upscale factor: 2 or 4 (default: 2)
+ * @param {string} [params.outputFormat] - "png" or "jpeg" (default: "png")
+ * @param {string} [params.output] - Output file path
+ * @returns {Promise<object>} Upscale result {image_url, images}
+ */
+async function upscale(params) {
+  if (!params.imageUrl) {
+    throw new Error('--image-url is required for upscale')
+  }
+
+  const inputs = {
+    image_url: params.imageUrl,
+    scale: params.scale || 2,
+    output_format: params.outputFormat || 'png',
+  }
+
+  return run({ model: 'fal/upscale', inputs, output: params.output })
+}
+
+/**
+ * Image-to-image transformation command (FAL FLUX dev)
+ * @param {object} params - img2img parameters
+ * @param {string} params.imageUrl - URL of source image
+ * @param {string} params.prompt - Transformation description
+ * @param {number} [params.strength] - Transform strength 0.0-1.0 (default: 0.75)
+ * @param {string} [params.imageSize] - Size preset: square_hd, square, portrait_4_3, landscape_16_9, etc. (default: square_hd)
+ * @param {string} [params.outputFormat] - "jpeg" or "png" (default: "jpeg")
+ * @param {number} [params.numImages] - Number of images 1-4 (default: 1)
+ * @param {string} [params.output] - Output file path
+ * @returns {Promise<object>} img2img result {image_url, images}
+ */
+async function img2img(params) {
+  if (!params.imageUrl) {
+    throw new Error('--image-url is required for img2img')
+  }
+  if (!params.prompt) {
+    throw new Error('--prompt is required for img2img')
+  }
+
+  const inputs = {
+    image_url: params.imageUrl,
+    prompt: params.prompt,
+    strength: params.strength || 0.75,
+    image_size: params.imageSize || 'square_hd',
+    output_format: params.outputFormat || 'jpeg',
+    num_images: params.numImages || 1,
+  }
+
+  return run({ model: 'fal/img2img', inputs, output: params.output })
+}
+
+module.exports = { image, upscale, img2img }

package/scripts/commands/models.js

@@ -0,0 +1,32 @@
+const { apiHubGet } = require('../lib/client')
+
+/**
+ * List available models from API Hub
+ * @param {object} [params] - List parameters
+ * @param {string} [params.type] - Filter by category (chat, tts, image, video, scraping, etc.)
+ * @param {string} [params.vendor] - Filter by vendor
+ * @returns {Promise<object>} Models list
+ */
+async function listModels(params = {}) {
+  const response = await apiHubGet('/v1/models')
+  let models = response.models || []
+
+  // Filter by category/type
+  if (params.type) {
+    const typeFilter = params.type.toLowerCase()
+    models = models.filter(m =>
+      m.category?.toLowerCase() === typeFilter ||
+      m.type?.toLowerCase() === typeFilter
+    )
+  }
+
+  // Filter by vendor
+  if (params.vendor) {
+    const vendorFilter = params.vendor.toLowerCase()
+    models = models.filter(m => m.vendor?.toLowerCase() === vendorFilter)
+  }
+
+  return { count: models.length, models }
+}
+
+module.exports = { listModels }

package/scripts/commands/music.js

@@ -0,0 +1,28 @@
+const { run } = require('./run')
+
+/**
+ * Music generation command
+ * @param {object} params - Music parameters
+ * @param {string} params.model - Model in "vendor/model" format
+ * @param {string} params.prompt - Music generation prompt
+ * @param {number} [params.duration] - Duration in seconds
+ * @param {string} [params.output] - Output file path
+ * @returns {Promise<object>} Music generation result
+ */
+async function music(params) {
+  if (!params.prompt) {
+    throw new Error('--prompt is required for music generation')
+  }
+
+  const inputs = {
+    prompt: params.prompt,
+  }
+
+  if (params.duration) {
+    inputs.duration = parseInt(params.duration)
+  }
+
+  return run({ model: params.model, inputs, output: params.output })
+}
+
+module.exports = { music }

package/scripts/commands/pilot.js

@@ -0,0 +1,100 @@
+const { post, postStream, BASE_URL } = require('../lib/client')
+const fs = require('fs')
+const path = require('path')
+
+async function pilot(flags) {
+  const type = flags.type || 'chat'
+  const prompt = flags.prompt || flags.text || ''
+  const output = flags.output || null
+
+  // 构造请求体
+  const body = { type, inputs: {} }
+
+  switch (type) {
+    case 'chat':
+      body.model = flags.model
+      body.inputs.messages = [{ role: 'user', content: prompt }]
+      break
+    case 'image':
+      body.model = flags.model
+      body.inputs.prompt = prompt
+      if (flags.size) body.inputs.size = flags.size
+      break
+    case 'tts':
+      body.model = flags.model
+      body.inputs.text  = prompt
+      body.inputs.input = prompt
+      body.inputs.voice = flags.voice || 'nova'
+      break
+    case 'stt':
+      if (flags.file) {
+        body.inputs.audio_data = fs.readFileSync(path.resolve(flags.file)).toString('base64')
+        body.inputs.filename   = path.basename(flags.file)
+      }
+      break
+    case 'video':
+      body.model = flags.model
+      body.inputs.prompt   = prompt
+      body.inputs.duration = flags.duration ? parseInt(flags.duration) : 5
+      break
+    case 'music':
+      body.model = flags.model
+      body.inputs.prompt = prompt
+      break
+    default:
+      body.inputs.prompt = prompt
+  }
+
+  // 流式输出（chat 默认流式）
+  if (type === 'chat' && !output) {
+    const res = await postStream('/chat/completions', {
+      model: flags.model || 'DeepSeek-V3.2-Fast',
+      messages: [{ role: 'user', content: prompt }],
+      stream: true,
+    })
+
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buf = ''
+    process.stdout.write('\n')
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buf += decoder.decode(value, { stream: true })
+      const lines = buf.split('\n')
+      buf = lines.pop()
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const chunk = line.slice(6)
+          if (chunk === '[DONE]') { process.stdout.write('\n'); return }
+          try {
+            const d = JSON.parse(chunk)
+            const text = d.choices?.[0]?.delta?.content
+            if (text) process.stdout.write(text)
+          } catch {}
+        }
+      }
+    }
+    return
+  }
+
+  // 非流式
+  const result = await post('/pilot', body)
+
+  // 如果有媒体 URL 且指定了输出文件，下载保存
+  const mediaUrl = result.image_url || result.video_url || result.audio_url
+    || result.data?.[0]?.url || result.data?.[0]
+  if (output && mediaUrl) {
+    const resp = await fetch(typeof mediaUrl === 'string' ? mediaUrl : mediaUrl.url)
+    fs.writeFileSync(output, Buffer.from(await resp.arrayBuffer()))
+    console.log(`✅ 已保存到 ${output}`)
+    return
+  }
+
+  // 文本输出
+  const text = result.choices?.[0]?.message?.content
+    || result.text || result.transcript || JSON.stringify(result, null, 2)
+  console.log(text)
+}
+
+module.exports = { pilot }

package/scripts/commands/stt.js

@@ -0,0 +1,47 @@
+const fs = require('fs')
+const path = require('path')
+const { run } = require('./run')
+
+/**
+ * Speech-to-text command
+ * @param {object} params - STT parameters
+ * @param {string} params.file - Local audio file path
+ * @param {string} [params.model] - Model (default: openai/whisper-1)
+ * @param {string} [params.prompt] - Optional prompt to guide transcription style
+ * @param {string} [params.language] - Optional language code (e.g., "en")
+ * @param {string} [params.output] - Optional output file path for transcript
+ * @returns {Promise<object>} STT result with transcribed text
+ */
+async function stt(params) {
+  if (!params.file) {
+    throw new Error('--file is required for STT (local audio file path)')
+  }
+
+  const filePath = path.resolve(params.file)
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Audio file not found: ${filePath}`)
+  }
+
+  const audioData = fs.readFileSync(filePath).toString('base64')
+  const filename = path.basename(filePath)
+
+  const inputs = {
+    audio_data: audioData,
+    filename,
+  }
+  if (params.prompt) inputs.prompt = params.prompt
+  if (params.language) inputs.language = params.language
+
+  const model = params.model || 'openai/whisper-1'
+  const result = await run({ model, inputs })
+
+  const text = result.text || JSON.stringify(result)
+
+  if (params.output) {
+    fs.writeFileSync(params.output, text)
+  }
+
+  return { text, ...(params.output ? { saved: params.output } : {}) }
+}
+
+module.exports = { stt }

package/scripts/commands/tts.js

@@ -0,0 +1,67 @@
+const { run } = require('./run')
+
+/**
+ * Text-to-speech command
+ * @param {object} params - TTS parameters
+ * @param {string} params.model - Model in "vendor/model" format
+ * @param {string} params.text - Text to synthesize
+ * @param {string} [params.voiceId] - Voice ID (provider-specific)
+ * @param {string} params.output - Output audio file path
+ * @returns {Promise<object>} TTS result
+ */
+async function tts(params) {
+  if (!params.text) {
+    throw new Error('--text is required for TTS')
+  }
+  if (!params.output) {
+    throw new Error('--output is required for TTS')
+  }
+
+  const inputs = {}
+
+  // Provider-specific input mapping
+  const [vendor] = params.model.split('/')
+  if (vendor === 'elevenlabs') {
+    // ElevenLabs uses 'text' and requires voice_id - default to "Rachel"
+    inputs.text = params.text
+    inputs.voice_id = params.voiceId || 'EXAVITQu4vr4xnSDxMaL'
+  } else if (vendor === 'minimax') {
+    // MiniMax uses 'text' and 'voice_setting' object
+    inputs.text = params.text
+    inputs.voice_setting = {
+      voice_id: params.voiceId || 'male-qn-qingse',
+      speed: 1.0,
+      vol: 1.0,
+      pitch: 0,
+    }
+  } else if (vendor === 'openai') {
+    // OpenAI TTS uses 'input' and 'voice'
+    inputs.input = params.text
+    inputs.voice = params.voiceId || 'alloy'
+  } else if (vendor === 'replicate') {
+    // Replicate XTTS uses 'text' and requires 'speaker' (audio URL for voice cloning)
+    inputs.text = params.text
+    if (params.speaker) {
+      inputs.speaker = params.speaker
+    } else if (params.voiceId) {
+      inputs.speaker = params.voiceId
+    } else {
+      // Default speaker sample
+      inputs.speaker =
+        'https://replicate.delivery/pbxt/Jt79w0xsT64R1JsiJ0LQRL8UcWspg5J4RFrU6YwEKpOT1ukS/male.wav'
+    }
+  } else if (vendor === 'mm') {
+    // MM TTS (qwen3-tts-flash) uses 'text' and optional 'voice'
+    inputs.text = params.text
+    if (params.voiceId) {
+      inputs.voice = params.voiceId
+    }
+  } else {
+    // Default: use 'text'
+    inputs.text = params.text
+  }
+
+  return run({ model: params.model, inputs, output: params.output })
+}
+
+module.exports = { tts }

package/scripts/commands/video.js

@@ -0,0 +1,97 @@
+const { run } = require('./run')
+
+/**
+ * Video generation command
+ * @param {object} params - Video parameters
+ * @param {string} params.model - Model in "vendor/model" format
+ * @param {string} params.prompt - Video generation prompt
+ * @param {string} [params.output] - Output file path
+ * @returns {Promise<object>} Video generation result
+ */
+async function video(params) {
+  if (!params.prompt) {
+    throw new Error('--prompt is required for video generation')
+  }
+
+  const [vendor] = params.model.split('/')
+  const inputs = {}
+
+  if (vendor === 'vertex') {
+    // Vertex/Veo uses instances array format
+    inputs.instances = [{ prompt: params.prompt }]
+    inputs.parameters = {}
+  } else if (vendor === 'mm') {
+    // MM video models: t2v (text-to-video), i2v (image-to-video)
+    inputs.prompt = params.prompt
+    if (params.size) {
+      // Convert "1280x720" to "1280*720" if needed
+      inputs.size = params.size.replace('x', '*')
+    }
+    if (params.duration) {
+      inputs.duration = parseInt(params.duration)
+    }
+    if (params.image) {
+      // i2v mode: image-to-video
+      inputs.image_url = params.image
+    }
+  } else {
+    // MiniMax and others use 'prompt'
+    inputs.prompt = params.prompt
+  }
+
+  return run({ model: params.model, inputs, output: params.output })
+}
+
+/**
+ * Multimodal understanding command (video/image/audio analysis)
+ * @param {object} params - Multimodal parameters
+ * @param {string} params.model - Model in "vendor/model" format (e.g., mm/qwen3-vl-plus)
+ * @param {string} params.prompt - Text prompt/question about the media
+ * @param {string} [params.video] - Video URL to analyze
+ * @param {string} [params.image] - Image URL to analyze
+ * @param {string} [params.audio] - Audio URL to analyze/transcribe
+ * @returns {Promise<object>} Multimodal analysis result
+ */
+async function multimodal(params) {
+  if (!params.prompt) {
+    throw new Error('--prompt is required for multimodal')
+  }
+  if (!params.video && !params.image && !params.audio) {
+    throw new Error('At least one of --video, --image, or --audio is required')
+  }
+
+  const [vendor] = params.model.split('/')
+  const inputs = {}
+
+  if (vendor === 'mm') {
+    // MM multimodal models use messages format
+    const content = []
+    if (params.video) {
+      content.push({ video: params.video })
+      if (params.fps) {
+        content[content.length - 1].fps = parseInt(params.fps)
+      }
+    }
+    if (params.image) {
+      content.push({ image: params.image })
+    }
+    if (params.audio) {
+      content.push({ audio: params.audio })
+    }
+    content.push({ text: params.prompt })
+
+    inputs.input = {
+      messages: [{ role: 'user', content }]
+    }
+  } else {
+    // Generic format
+    inputs.prompt = params.prompt
+    if (params.video) inputs.video_url = params.video
+    if (params.image) inputs.image_url = params.image
+    if (params.audio) inputs.audio_url = params.audio
+  }
+
+  return run({ model: params.model, inputs })
+}
+
+module.exports = { video, multimodal }

package/scripts/lib/client.js

@@ -0,0 +1,92 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+// ─── 配置路径 ─────────────────────────────────────────────────────────────────
+// API Key 存储在 ~/.skillfree/config.json
+const CONFIG_DIR  = path.join(os.homedir(), '.skillfree')
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json')
+
+const BASE_URL = 'https://skillfree.tech'
+const API_BASE = `${BASE_URL}/v1`
+
+// ─── 读写配置 ─────────────────────────────────────────────────────────────────
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'))
+    }
+  } catch {}
+  return {}
+}
+
+function saveConfig(cfg) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n')
+}
+
+let _config = loadConfig()
+
+function getApiKey() {
+  return _config.apiKey || process.env.SKILLFREE_API_KEY || ''
+}
+
+// ─── HTTP 工具 ────────────────────────────────────────────────────────────────
+async function request(endpoint, options = {}) {
+  const apiKey = getApiKey()
+  if (!apiKey) {
+    throw new Error('未登录，请先运行: skillfree auth login')
+  }
+
+  const url = `${API_BASE}${endpoint}`
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+      ...(options.headers || {}),
+    },
+  })
+
+  if (res.status === 402) throw new Error('积分不足，请前往 https://skillfree.tech/app 充值')
+  if (res.status === 401) throw new Error('API Key 无效或已过期，请重新登录: skillfree auth login')
+
+  return res
+}
+
+async function post(endpoint, body) {
+  const res = await request(endpoint, {
+    method: 'POST',
+    body: JSON.stringify(body),
+  })
+  return res.json()
+}
+
+async function postStream(endpoint, body) {
+  const res = await request(endpoint, {
+    method: 'POST',
+    headers: { 'Accept': 'text/event-stream' },
+    body: JSON.stringify({ ...body, stream: true }),
+  })
+  return res
+}
+
+async function get(endpoint) {
+  const res = await request(endpoint, { method: 'GET' })
+  return res.json()
+}
+
+// ─── 导出 ─────────────────────────────────────────────────────────────────────
+module.exports = {
+  BASE_URL,
+  API_BASE,
+  loadConfig,
+  saveConfig,
+  getApiKey,
+  get _config() { return _config },
+  set _config(v) { _config = v },
+  request,
+  post,
+  postStream,
+  get,
+}

package/scripts/lib/fetch-retry.js

@@ -0,0 +1,62 @@
+/**
+ * Shared fetch with retry logic for network errors and rate limits
+ */
+
+const MAX_RETRIES = 3
+const INITIAL_DELAY = 5000 // 5 seconds
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Fetch with automatic retry for network errors and rate limits (429)
+ *
+ * Design principles:
+ * - No HTTP timeout: Let server control (video generation can take 10+ minutes)
+ * - Retry on: Network errors (TypeError: fetch failed), 429 rate limit
+ * - Don't retry: 4xx client errors (except 429), 5xx server errors (server has retry)
+ *
+ * @param {string} url - The URL to fetch
+ * @param {object} options - Fetch options
+ * @param {number} maxRetries - Maximum number of retries (default: 3)
+ * @returns {Promise<Response>} The fetch response
+ */
+async function fetchWithRetry(url, options = {}, maxRetries = MAX_RETRIES) {
+  let lastError
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options)
+
+      // Handle rate limit (429)
+      if (response.status === 429) {
+        if (attempt >= maxRetries) {
+          return response // Return the 429 response on final attempt
+        }
+
+        const retryAfter = response.headers.get('Retry-After')
+        const delay = retryAfter ? parseInt(retryAfter) * 1000 : INITIAL_DELAY * attempt
+        console.log(`Rate limited. Waiting ${delay / 1000}s before retry ${attempt}/${maxRetries}...`)
+        await sleep(delay)
+        continue
+      }
+
+      // Return response for all other status codes (let caller handle errors)
+      return response
+    } catch (error) {
+      lastError = error
+
+      // Only retry on network errors (TypeError: fetch failed)
+      if (attempt < maxRetries) {
+        const delay = INITIAL_DELAY * attempt
+        console.log(`Network error: ${error.message}. Retry ${attempt}/${maxRetries} in ${delay / 1000}s...`)
+        await sleep(delay)
+      }
+    }
+  }
+
+  throw lastError
+}
+
+module.exports = { fetchWithRetry, sleep }