feat(baoyu-imagine): rename baoyu-image-gen to baoyu-imagine

2026-08-08 01:43:03 +08:00 · 2026-03-25 16:28:06 -05:00
parent 23b7487321
commit 69355b4ee1
34 changed files with 76 additions and 76 deletions
@@ -0,0 +1,171 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test, { type TestContext } from "node:test";
+
+import type { CliArgs } from "../types.ts";
+import {
+  buildMinimaxUrl,
+  buildRequestBody,
+  buildSubjectReference,
+  extractImageFromResponse,
+  parsePixelSize,
+  validateArgs,
+} from "./minimax.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
+  return {
+    prompt: null,
+    promptFiles: [],
+    imagePath: null,
+    provider: null,
+    model: null,
+    aspectRatio: null,
+    size: null,
+    quality: null,
+    imageSize: null,
+    referenceImages: [],
+    n: 1,
+    batchFile: null,
+    jobs: null,
+    json: false,
+    help: false,
+    ...overrides,
+  };
+}
+
+test("MiniMax URL builder normalizes /v1 suffixes", (t) => {
+  useEnv(t, { MINIMAX_BASE_URL: "https://api.minimax.io" });
+  assert.equal(buildMinimaxUrl(), "https://api.minimax.io/v1/image_generation");
+
+  process.env.MINIMAX_BASE_URL = "https://proxy.example.com/custom/v1/";
+  assert.equal(buildMinimaxUrl(), "https://proxy.example.com/custom/v1/image_generation");
+});
+
+test("MiniMax size parsing and validation follow documented constraints", () => {
+  assert.deepEqual(parsePixelSize("1536x1024"), { width: 1536, height: 1024 });
+  assert.deepEqual(parsePixelSize("1536*1024"), { width: 1536, height: 1024 });
+  assert.equal(parsePixelSize("wide"), null);
+
+  validateArgs("image-01", makeArgs({ size: "1536x1024", n: 9 }));
+
+  assert.throws(
+    () => validateArgs("image-01-live", makeArgs({ size: "1536x1024" })),
+    /only supported with model image-01/,
+  );
+  assert.throws(
+    () => validateArgs("image-01", makeArgs({ size: "1537x1024" })),
+    /divisible by 8/,
+  );
+  assert.throws(
+    () => validateArgs("image-01", makeArgs({ aspectRatio: "2.35:1" })),
+    /aspect_ratio must be one of/,
+  );
+  assert.throws(
+    () => validateArgs("image-01", makeArgs({ n: 10 })),
+    /at most 9 images/,
+  );
+});
+
+test("MiniMax request body maps aspect ratio, size, n, and subject references", async (t) => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "minimax-test-"));
+  t.after(() => fs.rm(dir, { recursive: true, force: true }));
+
+  const refPath = path.join(dir, "portrait.png");
+  await fs.writeFile(refPath, Buffer.from("portrait"));
+
+  const ratioBody = await buildRequestBody(
+    "A portrait by the window",
+    "image-01",
+    makeArgs({ aspectRatio: "16:9", n: 2, referenceImages: [refPath] }),
+  );
+  assert.equal(ratioBody.aspect_ratio, "16:9");
+  assert.equal(ratioBody.n, 2);
+  assert.equal(ratioBody.response_format, "base64");
+  assert.match(ratioBody.subject_reference?.[0]?.image_file || "", /^data:image\/png;base64,/);
+
+  const sizeBody = await buildRequestBody(
+    "A portrait by the window",
+    "image-01",
+    makeArgs({ size: "1536x1024" }),
+  );
+  assert.equal(sizeBody.width, 1536);
+  assert.equal(sizeBody.height, 1024);
+  assert.equal(sizeBody.aspect_ratio, undefined);
+});
+
+test("MiniMax subject references require supported file types", async (t) => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "minimax-ref-"));
+  t.after(() => fs.rm(dir, { recursive: true, force: true }));
+
+  const good = path.join(dir, "portrait.jpg");
+  const bad = path.join(dir, "portrait.webp");
+  await fs.writeFile(good, Buffer.from("portrait"));
+  await fs.writeFile(bad, Buffer.from("portrait"));
+
+  const subjectReference = await buildSubjectReference([good]);
+  assert.equal(subjectReference?.[0]?.type, "character");
+
+  await assert.rejects(
+    () => buildSubjectReference([bad]),
+    /only supports JPG, JPEG, or PNG/,
+  );
+});
+
+test("MiniMax response extraction supports base64 and URL payloads", async (t) => {
+  const originalFetch = globalThis.fetch;
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  const fromBase64 = await extractImageFromResponse({
+    data: {
+      image_base64: [Buffer.from("hello").toString("base64")],
+    },
+  });
+  assert.equal(Buffer.from(fromBase64).toString("utf8"), "hello");
+
+  globalThis.fetch = async () =>
+    new Response(Uint8Array.from([1, 2, 3]), {
+      status: 200,
+      headers: { "Content-Type": "image/jpeg" },
+    });
+
+  const fromUrl = await extractImageFromResponse({
+    data: {
+      image_urls: ["https://example.com/output.jpg"],
+    },
+  });
+  assert.deepEqual([...fromUrl], [1, 2, 3]);
+
+  await assert.rejects(
+    () => extractImageFromResponse({ base_resp: { status_code: 1001, status_msg: "blocked" } }),
+    /blocked/,
+  );
+});