svmc-cli 1.0.0

package/dist/src/index.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const commander_1 = require("commander");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const auth_1 = require("./commands/auth");
+const image_1 = require("./commands/image");
+const errors_1 = require("./core/errors");
+async function run(argv = process.argv) {
+    const program = new commander_1.Command();
+    program
+        .name("svmc")
+        .description("SVMC CLI for image workflows")
+        .helpOption("-h, --help", "显示帮助")
+        .version(getCliVersion(), "-v, --version", "显示版本号")
+        .showHelpAfterError();
+    const auth = program
+        .command("auth")
+        .description("鉴权相关命令（默认执行 token/cookie 写入）")
+        .option("--config-path <path>", "指定配置文件路径")
+        .option("--token <token>", "直接传入 token（可选）")
+        .option("--cookie <cookie>", "保存会话 Cookie，可粘贴 k1=v1; k2=v2")
+        .action(async (options) => {
+        await (0, auth_1.runAuthCommand)(options);
+    });
+    auth
+        .command("status")
+        .description("验证当前认证信息是否可用")
+        .option("--config-path <path>", "指定配置文件路径")
+        .option("--cookie <cookie>", "会话 Cookie，可覆盖配置")
+        .action(async (options) => {
+        await (0, auth_1.runAuthStatusCommand)(options);
+    });
+    const image = program.command("image").description("图像相关命令");
+    image
+        .command("specs")
+        .description("获取 img2img 参数规格")
+        .option("--provider <provider>", "指定供应商，仅输出该供应商规格")
+        .option("--base-url <url>", "服务地址")
+        .option("--cookie <cookie>", "会话 Cookie，可覆盖配置")
+        .option("--config-path <path>", "指定配置文件路径")
+        .action(async (options) => (0, image_1.runImageSpecsCommand)(options));
+    image
+        .command("generate")
+        .description("提交 img2img 任务并轮询下载结果")
+        .allowUnknownOption(true)
+        .option("--config-path <path>", "指定配置文件路径")
+        .action(async (options) => {
+        const rawArgs = getRawArgsAfterToken(argv, "generate");
+        await (0, image_1.runImageGenerateCommand)({
+            rawArgs,
+            configPath: options.configPath,
+        });
+    });
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError) {
+            process.stderr.write(`${error.message}\n`);
+            process.exit(error.exitCode);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exit(1);
+    }
+}
+function getRawArgsAfterToken(argv, token) {
+    const index = argv.findIndex((item) => item === token);
+    if (index === -1) {
+        return [];
+    }
+    return argv.slice(index + 1);
+}
+if (require.main === module) {
+    run(process.argv).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exit(1);
+    });
+}
+function getCliVersion() {
+    try {
+        const candidates = [(0, node_path_1.join)(__dirname, "../package.json"), (0, node_path_1.join)(__dirname, "../../package.json")];
+        const target = candidates.find((path) => (0, node_fs_1.existsSync)(path));
+        if (!target) {
+            return "0.0.0";
+        }
+        const content = (0, node_fs_1.readFileSync)(target, "utf8");
+        const pkg = JSON.parse(content);
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}

package/dist/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests/apiClient.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const apiClient_1 = require("../src/core/apiClient");
+const errors_1 = require("../src/core/errors");
+(0, vitest_1.describe)("ApiClient", () => {
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.unstubAllGlobals();
+    });
+    (0, vitest_1.it)("returns parsed json when request succeeds", async () => {
+        vitest_1.vi.stubGlobal("fetch", vitest_1.vi.fn(async () => new Response(JSON.stringify({ code: 200, message: "ok", data: { ok: true } }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        })));
+        const client = new apiClient_1.ApiClient("https://example.com", "token");
+        const res = await client.get("/ping");
+        (0, vitest_1.expect)(res.ok).toBe(true);
+    });
+    (0, vitest_1.it)("throws CliError on 401", async () => {
+        vitest_1.vi.stubGlobal("fetch", vitest_1.vi.fn(async () => new Response(JSON.stringify({ message: "unauthorized" }), {
+            status: 401,
+            headers: { "Content-Type": "application/json" },
+        })));
+        const client = new apiClient_1.ApiClient("https://example.com", "token");
+        await (0, vitest_1.expect)(client.get("/ping")).rejects.toBeInstanceOf(errors_1.CliError);
+    });
+    (0, vitest_1.it)("throws CliError when business code is 401", async () => {
+        vitest_1.vi.stubGlobal("fetch", vitest_1.vi.fn(async () => new Response(JSON.stringify({ code: 401, message: "未登录或登录已过期", data: null }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        })));
+        const client = new apiClient_1.ApiClient("https://example.com", "token");
+        await (0, vitest_1.expect)(client.get("/ping")).rejects.toBeInstanceOf(errors_1.CliError);
+    });
+});

package/dist/tests/config.test.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const vitest_1 = require("vitest");
+const config_1 = require("../src/core/config");
+let tempDir = "";
+(0, vitest_1.afterEach)(async () => {
+    if (tempDir) {
+        await (0, promises_1.rm)(tempDir, { recursive: true, force: true });
+    }
+    tempDir = "";
+});
+(0, vitest_1.describe)("config", () => {
+    (0, vitest_1.it)("saves and loads token", async () => {
+        tempDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "svmc-cli-"));
+        const configPath = (0, node_path_1.join)(tempDir, "config.toml");
+        await (0, config_1.saveConfig)({
+            auth: { access_token: "Bearer abc", cookie: "session=1" },
+            server: { base_url: "https://example.com" },
+        }, configPath);
+        const config = await (0, config_1.loadConfig)(configPath);
+        (0, vitest_1.expect)(config.auth.access_token).toBe("Bearer abc");
+        (0, vitest_1.expect)(config.auth.cookie).toBe("session=1");
+        (0, vitest_1.expect)(config.server.base_url).toBe("https://example.com");
+        await (0, vitest_1.expect)((0, config_1.getAccessToken)(configPath)).resolves.toBe("abc");
+        await (0, vitest_1.expect)((0, config_1.getSessionCookie)(undefined, configPath)).resolves.toBe("session=1");
+    });
+    (0, vitest_1.it)("uses production base url by default", async () => {
+        tempDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "svmc-cli-"));
+        const configPath = (0, node_path_1.join)(tempDir, "empty.toml");
+        const baseUrl = await (0, config_1.getBaseUrl)(undefined, configPath);
+        (0, vitest_1.expect)(baseUrl).toBe(config_1.DEFAULT_BASE_URL);
+    });
+});

package/dist/tests/parser.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const parser_1 = require("../src/core/parser");
+(0, vitest_1.describe)("parseGenerateCliArgs", () => {
+    (0, vitest_1.it)("parses standard and dynamic options", () => {
+        const args = (0, parser_1.parseGenerateCliArgs)([
+            "--provider",
+            "nano-banana",
+            "--input",
+            "a.jpg",
+            "--input",
+            "b.png",
+            "--prompt",
+            "cyberpunk",
+            "--ratio",
+            "16:9",
+            "--steps",
+            "20",
+            "--negative_prompt",
+            "low quality",
+        ]);
+        (0, vitest_1.expect)(args.provider).toBe("nano-banana");
+        (0, vitest_1.expect)(args.input).toEqual(["a.jpg", "b.png"]);
+        (0, vitest_1.expect)(args.prompt).toBe("cyberpunk");
+        (0, vitest_1.expect)(args.ratio).toBe("16:9");
+        (0, vitest_1.expect)(args.dynamicParams.steps).toBe(20);
+        (0, vitest_1.expect)(args.dynamicParams.negative_prompt).toBe("low quality");
+    });
+});

package/dist/tests/poller.test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const poller_1 = require("../src/core/poller");
+(0, vitest_1.describe)("pollTaskUntilDone", () => {
+    (0, vitest_1.it)("returns completed task", async () => {
+        const statuses = ["pending", "processing", "completed"];
+        const task = await (0, poller_1.pollTaskUntilDone)(async () => ({
+            task_uuid: "t-1",
+            status: statuses.shift(),
+        }), { intervalMs: 1, timeoutMs: 1000 });
+        (0, vitest_1.expect)(task.status).toBe("completed");
+    });
+});

package/dist/vitest.config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        include: ["tests/**/*.test.ts"],
+        exclude: ["dist/**", "node_modules/**"],
+    },
+});

package/eslint.config.js

@@ -0,0 +1,27 @@
+const tsParser = require("@typescript-eslint/parser");
+const tsPlugin = require("@typescript-eslint/eslint-plugin");
+
+/** @type {import('eslint').Linter.FlatConfig[]} */
+module.exports = [
+  {
+    files: ["**/*.ts"],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        project: "./tsconfig.json",
+        sourceType: "module",
+        ecmaVersion: "latest",
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tsPlugin,
+    },
+    rules: {
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+      "@typescript-eslint/no-explicit-any": "off",
+    },
+  },
+  {
+    ignores: ["dist/**", "node_modules/**"],
+  },
+];

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "svmc-cli",
+  "version": "1.0.0",
+  "description": "SVMC CLI for media-center image workflows",
+  "main": "dist/src/index.js",
+  "bin": {
+    "svmc": "./bin/svmc.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "lint:eslint": "eslint .",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit -p tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.valsun.cn:visual-ai/svmc-cli.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@inquirer/prompts": "^8.3.2",
+    "commander": "^14.0.3",
+    "yargs-parser": "^22.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/yargs-parser": "^21.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.57.0",
+    "@typescript-eslint/parser": "^8.57.0",
+    "eslint": "^10.0.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  }
+}

package/src/commands/auth.ts

@@ -0,0 +1,88 @@
+import { confirm, input, password } from "@inquirer/prompts";
+import { ApiClient } from "../core/apiClient";
+import {
+  getAccessToken,
+  getBaseUrl,
+  getConfigPath,
+  getSessionCookie,
+  loadConfig,
+  saveConfig,
+} from "../core/config";
+import { CliError, EXIT_CODES } from "../core/errors";
+
+export interface AuthCommandOptions {
+  configPath?: string;
+  token?: string;
+  cookie?: string;
+}
+
+export interface AuthStatusCommandOptions {
+  configPath?: string;
+  cookie?: string;
+}
+
+export async function runAuthCommand(
+  options: AuthCommandOptions,
+): Promise<void> {
+  const resolvedConfigPath = getConfigPath(options.configPath);
+  const currentConfig = await loadConfig(resolvedConfigPath);
+
+  const hasExisting = Boolean(currentConfig.auth.access_token?.trim());
+  if (hasExisting) {
+    const shouldOverwrite = await confirm({
+      message: `检测到已有 token，是否覆盖？(${resolvedConfigPath})`,
+      default: false,
+    });
+    if (!shouldOverwrite) {
+      process.stdout.write("已取消覆盖，保留现有配置。\n");
+      return;
+    }
+  }
+
+  const accessToken =
+    options.token?.trim() ||
+    (await password({
+      message: "请输入 SVMC_ACCESS_TOKEN",
+      mask: "*",
+      validate: (value) => (value.trim() ? true : "Token 不能为空"),
+    }));
+
+  const cookie =
+    options.cookie?.trim() ||
+    (await input({
+      message: "请输入可选 Cookie",
+      default: currentConfig.auth.cookie ?? "",
+    }));
+
+  const nextConfig = {
+    auth: {
+      access_token: accessToken.trim(),
+      cookie: cookie.trim() || undefined,
+    },
+    server: { base_url: currentConfig.server.base_url },
+  };
+
+  await saveConfig(nextConfig, resolvedConfigPath);
+  const verifyConfig = await loadConfig(resolvedConfigPath);
+  if (verifyConfig.auth.access_token !== nextConfig.auth.access_token) {
+    throw new CliError("配置写入校验失败，请重试。", EXIT_CODES.IO);
+  }
+
+  process.stdout.write(`AUTH_OK: ${resolvedConfigPath}\n`);
+}
+
+export async function runAuthStatusCommand(
+  options: AuthStatusCommandOptions,
+): Promise<void> {
+  try {
+    const token = await getAccessToken(options.configPath);
+    const baseUrl = await getBaseUrl(undefined, options.configPath);
+    const cookie = await getSessionCookie(options.cookie, options.configPath);
+    const client = new ApiClient(baseUrl, token, cookie);
+    await client.get("/image_generation/params");
+    process.stdout.write(`AUTH_STATUS: OK (${baseUrl})\n`);
+  } catch (error) {
+    process.stdout.write("AUTH_STATUS: FAIL\n");
+    throw error;
+  }
+}

package/src/commands/image.ts

@@ -0,0 +1,104 @@
+import { join } from "node:path";
+import { ApiClient } from "../core/apiClient";
+import { getAccessToken, getBaseUrl, getSessionCookie } from "../core/config";
+import { downloadToLocal } from "../core/downloader";
+import { CliError, EXIT_CODES } from "../core/errors";
+import { ensureInputsReadable, parseGenerateCliArgs, readImagesAsDataUrls } from "../core/parser";
+import { pollTaskUntilDone } from "../core/poller";
+import type { ImageGenerationTask, ImageParamsResponse } from "../types";
+
+export interface SpecsCommandOptions {
+  provider?: string;
+  configPath?: string;
+  baseUrl?: string;
+  cookie?: string;
+}
+
+export interface GenerateCommandOptions {
+  rawArgs: string[];
+  configPath?: string;
+}
+
+export async function runImageSpecsCommand(options: SpecsCommandOptions): Promise<void> {
+  const token = await getAccessToken(options.configPath);
+  const baseUrl = await getBaseUrl(options.baseUrl, options.configPath);
+  const cookie = await getSessionCookie(options.cookie, options.configPath);
+  const client = new ApiClient(baseUrl, token, cookie);
+
+  const params = await client.get<ImageParamsResponse>("/image_generation/params");
+  const suppliers = params.img2img?.for_supplier ?? {};
+  if (!options.provider) {
+    process.stdout.write(`${JSON.stringify({ providers: Object.keys(suppliers) }, null, 2)}\n`);
+    return;
+  }
+
+  const providerSpec = suppliers[options.provider];
+  if (!providerSpec) {
+    throw new CliError(`未找到 provider: ${options.provider}`, EXIT_CODES.USAGE);
+  }
+  process.stdout.write(
+    `${JSON.stringify({ provider: options.provider, spec: providerSpec }, null, 2)}\n`,
+  );
+}
+
+export async function runImageGenerateCommand(options: GenerateCommandOptions): Promise<void> {
+  const parsed = parseGenerateCliArgs(options.rawArgs);
+  await ensureInputsReadable(parsed.input);
+  const token = await getAccessToken(options.configPath);
+  const baseUrl = await getBaseUrl(parsed.baseUrl, options.configPath);
+  const cookie = await getSessionCookie(parsed.cookie, options.configPath);
+  const client = new ApiClient(baseUrl, token, cookie);
+  const imageData = await readImagesAsDataUrls(parsed.input);
+
+  const submitPayload: Record<string, unknown> = {
+    supplier: parsed.provider,
+    image: imageData,
+    ...parsed.dynamicParams,
+  };
+  if (parsed.prompt) {
+    submitPayload.prompt = parsed.prompt;
+  }
+  if (parsed.ratio) {
+    submitPayload.ratio = parsed.ratio;
+  }
+
+  if (parsed.verbose) {
+    process.stdout.write(`[generate] provider=${parsed.provider} images=${imageData.length}\n`);
+  }
+
+  const submittedTask = await client.post<ImageGenerationTask>(
+    "/image_generation/img2img",
+    submitPayload,
+  );
+  const taskUuid = submittedTask.task_uuid;
+  if (!taskUuid) {
+    throw new CliError("提交成功但未返回 task_uuid。", EXIT_CODES.API);
+  }
+  process.stdout.write(`TASK_UUID: ${taskUuid}\n`);
+
+  const completedTask = await pollTaskUntilDone(
+    () => client.get<ImageGenerationTask>(`/image_generation/get_task?task_uuid=${taskUuid}`),
+    {
+      intervalMs: 5000,
+      timeoutMs: parsed.timeoutSec * 1000,
+      verbose: parsed.verbose,
+    },
+  );
+
+  const results = completedTask.results ?? [];
+  if (results.length === 0) {
+    throw new CliError("任务已完成，但未返回任何图片结果。", EXIT_CODES.TASK_FAILED);
+  }
+
+  const outputDir = parsed.outputDir ? join(process.cwd(), parsed.outputDir) : process.cwd();
+  for (let index = 0; index < results.length; index += 1) {
+    const item = results[index];
+    if (!item.result_url) {
+      continue;
+    }
+    const name = `img2img_${taskUuid}_${Date.now()}_${index + 1}.${item.format || "jpg"}`;
+    const localPath = await downloadToLocal(item.result_url, outputDir, name);
+    process.stdout.write(`IMAGE_SAVED: ${localPath}\n`);
+    process.stdout.write(`MEDIA:${localPath}\n`);
+  }
+}

package/src/core/apiClient.ts

@@ -0,0 +1,119 @@
+import { CliError, EXIT_CODES } from "./errors";
+import type { ApiEnvelope } from "../types";
+
+interface RequestOptions {
+  method?: "GET" | "POST";
+  body?: unknown;
+  timeoutMs?: number;
+}
+
+export class ApiClient {
+  constructor(
+    private readonly baseUrl: string,
+    private readonly accessToken: string,
+    private readonly sessionCookie?: string,
+    private readonly defaultTimeoutMs = 30000,
+  ) {}
+
+  async get<T>(path: string): Promise<T> {
+    return this.request<T>(path, { method: "GET" });
+  }
+
+  async post<T>(path: string, body: unknown): Promise<T> {
+    return this.request<T>(path, { method: "POST", body });
+  }
+
+  private async request<T>(path: string, options: RequestOptions): Promise<T> {
+    const controller = new AbortController();
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const url = `${this.baseUrl}${path}`;
+
+    try {
+      const response = await fetch(url, {
+        method: options.method ?? "GET",
+        signal: controller.signal,
+        headers: buildHeaders(this.accessToken, this.sessionCookie),
+        body: options.body ? JSON.stringify(options.body) : undefined,
+      });
+
+      const text = await response.text();
+      const payload = text ? safeJsonParse(text) : null;
+
+      if (!response.ok) {
+        const errorMessage = extractErrorMessage(payload) ?? (text || response.statusText);
+        if (response.status === 401) {
+          throw new CliError(`鉴权失败(401): ${errorMessage}`, EXIT_CODES.AUTH);
+        }
+        throw new CliError(
+          `请求失败(${response.status}) ${path}: ${errorMessage}`,
+          EXIT_CODES.API,
+        );
+      }
+
+      return unwrapApiEnvelope<T>(payload);
+    } catch (error) {
+      if (error instanceof CliError) {
+        throw error;
+      }
+      if ((error as Error).name === "AbortError") {
+        throw new CliError(`请求超时: ${path}`, EXIT_CODES.API);
+      }
+      throw new CliError(`网络请求异常: ${(error as Error).message}`, EXIT_CODES.API);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+function safeJsonParse(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { message: text };
+  }
+}
+
+function extractErrorMessage(payload: unknown): string | null {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const maybeMessage = (payload as Record<string, unknown>).message;
+  if (typeof maybeMessage === "string") {
+    return maybeMessage;
+  }
+  const maybeDetail = (payload as Record<string, unknown>).detail;
+  if (typeof maybeDetail === "string") {
+    return maybeDetail;
+  }
+  return null;
+}
+
+function buildHeaders(token: string, cookie?: string): HeadersInit {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${token}`,
+  };
+  if (cookie?.trim()) {
+    headers.Cookie = cookie.trim();
+  }
+  return headers;
+}
+
+function unwrapApiEnvelope<T>(payload: unknown): T {
+  if (!payload || typeof payload !== "object") {
+    return payload as T;
+  }
+  const record = payload as Partial<ApiEnvelope<T>>;
+  if (typeof record.code !== "number") {
+    return payload as T;
+  }
+  if (record.code !== 200) {
+    const message = typeof record.message === "string" ? record.message : "接口返回错误";
+    if (record.code === 401) {
+      throw new CliError(`鉴权失败(401): ${message}`, EXIT_CODES.AUTH);
+    }
+    throw new CliError(`请求失败(${record.code}): ${message}`, EXIT_CODES.API);
+  }
+  return record.data as T;
+}