@vivipilot/cli 0.1.0

package/src/cli.ts

@@ -0,0 +1,656 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { flagBoolean, flagNumber, flagString, parseArgv, type ParsedArgs } from "./args.js";
+import {
+  defaultConfigPath,
+  deleteConfig,
+  readConfig,
+  resolveApiKey,
+  resolveApiUrl,
+  writeConfig,
+  type CliConfig,
+  type Env,
+} from "./config.js";
+import { VivipilotApiClient, type EstimateRequest, type ProgressResponse } from "./api.js";
+import { CliError, isCliError } from "./errors.js";
+import { verifyManifestFile } from "./manifest.js";
+import { renderManifest } from "./render.js";
+
+type WritableLike = {
+  write(chunk: string): void;
+};
+
+type CliIo = {
+  stdout: WritableLike;
+  stderr: WritableLike;
+};
+
+// ---------------------------------------------------------------------------
+// Spinner / progress display
+// ---------------------------------------------------------------------------
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+class ProgressDisplay {
+  private io: CliIo;
+  private frame = 0;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastMessage = "";
+  private lastStage = "";
+
+  constructor(io: CliIo) {
+    this.io = io;
+  }
+
+  start(message: string): void {
+    this.lastMessage = message;
+    this.io.stderr.write(`\r${SPINNER_FRAMES[0]} ${message}`);
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+      this.io.stderr.write(`\r${SPINNER_FRAMES[this.frame]} ${this.lastMessage}`);
+    }, 80);
+  }
+
+  update(stage: string, message: string): void {
+    if (stage !== this.lastStage) {
+      // Complete the previous stage with a checkmark
+      if (this.lastStage) {
+        this.io.stderr.write(`\r\x1b[32m✓\x1b[0m ${this.lastMessage}\n`);
+      }
+      this.lastStage = stage;
+    }
+    this.lastMessage = message;
+  }
+
+  succeed(message: string): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.io.stderr.write(`\r\x1b[32m✓\x1b[0m ${message}\n`);
+  }
+
+  fail(message: string): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.io.stderr.write(`\r\x1b[31m✗\x1b[0m ${message}\n`);
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+}
+
+const HELP = `Vivipilot CLI (paid-only)
+
+Usage:
+  vivipilot login --api-key <key> [--api-url <url>]
+  vivipilot logout
+  vivipilot whoami
+  vivipilot balance
+  vivipilot topup
+  vivipilot estimate --prompt "..." [--width 1280 --height 720 --fps 30 --duration 6 --engine auto]
+  vivipilot generate --prompt "..." --out scene.vivi.json [--idempotency-key <key>]
+  vivipilot chat [--out-dir ./scenes] [--width 1280 --height 720 --fps 30 --duration 6]
+  vivipilot verify scene.vivi.json
+  vivipilot render scene.vivi.json --out video.mp4
+  vivipilot mcp
+
+Commands:
+  generate    Create a motion graphics scene (shows live progress)
+  chat        Interactive multi-turn session (like the browser editor)
+  render      Render a signed manifest to video locally
+  verify      Verify a manifest's signature
+  estimate    Preview credit cost without generating
+  balance     Check your paid credit balance
+  topup       Get a link to buy more credits
+
+Environment:
+  VIVIPILOT_API_KEY                 Paid API key for non-interactive use
+  VIVIPILOT_API_URL                 Defaults to https://vivipilot.com
+  VIVIPILOT_MANIFEST_PUBLIC_KEYS    JSON map of keyId to Ed25519 public key
+
+CLI/MCP generation is paid-only: no trial credits and no free generations.
+`;
+
+function writeJson(io: CliIo, value: unknown): void {
+  io.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function requirePrompt(parsed: ParsedArgs): string {
+  const prompt = flagString(parsed, ["prompt", "p"]) ?? parsed.positionals.join(" ");
+  if (!prompt.trim()) throw new CliError("Missing prompt. Pass --prompt \"...\".", 2);
+  return prompt.trim();
+}
+
+function estimateRequestFromArgs(parsed: ParsedArgs): EstimateRequest {
+  const width = flagNumber(parsed, ["width", "w"]);
+  const height = flagNumber(parsed, ["height", "h"]);
+  const fps = flagNumber(parsed, ["fps"]);
+  const durationSeconds = flagNumber(parsed, ["duration", "duration-seconds"]);
+  const engineFlag = flagString(parsed, ["engine"]);
+  const enginePreference = engineFlag === "pixi" || engineFlag === "three" || engineFlag === "auto" ? engineFlag : undefined;
+
+  return {
+    prompt: requirePrompt(parsed),
+    ...(width || height || fps ? { canvas: { width, height, fps } } : {}),
+    ...(durationSeconds ? { durationSeconds } : {}),
+    ...(enginePreference ? { enginePreference } : {}),
+  };
+}
+
+function estimateRequestFromPrompt(
+  prompt: string,
+  defaults: { width?: number; height?: number; fps?: number; durationSeconds?: number },
+): EstimateRequest {
+  return {
+    prompt,
+    ...(defaults.width || defaults.height || defaults.fps
+      ? { canvas: { width: defaults.width, height: defaults.height, fps: defaults.fps } }
+      : {}),
+    ...(defaults.durationSeconds ? { durationSeconds: defaults.durationSeconds } : {}),
+  };
+}
+
+async function writeOutputFile(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function requireManifestPath(parsed: ParsedArgs): string {
+  const path = parsed.positionals[0];
+  if (!path) throw new CliError("Missing manifest path.", 2);
+  return path;
+}
+
+async function handleLogin(parsed: ParsedArgs, env: Env, io: CliIo): Promise<void> {
+  const configPath = defaultConfigPath(env);
+  const currentConfig = await readConfig(configPath);
+  const apiKey = flagString(parsed, ["api-key"]) ?? env.VIVIPILOT_API_KEY;
+  if (!apiKey) throw new CliError("Missing paid API key. Pass --api-key or set VIVIPILOT_API_KEY.", 2);
+
+  const nextConfig: CliConfig = {
+    ...currentConfig,
+    apiKey,
+    apiUrl: flagString(parsed, ["api-url"]) ?? env.VIVIPILOT_API_URL ?? currentConfig.apiUrl,
+  };
+  await writeConfig(nextConfig, configPath);
+  writeJson(io, { ok: true, configPath, paidOnly: true });
+}
+
+async function handleLogout(env: Env, io: CliIo): Promise<void> {
+  const configPath = defaultConfigPath(env);
+  await deleteConfig(configPath);
+  writeJson(io, { ok: true, configPath });
+}
+
+function apiClient(config: CliConfig, env: Env): VivipilotApiClient {
+  return new VivipilotApiClient({ config, env });
+}
+
+async function handleTopup(config: CliConfig, env: Env, io: CliIo): Promise<void> {
+  const apiUrl = resolveApiUrl(config, env);
+  writeJson(io, {
+    paidOnly: true,
+    topupUrl: `${apiUrl}/edit?billing=topup`,
+    message: "CLI/MCP generation requires paid top-up credits.",
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Generate with live progress
+// ---------------------------------------------------------------------------
+
+const POLL_INTERVAL_MS = 1500;
+const MAX_POLL_MS = 300_000; // 5 minute total timeout
+
+async function generateWithProgress(
+  client: VivipilotApiClient,
+  request: EstimateRequest,
+  idempotencyKey: string,
+  outPath: string,
+  io: CliIo,
+): Promise<{ generationId: string; manifestPath: string; creditsCharged: number | null }> {
+  const progress = new ProgressDisplay(io);
+  progress.start("Starting generation...");
+
+  // Start the async generation
+  const startResult = await client.startGenerate(
+    { ...request, outputFormat: "manifest" },
+    idempotencyKey,
+  );
+
+  const { generationId } = startResult;
+  progress.update("start", `Generation ${generationId} started (est. ${startResult.estimatedCredits} credits, engine: ${startResult.engine})`);
+
+  // If it was an idempotent replay and already completed, try to get the data
+  if (startResult.idempotentReplay && startResult.status === "completed") {
+    const status = await client.generationProgress(generationId);
+    if (status.manifestData) {
+      await writeOutputFile(outPath, status.manifestData);
+      progress.succeed(`Scene saved to ${outPath} (${status.creditsCharged ?? 0} credits)`);
+      return { generationId, manifestPath: outPath, creditsCharged: status.creditsCharged };
+    }
+  }
+
+  // Poll for progress
+  const startTime = Date.now();
+  let lastProgressMessage = "";
+
+  while (Date.now() - startTime < MAX_POLL_MS) {
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+
+    let status: ProgressResponse;
+    try {
+      status = await client.generationProgress(generationId);
+    } catch {
+      continue; // Transient network error, keep polling
+    }
+
+    // Show progress update
+    if (status.progressMessage && status.progressMessage !== lastProgressMessage) {
+      lastProgressMessage = status.progressMessage;
+      progress.update(
+        status.workflowStatus ?? status.status,
+        status.progressMessage,
+      );
+    }
+
+    // Terminal states
+    if (status.status === "completed") {
+      if (status.manifestData) {
+        await writeOutputFile(outPath, status.manifestData);
+        progress.succeed(`Scene saved to ${outPath} (${status.creditsCharged ?? 0} credits)`);
+        return { generationId, manifestPath: outPath, creditsCharged: status.creditsCharged };
+      }
+      progress.succeed("Generation complete.");
+      return { generationId, manifestPath: outPath, creditsCharged: status.creditsCharged };
+    }
+
+    if (status.status === "failed") {
+      progress.fail(status.error ?? "Generation failed.");
+      throw new CliError(status.error ?? "Generation failed.", 1);
+    }
+
+    if (status.status === "refunded") {
+      progress.fail("Generation refunded.");
+      throw new CliError("Generation was refunded.", 1);
+    }
+  }
+
+  progress.fail("Generation timed out after 5 minutes.");
+  throw new CliError(`Generation ${generationId} timed out. Check status with: vivipilot status ${generationId}`, 1);
+}
+
+async function handleGenerate(parsed: ParsedArgs, config: CliConfig, env: Env, io: CliIo): Promise<void> {
+  if (!resolveApiKey(config, env)) {
+    throw new CliError("Vivipilot generate is paid-only. Set VIVIPILOT_API_KEY or run `vivipilot login --api-key <key>`.", 2);
+  }
+  const out = flagString(parsed, ["out", "o"]) ?? "scene.vivi.json";
+  const idempotencyKey = flagString(parsed, ["idempotency-key"]) ?? `cli_${randomUUID()}`;
+  const request = estimateRequestFromArgs(parsed);
+
+  const result = await generateWithProgress(
+    apiClient(config, env),
+    request,
+    idempotencyKey,
+    out,
+    io,
+  );
+
+  writeJson(io, {
+    ok: true,
+    generationId: result.generationId,
+    manifestPath: result.manifestPath,
+    creditsCharged: result.creditsCharged,
+    paidOnly: true,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Interactive chat command
+// ---------------------------------------------------------------------------
+
+type ChatSession = {
+  scenes: Array<{ generationId: string; manifestPath: string; prompt: string; creditsCharged: number | null }>;
+  turnNumber: number;
+};
+
+function chatBanner(io: CliIo): void {
+  io.stderr.write("\n\x1b[1m\x1b[36m  Vivipilot Chat\x1b[0m  (paid-only)\n");
+  io.stderr.write("  Type a prompt to generate a motion graphics scene.\n");
+  io.stderr.write("  Commands: /render <n>, /verify <n>, /list, /balance, /help, /quit\n\n");
+}
+
+function chatHelp(io: CliIo): void {
+  io.stderr.write(`
+  \x1b[1mChat Commands:\x1b[0m
+    <prompt>        Generate a new scene from your description
+    /render <n>     Render scene #n to video (e.g. /render 1)
+    /verify <n>     Verify scene #n manifest signature
+    /list           List all generated scenes in this session
+    /balance        Check your credit balance
+    /estimate <p>   Estimate credits for a prompt
+    /help           Show this help
+    /quit           Exit chat
+
+  \x1b[1mTips:\x1b[0m
+    - Each prompt generates a new scene with live progress
+    - Scenes are saved as scene_1.vivi.json, scene_2.vivi.json, etc.
+    - Use /render to render any scene to video after generation
+    - All generations are paid-only and charged to your API key
+\n`);
+}
+
+async function handleChat(parsed: ParsedArgs, config: CliConfig, env: Env, io: CliIo): Promise<void> {
+  if (!resolveApiKey(config, env)) {
+    throw new CliError("Vivipilot chat is paid-only. Set VIVIPILOT_API_KEY or run `vivipilot login --api-key <key>`.", 2);
+  }
+
+  const outDir = flagString(parsed, ["out-dir"]) ?? ".";
+  const width = flagNumber(parsed, ["width", "w"]);
+  const height = flagNumber(parsed, ["height", "h"]);
+  const fps = flagNumber(parsed, ["fps"]);
+  const durationSeconds = flagNumber(parsed, ["duration", "duration-seconds"]);
+
+  const client = apiClient(config, env);
+  const session: ChatSession = { scenes: [], turnNumber: 0 };
+
+  chatBanner(io);
+
+  // Show balance at start
+  try {
+    const bal = await client.balance();
+    io.stderr.write(`  \x1b[33mBalance:\x1b[0m ${bal.paidBalance ?? bal.balance} credits\n\n`);
+  } catch {
+    io.stderr.write("  \x1b[33mCould not fetch balance.\x1b[0m\n\n");
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    prompt: "\x1b[36mvivipilot>\x1b[0m ",
+  });
+
+  rl.prompt();
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      continue;
+    }
+
+    // Handle slash commands
+    if (trimmed.startsWith("/")) {
+      const [cmd, ...rest] = trimmed.split(/\s+/);
+      const arg = rest.join(" ");
+
+      switch (cmd) {
+        case "/quit":
+        case "/exit":
+        case "/q":
+          io.stderr.write("\nGoodbye!\n");
+          rl.close();
+          return;
+
+        case "/help":
+        case "/h":
+          chatHelp(io);
+          break;
+
+        case "/list":
+        case "/ls": {
+          if (session.scenes.length === 0) {
+            io.stderr.write("  No scenes generated yet.\n");
+          } else {
+            io.stderr.write("\n  \x1b[1mGenerated Scenes:\x1b[0m\n");
+            for (let i = 0; i < session.scenes.length; i++) {
+              const s = session.scenes[i];
+              io.stderr.write(`  ${i + 1}. ${s.manifestPath} (${s.creditsCharged ?? "?"} credits)\n`);
+              io.stderr.write(`     \x1b[2m${s.prompt.slice(0, 80)}${s.prompt.length > 80 ? "..." : ""}\x1b[0m\n`);
+            }
+            io.stderr.write("\n");
+          }
+          break;
+        }
+
+        case "/balance":
+        case "/bal": {
+          try {
+            const bal = await client.balance();
+            io.stderr.write(`  \x1b[33mBalance:\x1b[0m ${bal.paidBalance ?? bal.balance} credits\n`);
+          } catch (e) {
+            io.stderr.write(`  \x1b[31mError:\x1b[0m ${e instanceof Error ? e.message : String(e)}\n`);
+          }
+          break;
+        }
+
+        case "/estimate":
+        case "/est": {
+          if (!arg) {
+            io.stderr.write("  Usage: /estimate <prompt>\n");
+            break;
+          }
+          try {
+            const est = await client.estimate(estimateRequestFromPrompt(arg, { width, height, fps, durationSeconds }));
+            io.stderr.write(`  \x1b[33mEstimate:\x1b[0m ${est.estimatedCredits} credits (engine: ${est.engine})\n`);
+          } catch (e) {
+            io.stderr.write(`  \x1b[31mError:\x1b[0m ${e instanceof Error ? e.message : String(e)}\n`);
+          }
+          break;
+        }
+
+        case "/render": {
+          const idx = parseInt(arg, 10) - 1;
+          if (isNaN(idx) || idx < 0 || idx >= session.scenes.length) {
+            io.stderr.write(`  Usage: /render <scene number 1-${session.scenes.length}>\n`);
+            break;
+          }
+          const scene = session.scenes[idx];
+          const videoOut = scene.manifestPath.replace(/\.vivi\.json$/, ".mp4");
+          io.stderr.write(`  Rendering ${scene.manifestPath} -> ${videoOut}...\n`);
+          try {
+            const result = await renderManifest(
+              { manifestPath: scene.manifestPath, outPath: videoOut },
+              config,
+              env,
+            );
+            io.stderr.write(`  \x1b[32m✓\x1b[0m Rendered to ${result.outPath} (${result.size} bytes)\n`);
+          } catch (e) {
+            io.stderr.write(`  \x1b[31m✗\x1b[0m Render failed: ${e instanceof Error ? e.message : String(e)}\n`);
+          }
+          break;
+        }
+
+        case "/verify": {
+          const vidx = parseInt(arg, 10) - 1;
+          if (isNaN(vidx) || vidx < 0 || vidx >= session.scenes.length) {
+            io.stderr.write(`  Usage: /verify <scene number 1-${session.scenes.length}>\n`);
+            break;
+          }
+          const sc = session.scenes[vidx];
+          try {
+            const vResult = await verifyManifestFile(sc.manifestPath, config, env);
+            if (vResult.ok) {
+              io.stderr.write(`  \x1b[32m✓\x1b[0m Manifest verified: ${vResult.manifest.manifestId}\n`);
+            } else {
+              io.stderr.write(`  \x1b[31m✗\x1b[0m Verification failed: ${vResult.message}\n`);
+            }
+          } catch (e) {
+            io.stderr.write(`  \x1b[31m✗\x1b[0m ${e instanceof Error ? e.message : String(e)}\n`);
+          }
+          break;
+        }
+
+        default:
+          io.stderr.write(`  Unknown command: ${cmd}. Type /help for available commands.\n`);
+      }
+
+      rl.prompt();
+      continue;
+    }
+
+    // It's a prompt — generate a scene
+    session.turnNumber++;
+    const sceneNum = session.turnNumber;
+    const outPath = `${outDir}/scene_${sceneNum}.vivi.json`.replace(/^\.\//, "");
+    const idempotencyKey = `chat_${randomUUID()}`;
+
+    io.stderr.write("\n");
+
+    try {
+      const result = await generateWithProgress(
+        client,
+        estimateRequestFromPrompt(trimmed, { width, height, fps, durationSeconds }),
+        idempotencyKey,
+        outPath,
+        io,
+      );
+
+      session.scenes.push({
+        generationId: result.generationId,
+        manifestPath: result.manifestPath,
+        prompt: trimmed,
+        creditsCharged: result.creditsCharged,
+      });
+
+      io.stderr.write(`  \x1b[2mScene #${sceneNum} saved. Use /render ${sceneNum} to render, or type another prompt.\x1b[0m\n\n`);
+    } catch (e) {
+      io.stderr.write(`  \x1b[31mGeneration failed:\x1b[0m ${e instanceof Error ? e.message : String(e)}\n\n`);
+    }
+
+    rl.prompt();
+  }
+
+  // Stream ended (stdin closed)
+  if (session.scenes.length > 0) {
+    io.stderr.write(`\n  Session complete. ${session.scenes.length} scene(s) generated.\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Other command handlers (unchanged)
+// ---------------------------------------------------------------------------
+
+async function handleVerify(parsed: ParsedArgs, config: CliConfig, env: Env, io: CliIo): Promise<void> {
+  const manifestPath = requireManifestPath(parsed);
+  const result = await verifyManifestFile(manifestPath, config, env);
+  if (!result.ok) throw new CliError(`Manifest verification failed: ${result.message}`, 1);
+  writeJson(io, {
+    ok: true,
+    manifestId: result.manifest.manifestId,
+    generationId: result.manifest.generationId,
+    canonicalPayloadHash: result.canonicalPayloadHash,
+  });
+}
+
+async function handleRender(parsed: ParsedArgs, config: CliConfig, env: Env, io: CliIo): Promise<void> {
+	const manifestPath = requireManifestPath(parsed);
+	const out = flagString(parsed, ["out", "o"]) ?? "video.mp4";
+	const format = flagString(parsed, ["format"]) as "mp4" | "webm" | "gif" | "mov" | undefined;
+	const scale = flagNumber(parsed, ["scale"]);
+	const fpsFlag = flagNumber(parsed, ["fps"]);
+	const transparent = flagBoolean(parsed, ["transparent"]);
+	const verifyOnly = flagBoolean(parsed, ["verify-only"]);
+
+	const result = await renderManifest(
+		{
+			manifestPath,
+			outPath: out,
+			...(format ? { format } : {}),
+			...(scale ? { scale } : {}),
+			...(fpsFlag ? { fps: fpsFlag } : {}),
+			...(transparent ? { transparent } : {}),
+			verifyOnly,
+		},
+		config,
+		env,
+	);
+
+	writeJson(io, {
+		ok: true,
+		manifestId: result.manifestId,
+		out: result.outPath,
+		size: result.size,
+		paidOnly: true,
+	});
+}
+
+async function handleMcp(config: CliConfig, env: Env, io: CliIo): Promise<void> {
+  const { startMcpServer } = await import("./mcp.js");
+  await startMcpServer({
+    config,
+    env,
+    stdin: process.stdin,
+    stdout: io.stdout as NodeJS.WritableStream,
+    stderr: io.stderr as NodeJS.WritableStream,
+  });
+}
+
+export async function runCli(argv = process.argv.slice(2), env: Env = process.env, io: CliIo = { stdout: process.stdout, stderr: process.stderr }): Promise<void> {
+  const parsed = parseArgv(argv);
+  if (!parsed.command || parsed.command === "help" || flagBoolean(parsed, ["help"])) {
+    io.stdout.write(HELP);
+    return;
+  }
+
+  const configPath = defaultConfigPath(env);
+  const config = await readConfig(configPath);
+
+  switch (parsed.command) {
+    case "login":
+      await handleLogin(parsed, env, io);
+      return;
+    case "logout":
+      await handleLogout(env, io);
+      return;
+    case "whoami":
+      writeJson(io, await apiClient(config, env).whoami());
+      return;
+    case "balance":
+      writeJson(io, await apiClient(config, env).balance());
+      return;
+    case "topup":
+      await handleTopup(config, env, io);
+      return;
+    case "estimate":
+      writeJson(io, await apiClient(config, env).estimate(estimateRequestFromArgs(parsed)));
+      return;
+    case "generate":
+      await handleGenerate(parsed, config, env, io);
+      return;
+    case "chat":
+      await handleChat(parsed, config, env, io);
+      return;
+    case "status": {
+      const generationId = parsed.positionals[0];
+      if (!generationId) throw new CliError("Missing generation id.", 2);
+      writeJson(io, await apiClient(config, env).generationStatus(generationId));
+      return;
+    }
+    case "verify":
+      await handleVerify(parsed, config, env, io);
+      return;
+    case "render":
+      await handleRender(parsed, config, env, io);
+      return;
+    case "mcp":
+      await handleMcp(config, env, io);
+      return;
+    default:
+      throw new CliError(`Unknown command: ${parsed.command}\n\n${HELP}`, 2);
+  }
+}
+
+runCli().catch((error: unknown) => {
+  if (isCliError(error)) {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = error.exitCode;
+    return;
+  }
+  process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+  process.exitCode = 1;
+});

package/src/config.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { defaultConfigPath, resolveApiKey, resolveApiUrl, resolvePublicKeys, type CliConfig, type Env } from "./config.js";
+
+describe("CLI config", () => {
+  it("resolves config path from VIVIPILOT_CONFIG", () => {
+    expect(defaultConfigPath({ VIVIPILOT_CONFIG: "/tmp/vivi.json" })).toBe("/tmp/vivi.json");
+  });
+
+  it("prefers env API settings over config", () => {
+    const config: CliConfig = { apiUrl: "https://config.example", apiKey: "config-key" };
+    const env: Env = { VIVIPILOT_API_URL: "https://env.example/", VIVIPILOT_API_KEY: " env-key " };
+
+    expect(resolveApiUrl(config, env)).toBe("https://env.example");
+    expect(resolveApiKey(config, env)).toBe("env-key");
+  });
+
+  it("loads public keys from single-key env pair", () => {
+    expect(resolvePublicKeys({}, {
+      VIVIPILOT_MANIFEST_PUBLIC_KEY_ID: "key_1",
+      VIVIPILOT_MANIFEST_PUBLIC_KEY: "public",
+    })).toEqual({ key_1: "public" });
+  });
+
+  it("loads public keys from JSON env", () => {
+    expect(resolvePublicKeys({}, {
+      VIVIPILOT_MANIFEST_PUBLIC_KEYS: JSON.stringify({ key_1: "public" }),
+    })).toEqual({ key_1: "public" });
+  });
+});
+