@flatkey-ai/cli 0.1.4 → 0.1.6

package/test/api.test.js

@@ -1,232 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import {
-  FlatkeyError,
-  generateAudio,
-  generateImage,
-  generateText,
-  generateVideo,
-  getCredits,
-  getModels,
-  getStatus,
-  planImageRequest,
-  planTextRequest,
-  planVideoRequest,
-} from "../src/api.js";
-
-function fetchRecorder(responseBody = { ok: true }) {
-  const calls = [];
-  const fetch = async (url, init) => {
-    calls.push({ url, init });
-    return {
-      ok: true,
-      status: 200,
-      async json() {
-        return responseBody;
-      },
-    };
-  };
-  return { fetch, calls };
-}
-
-test("builds nano image request using gemini-style route", async () => {
-  const { fetch, calls } = fetchRecorder({ candidates: [] });
-
-  await generateImage({
-    apiKey: "key",
-    baseUrl: "https://router.test",
-    prompt: "poster",
-    fetch,
-  });
-
-  assert.equal(
-    calls[0].url,
-    "https://router.test/v1beta/models/nano-banana-pro-preview:generateContent?key=key",
-  );
-  assert.equal(calls[0].init.method, "POST");
-  assert.equal(calls[0].init.headers.Authorization, "Bearer key");
-  assert.equal(calls[0].init.headers["x-goog-api-key"], "key");
-  assert.deepEqual(JSON.parse(calls[0].init.body), {
-    contents: [{ parts: [{ text: "poster" }] }],
-  });
-});
-
-test("builds OpenAI image request for gpt image models", async () => {
-  const { fetch, calls } = fetchRecorder({ data: [] });
-
-  await generateImage({
-    apiKey: "key",
-    baseUrl: "https://router.test",
-    model: "gpt-image-2",
-    prompt: "cover",
-    size: "1024x1024",
-    n: "2",
-    fetch,
-  });
-
-  assert.equal(calls[0].url, "https://router.test/v1/images/generations");
-  assert.equal(calls[0].init.headers.Authorization, "Bearer key");
-  assert.deepEqual(JSON.parse(calls[0].init.body), {
-    model: "gpt-image-2",
-    prompt: "cover",
-    size: "1024x1024",
-    n: 2,
-  });
-});
-
-test("builds video generation request", async () => {
-  const { fetch, calls } = fetchRecorder({ data: [] });
-
-  await generateVideo({
-    apiKey: "key",
-    baseUrl: "https://router.test",
-    model: "veo-3",
-    prompt: "walkthrough",
-    duration: "8",
-    aspect: "16:9",
-    fps: "24",
-    fetch,
-  });
-
-  assert.equal(calls[0].url, "https://router.test/v1/video/generations");
-  assert.deepEqual(JSON.parse(calls[0].init.body), {
-    model: "veo-3",
-    prompt: "walkthrough",
-    duration: 8,
-    aspect: "16:9",
-    fps: 24,
-  });
-});
-
-test("builds seedance2 video generation request", async () => {
-  const { fetch, calls } = fetchRecorder({ data: [] });
-
-  await generateVideo({
-    apiKey: "key",
-    baseUrl: "https://router.test",
-    model: "seedance2",
-    prompt: "newsroom b-roll",
-    fetch,
-  });
-
-  assert.equal(calls[0].url, "https://router.test/v1/video/generations");
-  assert.equal(JSON.parse(calls[0].init.body).model, "seedance2");
-});
-
-test("builds text generation request for gpt-5.5", async () => {
-  const { fetch, calls } = fetchRecorder({ choices: [{ message: { content: "copy" } }] });
-
-  await generateText({
-    apiKey: "key",
-    baseUrl: "https://router.test",
-    model: "gpt-5.5",
-    prompt: "write headline",
-    fetch,
-  });
-
-  assert.equal(calls[0].url, "https://router.test/v1/chat/completions");
-  assert.deepEqual(JSON.parse(calls[0].init.body), {
-    model: "gpt-5.5",
-    messages: [{ role: "user", content: "write headline" }],
-  });
-});
-
-test("builds audio generation request", async () => {
-  const { fetch, calls } = fetchRecorder({ data: [] });
-
-  await generateAudio({
-    apiKey: "key",
-    baseUrl: "https://router.test",
-    model: "tts-1",
-    prompt: "voiceover",
-    voice: "alloy",
-    format: "mp3",
-    fetch,
-  });
-
-  assert.equal(calls[0].url, "https://router.test/v1/audio/generations");
-  assert.deepEqual(JSON.parse(calls[0].init.body), {
-    model: "tts-1",
-    prompt: "voiceover",
-    voice: "alloy",
-    format: "mp3",
-  });
-});
-
-test("builds credits, status, and models requests", async () => {
-  const { fetch, calls } = fetchRecorder({});
-
-  await getCredits({ apiKey: "key", baseUrl: "https://router.test", fetch });
-  await getStatus({ apiKey: "key", baseUrl: "https://router.test", fetch });
-  await getModels({ apiKey: "key", baseUrl: "https://router.test", fetch });
-
-  assert.equal(calls[0].url, "https://router.test/v1/credits");
-  assert.equal(calls[1].url, "https://router.test/v1/status");
-  assert.equal(calls[2].url, "https://router.test/v1/available_models");
-  assert.equal(calls[0].init.headers.Authorization, "Bearer key");
-  assert.equal(calls[2].init.headers.Authorization, "Bearer key");
-});
-
-test("plans available model list request from new-api relay route", async () => {
-  const { fetch, calls } = fetchRecorder({
-    success: true,
-    object: "list",
-    data: [{ id: "gpt-5.5", object: "model", owned_by: "flatkey" }],
-  });
-
-  await getModels({ apiKey: "env-key", fetch });
-
-  assert.equal(calls[0].url, "https://console.flatkey.ai/v1/available_models");
-  assert.equal(calls[0].init.method, "GET");
-  assert.equal(calls[0].init.headers.Authorization, "Bearer env-key");
-});
-
-test("honors explicit base url for available model list request", async () => {
-  const { fetch, calls } = fetchRecorder({ success: true, object: "list", data: [] });
-
-  await getModels({ apiKey: "env-key", baseUrl: "https://router.test", fetch });
-
-  assert.equal(calls[0].url, "https://router.test/v1/available_models");
-});
-
-test("plans dry-run requests for target media models", () => {
-  assert.equal(planImageRequest({
-    apiKey: "key",
-    model: "gpt-image-2",
-    prompt: "poster",
-  }).url, "https://router.flatkey.ai/v1/images/generations");
-
-  assert.match(planImageRequest({
-    apiKey: "key",
-    model: "nano-banana-pro-preview",
-    prompt: "poster",
-  }).url, /\/v1beta\/models\/nano-banana-pro-preview:generateContent\?key=key$/);
-
-  assert.equal(planVideoRequest({
-    apiKey: "key",
-    model: "seedance2",
-    prompt: "clip",
-  }).body.model, "seedance2");
-
-  assert.equal(planTextRequest({
-    apiKey: "key",
-    model: "gpt-5.5",
-    prompt: "headline",
-  }).body.model, "gpt-5.5");
-});
-
-test("throws FlatkeyError with API message on HTTP failure", async () => {
-  const fetch = async () => ({
-    ok: false,
-    status: 402,
-    async json() {
-      return { error: { message: "credits exhausted" } };
-    },
-  });
-
-  await assert.rejects(
-    () => getCredits({ apiKey: "key", baseUrl: "https://router.test", fetch }),
-    (error) => error instanceof FlatkeyError && /credits exhausted/.test(error.message),
-  );
-});

package/test/artifacts.test.js

@@ -1,108 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-
-import { persistArtifacts } from "../src/artifacts.js";
-
-test("saves OpenAI base64 image artifacts", async () => {
-  const outDir = await mkdtemp(join(tmpdir(), "flatkey-artifacts-"));
-
-  const artifacts = await persistArtifacts({
-    kind: "image",
-    response: { data: [{ b64_json: Buffer.from("png-bytes").toString("base64") }] },
-    outDir,
-  });
-
-  assert.equal(artifacts.length, 1);
-  assert.match(artifacts[0].path, /image-01\.png$/);
-  assert.equal(await readFile(artifacts[0].path, "utf8"), "png-bytes");
-});
-
-test("saves data url video artifacts with mime extension", async () => {
-  const outDir = await mkdtemp(join(tmpdir(), "flatkey-artifacts-"));
-
-  const artifacts = await persistArtifacts({
-    kind: "video",
-    response: {
-      data: [{ url: `data:video/mp4;base64,${Buffer.from("mp4-bytes").toString("base64")}` }],
-    },
-    outDir,
-  });
-
-  assert.match(artifacts[0].path, /video-01\.mp4$/);
-  assert.equal(await readFile(artifacts[0].path, "utf8"), "mp4-bytes");
-});
-
-test("preserves remote url artifacts without downloading", async () => {
-  const outDir = await mkdtemp(join(tmpdir(), "flatkey-artifacts-"));
-
-  const artifacts = await persistArtifacts({
-    kind: "audio",
-    response: { data: [{ url: "https://cdn.test/audio.mp3" }] },
-    outDir,
-  });
-
-  assert.deepEqual(artifacts, [{ url: "https://cdn.test/audio.mp3" }]);
-});
-
-test("saves first artifact to explicit output path", async () => {
-  const outDir = await mkdtemp(join(tmpdir(), "flatkey-artifacts-"));
-  const output = join(outDir, "custom.png");
-
-  const artifacts = await persistArtifacts({
-    kind: "image",
-    response: { data: [{ b64_json: Buffer.from("custom-bytes").toString("base64") }] },
-    output,
-  });
-
-  assert.deepEqual(artifacts, [{ path: output }]);
-  assert.equal(await readFile(output, "utf8"), "custom-bytes");
-});
-
-test("adds numeric suffix for multiple artifacts with explicit output path", async () => {
-  const outDir = await mkdtemp(join(tmpdir(), "flatkey-artifacts-"));
-  const output = join(outDir, "custom.png");
-
-  const artifacts = await persistArtifacts({
-    kind: "image",
-    response: {
-      data: [
-        { b64_json: Buffer.from("one").toString("base64") },
-        { b64_json: Buffer.from("two").toString("base64") },
-      ],
-    },
-    output,
-  });
-
-  assert.match(artifacts[0].path, /custom\.png$/);
-  assert.match(artifacts[1].path, /custom-02\.png$/);
-  assert.equal(await readFile(artifacts[1].path, "utf8"), "two");
-});
-
-test("downloads remote url artifact when explicit output path is set", async () => {
-  const outDir = await mkdtemp(join(tmpdir(), "flatkey-artifacts-"));
-  const output = join(outDir, "clip.mp4");
-  const calls = [];
-
-  const artifacts = await persistArtifacts({
-    kind: "video",
-    response: { data: [{ url: "https://cdn.test/clip.mp4" }] },
-    output,
-    fetch: async (url) => {
-      calls.push(url);
-      return {
-        ok: true,
-        status: 200,
-        async arrayBuffer() {
-          return Buffer.from("video-bytes");
-        },
-      };
-    },
-  });
-
-  assert.deepEqual(calls, ["https://cdn.test/clip.mp4"]);
-  assert.deepEqual(artifacts, [{ path: output }]);
-  assert.equal(await readFile(output, "utf8"), "video-bytes");
-});

package/test/cli.test.js

@@ -1,105 +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 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,29 +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 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, /text generate/);
-});