yuanflow-cli 0.1.0 → 0.1.1

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;
+}

package/src/request.js

@@ -0,0 +1,97 @@
+import { readFile } from 'node:fs/promises';
+import { readConfig } from './config.js';
+import { findEndpointByPath, normalizeSocialPath } from './registry.js';
+
+export async function callEndpoint(socialPath, options = {}) {
+  const config = await readConfig();
+  const baseUrl = cleanBaseUrl(options.baseUrl || config.baseUrl);
+  const token = options.token || config.token || process.env.YUANFLOW_TOKEN || '';
+  const normalizedPath = normalizeSocialPath(socialPath);
+  const endpoint = findEndpointByPath(normalizedPath);
+  const method = options.method || endpoint?.method || 'POST';
+  const url = new URL(`/social${normalizedPath}`, baseUrl);
+
+  if (!token) {
+    throw new Error('缺少 token。请先执行 yuanflow-cli config set-token <你的令牌>');
+  }
+
+  const body = await resolveBody(options);
+  if (method.toUpperCase() === 'GET' && body && typeof body === 'object') {
+    for (const [key, value] of Object.entries(body)) {
+      if (value !== undefined && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+
+  if (options.dryRun) {
+    return {
+      dryRun: true,
+      method: method.toUpperCase(),
+      url: url.toString(),
+      headers: {
+        Authorization: `Bearer ${maskToken(token)}`,
+      },
+      body: method.toUpperCase() === 'GET' ? undefined : body || {},
+    };
+  }
+
+  const response = await fetch(url, {
+    method: method.toUpperCase(),
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json',
+      ...(method.toUpperCase() === 'GET' ? {} : { 'Content-Type': 'application/json' }),
+    },
+    body: method.toUpperCase() === 'GET' ? undefined : JSON.stringify(body || {}),
+  });
+
+  const text = await response.text();
+  const payload = parseMaybeJson(text);
+
+  if (!response.ok) {
+    const message = typeof payload === 'object' ? JSON.stringify(payload) : text;
+    throw new Error(`请求失败：HTTP ${response.status} ${message}`);
+  }
+
+  return payload;
+}
+
+async function resolveBody(options) {
+  if (options.json) {
+    return JSON.parse(options.json);
+  }
+  if (options.file) {
+    const raw = await readFile(options.file, 'utf8');
+    return JSON.parse(raw);
+  }
+  if (options.body) {
+    return options.body;
+  }
+  return {};
+}
+
+function cleanBaseUrl(value) {
+  return (value || 'https://open.yuanchuangai.com').replace(/\/+$/, '');
+}
+
+function parseMaybeJson(text) {
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function maskToken(token) {
+  if (!token) {
+    return '';
+  }
+  if (token.length <= 10) {
+    return '***';
+  }
+  return `${token.slice(0, 6)}...${token.slice(-4)}`;
+}