@flatkey-ai/cli 0.1.5 → 0.1.7

package/test/cli.test.js

@@ -1,143 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { parseArgv, runCommand } from "../src/cli.js";
-
-test("parses image generation with prompt and json mode", () => {
-  const command = parseArgv(["image", "generate", "--prompt", "city at dawn", "--json"]);
-
-  assert.deepEqual(command, {
-    group: "image",
-    action: "generate",
-    options: {
-      prompt: "city at dawn",
-      json: true,
-    },
-  });
-});
-
-test("parses credits with json mode", () => {
-  const command = parseArgv(["credits", "--json"]);
-
-  assert.deepEqual(command, {
-    group: "credits",
-    action: undefined,
-    options: {
-      json: true,
-    },
-  });
-});
-
-test("parses text generation with dry-run", () => {
-  const command = parseArgv([
-    "text",
-    "generate",
-    "--prompt",
-    "write lead",
-    "--model",
-    "gpt-5.5",
-    "--dry-run",
-    "--json",
-  ]);
-
-  assert.deepEqual(command, {
-    group: "text",
-    action: "generate",
-    options: {
-      prompt: "write lead",
-      model: "gpt-5.5",
-      dry_run: true,
-      json: true,
-    },
-  });
-});
-
-test("parses output aliases", () => {
-  assert.equal(
-    parseArgv(["image", "generate", "--prompt", "x", "--output", "out.png"]).options.output,
-    "out.png",
-  );
-  assert.equal(
-    parseArgv(["video", "generate", "--prompt", "x", "-o", "clip.mp4"]).options.output,
-    "clip.mp4",
-  );
-});
-
-test("parses audio voice generation controls", () => {
-  const command = parseArgv([
-    "audio",
-    "generate",
-    "--prompt",
-    "hello",
-    "--voice-id",
-    "voice-123",
-    "--stability",
-    "0.5",
-    "--similarity-boost",
-    "0.75",
-    "--style",
-    "0",
-    "-o",
-    "speech.mp3",
-  ]);
-
-  assert.deepEqual(command, {
-    group: "audio",
-    action: "generate",
-    options: {
-      prompt: "hello",
-      voice_id: "voice-123",
-      stability: "0.5",
-      similarity_boost: "0.75",
-      style: "0",
-      output: "speech.mp3",
-    },
-  });
-});
-
-test("parses audio sfx, music, and voices actions", () => {
-  assert.equal(parseArgv(["audio", "sfx", "--prompt", "glass", "--duration", "3"]).action, "sfx");
-  assert.equal(parseArgv(["audio", "music", "--prompt", "piano", "--music-length-ms", "10000"]).action, "music");
-  assert.equal(parseArgv(["audio", "voices", "--json"]).action, "voices");
-});
-
-test("parses ai help", () => {
-  const command = parseArgv(["help", "--ai"]);
-
-  assert.deepEqual(command, {
-    group: "help",
-    action: undefined,
-    options: {
-      ai: true,
-    },
-  });
-});
-
-test("parses global version aliases", () => {
-  assert.deepEqual(parseArgv(["--version"]), {
-    group: "version",
-    action: undefined,
-    options: {},
-  });
-  assert.deepEqual(parseArgv(["-v"]), {
-    group: "version",
-    action: undefined,
-    options: {},
-  });
-});
-
-test("rejects unknown commands", () => {
-  assert.throws(
-    () => parseArgv(["wat"]),
-    /Unknown command: wat/,
-  );
-});
-
-test("version command matches package version", async () => {
-  const pkg = JSON.parse(await (await import("node:fs/promises")).readFile("package.json", "utf8"));
-
-  assert.equal(await runCommand({ group: "version", options: {} }), pkg.version);
-  assert.deepEqual(await runCommand({ group: "version", options: { json: true } }), {
-    version: pkg.version,
-  });
-});

package/test/config.test.js

@@ -1,62 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readFile, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-
-import { getConfigPath, resolveApiKey, writeConfig } from "../src/config.js";
-
-test("resolves api key from explicit option first", async () => {
-  const configDir = await mkdtemp(join(tmpdir(), "flatkey-config-"));
-  await writeConfig({ apiKey: "saved-key", configDir });
-
-  const key = await resolveApiKey({
-    apiKey: "option-key",
-    env: { FLATKEY_API_KEY: "env-key" },
-    configDir,
-  });
-
-  assert.equal(key, "option-key");
-});
-
-test("resolves api key from FLATKEY_API_KEY before saved config", async () => {
-  const configDir = await mkdtemp(join(tmpdir(), "flatkey-config-"));
-  await writeConfig({ apiKey: "saved-key", configDir });
-
-  const key = await resolveApiKey({
-    env: { FLATKEY_API_KEY: "env-key" },
-    configDir,
-  });
-
-  assert.equal(key, "env-key");
-});
-
-test("resolves api key from saved config", async () => {
-  const configDir = await mkdtemp(join(tmpdir(), "flatkey-config-"));
-  await writeConfig({ apiKey: "saved-key", configDir });
-
-  const key = await resolveApiKey({ env: {}, configDir });
-
-  assert.equal(key, "saved-key");
-});
-
-test("throws actionable error when api key is missing", async () => {
-  const configDir = await mkdtemp(join(tmpdir(), "flatkey-config-"));
-
-  await assert.rejects(
-    () => resolveApiKey({ env: {}, configDir }),
-    /Missing Flatkey API key.*flatkey onboard.*FLATKEY_API_KEY/s,
-  );
-});
-
-test("writes config json with api key", async () => {
-  const configDir = await mkdtemp(join(tmpdir(), "flatkey-config-"));
-
-  const configPath = await writeConfig({ apiKey: "written-key", configDir });
-  const saved = JSON.parse(await readFile(configPath, "utf8"));
-  const fileStat = await stat(configPath);
-
-  assert.equal(configPath, getConfigPath(configDir));
-  assert.equal(saved.apiKey, "written-key");
-  assert.ok((fileStat.mode & 0o777) === 0o600 || process.platform === "win32");
-});

package/test/help.test.js

@@ -1,33 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { getAiHelp, getHumanHelp } from "../src/help.js";
-
-test("ai help teaches agents setup and command usage", () => {
-  const help = getAiHelp();
-
-  assert.match(help, /FLATKEY_API_KEY/);
-  assert.match(help, /flatkey onboard --api-key/);
-  assert.match(help, /flatkey image generate/);
-  assert.match(help, /flatkey video generate/);
-  assert.match(help, /flatkey audio generate/);
-  assert.match(help, /flatkey audio sfx/);
-  assert.match(help, /flatkey audio music/);
-  assert.match(help, /flatkey audio voices/);
-  assert.match(help, /flatkey text generate/);
-  assert.match(help, /flatkey credits --json/);
-  assert.match(help, /flatkey status --json/);
-  assert.match(help, /flatkey models --json/);
-  assert.match(help, /JSON mode/);
-  assert.match(help, /Missing key/);
-});
-
-test("human help lists core commands", () => {
-  const help = getHumanHelp();
-
-  assert.match(help, /Usage: flatkey/);
-  assert.match(help, /image generate/);
-  assert.match(help, /models/);
-  assert.match(help, /audio voices/);
-  assert.match(help, /text generate/);
-});

package/test/integration.test.js

@@ -1,274 +0,0 @@
-import assert from "node:assert/strict";
-import { createServer } from "node:http";
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-
-const BIN = new URL("../bin/flatkey.js", import.meta.url).pathname;
-
-test("runs generation and utility commands in json mode", async (t) => {
-  const requests = [];
-  const server = createServer((request, response) => {
-    let body = "";
-    request.on("data", (chunk) => {
-      body += chunk;
-    });
-    request.on("end", () => {
-      requests.push({ url: request.url, method: request.method, body });
-      if (request.url.startsWith("/v1beta/models/")) {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ data: [{ url: "https://cdn.test/image.png" }] }));
-      } else if (request.url === "/v1/video/generations") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ data: [{ url: "https://cdn.test/video.mp4" }] }));
-      } else if (request.url === "/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL") {
-        response.setHeader("content-type", "audio/mpeg");
-        response.end("audio-file");
-      } else if (request.url === "/v1/chat/completions") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ choices: [{ message: { content: "headline" } }] }));
-      } else if (request.url === "/v1/credits") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ remaining: 42, used: 8 }));
-      } else if (request.url === "/v1/status") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ status: "ok" }));
-      } else if (request.url === "/v1/available_models") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({
-          success: true,
-          object: "list",
-          data: [{ id: "remote-image", object: "model", owned_by: "flatkey" }],
-        }));
-      } else if (request.url === "/v1/voices") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ voices: [{ voice_id: "voice-123", name: "Rachel" }] }));
-      } else {
-        response.setHeader("content-type", "application/json");
-        response.statusCode = 404;
-        response.end(JSON.stringify({ error: { message: "not found" } }));
-      }
-    });
-  });
-  t.after(() => server.close());
-  await listen(server);
-  const baseUrl = `http://127.0.0.1:${server.address().port}`;
-
-  const common = ["--base-url", baseUrl, "--api-key", "test-key", "--json"];
-  const image = await runCli(["image", "generate", "--prompt", "poster", ...common]);
-  const video = await runCli(["video", "generate", "--prompt", "clip", ...common]);
-  const audio = await runCli(["audio", "generate", "--prompt", "voice", ...common]);
-  const text = await runCli(["text", "generate", "--prompt", "headline", ...common]);
-  const credits = await runCli(["credits", ...common]);
-  const status = await runCli(["status", ...common]);
-  const models = await runCli(["models", ...common]);
-  const voices = await runCli(["audio", "voices", ...common]);
-
-  assert.deepEqual(JSON.parse(image.stdout).artifacts, [{ url: "https://cdn.test/image.png" }]);
-  assert.deepEqual(JSON.parse(video.stdout).artifacts, [{ url: "https://cdn.test/video.mp4" }]);
-  assert.equal(JSON.parse(audio.stdout).artifacts.length, 1);
-  assert.match(JSON.parse(audio.stdout).artifacts[0].path, /audio-01\.mp3$/);
-  assert.equal(JSON.parse(text.stdout).text, "headline");
-  assert.equal(JSON.parse(credits.stdout).remaining, 42);
-  assert.equal(JSON.parse(status.stdout).status, "ok");
-  assert.deepEqual(JSON.parse(models.stdout).models, [
-    { id: "remote-image", type: "image", source: "remote" },
-  ]);
-  assert.deepEqual(JSON.parse(voices.stdout).voices, [{ voice_id: "voice-123", name: "Rachel" }]);
-  assert.equal(image.stderr, "");
-  assert.ok(requests.some((request) => request.url.startsWith("/v1beta/models/")));
-  assert.ok(requests.some((request) => request.url === "/v1/video/generations"));
-  assert.ok(requests.some((request) => request.url === "/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL"));
-  assert.ok(requests.some((request) => request.url === "/v1/chat/completions"));
-});
-
-test("dry-run returns planned request without calling network", async () => {
-  const result = await runCli([
-    "image",
-    "generate",
-    "--prompt",
-    "poster",
-    "--model",
-    "gpt-image-2",
-    "--dry-run",
-    "--json",
-  ]);
-
-  const payload = JSON.parse(result.stdout);
-  assert.equal(payload.dryRun, true);
-  assert.equal(payload.kind, "image");
-  assert.equal(payload.request.url, "https://router.flatkey.ai/v1/images/generations");
-  assert.equal(payload.request.body.model, "gpt-image-2");
-  assert.equal(result.stderr, "");
-});
-
-test("audio dry-run supports tts, sfx, and music routes", async () => {
-  const tts = await runCli([
-    "audio",
-    "generate",
-    "--prompt",
-    "hello",
-    "--voice-id",
-    "voice-123",
-    "--dry-run",
-    "--json",
-  ]);
-  const sfx = await runCli([
-    "audio",
-    "sfx",
-    "--prompt",
-    "glass shattering",
-    "--duration",
-    "3",
-    "--dry-run",
-    "--json",
-  ]);
-  const music = await runCli([
-    "audio",
-    "music",
-    "--prompt",
-    "calm ambient piano",
-    "--music-length-ms",
-    "10000",
-    "--dry-run",
-    "--json",
-  ]);
-
-  assert.equal(JSON.parse(tts.stdout).request.url, "https://router.flatkey.ai/v1/text-to-speech/voice-123");
-  assert.equal(JSON.parse(sfx.stdout).request.url, "https://router.flatkey.ai/v1/sound-generation");
-  assert.equal(JSON.parse(sfx.stdout).request.body.duration_seconds, 3);
-  assert.equal(JSON.parse(music.stdout).request.url, "https://router.flatkey.ai/v1/music");
-  assert.equal(JSON.parse(music.stdout).request.body.music_length_ms, 10000);
-});
-
-test("generation commands write explicit output files", async (t) => {
-  const server = createServer((request, response) => {
-    request.on("data", () => {});
-    request.on("end", () => {
-      response.setHeader("content-type", "application/json");
-      if (request.url === "/v1/images/generations") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({
-          data: [{ b64_json: Buffer.from("image-file").toString("base64") }],
-        }));
-      } else if (request.url === "/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL") {
-        response.setHeader("content-type", "audio/mpeg");
-        response.end("audio-file");
-      } else if (request.url === "/v1/chat/completions") {
-        response.setHeader("content-type", "application/json");
-        response.end(JSON.stringify({ choices: [{ message: { content: "text-file" } }] }));
-      } else {
-        response.setHeader("content-type", "application/json");
-        response.statusCode = 404;
-        response.end(JSON.stringify({ error: { message: "not found" } }));
-      }
-    });
-  });
-  t.after(() => server.close());
-  await listen(server);
-  const baseUrl = `http://127.0.0.1:${server.address().port}`;
-  const dir = await mkdtemp(join(tmpdir(), "flatkey-output-"));
-  const imageOutput = join(dir, "poster.png");
-  const audioOutput = join(dir, "speech.mp3");
-  const textOutput = join(dir, "headline.txt");
-
-  const common = ["--base-url", baseUrl, "--api-key", "test-key", "--json"];
-  const image = await runCli([
-    "image",
-    "generate",
-    "--model",
-    "gpt-image-2",
-    "--prompt",
-    "poster",
-    "--output",
-    imageOutput,
-    ...common,
-  ]);
-  const text = await runCli([
-    "text",
-    "generate",
-    "--prompt",
-    "headline",
-    "-o",
-    textOutput,
-    ...common,
-  ]);
-  const audio = await runCli([
-    "audio",
-    "generate",
-    "--prompt",
-    "hello",
-    "-o",
-    audioOutput,
-    ...common,
-  ]);
-
-  assert.deepEqual(JSON.parse(image.stdout).artifacts, [{ path: imageOutput }]);
-  assert.equal(await readFile(imageOutput, "utf8"), "image-file");
-  assert.deepEqual(JSON.parse(audio.stdout).artifacts, [{ path: audioOutput }]);
-  assert.equal(await readFile(audioOutput, "utf8"), "audio-file");
-  assert.equal(JSON.parse(text.stdout).output, textOutput);
-  assert.equal(await readFile(textOutput, "utf8"), "text-file");
-});
-
-test("prints json errors to stderr in json mode", async () => {
-  const result = await runCliAllowFailure(["credits", "--json"]);
-
-  assert.equal(result.code, 1);
-  assert.equal(result.stdout, "");
-  assert.deepEqual(JSON.parse(result.stderr), {
-    error: {
-      message: "Missing Flatkey API key. Run `flatkey onboard --api-key <key>` or set FLATKEY_API_KEY.",
-    },
-  });
-});
-
-function listen(server) {
-  return new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-}
-
-function runCli(args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [BIN, ...args], {
-      env: { ...process.env, FLATKEY_API_KEY: "" },
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error(`CLI exited ${code}\nstdout:${stdout}\nstderr:${stderr}`));
-        return;
-      }
-      resolve({ stdout, stderr });
-    });
-  });
-}
-
-function runCliAllowFailure(args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [BIN, ...args], {
-      env: { ...process.env, FLATKEY_API_KEY: "" },
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      resolve({ code, stdout, stderr });
-    });
-  });
-}

package/test/live-flatkey.test.js

@@ -1,121 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { test } from "node:test";
-
-const BIN = new URL("../bin/flatkey.js", import.meta.url).pathname;
-const LIVE = process.env.FLATKEY_LIVE_TESTS === "1";
-
-const cases = [
-  {
-    name: "models list",
-    args: ["models", "--json"],
-    paid: false,
-    expect: (payload) => {
-      assert.ok(Array.isArray(payload.models));
-      assert.ok(payload.models.length > 0);
-    },
-  },
-  {
-    name: "audio voices",
-    args: ["audio", "voices", "--json"],
-    paid: false,
-    expect: (payload) => {
-      assert.ok(Array.isArray(payload.voices));
-      assert.ok(payload.voices.length > 0);
-    },
-  },
-  {
-    name: "audio tts",
-    args: ["audio", "generate", "--prompt", "flatkey voice test", "--json"],
-    paid: true,
-    dryRun: true,
-    expect: (payload) => assert.equal(payload.request.url, "https://router.flatkey.ai/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL"),
-  },
-  {
-    name: "audio sfx",
-    args: ["audio", "sfx", "--prompt", "glass shattering", "--duration", "3", "--json"],
-    paid: true,
-    dryRun: true,
-    expect: (payload) => assert.equal(payload.request.url, "https://router.flatkey.ai/v1/sound-generation"),
-  },
-  {
-    name: "audio music",
-    args: ["audio", "music", "--prompt", "calm ambient piano", "--music-length-ms", "10000", "--json"],
-    paid: true,
-    dryRun: true,
-    expect: (payload) => assert.equal(payload.request.url, "https://router.flatkey.ai/v1/music"),
-  },
-  {
-    name: "image gpt",
-    args: ["image", "generate", "--model", "gpt-image-2", "--prompt", "one tiny red square icon", "--json"],
-    paid: true,
-    dryRun: false,
-    expect: (payload) => assert.equal(payload.kind, "image"),
-  },
-  {
-    name: "image nano",
-    args: ["image", "generate", "--model", "nano-banana-pro-preview", "--prompt", "one tiny blue square icon", "--json"],
-    paid: true,
-    dryRun: false,
-    expect: (payload) => assert.equal(payload.kind, "image"),
-  },
-  {
-    name: "video seedance2",
-    args: ["video", "generate", "--model", "seedance2", "--prompt", "one second newsroom establishing shot", "--duration", "1", "--json"],
-    paid: true,
-    dryRun: false,
-    expect: (payload) => assert.equal(payload.kind, "video"),
-  },
-  {
-    name: "text gpt-5.5",
-    args: ["text", "generate", "--model", "gpt-5.5", "--prompt", "Write a five word headline.", "--json"],
-    paid: true,
-    dryRun: false,
-    expect: (payload) => {
-      assert.equal(payload.kind, "text");
-      assert.equal(typeof payload.text, "string");
-    },
-  },
-];
-
-for (const item of cases) {
-  test(`live flatkey ${item.name}${item.dryRun ? " dry-run" : ""}`, { skip: !LIVE }, async () => {
-    assert.ok(process.env.FLATKEY_API_KEY, "FLATKEY_API_KEY is required");
-    const outDir = await mkdtemp(join(tmpdir(), "flatkey-live-"));
-    const args = [...item.args, "--out", outDir];
-    if (item.dryRun) args.push("--dry-run");
-    const result = await runCli(args);
-    const payload = JSON.parse(result.stdout);
-    item.expect(payload);
-  });
-}
-
-function runCli(args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [BIN, ...args], {
-      env: {
-        ...process.env,
-        FLATKEY_API_KEY: process.env.FLATKEY_API_KEY,
-      },
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error(`CLI exited ${code}\nstdout:${stdout}\nstderr:${stderr}`));
-        return;
-      }
-      resolve({ stdout, stderr });
-    });
-  });
-}

package/test/models.test.js

@@ -1,56 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { getBundledModels, normalizeModels } from "../src/models.js";
-
-test("returns bundled fallback models with source marker", () => {
-  const models = getBundledModels();
-
-  assert.ok(models.some((model) => model.id === "nano-banana-pro-preview"));
-  assert.ok(models.some((model) => model.id === "seedance2"));
-  assert.ok(models.some((model) => model.id === "gpt-5.5"));
-  assert.ok(models.some((model) => model.type === "video"));
-  assert.ok(models.some((model) => model.type === "text"));
-  assert.ok(models.some((model) => model.type === "audio"));
-  assert.equal(models[0].source, "bundled");
-});
-
-test("filters bundled models by type", () => {
-  const models = getBundledModels("image");
-
-  assert.ok(models.length > 0);
-  assert.ok(models.every((model) => model.type === "image"));
-});
-
-test("normalizes remote model arrays", () => {
-  const models = normalizeModels({
-    data: [
-      { id: "img-x", type: "image" },
-      { id: "vid-x", capabilities: ["video"] },
-    ],
-  });
-
-  assert.deepEqual(models, [
-    { id: "img-x", type: "image", source: "remote" },
-    { id: "vid-x", type: "video", source: "remote" },
-  ]);
-});
-
-test("normalizes OpenAI model list response from /v1/models", () => {
-  const models = normalizeModels({
-    object: "list",
-    data: [
-      { id: "gpt-5.5", object: "model" },
-      { id: "seedance2", object: "model" },
-      { id: "gpt-image-2", object: "model" },
-      { id: "nano-banana-pro-preview", object: "model" },
-    ],
-  });
-
-  assert.deepEqual(models, [
-    { id: "gpt-5.5", type: "text", source: "remote" },
-    { id: "seedance2", type: "video", source: "remote" },
-    { id: "gpt-image-2", type: "image", source: "remote" },
-    { id: "nano-banana-pro-preview", type: "image", source: "remote" },
-  ]);
-});