@flatkey-ai/cli 0.1.0

package/test/config.test.js

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,27 @@
+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 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/);
+});

package/test/integration.test.js

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+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 });
+      response.setHeader("content-type", "application/json");
+      if (request.url.startsWith("/v1beta/models/")) {
+        response.end(JSON.stringify({ data: [{ url: "https://cdn.test/image.png" }] }));
+      } else if (request.url === "/v1/videos/generations") {
+        response.end(JSON.stringify({ data: [{ url: "https://cdn.test/video.mp4" }] }));
+      } else if (request.url === "/v1/audio/generations") {
+        response.end(JSON.stringify({ data: [{ url: "https://cdn.test/audio.mp3" }] }));
+      } else if (request.url === "/v1/credits") {
+        response.end(JSON.stringify({ remaining: 42, used: 8 }));
+      } else if (request.url === "/v1/status") {
+        response.end(JSON.stringify({ status: "ok" }));
+      } else if (request.url === "/v1/models") {
+        response.end(JSON.stringify({ data: [{ id: "remote-image", type: "image" }] }));
+      } else {
+        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 credits = await runCli(["credits", ...common]);
+  const status = await runCli(["status", ...common]);
+  const models = await runCli(["models", ...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.deepEqual(JSON.parse(audio.stdout).artifacts, [{ url: "https://cdn.test/audio.mp3" }]);
+  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.equal(image.stderr, "");
+  assert.ok(requests.some((request) => request.url.startsWith("/v1beta/models/")));
+  assert.ok(requests.some((request) => request.url === "/v1/videos/generations"));
+  assert.ok(requests.some((request) => request.url === "/v1/audio/generations"));
+});
+
+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/models.test.js

@@ -0,0 +1,34 @@
+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.type === "video"));
+  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" },
+  ]);
+});

package/test/package.test.js

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { access, readFile, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { test } from "node:test";
+
+test("package exposes @flatkey-ai/cli flatkey binary", async () => {
+  const pkg = JSON.parse(await readFile("package.json", "utf8"));
+  const binStat = await stat("bin/flatkey.js");
+
+  assert.equal(pkg.name, "@flatkey-ai/cli");
+  assert.equal(pkg.bin.flatkey, "bin/flatkey.js");
+  assert.ok((binStat.mode & 0o111) !== 0);
+});
+
+test("release channel docs exist", async () => {
+  await access("README.md", constants.R_OK);
+  await access("release/homebrew/flatkey.rb", constants.R_OK);
+  await access("release/deb/README.md", constants.R_OK);
+  await access("release/msi/README.md", constants.R_OK);
+});
+
+test("github workflow publishes npm with secret token", async () => {
+  const workflow = await readFile(".github/workflows/npm-publish.yml", "utf8");
+
+  assert.match(workflow, /on:\n\s+workflow_dispatch:/);
+  assert.match(workflow, /tags:\n\s+- "v\*"/);
+  assert.match(workflow, /NODE_AUTH_TOKEN: \$\{\{ secrets\.NPM_TOKEN \}\}/);
+  assert.match(workflow, /npm publish --access public/);
+});