faceless-cli 1.0.0

package/src/index.mjs

@@ -0,0 +1,767 @@
+import fs from "node:fs";
+import readline from "node:readline/promises";
+import { Command, Option } from "commander";
+import { CONFIG_PATH, loadConfig, resolveApiKey, resolveBaseUrl, saveConfig } from "./config.mjs";
+import { CliError, exitCodeFor, request, sleep } from "./client.mjs";
+import { print, printError } from "./output.mjs";
+
+const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+let spec;
+try {
+  spec = JSON.parse(
+    fs.readFileSync(new URL("./generated/operations.json", import.meta.url), "utf8")
+  );
+} catch {
+  process.stderr.write(
+    'cli/src/generated/operations.json is missing. Run "npm run generate:agents" in the repo root to generate it.\n'
+  );
+  process.exit(1);
+}
+const operations = spec.operations;
+
+function getOp(operationId) {
+  const op = operations.find((o) => o.operationId === operationId);
+  if (!op) {
+    throw new CliError("internal_error", `Unknown operation: ${operationId}`);
+  }
+  return op;
+}
+
+function toInt(value) {
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n)) throw new CliError("invalid_input", `Not a number: ${value}`);
+  return n;
+}
+
+function splitList(value) {
+  return value
+    .split(",")
+    .map((v) => v.trim())
+    .filter(Boolean);
+}
+
+function compact(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined && value !== null) out[key] = value;
+  }
+  return out;
+}
+
+const MODELS = ["storyboard", "motion_lite", "motion_pro"];
+const PLATFORMS = ["youtube", "tiktok", "instagram", "x", "facebook", "linkedin", "threads"];
+const OPTION_KINDS = [
+  "sources",
+  "styles",
+  "niches",
+  "languages",
+  "durations",
+  "models",
+  "captionThemes",
+  "music",
+  "backgrounds",
+  "subreddits",
+];
+
+async function execute(
+  operationId,
+  { pathParams = {}, query = {}, body, idempotencyKey } = {},
+  cmd
+) {
+  const globals = cmd.optsWithGlobals();
+  const op = getOp(operationId);
+  const path = op.path.replace(/\{(\w+)\}/g, (_, name) => {
+    const value = pathParams[name];
+    if (value === undefined) {
+      throw new CliError("invalid_input", `Missing required parameter: ${name}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+  return request({
+    method: op.method,
+    path,
+    query: compact(query),
+    body: body === undefined ? undefined : compact(body),
+    apiKey: resolveApiKey(globals),
+    baseUrl: resolveBaseUrl(globals),
+    idempotencyKey,
+  });
+}
+
+async function waitForTerminal({ operationId, label, id, timeoutSec, cmd }) {
+  const terminal = getOp(operationId).terminalStates || [];
+  const deadline = Date.now() + timeoutSec * 1000;
+  for (;;) {
+    const result = await execute(operationId, { pathParams: { id } }, cmd);
+    const data = (result && result.data) || {};
+    if (terminal.includes(data.status)) {
+      return result;
+    }
+    if (Date.now() >= deadline) {
+      throw new CliError(
+        "timeout",
+        `Timed out after ${timeoutSec}s waiting for ${label} ${id} (last status: ${data.status || "unknown"})`
+      );
+    }
+    await sleep(5000);
+  }
+}
+
+// Polls GET /videos/{id}/status until completed or failed.
+function waitForVideo(id, timeoutSec, cmd) {
+  return waitForTerminal({ operationId: "getVideoStatus", label: "video", id, timeoutSec, cmd });
+}
+
+// Polls GET /renders/{id} until done or error.
+function waitForRender(id, timeoutSec, cmd) {
+  return waitForTerminal({ operationId: "getRender", label: "render", id, timeoutSec, cmd });
+}
+
+function noteCost(operationId) {
+  const cost = getOp(operationId).creditCost;
+  if (cost && cost !== "none") process.stderr.write(`This costs ${cost}.\n`);
+}
+
+// Async create commands share one shape: state the cost, fire the request,
+// then optionally poll the created video's status until it is terminal.
+async function createAndMaybeWait(operationId, body, opts, cmd) {
+  const globals = cmd.optsWithGlobals();
+  noteCost(operationId);
+  const created = await execute(operationId, { body, idempotencyKey: opts.idempotencyKey }, cmd);
+  const id = created?.data?.id;
+  if (!opts.wait || !id) {
+    print(created, { json: globals.json });
+    return;
+  }
+  print(await waitForVideo(id, opts.timeout, cmd), { json: globals.json });
+}
+
+function withWaitFlags(command, what) {
+  return command
+    .option("--wait", `poll until the ${what} reaches a terminal state`)
+    .option("--timeout <sec>", "max seconds to wait with --wait", toInt, 600);
+}
+
+// Series settings shared by "series create" and "series update". Field names
+// mirror the createSeries request schema.
+function withSeriesFlags(command) {
+  return command
+    .option("--niche <niche>", "content niche, e.g. scary stories (see: faceless options --kind niches)")
+    .option("--custom-prompt <text>", "custom topic prompt used instead of (or alongside) a niche")
+    .option("--voice <id>", "TTS voice id for narration (see: faceless voices)")
+    .option("--style <style>", "visual style for generated imagery (see: faceless options --kind styles)")
+    .option("--language <language>", "video language, e.g. English")
+    .addOption(
+      new Option("--duration <sec>", "target episode length in seconds").choices(["30", "60", "90"])
+    )
+    .option("--destination <platform>", "primary auto-post destination, e.g. youtube or tiktok")
+    .option(
+      "--destination-accounts <id[,id...]>",
+      "connected account ids to auto-post to (see: faceless accounts)"
+    )
+    .option("--auto-post-time <HH:mm>", "daily auto-post time in the series timezone")
+    .option(
+      "--posting-days <days>",
+      "comma-separated days of the week to post, e.g. Monday,Wednesday (omit for every day)"
+    )
+    .option("--timezone <tz>", "IANA timezone for scheduling, e.g. America/New_York")
+    .option("--caption-style <name>", "caption theme name (see: faceless options --kind captionThemes)")
+    .option("--subreddit <name>", 'subreddit to pull posts from when source is "Reddit post"')
+    .option(
+      "--background-video <id>",
+      "background gameplay/footage id (see: faceless options --kind backgrounds)"
+    )
+    .option("--random-background-video", "pick a random background video per episode")
+    .option("--layout <layout>", "video layout variant")
+    .addOption(
+      new Option("--broll-model <model>", "generation model for visuals").choices(MODELS)
+    )
+    .option("--show-emojis", "overlay emojis on captions")
+    .option("--enable-background-music", "mix background music under the narration")
+    .option(
+      "--background-music-mood <mood>",
+      "background music mood (see: faceless options --kind music)"
+    )
+    .option("--hashtags <text>", "hashtags appended to post captions")
+    .option("--tone <tone>", "writing tone for generated scripts")
+    .addOption(
+      new Option("--youtube-privacy <p>", "privacy for auto-posted YouTube videos").choices([
+        "public",
+        "unlisted",
+        "private",
+      ])
+    );
+}
+
+function seriesBody(opts) {
+  return compact({
+    name: opts.name,
+    source: opts.source,
+    niche: opts.niche,
+    customPrompt: opts.customPrompt,
+    voice: opts.voice,
+    style: opts.style,
+    language: opts.language,
+    duration: opts.duration,
+    destination: opts.destination,
+    destinationAccounts: opts.destinationAccounts ? splitList(opts.destinationAccounts) : undefined,
+    autoPostTime: opts.autoPostTime,
+    postingDays: opts.postingDays ? splitList(opts.postingDays) : undefined,
+    timezone: opts.timezone,
+    captionStyle: opts.captionStyle,
+    subreddit: opts.subreddit,
+    backgroundVideo: opts.backgroundVideo,
+    useRandomBackgroundVideo: opts.randomBackgroundVideo,
+    layout: opts.layout,
+    brollModel: opts.brollModel,
+    showEmojis: opts.showEmojis,
+    enableBackgroundMusic: opts.enableBackgroundMusic,
+    backgroundMusicMood: opts.backgroundMusicMood,
+    hashtags: opts.hashtags,
+    tone: opts.tone,
+    youtubePrivacyStatus: opts.youtubePrivacy,
+    paused: opts.paused,
+  });
+}
+
+const program = new Command();
+
+program
+  .name("faceless")
+  .description(
+    "Faceless.so CLI: create AI faceless videos, run automated series and publish to YouTube, TikTok, Instagram and more."
+  )
+  .version(pkg.version)
+  .option("--json", "output raw JSON")
+  .option("--api-key <key>", "API key (overrides env and config file)")
+  .option("--api-url <url>", "API base URL (default https://faceless.so/api/v1)");
+
+program
+  .command("login")
+  .description("Save an API key to ~/.faceless/config.json (verified against /me)")
+  .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    let key = globals.apiKey;
+    if (!key) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+      });
+      key = (await rl.question("API key (fl_live_...): ")).trim();
+      rl.close();
+    }
+    if (!key) throw new CliError("invalid_input", "No API key provided");
+    const result = await request({
+      method: "get",
+      path: "/me",
+      apiKey: key,
+      baseUrl: resolveBaseUrl(globals),
+    });
+    saveConfig({ apiKey: key });
+    if (globals.json || !process.stdout.isTTY) {
+      print(result, { json: true });
+      return;
+    }
+    const data = (result && result.data) || {};
+    const scopes = data.auth?.scopes || [];
+    process.stdout.write(`Logged in as ${data.team?.name || "unknown team"}\n`);
+    process.stdout.write(`Scopes: ${scopes.length ? scopes.join(", ") : "(none)"}\n`);
+    process.stdout.write(`Saved key to ${CONFIG_PATH}\n`);
+  });
+
+program
+  .command("logout")
+  .description("Remove the saved API key from ~/.faceless/config.json")
+  .action(async () => {
+    const config = loadConfig();
+    if (!config.apiKey) {
+      process.stdout.write("No saved API key.\n");
+      return;
+    }
+    delete config.apiKey;
+    saveConfig({ ...config, apiKey: undefined });
+    process.stdout.write(`Removed API key from ${CONFIG_PATH}\n`);
+  });
+
+program
+  .command("whoami")
+  .description(getOp("getMe").summary)
+  .action(async (_opts, cmd) => {
+    const result = await execute("getMe", {}, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("credits")
+  .description(getOp("getCredits").summary)
+  .option("--page <n>", "page number", toInt)
+  .option("--limit <n>", "items per page (max 100)", toInt)
+  .action(async (opts, cmd) => {
+    const result = await execute("getCredits", { query: { page: opts.page, limit: opts.limit } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+const videos = program.command("videos").description("Faceless video projects");
+
+withWaitFlags(
+  videos
+    .command("create")
+    .description(getOp("createVideo").summary)
+    .requiredOption("--script <text>", "the full narration script the video is generated from")
+    .requiredOption("--voice-id <id>", "TTS voice id for the narration (see: faceless voices)")
+    .addOption(
+      new Option(
+        "--model <model>",
+        "generation model: storyboard (20 credits), motion_lite (50) or motion_pro (100)"
+      ).choices(MODELS)
+    )
+    .option("--style <style>", "visual style for generated imagery (see: faceless options --kind styles)")
+    .option("--language <language>", "script language, e.g. English")
+    .option("--name <name>", "project name; defaults to the start of the script")
+    .option("--enable-background-music", "mix background music under the narration")
+    .option("--master-style <text>", "extra style directive applied to every generated scene")
+    .option("--global-negative-prompt <text>", "things the image model should avoid in every scene")
+    .option("--idempotency-key <k>", "Idempotency-Key header value"),
+  "video"
+).action(async (opts, cmd) => {
+  await createAndMaybeWait(
+    "createVideo",
+    {
+      script: opts.script,
+      voiceId: opts.voiceId,
+      model: opts.model,
+      style: opts.style,
+      language: opts.language,
+      name: opts.name,
+      enableBackgroundMusic: opts.enableBackgroundMusic,
+      masterStyle: opts.masterStyle,
+      globalNegativePrompt: opts.globalNegativePrompt,
+    },
+    opts,
+    cmd
+  );
+});
+
+withWaitFlags(
+  videos
+    .command("captions")
+    .description(getOp("createCaptionVideo").summary)
+    .option("--video-url <url>", "public URL of the video file to caption")
+    .option("--audio-url <url>", "public URL of an audio file to turn into a captioned video")
+    .option("--name <name>", "project name")
+    .option("--language <language>", "spoken language of the file, e.g. English")
+    .option("--idempotency-key <k>", "Idempotency-Key header value"),
+  "video"
+).action(async (opts, cmd) => {
+  await createAndMaybeWait(
+    "createCaptionVideo",
+    {
+      videoUrl: opts.videoUrl,
+      audioUrl: opts.audioUrl,
+      name: opts.name,
+      language: opts.language,
+    },
+    opts,
+    cmd
+  );
+});
+
+videos
+  .command("list")
+  .description(getOp("listVideos").summary)
+  .option("--archived", "only archived videos")
+  .option("--page <n>", "page number", toInt)
+  .option("--limit <n>", "items per page (max 100)", toInt)
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "listVideos",
+      { query: { archived: opts.archived, page: opts.page, limit: opts.limit } },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+videos
+  .command("get <id>")
+  .description(getOp("getVideo").summary)
+  .action(async (id, _opts, cmd) => {
+    const result = await execute("getVideo", { pathParams: { id } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+videos
+  .command("update <id>")
+  .description(getOp("updateVideo").summary)
+  .option("--name <name>", "project name")
+  .option("--youtube-title <text>", "YouTube title (max 100 chars)")
+  .option("--youtube-description <text>", "YouTube description")
+  .addOption(
+    new Option("--youtube-privacy <p>", "YouTube privacy, defaults to public").choices([
+      "public",
+      "unlisted",
+      "private",
+    ])
+  )
+  .option("--tiktok-title <text>", "TikTok caption")
+  .option("--instagram-caption <text>", "Instagram caption")
+  .option("--x-text <text>", "X post text (max 280 chars)")
+  .option("--facebook-description <text>", "Facebook description")
+  .option("--linkedin-description <text>", "LinkedIn description")
+  .option("--threads-text <text>", "Threads post text")
+  .action(async (id, opts, cmd) => {
+    const youtubePost = compact({
+      title: opts.youtubeTitle,
+      description: opts.youtubeDescription,
+      privacyStatus: opts.youtubePrivacy,
+    });
+    const body = compact({
+      name: opts.name,
+      youtubePost: Object.keys(youtubePost).length ? youtubePost : undefined,
+      tiktokPost: opts.tiktokTitle !== undefined ? { title: opts.tiktokTitle } : undefined,
+      instagramPost:
+        opts.instagramCaption !== undefined ? { caption: opts.instagramCaption } : undefined,
+      xPost: opts.xText !== undefined ? { text: opts.xText } : undefined,
+      facebookPost:
+        opts.facebookDescription !== undefined
+          ? { description: opts.facebookDescription }
+          : undefined,
+      linkedinPost:
+        opts.linkedinDescription !== undefined
+          ? { description: opts.linkedinDescription }
+          : undefined,
+      threadsPost: opts.threadsText !== undefined ? { text: opts.threadsText } : undefined,
+    });
+    const result = await execute("updateVideo", { pathParams: { id }, body }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+withWaitFlags(
+  videos.command("status <id>").description(getOp("getVideoStatus").summary),
+  "video"
+).action(async (id, opts, cmd) => {
+  const globals = cmd.optsWithGlobals();
+  const result = opts.wait
+    ? await waitForVideo(id, opts.timeout, cmd)
+    : await execute("getVideoStatus", { pathParams: { id } }, cmd);
+  print(result, { json: globals.json });
+});
+
+withWaitFlags(
+  videos
+    .command("render <id>")
+    .description(getOp("renderVideo").summary)
+    .addOption(new Option("--codec <codec>", "output codec; h264 for MP4").choices(["h264", "vp8"]))
+    .option("--idempotency-key <k>", "Idempotency-Key header value"),
+  "render"
+).action(async (id, opts, cmd) => {
+  const globals = cmd.optsWithGlobals();
+  const started = await execute(
+    "renderVideo",
+    { pathParams: { id }, body: { codec: opts.codec }, idempotencyKey: opts.idempotencyKey },
+    cmd
+  );
+  const renderId = started?.data?.renderId;
+  if (!opts.wait || !renderId) {
+    print(started, { json: globals.json });
+    return;
+  }
+  print(await waitForRender(renderId, opts.timeout, cmd), { json: globals.json });
+});
+
+videos
+  .command("delete <id>")
+  .description(getOp("deleteVideo").summary)
+  .action(async (id, _opts, cmd) => {
+    const result = await execute("deleteVideo", { pathParams: { id } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+const renders = program.command("renders").description("Render progress");
+
+withWaitFlags(renders.command("get <id>").description(getOp("getRender").summary), "render").action(
+  async (id, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const result = opts.wait
+      ? await waitForRender(id, opts.timeout, cmd)
+      : await execute("getRender", { pathParams: { id } }, cmd);
+    print(result, { json: globals.json });
+  }
+);
+
+const series = program.command("series").description("Automated video series");
+
+withSeriesFlags(
+  series
+    .command("create")
+    .description(getOp("createSeries").summary)
+    .requiredOption("--name <name>", "series name shown in the dashboard")
+    .requiredOption(
+      "--source <source>",
+      'content source, e.g. "Facts & stories" (see: faceless options --kind sources)'
+    )
+)
+  .option("--idempotency-key <k>", "Idempotency-Key header value")
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "createSeries",
+      { body: seriesBody(opts), idempotencyKey: opts.idempotencyKey },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+series
+  .command("list")
+  .description(getOp("listSeries").summary)
+  .action(async (_opts, cmd) => {
+    const result = await execute("listSeries", {}, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+series
+  .command("get <id>")
+  .description(getOp("getSeries").summary)
+  .action(async (id, _opts, cmd) => {
+    const result = await execute("getSeries", { pathParams: { id } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+withSeriesFlags(
+  series
+    .command("update <id>")
+    .description(getOp("updateSeries").summary)
+    .option("--name <name>", "series name")
+    .option("--source <source>", "content source (see: faceless options --kind sources)")
+    .option("--paused", "pause automatic episode generation")
+    .option("--no-paused", "resume automatic episode generation")
+).action(async (id, opts, cmd) => {
+  const result = await execute("updateSeries", { pathParams: { id }, body: seriesBody(opts) }, cmd);
+  print(result, { json: cmd.optsWithGlobals().json });
+});
+
+series
+  .command("delete <id>")
+  .description(getOp("deleteSeries").summary)
+  .action(async (id, _opts, cmd) => {
+    const result = await execute("deleteSeries", { pathParams: { id } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+withWaitFlags(
+  series
+    .command("generate <id>")
+    .description(getOp("generateSeriesEpisode").summary)
+    .option("--idempotency-key <k>", "Idempotency-Key header value"),
+  "episode's video"
+).action(async (id, opts, cmd) => {
+  const globals = cmd.optsWithGlobals();
+  noteCost("generateSeriesEpisode");
+  const started = await execute(
+    "generateSeriesEpisode",
+    { pathParams: { id }, idempotencyKey: opts.idempotencyKey },
+    cmd
+  );
+  const projectId = started?.data?.projectId;
+  if (!opts.wait || !projectId) {
+    print(started, { json: globals.json });
+    return;
+  }
+  print(await waitForVideo(projectId, opts.timeout, cmd), { json: globals.json });
+});
+
+series
+  .command("episodes <id>")
+  .description(getOp("listSeriesEpisodes").summary)
+  .option("--page <n>", "page number", toInt)
+  .option("--limit <n>", "items per page (max 100)", toInt)
+  .action(async (id, opts, cmd) => {
+    const result = await execute(
+      "listSeriesEpisodes",
+      { pathParams: { id }, query: { page: opts.page, limit: opts.limit } },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+const posts = program.command("posts").description("Publishing and scheduling");
+
+posts
+  .command("publish")
+  .description(getOp("publishPost").summary)
+  .requiredOption("--video-id <id>", "the video (project) to publish")
+  .addOption(
+    new Option("--platform <platform>", "destination platform; must be connected").choices(
+      PLATFORMS
+    ).makeOptionMandatory()
+  )
+  .option("--title <text>", "post title or caption; falls back to the video's stored post metadata")
+  .option("--description <text>", "longer description (YouTube, Facebook, LinkedIn)")
+  .addOption(
+    new Option("--privacy <p>", "YouTube only; defaults to public").choices([
+      "public",
+      "unlisted",
+      "private",
+    ])
+  )
+  .option("--auth-id <id>", "specific connected account id (see: faceless accounts)")
+  .option("--idempotency-key <k>", "Idempotency-Key header value")
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "publishPost",
+      {
+        body: {
+          videoId: opts.videoId,
+          platform: opts.platform,
+          title: opts.title,
+          description: opts.description,
+          privacyStatus: opts.privacy,
+          authId: opts.authId,
+        },
+        idempotencyKey: opts.idempotencyKey,
+      },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+posts
+  .command("schedule")
+  .description(getOp("schedulePost").summary)
+  .requiredOption("--video-id <id>", "the video (project) to schedule")
+  .requiredOption(
+    "--platforms <platform[,platform...]>",
+    "platforms to post to; each needs its post metadata set on the video first (faceless videos update)"
+  )
+  .requiredOption("--scheduled-time <ISO>", "when to post (ISO 8601, future)")
+  .option("--idempotency-key <k>", "Idempotency-Key header value")
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "schedulePost",
+      {
+        body: {
+          videoId: opts.videoId,
+          platforms: splitList(opts.platforms),
+          scheduledTime: opts.scheduledTime,
+        },
+        idempotencyKey: opts.idempotencyKey,
+      },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+posts
+  .command("cancel <videoId>")
+  .description(getOp("cancelPost").summary)
+  .action(async (videoId, _opts, cmd) => {
+    const result = await execute("cancelPost", { pathParams: { id: videoId } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("calendar")
+  .description(getOp("getCalendar").summary)
+  .requiredOption("--start-date <date>", "range start (ISO 8601, inclusive)")
+  .requiredOption("--end-date <date>", "range end (ISO 8601, inclusive)")
+  .addOption(new Option("--platform <platform>", "filter to one platform").choices(PLATFORMS))
+  .option("--status <status>", "filter by post status, e.g. scheduled, posted, failed")
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "getCalendar",
+      {
+        query: {
+          startDate: opts.startDate,
+          endDate: opts.endDate,
+          platform: opts.platform,
+          status: opts.status,
+        },
+      },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("accounts")
+  .description(getOp("listAccounts").summary)
+  .action(async (_opts, cmd) => {
+    const result = await execute("listAccounts", {}, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("voices")
+  .description(getOp("listVoices").summary)
+  .action(async (_opts, cmd) => {
+    const result = await execute("listVoices", {}, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("options")
+  .description(getOp("listOptions").summary)
+  .addOption(
+    new Option("--kind <kind>", "which catalog to return; omit to list available kinds").choices(
+      OPTION_KINDS
+    )
+  )
+  .action(async (opts, cmd) => {
+    const result = await execute("listOptions", { query: { kind: opts.kind } }, cmd);
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+const assets = program.command("assets").description("Media asset library");
+
+assets
+  .command("create")
+  .description(getOp("createAsset").summary)
+  .requiredOption("--url <url>", "public URL of the media file")
+  .option("--name <name>", "display name for the asset")
+  .option("--file-type <mime>", "MIME type hint, e.g. video/mp4")
+  .option("--idempotency-key <k>", "Idempotency-Key header value")
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "createAsset",
+      {
+        body: { url: opts.url, name: opts.name, fileType: opts.fileType },
+        idempotencyKey: opts.idempotencyKey,
+      },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("analytics")
+  .description(getOp("getAnalytics").summary)
+  .addOption(
+    new Option("--platform <platform>", "filter to one platform").choices([
+      "youtube",
+      "tiktok",
+      "instagram",
+      "facebook",
+    ])
+  )
+  .option("--auth-id <id>", "filter to one connected account (see: faceless accounts)")
+  .option("--range <days>", "trailing window in days (default 30, max 365)", toInt)
+  .action(async (opts, cmd) => {
+    const result = await execute(
+      "getAnalytics",
+      { query: { platform: opts.platform, authId: opts.authId, range: opts.range } },
+      cmd
+    );
+    print(result, { json: cmd.optsWithGlobals().json });
+  });
+
+program
+  .command("mcp")
+  .description("Start the local Faceless MCP server over stdio")
+  .action(async () => {
+    const { runMcpServer } = await import("./mcp/stdio.mjs");
+    await runMcpServer();
+  });
+
+program.parseAsync(process.argv).catch((err) => {
+  printError(err);
+  process.exit(exitCodeFor(err));
+});