jjs_cli 0.1.0

package/README.md

@@ -0,0 +1,79 @@
+# jjs_cli
+
+Node.js CLI for the `case_storage` Streamable HTTP MCP service. It follows the same install shape as Bailian-style CLIs: install with npm, then use `jjs_cli` or the short command `jjs`.
+
+## Install
+
+After publishing to npm:
+
+```bash
+npm install -g jjs_cli
+jjs_cli --help
+jjs --help
+```
+
+From this repository before publishing:
+
+```bash
+npm install -g ./cli/jjs_cli
+jjs_cli --help
+jjs --help
+```
+
+Requires Node.js `>=22.12.0` and npm.
+
+## Auth
+
+```bash
+jjs_cli auth login --url "https://<HOST>/mcp" --api-key "<SERVER_API_KEY>"
+jjs_cli auth status --json
+jjs_cli auth logout
+```
+
+The key is sent as `X-Server-API-Key`. CLI output masks the key. Local config is stored under the user config directory as `jjs_cli/config.json`, or a custom path from `CASE_STORAGE_CLI_CONFIG`.
+
+Environment overrides:
+
+```bash
+CASE_STORAGE_MCP_URL="https://<HOST>/mcp"
+CASE_STORAGE_SERVER_API_KEY="<SERVER_API_KEY>"
+```
+
+## Commands
+
+```bash
+jjs_cli tools
+jjs_cli schema create_image
+jjs_cli call get_user_info --json
+jjs_cli image create --prompt "产品宣传图" --aspect-ratio 3:4 --image-size 2K
+jjs_cli video seedance --prompt "产品缓慢旋转" --image "https://example.com/ref.jpg"
+jjs_cli task get --task-id "<TASK_ID>" --task-type image
+jjs_cli voice public
+jjs_cli voice synthesize --content "你好" --speaker-id "<SPEAKER_ID>"
+jjs_cli douhot search --keyword "热点" --page 1
+```
+
+The installed `jjs` command is equivalent to `jjs_cli`:
+
+```bash
+jjs tools
+jjs image create --prompt "产品宣传图" --json
+```
+
+Generic calls accept:
+
+```bash
+jjs_cli call create_image \
+  --arg prompt="产品宣传图" \
+  --json-arg image_urls='["https://example.com/ref.jpg"]' \
+  --json
+```
+
+## Test
+
+```bash
+npm test
+npm pack --dry-run
+```
+
+The automated tests use a fake local MCP server and do not require a real backend or key.

package/bin/jjs.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from '../src/cli.js';
+
+const code = await main(process.argv.slice(2));
+process.exitCode = code;
+

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "jjs_cli",
+  "version": "0.1.0",
+  "description": "Node.js CLI for case_storage Streamable HTTP MCP tools.",
+  "type": "module",
+  "bin": {
+    "jjs_cli": "bin/jjs.js",
+    "jjs": "bin/jjs.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "jjs",
+    "mcp",
+    "cli"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/args.js

@@ -0,0 +1,156 @@
+export function parseGlobalOptions(argv) {
+  const options = { json: false };
+  const rest = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (token === '--output') {
+      const value = requireValue(argv, i, token);
+      i += 1;
+      options.output = value;
+      if (value === 'json') options.json = true;
+      continue;
+    }
+    if (token === '--url') {
+      options.url = requireValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--api-key') {
+      options.apiKey = requireValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--config') {
+      options.configPath = requireValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--non-interactive') {
+      options.nonInteractive = true;
+      continue;
+    }
+    rest.push(token);
+  }
+
+  return { options, argv: rest };
+}
+
+export function parseCallArguments(argv) {
+  const out = {};
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--args-json') {
+      const raw = requireValue(argv, i, token);
+      i += 1;
+      const parsed = parseJson(raw, '--args-json');
+      if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+        throw new Error('--args-json must be a JSON object');
+      }
+      Object.assign(out, parsed);
+      continue;
+    }
+    if (token === '--arg' || token === '--json-arg') {
+      const raw = requireValue(argv, i, token);
+      i += 1;
+      const [key, value] = splitKeyValue(raw, token);
+      out[key] = token === '--json-arg' ? parseJson(value, key) : value;
+      continue;
+    }
+    throw new Error(`Unknown call argument option: ${token}`);
+  }
+
+  return out;
+}
+
+export function optionValue(argv, name, fallback = undefined) {
+  const index = argv.indexOf(name);
+  if (index === -1) return fallback;
+  return requireValue(argv, index, name);
+}
+
+export function optionNumber(argv, name, fallback = undefined) {
+  const value = optionValue(argv, name);
+  if (value === undefined) return fallback;
+  const number = Number(value);
+  if (!Number.isFinite(number)) {
+    throw new Error(`${name} must be a number`);
+  }
+  return number;
+}
+
+export function optionFlag(argv, name) {
+  return argv.includes(name);
+}
+
+export function optionBoolean(argv, positive, negative, fallback = undefined) {
+  if (argv.includes(positive)) return true;
+  if (negative && argv.includes(negative)) return false;
+  return fallback;
+}
+
+export function optionList(argv, name) {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === name) {
+      values.push(requireValue(argv, i, name));
+      i += 1;
+    }
+  }
+  return values;
+}
+
+export function compactObject(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => {
+    if (value === undefined || value === null) return false;
+    if (Array.isArray(value) && value.length === 0) return false;
+    if (value === '') return false;
+    return true;
+  }));
+}
+
+export function rejectUnknownOptions(argv, allowed) {
+  const allowedSet = new Set(allowed);
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith('--')) continue;
+    if (!allowedSet.has(token)) {
+      throw new Error(`Unknown option: ${token}`);
+    }
+    if (flagTakesValue(token)) i += 1;
+  }
+}
+
+function flagTakesValue(token) {
+  return !token.startsWith('--no-') && !['--sync', '--auto-translate', '--return-raw', '--cache'].includes(token);
+}
+
+function splitKeyValue(raw, label) {
+  const index = raw.indexOf('=');
+  if (index <= 0) {
+    throw new Error(`${label} expects key=value`);
+  }
+  return [raw.slice(0, index), raw.slice(index + 1)];
+}
+
+function parseJson(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON for ${label}: ${error.message}`);
+  }
+}
+
+function requireValue(argv, index, name) {
+  const value = argv[index + 1];
+  if (value === undefined || value.startsWith('--')) {
+    throw new Error(`${name} requires a value`);
+  }
+  return value;
+}
+

package/src/cli.js

@@ -0,0 +1,355 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  compactObject,
+  optionBoolean,
+  optionFlag,
+  optionList,
+  optionNumber,
+  optionValue,
+  parseCallArguments,
+  parseGlobalOptions,
+} from './args.js';
+import { configPathFromEnv, deleteConfig, loadConfig, resolveAuth, saveConfig, statusPayload } from './config.js';
+import { McpClient, normalizeMcpUrl, redactText } from './mcp-client.js';
+import { DOUHOT_COMMANDS, TOOL_SPECS, getToolSpec } from './tools.js';
+
+export async function main(rawArgv, io = defaultIo()) {
+  const { options, argv } = parseGlobalOptions(rawArgv);
+  const secrets = [options.apiKey, io.env.CASE_STORAGE_SERVER_API_KEY].filter(Boolean);
+  try {
+    const code = await dispatch(argv, options, io);
+    return code;
+  } catch (error) {
+    io.stderr.write(`${redactText(error.message || String(error), secrets)}\n`);
+    return 1;
+  }
+}
+
+async function dispatch(argv, options, io) {
+  const command = argv[0];
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    write(io, helpText());
+    return 0;
+  }
+  if (command === '--version' || command === 'version') {
+    write(io, 'jjs_cli 0.1.0\n');
+    return 0;
+  }
+  if (command === 'auth') return authCommand(argv.slice(1), options, io);
+  if (command === 'tools') return toolsCommand(argv.slice(1), options, io);
+  if (command === 'schema') return schemaCommand(argv.slice(1), options, io);
+  if (command === 'call') return callCommand(argv.slice(1), options, io);
+  if (command === 'user') return userCommand(argv.slice(1), options, io);
+  if (command === 'material') return materialCommand(argv.slice(1), options, io);
+  if (command === 'image') return imageCommand(argv.slice(1), options, io);
+  if (command === 'task') return taskCommand(argv.slice(1), options, io);
+  if (command === 'video') return videoCommand(argv.slice(1), options, io);
+  if (command === 'digital-human') return digitalHumanCommand(argv.slice(1), options, io);
+  if (command === 'voice') return voiceCommand(argv.slice(1), options, io);
+  if (command === 'douhot') return douhotCommand(argv.slice(1), options, io);
+  throw new Error(`Unknown command: ${command}\nRun: jjs_cli --help`);
+}
+
+async function authCommand(argv, options, io) {
+  const subcommand = argv[0] || 'status';
+  const configPath = configPathFromEnv(io.env, options);
+  const config = loadConfig(configPath);
+
+  if (subcommand === 'status') {
+    const payload = statusPayload({ auth: resolveAuth({ config, env: io.env, flags: options }), configPath });
+    return output(payload, options, io, humanAuthStatus(payload));
+  }
+
+  if (subcommand === 'login') {
+    const url = options.url || optionValue(argv, '--url') || config.mcp_url;
+    const apiKey = options.apiKey || optionValue(argv, '--api-key') || config.server_api_key;
+    if (!url) throw new Error('auth login requires --url <http(s)://host/mcp>');
+    if (!apiKey) throw new Error('auth login requires --api-key <SERVER_API_KEY>');
+    saveConfig(configPath, {
+      mcp_url: normalizeMcpUrl(url),
+      server_api_key: apiKey,
+    });
+    const payload = statusPayload({
+      auth: resolveAuth({ config: loadConfig(configPath), env: {}, flags: {} }),
+      configPath,
+    });
+    return output(payload, options, io, `Saved case_storage MCP credentials to ${configPath}\nAPI Key: ${payload.api_key}\n`);
+  }
+
+  if (subcommand === 'logout') {
+    deleteConfig(configPath);
+    return output({ ok: true, config_path: configPath }, options, io, `Removed ${configPath}\n`);
+  }
+
+  throw new Error(`Unknown auth command: ${subcommand}`);
+}
+
+async function toolsCommand(argv, options, io) {
+  if (optionFlag(argv, '--remote')) {
+    const result = await clientFromConfig(options, io).listTools();
+    return output(result, options, io, `${JSON.stringify(result, null, 2)}\n`);
+  }
+  const payload = { tools: TOOL_SPECS };
+  const human = TOOL_SPECS.map((tool) => `${tool.name.padEnd(38)} ${tool.description}`).join('\n');
+  return output(payload, options, io, `${human}\n`);
+}
+
+async function schemaCommand(argv, options, io) {
+  const toolName = argv[0];
+  if (!toolName) throw new Error('schema requires a tool name');
+  const spec = getToolSpec(toolName);
+  return output(spec, options, io, `${JSON.stringify(spec, null, 2)}\n`);
+}
+
+async function callCommand(argv, options, io) {
+  const toolName = argv[0];
+  if (!toolName) throw new Error('call requires a tool name');
+  getToolSpec(toolName);
+  const args = parseCallArguments(argv.slice(1));
+  return callAndOutput(toolName, args, options, io);
+}
+
+async function userCommand(argv, options, io) {
+  if (argv[0] !== 'info') throw new Error('Usage: jjs_cli user info');
+  return callAndOutput('get_user_info', {}, options, io);
+}
+
+async function materialCommand(argv, options, io) {
+  if (argv[0] !== 'upload') throw new Error('Usage: jjs_cli material upload --file <path>');
+  const file = optionValue(argv, '--file');
+  if (!file) throw new Error('material upload requires --file <path>');
+  const content = fs.readFileSync(file);
+  const args = compactObject({
+    file_name: optionValue(argv, '--file-name', path.basename(file)),
+    mime_type: optionValue(argv, '--mime-type', inferMimeType(file)),
+    content_base64: content.toString('base64'),
+    title: optionValue(argv, '--title'),
+    category: optionValue(argv, '--category'),
+    tags: optionValue(argv, '--tags'),
+  });
+  return callAndOutput('upload_material', args, options, io);
+}
+
+async function imageCommand(argv, options, io) {
+  if (argv[0] !== 'create') throw new Error('Usage: jjs_cli image create --prompt <text>');
+  const args = compactObject({
+    prompt: optionValue(argv, '--prompt'),
+    image_urls: optionList(argv, '--image-url'),
+    image_generation_type: optionValue(argv, '--type'),
+    model: optionValue(argv, '--model'),
+    aspect_ratio: optionValue(argv, '--aspect-ratio'),
+    image_size: optionValue(argv, '--image-size'),
+    title: optionValue(argv, '--title'),
+    task: optionValue(argv, '--task'),
+    is_sync: optionFlag(argv, '--sync') || undefined,
+    transparent_background: optionBoolean(argv, '--transparent-background', '--no-transparent-background'),
+    transparent_key_color: optionValue(argv, '--transparent-key-color'),
+  });
+  return callAndOutput('create_image', args, options, io);
+}
+
+async function taskCommand(argv, options, io) {
+  if (argv[0] !== 'get') throw new Error('Usage: jjs_cli task get --task-id <id> --task-type <image|video|digital_human>');
+  const args = compactObject({
+    task_id: optionValue(argv, '--task-id'),
+    task_type: optionValue(argv, '--task-type'),
+  });
+  return callAndOutput('get_task', args, options, io);
+}
+
+async function videoCommand(argv, options, io) {
+  const subcommand = argv[0];
+  const toolName = subcommand === 'seedance'
+    ? 'create_seedance_video'
+    : subcommand === 'happyhorse'
+      ? 'create_happyhorse_video'
+      : '';
+  if (!toolName) throw new Error('Usage: jjs_cli video <seedance|happyhorse> --prompt <text>');
+  const args = compactObject({
+    prompt: optionValue(argv, '--prompt'),
+    images: optionList(argv, '--image'),
+    videos: optionList(argv, '--video'),
+    audios: optionList(argv, '--audio'),
+    virtual_portrait_uri: optionValue(argv, '--virtual-portrait-uri'),
+    virtual_portrait_uris: optionList(argv, '--virtual-portrait-uri'),
+    aspect_ratio: optionValue(argv, '--aspect-ratio'),
+    quality: optionValue(argv, '--quality'),
+    orientation: optionValue(argv, '--orientation'),
+    duration: optionNumber(argv, '--duration'),
+    seed: optionValue(argv, '--seed'),
+    auto_translate: optionFlag(argv, '--auto-translate') || undefined,
+    title: optionValue(argv, '--title'),
+  });
+  return callAndOutput(toolName, args, options, io);
+}
+
+async function digitalHumanCommand(argv, options, io) {
+  if (argv[0] !== 'create') throw new Error('Usage: jjs_cli digital-human create --image-url <url> --audio-url <url>');
+  const args = compactObject({
+    image_url: optionValue(argv, '--image-url'),
+    audio_url: optionValue(argv, '--audio-url'),
+    resolution: optionValue(argv, '--resolution'),
+    start_time: optionValue(argv, '--start-time'),
+    end_time: optionValue(argv, '--end-time'),
+    prompt: optionValue(argv, '--prompt'),
+    title: optionValue(argv, '--title'),
+  });
+  return callAndOutput('create_digital_human', args, options, io);
+}
+
+async function voiceCommand(argv, options, io) {
+  const subcommand = argv[0];
+  if (subcommand === 'public') return callAndOutput('get_public_voice', {}, options, io);
+  if (subcommand === 'custom') return callAndOutput('get_custom_voice', {}, options, io);
+  if (subcommand === 'synthesize') {
+    const args = compactObject({
+      content: optionValue(argv, '--content'),
+      speaker_id: optionValue(argv, '--speaker-id'),
+      voice_id: optionValue(argv, '--voice-id'),
+      group_key: optionValue(argv, '--group-key'),
+      model: optionValue(argv, '--model'),
+      rate: optionNumber(argv, '--rate'),
+      volume: optionNumber(argv, '--volume'),
+      audio_format: optionValue(argv, '--audio-format'),
+      sample_rate: optionNumber(argv, '--sample-rate'),
+    });
+    return callAndOutput('create_audio_task', args, options, io);
+  }
+  if (subcommand === 'clone') {
+    const args = compactObject({
+      audio_url: optionValue(argv, '--audio-url'),
+      prefix: optionValue(argv, '--prefix'),
+      language_hints: optionList(argv, '--language-hint'),
+    });
+    return callAndOutput('clone_voice', args, options, io);
+  }
+  throw new Error('Usage: jjs_cli voice <public|custom|synthesize|clone>');
+}
+
+async function douhotCommand(argv, options, io) {
+  const subcommand = argv[0];
+  if (subcommand === 'call') return callCommand(argv.slice(1), options, io);
+  const toolName = DOUHOT_COMMANDS[subcommand];
+  if (!toolName) throw new Error(`Usage: jjs_cli douhot <${Object.keys(DOUHOT_COMMANDS).join('|')}>`);
+  if ((subcommand === 'hot-word' || subcommand === 'author') && !optionValue(argv, '--keyword')) {
+    throw new Error(`douhot ${subcommand} requires --keyword <text>`);
+  }
+  const args = compactObject({
+    keyword: optionValue(argv, '--keyword'),
+    page: optionNumber(argv, '--page'),
+    page_size: optionNumber(argv, '--page-size'),
+    type: optionValue(argv, '--type'),
+    sec_uid: optionValue(argv, '--sec-uid'),
+    min_cursor: optionValue(argv, '--min-cursor'),
+    max_cursor: optionValue(argv, '--max-cursor'),
+    item_id: optionValue(argv, '--item-id'),
+    option: optionNumber(argv, '--option'),
+    date_window: optionNumber(argv, '--date-window'),
+    return_raw: optionBoolean(argv, '--return-raw', '--no-return-raw'),
+    cache: optionBoolean(argv, '--cache', '--no-cache'),
+    cookie: optionValue(argv, '--cookie'),
+  });
+  return callAndOutput(toolName, args, options, io);
+}
+
+async function callAndOutput(toolName, args, options, io) {
+  const result = await clientFromConfig(options, io).callTool(toolName, args);
+  const code = result?.success === false ? 2 : 0;
+  output(result, options, io, `${JSON.stringify(result, null, 2)}\n`);
+  return code;
+}
+
+function clientFromConfig(options, io) {
+  const configPath = configPathFromEnv(io.env, options);
+  const config = loadConfig(configPath);
+  const auth = resolveAuth({ config, env: io.env, flags: options });
+  return new McpClient({ url: auth.url, apiKey: auth.apiKey });
+}
+
+function output(payload, options, io, human) {
+  if (options.json) {
+    write(io, `${JSON.stringify(payload)}\n`);
+  } else {
+    write(io, human);
+  }
+  return payload?.success === false ? 2 : 0;
+}
+
+function write(io, text) {
+  io.stdout.write(text);
+}
+
+function humanAuthStatus(payload) {
+  if (!payload.authenticated) {
+    return `Not authenticated\nConfig: ${payload.config_path}\nRun: jjs_cli auth login --url <MCP_URL> --api-key <SERVER_API_KEY>\n`;
+  }
+  return `Authenticated\nMCP URL: ${payload.mcp_url}\nAPI Key: ${payload.api_key}\nConfig: ${payload.config_path}\n`;
+}
+
+function inferMimeType(file) {
+  const ext = path.extname(file).toLowerCase();
+  if (ext === '.png') return 'image/png';
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+  if (ext === '.webp') return 'image/webp';
+  throw new Error('Unable to infer MIME type. Pass --mime-type image/png|image/jpeg|image/webp');
+}
+
+function defaultIo() {
+  return {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    env: process.env,
+  };
+}
+
+function helpText() {
+  return `jjs_cli - Node.js CLI for case_storage MCP tools
+
+Install:
+  npm install -g jjs_cli
+
+Commands after install:
+  jjs_cli
+  jjs
+
+Repo-local install:
+  npm install -g ./cli/jjs_cli
+
+Global options:
+  --url <url>        MCP URL, for example http://127.0.0.1:8303/mcp
+  --api-key <key>    Service API Key sent as X-Server-API-Key
+  --json             Machine-readable output
+  --output json      Bailian-style JSON output alias
+  --config <path>    Override local config path
+
+Auth:
+  jjs_cli auth login --url <url> --api-key <key>
+  jjs_cli auth status --json
+  jjs_cli auth logout
+
+Introspection:
+  jjs_cli tools
+  jjs_cli schema <tool>
+  jjs_cli call <tool> --arg key=value --json-arg list='["a"]'
+
+Friendly commands:
+  jjs_cli user info
+  jjs_cli material upload --file ref.png
+  jjs_cli image create --prompt "产品宣传图" --image-url https://...
+  jjs_cli task get --task-id <id> --task-type image
+  jjs_cli video seedance --prompt "..." --image https://...
+  jjs_cli video happyhorse --prompt "..." --image https://...
+  jjs_cli digital-human create --image-url https://... --audio-url https://...
+  jjs_cli voice public | custom
+  jjs_cli voice synthesize --content "你好" --speaker-id <id>
+  jjs_cli voice clone --audio-url https://...
+  jjs_cli douhot search --keyword "热点"
+
+Environment:
+  CASE_STORAGE_MCP_URL
+  CASE_STORAGE_SERVER_API_KEY
+  CASE_STORAGE_CLI_CONFIG
+`;
+}

package/src/config.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const CONFIG_DIR_NAME = 'jjs_cli';
+
+export function defaultConfigPath(runtime = {}) {
+  const platform = runtime.platform ?? process.platform;
+  const env = runtime.env ?? process.env;
+  const homedir = runtime.homedir ?? os.homedir;
+
+  if (platform === 'win32') {
+    const base = env.APPDATA || path.join(homedir(), 'AppData', 'Roaming');
+    return path.join(base, CONFIG_DIR_NAME, 'config.json');
+  }
+
+  const base = env.XDG_CONFIG_HOME || path.join(homedir(), '.config');
+  return path.join(base, CONFIG_DIR_NAME, 'config.json');
+}
+
+export function configPathFromEnv(env = process.env, flags = {}) {
+  return flags.configPath || env.CASE_STORAGE_CLI_CONFIG || defaultConfigPath({ env });
+}
+
+export function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) return {};
+  const raw = fs.readFileSync(configPath, 'utf8').trim();
+  if (!raw) return {};
+  return JSON.parse(raw);
+}
+
+export function saveConfig(configPath, config) {
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  try {
+    fs.chmodSync(configPath, 0o600);
+  } catch {
+    // Windows ACLs are handled by the user profile; chmod is best-effort.
+  }
+}
+
+export function deleteConfig(configPath) {
+  if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+}
+
+export function resolveAuth({ config = {}, env = process.env, flags = {} } = {}) {
+  const envUrl = env.CASE_STORAGE_MCP_URL || env.CASE_STORAGE_BASE_URL;
+  const envKey = env.CASE_STORAGE_SERVER_API_KEY;
+  const configUrl = config.mcp_url || config.url || config.base_url;
+  const configKey = config.server_api_key || config.api_key;
+
+  const url = flags.url || envUrl || configUrl || '';
+  const apiKey = flags.apiKey || envKey || configKey || '';
+  return {
+    url,
+    apiKey,
+    source: {
+      url: flags.url ? 'flag' : envUrl ? 'env' : configUrl ? 'config' : 'missing',
+      apiKey: flags.apiKey ? 'flag' : envKey ? 'env' : configKey ? 'config' : 'missing',
+    },
+  };
+}
+
+export function maskApiKey(apiKey) {
+  if (!apiKey) return null;
+  const text = String(apiKey);
+  if (text.length <= 8) return `${text.slice(0, 2)}***`;
+  if (text.startsWith('gva_sk_')) {
+    return `gva_***${text.slice(-4)}`;
+  }
+  return `${text.slice(0, 4)}***${text.slice(-4)}`;
+}
+
+export function statusPayload({ auth, configPath }) {
+  return {
+    authenticated: Boolean(auth.url && auth.apiKey),
+    mcp_url: auth.url || null,
+    api_key: maskApiKey(auth.apiKey),
+    source: auth.source,
+    config_path: configPath,
+  };
+}

package/src/mcp-client.js

@@ -0,0 +1,141 @@
+const DEFAULT_PROTOCOL_VERSION = '2025-06-18';
+
+export class McpClient {
+  constructor({ url, apiKey, fetchImpl = globalThis.fetch, protocolVersion = DEFAULT_PROTOCOL_VERSION } = {}) {
+    if (!url) throw new Error('MCP URL is required. Run: jjs_cli auth login --url <url> --api-key <key>');
+    if (!apiKey) throw new Error('Service API Key is required. Run: jjs_cli auth login --url <url> --api-key <key>');
+    if (typeof fetchImpl !== 'function') throw new Error('Node.js fetch is unavailable; Node >= 22.12.0 is required');
+    this.url = normalizeMcpUrl(url);
+    this.apiKey = apiKey;
+    this.fetchImpl = fetchImpl;
+    this.protocolVersion = protocolVersion;
+    this.sessionId = '';
+    this.nextId = 1;
+    this.initialized = false;
+  }
+
+  async initialize() {
+    if (this.initialized) return;
+    await this.request('initialize', {
+      protocolVersion: this.protocolVersion,
+      clientInfo: { name: 'jjs_cli', version: '0.1.0' },
+      capabilities: {},
+    }, { skipInitialize: true });
+    this.initialized = true;
+  }
+
+  async listTools() {
+    await this.initialize();
+    return this.request('tools/list', {});
+  }
+
+  async callTool(name, args = {}) {
+    await this.initialize();
+    const response = await this.request('tools/call', { name, arguments: args || {} });
+    return unwrapToolResult(response);
+  }
+
+  async request(method, params = {}, options = {}) {
+    const id = this.nextId;
+    this.nextId += 1;
+    const headers = {
+      Accept: 'application/json, text/event-stream',
+      'Content-Type': 'application/json',
+      'X-Server-API-Key': this.apiKey,
+    };
+    if (this.sessionId) headers['Mcp-Session-Id'] = this.sessionId;
+
+    const body = JSON.stringify({ jsonrpc: '2.0', id, method, params });
+    let response;
+    try {
+      response = await this.fetchImpl(this.url, { method: 'POST', headers, body });
+    } catch (error) {
+      throw new Error(redactText(`MCP request failed: ${error.message}`, [this.apiKey]));
+    }
+
+    const sessionId = response.headers?.get?.('mcp-session-id');
+    if (sessionId) this.sessionId = sessionId;
+
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(redactText(`MCP HTTP ${response.status}: ${text}`, [this.apiKey]));
+    }
+
+    const payload = parseResponseBody(text);
+    if (payload.error) {
+      const message = payload.error.message || JSON.stringify(payload.error);
+      throw new Error(redactText(`MCP JSON-RPC error: ${message}`, [this.apiKey]));
+    }
+    if (!Object.prototype.hasOwnProperty.call(payload, 'result')) {
+      throw new Error('MCP response missing result');
+    }
+    return payload.result;
+  }
+}
+
+export function parseResponseBody(text) {
+  const raw = String(text || '').trim();
+  if (!raw) throw new Error('MCP response body is empty');
+  if (!looksLikeSse(raw)) return JSON.parse(raw);
+
+  const frames = [];
+  let current = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (line === '') {
+      if (current.length > 0) frames.push(current);
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length > 0) frames.push(current);
+
+  let lastPayload = null;
+  for (const frame of frames) {
+    const dataLines = [];
+    for (const line of frame) {
+      if (line.startsWith(':')) continue;
+      if (!line.startsWith('data:')) continue;
+      dataLines.push(line.slice(5).trimStart());
+    }
+    if (dataLines.length === 0) continue;
+    const data = dataLines.join('\n').trim();
+    if (!data || data === '[DONE]') continue;
+    lastPayload = JSON.parse(data);
+  }
+  if (!lastPayload) throw new Error('MCP SSE response contained no JSON data');
+  return lastPayload;
+}
+
+export function redactText(text, secrets = []) {
+  let out = String(text ?? '');
+  for (const secret of secrets) {
+    if (secret) out = out.split(String(secret)).join('[REDACTED]');
+  }
+  out = out.replace(/gva_sk_[A-Za-z0-9_-]+/g, 'gva_sk_[REDACTED]');
+  out = out.replace(/Bearer\s+[A-Za-z0-9._-]+/g, 'Bearer [REDACTED]');
+  return out;
+}
+
+export function normalizeMcpUrl(url) {
+  const trimmed = String(url || '').trim();
+  if (!trimmed) return '';
+  return trimmed.endsWith('/mcp') ? trimmed : `${trimmed.replace(/\/+$/, '')}/mcp`;
+}
+
+function looksLikeSse(text) {
+  return /^(:|event:|id:|data:)/m.test(text);
+}
+
+function unwrapToolResult(result) {
+  if (!result || typeof result !== 'object') return result;
+  if (!Array.isArray(result.content)) return result;
+
+  const textPart = result.content.find((item) => item?.type === 'text' && typeof item.text === 'string');
+  if (!textPart) return result;
+  try {
+    return JSON.parse(textPart.text);
+  } catch {
+    return { success: true, data: textPart.text, error: null };
+  }
+}

package/src/tools.js

@@ -0,0 +1,172 @@
+const serviceAuth = 'service-api-key';
+
+export const TOOL_SPECS = [
+  tool('get_user_info', '获取当前 Service API Key 绑定用户的账户、会员和兼容信息。'),
+  tool('upload_material', '上传图片素材到 OSS 并注册到当前用户成品库。', [
+    arg('file_name', 'string', true),
+    arg('mime_type', 'string', true),
+    arg('content_base64', 'string', true),
+    arg('title'),
+    arg('category'),
+    arg('tags'),
+  ]),
+  tool('create_image', '创建图片生成或改图任务。', [
+    arg('prompt'),
+    arg('image_urls', 'string[]'),
+    arg('image_generation_type'),
+    arg('model'),
+    arg('aspect_ratio'),
+    arg('image_size'),
+    arg('title'),
+    arg('task'),
+    arg('is_sync', 'boolean'),
+    arg('providers', 'string[]'),
+    arg('transparent_background', 'boolean'),
+    arg('transparent_key_color'),
+  ]),
+  videoTool('create_seedance_video', '创建 Seedance 全能参考视频任务。'),
+  videoTool('create_happyhorse_video', '创建 HappyHorse 全能参考视频任务。'),
+  tool('create_digital_human', '使用固定模板 101 创建单图数字人视频任务。', [
+    arg('image_url', 'string', true),
+    arg('audio_url', 'string', true),
+    arg('resolution'),
+    arg('start_time'),
+    arg('end_time'),
+    arg('prompt'),
+    arg('title'),
+  ]),
+  tool('get_task', '统一查询图片、视频、数字人任务状态和结果 URL。', [
+    arg('task_id', 'string', true),
+    arg('task_type', 'string', true),
+  ]),
+  tool('get_public_voice', '查询可直接用于语音合成的公共音色列表。'),
+  tool('get_custom_voice', '查询当前用户已克隆或定制的音色列表。'),
+  tool('clone_voice', '根据公网音频 URL 克隆当前用户的定制音色。', [
+    arg('audio_url', 'string', true),
+    arg('prefix'),
+    arg('language_hints', 'string[]'),
+  ]),
+  tool('create_audio_task', '把文本合成为音频，返回 voice_url。', [
+    arg('content', 'string', true),
+    arg('speaker_id'),
+    arg('voice_id'),
+    arg('group_key'),
+    arg('model'),
+    arg('rate', 'number'),
+    arg('volume', 'number'),
+    arg('audio_format'),
+    arg('sample_rate', 'number'),
+  ]),
+  douhotSearchTool('douhot_search', '抖音热点宝搜索完整降级链路。'),
+  douhotSearchTool('douhot_search_video_billboard', '抖音热点宝视频榜搜索。'),
+  douhotSearchTool('douhot_search_hot_word', '抖音热点宝热词详情搜索。'),
+  douhotSearchTool('douhot_search_challenge_analysis', '抖音热点宝挑战分析搜索。'),
+  douhotSearchTool('douhot_search_hot_search', '抖音热点宝热搜榜搜索。'),
+  douhotSearchTool('douhot_search_author', '抖音热点宝作者搜索。'),
+  douhotCreatorTool('douhot_creator_info', '抖音热点宝创作者信息。', 'info'),
+  douhotCreatorTool('douhot_creator_contents', '抖音热点宝创作者作品列表。', 'contents'),
+  douhotCreatorTool('douhot_creator_fans_trend_index', '抖音热点宝创作者粉丝趋势概览。', 'info'),
+  douhotCreatorTool('douhot_creator_fans_trend_trends', '抖音热点宝创作者粉丝趋势明细。', 'trend'),
+  douhotVideoTool('douhot_video_detail', '抖音热点宝视频详情。', 'base'),
+  douhotVideoTool('douhot_video_comments', '抖音热点宝视频评论列表。', 'comments'),
+  douhotVideoTool('douhot_video_comment_word_cloud', '抖音热点宝视频评论词云。', 'base'),
+  douhotVideoTool('douhot_video_trends_index', '抖音热点宝视频趋势概览。', 'base'),
+  douhotVideoTool('douhot_video_trends', '抖音热点宝视频趋势明细。', 'trend'),
+];
+
+export const friendlyCommandGroups = {
+  user: ['get_user_info'],
+  media: ['upload_material', 'create_image', 'create_seedance_video', 'create_happyhorse_video', 'create_digital_human'],
+  task: ['get_task'],
+  voice: ['get_public_voice', 'get_custom_voice', 'clone_voice', 'create_audio_task'],
+  douhot: TOOL_SPECS.filter((toolSpec) => toolSpec.name.startsWith('douhot_')).map((toolSpec) => toolSpec.name),
+};
+
+export const DOUHOT_COMMANDS = {
+  search: 'douhot_search',
+  'video-billboard': 'douhot_search_video_billboard',
+  'hot-word': 'douhot_search_hot_word',
+  'challenge-analysis': 'douhot_search_challenge_analysis',
+  'hot-search': 'douhot_search_hot_search',
+  author: 'douhot_search_author',
+  'creator-info': 'douhot_creator_info',
+  'creator-contents': 'douhot_creator_contents',
+  'creator-fans-trend-index': 'douhot_creator_fans_trend_index',
+  'creator-fans-trend-trends': 'douhot_creator_fans_trend_trends',
+  'video-detail': 'douhot_video_detail',
+  'video-comments': 'douhot_video_comments',
+  'video-comment-word-cloud': 'douhot_video_comment_word_cloud',
+  'video-trends-index': 'douhot_video_trends_index',
+  'video-trends': 'douhot_video_trends',
+};
+
+export function getToolSpec(name) {
+  const spec = TOOL_SPECS.find((toolSpec) => toolSpec.name === name);
+  if (!spec) throw new Error(`Unknown MCP tool: ${name}`);
+  return spec;
+}
+
+function tool(name, description, args = []) {
+  return {
+    name,
+    description,
+    auth: serviceAuth,
+    arguments: args,
+    required: args.filter((item) => item.required).map((item) => item.name),
+  };
+}
+
+function arg(name, type = 'string', required = false) {
+  return { name, type, required };
+}
+
+function videoTool(name, description) {
+  return tool(name, description, [
+    arg('prompt', 'string', true),
+    arg('images', 'string[]'),
+    arg('videos', 'string[]'),
+    arg('audios', 'string[]'),
+    arg('virtual_portrait_uri'),
+    arg('virtual_portrait_uris', 'string[]'),
+    arg('aspect_ratio'),
+    arg('quality'),
+    arg('orientation'),
+    arg('duration', 'number'),
+    arg('seed'),
+    arg('auto_translate', 'boolean'),
+    arg('title'),
+  ]);
+}
+
+function douhotCommonArgs(args) {
+  return [
+    ...args,
+    arg('return_raw', 'boolean'),
+    arg('cache', 'boolean'),
+    arg('cookie'),
+  ];
+}
+
+function douhotSearchTool(name, description) {
+  return tool(name, description, douhotCommonArgs([
+    arg('keyword'),
+    arg('page', 'number'),
+    arg('page_size', 'number'),
+    arg('type'),
+  ]));
+}
+
+function douhotCreatorTool(name, description, kind) {
+  const args = [arg('sec_uid', 'string', true)];
+  if (kind === 'contents') args.push(arg('min_cursor'), arg('max_cursor'));
+  if (kind === 'trend') args.push(arg('option', 'number'), arg('date_window', 'number'));
+  return tool(name, description, douhotCommonArgs(args));
+}
+
+function douhotVideoTool(name, description, kind) {
+  const args = [arg('item_id', 'string', true)];
+  if (kind === 'comments') args.push(arg('page', 'number'), arg('page_size', 'number'), arg('keyword'));
+  if (kind === 'trend') args.push(arg('option', 'number'), arg('date_window', 'number'));
+  return tool(name, description, douhotCommonArgs(args));
+}
+