yuanflow-cli 0.1.0

package/src/ycloud/commands/compliance.js

@@ -0,0 +1,146 @@
+import { apiPost } from "../core/http.js";
+import { getToken } from "../core/token.js";
+import { getGlobalFlagsHelp, parseJsonString } from "./shared.js";
+
+export function getComplianceHelp() {
+  return `Check content compliance risk
+
+Usage:
+  ycloud compliance check [flags]
+
+Required Flags:
+  --content string       inline content text
+  --content-file string  UTF-8 text file path
+
+Optional Flags:
+  --project-id string    project id
+  --metadata string      JSON object string
+  --metadata-file string local JSON file path
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud compliance check --content "这是一个短视频口播文案测试文本" --output json
+  ycloud compliance check --content-file content.txt --output json
+
+Read on success:
+  data.passed
+  data.issues
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+}
+
+async function requireToken(context) {
+  const token = await getToken();
+  if (!token) {
+    return context.fail(
+      context.commandName,
+      "TOKEN_MISSING",
+      "缺少 YUANCHUANG_API_TOKEN",
+      3,
+      false,
+    );
+  }
+  return token;
+}
+
+export async function executeComplianceCheck(context, tokens) {
+  const options = context.parseCommandFlags(tokens);
+  if (!options.content && !options["content-file"]) {
+    return context.fail(
+      "compliance check",
+      "BAD_ARGUMENT",
+      "必须提供 --content 或 --content-file",
+      2,
+      false,
+    );
+  }
+  if (options.content && options["content-file"]) {
+    return context.fail(
+      "compliance check",
+      "BAD_ARGUMENT",
+      "--content 和 --content-file 只能二选一",
+      2,
+      false,
+    );
+  }
+  if (options.metadata && options["metadata-file"]) {
+    return context.fail(
+      "compliance check",
+      "BAD_ARGUMENT",
+      "--metadata 和 --metadata-file 只能二选一",
+      2,
+      false,
+    );
+  }
+
+  const token = await requireToken(context);
+  if (typeof token !== "string") {
+    return token;
+  }
+
+  let content = options.content;
+  if (options["content-file"]) {
+    const { readFile } = await import("node:fs/promises");
+    try {
+      content = await readFile(options["content-file"], { encoding: "utf-8" });
+    } catch {
+      return context.fail(
+        "compliance check",
+        "BAD_ARGUMENT",
+        "--content-file 必须是合法 UTF-8 文本文件",
+        2,
+        false,
+      );
+    }
+  }
+
+  let metadata = undefined;
+  if (options.metadata) {
+    try {
+      metadata = parseJsonString(options.metadata);
+    } catch {
+      return context.fail(
+        "compliance check",
+        "BAD_ARGUMENT",
+        "--metadata 必须是合法 JSON",
+        2,
+        false,
+      );
+    }
+  }
+
+  if (options["metadata-file"]) {
+    const { readFile } = await import("node:fs/promises");
+    try {
+      metadata = JSON.parse(
+        await readFile(options["metadata-file"], { encoding: "utf-8" }),
+      );
+    } catch {
+      return context.fail(
+        "compliance check",
+        "BAD_ARGUMENT",
+        "--metadata-file 必须是合法 JSON 文件",
+        2,
+        false,
+      );
+    }
+  }
+
+  const data = await apiPost("/v1/compliance/check", {
+    token,
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+    body: {
+      project_id: options["project-id"],
+      content,
+      metadata,
+    },
+  });
+
+  return context.ok("compliance check", data);
+}

package/src/ycloud/commands/config.js

@@ -0,0 +1,103 @@
+import {
+  clearConfigKey,
+  getConfigPath,
+  maskToken,
+  readConfig,
+  updateConfig,
+} from "../core/config.js";
+import { getTokenWithSource } from "../core/token.js";
+import { getGlobalFlagsHelp } from "./shared.js";
+
+export function getConfigHelp(subcommand) {
+  if (subcommand === "set-token") {
+    return `Store API token into local CLI config file
+
+Usage:
+  ycloud config set-token <token>
+
+Optional Flags:
+  none
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud config set-token yc-xxxx
+`;
+  }
+
+  if (subcommand === "get") {
+    return `Read current local CLI config
+
+Usage:
+  ycloud config get
+
+Optional Flags:
+  none
+
+${getGlobalFlagsHelp()}
+`;
+  }
+
+  if (subcommand === "clear-token") {
+    return `Clear stored API token from local CLI config
+
+Usage:
+  ycloud config clear-token
+
+Optional Flags:
+  none
+
+${getGlobalFlagsHelp()}
+`;
+  }
+
+  return `Config commands
+
+Usage:
+  ycloud config <set-token|get|clear-token> [flags]`;
+}
+
+export async function executeConfigSetToken(context, tokens) {
+  const token = (tokens[0] || "").trim();
+  if (!token) {
+    return context.fail(
+      "config set-token",
+      "BAD_ARGUMENT",
+      "缺少 token 参数",
+      2,
+      false,
+    );
+  }
+
+  await updateConfig({ token });
+  return context.ok("config set-token", {
+    token_present: true,
+    token_masked: maskToken(token),
+    token_source: "config",
+    config_path: getConfigPath(),
+  });
+}
+
+export async function executeConfigGet(context) {
+  const config = await readConfig();
+  const { token, source } = await getTokenWithSource();
+  return context.ok("config get", {
+    config_path: getConfigPath(),
+    token_present: Boolean(token),
+    token_source: source,
+    token_masked: maskToken(token),
+    base_url: config.base_url || null,
+    default_output: config.default_output || null,
+    timeout: config.timeout || null,
+  });
+}
+
+export async function executeConfigClearToken(context) {
+  await clearConfigKey("token");
+  return context.ok("config clear-token", {
+    token_present: false,
+    token_source: null,
+    token_masked: null,
+    config_path: getConfigPath(),
+  });
+}

package/src/ycloud/commands/health.js

@@ -0,0 +1,35 @@
+import { apiGet } from "../core/http.js";
+import { getGlobalFlagsHelp } from "./shared.js";
+
+export function getHealthHelp() {
+  return `Check cloud API health
+
+Usage:
+  ycloud health check [flags]
+
+Optional Flags:
+  none
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud health check --output json
+
+Read on success:
+  success
+  data
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+}
+
+export async function executeHealthCheck(context) {
+  const data = await apiGet("/v1/health", {
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+  });
+  return context.ok("health check", data);
+}

package/src/ycloud/commands/index.js

@@ -0,0 +1,381 @@
+import {
+  executeAuthCharges,
+  executeAuthInfo,
+  executeAuthStatus,
+  executeAuthValidate,
+  getAuthHelp,
+} from "./auth.js";
+import {
+  executeAnalysisCreatorProfile,
+  getAnalysisHelp,
+} from "./analysis.js";
+import {
+  executeComplianceCheck,
+  getComplianceHelp,
+} from "./compliance.js";
+import {
+  buildExposedCommands,
+  executeCommandsDescribe,
+  executeCommandsList,
+  getCommandsHelp,
+} from "./commands.js";
+import {
+  executeConfigClearToken,
+  executeConfigGet,
+  executeConfigSetToken,
+  getConfigHelp,
+} from "./config.js";
+import { executeHealthCheck, getHealthHelp } from "./health.js";
+import { executeKbSearch, getKbHelp } from "./kb.js";
+import { executeSchema, getSchemaHelp } from "./schema.js";
+import { buildToolRegistry } from "./tool-registry.js";
+import {
+  createDomainHelp,
+  createToolCommandHelp,
+  executeRegisteredTool,
+} from "./tool-runner.js";
+import { executeToolCatalog, executeToolExecute, getToolHelp } from "./tool.js";
+import { executeVersionCheck, getVersionHelp } from "./version.js";
+
+const TOP_LEVEL_HELP = `YuanFlow CLI local command tool for Agent-friendly cloud API access.
+
+USAGE:
+    ycloud <command> [subcommand] [flags]
+
+EXAMPLES:
+    ycloud auth validate --output json
+    ycloud tool catalog --output json
+    ycloud kb search --query "短视频脚本结构" --top-k 5 --output json
+
+GLOBAL FLAGS:
+    --output <string>      output format: json (default) | text
+    --trace-id <string>    optional request trace id
+    --timeout <int>        request timeout in milliseconds
+    --base-url <string>    override API base URL
+    -h, --help             show help
+
+COMMANDS:
+    auth                   token validation and account info
+    health                 service health check
+    version                local CLI version info
+    tool                   tool catalog and tool execution
+    kb                     knowledge base search
+    analysis               creator analysis commands
+    compliance             compliance checking commands
+    config                 local CLI config management
+    commands               list and describe exposed commands
+    schema                 inspect command parameter schema from OpenAPI
+    content                wrapped content generation tools
+    social                 social media atomic tools
+    oss                    oss helper tools
+    speech                 speech helper tools
+`;
+
+function parseArgs(rawArgs) {
+  const tokens = [...rawArgs];
+  const options = {
+    output: "json",
+    traceId: undefined,
+    timeout: undefined,
+    baseUrl: undefined,
+    help: false,
+  };
+  const positional = [];
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "-h" || token === "--help") {
+      options.help = true;
+      continue;
+    }
+    if (token === "--output") {
+      options.output = tokens[index + 1] || "json";
+      index += 1;
+      continue;
+    }
+    if (token === "--trace-id") {
+      options.traceId = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+    if (token === "--timeout") {
+      options.timeout = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+    if (token === "--base-url") {
+      options.baseUrl = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+    positional.push(token);
+  }
+
+  return { positional, options };
+}
+
+function getCommandName(positional) {
+  return `${positional[0] || ""} ${positional[1] || ""}`.trim() || "unknown";
+}
+
+function asJson(command, success, data, error = null, meta = {}, warnings = []) {
+  return {
+    success,
+    command,
+    data,
+    warnings,
+    error,
+    meta,
+  };
+}
+
+function renderJson(payload) {
+  return `${JSON.stringify(payload)}\n`;
+}
+
+function renderTextPayload(payload) {
+  const lines = [
+    `command: ${payload.command}`,
+    `success: ${payload.success}`,
+  ];
+
+  if (payload.error) {
+    lines.push(`error.code: ${payload.error.code}`);
+    lines.push(`error.message: ${payload.error.message}`);
+    lines.push(`error.retryable: ${payload.error.retryable}`);
+  }
+
+  if (payload.data !== null && payload.data !== undefined) {
+    lines.push("data:");
+    lines.push(JSON.stringify(payload.data, null, 2));
+  }
+
+  if (payload.meta && Object.keys(payload.meta).length > 0) {
+    lines.push("meta:");
+    lines.push(JSON.stringify(payload.meta, null, 2));
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function renderOutput(payload, globalOptions) {
+  if (globalOptions.output === "text") {
+    return renderTextPayload(payload);
+  }
+  return renderJson(payload);
+}
+
+function fail(command, code, message, exitCode = 1, retryable = false) {
+  const payload = asJson(command, false, null, { code, message, retryable }, {});
+  return {
+    code: exitCode,
+    output: renderOutput(payload, this?.globalOptions || { output: "json" }),
+  };
+}
+
+function ok(command, data, meta = {}) {
+  const payload = asJson(command, true, data, null, meta);
+  return {
+    code: 0,
+    output: renderOutput(payload, this?.globalOptions || { output: "json" }),
+  };
+}
+
+function text(commandHelp) {
+  return {
+    code: 0,
+    output: `${commandHelp}\n`,
+  };
+}
+
+function parseCommandFlags(tokens) {
+  const options = {};
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    const name = token.slice(2);
+    const next = tokens[index + 1];
+    if (!next || next.startsWith("--")) {
+      options[name] = true;
+      continue;
+    }
+    options[name] = next;
+    index += 1;
+  }
+  return options;
+}
+
+let cachedToolCatalogMap = null;
+let cachedToolRegistry = null;
+
+async function getToolCatalogMap() {
+  if (cachedToolCatalogMap) {
+    return cachedToolCatalogMap;
+  }
+  const { readFile } = await import("node:fs/promises");
+  const { join } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const currentDir = fileURLToPath(new URL(".", import.meta.url));
+  const jsonText = await readFile(
+    join(currentDir, "..", "resources", "tool_catalog_full.json"),
+    "utf8",
+  );
+  const raw = JSON.parse(jsonText);
+  const items = raw.data?.data?.items || [];
+  cachedToolCatalogMap = new Map(items.map((item) => [item.tool_id, item]));
+  return cachedToolCatalogMap;
+}
+
+async function getToolRegistry() {
+  if (cachedToolRegistry) {
+    return cachedToolRegistry;
+  }
+  const catalogMap = await getToolCatalogMap();
+  cachedToolRegistry = buildToolRegistry(catalogMap);
+  return cachedToolRegistry;
+}
+
+function buildContext(globalOptions, commandName) {
+  return {
+    globalOptions,
+    commandName,
+    ok: ok.bind({ globalOptions }),
+    fail: fail.bind({ globalOptions }),
+    parseCommandFlags,
+  };
+}
+
+export async function executeCommand(rawArgs) {
+  const { positional, options } = parseArgs(rawArgs);
+  const commandName = getCommandName(positional);
+  const context = buildContext(options, commandName);
+  const toolRegistry = await getToolRegistry();
+  const catalogMap = await getToolCatalogMap();
+  const exposedCommands = buildExposedCommands(toolRegistry, catalogMap);
+  const allowedToolIds = new Set(
+    exposedCommands
+      .filter((item) => item.kind === "tool")
+      .map((item) => item.tool_id),
+  );
+
+  if (positional.length === 0 || options.help) {
+    if (positional.length === 0) {
+      return text(TOP_LEVEL_HELP);
+    }
+    if (positional[0] === "auth") {
+      return text(getAuthHelp(positional[1]));
+    }
+    if (positional[0] === "health") {
+      return text(getHealthHelp(positional[1]));
+    }
+    if (positional[0] === "version") {
+      return text(getVersionHelp(positional[1]));
+    }
+    if (positional[0] === "tool") {
+      return text(getToolHelp(positional[1]));
+    }
+    if (positional[0] === "kb") {
+      return text(getKbHelp(positional[1]));
+    }
+    if (positional[0] === "analysis") {
+      return text(getAnalysisHelp(positional[1]));
+    }
+    if (positional[0] === "compliance") {
+      return text(getComplianceHelp(positional[1]));
+    }
+    if (positional[0] === "config") {
+      return text(getConfigHelp(positional[1]));
+    }
+    if (positional[0] === "commands") {
+      return text(getCommandsHelp(positional[1]));
+    }
+    if (positional[0] === "schema") {
+      return text(getSchemaHelp());
+    }
+    if (toolRegistry[positional[0]]) {
+      if (positional[1]) {
+        const config = toolRegistry[positional[0]].commands[positional[1]];
+        if (config) {
+          return text(
+            createToolCommandHelp(
+              positional[0],
+              positional[1],
+              config,
+              catalogMap.get(config.toolId),
+            ),
+          );
+        }
+      }
+      return text(createDomainHelp(positional[0], toolRegistry[positional[0]], catalogMap));
+    }
+    return text(TOP_LEVEL_HELP);
+  }
+
+  if (positional[0] === "auth" && positional[1] === "info") {
+    return executeAuthInfo(context, positional.slice(2));
+  }
+  if (positional[0] === "auth" && positional[1] === "validate") {
+    return executeAuthValidate(context, positional.slice(2));
+  }
+  if (positional[0] === "auth" && positional[1] === "charges") {
+    return executeAuthCharges(context, positional.slice(2));
+  }
+  if (positional[0] === "auth" && positional[1] === "status") {
+    return executeAuthStatus(context, positional.slice(2));
+  }
+  if (positional[0] === "health" && positional[1] === "check") {
+    return executeHealthCheck(context, positional.slice(2));
+  }
+  if (positional[0] === "version" && positional[1] === "check") {
+    return executeVersionCheck(context, positional.slice(2));
+  }
+  if (positional[0] === "tool" && positional[1] === "catalog") {
+    return executeToolCatalog(context, positional.slice(2));
+  }
+  if (positional[0] === "tool" && positional[1] === "execute") {
+    return executeToolExecute(context, positional.slice(2), allowedToolIds);
+  }
+  if (positional[0] === "kb" && positional[1] === "search") {
+    return executeKbSearch(context, positional.slice(2));
+  }
+  if (
+    positional[0] === "analysis" &&
+    positional[1] === "creator-profile"
+  ) {
+    return executeAnalysisCreatorProfile(context, positional.slice(2));
+  }
+  if (positional[0] === "compliance" && positional[1] === "check") {
+    return executeComplianceCheck(context, positional.slice(2));
+  }
+  if (positional[0] === "config" && positional[1] === "set-token") {
+    return executeConfigSetToken(context, positional.slice(2));
+  }
+  if (positional[0] === "config" && positional[1] === "get") {
+    return executeConfigGet(context, positional.slice(2));
+  }
+  if (positional[0] === "config" && positional[1] === "clear-token") {
+    return executeConfigClearToken(context, positional.slice(2));
+  }
+  if (positional[0] === "commands" && positional[1] === "list") {
+    return executeCommandsList(context, exposedCommands);
+  }
+  if (positional[0] === "commands" && positional[1] === "describe") {
+    return executeCommandsDescribe(context, positional.slice(2), exposedCommands);
+  }
+  if (positional[0] === "schema") {
+    return executeSchema(context, positional.slice(1));
+  }
+  if (toolRegistry[positional[0]]) {
+    return executeRegisteredTool(
+      context,
+      positional.slice(1),
+      positional[0],
+      toolRegistry[positional[0]],
+      catalogMap,
+    );
+  }
+
+  return fail(commandName, "UNKNOWN_COMMAND", "未知命令", 1, false);
+}