yuanflow-cli 0.1.0 → 0.1.2

package/src/agent-protocol.js

@@ -0,0 +1,169 @@
+import { listEndpoints } from './registry.js';
+import { listShortcuts } from './shortcuts.js';
+
+const ERROR_MAP = [
+  {
+    code: 'TOKEN_MISSING',
+    exitCode: 3,
+    retryable: false,
+      test: (message) => message.includes('缺少 token'),
+  },
+  {
+    code: 'BAD_ARGUMENT',
+    exitCode: 2,
+    retryable: false,
+      test: (message) =>
+        message.includes('缺少') ||
+        message.includes('未知平台') ||
+        message.includes('未找到命令') ||
+        message.includes('未知命令') ||
+        message.includes('不支持'),
+  },
+  {
+    code: 'AUTH_INVALID',
+    exitCode: 3,
+    retryable: false,
+    test: (message) => message.includes('HTTP 401') || message.includes('HTTP 403'),
+  },
+  {
+    code: 'UPSTREAM_ERROR',
+    exitCode: 4,
+    retryable: true,
+    test: (message) => /HTTP 5\d\d/.test(message),
+  },
+  {
+    code: 'NETWORK_ERROR',
+    exitCode: 5,
+    retryable: true,
+    test: (message) => message.includes('fetch failed') || message.includes('ECONN'),
+  },
+];
+
+export function isAgentJsonFormat(options = {}) {
+  return options.format === 'agent-json';
+}
+
+export function createAgentSuccess(command, data, meta = {}) {
+  return {
+    success: true,
+    command,
+    data,
+    warnings: [],
+    error: null,
+    meta,
+  };
+}
+
+export function createAgentError(command, error) {
+  const message = error?.message || String(error);
+  const mapped = mapError(message);
+  return {
+    payload: {
+      success: false,
+      command: command || 'unknown',
+      data: null,
+      warnings: [],
+      error: {
+        code: mapped.code,
+        message,
+        retryable: mapped.retryable,
+      },
+      meta: {},
+    },
+    exitCode: mapped.exitCode,
+  };
+}
+
+export function getCommandName(platform, command) {
+  return [platform, command].filter(Boolean).join(' ') || 'unknown';
+}
+
+export function buildCommandRegistry() {
+  const shortcuts = listShortcuts().map((shortcut) => shortcutToCommand(shortcut));
+  const endpoints = listEndpoints().map((endpoint) => endpointToCommand(endpoint));
+  return [...shortcuts, ...endpoints].sort((left, right) =>
+    left.key.localeCompare(right.key),
+  );
+}
+
+export function findCommandByKey(key) {
+  return buildCommandRegistry().find((item) => item.key === key);
+}
+
+export function commandToSchema(command) {
+  if (!command) {
+    return null;
+  }
+
+  return {
+    key: command.key,
+    command: command.command,
+    kind: command.kind,
+    description: command.description,
+    cli: {
+      positionals: command.positionals || [],
+      options: command.options || [],
+    },
+    api: {
+      method: command.method,
+      socialPath: command.socialPath,
+      url: `/social${command.socialPath}`,
+      queryParams: command.queryParams || [],
+      requestBody: command.requestBody || null,
+    },
+    returns: command.returns || '返回字段以上游接口实际响应为准。',
+  };
+}
+
+function shortcutToCommand(shortcut) {
+  return {
+    key: `${shortcut.platform}.${shortcut.command}`,
+    command: `${shortcut.platform} ${shortcut.command}`,
+    kind: 'shortcut',
+    description: shortcut.description,
+    method: shortcut.method,
+    socialPath: shortcut.socialPath,
+    positionals: shortcut.positionals,
+    options: shortcut.options.map((item) => ({
+      ...item,
+      flag: `--${item.flag}`,
+      required: false,
+    })),
+    returns: shortcut.returns,
+    alternatives: shortcut.alternatives,
+  };
+}
+
+function endpointToCommand(endpoint) {
+  const command = `${endpoint.platform} ${endpoint.command}`;
+  return {
+    key: command.replace(/\s+/g, '.'),
+    command,
+    kind: 'endpoint',
+    description: endpoint.summary,
+    method: endpoint.method,
+    socialPath: endpoint.socialPath,
+    positionals: [],
+    options: (endpoint.queryParams || []).map((item) => ({
+      flag: `--${item.name.replace(/_/g, '-')}`,
+      name: item.name,
+      required: item.required,
+      label: item.description || item.name,
+    })),
+    queryParams: endpoint.queryParams || [],
+    requestBody: endpoint.bodyExample,
+    returns: '返回字段以上游接口实际响应为准。',
+  };
+}
+
+function mapError(message) {
+  const mapped = ERROR_MAP.find((item) => item.test(message));
+  if (mapped) {
+    return mapped;
+  }
+  return {
+    code: 'INTERNAL_ERROR',
+    exitCode: 1,
+    retryable: false,
+  };
+}

package/src/cli.js

@@ -0,0 +1,382 @@
+import { writeFile } from 'node:fs/promises';
+import { getConfigFilePath, readConfig, writeConfig } from './config.js';
+import {
+  findEndpointByAlias,
+  findEndpointByCommand,
+  getPlatforms,
+  listEndpoints,
+} from './registry.js';
+import { callEndpoint } from './request.js';
+import {
+  buildCommandRegistry,
+  commandToSchema,
+  createAgentSuccess,
+  findCommandByKey,
+  getCommandName,
+  isAgentJsonFormat,
+} from './agent-protocol.js';
+import { findShortcut, listShortcuts } from './shortcuts.js';
+
+export async function main(argv) {
+  const args = argv.slice(2);
+  const [command, ...rest] = args;
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (command === 'config') {
+    await handleConfig(rest);
+    return;
+  }
+
+  if (command === 'list') {
+    handleList(rest);
+    return;
+  }
+
+  if (command === 'shortcuts') {
+    handleShortcuts(rest);
+    return;
+  }
+
+  if (command === 'commands') {
+    await handleCommands(rest);
+    return;
+  }
+
+  if (command === 'schema') {
+    await handleSchema(rest);
+    return;
+  }
+
+  if (command === 'call') {
+    await handleCall(rest);
+    return;
+  }
+
+  await handleGeneratedCommand(command, rest);
+}
+
+async function handleCommands(args) {
+  const { positionals, options } = parseOptions(args);
+  const [action, key] = positionals;
+
+  if (!action || action === 'list') {
+    const commands = buildCommandRegistry().map((item) => ({
+      key: item.key,
+      command: item.command,
+      kind: item.kind,
+      description: item.description,
+      method: item.method,
+      socialPath: item.socialPath,
+    }));
+    await outputResult(
+      createAgentSuccess('commands list', { commands }),
+      { ...options, forceJson: true },
+    );
+    return;
+  }
+
+  if (action === 'describe') {
+    if (!key) {
+      throw new Error('缺少命令标识，例如 douyin.video-detail');
+    }
+    const command = findCommandByKey(key);
+    if (!command) {
+      throw new Error(`未找到命令: ${key}`);
+    }
+    await outputResult(createAgentSuccess('commands describe', command), {
+      ...options,
+      forceJson: true,
+    });
+    return;
+  }
+
+  throw new Error('未知 commands 命令。用法：yuanflow-cli commands list');
+}
+
+async function handleSchema(args) {
+  const { positionals, options } = parseOptions(args);
+  const [key] = positionals;
+
+  if (!key || key === 'list') {
+    const commands = buildCommandRegistry().map((item) => ({
+      key: item.key,
+      command: item.command,
+      kind: item.kind,
+      method: item.method,
+      socialPath: item.socialPath,
+    }));
+    await outputResult(createAgentSuccess('schema list', { commands }), {
+      ...options,
+      forceJson: true,
+    });
+    return;
+  }
+
+  const command = findCommandByKey(key);
+  if (!command) {
+    throw new Error(`不支持的 schema 命令: ${key}`);
+  }
+  await outputResult(
+    createAgentSuccess(`schema ${key}`, commandToSchema(command)),
+    { ...options, forceJson: true },
+  );
+}
+
+async function handleConfig(args) {
+  const [action, key, ...valueParts] = args;
+  const value = valueParts.join(' ');
+
+  if (!action || action === 'show') {
+    const config = await readConfig();
+    console.log(JSON.stringify({ ...config, token: maskToken(config.token) }, null, 2));
+    console.log(`配置文件：${getConfigFilePath()}`);
+    return;
+  }
+
+  if (action === 'set-token') {
+    await writeConfig({ token: key || value });
+    console.log('token 已保存');
+    return;
+  }
+
+  if (action === 'set-base-url') {
+    await writeConfig({ baseUrl: key || value });
+    console.log('baseUrl 已保存');
+    return;
+  }
+
+  throw new Error('未知 config 命令。用法：yuanflow-cli config set-token <你的令牌>');
+}
+
+function handleList(args) {
+  const [platform] = args;
+  const endpoints = listEndpoints().filter((endpoint) => {
+    return platform ? endpoint.platform === platform : true;
+  });
+
+  for (const endpoint of endpoints) {
+    const aliases = endpoint.aliases.length > 0 ? ` aliases: ${endpoint.aliases.join(', ')}` : '';
+    console.log(`${endpoint.platform} ${endpoint.command} -> ${endpoint.method} /social${endpoint.socialPath}${aliases}`);
+  }
+}
+
+function handleShortcuts(args) {
+  const [platform] = args;
+  const items = listShortcuts(platform);
+  if (platform && items.length === 0) {
+    throw new Error(`未找到平台 ${platform} 的快捷命令。`);
+  }
+
+  for (const shortcut of items) {
+    const positionalUsage = shortcut.positionals.map((item) => `<${item.name}>`).join(' ');
+    const optionUsage = shortcut.options.map((item) => `[--${item.flag}]`).join(' ');
+    const usage = [shortcut.platform, shortcut.command, positionalUsage, optionUsage]
+      .filter(Boolean)
+      .join(' ');
+    console.log(`${usage}`);
+    console.log(`  ${shortcut.description}`);
+    console.log(`  接口：${shortcut.method} /social${shortcut.socialPath}`);
+    if (shortcut.positionals.length > 0 || shortcut.options.length > 0) {
+      console.log('  参数：');
+      for (const item of shortcut.positionals) {
+        console.log(`    <${item.name}> ${item.label}`);
+      }
+      for (const item of shortcut.options) {
+        console.log(`    --${item.flag} ${item.label}`);
+      }
+    }
+    console.log(`  返回：${shortcut.returns}`);
+    if (shortcut.alternatives.length > 0) {
+      console.log(`  备用接口：${shortcut.alternatives.join('；')}`);
+    }
+  }
+}
+
+async function handleCall(args) {
+  const { positionals, options } = parseOptions(args);
+  const [socialPath] = positionals;
+  if (!socialPath) {
+    throw new Error('缺少接口路径。示例：yuanflow-cli call /douyin/web/fetch_multi_video_v2 --json "{\"url\":\"...\"}"');
+  }
+
+  const result = await callEndpoint(socialPath, options);
+  await outputResult(result, options, {
+    command: `call ${socialPath}`,
+    meta: { endpoint: socialPath },
+  });
+}
+
+async function handleGeneratedCommand(platform, args) {
+  if (!getPlatforms().includes(platform)) {
+    throw new Error(`未知平台：${platform}。可用平台：${getPlatforms().join(', ')}`);
+  }
+
+  const { positionals, options } = parseOptions(args);
+  const [commandOrAlias, ...rest] = positionals;
+  const shortcut = findShortcut(platform, commandOrAlias);
+
+  if (shortcut) {
+    const body = buildShortcutBody(shortcut, rest, options);
+    const result = await callEndpoint(shortcut.socialPath, {
+      ...options,
+      method: shortcut.method,
+      body,
+    });
+    await outputResult(result, options, {
+      command: getCommandName(platform, shortcut.command),
+      meta: { endpoint: shortcut.socialPath, kind: 'shortcut' },
+    });
+    return;
+  }
+
+  const aliasEndpoint = findEndpointByAlias(platform, commandOrAlias);
+  const endpoint = aliasEndpoint || findEndpointByCommand(platform, [commandOrAlias, ...rest]);
+  const commandArgs = aliasEndpoint ? rest : [];
+
+  if (!endpoint) {
+    throw new Error(`未找到命令：${platform} ${positionals.join(' ')}。可执行 yuanflow-cli list ${platform} 查看命令。`);
+  }
+
+  const body = buildBodyFromPositionals(endpoint, commandArgs, options);
+  const result = await callEndpoint(endpoint.socialPath, {
+    ...options,
+    method: endpoint.method,
+    body,
+  });
+  await outputResult(result, options, {
+    command: getCommandName(platform, endpoint.command),
+    meta: { endpoint: endpoint.socialPath, kind: 'endpoint' },
+  });
+}
+
+function buildShortcutBody(shortcut, rest, options) {
+  if (options.json || options.file) {
+    return undefined;
+  }
+
+  const body = { ...(shortcut.defaults || {}) };
+  for (const [index, item] of shortcut.positionals.entries()) {
+    const value = rest[index];
+    if (value === undefined) {
+      throw new Error(`缺少参数 <${item.name}>。可执行 yuanflow-cli shortcuts ${shortcut.platform} 查看用法。`);
+    }
+    body[item.name] = value;
+  }
+
+  for (const item of shortcut.options) {
+    const value = options.named?.[item.flag];
+    if (value !== undefined) {
+      body[item.name] = value;
+    }
+  }
+
+  return body;
+}
+
+function buildBodyFromPositionals(endpoint, rest, options) {
+  if (options.json || options.file) {
+    return undefined;
+  }
+
+  if (endpoint.aliases.includes('video-detail') && rest.length > 0) {
+    return { url: rest[0] };
+  }
+
+  return {};
+}
+
+function parseOptions(args) {
+  const options = { named: {} };
+  const positionals = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--json') {
+      options.json = args[++index];
+    } else if (arg === '--file') {
+      options.file = args[++index];
+    } else if (arg === '--output' || arg === '-o') {
+      options.output = args[++index];
+    } else if (arg === '--base-url') {
+      options.baseUrl = args[++index];
+    } else if (arg === '--token') {
+      options.token = args[++index];
+    } else if (arg === '--method') {
+      options.method = args[++index];
+    } else if (arg === '--format') {
+      options.format = args[++index];
+    } else if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (arg.startsWith('--')) {
+      const name = arg.slice(2);
+      const next = args[index + 1];
+      if (next === undefined || next.startsWith('--')) {
+        options.named[name] = true;
+      } else {
+        options.named[name] = args[++index];
+      }
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  return { positionals, options };
+}
+
+async function outputResult(result, options, agentContext = {}) {
+  if (isAgentJsonFormat(options) && !options.forceJson) {
+    const payload = createAgentSuccess(
+      agentContext.command || 'unknown',
+      result,
+      agentContext.meta || {},
+    );
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    return;
+  }
+
+  const text = typeof result === 'string' ? result : `${JSON.stringify(result, null, 2)}\n`;
+  if (options.output) {
+    await writeFile(options.output, text, 'utf8');
+    console.log(`已保存：${options.output}`);
+    return;
+  }
+  process.stdout.write(text);
+}
+
+function printHelp() {
+  console.log(`yuanflow-cli
+
+用法：
+  yuanflow-cli config set-token <你的令牌>
+  yuanflow-cli config set-base-url https://open.yuanchuangai.com
+  yuanflow-cli call /douyin/app/v3/fetch_multi_video_v2 --json '{"url":"https://v.douyin.com/xxx/"}'
+  yuanflow-cli douyin video-detail "https://v.douyin.com/xxx/"
+  yuanflow-cli douyin video-detail "https://v.douyin.com/xxx/" --dry-run
+  yuanflow-cli douyin video-download "https://v.douyin.com/xxx/" --region CN
+  yuanflow-cli xiaohongshu note-detail note_id --xsec-token xxx
+  yuanflow-cli bilibili user-posts uid --page 1
+  yuanflow-cli wechat channels-search "关键词"
+  yuanflow-cli shortcuts douyin
+  yuanflow-cli commands list
+  yuanflow-cli schema douyin.video-detail
+  yuanflow-cli list douyin
+
+说明：
+  所有请求都会调用 Yuan API 的 /social/*path，并使用 Authorization: Bearer <token>。
+  AI Agent 推荐使用 --format agent-json 获取稳定 JSON 外壳。
+`);
+}
+
+function maskToken(token) {
+  if (!token) {
+    return '';
+  }
+  if (token.length <= 10) {
+    return '***';
+  }
+  return `${token.slice(0, 6)}...${token.slice(-4)}`;
+}

package/src/config.js

@@ -0,0 +1,31 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+const CONFIG_DIR = path.join(homedir(), '.yuanflow-cli');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_CONFIG = {
+  baseUrl: 'https://open.yuanchuangai.com',
+  token: '',
+};
+
+export async function readConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, 'utf8');
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export async function writeConfig(nextConfig) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  const config = { ...(await readConfig()), ...nextConfig };
+  await writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  return config;
+}
+
+export function getConfigFilePath() {
+  return CONFIG_FILE;
+}

package/src/registry.js

@@ -0,0 +1,45 @@
+import registry from '../generated/registry.json' with { type: 'json' };
+
+export function listEndpoints() {
+  return registry.endpoints;
+}
+
+export function findEndpointByPath(socialPath) {
+  const normalized = normalizeSocialPath(socialPath);
+  return registry.endpoints.find((endpoint) => endpoint.socialPath === normalized);
+}
+
+export function findEndpointByCommand(platform, commandParts) {
+  const command = commandParts.join(' ');
+  return registry.endpoints.find(
+    (endpoint) => endpoint.platform === platform && endpoint.command === command,
+  );
+}
+
+export function findEndpointByAlias(platform, alias) {
+  return registry.endpoints.find(
+    (endpoint) => endpoint.platform === platform && endpoint.aliases.includes(alias),
+  );
+}
+
+export function getPlatforms() {
+  return registry.platforms;
+}
+
+export function normalizeSocialPath(value) {
+  if (!value || typeof value !== 'string') {
+    return '';
+  }
+
+  const trimmed = value.trim();
+  if (trimmed.startsWith('/social/')) {
+    return trimmed.slice('/social'.length);
+  }
+  if (trimmed.startsWith('/api/v1/')) {
+    return trimmed.slice('/api/v1'.length);
+  }
+  if (!trimmed.startsWith('/')) {
+    return `/${trimmed}`;
+  }
+  return trimmed;
+}