@yswgaicx/yswg-img-cli 0.1.0

package/README.md

@@ -0,0 +1,88 @@
+# yswg-img-cli
+
+`yswg-img` wraps the YSWG Monkey Genius image generation page as a CLI.
+
+## Install Locally
+
+```bash
+npm link
+```
+
+You can also run it without linking:
+
+```bash
+node bin/yswg-img.js --help
+```
+
+## Login
+
+Send the enterprise WeChat verification code:
+
+```bash
+yswg-img auth send-code --email zhangsan
+```
+
+Login with the 6-digit code:
+
+```bash
+yswg-img auth login --email zhangsan --code 123456
+```
+
+The token is saved to `~/.yswg-img-cli/config.json`.
+
+## Generate
+
+Dry-run the backend payload:
+
+```bash
+yswg-img generate \
+  --prompt "一张白底产品图，柔和自然光，高级电商摄影" \
+  --group-id 5 \
+  --model gemini-2.5-flash-image \
+  --ratio 1:1 \
+  --count 1 \
+  --dry-run \
+  --json
+```
+
+Submit and wait for output images:
+
+```bash
+yswg-img generate \
+  --prompt "一张白底产品图，柔和自然光，高级电商摄影" \
+  --group-id 5 \
+  --model gemini-2.5-flash-image \
+  --ratio 1:1 \
+  --count 1 \
+  --out outputs \
+  --json
+```
+
+Use reference images:
+
+```bash
+yswg-img generate \
+  --prompt "参考产品主体，生成室内生活方式场景图" \
+  --group-id 5 \
+  --ref ./product.png,https://example.com/ref.jpg \
+  --out outputs \
+  --json
+```
+
+Submit only and return task IDs:
+
+```bash
+yswg-img generate --prompt "..." --group-id 5 --no-wait --json
+```
+
+## Configuration
+
+Flags override environment variables, which override the saved config.
+
+- `YSWG_TOKEN`
+- `YSWG_REFRESH_TOKEN`
+- `YSWG_APP_ID`
+- `YSWG_BASE_URL`
+- `YSWG_WS_PATH`
+
+Default app ID: `2014153035982319618`.

package/bin/yswg-img.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import { parseArgs, readFlag, splitCsv } from "../src/args.js";
+import { loadConfig, normalizeEmail, resolveConfig, saveConfig, DEFAULT_CONFIG_PATH } from "../src/config.js";
+import { YswgApi } from "../src/api.js";
+import { buildGeneratePayload, downloadImages, extractImageUrls, uploadReferences, waitForTask } from "../src/generate.js";
+
+function printHelp() {
+  console.log(`yswg-img
+
+Commands:
+  auth send-code --email <name|email>
+  auth login --email <name|email> --code <6 digits>
+  models [--app-id <id>]
+  generate --prompt <text> --group-id <id> [--model <name>] [--ratio 1:1] [--count 1] [--ref a.png,b.jpg] [--out outputs]
+
+Environment:
+  YSWG_TOKEN, YSWG_REFRESH_TOKEN, YSWG_APP_ID, YSWG_BASE_URL, YSWG_WS_PATH
+
+Config:
+  ${DEFAULT_CONFIG_PATH}
+`);
+}
+
+function output(data, json = false) {
+  if (json) console.log(JSON.stringify(data, null, 2));
+  else if (typeof data === "string") console.log(data);
+  else console.log(JSON.stringify(data, null, 2));
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  const { command, subcommand, flags } = parsed;
+  const json = Boolean(flags.json);
+  if (command === "help" || flags.help) return printHelp();
+
+  const config = await loadConfig();
+  const resolved = resolveConfig(config, flags);
+  const api = new YswgApi(resolved);
+
+  if (command === "auth" && subcommand === "send-code") {
+    const email = normalizeEmail(readFlag(flags, ["email", "e"]));
+    const check = await api.checkEmail(email);
+    if (check?.registered === false) throw new Error(check.message || "email is not registered");
+    await api.sendCode(email);
+    output({ ok: true, email, message: "验证码已发送，请在企业微信中查收" }, json);
+    return;
+  }
+
+  if (command === "auth" && subcommand === "login") {
+    const email = normalizeEmail(readFlag(flags, ["email", "e"]));
+    const code = String(readFlag(flags, ["code", "c"], "")).trim();
+    if (!code) throw new Error("missing --code");
+    const session = await api.login(email, code);
+    const next = {
+      ...config,
+      baseUrl: resolved.baseUrl,
+      appId: resolved.appId,
+      wsPath: resolved.wsPath,
+      token: session.token,
+      refreshToken: session.refreshToken,
+      user: session,
+      email,
+    };
+    await saveConfig(next);
+    output({ ok: true, email, configPath: DEFAULT_CONFIG_PATH }, json);
+    return;
+  }
+
+  if (command === "models") {
+    const models = await api.models(resolved.appId);
+    output(models, json);
+    return;
+  }
+
+  if (command === "generate") {
+    if (!resolved.token) throw new Error("missing token; run auth login or set YSWG_TOKEN");
+    const prompt = String(readFlag(flags, ["prompt", "p"], "")).trim();
+    const refs = splitCsv(readFlag(flags, ["ref", "refs"], ""));
+    const refImages = await uploadReferences(api, refs);
+    const payload = buildGeneratePayload({
+      appId: resolved.appId,
+      groupId: String(readFlag(flags, ["groupId", "group"], "")),
+      prompt,
+      model: String(readFlag(flags, ["model", "m"], "gemini-2.5-flash-image")),
+      ratio: String(readFlag(flags, ["ratio", "r"], "1:1")),
+      imageCount: Number(readFlag(flags, ["count", "imageCount"], 1)),
+      refImages,
+      size: String(readFlag(flags, ["size"], "")),
+      night: Boolean(flags.night),
+    });
+
+    if (flags.dryRun) {
+      output({ payload }, json);
+      return;
+    }
+
+    const taskIds = await api.createTasks(payload);
+    const ids = Array.isArray(taskIds) ? taskIds : [taskIds?.taskId || taskIds?.id].filter(Boolean);
+    if (!ids.length) throw new Error("create task did not return task ids");
+
+    if (flags.noWait || flags.night) {
+      output({ ok: true, taskIds: ids, payload }, json);
+      return;
+    }
+
+    const timeoutMs = Number(readFlag(flags, ["timeoutMs"], Number(readFlag(flags, ["timeout"], 3600)) * 1000));
+    const messages = await Promise.all(ids.map((taskId) => waitForTask({
+      baseUrl: resolved.baseUrl,
+      token: resolved.token,
+      wsPath: resolved.wsPath,
+      taskId,
+      timeoutMs,
+    })));
+    const imageUrls = messages.flatMap((message) => extractImageUrls(message.responseJson));
+    const files = flags.out === "none" ? [] : await downloadImages(imageUrls, String(readFlag(flags, ["out"], "outputs")));
+    output({ ok: true, taskIds: ids, imageUrls, files }, json);
+    return;
+  }
+
+  printHelp();
+}
+
+main().catch((error) => {
+  console.error(`yswg-img: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@yswgaicx/yswg-img-cli",
+  "version": "0.1.0",
+  "description": "CLI wrapper for YSWG Monkey Genius image generation.",
+  "type": "module",
+  "bin": {
+    "yswg-img": "bin/yswg-img.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "check": "node --check bin/yswg-img.js && node --check src/*.js"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/api.js

@@ -0,0 +1,101 @@
+export class YswgApi {
+  constructor({ baseUrl, token = "", refreshToken = "" }) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token = token;
+    this.refreshToken = refreshToken;
+  }
+
+  async request(path, { method = "GET", data, headers = {}, raw = false, params } = {}) {
+    const url = new URL(`/prod-api${path}`, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== "") url.searchParams.set(key, value);
+      }
+    }
+
+    const requestHeaders = { ...headers };
+    let body;
+    if (data instanceof FormData) {
+      body = data;
+    } else if (data !== undefined) {
+      requestHeaders["Content-Type"] = "application/json;charset=utf-8";
+      body = JSON.stringify(data);
+    }
+    if (this.token) requestHeaders.Authorization = `Bearer ${this.token}`;
+
+    const response = await fetch(url, { method, headers: requestHeaders, body });
+    if (raw) return response;
+
+    const text = await response.text();
+    const json = text ? JSON.parse(text.replace(/(?<=[:,[]\s*)(\d{16,})(?=\s*[,}\]])/g, '"$1"')) : {};
+    if (!response.ok) throw new Error(json.message || `HTTP ${response.status}`);
+    const status = String(json.status ?? json.code ?? "");
+    if (status && status !== "200") {
+      const error = new Error(json.message || "request failed");
+      error.responseData = json;
+      throw error;
+    }
+    return Object.prototype.hasOwnProperty.call(json, "data") ? json.data : json;
+  }
+
+  checkEmail(email) {
+    return this.request("/web/auth/email-checks", { params: { email } });
+  }
+
+  sendCode(email) {
+    return this.request("/web/auth/email-codes", { method: "POST", data: { email } });
+  }
+
+  login(email, code) {
+    return this.request("/web/auth/email-sessions", { method: "POST", data: { email, code } });
+  }
+
+  refresh() {
+    return this.request("/web/auth/token-refresh", {
+      method: "POST",
+      headers: { "Refresh-Token": `Bearer ${this.refreshToken}` },
+    });
+  }
+
+  models(appId) {
+    return this.request(`/web/permissions/models/${appId}`);
+  }
+
+  templates(appId) {
+    return this.request("/system/ai-prompt-templates/options", { params: { appId } });
+  }
+
+  createTasks(payload) {
+    return this.request("/web/ai/invoke/tasks", { method: "POST", data: payload });
+  }
+
+  ossToken(scene = "ai_invoke") {
+    return this.request("/web/oss-tokens", { params: { scene } });
+  }
+
+  async uploadFile(file, filename, scene = "ai_invoke") {
+    const token = await this.ossToken(scene);
+    const info = token?.data || token;
+    const accessId = info.accessId || info.accessKeyId || info.accessid || info.AccessKeyId;
+    const policy = info.policy || info.Policy;
+    const signature = info.signature || info.Signature;
+    const host = info.host || info.Host;
+    const cdnHost = info.cdnHost || info.CdnHost || host;
+    const dir = info.dir || info.Dir || "";
+    if (!accessId || !policy || !signature || !host) throw new Error("invalid OSS token response");
+
+    const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")) : "";
+    const key = `${dir}${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+    const form = new FormData();
+    form.append("key", key);
+    form.append("OSSAccessKeyId", accessId);
+    form.append("policy", policy);
+    form.append("signature", signature);
+    form.append("success_action_status", "200");
+    form.append("file", file, filename);
+
+    const response = await fetch(host, { method: "POST", body: form });
+    if (!response.ok) throw new Error(`OSS upload failed: HTTP ${response.status}`);
+    return `${cdnHost}/${key}`;
+  }
+}

package/src/args.js

@@ -0,0 +1,50 @@
+export function parseArgs(argv) {
+  const [command = "help", maybeSubcommand = "", ...tail] = argv;
+  const hasSubcommand = Boolean(maybeSubcommand) && !maybeSubcommand.startsWith("--");
+  const subcommand = hasSubcommand ? maybeSubcommand : "";
+  const rest = hasSubcommand ? tail : argv.slice(1);
+  const flags = {};
+  const positionals = [];
+
+  for (let i = 0; i < rest.length; i += 1) {
+    const item = rest[i];
+    if (!item.startsWith("--")) {
+      positionals.push(item);
+      continue;
+    }
+
+    const withoutPrefix = item.slice(2);
+    const [rawKey, inlineValue] = withoutPrefix.split(/=(.*)/s, 2);
+    const key = rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+    if (inlineValue !== undefined) {
+      flags[key] = inlineValue;
+      continue;
+    }
+
+    const next = rest[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+      flags[key] = true;
+    } else {
+      flags[key] = next;
+      i += 1;
+    }
+  }
+
+  return { command, subcommand, flags, positionals };
+}
+
+export function splitCsv(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value)
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function readFlag(flags, names, fallback = undefined) {
+  for (const name of names) {
+    if (flags[name] !== undefined) return flags[name];
+  }
+  return fallback;
+}

package/src/config.js

@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+export const DEFAULT_CONFIG_PATH = join(homedir(), ".yswg-img-cli", "config.json");
+export const DEFAULT_BASE_URL = "https://www.yswg.love";
+export const DEFAULT_APP_ID = "2014153035982319618";
+export const DEFAULT_WS_PATH = "/websocket";
+
+export async function loadConfig(path = DEFAULT_CONFIG_PATH) {
+  try {
+    const text = await readFile(path, "utf8");
+    return JSON.parse(text);
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+export async function saveConfig(config, path = DEFAULT_CONFIG_PATH) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+
+export function resolveConfig(config, flags = {}) {
+  return {
+    baseUrl: flags.baseUrl || process.env.YSWG_BASE_URL || config.baseUrl || DEFAULT_BASE_URL,
+    appId: flags.appId || process.env.YSWG_APP_ID || config.appId || DEFAULT_APP_ID,
+    token: flags.token || process.env.YSWG_TOKEN || config.token || "",
+    refreshToken: flags.refreshToken || process.env.YSWG_REFRESH_TOKEN || config.refreshToken || "",
+    wsPath: flags.wsPath || process.env.YSWG_WS_PATH || config.wsPath || DEFAULT_WS_PATH,
+  };
+}
+
+export function normalizeEmail(input) {
+  const raw = String(input || "").trim();
+  if (!raw) throw new Error("missing email");
+  const prefix = raw.replace(/@yswg(?:\.com(?:\.cn)?)?$/i, "");
+  return `${prefix}@yswg.com.cn`;
+}

package/src/generate.js

@@ -0,0 +1,116 @@
+import { basename } from "node:path";
+import { readFile, mkdir, writeFile } from "node:fs/promises";
+
+export function buildGeneratePayload({
+  appId,
+  groupId,
+  prompt,
+  model,
+  ratio = "1:1",
+  imageCount = 1,
+  refImages = [],
+  templates = [],
+  displayPrompt = "",
+  size = "",
+  night = false,
+}) {
+  if (!appId) throw new Error("missing appId");
+  if (!groupId) throw new Error("missing groupId");
+  if (!model) throw new Error("missing model");
+  if (!prompt && templates.length === 0) throw new Error("missing prompt");
+
+  const params = { model };
+  if (prompt) params.prompt = prompt;
+  if (ratio) params.aspect_ratio = ratio;
+  if (refImages.length) params.image = refImages;
+  if (size) params.size = size;
+
+  return {
+    appId,
+    groupId,
+    params,
+    imageCount: Number(imageCount),
+    ...(templates.length ? { templates } : {}),
+    ...(displayPrompt ? { displayPrompt } : {}),
+    ...(night ? { isNightGenerate: true } : {}),
+  };
+}
+
+export function extractImageUrls(responseJson) {
+  const parsed = typeof responseJson === "string" ? JSON.parse(responseJson) : responseJson;
+  const data = parsed?.data ?? parsed?.result?.data ?? parsed?.images ?? parsed;
+  if (Array.isArray(data)) {
+    return data
+      .map((item) => (typeof item === "string" ? item : item?.url || item?.imageUrl))
+      .filter(Boolean);
+  }
+  if (typeof data === "string") return [data];
+  if (data?.url) return [data.url];
+  if (data?.imageUrl) return [data.imageUrl];
+  return [];
+}
+
+export async function uploadReferences(api, refs) {
+  const urls = [];
+  for (const ref of refs) {
+    if (/^https?:\/\//i.test(ref)) {
+      urls.push(ref);
+      continue;
+    }
+    const bytes = await readFile(ref);
+    const blob = new Blob([bytes]);
+    urls.push(await api.uploadFile(blob, basename(ref)));
+  }
+  return urls;
+}
+
+export function waitForTask({ baseUrl, token, wsPath, taskId, timeoutMs = 3600000 }) {
+  const protocol = baseUrl.startsWith("https:") ? "wss:" : "ws:";
+  const host = new URL(baseUrl).host;
+  const url = `${protocol}//${host}${wsPath}?token=${encodeURIComponent(token)}`;
+
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const timer = setTimeout(() => {
+      try {
+        ws.close();
+      } catch {}
+      reject(new Error(`task ${taskId} timed out`));
+    }, timeoutMs);
+
+    const cleanup = () => clearTimeout(timer);
+    ws.addEventListener("open", () => {
+      ws.send(JSON.stringify({ type: 3, taskId }));
+      ws.send(JSON.stringify({ type: 8888 }));
+    });
+    ws.addEventListener("message", (event) => {
+      const text = String(event.data).replace(/(?<=[:,[]\s*)(\d{16,})(?=\s*[,}\]])/g, '"$1"');
+      const msg = JSON.parse(text);
+      if (msg === 9999 || msg.type === 9999 || String(msg.taskId) !== String(taskId) || msg.status === 1) return;
+      cleanup();
+      ws.close();
+      if (msg.status === 2) resolve(msg);
+      else reject(new Error(msg.failReason || `task ${taskId} failed`));
+    });
+    ws.addEventListener("error", () => {
+      cleanup();
+      reject(new Error(`websocket failed for ${taskId}`));
+    });
+  });
+}
+
+export async function downloadImages(urls, outDir) {
+  await mkdir(outDir, { recursive: true });
+  const files = [];
+  for (let i = 0; i < urls.length; i += 1) {
+    const url = urls[i];
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`download failed: HTTP ${response.status} ${url}`);
+    const contentType = response.headers.get("content-type") || "";
+    const ext = contentType.includes("png") ? "png" : contentType.includes("webp") ? "webp" : "jpg";
+    const file = `${outDir.replace(/\/$/, "")}/image-${String(i + 1).padStart(2, "0")}.${ext}`;
+    await writeFile(file, Buffer.from(await response.arrayBuffer()));
+    files.push(file);
+  }
+  return files;
+}