yuanflow-cli 0.1.0

package/src/ycloud/commands/tool-runner.js

@@ -0,0 +1,226 @@
+import { apiPost } from "../core/http.js";
+import { getToken } from "../core/token.js";
+import { getGlobalFlagsHelp, parseFloatNumber, parseInteger, parseJsonString } from "./shared.js";
+
+function toFlagName(property) {
+  return property.replace(/_/g, "-");
+}
+
+function parsePrimitiveBySchema(name, schema, value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  const type = schema?.type;
+  if (type === "integer") {
+    return parseInteger(value);
+  }
+  if (type === "number") {
+    return parseFloatNumber(value);
+  }
+  if (type === "boolean") {
+    return value === true || value === "true";
+  }
+  if (type === "object") {
+    if (typeof value === "string") {
+      return parseJsonString(value);
+    }
+    return value;
+  }
+  if (type === "array") {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.startsWith("[")) {
+        return parseJsonString(trimmed);
+      }
+      return trimmed
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    }
+  }
+  return value;
+}
+
+function normalizeFlagValue(name, schema, value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (schema?.type) {
+    return parsePrimitiveBySchema(name, schema, value);
+  }
+  if (name.endsWith("_count") || name.endsWith("_limit") || name.endsWith("_seconds") || name === "page" || name === "page_size" || name === "top_k" || name === "sample_rate" || name === "count" || name === "image_count" || name === "copy_length" || name === "duration_seconds" || name === "ai_mode") {
+    return parseInteger(value);
+  }
+  if (name === "min_score") {
+    return parseFloatNumber(value);
+  }
+  if (name === "enable_timestamp" || name === "return_raw") {
+    return value === true || value === "true";
+  }
+  if (name === "constraints" || name === "context" || name === "body") {
+    return typeof value === "string" ? parseJsonString(value) : value;
+  }
+  return value;
+}
+
+function mapFlagsToBody(rawOptions, commandConfig, schemaProperties = {}) {
+  const options = { ...rawOptions };
+  for (const [from, to] of Object.entries(commandConfig.aliases || {})) {
+    if (options[from] !== undefined && options[to] === undefined) {
+      options[to] = options[from];
+    }
+  }
+
+  const body = {};
+  for (const property of Object.keys(schemaProperties)) {
+    const flag = toFlagName(property);
+    const rawValue = options[flag];
+    if (rawValue !== undefined) {
+      body[property] = normalizeFlagValue(property, schemaProperties[property], rawValue);
+    }
+  }
+  return body;
+}
+
+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 function createDomainHelp(domain, registry, catalogMap) {
+  const items = Object.entries(registry.commands).map(([subcommand, config]) => {
+    const item = catalogMap.get(config.toolId);
+    const description = item?.description || config.description;
+    return `  ${subcommand.padEnd(28)} ${description}`;
+  });
+
+  return `${registry.title}
+
+Usage:
+  ycloud ${domain} <subcommand> [flags]
+
+Available Subcommands:
+${items.join("\n")}
+
+${getGlobalFlagsHelp()}`;
+}
+
+export function createToolCommandHelp(domain, subcommand, config, catalogItem) {
+  const properties = catalogItem?.schema?.properties || {};
+  const required = new Set(config.requiredFlags || []);
+  const propertyLines = [];
+  const optionalLines = [];
+
+  for (const property of Object.keys(properties)) {
+    const flag = `--${toFlagName(property)}`;
+    const type = properties[property].type || "string";
+    const desc = properties[property].description || "";
+    const line = `  ${flag} ${type}`.padEnd(28) + desc;
+    if (required.has(toFlagName(property))) {
+      propertyLines.push(line);
+    } else {
+      optionalLines.push(line);
+    }
+  }
+
+  return `${config.description}
+
+Usage:
+  ycloud ${domain} ${subcommand} [flags]
+
+Required Flags:
+${propertyLines.length ? propertyLines.join("\n") : "  none"}
+
+Optional Flags:
+${optionalLines.length ? optionalLines.join("\n") : "  none"}
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud ${domain} ${subcommand} --output json
+
+Read on success:
+  data
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+}
+
+export async function executeRegisteredTool(
+  context,
+  tokens,
+  domain,
+  registry,
+  catalogMap,
+) {
+  const subcommand = tokens[0];
+  const config = registry.commands[subcommand];
+  if (!config) {
+    return context.fail(
+      context.commandName,
+      "UNKNOWN_COMMAND",
+      "未知命令",
+      1,
+      false,
+    );
+  }
+
+  const options = context.parseCommandFlags(tokens.slice(1));
+  for (const requiredFlag of config.requiredFlags || []) {
+    const aliasSource = Object.entries(config.aliases || {}).find(
+      ([from, to]) => to === requiredFlag && options[from] !== undefined,
+    );
+    if (options[requiredFlag] === undefined && !aliasSource) {
+      return context.fail(
+        config.commandName,
+        "BAD_ARGUMENT",
+        `缺少必填参数 --${requiredFlag}`,
+        2,
+        false,
+      );
+    }
+  }
+
+  const token = await requireToken(context);
+  if (typeof token !== "string") {
+    return token;
+  }
+
+  const catalogItem = catalogMap.get(config.toolId);
+  const body = mapFlagsToBody(
+    options,
+    config,
+    catalogItem?.schema?.properties || {},
+  );
+
+  const data = await apiPost("/v1/tools/execute", {
+    token,
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+    body: {
+      tool_id: config.toolId,
+      params: body,
+      trace_id: context.globalOptions.traceId,
+    },
+  });
+
+  return context.ok(config.commandName, data, {
+    tool_id: config.toolId,
+  });
+}

package/src/ycloud/commands/tool.js

@@ -0,0 +1,178 @@
+import { apiGet, apiPost } from "../core/http.js";
+import { getToken } from "../core/token.js";
+import { getGlobalFlagsHelp, parseJsonString } from "./shared.js";
+
+export function getToolHelp(subcommand) {
+  if (subcommand === "catalog") {
+    return `List available tool catalog
+
+Usage:
+  ycloud tool catalog [flags]
+
+Optional Flags:
+  none
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud tool catalog --output json
+
+Read on success:
+  data.tools
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+  }
+
+  if (subcommand === "execute") {
+    return `Execute a server-side tool
+
+Usage:
+  ycloud tool execute [flags]
+
+Required Flags:
+  --tool-id string       tool id to execute
+
+Optional Flags:
+  --params string        JSON object string
+  --params-file string   local JSON file path
+  --session-id string    optional session id
+  --idempotency-key string request idempotency key
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud tool execute --tool-id copywriting_generate --params "{\"topic\":\"短视频文案\"}" --output json
+
+Read on success:
+  data
+  meta.tool_id
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+  }
+
+  return `Tool commands
+
+Usage:
+  ycloud tool <catalog|execute> [flags]`;
+}
+
+function requireToken(context) {
+  return getToken().then((token) => {
+    if (!token) {
+      return context.fail(
+        context.commandName,
+        "TOKEN_MISSING",
+        "缺少 YUANCHUANG_API_TOKEN",
+        3,
+        false,
+      );
+    }
+    return token;
+  });
+}
+
+export async function executeToolCatalog(context) {
+  const token = await requireToken(context);
+  if (typeof token !== "string") {
+    return token;
+  }
+  const data = await apiGet("/v1/tools/catalog", {
+    token,
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+  });
+  return context.ok("tool catalog", data);
+}
+
+export async function executeToolExecute(context, tokens, allowedToolIds = new Set()) {
+  const options = context.parseCommandFlags(tokens);
+  if (!options["tool-id"]) {
+    return context.fail(
+      "tool execute",
+      "BAD_ARGUMENT",
+      "缺少必填参数 --tool-id",
+      2,
+      false,
+    );
+  }
+  if (options.params && options["params-file"]) {
+    return context.fail(
+      "tool execute",
+      "BAD_ARGUMENT",
+      "--params 和 --params-file 只能二选一",
+      2,
+      false,
+    );
+  }
+  if (allowedToolIds.size > 0 && !allowedToolIds.has(options["tool-id"])) {
+    return context.fail(
+      "tool execute",
+      "BAD_ARGUMENT",
+      `tool_id 未注册到当前 CLI 暴露面: ${options["tool-id"]}`,
+      2,
+      false,
+    );
+  }
+
+  const token = await requireToken(context);
+  if (typeof token !== "string") {
+    return token;
+  }
+
+  let params = undefined;
+  if (options.params) {
+    try {
+      params = parseJsonString(options.params);
+    } catch {
+      return context.fail(
+        "tool execute",
+        "BAD_ARGUMENT",
+        "--params 必须是合法 JSON",
+        2,
+        false,
+      );
+    }
+  }
+
+  if (options["params-file"]) {
+    const { readFile } = await import("node:fs/promises");
+    try {
+      params = JSON.parse(
+        await readFile(options["params-file"], { encoding: "utf-8" }),
+      );
+    } catch {
+      return context.fail(
+        "tool execute",
+        "BAD_ARGUMENT",
+        "--params-file 必须是合法 JSON 文件",
+        2,
+        false,
+      );
+    }
+  }
+
+  const data = await apiPost("/v1/tools/execute", {
+    token,
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+    body: {
+      tool_id: options["tool-id"],
+      params,
+      session_id: options["session-id"],
+      trace_id: context.globalOptions.traceId,
+      idempotency_key: options["idempotency-key"],
+    },
+  });
+
+  return context.ok("tool execute", data, {
+    tool_id: options["tool-id"],
+  });
+}

package/src/ycloud/commands/version.js

@@ -0,0 +1,84 @@
+import pkg from "../../../package.json" with { type: "json" };
+import { apiGet } from "../core/http.js";
+import { getToken } from "../core/token.js";
+import { getGlobalFlagsHelp } from "./shared.js";
+
+export function getVersionHelp() {
+  return `Check remote version update information
+
+Usage:
+  ycloud version check [flags]
+
+Optional Flags:
+  --app-id string        application id, default ai-solovision
+  --platform string      target platform, default desktop
+  --channel string       release channel, default stable
+  --current-version string current CLI version, default local package version
+  --current-build int    optional current build number
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud version check --output json
+
+Read on success:
+  data.latest_version
+  data.update_available
+  data.update_type
+
+Read on error:
+  error.code
+  error.message`;
+}
+
+export async function executeVersionCheck(context, tokens) {
+  const token = await getToken();
+  if (!token) {
+    return context.fail(
+      "version check",
+      "TOKEN_MISSING",
+      "缺少 YUANCHUANG_API_TOKEN",
+      3,
+      false,
+    );
+  }
+
+  const options = context.parseCommandFlags(tokens);
+  const appId = options["app-id"] || "ai-solovision";
+  const platform = options.platform || "desktop";
+  const channel = options.channel || "stable";
+  const currentVersion = options["current-version"] || pkg.version;
+  const query = new URLSearchParams({
+    app_id: appId,
+    platform,
+    channel,
+    current_version: currentVersion,
+  });
+
+  if (options["current-build"] !== undefined) {
+    query.set("current_build", String(options["current-build"]));
+  }
+
+  const data = await apiGet(`/v1/version/check?${query.toString()}`, {
+    token,
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+  });
+
+  const remoteData = data?.data || data || {};
+  return context.ok("version check", {
+    app_id: appId,
+    platform,
+    channel,
+    current_version: currentVersion,
+    current_build: remoteData.current_build ?? null,
+    latest_version: remoteData.latest_version ?? null,
+    latest_build: remoteData.latest_build ?? null,
+    update_available: Boolean(remoteData.update_available),
+    update_type: remoteData.update_type || "none",
+    checked_at: remoteData.checked_at || null,
+    release: remoteData.release || null,
+    raw: data,
+  });
+}

package/src/ycloud/core/config.js

@@ -0,0 +1,78 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR_NAME = ".yuanflow";
+const CONFIG_FILE_NAME = "config.json";
+
+function getUserHomeDir() {
+  return process.env.USERPROFILE || process.env.HOME || homedir();
+}
+
+export function getConfigDir() {
+  return join(getUserHomeDir(), CONFIG_DIR_NAME);
+}
+
+export function getConfigPath() {
+  return join(getConfigDir(), CONFIG_FILE_NAME);
+}
+
+export async function readConfig() {
+  try {
+    const content = await readFile(getConfigPath(), "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+
+export async function writeConfig(config) {
+  await mkdir(getConfigDir(), { recursive: true });
+  await writeFile(
+    getConfigPath(),
+    `${JSON.stringify(config, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+export async function updateConfig(partial) {
+  const current = await readConfig();
+  const next = {
+    ...current,
+    ...partial,
+  };
+  await writeConfig(next);
+  return next;
+}
+
+export async function clearConfigKey(key) {
+  const current = await readConfig();
+  if (!(key in current)) {
+    return current;
+  }
+  const next = { ...current };
+  delete next[key];
+  if (Object.keys(next).length === 0) {
+    try {
+      await rm(getConfigPath(), { force: true });
+    } catch {
+      return {};
+    }
+    return {};
+  }
+  await writeConfig(next);
+  return next;
+}
+
+export function maskToken(token) {
+  if (!token) {
+    return null;
+  }
+  if (token.length <= 8) {
+    return `${token.slice(0, 2)}****`;
+  }
+  return `${token.slice(0, 7)}****${token.slice(-4)}`;
+}

package/src/ycloud/core/http.js

@@ -0,0 +1,133 @@
+const DEFAULT_BASE_URL = "https://api.yuanchuangai.com";
+const DEFAULT_OPENAPI_URL = "https://api.yuanchuangai.com/openapi.json";
+
+function normalizeBaseUrl(baseUrl) {
+  return (baseUrl || process.env.YUANCHUANG_API_BASE_URL || DEFAULT_BASE_URL)
+    .trim()
+    .replace(/\/+$/, "");
+}
+
+function buildHeaders(token, traceId) {
+  const headers = {
+    Accept: "application/json",
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  if (traceId) {
+    headers["X-Trace-Id"] = traceId;
+  }
+  return headers;
+}
+
+function createTimeoutSignal(timeout) {
+  const timeoutMs = timeout ? Number.parseInt(String(timeout), 10) : undefined;
+  if (!timeoutMs || Number.isNaN(timeoutMs) || timeoutMs <= 0) {
+    return undefined;
+  }
+  return AbortSignal.timeout(timeoutMs);
+}
+
+function parseResponseBody(text) {
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function mapStatusToCode(status) {
+  if (status === 401 || status === 403) {
+    return { code: "AUTH_INVALID", exitCode: 3, retryable: false };
+  }
+  if (status === 400 || status === 404 || status === 422) {
+    return { code: "BAD_ARGUMENT", exitCode: 2, retryable: false };
+  }
+  if (status >= 500) {
+    return { code: "UPSTREAM_ERROR", exitCode: 4, retryable: true };
+  }
+  return { code: "UPSTREAM_ERROR", exitCode: 4, retryable: false };
+}
+
+async function request(method, path, options = {}) {
+  const headers = buildHeaders(options.token, options.traceId);
+  const init = {
+    method,
+    headers,
+    signal: createTimeoutSignal(options.timeout),
+  };
+
+  if (options.body !== undefined) {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(options.body);
+  }
+
+  try {
+    const response = await fetch(`${normalizeBaseUrl(options.baseUrl)}${path}`, init);
+    const text = await response.text();
+    const payload = parseResponseBody(text);
+
+    if (!response.ok) {
+      const mapped = mapStatusToCode(response.status);
+      const message =
+        payload?.detail ||
+        payload?.message ||
+        payload?.error?.message ||
+        `HTTP ${response.status}`;
+      const error = new Error(message);
+      error.code = mapped.code;
+      error.exitCode = mapped.exitCode;
+      error.retryable = mapped.retryable;
+      throw error;
+    }
+
+    return payload;
+  } catch (error) {
+    if (error.name === "AbortError") {
+      const timeoutError = new Error("请求超时");
+      timeoutError.code = "UPSTREAM_TIMEOUT";
+      timeoutError.exitCode = 5;
+      timeoutError.retryable = true;
+      throw timeoutError;
+    }
+    if (error.code) {
+      throw error;
+    }
+    const networkError = new Error(error.message || "网络请求失败");
+    networkError.code = "NETWORK_ERROR";
+    networkError.exitCode = 5;
+    networkError.retryable = true;
+    throw networkError;
+  }
+}
+
+export async function apiGet(path, options = {}) {
+  return request("GET", path, options);
+}
+
+export async function apiPost(path, options = {}) {
+  return request("POST", path, options);
+}
+
+export async function fetchOpenApiSpec(options = {}) {
+  const response = await fetch(DEFAULT_OPENAPI_URL, {
+    method: "GET",
+    headers: {
+      Accept: "application/json",
+    },
+    signal: createTimeoutSignal(options.timeout),
+  });
+
+  if (!response.ok) {
+    const error = new Error(`HTTP ${response.status}`);
+    error.code = "UPSTREAM_ERROR";
+    error.exitCode = 4;
+    error.retryable = true;
+    throw error;
+  }
+
+  return response.json();
+}