svmc-cli 1.0.0

package/src/core/config.ts

@@ -0,0 +1,101 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { parse, stringify } from "@iarna/toml";
+import type { RuntimeConfig } from "../types";
+import { CliError, EXIT_CODES } from "./errors";
+
+const DEFAULT_CONFIG_PATH = join(homedir(), ".svmc", "config.toml");
+export const DEFAULT_BASE_URL = "https://media.sailvan.com/api/v1";
+
+const EMPTY_CONFIG: RuntimeConfig = {
+  auth: { access_token: "" },
+  server: {},
+};
+
+export function getConfigPath(overridePath?: string): string {
+  return overridePath ?? process.env.SVMC_CONFIG_PATH ?? DEFAULT_CONFIG_PATH;
+}
+
+export async function loadConfig(configPath?: string): Promise<RuntimeConfig> {
+  const resolved = getConfigPath(configPath);
+  try {
+    const content = await readFile(resolved, "utf8");
+    const raw = parse(content) as Partial<RuntimeConfig>;
+    return {
+      auth: {
+        access_token: raw.auth?.access_token ?? "",
+        cookie: raw.auth?.cookie ?? undefined,
+      },
+      server: { base_url: raw.server?.base_url ?? undefined },
+    };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return { ...EMPTY_CONFIG };
+    }
+    throw new CliError(`读取配置失败: ${(error as Error).message}`, EXIT_CODES.IO);
+  }
+}
+
+export async function saveConfig(config: RuntimeConfig, configPath?: string): Promise<string> {
+  const resolved = getConfigPath(configPath);
+  await mkdir(dirname(resolved), { recursive: true });
+  const content = stringify(config as any);
+  await writeFile(resolved, content, "utf8");
+  return resolved;
+}
+
+export async function getAccessToken(configPath?: string): Promise<string> {
+  const cfg = await loadConfig(configPath);
+  const token = cfg.auth.access_token?.trim();
+  if (!token) {
+    throw new CliError(
+      "未找到 SVMC_ACCESS_TOKEN，请先执行 `svmc auth` 完成鉴权。",
+      EXIT_CODES.AUTH,
+    );
+  }
+  return stripBearerPrefix(token);
+}
+
+export async function getSessionCookie(cookieFlag?: string, configPath?: string): Promise<string | undefined> {
+  const fromFlag = cookieFlag?.trim();
+  if (fromFlag) {
+    return fromFlag;
+  }
+  const fromEnv = process.env.SVMC_COOKIE?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  const cfg = await loadConfig(configPath);
+  const fromConfig = cfg.auth.cookie?.trim();
+  return fromConfig || undefined;
+}
+
+export async function getBaseUrl(baseUrlFlag?: string, configPath?: string): Promise<string> {
+  const fromFlag = baseUrlFlag?.trim();
+  if (fromFlag) {
+    return normalizeBaseUrl(fromFlag);
+  }
+  const fromEnv = process.env.SVMC_BASE_URL?.trim();
+  if (fromEnv) {
+    return normalizeBaseUrl(fromEnv);
+  }
+  const config = await loadConfig(configPath);
+  const fromConfig = config.server.base_url?.trim();
+  if (fromConfig) {
+    return normalizeBaseUrl(fromConfig);
+  }
+  return DEFAULT_BASE_URL;
+}
+
+export function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/+$/, "");
+}
+
+function stripBearerPrefix(token: string): string {
+  const normalized = token.trim();
+  if (normalized.toLowerCase().startsWith("bearer ")) {
+    return normalized.slice(7).trim();
+  }
+  return normalized;
+}

package/src/core/downloader.ts

@@ -0,0 +1,42 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
+import { CliError, EXIT_CODES } from "./errors";
+
+export async function downloadToLocal(
+  url: string,
+  outputDir: string,
+  preferredName?: string,
+): Promise<string> {
+  await mkdir(outputDir, { recursive: true });
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new CliError(`下载失败(${response.status}): ${url}`, EXIT_CODES.DOWNLOAD_FAILED);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const fileName = sanitizeFileName(
+    preferredName ?? (basename(new URL(url).pathname) || "image.jpg"),
+  );
+  const fullPath = resolve(join(outputDir, ensureExt(fileName, response.headers.get("content-type"))));
+  await writeFile(fullPath, bytes);
+  return fullPath;
+}
+
+function ensureExt(fileName: string, contentType: string | null): string {
+  if (extname(fileName)) {
+    return fileName;
+  }
+  if (!contentType) {
+    return `${fileName}.jpg`;
+  }
+  if (contentType.includes("png")) {
+    return `${fileName}.png`;
+  }
+  if (contentType.includes("webp")) {
+    return `${fileName}.webp`;
+  }
+  return `${fileName}.jpg`;
+}
+
+function sanitizeFileName(input: string): string {
+  return input.replace(/[^\w.-]+/g, "_");
+}

package/src/core/errors.ts

@@ -0,0 +1,19 @@
+export class CliError extends Error {
+  public readonly exitCode: number;
+
+  constructor(message: string, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+
+export const EXIT_CODES = {
+  OK: 0,
+  USAGE: 2,
+  AUTH: 3,
+  API: 4,
+  TASK_FAILED: 5,
+  DOWNLOAD_FAILED: 6,
+  IO: 7,
+} as const;

package/src/core/parser.ts

@@ -0,0 +1,147 @@
+import { access, readFile } from "node:fs/promises";
+import yargsParser from "yargs-parser";
+import { CliError, EXIT_CODES } from "./errors";
+
+export interface GenerateCliArgs {
+  provider: string;
+  input: string[];
+  prompt?: string;
+  ratio?: string;
+  outputDir?: string;
+  timeoutSec: number;
+  verbose: boolean;
+  baseUrl?: string;
+  cookie?: string;
+  dynamicParams: Record<string, string | number | boolean | string[]>;
+}
+
+export function parseGenerateCliArgs(rawArgs: string[]): GenerateCliArgs {
+  const parsed = yargsParser(rawArgs, {
+    array: ["input"],
+    string: ["provider", "prompt", "ratio", "output-dir", "base-url", "cookie", "config-path"],
+    boolean: ["verbose"],
+    number: ["timeout-sec"],
+    configuration: {
+      "camel-case-expansion": false,
+      "dot-notation": false,
+      "unknown-options-as-args": false,
+      "strip-aliased": true,
+      "strip-dashed": false,
+    },
+  });
+
+  const provider = asString(parsed.provider);
+  if (!provider) {
+    throw new CliError("缺少 `--provider` 参数。", EXIT_CODES.USAGE);
+  }
+
+  const input = toStringArray(parsed.input);
+  if (input.length === 0) {
+    throw new CliError("至少传入一个 `--input` 图片路径。", EXIT_CODES.USAGE);
+  }
+
+  const timeoutSec = typeof parsed["timeout-sec"] === "number" ? parsed["timeout-sec"] : 600;
+  if (!Number.isFinite(timeoutSec) || timeoutSec <= 0) {
+    throw new CliError("`--timeout-sec` 必须为正整数。", EXIT_CODES.USAGE);
+  }
+
+  const dynamicParams = collectDynamicParams(parsed, [
+    "_",
+    "$0",
+    "provider",
+    "input",
+    "prompt",
+    "ratio",
+    "output-dir",
+    "timeout-sec",
+    "verbose",
+    "base-url",
+    "cookie",
+    "config-path",
+  ]);
+
+  return {
+    provider,
+    input,
+    prompt: asString(parsed.prompt),
+    ratio: asString(parsed.ratio),
+    outputDir: asString(parsed["output-dir"]),
+    timeoutSec,
+    verbose: Boolean(parsed.verbose),
+    baseUrl: asString(parsed["base-url"]),
+    cookie: asString(parsed.cookie),
+    dynamicParams,
+  };
+}
+
+export async function ensureInputsReadable(paths: string[]): Promise<void> {
+  for (const path of paths) {
+    try {
+      await access(path);
+    } catch {
+      throw new CliError(`输入文件不存在或不可读: ${path}`, EXIT_CODES.USAGE);
+    }
+  }
+}
+
+export async function readImagesAsDataUrls(paths: string[]): Promise<string[]> {
+  const urls: string[] = [];
+  for (const path of paths) {
+    const content = await readFile(path);
+    const ext = path.split(".").pop()?.toLowerCase() ?? "jpg";
+    const mime = toMime(ext);
+    urls.push(`data:${mime};base64,${content.toString("base64")}`);
+  }
+  return urls;
+}
+
+function toMime(ext: string): string {
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "webp":
+      return "image/webp";
+    case "gif":
+      return "image/gif";
+    case "jpeg":
+    case "jpg":
+    default:
+      return "image/jpeg";
+  }
+}
+
+function collectDynamicParams(
+  parsed: Record<string, unknown>,
+  excludedKeys: string[],
+): Record<string, string | number | boolean | string[]> {
+  const excluded = new Set(excludedKeys);
+  const result: Record<string, string | number | boolean | string[]> = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (excluded.has(key)) {
+      continue;
+    }
+    if (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean" ||
+      (Array.isArray(value) && value.every((item) => typeof item === "string"))
+    ) {
+      result[key] = value as string | number | boolean | string[];
+    }
+  }
+  return result;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function toStringArray(value: unknown): string[] {
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((item): item is string => typeof item === "string");
+  }
+  return typeof value === "string" ? [value] : [];
+}

package/src/core/poller.ts

@@ -0,0 +1,46 @@
+import { CliError, EXIT_CODES } from "./errors";
+import type { ImageGenerationTask } from "../types";
+
+interface PollOptions {
+  intervalMs?: number;
+  timeoutMs?: number;
+  verbose?: boolean;
+}
+
+const RUNNING_STATUSES = new Set(["pending", "processing", "running"]);
+
+export async function pollTaskUntilDone(
+  fetchTask: () => Promise<ImageGenerationTask>,
+  options: PollOptions = {},
+): Promise<ImageGenerationTask> {
+  const intervalMs = options.intervalMs ?? 5000;
+  const timeoutMs = options.timeoutMs ?? 600_000;
+  const start = Date.now();
+
+  while (true) {
+    const task = await fetchTask();
+    const status = task.status;
+    if (options.verbose) {
+      process.stdout.write(`[poll] status=${status} task_uuid=${task.task_uuid}\n`);
+    }
+
+    if (status === "completed") {
+      return task;
+    }
+    if (status === "failed") {
+      const reason = task.error_message ?? "任务失败（无错误详情）";
+      throw new CliError(reason, EXIT_CODES.TASK_FAILED);
+    }
+    if (!RUNNING_STATUSES.has(status)) {
+      throw new CliError(`未知任务状态: ${status}`, EXIT_CODES.API);
+    }
+    if (Date.now() - start > timeoutMs) {
+      throw new CliError("轮询超时，请稍后重试。", EXIT_CODES.API);
+    }
+    await sleep(intervalMs);
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/index.ts

@@ -0,0 +1,108 @@
+import { Command } from "commander";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { runAuthCommand, runAuthStatusCommand } from "./commands/auth";
+import { runImageGenerateCommand, runImageSpecsCommand } from "./commands/image";
+import { CliError } from "./core/errors";
+
+export async function run(argv: string[] = process.argv): Promise<void> {
+  const program = new 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: { configPath?: string; token?: string; cookie?: string }) => {
+      await runAuthCommand(options);
+      },
+    );
+
+  auth
+    .command("status")
+    .description("验证当前认证信息是否可用")
+    .option("--config-path <path>", "指定配置文件路径")
+    .option("--cookie <cookie>", "会话 Cookie，可覆盖配置")
+    .action(async (options: { configPath?: string; cookie?: string }) => {
+      await 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: { provider?: string; baseUrl?: string; cookie?: string; configPath?: string }) =>
+        runImageSpecsCommand(options),
+    );
+
+  image
+    .command("generate")
+    .description("提交 img2img 任务并轮询下载结果")
+    .allowUnknownOption(true)
+    .option("--config-path <path>", "指定配置文件路径")
+    .action(async (options: { configPath?: string }) => {
+      const rawArgs = getRawArgsAfterToken(argv, "generate");
+      await runImageGenerateCommand({
+        rawArgs,
+        configPath: options.configPath,
+      });
+    });
+
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    if (error instanceof 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: string[], token: string): string[] {
+  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(): string {
+  try {
+    const candidates = [join(__dirname, "../package.json"), join(__dirname, "../../package.json")];
+    const target = candidates.find((path) => existsSync(path));
+    if (!target) {
+      return "0.0.0";
+    }
+    const content = readFileSync(target, "utf8");
+    const pkg = JSON.parse(content) as { version?: string };
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,47 @@
+export type TaskStatus = "pending" | "processing" | "running" | "completed" | "failed";
+
+export interface ResultItem {
+  result_url: string;
+  thumbnail_url?: string;
+  format?: string;
+  width?: number;
+  height?: number;
+  size?: number;
+}
+
+export interface ImageGenerationTask {
+  id?: number;
+  task_uuid: string;
+  status: TaskStatus;
+  supplier?: string;
+  error_message?: string;
+  results?: ResultItem[];
+  request_payload?: Record<string, unknown>;
+}
+
+export interface ModuleParamsConfig {
+  supplier?: Record<string, unknown>;
+  for_supplier?: Record<string, Record<string, unknown>>;
+}
+
+export interface ImageParamsResponse {
+  img2img?: ModuleParamsConfig;
+  [key: string]: unknown;
+}
+
+export interface RuntimeConfig {
+  auth: {
+    access_token: string;
+    cookie?: string;
+  };
+  server: {
+    base_url?: string;
+  };
+}
+
+export interface ApiEnvelope<T> {
+  code: number;
+  message?: string;
+  success?: boolean;
+  data: T;
+}

package/tests/apiClient.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ApiClient } from "../src/core/apiClient";
+import { CliError } from "../src/core/errors";
+
+describe("ApiClient", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("returns parsed json when request succeeds", async () => {
+    vi.stubGlobal(
+      "fetch",
+      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("https://example.com", "token");
+    const res = await client.get<{ ok: boolean }>("/ping");
+    expect(res.ok).toBe(true);
+  });
+
+  it("throws CliError on 401", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () =>
+        new Response(JSON.stringify({ message: "unauthorized" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" },
+        }),
+      ),
+    );
+    const client = new ApiClient("https://example.com", "token");
+    await expect(client.get("/ping")).rejects.toBeInstanceOf(CliError);
+  });
+
+  it("throws CliError when business code is 401", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () =>
+        new Response(JSON.stringify({ code: 401, message: "未登录或登录已过期", data: null }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        }),
+      ),
+    );
+    const client = new ApiClient("https://example.com", "token");
+    await expect(client.get("/ping")).rejects.toBeInstanceOf(CliError);
+  });
+});

package/tests/config.test.ts

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

package/tests/parser.test.ts

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

package/tests/poller.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { pollTaskUntilDone } from "../src/core/poller";
+
+describe("pollTaskUntilDone", () => {
+  it("returns completed task", async () => {
+    const statuses = ["pending", "processing", "completed"];
+    const task = await pollTaskUntilDone(
+      async () => ({
+        task_uuid: "t-1",
+        status: statuses.shift() as "pending" | "processing" | "completed",
+      }),
+      { intervalMs: 1, timeoutMs: 1000 },
+    );
+    expect(task.status).toBe("completed");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "rootDir": ".",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.ts"],
+    exclude: ["dist/**", "node_modules/**"],
+  },
+});