Agent Media

{
  "name": "agent-media",
  "owner": {
    "name": "Nevo David",
    "email": "nevo@postiz.com"
  },
  "metadata": {
    "description": "AI UGC video production — generate complete videos with talking heads, B-roll, subtitles, and SaaS review videos from the terminal",
    "version": "2.0.0"
  },
  "plugins": [
    {
      "name": "agent-media",
      "description": "Produce complete UGC videos with AI talking heads, B-roll, voiceover, and animated subtitles. Generate SaaS review videos, manage personas, and add subtitles — all from the terminal via the agent-media CLI.",
      "source": "./",
      "strict": false,
      "skills": [
        "./"
      ]
    }
  ]
}

{
  "name": "agent-media",
  "version": "1.4.3",
  "description": "AI UGC video production — generate complete videos with talking heads, B-roll, subtitles, and SaaS review videos from the terminal",
  "author": {
    "name": "Nevo David",
    "email": "nevo@postiz.com",
    "url": "https://github.com/nevo-david"
  },
  "homepage": "https://agent-media.ai",
  "repository": "https://github.com/gitroomhq/agent-media",
  "license": "Apache-2.0",
  "keywords": [
    "ai",
    "video",
    "ugc",
    "talking-head",
    "ai-video-generator",
    "saas-review",
    "text-to-video",
    "cli",
    "agent-media"
  ]
}

node_modules/
dist/
*.tgz
.env
.env.*
.DS_Store

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to the Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by the Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding any notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format.

   Copyright 2026 agent-media contributors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

{
  "name": "agent-media-cli",
  "version": "1.4.3",
  "type": "module",
  "private": false,
  "license": "Apache-2.0",
  "description": "CLI tool for AI-powered UGC video generation.",
  "homepage": "https://agent-media.ai",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/gitroomhq/agent-media.git"
  },
  "keywords": [
    "ai",
    "video",
    "image",
    "generation",
    "cli",
    "terminal",
    "text-to-video",
    "text-to-image",
    "image-to-video",
    "ugc",
    "ai-video-generator",
    "talking-head",
    "ai-ugc",
    "saas-review",
    "ai-actor"
  ],
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "bin": {
    "agent-media": "./dist/index.js"
  },
  "files": [
    "dist",
    "README.md",
    "SKILL.md",
    "LICENSE"
  ],
  "scripts": {
    "build": "tsc",
    "typecheck": "tsc --noEmit",
    "lint": "eslint src/",
    "prepublishOnly": "npm run build"
  },
  "dependencies": {
    "chalk": "^5.4.1",
    "commander": "^13.1.0",
    "open": "^10.1.0",
    "ora": "^8.2.0"
  },
  "devDependencies": {
    "@types/node": "^22.13.4",
    "typescript": "^5.7.3"
  }
}

// Copyright 2026 agent-media contributors. Apache-2.0 license.

/**
 * `agent-media actor` command group.
 *
 * Browse and preview actors from the actor library.
 *
 * Subcommands:
 *   list    — List actors with optional filters
 *   preview — Show details for a specific actor
 */

import type { Command } from 'commander';
import chalk from 'chalk';
import {
  detectOutputMode,
  printJson,
  printQuiet,
  createSpinner,
} from '../lib/output.js';
import { AgentMediaAPI } from '../lib/api.js';

interface ActorRecord {
  id: string;
  name: string;
  slug: string;
  gender: string;
  age: number;
  age_range: string;
  nationality: string;
  style: string;
  actor_type: string;
  portrait_url: string;
  voice_id: string;
  voice_gender: string;
  lip_sync_engine: string;
}

export function registerActorCommand(program: Command): void {
  const actor = program
    .command('actor')
    .description('Browse the actor library (200 AI actors for UGC videos)');

  // ── actor list ──────────────────────────────────────────────────────────

  actor
    .command('list')
    .description('List actors with optional filters')
    .option('--gender <gender>', 'Filter by gender: female, male')
    .option('--type <type>', 'Filter by type: Young Adult, Professional, Mom, Elder, Casual')
    .option('--age <range>', 'Filter by age range: 18-25, 26-35, 36-50, 51+')
    .option('--search <name>', 'Search by name')
    .action(async (cmdOpts) => {
      const globalOpts = program.opts<{
        json?: boolean;
        quiet?: boolean;
      }>();
      const mode = detectOutputMode(globalOpts);

      try {
        const api = new AgentMediaAPI(); // no auth needed for public endpoint
        const spinner = createSpinner('Fetching actors...');
        if (mode === 'human') spinner.start();

        const params = new URLSearchParams();
        if (cmdOpts.gender) params.set('gender', cmdOpts.gender);
        if (cmdOpts.type) params.set('actor_type', cmdOpts.type);
        if (cmdOpts.age) params.set('age_range', cmdOpts.age);
        if (cmdOpts.search) params.set('search', cmdOpts.search);

        const result = await api.listActors(params);

        if (mode === 'human') spinner.succeed(`Found ${result.total} actor(s)`);

        if (mode === 'json') {
          printJson(result);
          return;
        }

        if (mode === 'quiet') {
          (result.actors as ActorRecord[]).forEach((a) => printQuiet(a.slug));
          return;
        }

        if (result.actors.length === 0) {
          console.log(chalk.yellow('  No actors match your filters.'));
          return;
        }

        // Table output
        console.log('');
        console.log(
          chalk.gray('  Slug'.padEnd(20)) +
          chalk.gray('Name'.padEnd(15)) +
          chalk.gray('Gender'.padEnd(10)) +
          chalk.gray('Age'.padEnd(8)) +
          chalk.gray('Type'.padEnd(18)) +
          chalk.gray('Voice'),
        );
        console.log(chalk.gray('  ' + '─'.repeat(85)));

        for (const a of result.actors as ActorRecord[]) {
          console.log(
            `  ${chalk.cyan(a.slug.padEnd(18))}` +
            `${a.name.padEnd(15)}` +
            `${a.gender.padEnd(10)}` +
            `${String(a.age).padEnd(8)}` +
            `${a.actor_type.padEnd(18)}` +
            `${chalk.dim(a.voice_id)}`,
          );
        }

        console.log('');
        console.log(chalk.dim(`  Use: agent-media ugc "script..." --actor <slug> --sync`));
      } catch (err) {
        if (mode === 'human') {
          console.error(chalk.red(`Error: ${(err as Error).message}`));
        }
        process.exitCode = 1;
      }
    });

  // ── actor preview ───────────────────────────────────────────────────────

  actor
    .command('preview <slug>')
    .description('Show details for a specific actor')
    .action(async (slug: string) => {
      const globalOpts = program.opts<{
        json?: boolean;
        quiet?: boolean;
      }>();
      const mode = detectOutputMode(globalOpts);

      try {
        const api = new AgentMediaAPI();
        const spinner = createSpinner(`Fetching actor ${slug}...`);
        if (mode === 'human') spinner.start();

        const result = await api.getActor(slug);

        if (mode === 'human') spinner.succeed(`Actor: ${result.actor.name}`);

        if (mode === 'json') {
          printJson(result.actor);
          return;
        }

        if (mode === 'quiet') {
          printQuiet(result.actor.slug as string);
          return;
        }

        const a = result.actor as unknown as ActorRecord;
        console.log('');
        console.log(`  ${chalk.bold(a.name)} ${chalk.dim(`(${a.slug})`)}`);
        console.log(`  ${chalk.gray('Gender:')} ${a.gender}`);
        console.log(`  ${chalk.gray('Age:')} ${a.age} (${a.age_range})`);
        console.log(`  ${chalk.gray('Nationality:')} ${a.nationality}`);
        console.log(`  ${chalk.gray('Style:')} ${a.style}`);
        console.log(`  ${chalk.gray('Type:')} ${a.actor_type}`);
        console.log(`  ${chalk.gray('Voice:')} ${a.voice_id}`);
        console.log(`  ${chalk.gray('Lip Sync:')} ${a.lip_sync_engine}`);
        console.log(`  ${chalk.gray('Portrait:')} ${a.portrait_url}`);
        console.log('');
        console.log(chalk.dim(`  Usage: agent-media ugc "your script..." --actor ${a.slug} --sync`));
      } catch (err) {
        if (mode === 'human') {
          console.error(chalk.red(`Error: ${(err as Error).message}`));
        }
        process.exitCode = 1;
      }
    });
}

// Copyright 2026 agent-media contributors. Apache-2.0 license.

/**
 * `agent-media alias` command group.
 *
 * Manages user-defined command aliases stored at ~/.agent-media/aliases.json.
 * Aliases expand to full CLI invocations, allowing frequently used commands
 * to be accessed with shorter names.
 *
 * Subcommands:
 *   - `agent-media alias set <name> <expansion>`  -- create or update an alias
 *   - `agent-media alias list`                    -- show all aliases
 *   - `agent-media alias delete <name>`           -- remove an alias
 *
 * Supports human, JSON, and quiet output modes via global flags.
 */

import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import type { Command } from 'commander';
import chalk from 'chalk';
import { CONFIG_DIR } from '../lib/config.js';
import { detectOutputMode, printJson, printQuiet } from '../lib/output.js';
import { CLIError, handleError } from '../lib/errors.js';

// ── Constants ────────────────────────────────────────────────────────────────

const ALIASES_FILE = join(CONFIG_DIR, 'aliases.json');
const MAX_ALIAS_NAME_LENGTH = 50;
const MAX_EXPANSION_LENGTH = 500;

/**
 * Reserved names that cannot be used as aliases because they conflict with
 * built-in commands.
 */
const RESERVED_NAMES = new Set([
  'alias',
  'apikey',
  'cancel',
  'config',
  'credits',
  'debug',
  'delete',
  'doctor',
  'download',
  'generate',
  'help',
  'inspect',
  'list',
  'login',
  'logout',
  'models',
  'plan',
  'pricing',
  'profile',
  'retry',
  'status',
  'subscribe',
  'text',
  'usage',
  'version',
  'whoami',
]);

// ── Alias Store ──────────────────────────────────────────────────────────────

type AliasMap = Record<string, string>;

/**
 * Ensure the config directory exists.
 */
function ensureConfigDir(): void {
  if (!existsSync(CONFIG_DIR)) {
    mkdirSync(CONFIG_DIR, { recursive: true });
  }
}

/**
 * Load aliases from disk. Returns an empty object if the file does not
 * exist or is malformed.
 */
function loadAliases(): AliasMap {
  if (!existsSync(ALIASES_FILE)) {
    return {};
  }
  try {
    const raw = readFileSync(ALIASES_FILE, 'utf-8');
    const data = JSON.parse(raw) as unknown;
    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
      return {};
    }
    return data as AliasMap;
  } catch {
    return {};
  }
}

/**
 * Persist the aliases map to disk.
 */
function saveAliases(aliases: AliasMap): void {
  ensureConfigDir();
  writeFileSync(ALIASES_FILE, JSON.stringify(aliases, null, 2) + '\n', 'utf-8');
}

/**
 * Validate an alias name.
 */
function validateAliasName(name: string): void {
  if (name.length === 0) {
    throw new CLIError('Alias name must not be empty.', {
      code: 'INVALID_ALIAS_NAME',
    });
  }

  if (name.length > MAX_ALIAS_NAME_LENGTH) {
    throw new CLIError(
      `Alias name must be ${MAX_ALIAS_NAME_LENGTH} characters or fewer.`,
      { code: 'INVALID_ALIAS_NAME' },
    );
  }

  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
    throw new CLIError(
      'Alias name may only contain letters, digits, hyphens, and underscores.',
      { code: 'INVALID_ALIAS_NAME' },
    );
  }

  if (RESERVED_NAMES.has(name.toLowerCase())) {
    throw new CLIError(`"${name}" is a built-in command and cannot be used as an alias.`, {
      code: 'RESERVED_ALIAS_NAME',
      suggestion: 'Choose a different name that does not conflict with a built-in command.',
    });
  }
}

// ── Command Registration ─────────────────────────────────────────────────────

export function registerAliasCommand(program: Command): void {
  const aliasCmd = program
    .command('alias')
    .description('Manage command aliases');

  // ── agent-media alias set <name> <expansion> ──────────────────────────
  aliasCmd
    .command('set <name> <expansion>')
    .description('Create or update a command alias')
    .action((name: string, expansion: string) => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        validateAliasName(name);

        if (expansion.length === 0) {
          throw new CLIError('Expansion must not be empty.', {
            code: 'INVALID_ALIAS_EXPANSION',
          });
        }

        if (expansion.length > MAX_EXPANSION_LENGTH) {
          throw new CLIError(
            `Expansion must be ${MAX_EXPANSION_LENGTH} characters or fewer.`,
            { code: 'INVALID_ALIAS_EXPANSION' },
          );
        }

        const aliases = loadAliases();
        const isUpdate = name in aliases;
        aliases[name] = expansion;
        saveAliases(aliases);

        switch (mode) {
          case 'json':
            printJson({ name, expansion, updated: isUpdate, success: true });
            break;
          case 'quiet':
            printQuiet(name);
            break;
          default: {
            const verb = isUpdate ? 'Updated' : 'Created';
            console.log(
              chalk.green(`\u2713 ${verb} alias ${chalk.bold(name)} = ${chalk.cyan(expansion)}`),
            );
            break;
          }
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // ── agent-media alias list ────────────────────────────────────────────
  aliasCmd
    .command('list')
    .description('List all command aliases')
    .action(() => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        const aliases = loadAliases();
        const entries = Object.entries(aliases);

        if (entries.length === 0) {
          switch (mode) {
            case 'json':
              printJson({});
              break;
            case 'quiet':
              // No output for quiet mode on empty result
              break;
            default:
              console.log();
              console.log(
                chalk.dim("  No aliases defined. Create one with 'agent-media alias set <name> <expansion>'."),
              );
              console.log();
              break;
          }
          return;
        }

        switch (mode) {
          case 'json':
            printJson(aliases);
            break;
          case 'quiet':
            printQuiet(entries.map(([name]) => name));
            break;
          default: {
            console.log();
            console.log(chalk.bold(`  Aliases (${entries.length})`));
            console.log(chalk.dim(`  ${ALIASES_FILE}`));
            console.log();

            // Calculate column width for alignment
            const maxNameLen = Math.max(...entries.map(([n]) => n.length));

            for (const [name, expansion] of entries) {
              console.log(`  ${chalk.bold(name.padEnd(maxNameLen))}  ${chalk.cyan(expansion)}`);
            }
            console.log();
            break;
          }
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // ── agent-media alias delete <name> ───────────────────────────────────
  aliasCmd
    .command('delete <name>')
    .description('Remove a command alias')
    .action((name: string) => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        const aliases = loadAliases();

        if (!(name in aliases)) {
          throw new CLIError(`Alias "${name}" not found.`, {
            code: 'ALIAS_NOT_FOUND',
            suggestion: "Run 'agent-media alias list' to see all aliases.",
          });
        }

        delete aliases[name];
        saveAliases(aliases);

        switch (mode) {
          case 'json':
            printJson({ name, deleted: true, success: true });
            break;
          case 'quiet':
            printQuiet('deleted');
            break;
          default:
            console.log(chalk.green(`\u2713 Deleted alias ${chalk.bold(name)}`));
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });
}

// Copyright 2026 agent-media contributors. Apache-2.0 license.

/**
 * `agent-media apikey` command group.
 *
 * Manages user API keys: list, create, and revoke. API keys are used
 * for authenticating CLI and programmatic access to the agent-media
 * platform.
 *
 * Subcommands:
 * - `agent-media apikey list`            -- list all active API keys
 * - `agent-media apikey create <name>`   -- create a new API key
 * - `agent-media apikey revoke <key-id>` -- revoke an existing key
 *
 * Supports human, JSON, and quiet output modes via global flags.
 */

import { createInterface } from 'node:readline';
import type { Command } from 'commander';
import chalk from 'chalk';
import {
  detectOutputMode,
  printJson,
  printQuiet,
  createSpinner,
} from '../lib/output.js';
import { getApiKey, resolveProfileName } from '../lib/credentials.js';
import {
  AgentMediaAPI,
  type ApiKeyRecord,
} from '../lib/api.js';
import { CLIError, handleError } from '../lib/errors.js';

/**
 * Require authentication and return the API key or throw.
 */
function requireAuth(profileName: string): string {
  const apiKey = getApiKey(profileName);
  if (!apiKey) {
    throw new CLIError('Not logged in.', {
      code: 'NOT_AUTHENTICATED',
      suggestion: "Run 'agent-media login' to authenticate.",
    });
  }
  return apiKey;
}

/**
 * Format a date string into a short human-readable label.
 * Returns "Never" for null/undefined values.
 */
function formatDate(dateStr: string | null): string {
  if (!dateStr) return 'Never';

  const date = new Date(dateStr);
  const now = new Date();
  const months = [
    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec',
  ];

  const month = months[date.getMonth()]!;
  const day = date.getDate();

  // If same year, show "Mon DD"; otherwise "Mon DD, YYYY"
  if (date.getFullYear() === now.getFullYear()) {
    return `${month} ${day}`;
  }

  return `${month} ${day}, ${date.getFullYear()}`;
}

/**
 * Pad or truncate a string to an exact column width.
 * Strips ANSI codes for length calculation.
 */
function fixedWidth(str: string, width: number): string {
  // eslint-disable-next-line no-control-regex
  const stripped = str.replace(/\x1B\[[0-9;]*m/g, '');
  if (stripped.length >= width) return str;
  return str + ' '.repeat(width - stripped.length);
}

/**
 * Truncate a string to a maximum length, appending ellipsis if needed.
 */
function truncate(str: string, maxLen: number): string {
  if (str.length <= maxLen) return str;
  return str.slice(0, maxLen - 1) + '\u2026';
}

/**
 * Print a formatted table of API keys.
 */
function printKeyTable(keys: ApiKeyRecord[]): void {
  const COL_PREFIX = 10;
  const COL_NAME = 14;
  const COL_CREATED = 12;
  const COL_LAST_USED = 12;

  const header =
    fixedWidth('PREFIX', COL_PREFIX) +
    fixedWidth('NAME', COL_NAME) +
    fixedWidth('CREATED', COL_CREATED) +
    'LAST USED';

  const separator =
    '\u2500'.repeat(COL_PREFIX) +
    '\u2500'.repeat(COL_NAME) +
    '\u2500'.repeat(COL_CREATED) +
    '\u2500'.repeat(COL_LAST_USED);

  console.log();
  console.log(chalk.bold(`  API Keys (${keys.length})`));
  console.log();
  console.log(`  ${chalk.bold(header)}`);
  console.log(`  ${chalk.dim(separator)}`);

  for (const key of keys) {
    const prefix = fixedWidth(key.key_prefix, COL_PREFIX);
    const name = fixedWidth(truncate(key.name, COL_NAME - 2), COL_NAME);
    const created = fixedWidth(formatDate(key.created_at), COL_CREATED);
    const lastUsed = formatDate(key.last_used_at);

    console.log(`  ${prefix}${name}${created}${lastUsed}`);
  }

  console.log();
}

/**
 * Ask a yes/no question on stdin and return the result.
 * Defaults to "no" (destructive action requires explicit confirmation).
 */
function askConfirmation(question: string): Promise<boolean> {
  return new Promise((resolve) => {
    const rl = createInterface({
      input: process.stdin,
      output: process.stdout,
    });

    rl.question(question, (answer) => {
      rl.close();
      const trimmed = answer.trim().toLowerCase();
      resolve(trimmed === 'y' || trimmed === 'yes');
    });
  });
}

export function registerApikeyCommand(program: Command): void {
  const apikeyCmd = program
    .command('apikey')
    .description('Manage API keys');

  // ── agent-media apikey list ──────────────────────────────────────────────
  apikeyCmd
    .command('list')
    .description('List all active API keys')
    .action(async () => {
      const globalOpts = program.opts<{
        json?: boolean;
        quiet?: boolean;
        profile?: string;
      }>();
      const mode = detectOutputMode(globalOpts);
      const profileName = resolveProfileName(globalOpts.profile);
      const apiKey = requireAuth(profileName);

      try {
        const spinner = createSpinner('Fetching API keys...');
        if (mode === 'human') spinner.start();

        const api = new AgentMediaAPI(apiKey);
        const keys = await api.listApiKeys();

        if (mode === 'human') spinner.stop();

        // ── Empty state ──────────────────────────────────────────────
        if (keys.length === 0) {
          switch (mode) {
            case 'json':
              printJson([]);
              break;

            case 'quiet':
              // No output for quiet mode on empty result
              break;

            default:
              console.log();
              console.log(
                chalk.dim(
                  "  No API keys found. Create one with 'agent-media apikey create <name>'.",
                ),
              );
              console.log();
              break;
          }
          return;
        }

        // ── Output ───────────────────────────────────────────────────
        switch (mode) {
          case 'json':
            printJson(keys);
            break;

          case 'quiet':
            printQuiet(keys.map((k) => k.key_prefix));
            break;

          default:
            printKeyTable(keys);
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // ── agent-media apikey create <name> ─────────────────────────────────────
  apikeyCmd
    .command('create <name>')
    .description('Create a new API key')
    .action(async (name: string) => {
      const globalOpts = program.opts<{
        json?: boolean;
        quiet?: boolean;
        profile?: string;
      }>();
      const mode = detectOutputMode(globalOpts);
      const profileName = resolveProfileName(globalOpts.profile);
      const apiKey = requireAuth(profileName);

      try {
        const spinner = createSpinner('Creating API key...');
        if (mode === 'human') spinner.start();

        const api = new AgentMediaAPI(apiKey);
        const result = await api.createApiKey(name);

        if (mode === 'human') spinner.stop();

        switch (mode) {
          case 'json':
            printJson({
              id: result.id,
              name: result.name,
              api_key: result.key,
              key_prefix: result.key_prefix,
            });
            break;

          case 'quiet':
            printQuiet(result.key);
            break;

          default:
            console.log();
            console.log(
              `  ${chalk.green('\u2713')} API key created: ${chalk.bold(`"${result.name}"`)}`,
            );
            console.log();
            console.log(`  ${chalk.cyan(result.key)}`);
            console.log();
            console.log(
              `  ${chalk.yellow('\u26A0')} Copy this key now. You won't see it again.`,
            );
            console.log();
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // ── agent-media apikey revoke <key-id> ──────────────────────────────────
  apikeyCmd
    .command('revoke <key-id>')
    .description('Revoke an API key')
    .option('-f, --force', 'Skip confirmation prompt')
    .action(async (keyId: string, cmdOpts: { force?: boolean }) => {
      const globalOpts = program.opts<{
        json?: boolean;
        quiet?: boolean;
        profile?: string;
      }>();
      const mode = detectOutputMode(globalOpts);
      const profileName = resolveProfileName(globalOpts.profile);
      const apiKey = requireAuth(profileName);

      try {
        const api = new AgentMediaAPI(apiKey);

        // Fetch the key list to show details before confirming
        if (mode === 'human' && !cmdOpts.force) {
          const spinner = createSpinner('Looking up API key...');
          spinner.start();

          const keys = await api.listApiKeys();
          const targetKey = keys.find((k) => k.id === keyId);

          spinner.stop();

          if (targetKey) {
            console.log();
            console.log(`  ${chalk.bold('Key:')}      ${targetKey.key_prefix}`);
            console.log(`  ${chalk.bold('Name:')}     ${targetKey.name}`);
            console.log(`  ${chalk.bold('Created:')}  ${formatDate(targetKey.created_at)}`);
            console.log();
          }

          const confirmed = await askConfirmation(
            `  Revoke API key ${chalk.cyan(keyId.slice(0, 8))}? This cannot be undone. [y/N] `,
          );

          if (!confirmed) {
            console.log(chalk.dim('  Revocation cancelled.'));
            return;
          }
        }

        const revokeSpinner = createSpinner('Revoking API key...');
        if (mode === 'human') revokeSpinner.start();

        const result = await api.revokeManagedApiKey(keyId);

        if (mode === 'human') revokeSpinner.succeed('API key revoked');

        switch (mode) {
          case 'json':
            printJson({
              id: result.id,
              revoked: result.revoked,
            });
            break;

          case 'quiet':
            printQuiet('revoked');
            break;

          default:
            console.log();
            console.log(`  ${chalk.green('API key revoked successfully.')}`);
            console.log(
              chalk.dim('  Any applications using this key will lose access immediately.'),
            );
            console.log();
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });
}

// Copyright 2026 agent-media contributors. Apache-2.0 license.

/**
 * `agent-media cancel <job-id>` command.
 *
 * Cancels an active generation job (submitted/queued/processing)
 * and refunds the credits. Use --all to cancel all active jobs.
 */

import type { Command } from 'commander';
import chalk from 'chalk';
import {
  detectOutputMode,
  printJson,
  printQuiet,
  createSpinner,
} from '../lib/output.js';
import { getApiKey, resolveProfileName } from '../lib/credentials.js';
import { AgentMediaAPI } from '../lib/api.js';
import { CLIError, handleError } from '../lib/errors.js';

interface CancelOptions {
  all?: boolean;
}

export function registerCancelCommand(program: Command): void {
  program
    .command('cancel [job-id]')
    .description('Cancel an active generation job and refund credits')
    .option('--all', 'Cancel all active (submitted/queued/processing) jobs')
    .action(async (jobId: string | undefined, cmdOpts: CancelOptions) => {
      const globalOpts = program.opts<{
        json?: boolean;
        quiet?: boolean;
        profile?: string;
      }>();
      const mode = detectOutputMode(globalOpts);
      const profileName = resolveProfileName(globalOpts.profile);
      const apiKey = getApiKey(profileName);

      if (!apiKey) {
        throw new CLIError('Not logged in.', {
          code: 'NOT_AUTHENTICATED',
          suggestion: "Run 'agent-media login' to authenticate.",
        });
      }

      if (!jobId && !cmdOpts.all) {
        throw new CLIError('Provide a job ID or use --all.', {
          code: 'MISSING_ARGUMENT',
          suggestion: "Usage: agent-media cancel <job-id> or agent-media cancel --all",
        });
      }

      try {
        const api = new AgentMediaAPI(apiKey);

        // ── Cancel all active jobs ──────────────────────────────────────
        if (cmdOpts.all) {
          const spinner = createSpinner('Finding active jobs...');
          if (mode === 'human') spinner.start();

          const { jobs } = await api.listJobs({ limit: 100 });
          const activeJobs = jobs.filter((j) =>
            ['submitted', 'queued', 'processing'].includes(j.status),
          );

          if (activeJobs.length === 0) {
            if (mode === 'human') {
              spinner.stop();
              console.log(chalk.dim('\n  No active jobs to cancel.\n'));
            } else if (mode === 'json') {
              printJson({ canceled: [], count: 0, credits_refunded: 0 });
            } else {
              printQuiet('0');
            }
            return;
          }

          if (mode === 'human') {
            spinner.text = `Canceling ${activeJobs.length} active job${activeJobs.length === 1 ? '' : 's'}...`;
          }

          let totalRefunded = 0;
          const canceled: string[] = [];

          for (const job of activeJobs) {
            try {
              const result = await api.cancelJob(job.id);
              if (result.canceled) {
                canceled.push(job.id);
                totalRefunded += result.credits_refunded;
              }
            } catch {
              // Skip jobs that can't be canceled
            }
          }

          if (mode === 'human') {
            spinner.succeed(
              `Canceled ${canceled.length} job${canceled.length === 1 ? '' : 's'}, refunded ${chalk.green(String(totalRefunded))} credits`,
            );
            console.log();
          } else if (mode === 'json') {
            printJson({ canceled, count: canceled.length, credits_refunded: totalRefunded });
          } else {
            printQuiet(String(canceled.length));
          }

          return;
        }

        // ── Cancel single job ───────────────────────────────────────────
        const spinner = createSpinner('Canceling job...');
        if (mode === 'human') spinner.start();

        const result = await api.cancelJob(jobId!);

        if (mode === 'human') {
          spinner.succeed(
            `Job ${chalk.cyan(jobId!.slice(0, 8))} canceled, ${chalk.green(String(result.credits_refunded))} credits refunded`,
          );
          console.log();
        } else if (mode === 'json') {
          printJson(result);
        } else {
          printQuiet('canceled');
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });
}

// Copyright 2026 agent-media contributors. Apache-2.0 license.

/**
 * `agent-media completions <shell>` command.
 *
 * Generates shell completion scripts for bash, zsh, and fish.
 * Users pipe the output into their shell's configuration to enable
 * tab-completion of commands, options, and arguments.
 *
 * Usage:
 *   agent-media completions bash >> ~/.bashrc
 *   agent-media completions zsh  >> ~/.zshrc
 *   agent-media completions fish > ~/.config/fish/completions/agent-media.fish
 */

import type { Command } from 'commander';
import { CLIError, handleError } from '../lib/errors.js';

/** All registered command names (used in completion scripts). */
const COMMANDS = [
  'actor',
  'alias',
  'apikey',
  'cancel',
  'completions',
  'config',
  'credits',
  'debug',
  'delete',
  'doctor',
  'download',
  'inspect',
  'list',
  'login',
  'logout',
  'persona',
  'plan',
  'profile',
  'status',
  'subscribe',
  'subtitle',
  'ugc',
  'update',
  'usage',
  'version',
  'whoami',
];

/** Global option flags available on all commands. */
const GLOBAL_FLAGS = [
  '--json',
  '--quiet',
  '--no-color',
  '--verbose',
  '--profile',
  '--help',
  '--version',
];

/**
 * Generate a Bash completion script.
 */
function generateBash(): string {
  const cmds = COMMANDS.join(' ');
  const flags = GLOBAL_FLAGS.join(' ');

  return `# agent-media bash completion
# Generated by: agent-media completions bash
# Add to ~/.bashrc or ~/.bash_profile:
#   eval "$(agent-media completions bash)"

_agent_media_completions() {
    local cur prev commands global_flags
    COMPREPLY=()
    cur="\${COMP_WORDS[COMP_CWORD]}"
    prev="\${COMP_WORDS[COMP_CWORD-1]}"

    commands="${cmds}"
    global_flags="${flags}"

    # Complete subcommands when at position 1
    if [[ \${COMP_CWORD} -eq 1 ]]; then
        COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
        return 0
    fi

    # Complete global flags
    if [[ "\${cur}" == -* ]]; then
        COMPREPLY=( $(compgen -W "\${global_flags}" -- "\${cur}") )
        return 0
    fi

    # Command-specific completions
    case "\${COMP_WORDS[1]}" in
        completions)
            COMPREPLY=( $(compgen -W "bash zsh fish" -- "\${cur}") )
            ;;
        config)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "get set list reset export import" -- "\${cur}") )
            elif [[ \${COMP_CWORD} -eq 3 && ("\${prev}" == "get" || "\${prev}" == "set") ]]; then
                COMPREPLY=( $(compgen -W "api_url output_format default_model auto_open_browser download_dir" -- "\${cur}") )
            fi
            ;;
        credits)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "estimate history topup" -- "\${cur}") )
            fi
            ;;
        ugc)
            # UGC has many options but no positional subcommands to complete
            ;;
        actor)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "list preview" -- "\${cur}") )
            fi
            ;;
        persona)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "list create delete" -- "\${cur}") )
            fi
            ;;
        apikey)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "list create revoke" -- "\${cur}") )
            fi
            ;;
        profile)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "list use delete export" -- "\${cur}") )
            fi
            ;;
        alias)
            if [[ \${COMP_CWORD} -eq 2 ]]; then
                COMPREPLY=( $(compgen -W "set remove list" -- "\${cur}") )
            fi
            ;;
    esac

    return 0
}

complete -F _agent_media_completions agent-media
`;
}

/**
 * Generate a Zsh completion script.
 */
function generateZsh(): string {
  const cmdLines = COMMANDS.map((cmd) => `    '${cmd}:${cmd} command'`).join(' \\\n');

  return `#compdef agent-media

# agent-media zsh completion
# Generated by: agent-media completions zsh
# Add to ~/.zshrc:
#   eval "$(agent-media completions zsh)"
# Or save to a file in your $fpath:
#   agent-media completions zsh > ~/.zsh/completions/_agent-media

_agent-media() {
    local -a commands
    commands=(
${cmdLines}
    )

    local -a global_flags
    global_flags=(
        '--json[Output as JSON]'
        '--quiet[Minimal output]'
        '--no-color[Disable colored output]'
        '--verbose[Show debug output]'
        '--profile[Use a specific credential profile]:profile name'
        '--help[Show help]'
        '--version[Show version]'
    )

    _arguments -C \\
        '1:command:->command' \\
        '*::arg:->args' \\
        \${global_flags}

    case "\$state" in
        command)
            _describe -t commands 'agent-media command' commands
            ;;
        args)
            case "\$words[1]" in
                completions)
                    _values 'shell' bash zsh fish
                    ;;
                config)
                    local -a config_subcmds
                    config_subcmds=(get set list reset export import)
                    if (( CURRENT == 2 )); then
                        _describe -t subcommands 'config subcommand' config_subcmds
                    elif (( CURRENT == 3 )) && [[ "\$words[2]" == (get|set) ]]; then
                        local -a config_keys
                        config_keys=(api_url output_format default_model auto_open_browser download_dir)
                        _describe -t keys 'config key' config_keys
                    fi
                    ;;
                credits)
                    local -a credits_subcmds
                    credits_subcmds=(estimate history topup)
                    _describe -t subcommands 'credits subcommand' credits_subcmds
                    ;;
                ugc)
                    # UGC has many options but no positional subcommands
                    ;;
                actor)
                    local -a actor_subcmds
                    actor_subcmds=(list preview)
                    _describe -t subcommands 'actor subcommand' actor_subcmds
                    ;;
                persona)
                    local -a persona_subcmds
                    persona_subcmds=(list create delete)
                    _describe -t subcommands 'persona subcommand' persona_subcmds
                    ;;
                apikey)
                    local -a apikey_subcmds
                    apikey_subcmds=(list create revoke)
                    _describe -t subcommands 'apikey subcommand' apikey_subcmds
                    ;;
                profile)
                    local -a profile_subcmds
                    profile_subcmds=(list use delete export)
                    _describe -t subcommands 'profile subcommand' profile_subcmds
                    ;;
                alias)
                    local -a alias_subcmds
                    alias_subcmds=(set remove list)
                    _describe -t subcommands 'alias subcommand' alias_subcmds
                    ;;
                download|status|inspect|cancel|delete)
                    _message 'job ID'
                    ;;
            esac
            ;;
    esac
}

_agent-media "\$@"
`;
}

/**
 * Generate a Fish completion script.
 */
function generateFish(): string {
  const cmdCompletions = COMMANDS.map(
    (cmd) => `complete -c agent-media -n "__fish_use_subcommand" -a "${cmd}" -d "${cmd} command"`,
  ).join('\n');

  return `# agent-media fish completion
# Generated by: agent-media completions fish
# Save to: ~/.config/fish/completions/agent-media.fish

# Disable file completions by default
complete -c agent-media -f

# Global flags
complete -c agent-media -l json -d "Output as JSON"
complete -c agent-media -l quiet -d "Minimal output"
complete -c agent-media -l no-color -d "Disable colored output"
complete -c agent-media -l verbose -d "Show debug output"
complete -c agent-media -l profile -d "Use a specific credential profile" -x
complete -c agent-media -l help -d "Show help"
complete -c agent-media -l version -d "Show version"

# Subcommands
${cmdCompletions}

# completions subcommand
complete -c agent-media -n "__fish_seen_subcommand_from completions" -a "bash zsh fish" -d "Shell type"

# config subcommand
complete -c agent-media -n "__fish_seen_subcommand_from config" -a "get set list reset export import" -d "Config action"

# credits subcommand
complete -c agent-media -n "__fish_seen_subcommand_from credits" -a "estimate history topup" -d "Credits action"

# ugc subcommand (no positional completions, uses flags)

# actor subcommand
complete -c agent-media -n "__fish_seen_subcommand_from actor" -a "list preview" -d "Actor action"

# persona subcommand
complete -c agent-media -n "__fish_seen_subcommand_from persona" -a "list create delete" -d "Persona action"

# apikey subcommand
complete -c agent-media -n "__fish_seen_subcommand_from apikey" -a "list create revoke" -d "API key action"

# profile subcommand
complete -c agent-media -n "__fish_seen_subcommand_from profile" -a "list use delete export" -d "Profile action"

# alias subcommand
complete -c agent-media -n "__fish_seen_subcommand_from alias" -a "set remove list" -d "Alias action"
`;
}

export function registerCompletionsCommand(program: Command): void {
  program
    .command('completions <shell>')
    .description(
      'Generate shell completion scripts\n\n' +
      'Usage:\n' +
      '  agent-media completions bash >> ~/.bashrc\n' +
      '  agent-media completions zsh  >> ~/.zshrc\n' +
      '  agent-media completions fish > ~/.config/fish/completions/agent-media.fish',
    )
    .action((shell: string) => {
      try {
        const shellLower = shell.toLowerCase();

        switch (shellLower) {
          case 'bash':
            process.stdout.write(generateBash());
            break;

          case 'zsh':
            process.stdout.write(generateZsh());
            break;

          case 'fish':
            process.stdout.write(generateFish());
            break;

          default:
            throw new CLIError(`Unsupported shell: "${shell}"`, {
              code: 'UNSUPPORTED_SHELL',
              suggestion: 'Supported shells: bash, zsh, fish',
            });
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });
}

// Copyright 2026 agent-media contributors. Apache-2.0 license.

/**
 * `agent-media config` command.
 *
 * Manages CLI configuration stored at ~/.agent-media/config.json.
 * Supports get, set, list, and reset subcommands for controlling
 * default behavior of the CLI.
 *
 * Supported keys:
 * - api_url: Supabase Edge Functions URL
 * - output_format: default output format (human/json/quiet)
 * - default_model: default model for generate command
 * - auto_open_browser: whether to auto-open browser on login (default: true)
 * - download_dir: default download directory
 */

import { readFileSync } from 'node:fs';
import type { Command } from 'commander';
import chalk from 'chalk';
import {
  loadConfig,
  saveConfig,
  getConfigValue,
  setConfigValue,
  resetConfig,
  CONFIG_FILE,
  VALID_CONFIG_KEYS,
  CONFIG_DEFAULTS,
  isValidConfigKey,
  type ConfigData,
} from '../lib/config.js';
import { detectOutputMode, printJson, printQuiet } from '../lib/output.js';
import { handleError } from '../lib/errors.js';
import { CLIError } from '../lib/errors.js';

export function registerConfigCommand(program: Command): void {
  const configCmd = program
    .command('config')
    .description('Manage CLI configuration');

  // agent-media config set <key> <value>
  configCmd
    .command('set <key> <value>')
    .description('Set a configuration value')
    .action((key: string, value: string) => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        if (!isValidConfigKey(key)) {
          throw new CLIError(`Unknown config key: "${key}"`, {
            code: 'INVALID_CONFIG_KEY',
            suggestion: `Valid keys: ${VALID_CONFIG_KEYS.join(', ')}`,
          });
        }

        // Validate specific keys
        if (key === 'output_format' && !['human', 'json', 'quiet'].includes(value)) {
          throw new CLIError(`Invalid output_format: "${value}"`, {
            code: 'INVALID_CONFIG_VALUE',
            suggestion: 'Valid values: human, json, quiet',
          });
        }

        if (key === 'auto_open_browser' && !['true', 'false'].includes(value)) {
          throw new CLIError(`Invalid auto_open_browser: "${value}"`, {
            code: 'INVALID_CONFIG_VALUE',
            suggestion: 'Valid values: true, false',
          });
        }

        // Coerce boolean values
        const coerced = key === 'auto_open_browser' ? value === 'true' : value;

        setConfigValue(key, coerced);

        switch (mode) {
          case 'json':
            printJson({ key, value: coerced, success: true });
            break;
          case 'quiet':
            printQuiet(String(coerced));
            break;
          default:
            console.log(chalk.green(`\u2713 Set ${chalk.bold(key)} = ${coerced}`));
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // agent-media config get <key>
  configCmd
    .command('get <key>')
    .description('Get a configuration value')
    .action((key: string) => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        if (!isValidConfigKey(key)) {
          throw new CLIError(`Unknown config key: "${key}"`, {
            code: 'INVALID_CONFIG_KEY',
            suggestion: `Valid keys: ${VALID_CONFIG_KEYS.join(', ')}`,
          });
        }

        const value = getConfigValue(key);
        const defaultValue = CONFIG_DEFAULTS[key];
        const effectiveValue = value ?? defaultValue;

        switch (mode) {
          case 'json':
            printJson({
              key,
              value: effectiveValue ?? null,
              is_default: value === undefined,
            });
            break;
          case 'quiet':
            printQuiet(effectiveValue !== undefined ? String(effectiveValue) : '');
            break;
          default:
            if (value !== undefined) {
              console.log(`${chalk.bold(key)} = ${value}`);
            } else if (defaultValue !== undefined) {
              console.log(`${chalk.bold(key)} = ${defaultValue} ${chalk.dim('(default)')}`);
            } else {
              console.log(`${chalk.bold(key)} = ${chalk.dim('(not set)')}`);
            }
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // agent-media config list
  configCmd
    .command('list')
    .description('List all configuration values')
    .action(() => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        const config = loadConfig();

        switch (mode) {
          case 'json': {
            // Merge defaults with current config for a complete picture
            const merged: Record<string, unknown> = {};
            for (const key of VALID_CONFIG_KEYS) {
              merged[key] = config[key] ?? CONFIG_DEFAULTS[key] ?? null;
            }
            printJson(merged);
            break;
          }

          case 'quiet': {
            const lines: string[] = [];
            for (const key of VALID_CONFIG_KEYS) {
              const val = config[key] ?? CONFIG_DEFAULTS[key];
              lines.push(`${key}=${val !== undefined ? val : ''}`);
            }
            printQuiet(lines);
            break;
          }

          default: {
            console.log();
            console.log(chalk.bold('  Configuration'));
            console.log(chalk.dim(`  ${CONFIG_FILE}`));
            console.log();

            for (const key of VALID_CONFIG_KEYS) {
              const value = config[key];
              const defaultValue = CONFIG_DEFAULTS[key];

              if (value !== undefined) {
                console.log(`  ${chalk.bold(key)} = ${value}`);
              } else if (defaultValue !== undefined) {
                console.log(
                  `  ${chalk.bold(key)} = ${chalk.dim(String(defaultValue))} ${chalk.dim('(default)')}`,
                );
              } else {
                console.log(`  ${chalk.bold(key)} = ${chalk.dim('(not set)')}`);
              }
            }
            console.log();
            break;
          }
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // agent-media config reset
  configCmd
    .command('reset')
    .description('Reset all configuration to defaults')
    .action(() => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        resetConfig();

        switch (mode) {
          case 'json':
            printJson({ success: true, message: 'Configuration reset to defaults.' });
            break;
          case 'quiet':
            printQuiet('reset');
            break;
          default:
            console.log(chalk.green('\u2713 Configuration reset to defaults.'));
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // agent-media config export
  configCmd
    .command('export')
    .description('Output full configuration as JSON to stdout')
    .action(() => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        const config = loadConfig();

        // Build a complete view: merge defaults with stored values
        const merged: Record<string, unknown> = {};
        for (const key of VALID_CONFIG_KEYS) {
          merged[key] = config[key] ?? CONFIG_DEFAULTS[key] ?? null;
        }

        switch (mode) {
          case 'json':
          case 'quiet':
            // Both modes output raw JSON for piping
            printJson(merged);
            break;
          default:
            // Human mode: also output raw JSON (this is the export)
            printJson(merged);
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });

  // agent-media config import <file>
  configCmd
    .command('import <file>')
    .description('Import configuration from a JSON file, merging into current config')
    .action((file: string) => {
      const globalOpts = program.opts<{ json?: boolean; quiet?: boolean }>();
      const mode = detectOutputMode(globalOpts);

      try {
        // 1. Read and parse the file
        let raw: string;
        try {
          raw = readFileSync(file, 'utf-8');
        } catch (err: unknown) {
          const msg = err instanceof Error ? err.message : 'Unknown read error';
          throw new CLIError(`Failed to read file: ${msg}`, {
            code: 'FILE_READ_ERROR',
            suggestion: 'Verify the file path exists and is readable.',
          });
        }

        let imported: unknown;
        try {
          imported = JSON.parse(raw);
        } catch {
          throw new CLIError('File is not valid JSON.', {
            code: 'INVALID_JSON',
            suggestion: 'Ensure the file contains a valid JSON object.',
          });
        }

        // 2. Validate schema: must be a plain object
        if (imported === null || typeof imported !== 'object' || Array.isArray(imported)) {
          throw new CLIError('Imported config must be a JSON object.', {
            code: 'INVALID_CONFIG_SCHEMA',
            suggestion: 'The file should contain a JSON object like { "key": "value" }.',
          });
        }

        const importedObj = imported as Record<string, unknown>;

        // 3. Validate all keys are recognized config keys
        const unknownKeys: string[] = [];
        for (const key of Object.keys(importedObj)) {
          if (!isValidConfigKey(key)) {
            unknownKeys.push(key);
          }
        }

        if (unknownKeys.length > 0) {
          throw new CLIError(
            `Unknown config key${unknownKeys.length > 1 ? 's' : ''}: ${unknownKeys.join(', ')}`,
            {
              code: 'INVALID_CONFIG_KEY',
              suggestion: `Valid keys: ${VALID_CONFIG_KEYS.join(', ')}`,
            },
          );
        }

        // 4. Validate individual values
        if ('output_format' in importedObj) {
          const val = importedObj['output_format'];
          if (typeof val !== 'string' || !['human', 'json', 'quiet'].includes(val)) {
            throw new CLIError(`Invalid output_format: "${val}"`, {
              code: 'INVALID_CONFIG_VALUE',
              suggestion: 'Valid values: human, json, quiet',
            });
          }
        }

        if ('auto_open_browser' in importedObj) {
          const val = importedObj['auto_open_browser'];
          if (typeof val !== 'boolean' && val !== 'true' && val !== 'false') {
            throw new CLIError(`Invalid auto_open_browser: "${val}"`, {
              code: 'INVALID_CONFIG_VALUE',
              suggestion: 'Valid values: true, false',
            });
          }
          // Normalize string booleans
          if (typeof val === 'string') {
            importedObj['auto_open_browser'] = val === 'true';
          }
        }

        // 5. Merge into current config and save
        const current = loadConfig();
        const merged: ConfigData = { ...current, ...importedObj };
        saveConfig(merged);

        const importedKeyCount = Object.keys(importedObj).length;

        switch (mode) {
          case 'json':
            printJson({
              success: true,
              keys_imported: importedKeyCount,
              config: merged,
            });
            break;
          case 'quiet':
            printQuiet(String(importedKeyCount));
            break;
          default:
            console.log(
              chalk.green(
                `\u2713 Imported ${importedKeyCount} config key${importedKeyCount !== 1 ? 's' : ''} from ${chalk.bold(file)}`,
              ),
            );
            break;
        }
      } catch (error: unknown) {
        handleError(error);
      }
    });
}