@wave-av/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,4034 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk54 from "chalk";
+
+// src/commands/auth/index.ts
+import chalk5 from "chalk";
+
+// src/lib/errors.ts
+import chalk2 from "chalk";
+import { WaveError, RateLimitError } from "@wave-av/sdk";
+
+// src/lib/exit-codes.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  AUTH_REQUIRED: 2,
+  AUTH_EXPIRED: 3,
+  NOT_FOUND: 4,
+  VALIDATION_ERROR: 5,
+  RATE_LIMITED: 6,
+  PERMISSION_DENIED: 7,
+  NETWORK_ERROR: 8,
+  CONFIG_ERROR: 9,
+  TIMEOUT: 10
+};
+
+// src/lib/environment.ts
+function detectEnvironment() {
+  const isCI = Boolean(
+    process.env["CI"] || process.env["GITHUB_ACTIONS"] || process.env["VERCEL"] || process.env["BUILDKITE"] || process.env["GITLAB_CI"] || process.env["CIRCLECI"]
+  );
+  const isAgent = Boolean(
+    process.env["WAVE_AGENT"] || process.env["CLAUDE_CODE"] || process.env["CURSOR_SESSION"] || process.env["AIDER_SESSION"] || process.env["CONTINUE_SESSION"]
+  );
+  const isInteractive = Boolean(process.stdin.isTTY) && !isCI && !isAgent;
+  const preferJson = !isInteractive || process.env["WAVE_OUTPUT_FORMAT"] === "json" || isAgent;
+  const supportsColor = process.env["WAVE_NO_COLOR"] !== "1" && process.env["NO_COLOR"] === void 0 && (process.env["FORCE_COLOR"] !== void 0 || Boolean(process.stdout.isTTY));
+  const agentName = process.env["WAVE_AGENT_NAME"] || (process.env["CLAUDE_CODE"] ? "claude-code" : void 0) || (process.env["CURSOR_SESSION"] ? "cursor" : void 0);
+  return { isCI, isAgent, isInteractive, preferJson, supportsColor, agentName };
+}
+
+// src/lib/suggestions.ts
+import chalk from "chalk";
+var AUTH_SUGGESTIONS = [
+  { message: "Authenticate with WAVE", command: "wave login" },
+  { message: "Use an API key directly", command: "wave login --api-key <your-key>" },
+  { message: "Set env var for CI/CD", command: "export WAVE_API_KEY=wave_live_..." }
+];
+var RATE_LIMIT_SUGGESTIONS = [
+  { message: "Check your current limits", command: "wave billing limits" },
+  { message: "Upgrade your plan", command: "wave billing upgrade" },
+  { message: "Wait and retry (the CLI does this automatically)" }
+];
+function formatSuggestion(suggestion) {
+  const parts = [`  ${chalk.dim(">")} ${suggestion.message}`];
+  if (suggestion.command) {
+    parts.push(`    ${chalk.cyan("$")} ${chalk.bold(suggestion.command)}`);
+  }
+  if (suggestion.docs) {
+    parts.push(`    ${chalk.dim(suggestion.docs)}`);
+  }
+  return parts.join("\n");
+}
+function getAuthSuggestions() {
+  const header = chalk.yellow("Not authenticated. Try one of:");
+  const suggestions = AUTH_SUGGESTIONS.map(formatSuggestion).join("\n\n");
+  return `${header}
+
+${suggestions}`;
+}
+function getRateLimitSuggestions() {
+  const header = chalk.yellow("Rate limited. Options:");
+  return `${header}
+
+${RATE_LIMIT_SUGGESTIONS.map(formatSuggestion).join("\n\n")}`;
+}
+function toStructuredError(code, message, exitCode, suggestions, requestId) {
+  return {
+    error: {
+      code,
+      message,
+      exit_code: exitCode,
+      suggestions,
+      request_id: requestId
+    }
+  };
+}
+
+// src/lib/errors.ts
+function formatCLIError(error) {
+  const env = detectEnvironment();
+  if (error instanceof RateLimitError) {
+    if (env.preferJson) {
+      const structured = toStructuredError(
+        "RATE_LIMITED",
+        `Rate limit exceeded. Retry after ${error.retryAfter}ms.`,
+        EXIT_CODES.RATE_LIMITED,
+        [
+          { message: "Check your limits", command: "wave billing limits" },
+          { message: "Upgrade your plan", command: "wave billing upgrade" }
+        ],
+        error.requestId
+      );
+      return { message: JSON.stringify(structured, null, 2), exitCode: EXIT_CODES.RATE_LIMITED };
+    }
+    return {
+      message: getRateLimitSuggestions(),
+      exitCode: EXIT_CODES.RATE_LIMITED
+    };
+  }
+  if (error instanceof WaveError) {
+    const exitCode = error.statusCode === 401 ? EXIT_CODES.AUTH_REQUIRED : error.statusCode === 403 ? EXIT_CODES.PERMISSION_DENIED : error.statusCode === 404 ? EXIT_CODES.NOT_FOUND : error.statusCode === 422 ? EXIT_CODES.VALIDATION_ERROR : error.statusCode === 429 ? EXIT_CODES.RATE_LIMITED : EXIT_CODES.GENERAL_ERROR;
+    if (env.preferJson) {
+      const suggestions = error.statusCode === 401 ? [{ message: "Authenticate", command: "wave login" }, { message: "Use API key", command: "export WAVE_API_KEY=..." }] : error.statusCode === 404 ? [{ message: "List resources", command: "wave <resource> list" }] : [];
+      const structured = toStructuredError(
+        error.code,
+        error.message,
+        exitCode,
+        suggestions,
+        error.requestId
+      );
+      return { message: JSON.stringify(structured, null, 2), exitCode };
+    }
+    if (error.statusCode === 401) {
+      return { message: getAuthSuggestions(), exitCode };
+    }
+    const lines = [
+      chalk2.red(error.message),
+      chalk2.dim(`  Code: ${error.code} | Status: ${error.statusCode}`),
+      error.requestId ? chalk2.dim(`  Request ID: ${error.requestId}`) : "",
+      error.retryable ? chalk2.yellow("  This error is retryable.") : ""
+    ].filter(Boolean);
+    return { message: lines.join("\n"), exitCode };
+  }
+  if (error instanceof Error) {
+    if (env.preferJson) {
+      const structured = toStructuredError(
+        "CLI_ERROR",
+        error.message,
+        EXIT_CODES.GENERAL_ERROR,
+        []
+      );
+      return { message: JSON.stringify(structured, null, 2), exitCode: EXIT_CODES.GENERAL_ERROR };
+    }
+    return {
+      message: chalk2.red(`Error: ${error.message}`),
+      exitCode: EXIT_CODES.GENERAL_ERROR
+    };
+  }
+  return {
+    message: chalk2.red(`Unexpected error: ${String(error)}`),
+    exitCode: EXIT_CODES.GENERAL_ERROR
+  };
+}
+function wrapCommand(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      const { message, exitCode } = formatCLIError(error);
+      console.error(message);
+      process.exit(exitCode);
+    }
+  };
+}
+
+// src/lib/output/table.ts
+import Table from "cli-table3";
+function formatTable(data, columns) {
+  if (data.length === 0) {
+    return "No results found.";
+  }
+  const cols = columns ?? Object.keys(data[0] ?? {});
+  const table = new Table({
+    head: cols,
+    style: { head: ["cyan"] }
+  });
+  for (const row of data) {
+    table.push(
+      cols.map((col) => {
+        const val = row[col];
+        if (val === null || val === void 0) return "";
+        if (typeof val === "object") return JSON.stringify(val);
+        const str = String(val);
+        return str.length > 60 ? str.slice(0, 57) + "..." : str;
+      })
+    );
+  }
+  return table.toString();
+}
+function formatDetail(data) {
+  const table = new Table({
+    style: { head: ["cyan"] }
+  });
+  for (const [key, value] of Object.entries(data)) {
+    const val = value === null || value === void 0 ? "" : typeof value === "object" ? JSON.stringify(value, null, 2) : String(value);
+    table.push({ [key]: val });
+  }
+  return table.toString();
+}
+
+// src/lib/output/json.ts
+import chalk3 from "chalk";
+function formatJson(data, colorize = true) {
+  const json = JSON.stringify(data, null, 2);
+  if (!colorize) return json;
+  return json.replace(/("(?:\\.|[^"\\])*")\s*:/g, (_match, key) => `${chalk3.cyan(key)}:`);
+}
+
+// src/lib/output/yaml.ts
+import { stringify } from "yaml";
+function formatYaml(data) {
+  return stringify(data, { indent: 2 });
+}
+
+// src/lib/output/spinner.ts
+import ora from "ora";
+async function withSpinner(message, fn) {
+  const spinner = ora(message).start();
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+
+// src/lib/output/confirm.ts
+import inquirer from "inquirer";
+async function confirmDestructive(action, resource, opts) {
+  if (opts.confirm) return true;
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: `Are you sure you want to ${action} ${resource}?`,
+      default: false
+    }
+  ]);
+  return confirmed;
+}
+
+// src/lib/output/index.ts
+function formatOutput(data, opts = {}) {
+  const format = opts.output ?? "table";
+  switch (format) {
+    case "json":
+      console.log(formatJson(data));
+      break;
+    case "yaml":
+      console.log(formatYaml(data));
+      break;
+    case "table":
+    default:
+      if (Array.isArray(data)) {
+        console.log(formatTable(data));
+      } else if (data && typeof data === "object") {
+        console.log(formatDetail(data));
+      } else {
+        console.log(String(data));
+      }
+      break;
+  }
+}
+
+// src/lib/auth/keychain.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var SERVICE_NAME = "wave-cli";
+var keytarModule = null;
+var keytarChecked = false;
+async function getKeytar() {
+  if (keytarChecked) return keytarModule;
+  keytarChecked = true;
+  try {
+    keytarModule = await import(
+      /* webpackIgnore: true */
+      "keytar"
+    );
+    return keytarModule;
+  } catch {
+    return null;
+  }
+}
+async function storeApiKey(project, key) {
+  const keytar = await getKeytar();
+  if (keytar) {
+    await keytar.setPassword(SERVICE_NAME, `apikey:${project}`, key);
+  } else {
+    await storeToFile(project, key);
+  }
+}
+async function getApiKey(project) {
+  const keytar = await getKeytar();
+  if (keytar) {
+    return keytar.getPassword(SERVICE_NAME, `apikey:${project}`);
+  }
+  return getFromFile(project);
+}
+async function deleteApiKey(project) {
+  const keytar = await getKeytar();
+  if (keytar) {
+    await keytar.deletePassword(SERVICE_NAME, `apikey:${project}`);
+  } else {
+    await deleteFromFile(project);
+  }
+}
+async function deleteAllKeys() {
+  const keytar = await getKeytar();
+  if (keytar) {
+    const credentials = await keytar.findCredentials(SERVICE_NAME);
+    for (const cred of credentials) {
+      await keytar.deletePassword(SERVICE_NAME, cred.account);
+    }
+  } else {
+    await deleteAllFromFile();
+  }
+}
+var CRED_FILE = join(homedir(), ".wave", "credentials.json");
+async function loadCredentials() {
+  try {
+    if (!existsSync(CRED_FILE)) return {};
+    const raw = await readFile(CRED_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveCredentials(creds) {
+  const dir = join(homedir(), ".wave");
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(CRED_FILE, JSON.stringify(creds, null, 2), {
+    mode: 384
+  });
+}
+async function storeToFile(project, key) {
+  const creds = await loadCredentials();
+  creds[project] = key;
+  await saveCredentials(creds);
+}
+async function getFromFile(project) {
+  const creds = await loadCredentials();
+  return creds[project] ?? null;
+}
+async function deleteFromFile(project) {
+  const creds = await loadCredentials();
+  delete creds[project];
+  await saveCredentials(creds);
+}
+async function deleteAllFromFile() {
+  await saveCredentials({});
+}
+
+// src/lib/config/manager.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/lib/config/schema.ts
+import { z } from "zod";
+var projectConfigSchema = z.object({
+  organizationId: z.string(),
+  organizationName: z.string(),
+  baseUrl: z.string().url().optional(),
+  region: z.string().optional()
+});
+var waveConfigSchema = z.object({
+  version: z.string().default("1.0.0"),
+  currentProject: z.string().default("default"),
+  projects: z.record(z.string(), projectConfigSchema).default({}),
+  defaults: z.object({
+    outputFormat: z.enum(["table", "json", "yaml"]).default("table"),
+    protocol: z.string().optional(),
+    color: z.enum(["auto", "on", "off"]).default("auto")
+  }).default({}),
+  telemetry: z.object({
+    enabled: z.boolean().default(false),
+    errorReporting: z.boolean().default(false)
+  }).default({})
+});
+function getDefaultConfig() {
+  return waveConfigSchema.parse({});
+}
+
+// src/lib/config/manager.ts
+var CONFIG_DIR = join2(homedir2(), ".wave");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+async function loadConfig() {
+  try {
+    if (!existsSync2(CONFIG_FILE)) {
+      const defaults = getDefaultConfig();
+      await saveConfig(defaults);
+      return defaults;
+    }
+    const raw = await readFile2(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return waveConfigSchema.parse(parsed);
+  } catch {
+    const defaults = getDefaultConfig();
+    await saveConfig(defaults);
+    return defaults;
+  }
+}
+async function saveConfig(config) {
+  const validated = waveConfigSchema.parse(config);
+  if (!existsSync2(CONFIG_DIR)) {
+    await mkdir2(CONFIG_DIR, { recursive: true });
+  }
+  const tmpPath = `${CONFIG_FILE}.tmp`;
+  await writeFile2(tmpPath, JSON.stringify(validated, null, 2) + "\n", "utf-8");
+  const { rename } = await import("fs/promises");
+  await rename(tmpPath, CONFIG_FILE);
+}
+async function updateConfig(updater) {
+  const current = await loadConfig();
+  const updated = updater(current);
+  await saveConfig(updated);
+  return updated;
+}
+
+// src/lib/auth/device-flow.ts
+import open from "open";
+import chalk4 from "chalk";
+var POLL_ERROR_AUTHORIZATION_PENDING = "authorization_pending";
+var POLL_ERROR_SLOW_DOWN = "slow_down";
+var POLL_ERROR_EXPIRED_TOKEN = "expired_token";
+var POLL_ERROR_ACCESS_DENIED = "access_denied";
+var SLOW_DOWN_INCREMENT_MS = 5e3;
+async function startDeviceAuth(baseUrl) {
+  const url = `${baseUrl}/api/oauth/device/authorize`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_id: "wave-cli",
+      scope: "openid profile email offline_access"
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Device authorization request failed (${response.status}): ${text}`);
+  }
+  const data = await response.json();
+  console.log();
+  console.log(chalk4.bold("  Open this URL in your browser to authenticate:"));
+  console.log();
+  console.log(`    ${chalk4.cyan.underline(data.verification_uri)}`);
+  console.log();
+  console.log(chalk4.bold("  Enter this code when prompted:"));
+  console.log();
+  console.log(`    ${chalk4.bold.yellow(data.user_code)}`);
+  console.log();
+  const verificationUrl = data.verification_uri_complete ?? data.verification_uri;
+  try {
+    await open(verificationUrl);
+    console.log(chalk4.gray("  Browser opened automatically."));
+  } catch {
+    console.log(
+      chalk4.gray("  Could not open browser automatically. Please open the URL manually.")
+    );
+  }
+  console.log();
+  console.log(chalk4.gray("  Waiting for authentication..."));
+  console.log();
+  return data;
+}
+async function pollForToken(baseUrl, deviceCode, interval, expiresIn) {
+  const url = `${baseUrl}/api/oauth/device/token`;
+  const deadline = Date.now() + expiresIn * 1e3;
+  let pollIntervalMs = interval * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(pollIntervalMs);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode,
+        client_id: "wave-cli"
+      })
+    });
+    if (response.ok) {
+      const tokenData = await response.json();
+      console.log(chalk4.green("  Authentication successful."));
+      return tokenData;
+    }
+    const errorBody = await response.json();
+    const errorCode = errorBody.error;
+    switch (errorCode) {
+      case POLL_ERROR_AUTHORIZATION_PENDING:
+        break;
+      case POLL_ERROR_SLOW_DOWN:
+        pollIntervalMs += SLOW_DOWN_INCREMENT_MS;
+        break;
+      case POLL_ERROR_EXPIRED_TOKEN:
+        throw new Error("Device code has expired. Please run the login command again.");
+      case POLL_ERROR_ACCESS_DENIED:
+        throw new Error("Authentication was denied. Please try again.");
+      default:
+        throw new Error(
+          `Unexpected error during device flow: ${errorCode}${errorBody.error_description ? ` - ${errorBody.error_description}` : ""}`
+        );
+    }
+  }
+  throw new Error("Device code has expired (timeout). Please run the login command again.");
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
+// src/commands/auth/index.ts
+function registerAuthCommands(program) {
+  const auth = program.command("auth").description("Manage authentication");
+  auth.command("login").description("Authenticate with the WAVE platform").option("--api-key <key>", "API key for non-interactive authentication").action(
+    wrapCommand(async (opts) => {
+      if (opts.apiKey) {
+        const config = await loadConfig();
+        const project2 = config.currentProject || "default";
+        await storeApiKey(project2, opts.apiKey);
+        console.log(chalk5.green(`API key stored for project "${project2}".`));
+        return;
+      }
+      const baseUrl = process.env["WAVE_BASE_URL"] ?? "https://wave.online";
+      const deviceAuth = await startDeviceAuth(baseUrl);
+      const token = await pollForToken(
+        baseUrl,
+        deviceAuth.device_code,
+        deviceAuth.interval,
+        deviceAuth.expires_in
+      );
+      const project = "default";
+      await storeApiKey(project, token.access_token);
+      await updateConfig((config) => ({
+        ...config,
+        currentProject: project
+      }));
+      console.log(chalk5.green("\nAuthentication complete. You can now use the WAVE CLI."));
+    })
+  );
+  auth.command("logout").description("Remove stored credentials").option("--all", "Remove credentials for all projects").action(
+    wrapCommand(async (opts) => {
+      if (opts.all) {
+        await deleteAllKeys();
+        console.log(chalk5.green("All credentials removed."));
+      } else {
+        const config = await loadConfig();
+        await deleteApiKey(config.currentProject);
+        console.log(chalk5.green(`Credentials removed for project "${config.currentProject}".`));
+      }
+    })
+  );
+  auth.command("status").description("Show current authentication status").action(
+    wrapCommand(async () => {
+      const config = await loadConfig();
+      const apiKey = await getApiKey(config.currentProject);
+      const status = {
+        project: config.currentProject,
+        authenticated: !!apiKey,
+        organization: config.projects[config.currentProject]?.organizationName ?? "N/A",
+        organizationId: config.projects[config.currentProject]?.organizationId ?? "N/A"
+      };
+      formatOutput(status, program.opts());
+    })
+  );
+  program.command("whoami").description("Show the current authenticated user").action(
+    wrapCommand(async () => {
+      const config = await loadConfig();
+      const project = config.currentProject || "default";
+      const apiKey = await getApiKey(project);
+      if (!apiKey) {
+        console.error(chalk5.red("Not authenticated. Run `wave auth login` first."));
+        process.exit(1);
+      }
+      const baseUrl = config.projects[project]?.baseUrl ?? "https://wave.online";
+      const res = await fetch(`${baseUrl}/api/v1/me`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!res.ok) {
+        console.error(
+          chalk5.red(
+            "Authentication invalid or expired. Run `wave auth login` to re-authenticate."
+          )
+        );
+        process.exit(1);
+      }
+      const user = await res.json();
+      console.log(chalk5.bold("\n  Authenticated as:"));
+      if (user.name) console.log(`  Name:  ${chalk5.cyan(user.name)}`);
+      if (user.email) console.log(`  Email: ${chalk5.cyan(user.email)}`);
+      console.log(
+        `  Org:   ${chalk5.cyan(user.organization ?? config.projects[project]?.organizationName ?? "N/A")}`
+      );
+      console.log(`  Project: ${chalk5.cyan(project)}`);
+      console.log("");
+      formatOutput(
+        {
+          project,
+          name: user.name ?? "N/A",
+          email: user.email ?? "N/A",
+          organization: user.organization ?? config.projects[project]?.organizationName ?? "N/A"
+        },
+        program.opts()
+      );
+    })
+  );
+}
+
+// src/commands/org/index.ts
+import chalk6 from "chalk";
+function registerOrgCommands(program) {
+  const org = program.command("org").description("Manage organizations");
+  org.command("list").description("List available organizations").action(
+    wrapCommand(async () => {
+      const config = await loadConfig();
+      const orgs = Object.entries(config.projects).map(([name, project]) => ({
+        name,
+        organizationId: project.organizationId,
+        organizationName: project.organizationName,
+        current: name === config.currentProject ? "*" : ""
+      }));
+      formatOutput(orgs, program.opts());
+    })
+  );
+  org.command("switch <id>").description("Switch to a different organization").action(
+    wrapCommand(async (id) => {
+      const config = await loadConfig();
+      const match = Object.entries(config.projects).find(
+        ([name, project]) => name === id || project.organizationId === id
+      );
+      if (!match) {
+        throw new Error(
+          `Organization "${id}" not found. Run ${chalk6.bold("wave org list")} to see available organizations.`
+        );
+      }
+      const [projectName] = match;
+      await updateConfig((cfg) => ({
+        ...cfg,
+        currentProject: projectName
+      }));
+      console.log(chalk6.green(`Switched to organization "${projectName}".`));
+    })
+  );
+  org.command("current").description("Show the current organization").action(
+    wrapCommand(async () => {
+      const config = await loadConfig();
+      const project = config.projects[config.currentProject];
+      if (!project) {
+        console.log(chalk6.yellow("No organization configured. Run `wave login` first."));
+        return;
+      }
+      formatOutput(
+        {
+          project: config.currentProject,
+          organizationId: project.organizationId,
+          organizationName: project.organizationName,
+          region: project.region ?? "auto"
+        },
+        program.opts()
+      );
+    })
+  );
+}
+
+// src/commands/config/index.ts
+import chalk7 from "chalk";
+function registerConfigCommands(program) {
+  const config = program.command("config").description("Manage CLI configuration");
+  config.command("list").description("List all configuration values").action(
+    wrapCommand(async () => {
+      const cfg = await loadConfig();
+      console.log(chalk7.gray(`Config file: ${getConfigPath()}
+`));
+      formatOutput(cfg, program.opts());
+    })
+  );
+  config.command("get <key>").description("Get a configuration value").action(
+    wrapCommand(async (key) => {
+      const cfg = await loadConfig();
+      const value = getNestedValue(cfg, key);
+      if (value === void 0) {
+        throw new Error(`Configuration key "${key}" not found.`);
+      }
+      if (typeof value === "object" && value !== null) {
+        formatOutput(value, program.opts());
+      } else {
+        console.log(String(value));
+      }
+    })
+  );
+  config.command("set <key> <value>").description("Set a configuration value").action(
+    wrapCommand(async (key, value) => {
+      await updateConfig((cfg) => {
+        const updated = { ...cfg };
+        setNestedValue(updated, key, value);
+        return updated;
+      });
+      console.log(chalk7.green(`Set ${chalk7.bold(key)} = ${value}`));
+    })
+  );
+  config.command("reset").description("Reset configuration to defaults").action(
+    wrapCommand(async () => {
+      const defaults = getDefaultConfig();
+      await updateConfig(() => defaults);
+      console.log(chalk7.green("Configuration reset to defaults."));
+    })
+  );
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  if (value === "true") current[lastKey] = true;
+  else if (value === "false") current[lastKey] = false;
+  else if (!isNaN(Number(value)) && value !== "") current[lastKey] = Number(value);
+  else current[lastKey] = value;
+}
+
+// src/commands/stream/index.ts
+import chalk9 from "chalk";
+
+// src/lib/api-client.ts
+import { Wave } from "@wave-av/sdk";
+import chalk8 from "chalk";
+async function getClient(opts) {
+  const envApiKey = process.env["WAVE_API_KEY"];
+  const envOrgId = process.env["WAVE_ORG_ID"];
+  const envBaseUrl = process.env["WAVE_BASE_URL"];
+  if (envApiKey) {
+    return new Wave({
+      apiKey: envApiKey,
+      organizationId: envOrgId ?? opts?.org,
+      baseUrl: envBaseUrl
+    });
+  }
+  const config = await loadConfig();
+  const projectName = opts?.project ?? process.env["WAVE_PROJECT"] ?? config.currentProject;
+  const project = config.projects[projectName];
+  if (!project) {
+    console.error(
+      chalk8.red(
+        `No project "${projectName}" configured. Run ${chalk8.bold("wave login")} to authenticate.`
+      )
+    );
+    process.exit(1);
+  }
+  const apiKey = await getApiKey(projectName);
+  if (!apiKey) {
+    console.error(
+      chalk8.red(
+        `No API key found for project "${projectName}". Run ${chalk8.bold("wave login")} to authenticate.`
+      )
+    );
+    process.exit(1);
+  }
+  const client = new Wave({
+    apiKey,
+    organizationId: opts?.org ?? project.organizationId,
+    baseUrl: project.baseUrl,
+    customHeaders: {
+      "X-Wave-Source": "cli",
+      "X-Wave-CLI-Version": "1.0.0"
+    }
+  });
+  client.client.on("rate_limit.hit", (retryAfter) => {
+    console.warn(chalk8.yellow(`Rate limited. Retrying in ${retryAfter}ms...`));
+  });
+  client.client.on("request.retry", (_url, _method, attempt) => {
+    console.warn(chalk8.gray(`Retry ${attempt}/3...`));
+  });
+  return client;
+}
+
+// src/commands/stream/index.ts
+function registerStreamCommands(program) {
+  const stream = program.command("stream").description("Manage live streams");
+  stream.command("create").description("Create a new live stream").requiredOption("--title <title>", "Stream title").option("--protocol <protocol>", "Streaming protocol (webrtc, srt, rtmp)", "webrtc").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.create({
+        title: opts.title,
+        protocol: opts.protocol
+      });
+      console.log(chalk9.green(`Stream created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("list").description("List all streams").option("--limit <n>", "Maximum results", "20").option("--status <status>", "Filter by status").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const params = {
+        limit: parseInt(opts.limit)
+      };
+      if (opts.status) params.status = opts.status;
+      const result = await client.pipeline.list(params);
+      formatOutput(result.data, program.opts());
+    })
+  );
+  stream.command("get <id>").description("Get stream details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("update <id>").description("Update a stream").option("--title <title>", "New stream title").option("--protocol <protocol>", "New streaming protocol").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const updates = {};
+      if (opts.title) updates.title = opts.title;
+      if (opts.protocol) updates.protocol = opts.protocol;
+      const result = await client.pipeline.update(id, updates);
+      console.log(chalk9.green(`Stream ${id} updated.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("delete <id>").description("Delete a stream").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("delete", `stream ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.pipeline.delete(id);
+      console.log(chalk9.green(`Stream ${id} deleted.`));
+    })
+  );
+  stream.command("start <id>").description("Start a live stream").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.start(id);
+      console.log(chalk9.green(`Stream ${id} started.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("stop <id>").description("Stop a live stream").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("stop", `stream ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.stop(id);
+      console.log(chalk9.green(`Stream ${id} stopped.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("restart <id>").description("Restart a live stream").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.restart(id);
+      console.log(chalk9.green(`Stream ${id} restarted.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("status <id>").description("Get stream status").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.status(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("viewers <id>").description("Get viewer count for a stream").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.viewers(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("metrics <id>").description("Get stream metrics").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.metrics(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  stream.command("recordings <id>").description("List recordings for a stream").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.pipeline.recordings(id);
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/studio/index.ts
+import chalk10 from "chalk";
+function registerStudioCommands(program) {
+  const studio = program.command("studio").description("Manage studio productions");
+  studio.command("create").description("Create a new studio production").requiredOption("--title <title>", "Production title").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.create({ title: opts.title });
+      console.log(chalk10.green(`Studio production created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  studio.command("list").description("List studio productions").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.list({ limit: parseInt(opts.limit) });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  studio.command("get <id>").description("Get studio production details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  studio.command("start <id>").description("Start a studio production").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.start(id);
+      console.log(chalk10.green(`Studio production ${id} started.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  studio.command("stop <id>").description("Stop a studio production").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.stop(id);
+      console.log(chalk10.green(`Studio production ${id} stopped.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  const scene = studio.command("scene").description("Manage studio scenes");
+  scene.command("list <productionId>").description("List scenes in a production").action(
+    wrapCommand(async (productionId) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.scenes.list(productionId);
+      formatOutput(result, program.opts());
+    })
+  );
+  scene.command("create <productionId>").description("Create a scene in a production").requiredOption("--name <name>", "Scene name").action(
+    wrapCommand(async (productionId, opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.scenes.create(productionId, {
+        name: opts.name
+      });
+      console.log(chalk10.green(`Scene created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  scene.command("activate <productionId> <sceneId>").description("Activate a scene in a production").action(
+    wrapCommand(async (productionId, sceneId) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.scenes.activate(productionId, sceneId);
+      console.log(chalk10.green(`Scene ${sceneId} activated.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  const source = studio.command("source").description("Manage studio sources");
+  source.command("list <productionId>").description("List sources in a production").action(
+    wrapCommand(async (productionId) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.sources.list(productionId);
+      formatOutput(result, program.opts());
+    })
+  );
+  source.command("add <productionId>").description("Add a source to a production").requiredOption("--type <type>", "Source type (camera, screen, url)").option("--url <url>", "Source URL for url type").option("--name <name>", "Source display name").action(
+    wrapCommand(async (productionId, opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studio.sources.add(productionId, {
+        type: opts.type,
+        url: opts.url,
+        name: opts.name
+      });
+      console.log(chalk10.green(`Source added: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/clips/index.ts
+import chalk11 from "chalk";
+function registerClipCommands(program) {
+  const clip = program.command("clip").description("Manage stream clips");
+  clip.command("create").description("Create a clip from a stream").requiredOption("--stream-id <streamId>", "Source stream ID").requiredOption("--start <start>", "Start time in seconds").requiredOption("--end <end>", "End time in seconds").option("--title <title>", "Clip title").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.clips.create({
+        streamId: opts.streamId,
+        start: parseFloat(opts.start),
+        end: parseFloat(opts.end),
+        title: opts.title
+      });
+      console.log(chalk11.green(`Clip created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  clip.command("list").description("List all clips").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.clips.list({ limit: parseInt(opts.limit) });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  clip.command("get <id>").description("Get clip details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.clips.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  clip.command("export <id>").description("Export a clip").option("--format <format>", "Export format (mp4, webm, gif)", "mp4").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.clips.export(id, { format: opts.format });
+      console.log(chalk11.green(`Clip ${id} export started.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  clip.command("download <id>").description("Download a clip to local filesystem").option("--output <path>", "Output file path").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.clips.download(id, { output: opts.output });
+      console.log(chalk11.green(`Clip ${id} downloaded to ${result.path}`));
+    })
+  );
+}
+
+// src/commands/editor/index.ts
+import chalk12 from "chalk";
+function registerEditorCommands(program) {
+  const editor = program.command("editor").description("Manage video editor projects");
+  editor.command("create").description("Create a new editor project").requiredOption("--title <title>", "Project title").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.editor.create({ title: opts.title });
+      console.log(chalk12.green(`Editor project created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  editor.command("list").description("List editor projects").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.editor.list({ limit: parseInt(opts.limit) });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  editor.command("get <id>").description("Get editor project details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.editor.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  editor.command("render <id>").description("Render an editor project").option("--format <format>", "Output format (mp4, webm, mov)", "mp4").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.editor.render(id, { format: opts.format });
+      console.log(chalk12.green(`Render started for project ${id}.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/voice/index.ts
+import chalk13 from "chalk";
+function registerVoiceCommands(program) {
+  const voice = program.command("voice").description("Voice synthesis and cloning");
+  voice.command("synthesize").description("Synthesize text to speech").requiredOption("--text <text>", "Text to synthesize").requiredOption("--voice-id <voiceId>", "Voice ID to use").option("--output <path>", "Output audio file path").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.voice.synthesize({
+        text: opts.text,
+        voiceId: opts.voiceId,
+        output: opts.output
+      });
+      console.log(chalk13.green("Speech synthesized successfully."));
+      formatOutput(result, program.opts());
+    })
+  );
+  voice.command("clone").description("Clone a voice from a sample").requiredOption("--name <name>", "Name for the cloned voice").option("--sample <path>", "Path to voice sample audio file").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.voice.clone({
+        name: opts.name,
+        samplePath: opts.sample
+      });
+      console.log(chalk13.green(`Voice cloned: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  voice.command("list-voices").description("List available voices").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.voice.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/phone/index.ts
+import chalk14 from "chalk";
+function registerPhoneCommands(program) {
+  const phone = program.command("phone").description("Telephony and phone services");
+  phone.command("call").description("Initiate a phone call").requiredOption("--to <number>", "Destination phone number").requiredOption("--from <number>", "Source phone number").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.phone.call({
+        to: opts.to,
+        from: opts.from
+      });
+      console.log(chalk14.green(`Call initiated: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  const conference = phone.command("conference").description("Manage conference calls");
+  conference.command("create").description("Create a conference call").option("--name <name>", "Conference name").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.phone.conferences.create({
+        name: opts.name
+      });
+      console.log(chalk14.green(`Conference created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  conference.command("list").description("List conference calls").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.phone.conferences.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  const numbers = phone.command("numbers").description("Manage phone numbers");
+  numbers.command("list").description("List provisioned phone numbers").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.phone.numbers.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  numbers.command("provision").description("Provision a new phone number").option("--country <code>", "Country code", "US").option("--area-code <code>", "Area code").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.phone.numbers.provision({
+        country: opts.country,
+        areaCode: opts.areaCode
+      });
+      console.log(chalk14.green(`Number provisioned: ${result.number}`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/collab/index.ts
+import chalk15 from "chalk";
+function registerCollabCommands(program) {
+  const collab = program.command("collab").description("Real-time collaboration rooms");
+  const room = collab.command("room").description("Manage collaboration rooms");
+  room.command("create").description("Create a collaboration room").option("--name <name>", "Room name").option("--max-participants <n>", "Maximum participants", "50").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.collab.rooms.create({
+        name: opts.name,
+        maxParticipants: parseInt(opts.maxParticipants)
+      });
+      console.log(chalk15.green(`Room created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  room.command("list").description("List collaboration rooms").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.collab.rooms.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  room.command("join <id>").description("Join a collaboration room").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.collab.rooms.join(id);
+      console.log(chalk15.green(`Joined room ${id}.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  collab.command("invite").description("Invite a user to a collaboration room").requiredOption("--room-id <roomId>", "Room ID").requiredOption("--email <email>", "Email address to invite").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.collab.invite({
+        roomId: opts.roomId,
+        email: opts.email
+      });
+      console.log(chalk15.green(`Invitation sent to ${opts.email}.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/captions/index.ts
+import chalk16 from "chalk";
+function registerCaptionsCommands(program) {
+  const captions = program.command("captions").description("Live captioning and subtitles");
+  captions.command("generate").description("Generate captions for a stream").requiredOption("--stream-id <streamId>", "Stream ID").option("--language <lang>", "Source language", "en").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.captions.generate({
+        streamId: opts.streamId,
+        language: opts.language
+      });
+      console.log(chalk16.green("Caption generation started."));
+      formatOutput(result, program.opts());
+    })
+  );
+  captions.command("translate").description("Translate captions to another language").requiredOption("--stream-id <streamId>", "Stream ID").requiredOption("--target-language <lang>", "Target language code").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.captions.translate({
+        streamId: opts.streamId,
+        targetLanguage: opts.targetLanguage
+      });
+      console.log(chalk16.green(`Translation to ${opts.targetLanguage} started.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  captions.command("burn-in").description("Burn captions into a recording").requiredOption("--recording-id <recordingId>", "Recording ID").option("--style <style>", "Caption style (default, cinematic, minimal)", "default").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.captions.burnIn({
+        recordingId: opts.recordingId,
+        style: opts.style
+      });
+      console.log(chalk16.green("Caption burn-in started."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/chapters/index.ts
+import chalk17 from "chalk";
+function registerChaptersCommands(program) {
+  const chapters = program.command("chapters").description("Chapter detection and management");
+  chapters.command("detect").description("Auto-detect chapters in a recording").requiredOption("--recording-id <recordingId>", "Recording ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.chapters.detect({
+        recordingId: opts.recordingId
+      });
+      console.log(chalk17.green("Chapter detection started."));
+      formatOutput(result, program.opts());
+    })
+  );
+  chapters.command("create").description("Create a chapter manually").requiredOption("--recording-id <recordingId>", "Recording ID").requiredOption("--title <title>", "Chapter title").requiredOption("--timestamp <timestamp>", "Timestamp in seconds").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.chapters.create({
+        recordingId: opts.recordingId,
+        title: opts.title,
+        timestamp: parseFloat(opts.timestamp)
+      });
+      console.log(chalk17.green(`Chapter created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  chapters.command("list").description("List chapters for a recording").requiredOption("--recording-id <recordingId>", "Recording ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.chapters.list({
+        recordingId: opts.recordingId
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/ai/index.ts
+import chalk18 from "chalk";
+function registerAICommands(program) {
+  const ai = program.command("ai").description("AI-powered studio assistant");
+  const assistant = ai.command("assistant").description("Studio AI assistant");
+  assistant.command("start").description("Start the AI assistant for a production").requiredOption("--production-id <productionId>", "Production ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studioAI.start({
+        productionId: opts.productionId
+      });
+      console.log(chalk18.green("AI assistant started."));
+      formatOutput(result, program.opts());
+    })
+  );
+  assistant.command("stop").description("Stop the AI assistant for a production").requiredOption("--production-id <productionId>", "Production ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studioAI.stop({
+        productionId: opts.productionId
+      });
+      console.log(chalk18.green("AI assistant stopped."));
+      formatOutput(result, program.opts());
+    })
+  );
+  ai.command("suggestions").description("Get AI suggestions for the current production").requiredOption("--production-id <productionId>", "Production ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.studioAI.suggestions({
+        productionId: opts.productionId
+      });
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/transcribe/index.ts
+import chalk19 from "chalk";
+function registerTranscribeCommands(program) {
+  const transcribe = program.command("transcribe").description("Transcription services");
+  transcribe.command("create").description("Start a transcription job").requiredOption("--stream-id <streamId>", "Stream or recording ID").option("--language <lang>", "Source language", "en").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.transcribe.create({
+        streamId: opts.streamId,
+        language: opts.language
+      });
+      console.log(chalk19.green(`Transcription started: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  transcribe.command("get <id>").description("Get transcription status and results").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.transcribe.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  transcribe.command("export <id>").description("Export a transcription").option("--format <format>", "Export format (srt, vtt, txt, json)", "srt").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.transcribe.export(id, {
+        format: opts.format
+      });
+      console.log(chalk19.green(`Transcription exported as ${opts.format}.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/sentiment/index.ts
+function registerSentimentCommands(program) {
+  const sentiment = program.command("sentiment").description("Sentiment analysis tools");
+  sentiment.command("analyze").description("Analyze sentiment of text").requiredOption("--text <text>", "Text to analyze").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.sentiment.analyze({ text: opts.text });
+      formatOutput(result, program.opts());
+    })
+  );
+  sentiment.command("batch").description("Analyze sentiment of multiple texts from stdin").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.sentiment.batch();
+      formatOutput(result, program.opts());
+    })
+  );
+  sentiment.command("trends").description("View sentiment trends over time").option("--stream-id <streamId>", "Filter by stream ID").option("--period <period>", "Time period (hour, day, week)", "day").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.sentiment.trends({
+        streamId: opts.streamId,
+        period: opts.period
+      });
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/search/index.ts
+import chalk20 from "chalk";
+function registerSearchCommands(program) {
+  const search = program.command("search").description("Content search across streams and recordings");
+  search.command("query").description("Search content by text query").requiredOption("--q <query>", "Search query").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.search.query({
+        q: opts.q,
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  search.command("visual").description("Search by visual content").requiredOption("--q <query>", "Visual search query").option("--limit <n>", "Maximum results", "10").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.search.visual({
+        q: opts.q,
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  search.command("audio").description("Search by audio content").requiredOption("--q <query>", "Audio search query").option("--limit <n>", "Maximum results", "10").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.search.audio({
+        q: opts.q,
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  search.command("index").description("Index a recording for search").requiredOption("--recording-id <recordingId>", "Recording ID to index").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.search.index({
+        recordingId: opts.recordingId
+      });
+      console.log(chalk20.green("Recording indexing started."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/scene/index.ts
+import chalk21 from "chalk";
+function registerSceneCommands(program) {
+  const scene = program.command("scene").description("Scene detection and analysis");
+  scene.command("detect").description("Detect scenes in a recording").requiredOption("--recording-id <recordingId>", "Recording ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.scene.detect({
+        recordingId: opts.recordingId
+      });
+      console.log(chalk21.green("Scene detection started."));
+      formatOutput(result, program.opts());
+    })
+  );
+  scene.command("list").description("List detected scenes").requiredOption("--recording-id <recordingId>", "Recording ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.scene.list({
+        recordingId: opts.recordingId
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  scene.command("compare").description("Compare scenes across recordings").requiredOption("--recording-ids <ids>", "Comma-separated recording IDs").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const recordingIds = opts.recordingIds.split(",");
+      const result = await client.scene.compare({ recordingIds });
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/fleet/index.ts
+import chalk22 from "chalk";
+function registerFleetCommands(program) {
+  const fleet = program.command("fleet").description("Device fleet management");
+  fleet.command("list").description("List all devices in the fleet").option("--limit <n>", "Maximum results", "20").option("--status <status>", "Filter by device status").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const params = {
+        limit: parseInt(opts.limit)
+      };
+      if (opts.status) params.status = opts.status;
+      const result = await client.fleet.list(params);
+      formatOutput(result.data, program.opts());
+    })
+  );
+  fleet.command("get <id>").description("Get device details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.fleet.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  fleet.command("command <id>").description("Send a command to a device").requiredOption("--action <action>", "Command action (reboot, update, configure)").option("--payload <json>", "JSON payload for the command").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const payload = opts.payload ? JSON.parse(opts.payload) : void 0;
+      const result = await client.fleet.command(id, {
+        action: opts.action,
+        payload
+      });
+      console.log(chalk22.green(`Command sent to device ${id}.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  fleet.command("health <id>").description("Get device health status").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.fleet.health(id);
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/ghost/index.ts
+import chalk23 from "chalk";
+function registerGhostCommands(program) {
+  const ghost = program.command("ghost").description("WAVE Autopilot AI director");
+  ghost.command("suggestions").description("Get AI production suggestions").requiredOption("--production-id <productionId>", "Production ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.ghost.suggestions({
+        productionId: opts.productionId
+      });
+      formatOutput(result, program.opts());
+    })
+  );
+  ghost.command("apply <id>").description("Apply an autopilot suggestion").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.ghost.apply(id);
+      console.log(chalk23.green(`Suggestion ${id} applied.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  ghost.command("history").description("View autopilot action history").option("--production-id <productionId>", "Filter by production ID").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.ghost.history({
+        productionId: opts.productionId,
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/mesh/index.ts
+import chalk24 from "chalk";
+function registerMeshCommands(program) {
+  const mesh = program.command("mesh").description("Multi-region mesh network and failover");
+  mesh.command("status").description("Show mesh network status").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.mesh.status();
+      formatOutput(result, program.opts());
+    })
+  );
+  mesh.command("regions").description("List available mesh regions").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.mesh.regions();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  mesh.command("failover").description("Trigger a failover between regions").requiredOption("--from <region>", "Source region").requiredOption("--to <region>", "Target region").action(
+    wrapCommand(async (opts) => {
+      const confirmed = await confirmDestructive(
+        "failover",
+        `from ${opts.from} to ${opts.to}`,
+        program.opts()
+      );
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      const result = await client.mesh.failover({
+        from: opts.from,
+        to: opts.to
+      });
+      console.log(chalk24.green(`Failover initiated: ${opts.from} -> ${opts.to}`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/edge/index.ts
+import chalk25 from "chalk";
+function registerEdgeCommands(program) {
+  const edge = program.command("edge").description("Edge processing and CDN management");
+  const cache = edge.command("cache").description("Manage edge cache");
+  cache.command("status").description("Show edge cache status").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.edge.cache.status();
+      formatOutput(result, program.opts());
+    })
+  );
+  cache.command("purge").description("Purge edge cache").option("--path <path>", "Specific path to purge (purges all if omitted)").action(
+    wrapCommand(async (opts) => {
+      const target = opts.path ?? "all cache entries";
+      const confirmed = await confirmDestructive("purge", target, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      const result = await client.edge.cache.purge({ path: opts.path });
+      console.log(chalk25.green("Cache purge initiated."));
+      formatOutput(result, program.opts());
+    })
+  );
+  const workers = edge.command("workers").description("Manage edge workers");
+  workers.command("list").description("List edge workers").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.edge.workers.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  const rules = edge.command("rules").description("Manage edge rules");
+  rules.command("list").description("List edge rules").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.edge.rules.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  rules.command("create").description("Create an edge rule").requiredOption("--pattern <pattern>", "URL pattern to match").requiredOption("--action <action>", "Rule action (cache, redirect, block)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.edge.rules.create({
+        pattern: opts.pattern,
+        action: opts.action
+      });
+      console.log(chalk25.green(`Edge rule created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/analytics/index.ts
+function registerAnalyticsCommands(program) {
+  const analytics = program.command("analytics").description("Streaming analytics and insights");
+  analytics.command("viewers").description("View audience analytics").option("--stream-id <streamId>", "Filter by stream ID").option("--period <period>", "Time period (hour, day, week, month)", "day").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.pulse.viewers({
+        streamId: opts.streamId,
+        period: opts.period
+      });
+      formatOutput(result, program.opts());
+    })
+  );
+  analytics.command("revenue").description("View revenue analytics").option("--period <period>", "Time period (day, week, month)", "month").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.pulse.revenue({ period: opts.period });
+      formatOutput(result, program.opts());
+    })
+  );
+  analytics.command("export").description("Export analytics data").option("--format <format>", "Export format (csv, json)", "csv").option("--period <period>", "Time period (day, week, month)", "month").option("--stream-id <streamId>", "Filter by stream ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.pulse.export({
+        format: opts.format,
+        period: opts.period,
+        streamId: opts.streamId
+      });
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/prism/index.ts
+import chalk26 from "chalk";
+function registerPrismCommands(program) {
+  const prism = program.command("prism").description("Camera discovery and PTZ control");
+  prism.command("discover").description("Discover available cameras on the network").option("--timeout <ms>", "Discovery timeout in milliseconds", "5000").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.prism.discover({
+        timeout: parseInt(opts.timeout)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  prism.command("create").description("Register a camera source").requiredOption("--source-type <type>", "Source type (ndi, srt, rtmp, usb)").option("--name <name>", "Camera display name").option("--url <url>", "Camera source URL").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.prism.create({
+        sourceType: opts.sourceType,
+        name: opts.name,
+        url: opts.url
+      });
+      console.log(chalk26.green(`Camera registered: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  prism.command("ptz").description("Control camera PTZ (Pan-Tilt-Zoom)").requiredOption("--camera-id <cameraId>", "Camera ID").option("--pan <degrees>", "Pan angle in degrees").option("--tilt <degrees>", "Tilt angle in degrees").option("--zoom <level>", "Zoom level (0-100)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const params = {
+        cameraId: opts.cameraId
+      };
+      if (opts.pan !== void 0) params.pan = parseFloat(opts.pan);
+      if (opts.tilt !== void 0) params.tilt = parseFloat(opts.tilt);
+      if (opts.zoom !== void 0) params.zoom = parseFloat(opts.zoom);
+      const result = await client.prism.ptz(params);
+      console.log(chalk26.green("PTZ command sent."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/zoom/index.ts
+import chalk27 from "chalk";
+function registerZoomCommands(program) {
+  const zoom = program.command("zoom").description("Zoom meeting and webinar integration");
+  const meeting = zoom.command("meeting").description("Manage Zoom meetings");
+  meeting.command("create").description("Create a Zoom meeting").requiredOption("--topic <topic>", "Meeting topic").option("--duration <minutes>", "Duration in minutes", "60").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.meetings.create({
+        topic: opts.topic,
+        duration: parseInt(opts.duration)
+      });
+      console.log(chalk27.green(`Meeting created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  meeting.command("list").description("List Zoom meetings").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.meetings.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  meeting.command("get <id>").description("Get Zoom meeting details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.meetings.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  meeting.command("delete <id>").description("Delete a Zoom meeting").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("delete", `Zoom meeting ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.zoom.meetings.delete(id);
+      console.log(chalk27.green(`Meeting ${id} deleted.`));
+    })
+  );
+  const recordings = zoom.command("recordings").description("Manage Zoom recordings");
+  recordings.command("list").description("List Zoom recordings").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.recordings.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  recordings.command("get <id>").description("Get Zoom recording details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.recordings.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  const webinar = zoom.command("webinar").description("Manage Zoom webinars");
+  webinar.command("create").description("Create a Zoom webinar").requiredOption("--topic <topic>", "Webinar topic").option("--duration <minutes>", "Duration in minutes", "60").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.webinars.create({
+        topic: opts.topic,
+        duration: parseInt(opts.duration)
+      });
+      console.log(chalk27.green(`Webinar created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  webinar.command("list").description("List Zoom webinars").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.zoom.webinars.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/vault/index.ts
+import chalk28 from "chalk";
+function registerVaultCommands(program) {
+  const vault = program.command("vault").description("Recording vault and archive management");
+  const recordings = vault.command("recordings").description("Manage vault recordings");
+  recordings.command("list").description("List recordings in the vault").option("--limit <n>", "Maximum results", "20").option("--status <status>", "Filter by status (active, archived)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const params = {
+        limit: parseInt(opts.limit)
+      };
+      if (opts.status) params.status = opts.status;
+      const result = await client.vault.recordings.list(params);
+      formatOutput(result.data, program.opts());
+    })
+  );
+  recordings.command("get <id>").description("Get recording details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.vault.recordings.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  recordings.command("delete <id>").description("Delete a recording from the vault").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive(
+        "permanently delete",
+        `recording ${id}`,
+        program.opts()
+      );
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.vault.recordings.delete(id);
+      console.log(chalk28.green(`Recording ${id} deleted.`));
+    })
+  );
+  vault.command("archive <id>").description("Archive a recording to cold storage").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.vault.archive(id);
+      console.log(chalk28.green(`Recording ${id} archived.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  vault.command("restore <id>").description("Restore an archived recording").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.vault.restore(id);
+      console.log(chalk28.green(`Recording ${id} restoration started.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/marketplace/index.ts
+import chalk29 from "chalk";
+function registerMarketplaceCommands(program) {
+  const marketplace = program.command("marketplace").description("WAVE marketplace for plugins and extensions");
+  marketplace.command("search").description("Search the marketplace").requiredOption("--q <query>", "Search query").option("--category <category>", "Filter by category").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.marketplace.search({
+        q: opts.q,
+        category: opts.category,
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  marketplace.command("install <id>").description("Install a marketplace extension").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.marketplace.install(id);
+      console.log(chalk29.green(`Extension ${id} installed.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  marketplace.command("publish").description("Publish an extension to the marketplace").option("--path <path>", "Path to extension package", ".").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.marketplace.publish({ path: opts.path });
+      console.log(chalk29.green("Extension published successfully."));
+      formatOutput(result, program.opts());
+    })
+  );
+  marketplace.command("list").description("List installed extensions").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.marketplace.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/connect/index.ts
+import chalk30 from "chalk";
+function registerConnectCommands(program) {
+  const connect = program.command("connect").description("Third-party integrations and connectors");
+  connect.command("integrations").description("List available integrations").option("--limit <n>", "Maximum results", "50").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.connect.integrations({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  connect.command("configure <id>").description("Configure an integration").option("--settings <json>", "JSON settings for the integration").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const settings = opts.settings ? JSON.parse(opts.settings) : void 0;
+      const result = await client.connect.configure(id, { settings });
+      console.log(chalk30.green(`Integration ${id} configured.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  connect.command("status <id>").description("Get integration connection status").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.connect.status(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  connect.command("disconnect <id>").description("Disconnect an integration").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive(
+        "disconnect",
+        `integration ${id}`,
+        program.opts()
+      );
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.connect.disconnect(id);
+      console.log(chalk30.green(`Integration ${id} disconnected.`));
+    })
+  );
+}
+
+// src/commands/distribution/index.ts
+import chalk31 from "chalk";
+function registerDistributionCommands(program) {
+  const distribution = program.command("distribution").description("Multi-platform stream distribution");
+  distribution.command("simulcast").description("Set up simulcast for a stream").requiredOption("--stream-id <streamId>", "Stream ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.distribution.simulcast({
+        streamId: opts.streamId
+      });
+      console.log(chalk31.green("Simulcast configured."));
+      formatOutput(result, program.opts());
+    })
+  );
+  const destinations = distribution.command("destinations").description("Manage distribution destinations");
+  destinations.command("list").description("List distribution destinations").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.distribution.destinations.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  destinations.command("add").description("Add a distribution destination").requiredOption("--platform <platform>", "Platform (youtube, twitch, facebook, custom)").requiredOption("--stream-key <key>", "Stream key for the platform").option("--url <url>", "Custom RTMP URL").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.distribution.destinations.add({
+        platform: opts.platform,
+        streamKey: opts.streamKey,
+        url: opts.url
+      });
+      console.log(chalk31.green(`Destination added: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  destinations.command("remove <id>").description("Remove a distribution destination").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("remove", `destination ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.distribution.destinations.remove(id);
+      console.log(chalk31.green(`Destination ${id} removed.`));
+    })
+  );
+}
+
+// src/commands/desktop/index.ts
+import chalk32 from "chalk";
+function registerDesktopCommands(program) {
+  const desktop = program.command("desktop").description("Desktop node management and pairing");
+  desktop.command("nodes").description("List connected desktop nodes").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.desktop.nodes();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  desktop.command("pair").description("Pair a desktop node").requiredOption("--code <code>", "Pairing code from the desktop application").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.desktop.pair({ code: opts.code });
+      console.log(chalk32.green("Desktop node paired successfully."));
+      formatOutput(result, program.opts());
+    })
+  );
+  desktop.command("status <id>").description("Get desktop node status").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.desktop.status(id);
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/signage/index.ts
+import chalk33 from "chalk";
+function registerSignageCommands(program) {
+  const signage = program.command("signage").description("Digital signage management");
+  const displays = signage.command("displays").description("Manage signage displays");
+  displays.command("list").description("List registered displays").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.signage.displays.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  displays.command("register").description("Register a new display").requiredOption("--name <name>", "Display name").option("--location <location>", "Physical location").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.signage.displays.register({
+        name: opts.name,
+        location: opts.location
+      });
+      console.log(chalk33.green(`Display registered: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  const content = signage.command("content").description("Manage signage content");
+  content.command("upload").description("Upload content for signage").requiredOption("--file <path>", "Path to content file").option("--name <name>", "Content name").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.signage.content.upload({
+        file: opts.file,
+        name: opts.name
+      });
+      console.log(chalk33.green(`Content uploaded: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  content.command("list").description("List signage content").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.signage.content.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  content.command("delete <id>").description("Delete signage content").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("delete", `content ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.signage.content.delete(id);
+      console.log(chalk33.green(`Content ${id} deleted.`));
+    })
+  );
+  const schedule = signage.command("schedule").description("Manage content schedules");
+  schedule.command("create").description("Create a content schedule").requiredOption("--display-id <displayId>", "Target display ID").requiredOption("--content-id <contentId>", "Content ID to schedule").option("--start <datetime>", "Start datetime (ISO 8601)").option("--end <datetime>", "End datetime (ISO 8601)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.signage.schedules.create({
+        displayId: opts.displayId,
+        contentId: opts.contentId,
+        start: opts.start,
+        end: opts.end
+      });
+      console.log(chalk33.green(`Schedule created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  schedule.command("list").description("List content schedules").option("--display-id <displayId>", "Filter by display ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.signage.schedules.list({
+        displayId: opts.displayId
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/qr/index.ts
+import chalk34 from "chalk";
+function registerQrCommands(program) {
+  const qr = program.command("qr").description("QR code generation and scanning");
+  qr.command("create").description("Generate a QR code").requiredOption("--data <data>", "Data to encode in the QR code").option("--format <format>", "Output format (png, svg)", "png").option("--size <size>", "QR code size in pixels", "256").option("--output <path>", "Output file path").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.qr.create({
+        data: opts.data,
+        format: opts.format,
+        size: parseInt(opts.size),
+        output: opts.output
+      });
+      console.log(chalk34.green("QR code generated."));
+      formatOutput(result, program.opts());
+    })
+  );
+  qr.command("scan").description("Scan a QR code from an image").requiredOption("--image-path <path>", "Path to image file containing QR code").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.qr.scan({ imagePath: opts.imagePath });
+      formatOutput(result, program.opts());
+    })
+  );
+  qr.command("list").description("List generated QR codes").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.qr.list({ limit: parseInt(opts.limit) });
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/audience/index.ts
+import chalk35 from "chalk";
+function registerAudienceCommands(program) {
+  const audience = program.command("audience").description("Audience engagement tools");
+  const polls = audience.command("polls").description("Manage audience polls");
+  polls.command("create").description("Create an audience poll").requiredOption("--question <question>", "Poll question").requiredOption("--options <options>", "Comma-separated poll options").option("--stream-id <streamId>", "Attach to a stream").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const options = opts.options.split(",").map((o) => o.trim());
+      const result = await client.audience.polls.create({
+        question: opts.question,
+        options,
+        streamId: opts.streamId
+      });
+      console.log(chalk35.green(`Poll created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  polls.command("list").description("List polls").option("--stream-id <streamId>", "Filter by stream ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.polls.list({
+        streamId: opts.streamId
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  polls.command("results <id>").description("Get poll results").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.polls.results(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  polls.command("close <id>").description("Close an active poll").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.polls.close(id);
+      console.log(chalk35.green(`Poll ${id} closed.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  const questions = audience.command("questions").description("Manage audience Q&A");
+  questions.command("create").description("Open a Q&A session").option("--stream-id <streamId>", "Attach to a stream").option("--moderated", "Enable moderation", false).action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.questions.create({
+        streamId: opts.streamId,
+        moderated: opts.moderated
+      });
+      console.log(chalk35.green(`Q&A session created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  questions.command("list").description("List questions in a Q&A session").requiredOption("--session-id <sessionId>", "Q&A session ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.questions.list({
+        sessionId: opts.sessionId
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  const reactions = audience.command("reactions").description("Manage audience reactions");
+  reactions.command("enable").description("Enable reactions for a stream").requiredOption("--stream-id <streamId>", "Stream ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.reactions.enable({
+        streamId: opts.streamId
+      });
+      console.log(chalk35.green("Reactions enabled."));
+      formatOutput(result, program.opts());
+    })
+  );
+  reactions.command("disable").description("Disable reactions for a stream").requiredOption("--stream-id <streamId>", "Stream ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.audience.reactions.disable({
+        streamId: opts.streamId
+      });
+      console.log(chalk35.green("Reactions disabled."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/creator/index.ts
+import chalk36 from "chalk";
+function registerCreatorCommands(program) {
+  const creator = program.command("creator").description("Creator monetization and analytics");
+  creator.command("revenue").description("View revenue summary").option("--period <period>", "Time period (day, week, month)", "month").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.creator.revenue({ period: opts.period });
+      formatOutput(result, program.opts());
+    })
+  );
+  const payouts = creator.command("payouts").description("Manage payouts");
+  payouts.command("list").description("List payout history").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.creator.payouts.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  payouts.command("request").description("Request a payout").option("--amount <amount>", "Payout amount (uses full balance if omitted)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const params = {};
+      if (opts.amount) params.amount = parseFloat(opts.amount);
+      const result = await client.creator.payouts.request(params);
+      console.log(chalk36.green("Payout requested."));
+      formatOutput(result, program.opts());
+    })
+  );
+  creator.command("analytics").description("View creator analytics").option("--period <period>", "Time period (day, week, month)", "month").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.creator.analytics({ period: opts.period });
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/podcast/index.ts
+import chalk37 from "chalk";
+function registerPodcastCommands(program) {
+  const podcast = program.command("podcast").description("Podcast management");
+  const episodes = podcast.command("episodes").description("Manage podcast episodes");
+  episodes.command("create").description("Create a podcast episode").requiredOption("--title <title>", "Episode title").option("--description <desc>", "Episode description").option("--audio <path>", "Path to audio file").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.podcast.episodes.create({
+        title: opts.title,
+        description: opts.description,
+        audioPath: opts.audio
+      });
+      console.log(chalk37.green(`Episode created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  episodes.command("list").description("List podcast episodes").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.podcast.episodes.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  episodes.command("get <id>").description("Get episode details").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.podcast.episodes.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  episodes.command("publish <id>").description("Publish a podcast episode").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.podcast.episodes.publish(id);
+      console.log(chalk37.green(`Episode ${id} published.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  episodes.command("delete <id>").description("Delete a podcast episode").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("delete", `episode ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.podcast.episodes.delete(id);
+      console.log(chalk37.green(`Episode ${id} deleted.`));
+    })
+  );
+  const rss = podcast.command("rss").description("Manage podcast RSS feed");
+  rss.command("generate").description("Generate an RSS feed").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.podcast.rss.generate();
+      console.log(chalk37.green("RSS feed generated."));
+      formatOutput(result, program.opts());
+    })
+  );
+  rss.command("get").description("Get the current RSS feed URL").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.podcast.rss.get();
+      formatOutput(result, program.opts());
+    })
+  );
+  podcast.command("distribute").description("Distribute podcast to platforms").option("--platforms <platforms>", "Comma-separated platforms (spotify, apple, google)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const platforms = opts.platforms ? opts.platforms.split(",").map((p) => p.trim()) : void 0;
+      const result = await client.podcast.distribute({ platforms });
+      console.log(chalk37.green("Distribution initiated."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/slides/index.ts
+import chalk38 from "chalk";
+function registerSlidesCommands(program) {
+  const slides = program.command("slides").description("Slide presentation tools");
+  slides.command("convert").description("Convert a presentation file for streaming").requiredOption("--input-file <path>", "Path to presentation file (pptx, pdf, keynote)").option("--output <path>", "Output directory").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.slides.convert({
+        inputFile: opts.inputFile,
+        output: opts.output
+      });
+      console.log(chalk38.green("Presentation converted."));
+      formatOutput(result, program.opts());
+    })
+  );
+  slides.command("present").description("Start a slide presentation in a production").requiredOption("--production-id <productionId>", "Production ID").option("--slide-deck <id>", "Slide deck ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.slides.present({
+        productionId: opts.productionId,
+        slideDeckId: opts.slideDeck
+      });
+      console.log(chalk38.green("Presentation started."));
+      formatOutput(result, program.opts());
+    })
+  );
+  slides.command("annotate").description("Enable slide annotations").requiredOption("--production-id <productionId>", "Production ID").option("--tool <tool>", "Annotation tool (pen, highlight, pointer)", "pen").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.slides.annotate({
+        productionId: opts.productionId,
+        tool: opts.tool
+      });
+      console.log(chalk38.green("Annotations enabled."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/usb/index.ts
+import chalk39 from "chalk";
+function registerUsbCommands(program) {
+  const usb = program.command("usb").description("USB device relay and management");
+  const relay = usb.command("relay").description("Manage USB relay");
+  relay.command("start").description("Start USB relay for virtual camera/microphone").option("--device <id>", "Specific device ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.usb.relay.start({ deviceId: opts.device });
+      console.log(chalk39.green("USB relay started."));
+      formatOutput(result, program.opts());
+    })
+  );
+  relay.command("stop").description("Stop USB relay").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.usb.relay.stop();
+      console.log(chalk39.green("USB relay stopped."));
+      formatOutput(result, program.opts());
+    })
+  );
+  usb.command("devices").description("List connected USB devices").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.usb.devices.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+  usb.command("configure <id>").description("Configure a USB device").option("--settings <json>", "JSON settings for the device").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const settings = opts.settings ? JSON.parse(opts.settings) : void 0;
+      const result = await client.usb.configure(id, { settings });
+      console.log(chalk39.green(`Device ${id} configured.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/notify/index.ts
+import chalk40 from "chalk";
+function registerNotifyCommands(program) {
+  const notify = program.command("notify").description("Notification management");
+  notify.command("send").description("Send a notification").requiredOption("--to <userId>", "Recipient user ID").requiredOption("--template <templateId>", "Notification template ID").option("--data <json>", "JSON data for template variables").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const data = opts.data ? JSON.parse(opts.data) : void 0;
+      const result = await client.notifications.send({
+        to: opts.to,
+        template: opts.template,
+        data
+      });
+      console.log(chalk40.green("Notification sent."));
+      formatOutput(result, program.opts());
+    })
+  );
+  const templates = notify.command("templates").description("Manage notification templates");
+  templates.command("list").description("List notification templates").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.notifications.templates.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  templates.command("get <id>").description("Get a notification template").action(
+    wrapCommand(async (id) => {
+      const client = await getClient(program.opts());
+      const result = await client.notifications.templates.get(id);
+      formatOutput(result, program.opts());
+    })
+  );
+  templates.command("create").description("Create a notification template").requiredOption("--name <name>", "Template name").requiredOption("--body <body>", "Template body").option("--subject <subject>", "Template subject (for email)").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.notifications.templates.create({
+        name: opts.name,
+        body: opts.body,
+        subject: opts.subject
+      });
+      console.log(chalk40.green(`Template created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  const channels = notify.command("channels").description("Manage notification channels");
+  channels.command("list").description("List notification channels").action(
+    wrapCommand(async () => {
+      const client = await getClient(program.opts());
+      const result = await client.notifications.channels.list();
+      formatOutput(result.data, program.opts());
+    })
+  );
+}
+
+// src/commands/drm/index.ts
+import chalk41 from "chalk";
+function registerDrmCommands(program) {
+  const drm = program.command("drm").description("Digital rights management");
+  const licenses = drm.command("licenses").description("Manage DRM licenses");
+  licenses.command("list").description("List DRM licenses").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.drm.licenses.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  licenses.command("create").description("Create a DRM license").requiredOption("--content-id <contentId>", "Content ID").requiredOption("--policy-id <policyId>", "Policy ID").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.drm.licenses.create({
+        contentId: opts.contentId,
+        policyId: opts.policyId
+      });
+      console.log(chalk41.green(`License created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  licenses.command("revoke <id>").description("Revoke a DRM license").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("revoke", `license ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.drm.licenses.revoke(id);
+      console.log(chalk41.green(`License ${id} revoked.`));
+    })
+  );
+  const policies = drm.command("policies").description("Manage DRM policies");
+  policies.command("list").description("List DRM policies").option("--limit <n>", "Maximum results", "20").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const result = await client.drm.policies.list({
+        limit: parseInt(opts.limit)
+      });
+      formatOutput(result.data, program.opts());
+    })
+  );
+  policies.command("create").description("Create a DRM policy").requiredOption("--name <name>", "Policy name").option("--rules <json>", "JSON rules for the policy").action(
+    wrapCommand(async (opts) => {
+      const client = await getClient(program.opts());
+      const rules = opts.rules ? JSON.parse(opts.rules) : void 0;
+      const result = await client.drm.policies.create({
+        name: opts.name,
+        rules
+      });
+      console.log(chalk41.green(`Policy created: ${result.id}`));
+      formatOutput(result, program.opts());
+    })
+  );
+  policies.command("update <id>").description("Update a DRM policy").option("--name <name>", "New policy name").option("--rules <json>", "Updated JSON rules").action(
+    wrapCommand(async (id, opts) => {
+      const client = await getClient(program.opts());
+      const updates = {};
+      if (opts.name) updates.name = opts.name;
+      if (opts.rules) updates.rules = JSON.parse(opts.rules);
+      const result = await client.drm.policies.update(id, updates);
+      console.log(chalk41.green(`Policy ${id} updated.`));
+      formatOutput(result, program.opts());
+    })
+  );
+  policies.command("delete <id>").description("Delete a DRM policy").action(
+    wrapCommand(async (id) => {
+      const confirmed = await confirmDestructive("delete", `policy ${id}`, program.opts());
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      await client.drm.policies.delete(id);
+      console.log(chalk41.green(`Policy ${id} deleted.`));
+    })
+  );
+  const keys = drm.command("keys").description("Manage encryption keys");
+  keys.command("rotate").description("Rotate encryption keys").option("--content-id <contentId>", "Rotate keys for specific content").action(
+    wrapCommand(async (opts) => {
+      const confirmed = await confirmDestructive(
+        "rotate encryption keys for",
+        opts.contentId ?? "all content",
+        program.opts()
+      );
+      if (!confirmed) return;
+      const client = await getClient(program.opts());
+      const result = await client.drm.keys.rotate({
+        contentId: opts.contentId
+      });
+      console.log(chalk41.green("Key rotation initiated."));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/billing/index.ts
+import chalk42 from "chalk";
+async function billingFetch(path, opts) {
+  const config = await loadConfig();
+  const project = config.projects[config.currentProject];
+  const baseUrl = project?.baseUrl ?? process.env["WAVE_BASE_URL"] ?? "https://wave.online";
+  const apiKey = await getApiKey(config.currentProject);
+  if (!apiKey) {
+    throw new Error(`No API key found. Run ${chalk42.bold("wave login")} to authenticate.`);
+  }
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: opts?.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "X-Wave-Source": "cli"
+    },
+    body: opts?.body ? JSON.stringify(opts.body) : void 0
+  });
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({}));
+    throw new Error(error.message ?? `Billing API error: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+function registerBillingCommands(program) {
+  const billing = program.command("billing").description("Billing, usage, and subscription management");
+  billing.command("status").description("Show current billing status and plan").action(
+    wrapCommand(async () => {
+      const result = await billingFetch("/api/billing/status");
+      formatOutput(result, program.opts());
+    })
+  );
+  billing.command("usage").description("Show current usage metrics").option("--period <period>", "Billing period (current, previous)", "current").action(
+    wrapCommand(async (opts) => {
+      const result = await billingFetch(`/api/billing/usage?period=${opts.period}`);
+      formatOutput(result, program.opts());
+    })
+  );
+  billing.command("invoices").description("List billing invoices").option("--limit <n>", "Maximum results", "10").action(
+    wrapCommand(async (opts) => {
+      const result = await billingFetch(`/api/billing/invoices?limit=${opts.limit}`);
+      formatOutput(result, program.opts());
+    })
+  );
+  billing.command("limits").description("Show current usage limits").action(
+    wrapCommand(async () => {
+      const result = await billingFetch("/api/billing/limits");
+      formatOutput(result, program.opts());
+    })
+  );
+  billing.command("portal").description("Open the billing portal in your browser").action(
+    wrapCommand(async () => {
+      const result = await billingFetch("/api/billing/portal", {
+        method: "POST"
+      });
+      const open2 = (await import("open")).default;
+      await open2(result.url);
+      console.log(chalk42.green("Billing portal opened in your browser."));
+    })
+  );
+  billing.command("upgrade").description("View available upgrade options").action(
+    wrapCommand(async () => {
+      const result = await billingFetch("/api/billing/plans");
+      formatOutput(result, program.opts());
+      console.log(chalk42.gray("\nTo upgrade, visit the billing portal: wave billing portal"));
+    })
+  );
+}
+
+// src/commands/listen/index.ts
+import chalk43 from "chalk";
+
+// src/lib/sse-client.ts
+async function connectSSE(url, apiKey, options) {
+  const controller = new AbortController();
+  const maxAttempts = options.maxReconnectAttempts ?? 10;
+  const initialDelay = options.initialReconnectDelay ?? 1e3;
+  const maxDelay = options.maxReconnectDelay ?? 3e4;
+  let reconnectAttempts = 0;
+  let lastEventId;
+  const cleanup = () => {
+    controller.abort();
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  async function connect() {
+    if (controller.signal.aborted) return;
+    try {
+      const headers = {
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache",
+        Authorization: `Bearer ${apiKey}`
+      };
+      if (lastEventId) {
+        headers["Last-Event-ID"] = lastEventId;
+      }
+      const response = await fetch(url, {
+        headers,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("SSE response has no body");
+      }
+      reconnectAttempts = 0;
+      options.onConnect?.();
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentEvent = {};
+      while (!controller.signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line === "") {
+            if (currentEvent.data !== void 0) {
+              const event = {
+                id: currentEvent.id,
+                event: currentEvent.event,
+                data: currentEvent.data,
+                retry: currentEvent.retry
+              };
+              if (event.id) {
+                lastEventId = event.id;
+              }
+              options.onEvent(event);
+            }
+            currentEvent = {};
+          } else if (line.startsWith(":")) {
+          } else if (line.startsWith("data:")) {
+            const value2 = line.slice(5).trimStart();
+            currentEvent.data = currentEvent.data !== void 0 ? `${currentEvent.data}
+${value2}` : value2;
+          } else if (line.startsWith("event:")) {
+            currentEvent.event = line.slice(6).trimStart();
+          } else if (line.startsWith("id:")) {
+            currentEvent.id = line.slice(3).trimStart();
+          } else if (line.startsWith("retry:")) {
+            const retry = parseInt(line.slice(6).trimStart(), 10);
+            if (!isNaN(retry)) {
+              currentEvent.retry = retry;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (controller.signal.aborted) {
+        options.onClose?.();
+        return;
+      }
+      const err = error instanceof Error ? error : new Error(String(error));
+      options.onError?.(err);
+      if (reconnectAttempts < maxAttempts) {
+        reconnectAttempts++;
+        const delay = Math.min(initialDelay * Math.pow(2, reconnectAttempts - 1), maxDelay);
+        await new Promise((resolve4) => setTimeout(resolve4, delay));
+        if (!controller.signal.aborted) {
+          return connect();
+        }
+      } else {
+        options.onError?.(new Error(`Max reconnect attempts (${maxAttempts}) exceeded`));
+        options.onClose?.();
+      }
+    }
+  }
+  connect().catch((error) => {
+    const err = error instanceof Error ? error : new Error(String(error));
+    options.onError?.(err);
+  });
+  controller.signal.addEventListener("abort", () => {
+    process.removeListener("SIGINT", cleanup);
+    process.removeListener("SIGTERM", cleanup);
+  });
+  return controller;
+}
+
+// src/commands/listen/index.ts
+function registerListenCommands(program) {
+  program.command("listen").description("Listen for webhook events from WAVE").option("--forward-to <url>", "URL to forward events to", "http://localhost:3000/webhooks/wave").option("--events <pattern>", "Event pattern to listen for (e.g., stream.*)").action(
+    wrapCommand(async (opts) => {
+      const config = await loadConfig();
+      const apiKey = await getApiKey(config.currentProject);
+      if (!apiKey) {
+        console.error(chalk43.red("Not authenticated. Run `wave login` first."));
+        process.exit(1);
+      }
+      const baseUrl = config.projects[config.currentProject]?.baseUrl ?? "https://wave.online";
+      const params = new URLSearchParams();
+      if (opts.events) params.set("events", opts.events);
+      const url = `${baseUrl}/api/webhooks/listen${params.toString() ? `?${params}` : ""}`;
+      console.log(chalk43.bold("WAVE Event Listener\n"));
+      console.log(`  Forward URL:  ${chalk43.cyan(opts.forwardTo)}`);
+      if (opts.events) console.log(`  Event filter: ${chalk43.cyan(opts.events)}`);
+      console.log("");
+      let eventCount = 0;
+      const controller = await connectSSE(url, apiKey, {
+        onConnect() {
+          console.log(chalk43.green("  Connected to event stream."));
+          console.log(chalk43.gray("  Waiting for events... (Ctrl+C to stop)\n"));
+        },
+        onEvent(event) {
+          if (event.event === "connected" || event.event === "timeout") return;
+          if (event.event === "webhook") {
+            eventCount++;
+            const data = JSON.parse(event.data);
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+            const eventType = String(data.type ?? "unknown");
+            console.log(`${chalk43.gray(timestamp)} ${chalk43.cyan(`[${eventType}]`)} ${chalk43.white(JSON.stringify(data).slice(0, 120))}`);
+            fetch(opts.forwardTo, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(data)
+            }).catch((err) => {
+              const msg = err instanceof Error ? err.message : String(err);
+              console.error(chalk43.red(`  Forward failed: ${msg}`));
+            });
+          }
+        },
+        onError(error) {
+          console.error(chalk43.red(`  Connection error: ${error.message}`));
+        },
+        onClose() {
+          console.log(chalk43.gray(`
+  Disconnected. ${eventCount} events received.`));
+        }
+      });
+      await new Promise((resolve4) => {
+        controller.signal.addEventListener("abort", () => resolve4());
+      });
+    })
+  );
+}
+
+// src/commands/logs/index.ts
+import chalk44 from "chalk";
+var LEVEL_COLORS = {
+  debug: chalk44.gray,
+  info: chalk44.white,
+  warn: chalk44.yellow,
+  error: chalk44.red
+};
+function registerLogsCommands(program) {
+  const logs = program.command("logs").description("Stream application logs");
+  logs.command("tail").description("Tail logs in real-time").option("--stream <id>", "Filter by stream ID").option("--level <level>", "Minimum log level (debug, info, warn, error)", "info").option("--since <duration>", "Show logs since duration (e.g., 5m, 1h)", "5m").action(
+    wrapCommand(async (opts) => {
+      const config = await loadConfig();
+      const apiKey = await getApiKey(config.currentProject);
+      if (!apiKey) {
+        console.error(
+          chalk44.red("Not authenticated. Run `wave login` first.")
+        );
+        process.exit(1);
+      }
+      const baseUrl = config.projects[config.currentProject]?.baseUrl ?? "https://wave.online";
+      const params = new URLSearchParams();
+      params.set("level", opts.level);
+      if (opts.stream) params.set("stream", opts.stream);
+      if (opts.since) params.set("since", opts.since);
+      const url = `${baseUrl}/api/logs/stream?${params}`;
+      console.log(chalk44.bold("WAVE Log Tail\n"));
+      console.log(`  Level: ${chalk44.cyan(opts.level)}`);
+      console.log(`  Since: ${chalk44.cyan(opts.since)}`);
+      if (opts.stream) {
+        console.log(`  Stream: ${chalk44.cyan(opts.stream)}`);
+      }
+      console.log("");
+      let logCount = 0;
+      const controller = await connectSSE(url, apiKey, {
+        onConnect() {
+          console.log(chalk44.green("  Connected to log stream."));
+          console.log(chalk44.gray("  Tailing logs... (Ctrl+C to stop)\n"));
+        },
+        onEvent(event) {
+          if (event.event === "connected" || event.event === "timeout") {
+            return;
+          }
+          if (event.event === "log") {
+            logCount++;
+            const data = JSON.parse(event.data);
+            const level = String(data.level ?? "info");
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+            const message = String(data.message ?? "");
+            const colorFn = LEVEL_COLORS[level] ?? chalk44.white;
+            console.log(
+              `${chalk44.gray(timestamp)} ${colorFn(level.toUpperCase().padEnd(5))} ${message}`
+            );
+          }
+        },
+        onError(error) {
+          console.error(chalk44.red(`  Connection error: ${error.message}`));
+        },
+        onClose() {
+          console.log(chalk44.gray(`
+  Disconnected. ${logCount} log entries received.`));
+        }
+      });
+      await new Promise((resolve4) => {
+        controller.signal.addEventListener("abort", () => resolve4());
+      });
+    })
+  );
+}
+
+// src/commands/trigger/index.ts
+import chalk45 from "chalk";
+function registerTriggerCommands(program) {
+  program.command("trigger <event>").description("Trigger a WAVE event manually").option("--override <pairs...>", "Override event data (key=value pairs)").option("--list", "List available trigger events").action(
+    wrapCommand(async (event, opts) => {
+      const config = await loadConfig();
+      const project = config.projects[config.currentProject];
+      const baseUrl = project?.baseUrl ?? process.env["WAVE_BASE_URL"] ?? "https://wave.online";
+      const apiKey = await getApiKey(config.currentProject);
+      if (!apiKey) {
+        throw new Error(`No API key found. Run ${chalk45.bold("wave login")} to authenticate.`);
+      }
+      if (opts.list) {
+        const res2 = await fetch(`${baseUrl}/api/cli/trigger`, {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "X-Wave-Source": "cli"
+          }
+        });
+        if (!res2.ok) throw new Error(`Failed to list events: ${res2.statusText}`);
+        const events = await res2.json();
+        formatOutput(events, program.opts());
+        return;
+      }
+      const overrides = {};
+      if (opts.override) {
+        for (const pair of opts.override) {
+          const [key, ...valueParts] = pair.split("=");
+          if (key && valueParts.length > 0) {
+            overrides[key] = valueParts.join("=");
+          }
+        }
+      }
+      const res = await fetch(`${baseUrl}/api/cli/trigger`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+          "X-Wave-Source": "cli"
+        },
+        body: JSON.stringify({ event, data: overrides })
+      });
+      if (!res.ok) {
+        const error = await res.json().catch(() => ({}));
+        throw new Error(error.message ?? `Failed to trigger event: ${res.statusText}`);
+      }
+      const result = await res.json();
+      console.log(chalk45.green(`Event "${event}" triggered.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/dev/index.ts
+import chalk46 from "chalk";
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, resolve } from "path";
+var LEVEL_COLORS2 = {
+  debug: chalk46.gray,
+  info: chalk46.white,
+  warn: chalk46.yellow,
+  error: chalk46.red
+};
+async function loadProjectConfig() {
+  const projectJsonPath = join3(resolve(process.cwd()), ".wave", "project.json");
+  if (!existsSync3(projectJsonPath)) {
+    return null;
+  }
+  try {
+    const raw = await readFile3(projectJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.projectId === "string" && typeof parsed.organizationId === "string" && typeof parsed.projectName === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function detectLocalPort() {
+  const pkgPath = join3(resolve(process.cwd()), "package.json");
+  if (!existsSync3(pkgPath)) {
+    return 3e3;
+  }
+  try {
+    const raw = await readFile3(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const scripts = pkg.scripts;
+    if (!scripts) return 3e3;
+    const devScript = scripts.dev ?? scripts.start ?? "";
+    const portMatch = devScript.match(
+      /(?:--port\s+|(?:^|\s)-p\s+|PORT=|:)(\d{4,5})/
+    );
+    if (portMatch) {
+      const port = parseInt(portMatch[1], 10);
+      if (port > 0 && port < 65536) return port;
+    }
+    return 3e3;
+  } catch {
+    return 3e3;
+  }
+}
+function registerDevCommands(program) {
+  program.command("dev").description(
+    "Start unified development proxy (webhook forwarding + log streaming)"
+  ).option(
+    "--forward-to <url>",
+    "URL to forward webhook events to (overrides auto-detected port)"
+  ).option("--port <number>", "Local server port (overrides auto-detection)").option(
+    "--log-level <level>",
+    "Minimum log level (debug, info, warn, error)",
+    "info"
+  ).option("--events <pattern>", "Event pattern to filter (e.g., stream.*)").action(
+    wrapCommand(async (opts) => {
+      const config = await loadConfig();
+      const apiKey = await getApiKey(config.currentProject);
+      if (!apiKey) {
+        console.error(
+          chalk46.red("Not authenticated. Run `wave login` first.")
+        );
+        process.exit(1);
+      }
+      const baseUrl = config.projects[config.currentProject]?.baseUrl ?? "https://wave.online";
+      const projectConfig = await loadProjectConfig();
+      let forwardUrl;
+      if (opts.forwardTo) {
+        forwardUrl = opts.forwardTo;
+      } else {
+        const port = opts.port ? parseInt(opts.port, 10) : await detectLocalPort();
+        forwardUrl = `http://localhost:${port}/webhooks/wave`;
+      }
+      console.log(chalk46.bold("WAVE Development Mode\n"));
+      if (projectConfig) {
+        console.log(
+          `  Project:            ${chalk46.cyan(projectConfig.projectName)} ${chalk46.dim(`(${projectConfig.projectId})`)}`
+        );
+      } else {
+        console.log(
+          chalk46.dim(
+            "  No .wave/project.json found. Run `wave link` to connect a project."
+          )
+        );
+      }
+      console.log(
+        `  Webhook forwarding: ${chalk46.cyan(forwardUrl)}`
+      );
+      console.log(
+        `  Log level:          ${chalk46.cyan(opts.logLevel)}`
+      );
+      if (opts.events) {
+        console.log(
+          `  Event filter:       ${chalk46.cyan(opts.events)}`
+        );
+      }
+      console.log("");
+      console.log(chalk46.dim("  Starting development proxy...\n"));
+      let webhookCount = 0;
+      let logCount = 0;
+      let errorCount = 0;
+      const webhookParams = new URLSearchParams();
+      if (opts.events) webhookParams.set("events", opts.events);
+      const webhookUrl = `${baseUrl}/api/webhooks/listen${webhookParams.toString() ? `?${webhookParams}` : ""}`;
+      const webhookController = await connectSSE(webhookUrl, apiKey, {
+        onConnect() {
+          console.log(
+            chalk46.green("  [webhook] Connected to event stream")
+          );
+        },
+        onEvent(event) {
+          if (event.event === "connected" || event.event === "timeout")
+            return;
+          if (event.event === "webhook") {
+            webhookCount++;
+            const data = JSON.parse(event.data);
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+            const eventType = String(data.type ?? "unknown");
+            console.log(
+              `${chalk46.gray(timestamp)} ${chalk46.magenta("[webhook]")} ${chalk46.cyan(eventType)} ${chalk46.white(JSON.stringify(data).slice(0, 100))}`
+            );
+            fetch(forwardUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(data)
+            }).catch((err) => {
+              const msg = err instanceof Error ? err.message : String(err);
+              console.error(
+                `${chalk46.gray((/* @__PURE__ */ new Date()).toISOString().slice(11, 23))} ${chalk46.red("[error]")}   Forward failed: ${msg}`
+              );
+              errorCount++;
+            });
+          }
+        },
+        onError(error) {
+          console.error(
+            chalk46.red(`  [webhook] Error: ${error.message}`)
+          );
+          errorCount++;
+        }
+      });
+      const logParams = new URLSearchParams();
+      logParams.set("level", opts.logLevel);
+      const logUrl = `${baseUrl}/api/logs/stream?${logParams}`;
+      const logController = await connectSSE(logUrl, apiKey, {
+        onConnect() {
+          console.log(
+            chalk46.green("  [log]     Connected to log stream")
+          );
+          console.log(chalk46.gray("\n  Ready. Ctrl+C to stop.\n"));
+        },
+        onEvent(event) {
+          if (event.event === "connected" || event.event === "timeout")
+            return;
+          if (event.event === "log") {
+            logCount++;
+            const data = JSON.parse(event.data);
+            const level = String(data.level ?? "info");
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+            const message = String(data.message ?? "");
+            const colorFn = LEVEL_COLORS2[level] ?? chalk46.white;
+            console.log(
+              `${chalk46.gray(timestamp)} ${chalk46.blue("[log]")}     ${colorFn(level.toUpperCase().padEnd(5))} ${message}`
+            );
+          }
+        },
+        onError(error) {
+          console.error(
+            chalk46.red(`  [log]     Error: ${error.message}`)
+          );
+          errorCount++;
+        }
+      });
+      await new Promise((resolve4) => {
+        const done = () => {
+          webhookController.abort();
+          logController.abort();
+          resolve4();
+        };
+        process.on("SIGINT", done);
+        process.on("SIGTERM", done);
+      });
+      console.log(
+        chalk46.gray(
+          `
+  Session ended. ${webhookCount} webhook events, ${logCount} log entries, ${errorCount} errors.`
+        )
+      );
+    })
+  );
+}
+
+// src/commands/open/index.ts
+import chalk47 from "chalk";
+var PAGE_MAP = {
+  dashboard: "https://wave.online/dashboard",
+  streams: "https://wave.online/dashboard/streams",
+  studio: "https://wave.online/dashboard/production",
+  settings: "https://wave.online/dashboard/settings",
+  billing: "https://wave.online/dashboard/settings/billing",
+  api: "https://wave.online/dashboard/settings/api-keys",
+  docs: "https://docs.wave.online",
+  status: "https://status.wave.online",
+  marketplace: "https://wave.online/marketplace",
+  fleet: "https://wave.online/dashboard/fleet",
+  analytics: "https://wave.online/dashboard/analytics",
+  recordings: "https://wave.online/dashboard/recordings",
+  integrations: "https://wave.online/dashboard/integrations"
+};
+function registerOpenCommands(program) {
+  program.command("open [page]").description("Open WAVE pages in your browser").action(
+    wrapCommand(async (page) => {
+      if (!page) {
+        console.log(chalk47.bold("Available pages:\n"));
+        for (const [name, url2] of Object.entries(PAGE_MAP)) {
+          console.log(`  ${chalk47.cyan(name.padEnd(16))} ${chalk47.gray(url2)}`);
+        }
+        console.log(chalk47.gray(`
+Usage: wave open <page>`));
+        return;
+      }
+      const url = PAGE_MAP[page.toLowerCase()];
+      if (!url) {
+        console.error(
+          chalk47.red(
+            `Unknown page "${page}". Run ${chalk47.bold("wave open")} to see available pages.`
+          )
+        );
+        process.exit(1);
+      }
+      const open2 = (await import("open")).default;
+      await open2(url);
+      console.log(chalk47.green(`Opened ${url}`));
+    })
+  );
+}
+
+// src/commands/init/index.ts
+import chalk48 from "chalk";
+import { writeFile as writeFile3, mkdir as mkdir3, readFile as readFile4, readdir, copyFile } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
+
+// src/lib/prompts.ts
+import inquirer2 from "inquirer";
+function isNonInteractive() {
+  return Boolean(process.env["CI"]) || Boolean(process.env["WAVE_NON_INTERACTIVE"]) || !process.stdin.isTTY;
+}
+async function promptSelect(message, choices) {
+  if (isNonInteractive()) {
+    const first = choices[0];
+    if (!first) {
+      throw new Error(
+        `Cannot prompt in non-interactive mode and no choices provided for: ${message}`
+      );
+    }
+    return first.value;
+  }
+  const { selection } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "selection",
+      message,
+      choices
+    }
+  ]);
+  return selection;
+}
+async function promptInput(message, defaultValue) {
+  if (isNonInteractive()) {
+    if (defaultValue !== void 0) {
+      return defaultValue;
+    }
+    throw new Error(
+      `Cannot prompt in non-interactive mode and no default provided for: ${message}`
+    );
+  }
+  const { value } = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "value",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return value;
+}
+async function promptConfirm(message, defaultValue) {
+  if (isNonInteractive()) {
+    return defaultValue ?? false;
+  }
+  const { confirmed } = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: defaultValue ?? false
+    }
+  ]);
+  return confirmed;
+}
+
+// src/commands/init/index.ts
+var TEMPLATES = [
+  {
+    name: "WebRTC Quickstart",
+    description: "Browser-based live streaming with WebRTC",
+    dirName: "webrtc-demo"
+  },
+  {
+    name: "SRT Ingest",
+    description: "Low-latency SRT ingest for professional streaming",
+    dirName: "srt-contribution"
+  },
+  {
+    name: "Webhook Handler",
+    description: "Express server handling WAVE webhooks",
+    dirName: "webhook-handler"
+  },
+  {
+    name: "API Integration",
+    description: "Node.js API integration boilerplate",
+    dirName: "api-integration"
+  },
+  {
+    name: "Studio Plugin",
+    description: "Studio plugin for custom production features",
+    dirName: "studio-plugin"
+  }
+];
+function getTemplatesDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const packageRoot = resolve2(dirname(thisFile), "..", "..", "..");
+  return join4(packageRoot, "templates");
+}
+async function copyDir(src, dest) {
+  await mkdir3(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await copyFile(srcPath, destPath);
+    }
+  }
+}
+async function rewritePackageName(projectDir, projectName) {
+  const pkgPath = join4(projectDir, "package.json");
+  if (!existsSync4(pkgPath)) return;
+  const raw = await readFile4(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+  pkg["name"] = projectName;
+  await writeFile3(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+}
+function registerInitCommands(program) {
+  program.command("init [name]").description("Initialize a new WAVE project").option("--template <template>", "Project template to use (skips interactive picker)").option("--no-install", "Skip dependency installation").action(
+    wrapCommand(async (name, opts) => {
+      let selectedTemplate;
+      if (opts.template) {
+        const match = TEMPLATES.find(
+          (t) => t.dirName === opts.template || t.name.toLowerCase().replace(/\s+/g, "-") === opts.template
+        );
+        if (!match) {
+          const valid = TEMPLATES.map((t) => t.dirName).join(", ");
+          throw new Error(
+            `Unknown template "${opts.template}". Available templates: ${valid}`
+          );
+        }
+        selectedTemplate = match;
+      } else {
+        const choices = TEMPLATES.map((t) => ({
+          name: `${t.name} - ${t.description}`,
+          value: t
+        }));
+        selectedTemplate = await promptSelect(
+          "Choose a template:",
+          choices
+        );
+      }
+      const projectName = name ?? await promptInput("Project name:", "my-wave-project");
+      const dir = join4(process.cwd(), projectName);
+      if (existsSync4(dir)) {
+        throw new Error(
+          `Directory "${projectName}" already exists. Choose a different name or remove the directory.`
+        );
+      }
+      console.log(
+        chalk48.bold(
+          `
+Creating "${projectName}" with ${selectedTemplate.name} template...
+`
+        )
+      );
+      const templatesDir = getTemplatesDir();
+      const templateDir = join4(templatesDir, selectedTemplate.dirName);
+      const resolvedTemplateDir = resolve2(templateDir);
+      const resolvedTemplatesRoot = resolve2(templatesDir);
+      if (!resolvedTemplateDir.startsWith(resolvedTemplatesRoot)) {
+        throw new Error("Invalid template path");
+      }
+      const templateExists = existsSync4(resolvedTemplateDir);
+      await withSpinner(`Creating ${projectName}/`, async () => {
+        if (templateExists) {
+          await copyDir(resolvedTemplateDir, dir);
+        } else {
+          await mkdir3(join4(dir, "src"), { recursive: true });
+        }
+        await rewritePackageName(dir, projectName);
+        const configContent = `import { defineConfig } from "@wave-av/sdk";
+
+export default defineConfig({
+  project: "${projectName}",
+  template: "${selectedTemplate.dirName}",
+  streaming: {
+    protocol: "webrtc",
+    fallback: ["srt", "rtmp"],
+  },
+});
+`;
+        await writeFile3(join4(dir, "wave.config.ts"), configContent, "utf-8");
+        const gitignorePath = join4(dir, ".gitignore");
+        const gitignoreContent = `.env.local
+.wave/
+node_modules/
+dist/
+`;
+        await writeFile3(gitignorePath, gitignoreContent, "utf-8");
+        const readmeContent = `# ${projectName}
+
+Created with [WAVE CLI](https://docs.wave.online/cli) using the **${selectedTemplate.name}** template.
+
+## Getting Started
+
+\`\`\`bash
+# Set your API key
+cp .env.example .env.local
+# Edit .env.local with your WAVE API key from https://wave.online/dashboard/settings/api-keys
+
+# Install dependencies
+npm install
+
+# Run the project
+npm run dev
+\`\`\`
+
+## Learn More
+
+- [WAVE Documentation](https://docs.wave.online)
+- [API Reference](https://docs.wave.online/api)
+- [SDK Reference](https://docs.wave.online/sdk)
+`;
+        await writeFile3(join4(dir, "README.md"), readmeContent, "utf-8");
+      });
+      console.log(chalk48.green(`  Created ${projectName}/`));
+      if (opts.install) {
+        const shouldInstall = await promptConfirm("Install dependencies?", true);
+        if (shouldInstall) {
+          await withSpinner("Installing dependencies", async () => {
+            const result = spawnSync("npm", ["install"], {
+              cwd: dir,
+              stdio: "pipe",
+              shell: false
+            });
+            if (result.status !== 0) {
+              const stderr = result.stderr?.toString() ?? "";
+              throw new Error(`npm install failed: ${stderr}`);
+            }
+          });
+          console.log(chalk48.green("  Installed dependencies"));
+        }
+      }
+      console.log(chalk48.green("\n  Ready!"));
+      console.log(`
+Next steps:`);
+      console.log(`  cd ${projectName}`);
+      if (!opts.install) {
+        console.log(`  npm install`);
+      }
+      console.log(`  wave login`);
+      console.log(`  npm run dev
+`);
+    })
+  );
+}
+
+// src/commands/admin/index.ts
+import chalk49 from "chalk";
+async function adminFetch(path, opts) {
+  const config = await loadConfig();
+  const project = config.projects[config.currentProject];
+  const baseUrl = project?.baseUrl ?? process.env["WAVE_BASE_URL"] ?? "https://wave.online";
+  const apiKey = await getApiKey(config.currentProject);
+  if (!apiKey) {
+    throw new Error(`No API key found. Run ${chalk49.bold("wave login")} to authenticate.`);
+  }
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: opts?.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "X-Wave-Source": "cli"
+    },
+    body: opts?.body ? JSON.stringify(opts.body) : void 0
+  });
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({}));
+    throw new Error(error.message ?? `Admin API error: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+function registerAdminCommands(program) {
+  const admin = program.command("admin").description("Administrative commands (requires admin role)");
+  const jobs = admin.command("jobs").description("Manage background jobs");
+  jobs.command("list").description("List background job functions").option("--status <status>", "Filter by status (active, paused, failed)").action(
+    wrapCommand(async (opts) => {
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      const query = params.toString();
+      const result = await adminFetch(`/api/admin/jobs${query ? `?${query}` : ""}`);
+      formatOutput(result, program.opts());
+    })
+  );
+  jobs.command("trigger <functionId>").description("Manually trigger a background job function").option("--data <json>", "JSON data payload for the job").action(
+    wrapCommand(async (functionId, opts) => {
+      const data = opts.data ? JSON.parse(opts.data) : void 0;
+      const result = await adminFetch(`/api/admin/jobs/${functionId}/trigger`, {
+        method: "POST",
+        body: data ? { data } : void 0
+      });
+      console.log(chalk49.green(`Job "${functionId}" triggered.`));
+      formatOutput(result, program.opts());
+    })
+  );
+}
+
+// src/commands/doctor/index.ts
+import chalk50 from "chalk";
+function registerDoctorCommands(program) {
+  program.command("doctor").description("Check your WAVE CLI setup and diagnose issues").action(
+    wrapCommand(async () => {
+      const checks = [];
+      const nodeVersion = process.version;
+      const major = parseInt(nodeVersion.slice(1).split(".")[0] ?? "0");
+      checks.push({
+        name: "Node.js",
+        status: major >= 18 ? "pass" : "fail",
+        message: `${nodeVersion} ${major >= 18 ? "(supported)" : "(requires >=18)"}`,
+        fix: major < 18 ? "Install Node.js 18+: https://nodejs.org" : void 0
+      });
+      try {
+        const config2 = await loadConfig();
+        checks.push({
+          name: "Config",
+          status: "pass",
+          message: `Loaded (project: ${config2.currentProject})`
+        });
+      } catch {
+        checks.push({
+          name: "Config",
+          status: "warn",
+          message: "Could not load config (using defaults)",
+          fix: "wave config list"
+        });
+      }
+      const config = await loadConfig();
+      const apiKey = await getApiKey(config.currentProject);
+      const envKey = process.env["WAVE_API_KEY"];
+      if (envKey) {
+        checks.push({
+          name: "Auth",
+          status: "pass",
+          message: `WAVE_API_KEY env var set (${envKey.slice(0, 12)}...)`
+        });
+      } else if (apiKey) {
+        checks.push({
+          name: "Auth",
+          status: "pass",
+          message: `API key stored for "${config.currentProject}" (${apiKey.slice(0, 12)}...)`
+        });
+      } else {
+        checks.push({
+          name: "Auth",
+          status: "fail",
+          message: "No API key found",
+          fix: "wave login"
+        });
+      }
+      const projectCount = Object.keys(config.projects).length;
+      checks.push({
+        name: "Projects",
+        status: projectCount > 0 ? "pass" : "warn",
+        message: projectCount > 0 ? `${projectCount} project(s) configured` : "No projects configured",
+        fix: projectCount === 0 ? "wave login --project-name production" : void 0
+      });
+      const env = detectEnvironment();
+      checks.push({
+        name: "Environment",
+        status: "pass",
+        message: [
+          env.isCI ? "CI" : env.isAgent ? `Agent (${env.agentName ?? "unknown"})` : "Interactive",
+          env.supportsColor ? "color" : "no-color",
+          env.preferJson ? "json-mode" : "table-mode"
+        ].join(", ")
+      });
+      checks.push({
+        name: "Telemetry",
+        status: "pass",
+        message: config.telemetry.enabled ? "Enabled (anonymous)" : "Disabled"
+      });
+      const opts = program.opts();
+      if (opts.output === "json") {
+        formatOutput(
+          checks.map((c) => ({ ...c })),
+          opts
+        );
+      } else {
+        console.log(chalk50.bold("\n  WAVE CLI Doctor\n"));
+        for (const check of checks) {
+          const icon = check.status === "pass" ? chalk50.green("\u2713") : check.status === "warn" ? chalk50.yellow("!") : chalk50.red("\u2717");
+          console.log(`  ${icon} ${chalk50.bold(check.name)}: ${check.message}`);
+          if (check.fix) {
+            console.log(`    ${chalk50.dim("Fix:")} ${chalk50.cyan(check.fix)}`);
+          }
+        }
+        const failures = checks.filter((c) => c.status === "fail");
+        const warnings = checks.filter((c) => c.status === "warn");
+        console.log("");
+        if (failures.length === 0 && warnings.length === 0) {
+          console.log(chalk50.green("  All checks passed! You're ready to go."));
+        } else if (failures.length > 0) {
+          console.log(
+            chalk50.red(`  ${failures.length} issue(s) need attention.`)
+          );
+        }
+        console.log("");
+      }
+    })
+  );
+}
+
+// src/commands/status/index.ts
+import chalk51 from "chalk";
+function registerStatusCommands(program) {
+  program.command("status").description("Show WAVE CLI status (auth, API health, current project)").action(
+    wrapCommand(async () => {
+      const config = await loadConfig();
+      const project = config.currentProject || "default";
+      const apiKey = await getApiKey(project);
+      const baseUrl = config.projects[project]?.baseUrl ?? "https://wave.online";
+      const authenticated = !!apiKey;
+      let apiHealthy = false;
+      let apiLatencyMs = null;
+      try {
+        const start = Date.now();
+        const res = await fetch(`${baseUrl}/api/health`, {
+          signal: AbortSignal.timeout(5e3)
+        });
+        apiLatencyMs = Date.now() - start;
+        apiHealthy = res.ok;
+      } catch {
+        apiHealthy = false;
+      }
+      const status = {
+        project,
+        authenticated,
+        organization: config.projects[project]?.organizationName ?? "N/A",
+        apiEndpoint: baseUrl,
+        apiHealthy,
+        apiLatencyMs
+      };
+      console.log(chalk51.bold("\nWAVE CLI Status\n"));
+      console.log(
+        `  Auth:     ${authenticated ? chalk51.green("Authenticated") : chalk51.red("Not authenticated")}`
+      );
+      console.log(`  Project:  ${chalk51.cyan(project)}`);
+      console.log(
+        `  Org:      ${chalk51.cyan(config.projects[project]?.organizationName ?? "N/A")}`
+      );
+      console.log(`  Endpoint: ${chalk51.cyan(baseUrl)}`);
+      console.log(
+        `  API:      ${apiHealthy ? chalk51.green(`Healthy (${apiLatencyMs}ms)`) : chalk51.red("Unreachable")}`
+      );
+      console.log("");
+      if (!authenticated) {
+        console.log(chalk51.yellow("  Run `wave auth login` to authenticate.\n"));
+      }
+      formatOutput(status, program.opts());
+    })
+  );
+}
+
+// src/commands/completion/index.ts
+function registerCompletionCommands(program) {
+  const completion = program.command("completion").description("Generate shell completion scripts");
+  completion.command("bash").description("Generate bash completion script").action(
+    wrapCommand(async () => {
+      console.log(generateBashCompletion(program));
+    })
+  );
+  completion.command("zsh").description("Generate zsh completion script").action(
+    wrapCommand(async () => {
+      console.log(generateZshCompletion(program));
+    })
+  );
+  completion.command("fish").description("Generate fish completion script").action(
+    wrapCommand(async () => {
+      console.log(generateFishCompletion(program));
+    })
+  );
+}
+function getCommandNames(program) {
+  return program.commands.map((cmd) => cmd.name());
+}
+function generateBashCompletion(program) {
+  const commands = getCommandNames(program);
+  return `# WAVE CLI bash completion
+# Add to ~/.bashrc: eval "$(wave completion bash)"
+
+_wave_completions() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  commands="${commands.join(" ")}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+    return 0
+  fi
+
+  # Global options
+  local global_opts="--output --project --org --confirm --color --debug --help --version"
+  COMPREPLY=( $(compgen -W "\${global_opts}" -- "\${cur}") )
+}
+
+complete -F _wave_completions wave`;
+}
+function generateZshCompletion(program) {
+  const commands = getCommandNames(program);
+  const cmdList = commands.map((name) => {
+    const cmd = program.commands.find((c) => c.name() === name);
+    const desc = cmd?.description() ?? name;
+    return `    '${name}:${desc.replace(/'/g, "'\\''")}'`;
+  }).join("\n");
+  return `#compdef wave
+# WAVE CLI zsh completion
+# Add to ~/.zshrc: eval "$(wave completion zsh)"
+
+_wave() {
+  local -a commands
+  commands=(
+${cmdList}
+  )
+
+  _arguments -C \\
+    '--output[Output format]:format:(table json yaml)' \\
+    '--project[Project name]:project:' \\
+    '--org[Organization]:org:' \\
+    '--debug[Enable debug output]' \\
+    '--help[Show help]' \\
+    '--version[Show version]' \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case $state in
+    command)
+      _describe 'command' commands
+      ;;
+  esac
+}
+
+_wave`;
+}
+function generateFishCompletion(program) {
+  const commands = getCommandNames(program);
+  const completions = commands.map((name) => {
+    const cmd = program.commands.find((c) => c.name() === name);
+    const desc = cmd?.description() ?? name;
+    return `complete -c wave -n '__fish_use_subcommand' -a '${name}' -d '${desc.replace(/'/g, "\\'")}'`;
+  }).join("\n");
+  return `# WAVE CLI fish completion
+# Add to ~/.config/fish/completions/wave.fish: wave completion fish | source
+
+# Disable file completions for wave
+complete -c wave -f
+
+# Global options
+complete -c wave -l output -d 'Output format' -a 'table json yaml'
+complete -c wave -l project -d 'Project name'
+complete -c wave -l org -d 'Organization'
+complete -c wave -l debug -d 'Enable debug output'
+complete -c wave -l help -d 'Show help'
+complete -c wave -l version -d 'Show version'
+
+# Commands
+${completions}`;
+}
+
+// src/commands/api/index.ts
+import chalk52 from "chalk";
+function registerApiCommands(program) {
+  program.command("api <method> <path>").description("Make raw API requests (like gh api)").option("-d, --data <json>", "Request body (JSON)").option("-H, --header <header>", "Additional header (key:value)", collectHeaders, []).option("--paginate", "Auto-paginate and collect all results").action(
+    wrapCommand(async (method, path, opts) => {
+      const config = await loadConfig();
+      const project = config.currentProject || "default";
+      const apiKey = await getApiKey(project);
+      if (!apiKey) {
+        console.error(chalk52.red("Not authenticated. Run `wave auth login` first."));
+        process.exit(1);
+      }
+      const baseUrl = config.projects[project]?.baseUrl ?? "https://wave.online";
+      const url = path.startsWith("http") ? path : `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+      const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": "wave-cli/1.0.0"
+      };
+      for (const h of opts.header) {
+        const [key, ...valueParts] = h.split(":");
+        if (key && valueParts.length > 0) {
+          headers[key.trim()] = valueParts.join(":").trim();
+        }
+      }
+      const fetchOpts = {
+        method: method.toUpperCase(),
+        headers
+      };
+      if (opts.data && ["POST", "PUT", "PATCH"].includes(method.toUpperCase())) {
+        fetchOpts.body = opts.data;
+      }
+      const res = await fetch(url, fetchOpts);
+      const contentType = res.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        const data = await res.json();
+        if (!res.ok) {
+          console.error(chalk52.red(`${res.status} ${res.statusText}`));
+          console.error(JSON.stringify(data, null, 2));
+          process.exit(1);
+        }
+        formatOutput(data, program.opts());
+      } else {
+        const text = await res.text();
+        if (!res.ok) {
+          console.error(chalk52.red(`${res.status} ${res.statusText}`));
+          console.error(text);
+          process.exit(1);
+        }
+        console.log(text);
+      }
+    })
+  );
+}
+function collectHeaders(value, previous) {
+  return previous.concat([value]);
+}
+
+// src/commands/link/index.ts
+import chalk53 from "chalk";
+import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile5, appendFile } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
+var CREATE_NEW_PROJECT_VALUE = "__create_new__";
+function registerLinkCommands(program) {
+  program.command("link").description("Link the current directory to a WAVE project").option("--org <id>", "Organization ID (skip org selection prompt)").option("--project <id>", "Project ID (skip project selection prompt)").action(
+    wrapCommand(async (opts) => {
+      const config = await loadConfig();
+      const configProjectName = config.currentProject || "default";
+      const apiKey = await getApiKey(configProjectName);
+      if (!apiKey) {
+        console.error(
+          chalk53.red(
+            `Not authenticated. Run ${chalk53.bold("wave auth login")} first.`
+          )
+        );
+        process.exit(1);
+      }
+      const wave = await getClient({ org: opts.org });
+      const orgs = await withSpinner("Fetching organizations...", async () => {
+        const response = await wave.client.get(
+          "/v1/organizations"
+        );
+        return response.data;
+      });
+      if (!orgs || orgs.length === 0) {
+        console.error(
+          chalk53.red(
+            "No organizations found. Create one at https://wave.online/dashboard/settings/organizations"
+          )
+        );
+        process.exit(1);
+      }
+      let selectedOrg;
+      if (opts.org) {
+        const match = orgs.find((o) => o.id === opts.org);
+        if (!match) {
+          console.error(
+            chalk53.red(
+              `Organization "${opts.org}" not found. Available organizations:
+` + orgs.map((o) => `  ${o.name} (${o.id})`).join("\n")
+            )
+          );
+          process.exit(1);
+        }
+        selectedOrg = match;
+      } else {
+        const orgId = await promptSelect(
+          "Select organization:",
+          orgs.map((o) => ({
+            name: `${o.name} (${o.id})`,
+            value: o.id
+          }))
+        );
+        selectedOrg = orgs.find((o) => o.id === orgId);
+      }
+      const projects = await withSpinner("Fetching projects...", async () => {
+        const response = await wave.client.get(
+          "/v1/projects",
+          {
+            params: { organization_id: selectedOrg.id }
+          }
+        );
+        return response.data;
+      });
+      let selectedProject;
+      if (opts.project) {
+        const match = projects?.find((p) => p.id === opts.project);
+        if (!match) {
+          console.error(
+            chalk53.red(
+              `Project "${opts.project}" not found in organization "${selectedOrg.name}".`
+            )
+          );
+          process.exit(1);
+        }
+        selectedProject = match;
+      } else {
+        const choices = [
+          ...(projects ?? []).map((p) => ({
+            name: `${p.name} (${p.id})`,
+            value: p.id
+          })),
+          {
+            name: chalk53.green("+ Create new project"),
+            value: CREATE_NEW_PROJECT_VALUE
+          }
+        ];
+        const projectId = await promptSelect("Select project:", choices);
+        if (projectId === CREATE_NEW_PROJECT_VALUE) {
+          const newName = await promptInput("Project name:");
+          selectedProject = await withSpinner(
+            "Creating project...",
+            async () => {
+              return wave.client.post("/v1/projects", {
+                organization_id: selectedOrg.id,
+                name: newName
+              });
+            }
+          );
+        } else {
+          selectedProject = projects.find((p) => p.id === projectId);
+        }
+      }
+      const cwd = resolve3(process.cwd());
+      const waveDirPath = join5(cwd, ".wave");
+      const projectJsonPath = join5(waveDirPath, "project.json");
+      if (!existsSync5(waveDirPath)) {
+        await mkdir4(waveDirPath, { recursive: true });
+      }
+      const linkConfig = {
+        projectId: selectedProject.id,
+        organizationId: selectedOrg.id,
+        projectName: selectedProject.name
+      };
+      await writeFile4(
+        projectJsonPath,
+        JSON.stringify(linkConfig, null, 2) + "\n",
+        "utf-8"
+      );
+      const gitignorePath = join5(cwd, ".gitignore");
+      await ensureGitignoreEntry(gitignorePath, ".wave/");
+      await updateConfig((cfg) => ({
+        ...cfg,
+        projects: {
+          ...cfg.projects,
+          [configProjectName]: {
+            ...cfg.projects[configProjectName],
+            organizationId: selectedOrg.id,
+            organizationName: selectedOrg.name
+          }
+        }
+      }));
+      console.log("");
+      console.log(
+        chalk53.green(
+          `Linked to "${selectedProject.name}" (${selectedProject.id})`
+        )
+      );
+      console.log(chalk53.dim(`Created ${projectJsonPath}`));
+      console.log("");
+    })
+  );
+}
+async function ensureGitignoreEntry(gitignorePath, entry) {
+  if (existsSync5(gitignorePath)) {
+    const content = await readFile5(gitignorePath, "utf-8");
+    const lines = content.split("\n").map((l) => l.trim());
+    if (lines.includes(entry)) {
+      return;
+    }
+    const separator = content.endsWith("\n") ? "" : "\n";
+    await appendFile(gitignorePath, `${separator}${entry}
+`, "utf-8");
+  } else {
+    await writeFile4(gitignorePath, `${entry}
+`, "utf-8");
+  }
+}
+
+// src/cli.ts
+function printBanner() {
+  const b = chalk54.hex("#3366FF");
+  const p = chalk54.hex("#7B41E8");
+  const c = chalk54.hex("#33BBCC");
+  const d = chalk54.dim;
+  console.log("");
+  console.log(`  ${b("\u2588\u2588\u2557    \u2588\u2588\u2557")} ${p("\u2588\u2588\u2588\u2588\u2588\u2557 ")} ${p("\u2588\u2588\u2557   \u2588\u2588\u2557")} ${c("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}`);
+  console.log(`  ${b("\u2588\u2588\u2551    \u2588\u2588\u2551")} ${p("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557")} ${p("\u2588\u2588\u2551   \u2588\u2588\u2551")} ${c("\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D")}`);
+  console.log(`  ${b("\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551")} ${p("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551")} ${p("\u2588\u2588\u2551   \u2588\u2588\u2551")} ${c("\u2588\u2588\u2588\u2588\u2588\u2557  ")}`);
+  console.log(`  ${b("\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551")} ${p("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551")} ${p("\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D")} ${c("\u2588\u2588\u2554\u2550\u2550\u255D  ")}`);
+  console.log(`  ${b("\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D")} ${p("\u2588\u2588\u2551  \u2588\u2588\u2551")} ${p(" \u255A\u2588\u2588\u2588\u2588\u2554\u255D ")} ${c("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}`);
+  console.log(`  ${b(" \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D ")} ${p("\u255A\u2550\u255D  \u255A\u2550\u255D")} ${p("  \u255A\u2550\u2550\u2550\u255D  ")} ${c("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}`);
+  console.log("");
+  console.log(`  ${d("Enterprise Streaming Platform")}  ${chalk54.hex("#555")("v1.0.0")}`);
+  console.log(`  ${d("\u2500".repeat(45))}`);
+  console.log("");
+}
+function createProgram() {
+  const program = new Command();
+  program.name("wave").description("WAVE CLI - Command-line interface for the WAVE streaming platform").version("1.0.0", "-v, --version").option("-o, --output <format>", "Output format: table, json, yaml", "table").option("--project <name>", "Override project context").option("--org <id>", "Override organization").option("-c, --confirm", "Skip confirmation prompts").option("--no-color", "Disable colored output").option("--debug", "Verbose debug logging");
+  registerAuthCommands(program);
+  registerOrgCommands(program);
+  registerConfigCommands(program);
+  registerInitCommands(program);
+  registerLinkCommands(program);
+  registerStreamCommands(program);
+  registerStudioCommands(program);
+  registerClipCommands(program);
+  registerEditorCommands(program);
+  registerVoiceCommands(program);
+  registerPhoneCommands(program);
+  registerCollabCommands(program);
+  registerCaptionsCommands(program);
+  registerChaptersCommands(program);
+  registerAICommands(program);
+  registerTranscribeCommands(program);
+  registerSentimentCommands(program);
+  registerSearchCommands(program);
+  registerSceneCommands(program);
+  registerFleetCommands(program);
+  registerGhostCommands(program);
+  registerMeshCommands(program);
+  registerEdgeCommands(program);
+  registerAnalyticsCommands(program);
+  registerPrismCommands(program);
+  registerZoomCommands(program);
+  registerVaultCommands(program);
+  registerMarketplaceCommands(program);
+  registerConnectCommands(program);
+  registerDistributionCommands(program);
+  registerDesktopCommands(program);
+  registerSignageCommands(program);
+  registerQrCommands(program);
+  registerAudienceCommands(program);
+  registerCreatorCommands(program);
+  registerPodcastCommands(program);
+  registerSlidesCommands(program);
+  registerUsbCommands(program);
+  registerNotifyCommands(program);
+  registerDrmCommands(program);
+  registerBillingCommands(program);
+  registerListenCommands(program);
+  registerLogsCommands(program);
+  registerTriggerCommands(program);
+  registerDevCommands(program);
+  registerOpenCommands(program);
+  registerAdminCommands(program);
+  registerDoctorCommands(program);
+  registerStatusCommands(program);
+  registerCompletionCommands(program);
+  registerApiCommands(program);
+  const env = detectEnvironment();
+  if (!env.isAgent && !env.isCI) {
+    const originalHelp = program.helpInformation.bind(program);
+    program.helpInformation = function() {
+      printBanner();
+      return originalHelp();
+    };
+  }
+  return program;
+}
+
+// src/index.ts
+async function main() {
+  const program = createProgram();
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : "An unexpected error occurred");
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map