yuanflow-cli 0.1.0 → 0.1.1

package/lib/skill-installer/repo-source.cjs

@@ -0,0 +1,157 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+function readPackageJson(packageRoot) {
+  return JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+}
+
+function readRepositoryConfig(packageRoot) {
+  const packageJson = readPackageJson(packageRoot);
+  const skillRepo = packageJson.yuanflowSkill && packageJson.yuanflowSkill.skillRepo;
+
+  if (!skillRepo || !skillRepo.owner || !skillRepo.repo || !skillRepo.ref) {
+    throw new Error('package.json 缺少 yuanflowSkill.skillRepo 配置。');
+  }
+
+  return {
+    owner: skillRepo.owner,
+    repo: skillRepo.repo,
+    ref: skillRepo.ref,
+  };
+}
+
+function buildArchiveUrl(repoConfig) {
+  if (process.env.YUANFLOW_SKILL_ARCHIVE_URL) {
+    return process.env.YUANFLOW_SKILL_ARCHIVE_URL;
+  }
+
+  return `https://codeload.github.com/${repoConfig.owner}/${repoConfig.repo}/tar.gz/refs/heads/${repoConfig.ref}`;
+}
+
+function buildGitUrl(repoConfig) {
+  if (process.env.YUANFLOW_SKILL_GIT_URL) {
+    return process.env.YUANFLOW_SKILL_GIT_URL;
+  }
+
+  return `https://github.com/${repoConfig.owner}/${repoConfig.repo}.git`;
+}
+
+async function downloadArchive({ url, targetFile }) {
+  const response = await fetch(url, {
+    headers: {
+      'user-agent': 'yuanflow-cli',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`下载 skill 仓库失败：${response.status} ${response.statusText}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  fs.writeFileSync(targetFile, Buffer.from(arrayBuffer));
+}
+
+function extractArchive(archivePath, extractDir) {
+  execFileSync('tar', ['-xzf', archivePath, '-C', extractDir], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function cloneRepository({ repoConfig, targetDir }) {
+  execFileSync(
+    'git',
+    ['clone', '--depth', '1', '--branch', repoConfig.ref, buildGitUrl(repoConfig), targetDir],
+    {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }
+  );
+}
+
+function resolveRepositoryRoot(extractDir) {
+  if (fs.existsSync(path.join(extractDir, 'SKILL.md'))) {
+    return extractDir;
+  }
+
+  const entries = fs.readdirSync(extractDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const candidate = path.join(extractDir, entry.name);
+    if (fs.existsSync(path.join(candidate, 'SKILL.md'))) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`解压后的内容里没有找到 SKILL.md：${extractDir}`);
+}
+
+function resolveLocalSkillRoot(packageRoot) {
+  const localRoot = path.resolve(packageRoot, '..', 'YuanFlow-skill');
+  if (fs.existsSync(path.join(localRoot, 'SKILL.md'))) {
+    return localRoot;
+  }
+  return '';
+}
+
+async function prepareSkillSource({ packageRoot }) {
+  const localRoot = resolveLocalSkillRoot(packageRoot);
+  if (localRoot) {
+    return {
+      sourceRoot: localRoot,
+      cleanup() {},
+    };
+  }
+
+  const repoConfig = readRepositoryConfig(packageRoot);
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'yuanflow-skill-'));
+  const archiveFile = path.join(tempRoot, `${repoConfig.repo}-${repoConfig.ref}.tar.gz`);
+  const extractDir = path.join(tempRoot, 'extract');
+  const cloneDir = path.join(tempRoot, 'clone');
+
+  fs.mkdirSync(extractDir, { recursive: true });
+
+  let sourceRoot;
+  let archiveError;
+
+  try {
+    await downloadArchive({
+      url: buildArchiveUrl(repoConfig),
+      targetFile: archiveFile,
+    });
+    extractArchive(archiveFile, extractDir);
+    sourceRoot = resolveRepositoryRoot(extractDir);
+  } catch (error) {
+    archiveError = error;
+  }
+
+  if (!sourceRoot) {
+    try {
+      cloneRepository({ repoConfig, targetDir: cloneDir });
+      sourceRoot = resolveRepositoryRoot(cloneDir);
+    } catch (gitError) {
+      const archiveMessage = archiveError instanceof Error ? archiveError.message : String(archiveError);
+      const gitMessage = gitError instanceof Error ? gitError.message : String(gitError);
+      throw new Error(`下载 skill 仓库失败。archive: ${archiveMessage}; git: ${gitMessage}`);
+    }
+  }
+
+  return {
+    sourceRoot,
+    cleanup() {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    },
+  };
+}
+
+module.exports = {
+  buildArchiveUrl,
+  buildGitUrl,
+  prepareSkillSource,
+  readRepositoryConfig,
+  resolveRepositoryRoot,
+  resolveLocalSkillRoot,
+};

package/package.json

@@ -1,22 +1,72 @@
 {
   "name": "yuanflow-cli",
-  "version": "0.1.0",
-  "private": false,
+  "version": "0.1.1",
+  "description": "YuanFlow API CLI and skill installer for supported AI coding agents.",
   "type": "module",
-  "description": "NPM packaging wrapper for YuanFlow CLI",
+  "license": "MIT",
+  "private": false,
+  "author": "zktlove",
   "publishConfig": {
     "access": "public"
   },
   "bin": {
-    "ycloud": "cli.js"
+    "yuanflow-cli": "bin/yuanflow-cli.js",
+    "yuanflow-skill": "bin/yuanflow-skill.cjs"
+  },
+  "scripts": {
+    "postinstall": "node ./bin/yuanflow-skill.cjs install --postinstall",
+    "generate": "node ./scripts/generate-registry.js",
+    "start": "node ./bin/yuanflow-cli.js",
+    "test": "node --test test/*.test.js tests/*.test.cjs",
+    "pack:check": "npm pack --dry-run",
+    "release:check": "node ./bin/yuanflow-skill.cjs release-check",
+    "publish:help": "node ./bin/yuanflow-skill.cjs publish-help"
   },
   "files": [
-    "cli.js",
+    "bin",
     "src",
+    "generated",
+    "scripts",
+    "lib",
     "README.md",
     "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zktlove/yuanflow-cli.git"
+  },
+  "homepage": "https://github.com/zktlove/yuanflow-cli#readme",
+  "bugs": {
+    "url": "https://github.com/zktlove/yuanflow-cli/issues"
+  },
+  "yuanflowSkill": {
+    "skillRepo": {
+      "owner": "zktlove",
+      "repo": "yuanflow-skill",
+      "ref": "main"
+    }
+  },
   "engines": {
     "node": ">=20"
-  }
+  },
+  "keywords": [
+    "skills",
+    "ai-agent",
+    "codex",
+    "claude-code",
+    "cursor",
+    "opencode",
+    "github-copilot",
+    "gemini-cli",
+    "kimi-cli",
+    "openclaw",
+    "trae",
+    "windsurf",
+    "qoder",
+    "qwen-code",
+    "yuanflow-cli",
+    "yuanflow-skill",
+    "xiaohongshu",
+    "douyin"
+  ]
 }

package/scripts/generate-registry.js

@@ -0,0 +1,174 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = path.resolve(__dirname, '..');
+const PROJECT_ROOT = path.resolve(CLI_ROOT, '..');
+const OPENAPI_FILE = path.join(
+  PROJECT_ROOT,
+  'docs',
+  'social-api-tikhub',
+  'tikhubopenapi.latest.json',
+);
+const OUTPUT_FILE = path.join(CLI_ROOT, 'generated', 'registry.json');
+
+const ALIAS_RULES = [
+  {
+    alias: 'video-detail',
+    test: (entry) => {
+      return (
+        entry.platform === 'douyin' &&
+        entry.socialPath === '/douyin/app/v3/fetch_multi_video_v2'
+      );
+    },
+  },
+];
+
+const EXCLUDED_TAG_PATTERNS = [
+  /deprecated/i,
+  /sora2/i,
+  /hybrid/i,
+  /demo/i,
+  /shortcut/i,
+  /temp-mail/i,
+  /tikhub-user/i,
+  /downloader/i,
+  /health/i,
+];
+
+async function main() {
+  const api = JSON.parse(await readFile(OPENAPI_FILE, 'utf8'));
+  const endpoints = [];
+
+  for (const [rawPath, pathItem] of Object.entries(api.paths || {})) {
+    for (const [method, operation] of Object.entries(pathItem || {})) {
+      if (!['get', 'post', 'put', 'patch', 'delete'].includes(method)) {
+        continue;
+      }
+
+      const tag = operation.tags?.[0] || 'Other';
+      if (shouldSkip(tag, operation)) {
+        continue;
+      }
+
+      const socialPath = toSocialPath(rawPath);
+      if (!socialPath) {
+        continue;
+      }
+
+      const platform = inferPlatform(tag, socialPath);
+      const command = toCommand(socialPath, platform);
+      const endpoint = {
+        id: operation.operationId || `${method}_${socialPath.replaceAll('/', '_')}`,
+        platform,
+        tag,
+        command,
+        aliases: [],
+        method: method.toUpperCase(),
+        upstreamPath: rawPath,
+        socialPath,
+        summary: cleanText(operation.summary || ''),
+        bodyExample: extractBodyExample(operation),
+        queryParams: extractQueryParams(operation),
+      };
+
+      endpoint.aliases = ALIAS_RULES.filter((rule) => rule.test(endpoint)).map(
+        (rule) => rule.alias,
+      );
+      endpoints.push(endpoint);
+    }
+  }
+
+  endpoints.sort((a, b) => {
+    return `${a.platform} ${a.command}`.localeCompare(`${b.platform} ${b.command}`);
+  });
+
+  const registry = {
+    generatedAt: new Date().toISOString(),
+    source: 'YuanFlow API registry',
+    platforms: [...new Set(endpoints.map((endpoint) => endpoint.platform))].sort(),
+    endpoints,
+  };
+
+  await mkdir(path.dirname(OUTPUT_FILE), { recursive: true });
+  await writeFile(OUTPUT_FILE, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+  console.log(`Generated ${endpoints.length} endpoints -> ${OUTPUT_FILE}`);
+}
+
+function shouldSkip(tag, operation) {
+  const haystack = `${tag} ${operation.summary || ''} ${operation.description || ''}`;
+  return EXCLUDED_TAG_PATTERNS.some((pattern) => pattern.test(haystack));
+}
+
+function toSocialPath(rawPath) {
+  if (!rawPath.startsWith('/api/v1/')) {
+    return null;
+  }
+  return rawPath.slice('/api/v1'.length);
+}
+
+function inferPlatform(tag, socialPath) {
+  const lowerTag = tag.toLowerCase();
+  const firstSegment = socialPath.split('/').filter(Boolean)[0] || 'other';
+
+  if (lowerTag.includes('xiaohongshu')) return 'xiaohongshu';
+  if (lowerTag.includes('tiktok')) return 'tiktok';
+  if (lowerTag.includes('douyin')) return 'douyin';
+  if (lowerTag.includes('bilibili')) return 'bilibili';
+  if (lowerTag.includes('kuaishou')) return 'kuaishou';
+  if (lowerTag.includes('weibo')) return 'weibo';
+  if (lowerTag.includes('wechat')) return 'wechat';
+  if (lowerTag.includes('youtube')) return 'youtube';
+  if (lowerTag.includes('twitter')) return 'twitter';
+  if (lowerTag.includes('instagram')) return 'instagram';
+  if (lowerTag.includes('threads')) return 'threads';
+  if (lowerTag.includes('reddit')) return 'reddit';
+  if (lowerTag.includes('zhihu')) return 'zhihu';
+  if (lowerTag.includes('lemon8')) return 'lemon8';
+  if (lowerTag.includes('xigua')) return 'xigua';
+  if (lowerTag.includes('linkedin')) return 'linkedin';
+  if (lowerTag.includes('netease')) return 'netease';
+
+  return normalizeName(firstSegment);
+}
+
+function toCommand(socialPath, platform) {
+  const segments = socialPath.split('/').filter(Boolean);
+  const withoutPlatform = segments[0] === platform ? segments.slice(1) : segments;
+  return withoutPlatform.map(normalizeName).join(' ');
+}
+
+function normalizeName(value) {
+  return String(value)
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/_/g, '-')
+    .replace(/[^a-zA-Z0-9-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .toLowerCase();
+}
+
+function cleanText(value) {
+  return String(value).replace(/\s+/g, ' ').trim();
+}
+
+function extractBodyExample(operation) {
+  const content = operation.requestBody?.content?.['application/json'];
+  return content?.example || content?.examples?.default?.value || null;
+}
+
+function extractQueryParams(operation) {
+  return (operation.parameters || [])
+    .filter((parameter) => parameter.in === 'query')
+    .map((parameter) => ({
+      name: parameter.name,
+      required: Boolean(parameter.required),
+      description: cleanText(parameter.description || ''),
+    }));
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

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