@viucraft/cli 0.1.1

package/dist/index.js

@@ -0,0 +1,2928 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/browser.ts
+import { exec } from "child_process";
+import { createWriteStream, existsSync, statSync } from "fs";
+import { basename, join } from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { platform } from "os";
+function openInBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${url}`, (err) => {
+    if (err) {
+      console.log(`Open in your browser: ${url}`);
+    }
+  });
+}
+async function downloadFile(url, outputPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("Download failed: empty response body");
+  }
+  let finalPath = outputPath;
+  if (existsSync(outputPath) && statSync(outputPath).isDirectory()) {
+    const urlFilename = basename(new URL(url).pathname);
+    finalPath = join(outputPath, urlFilename);
+  }
+  const nodeStream = Readable.fromWeb(response.body);
+  const fileStream = createWriteStream(finalPath);
+  await pipeline(nodeStream, fileStream);
+  return finalPath;
+}
+
+// src/commands/auth.ts
+import { password, input, confirm } from "@inquirer/prompts";
+import chalk2 from "chalk";
+
+// src/lib/client.ts
+import { arch, platform as platform2 } from "os";
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  constructor(message, exitCode = 1, requestId) {
+    super(message);
+    this.exitCode = exitCode;
+    this.requestId = requestId;
+    this.name = "CliError";
+  }
+  exitCode;
+  requestId;
+};
+var AuthenticationError = class extends CliError {
+  constructor(message = "Invalid or expired API key. Run `viucraft auth login`.", requestId) {
+    super(message, 2, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends CliError {
+  constructor(message = "Access denied. Your plan may not include this feature.", requestId) {
+    super(message, 3, requestId);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends CliError {
+  constructor(message = "Resource not found.", requestId) {
+    super(message, 3, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends CliError {
+  constructor(message, requestId) {
+    super(message, 3, requestId);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends CliError {
+  constructor(message, retryAfter, requestId) {
+    super(message, 3, requestId);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+  retryAfter;
+};
+var ServerError = class extends CliError {
+  constructor(message = "Server error. Try again later.", requestId) {
+    super(message, 3, requestId);
+    this.name = "ServerError";
+  }
+};
+
+// src/lib/masking.ts
+function maskApiKey(key) {
+  if (key.startsWith("vc_live_") || key.startsWith("vc_test_")) {
+    const prefix = key.substring(0, 8);
+    const suffix = key.slice(-4);
+    return `${prefix}...${suffix}`;
+  }
+  return `...${key.slice(-4)}`;
+}
+
+// src/lib/client.ts
+var MAX_RETRIES = 3;
+var RETRY_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var ApiClient = class {
+  apiKey;
+  baseUrl;
+  debug;
+  userAgent;
+  constructor(opts) {
+    if (!opts.insecure && opts.baseUrl.startsWith("http://")) {
+      throw new Error("HTTPS is required. Use --insecure for local development.");
+    }
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.debug = opts.debug ?? false;
+    this.userAgent = `viucraft-cli/${"0.1.1"} (${platform2()}/${arch()})`;
+  }
+  async get(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return this.request(url.toString(), { method: "GET" });
+  }
+  async post(path, body) {
+    const url = new URL(path, this.baseUrl);
+    const init = { method: "POST" };
+    if (body !== void 0) {
+      init.headers = { "Content-Type": "application/json" };
+      init.body = JSON.stringify(body);
+    }
+    return this.request(url.toString(), init);
+  }
+  async postForm(path, form) {
+    const url = new URL(path, this.baseUrl);
+    return this.request(url.toString(), { method: "POST", body: form });
+  }
+  async delete(path) {
+    const url = new URL(path, this.baseUrl);
+    await this.request(url.toString(), { method: "DELETE" });
+  }
+  async stream(path, lastEventId) {
+    const url = new URL(path, this.baseUrl);
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "User-Agent": this.userAgent,
+      Accept: "text/event-stream"
+    };
+    if (lastEventId) headers["Last-Event-ID"] = lastEventId;
+    if (this.debug) {
+      console.error(`[debug] GET ${url} (SSE stream)`);
+    }
+    const response = await fetch(url.toString(), { headers });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const message = extractErrorMessage(errorBody, response.statusText);
+      this.throwForStatus(response.status, message, response);
+    }
+    return response;
+  }
+  async getRaw(path) {
+    const url = new URL(path, this.baseUrl);
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "User-Agent": this.userAgent
+    };
+    if (this.debug) {
+      console.error(`[debug] GET ${url} (binary)`);
+    }
+    const response = await fetch(url.toString(), { headers });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const message = extractErrorMessage(errorBody, response.statusText);
+      this.throwForStatus(response.status, message, response);
+    }
+    return response;
+  }
+  async request(url, init, attempt = 1) {
+    const headers = new Headers(init.headers);
+    headers.set("X-API-Key", this.apiKey);
+    headers.set("User-Agent", this.userAgent);
+    headers.set("Accept", "application/json");
+    if (this.debug) {
+      const maskedKey = maskApiKey(this.apiKey);
+      console.error(`[debug] ${init.method ?? "GET"} ${url}`);
+      console.error(`[debug] X-API-Key: ${maskedKey}`);
+    }
+    const response = await fetch(url, { ...init, headers });
+    if (this.debug) {
+      console.error(`[debug] ${response.status} ${response.statusText}`);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    if (RETRY_STATUS_CODES.has(response.status) && attempt <= MAX_RETRIES) {
+      const retryAfter = response.headers.get("Retry-After");
+      const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : Math.min(1e3 * 2 ** (attempt - 1), 8e3) + Math.random() * 1e3;
+      console.error(
+        `Rate limited. Retrying in ${Math.ceil(delay / 1e3)}s... (attempt ${attempt}/${MAX_RETRIES})`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return this.request(url, init, attempt + 1);
+    }
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const message = extractErrorMessage(errorBody, response.statusText);
+      this.throwForStatus(response.status, message, response);
+    }
+    return response.json();
+  }
+  throwForStatus(status, message, response) {
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    if (this.debug && requestId) {
+      console.error(`[debug] X-Request-Id: ${requestId}`);
+    }
+    switch (status) {
+      case 401:
+        throw new AuthenticationError(message, requestId);
+      case 403:
+        throw new ForbiddenError(message, requestId);
+      case 404:
+        throw new NotFoundError(message, requestId);
+      case 422:
+        throw new ValidationError(message, requestId);
+      case 429: {
+        const retryAfter = response.headers.get("Retry-After");
+        throw new RateLimitError(
+          message,
+          retryAfter ? parseInt(retryAfter, 10) : void 0,
+          requestId
+        );
+      }
+      default:
+        throw new ServerError(message, requestId);
+    }
+  }
+};
+function extractErrorMessage(body, fallback) {
+  if (typeof body !== "object" || body === null) return fallback;
+  const obj = body;
+  if (typeof obj.message === "string") return obj.message;
+  if (typeof obj.error === "string") return obj.error;
+  if (typeof obj.error === "object" && obj.error !== null) {
+    const nested = obj.error;
+    if (typeof nested.message === "string") return nested.message;
+    return JSON.stringify(obj.error);
+  }
+  return fallback;
+}
+
+// src/lib/config.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, statSync as statSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { parse, stringify } from "yaml";
+var CONFIG_DIR = join2(homedir(), ".viucraft");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.yaml");
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function loadConfig() {
+  if (!existsSync2(CONFIG_FILE)) {
+    return {
+      current_profile: "",
+      profiles: {},
+      defaults: {
+        output_format: "table",
+        color: true
+      }
+    };
+  }
+  checkConfigPermissions();
+  const raw = readFileSync(CONFIG_FILE, "utf-8");
+  const parsed = parse(raw);
+  return {
+    current_profile: parsed.current_profile ?? "",
+    profiles: parsed.profiles ?? {},
+    defaults: {
+      output_format: parsed.defaults?.output_format ?? "table",
+      color: parsed.defaults?.color ?? true
+    }
+  };
+}
+function saveConfig(config) {
+  if (!existsSync2(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  const yaml = stringify(config);
+  writeFileSync(CONFIG_FILE, yaml, { mode: 384 });
+}
+function checkConfigPermissions() {
+  try {
+    const stats = statSync2(CONFIG_FILE);
+    const mode = stats.mode & 511;
+    if (mode & 63) {
+      console.error(
+        `Warning: config file permissions are too open (${mode.toString(8)}). Run: chmod 600 ${CONFIG_FILE}`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/lib/auth.ts
+function createClientFromGlobalOpts(globalOpts) {
+  const creds = resolveCredentials({
+    apiKey: globalOpts.apiKey,
+    profile: globalOpts.profile
+  });
+  return new ApiClient({
+    apiKey: creds.apiKey,
+    baseUrl: creds.apiUrl,
+    debug: globalOpts.debug,
+    insecure: globalOpts.insecure ?? creds.insecure
+  });
+}
+function resolveCredentials(opts) {
+  if (opts.apiKey) {
+    return {
+      apiKey: opts.apiKey,
+      apiUrl: "https://api.viucraft.com",
+      profile: "(flag)",
+      source: "flag"
+    };
+  }
+  const envKey = process.env.VIUCRAFT_API_KEY;
+  if (envKey) {
+    return {
+      apiKey: envKey,
+      apiUrl: process.env.VIUCRAFT_API_URL ?? "https://api.viucraft.com",
+      profile: "(env)",
+      source: "env"
+    };
+  }
+  const config = loadConfig();
+  const profileName = opts.profile ?? process.env.VIUCRAFT_PROFILE ?? config.current_profile;
+  if (!profileName || !config.profiles[profileName]) {
+    throw new Error("No profile configured. Run `viucraft auth login` to set up a profile.");
+  }
+  const profile = config.profiles[profileName];
+  return {
+    apiKey: profile.api_key,
+    apiUrl: profile.api_url,
+    profile: profileName,
+    source: "profile",
+    insecure: profile.insecure,
+    subdomain: profile.subdomain
+  };
+}
+function detectEnvironment(apiKey) {
+  if (apiKey.startsWith("vc_test_")) return "test";
+  return "live";
+}
+function validateKeyFormat(apiKey) {
+  return apiKey.startsWith("vc_live_") || apiKey.startsWith("vc_test_");
+}
+function buildImageUrl(opts) {
+  const isLocal = opts.apiUrl.includes("localhost") || opts.apiUrl.includes("127.0.0.1");
+  const parsed = new URL(opts.apiUrl);
+  const port = parsed.port ? `:${parsed.port}` : "";
+  const protocol = opts.insecure || isLocal ? "http" : "https";
+  const baseDomain = isLocal ? `viucraft.com${port}` : "viucraft.com";
+  const opsPath = opts.ops ? `/${opts.ops}` : "";
+  return `${protocol}://${opts.subdomain}.${baseDomain}${opsPath}/${opts.uuid}.${opts.format}`;
+}
+
+// src/lib/output.ts
+import chalk from "chalk";
+function printTable(columns, rows) {
+  const widths = columns.map((col) => {
+    const dataWidths = rows.map((row) => String(row[col.key] ?? "").length);
+    return Math.max(col.header.length, ...dataWidths, col.width ?? 0);
+  });
+  const headerLine = columns.map((col, i) => chalk.bold(col.header.padEnd(widths[i]))).join("  ");
+  console.log(headerLine);
+  console.log(widths.map((w) => "\u2500".repeat(w)).join("  "));
+  for (const row of rows) {
+    const line = columns.map((col, i) => String(row[col.key] ?? "").padEnd(widths[i])).join("  ");
+    console.log(line);
+  }
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage authentication and profiles");
+  auth.command("login").description("Authenticate with your VIUCraft API key").option("--profile <name>", "Profile name to save as").option("--api-key <key>", "API key (skips interactive prompt)").option("--api-url <url>", "API base URL (for dev/staging)").action(async (opts) => {
+    const globalOpts = program2.opts();
+    let apiKey = opts.apiKey ?? globalOpts.apiKey;
+    if (apiKey) {
+      console.error(
+        chalk2.yellow(
+          "Warning: passing API keys via flags may expose them in shell history. Consider using `viucraft auth login` interactively."
+        )
+      );
+    } else {
+      apiKey = await password({
+        message: "Enter your VIUCraft API key:"
+      });
+    }
+    if (!apiKey || !validateKeyFormat(apiKey)) {
+      console.error(
+        chalk2.red('Invalid API key format. Keys must start with "vc_live_" or "vc_test_".')
+      );
+      process.exit(2);
+    }
+    const environment = detectEnvironment(apiKey);
+    const baseUrl = opts.apiUrl ?? (globalOpts.insecure ? "http://localhost:8080" : "https://api.viucraft.com");
+    const client = new ApiClient({
+      apiKey,
+      baseUrl,
+      debug: globalOpts.debug,
+      insecure: globalOpts.insecure
+    });
+    let authResponse;
+    try {
+      authResponse = await client.post("/api/v1/cli/auth");
+    } catch (err) {
+      console.error(chalk2.red(`Authentication failed: ${err.message}`));
+      process.exit(2);
+    }
+    let profileName = opts.profile ?? globalOpts.profile;
+    const isNonInteractive = !!opts.apiKey || !!globalOpts.apiKey;
+    if (!profileName) {
+      if (isNonInteractive) {
+        profileName = "default";
+      } else {
+        profileName = await input({
+          message: "Profile name:",
+          default: "default"
+        });
+      }
+    }
+    const config = loadConfig();
+    if (config.profiles[profileName] && !isNonInteractive) {
+      const overwrite = await confirm({
+        message: `Profile "${profileName}" already exists. Overwrite?`,
+        default: false
+      });
+      if (!overwrite) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    config.profiles[profileName] = {
+      api_key: apiKey,
+      api_url: baseUrl,
+      environment,
+      customer_email: authResponse.customer.email,
+      customer_name: authResponse.customer.name,
+      plan: authResponse.customer.plan,
+      subdomain: authResponse.customer.subdomain,
+      insecure: baseUrl.startsWith("http://") || void 0
+    };
+    const isFirstProfile = Object.keys(config.profiles).length === 1;
+    if (isFirstProfile || !config.current_profile || isNonInteractive) {
+      config.current_profile = profileName;
+    } else {
+      const switchTo = await confirm({
+        message: `Switch to profile "${profileName}"?`,
+        default: true
+      });
+      if (switchTo) {
+        config.current_profile = profileName;
+      }
+    }
+    saveConfig(config);
+    console.log();
+    console.log(chalk2.green("Authenticated successfully."));
+    console.log();
+    const envColor = environment === "live" ? chalk2.green : chalk2.yellow;
+    console.log(`  Profile:      ${chalk2.bold(profileName)}`);
+    console.log(`  Environment:  ${envColor(environment)}`);
+    console.log(`  Account:      ${authResponse.customer.name} (${authResponse.customer.email})`);
+    console.log(`  Plan:         ${authResponse.customer.plan}`);
+    console.log(`  Subdomain:    ${authResponse.customer.subdomain}`);
+    console.log(`  API Key:      ${maskApiKey(apiKey)}`);
+  });
+  auth.command("status").description("Show current authentication status").action(async () => {
+    const globalOpts = program2.opts();
+    let creds;
+    try {
+      creds = resolveCredentials({
+        apiKey: globalOpts.apiKey,
+        profile: globalOpts.profile
+      });
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exit(2);
+    }
+    const client = new ApiClient({
+      apiKey: creds.apiKey,
+      baseUrl: creds.apiUrl,
+      debug: globalOpts.debug,
+      insecure: globalOpts.insecure ?? creds.insecure
+    });
+    let whoami;
+    try {
+      whoami = await client.get("/api/v1/cli/whoami");
+    } catch (err) {
+      console.error(chalk2.red(`Failed: ${err.message}`));
+      process.exit(2);
+    }
+    const environment = detectEnvironment(creds.apiKey);
+    const envColor = environment === "live" ? chalk2.green : chalk2.yellow;
+    if (globalOpts.output === "json") {
+      printJson({
+        profile: creds.profile,
+        source: creds.source,
+        environment,
+        customer: whoami.customer,
+        usage: whoami.usage,
+        api_key: maskApiKey(creds.apiKey),
+        config_path: getConfigPath()
+      });
+      return;
+    }
+    console.log(chalk2.bold("Authentication Status"));
+    console.log();
+    console.log(`  Profile:      ${chalk2.bold(creds.profile)}`);
+    console.log(`  Source:       ${creds.source}`);
+    console.log(`  Environment:  ${envColor(environment)}`);
+    console.log(`  API Key:      ${maskApiKey(creds.apiKey)}`);
+    console.log();
+    console.log(`  Account:      ${whoami.customer.name} (${whoami.customer.email})`);
+    console.log(`  Plan:         ${whoami.customer.plan}`);
+    console.log(`  Subdomain:    ${whoami.customer.subdomain}`);
+    console.log();
+    console.log(chalk2.bold("Usage"));
+    console.log(`  Images:          ${formatPercent(whoami.usage.images)}`);
+    console.log(`  Storage:         ${formatPercent(whoami.usage.storage)}`);
+    console.log(`  Transformations: ${formatPercent(whoami.usage.transformations)}`);
+    console.log();
+    console.log(chalk2.dim(`Config: ${getConfigPath()}`));
+  });
+  auth.command("switch").description("Switch active profile").argument("<profile>", "Profile name to switch to").action(async (profileName) => {
+    const config = loadConfig();
+    if (!config.profiles[profileName]) {
+      console.error(chalk2.red(`Profile "${profileName}" not found.`));
+      console.log();
+      const names = Object.keys(config.profiles);
+      if (names.length > 0) {
+        console.log("Available profiles:");
+        for (const name of names) {
+          const marker = name === config.current_profile ? chalk2.green(" (current)") : "";
+          console.log(`  ${name}${marker}`);
+        }
+      } else {
+        console.log("No profiles configured. Run `viucraft auth login` to create one.");
+      }
+      process.exit(1);
+    }
+    config.current_profile = profileName;
+    saveConfig(config);
+    const profile = config.profiles[profileName];
+    const envColor = profile.environment === "live" ? chalk2.green : chalk2.yellow;
+    console.log(chalk2.green(`Switched to profile "${profileName}".`));
+    console.log();
+    console.log(`  Environment:  ${envColor(profile.environment)}`);
+    console.log(`  Account:      ${profile.customer_name} (${profile.customer_email})`);
+    console.log(`  Plan:         ${profile.plan}`);
+    console.log(`  Subdomain:    ${profile.subdomain}`);
+  });
+  auth.command("list").description("List all configured profiles").action(async () => {
+    const globalOpts = program2.opts();
+    const config = loadConfig();
+    const names = Object.keys(config.profiles);
+    if (names.length === 0) {
+      console.log("No profiles configured. Run `viucraft auth login` to create one.");
+      return;
+    }
+    if (globalOpts.output === "json") {
+      const profiles = names.map((name) => ({
+        name,
+        current: name === config.current_profile,
+        ...config.profiles[name],
+        api_key: maskApiKey(config.profiles[name].api_key)
+      }));
+      printJson(profiles);
+      return;
+    }
+    const rows = names.map((name) => {
+      const p = config.profiles[name];
+      const marker = name === config.current_profile ? "*" : " ";
+      return {
+        marker,
+        name,
+        environment: p.environment,
+        email: p.customer_email,
+        plan: p.plan,
+        api_key: maskApiKey(p.api_key)
+      };
+    });
+    printTable(
+      [
+        { header: " ", key: "marker", width: 1 },
+        { header: "Profile", key: "name" },
+        { header: "Env", key: "environment" },
+        { header: "Email", key: "email" },
+        { header: "Plan", key: "plan" },
+        { header: "API Key", key: "api_key" }
+      ],
+      rows
+    );
+  });
+  auth.command("logout").description("Remove a profile").option("--profile <name>", "Profile to remove (default: current)").action(async (opts) => {
+    const config = loadConfig();
+    const profileName = opts.profile ?? config.current_profile;
+    if (!profileName || !config.profiles[profileName]) {
+      console.error(
+        chalk2.red(
+          profileName ? `Profile "${profileName}" not found.` : "No profile specified and no current profile set."
+        )
+      );
+      process.exit(1);
+    }
+    const doRemove = await confirm({
+      message: `Remove profile "${profileName}"?`,
+      default: false
+    });
+    if (!doRemove) {
+      console.log("Aborted.");
+      return;
+    }
+    delete config.profiles[profileName];
+    if (config.current_profile === profileName) {
+      const remaining = Object.keys(config.profiles);
+      config.current_profile = remaining[0] ?? "";
+      if (config.current_profile) {
+        console.log(chalk2.dim(`Switched to profile "${config.current_profile}".`));
+      }
+    }
+    saveConfig(config);
+    console.log(chalk2.green(`Profile "${profileName}" removed.`));
+  });
+}
+function formatPercent(value) {
+  if (value == null || isNaN(value)) return chalk2.dim("n/a");
+  const pct = Math.round(value);
+  const bar = progressBar(value);
+  if (pct >= 90) return chalk2.red(`${bar} ${pct}%`);
+  if (pct >= 75) return chalk2.yellow(`${bar} ${pct}%`);
+  return chalk2.green(`${bar} ${pct}%`);
+}
+function progressBar(percent, width = 20) {
+  const clamped = Math.max(0, Math.min(percent, 100));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+
+// src/commands/images.ts
+import { confirm as confirm3 } from "@inquirer/prompts";
+import { readFileSync as readFileSync2, statSync as statSync3 } from "fs";
+import { basename as basename2 } from "path";
+import chalk4 from "chalk";
+import ora from "ora";
+
+// src/lib/operations.ts
+import chalk3 from "chalk";
+import { select, input as input2, number, confirm as confirm2 } from "@inquirer/prompts";
+var OPERATIONS_CATALOG = [
+  {
+    id: "resize_crop",
+    name: "Resize & Crop",
+    operations: [
+      {
+        id: "resize",
+        name: "Resize",
+        shortName: "resize",
+        description: "Resize image to specified dimensions",
+        params: [
+          {
+            name: "width",
+            label: "Width",
+            type: "slider",
+            default: 800,
+            min: 1,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "height",
+            label: "Height",
+            type: "slider",
+            default: 600,
+            min: 1,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          { name: "force", label: "Force exact dimensions", type: "toggle", default: false },
+          {
+            name: "scale",
+            label: "Scale Factor",
+            type: "slider",
+            default: 1,
+            min: 0.1,
+            max: 4,
+            step: 0.05,
+            note: "When set, overrides width/height"
+          }
+        ]
+      },
+      {
+        id: "crop",
+        name: "Crop",
+        shortName: "crop",
+        description: "Crop image to a specific region",
+        params: [
+          {
+            name: "width",
+            label: "Width",
+            type: "slider",
+            default: 500,
+            min: 1,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "height",
+            label: "Height",
+            type: "slider",
+            default: 500,
+            min: 1,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "left",
+            label: "Left Offset",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "top",
+            label: "Top Offset",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          }
+        ]
+      },
+      {
+        id: "thumbnail",
+        name: "Thumbnail",
+        shortName: "thumb",
+        description: "Generate a thumbnail with smart sizing",
+        params: [
+          {
+            name: "width",
+            label: "Width",
+            type: "slider",
+            default: 300,
+            min: 50,
+            max: 2e3,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "height",
+            label: "Height",
+            type: "slider",
+            default: 300,
+            min: 50,
+            max: 2e3,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "crop",
+            label: "Crop Strategy",
+            type: "dropdown",
+            default: "centre",
+            options: [
+              { value: "centre", label: "Centre" },
+              { value: "entropy", label: "Entropy" },
+              { value: "attention", label: "Attention" },
+              { value: "none", label: "None (Letterbox)" }
+            ]
+          },
+          { name: "background", label: "Letterbox Color", type: "color", default: "#ffffff" }
+        ]
+      },
+      {
+        id: "smartcrop",
+        name: "Smart Crop",
+        shortName: "scrop",
+        description: "Intelligently crop to the most interesting region",
+        params: [
+          {
+            name: "width",
+            label: "Width",
+            type: "slider",
+            default: 500,
+            min: 50,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "height",
+            label: "Height",
+            type: "slider",
+            default: 500,
+            min: 50,
+            max: 1e4,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "strategy",
+            label: "Strategy",
+            type: "dropdown",
+            default: "attention",
+            options: [
+              { value: "attention", label: "Attention (AI Focus)" },
+              { value: "entropy", label: "Entropy (Detail)" },
+              { value: "centre", label: "Centre" },
+              { value: "high", label: "High (Top)" },
+              { value: "low", label: "Low (Bottom)" }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    id: "color",
+    name: "Color Adjustments",
+    operations: [
+      {
+        id: "brightness",
+        name: "Brightness",
+        shortName: "bright",
+        description: "Adjust image brightness",
+        params: [
+          {
+            name: "factor",
+            label: "Brightness Factor",
+            type: "slider",
+            default: 1,
+            min: 0.1,
+            max: 5,
+            step: 0.05
+          }
+        ]
+      },
+      {
+        id: "contrast",
+        name: "Contrast",
+        shortName: "con",
+        description: "Adjust image contrast",
+        params: [
+          {
+            name: "factor",
+            label: "Contrast Factor",
+            type: "slider",
+            default: 1,
+            min: 0.1,
+            max: 5,
+            step: 0.05
+          }
+        ]
+      },
+      {
+        id: "gamma",
+        name: "Gamma",
+        shortName: "gam",
+        description: "Adjust gamma correction level",
+        params: [
+          {
+            name: "exponent",
+            label: "Gamma",
+            type: "slider",
+            default: 2.2,
+            min: 0.1,
+            max: 10,
+            step: 0.1
+          }
+        ]
+      },
+      {
+        id: "saturation",
+        name: "Saturation",
+        shortName: "sat",
+        description: "Adjust color saturation intensity",
+        params: [
+          {
+            name: "factor",
+            label: "Saturation Factor",
+            type: "slider",
+            default: 1,
+            min: 0,
+            max: 3,
+            step: 0.05
+          }
+        ]
+      },
+      {
+        id: "hue",
+        name: "Hue Rotate",
+        shortName: "hue",
+        description: "Rotate the color hue of the image",
+        params: [
+          {
+            name: "angle",
+            label: "Hue Angle",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 360,
+            step: 1,
+            unit: "deg"
+          }
+        ]
+      },
+      {
+        id: "colorize",
+        name: "Colorize",
+        shortName: "col",
+        description: "Apply a color overlay with adjustable blend",
+        params: [
+          { name: "color", label: "Color", type: "color", default: "#ff6600" },
+          {
+            name: "amount",
+            label: "Blend Amount",
+            type: "slider",
+            default: 0.5,
+            min: 0,
+            max: 1,
+            step: 0.05
+          }
+        ]
+      },
+      {
+        id: "tint",
+        name: "Tint",
+        shortName: "tint",
+        description: "Map shadows and highlights to custom colors",
+        params: [
+          { name: "highlight", label: "Highlight Color", type: "color", default: "#ffffff" },
+          { name: "shadow", label: "Shadow Color", type: "color", default: "#000066" }
+        ]
+      },
+      {
+        id: "invert",
+        name: "Invert",
+        shortName: "inv",
+        description: "Invert all image colors",
+        params: [{ name: "enabled", label: "Enabled", type: "toggle", default: true }]
+      },
+      {
+        id: "grayscale",
+        name: "Grayscale",
+        shortName: "gray",
+        description: "Convert image to grayscale",
+        params: [{ name: "enabled", label: "Enabled", type: "toggle", default: true }]
+      },
+      {
+        id: "sepia",
+        name: "Sepia",
+        shortName: "sepia",
+        description: "Apply a warm sepia tone effect",
+        params: [{ name: "enabled", label: "Enabled", type: "toggle", default: true }]
+      },
+      {
+        id: "autoenhance",
+        name: "Auto Enhance",
+        shortName: "auto",
+        description: "Automatically improve brightness, contrast, and sharpness",
+        params: [
+          {
+            name: "strength",
+            label: "Strength",
+            type: "slider",
+            default: 0.5,
+            min: 0,
+            max: 1,
+            step: 0.05
+          }
+        ]
+      }
+    ]
+  },
+  {
+    id: "effects",
+    name: "Effects",
+    operations: [
+      {
+        id: "blur",
+        name: "Blur",
+        shortName: "blur",
+        description: "Apply Gaussian blur to the image",
+        params: [
+          {
+            name: "sigma",
+            label: "Blur Intensity",
+            type: "slider",
+            default: 5,
+            min: 0.3,
+            max: 100,
+            step: 0.1
+          }
+        ]
+      },
+      {
+        id: "sharpen",
+        name: "Sharpen",
+        shortName: "sharp",
+        description: "Sharpen image details and edges",
+        params: [
+          {
+            name: "sigma",
+            label: "Sharpen Radius",
+            type: "slider",
+            default: 1,
+            min: 0.1,
+            max: 10,
+            step: 0.1
+          },
+          {
+            name: "x1",
+            label: "Flat Area Threshold",
+            type: "slider",
+            default: 2,
+            min: 0,
+            max: 10,
+            step: 0.1
+          },
+          {
+            name: "y2",
+            label: "Jagged Area Level",
+            type: "slider",
+            default: 10,
+            min: 0,
+            max: 100,
+            step: 0.5
+          },
+          {
+            name: "y3",
+            label: "Max Brightening",
+            type: "slider",
+            default: 20,
+            min: 0,
+            max: 100,
+            step: 0.5
+          }
+        ]
+      },
+      {
+        id: "edge",
+        name: "Edge Detect",
+        shortName: "edge",
+        description: "Detect and highlight edges in the image",
+        params: [{ name: "enabled", label: "Enabled", type: "toggle", default: true }]
+      },
+      {
+        id: "emboss",
+        name: "Emboss",
+        shortName: "emb",
+        description: "Apply an emboss relief effect",
+        params: [{ name: "enabled", label: "Enabled", type: "toggle", default: true }]
+      },
+      {
+        id: "median",
+        name: "Median Filter",
+        shortName: "med",
+        description: "Apply median filter for noise reduction",
+        params: [
+          {
+            name: "size",
+            label: "Filter Size",
+            type: "slider",
+            default: 3,
+            min: 3,
+            max: 15,
+            step: 2,
+            note: "Must be odd"
+          }
+        ]
+      },
+      {
+        id: "vignette",
+        name: "Vignette",
+        shortName: "vig",
+        description: "Apply a dark vignette around the edges",
+        params: [
+          {
+            name: "scale",
+            label: "Inner Radius",
+            type: "slider",
+            default: 0.3,
+            min: 0,
+            max: 1,
+            step: 0.05
+          },
+          {
+            name: "opacity",
+            label: "Darkness",
+            type: "slider",
+            default: 0.7,
+            min: 0,
+            max: 1,
+            step: 0.05
+          },
+          { name: "color", label: "Edge Color", type: "color", default: "#000000" }
+        ]
+      },
+      {
+        id: "noise",
+        name: "Noise",
+        shortName: "noise",
+        description: "Add random noise grain to the image",
+        params: [
+          {
+            name: "amount",
+            label: "Noise Amount",
+            type: "slider",
+            default: 0.2,
+            min: 0.01,
+            max: 1,
+            step: 0.01
+          },
+          {
+            name: "type",
+            label: "Noise Type",
+            type: "dropdown",
+            default: "gaussian",
+            options: [
+              { value: "gaussian", label: "Gaussian" },
+              { value: "salt", label: "Salt (White)" },
+              { value: "pepper", label: "Pepper (Black)" },
+              { value: "salt-pepper", label: "Salt & Pepper" }
+            ]
+          }
+        ]
+      },
+      {
+        id: "pixelate",
+        name: "Pixelate",
+        shortName: "pix",
+        description: "Apply a pixelation mosaic effect",
+        params: [
+          {
+            name: "size",
+            label: "Pixel Size",
+            type: "slider",
+            default: 10,
+            min: 2,
+            max: 100,
+            step: 1,
+            unit: "px"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    id: "transform",
+    name: "Transform",
+    operations: [
+      {
+        id: "rotate",
+        name: "Rotate",
+        shortName: "rotate",
+        description: "Rotate the image by a specified angle",
+        params: [
+          {
+            name: "angle",
+            label: "Rotation Angle",
+            type: "slider",
+            default: 90,
+            min: 0,
+            max: 360,
+            step: 1,
+            unit: "deg"
+          },
+          { name: "background", label: "Background Color", type: "color", default: "#000000" }
+        ]
+      },
+      {
+        id: "flip",
+        name: "Flip",
+        shortName: "flip",
+        description: "Flip the image horizontally, vertically, or both",
+        params: [
+          {
+            name: "direction",
+            label: "Direction",
+            type: "dropdown",
+            default: "horizontal",
+            options: [
+              { value: "horizontal", label: "Horizontal" },
+              { value: "vertical", label: "Vertical" },
+              { value: "both", label: "Both" }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    id: "decoration",
+    name: "Decoration",
+    operations: [
+      {
+        id: "border",
+        name: "Border",
+        shortName: "brd",
+        description: "Add a border with optional rounded corners and shadow",
+        params: [
+          {
+            name: "width",
+            label: "Border Width",
+            type: "slider",
+            default: 10,
+            min: 1,
+            max: 200,
+            step: 1,
+            unit: "px"
+          },
+          { name: "color", label: "Border Color", type: "color", default: "#000000" },
+          {
+            name: "radius",
+            label: "Corner Radius",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 500,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "shadow_blur",
+            label: "Shadow Blur",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 50,
+            step: 1
+          },
+          { name: "shadow_color", label: "Shadow Color", type: "color", default: "#000000" },
+          {
+            name: "shadow_x",
+            label: "Shadow X Offset",
+            type: "slider",
+            default: 4,
+            min: -50,
+            max: 50,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "shadow_y",
+            label: "Shadow Y Offset",
+            type: "slider",
+            default: 4,
+            min: -50,
+            max: 50,
+            step: 1,
+            unit: "px"
+          }
+        ]
+      },
+      {
+        id: "watermark",
+        name: "Text Watermark",
+        shortName: "wmt",
+        description: "Add a text watermark overlay",
+        params: [
+          { name: "text", label: "Watermark Text", type: "text", default: "Sample" },
+          { name: "tiled", label: "Tiled (Repeat Pattern)", type: "toggle", default: false },
+          {
+            name: "opacity",
+            label: "Opacity",
+            type: "slider",
+            default: 0.5,
+            min: 0,
+            max: 1,
+            step: 0.05
+          },
+          {
+            name: "position",
+            label: "Position",
+            type: "dropdown",
+            default: "bottom-right",
+            options: [
+              { value: "center", label: "Center" },
+              { value: "top-left", label: "Top Left" },
+              { value: "top-center", label: "Top Center" },
+              { value: "top-right", label: "Top Right" },
+              { value: "center-left", label: "Center Left" },
+              { value: "center-right", label: "Center Right" },
+              { value: "bottom-left", label: "Bottom Left" },
+              { value: "bottom-center", label: "Bottom Center" },
+              { value: "bottom-right", label: "Bottom Right" }
+            ]
+          },
+          {
+            name: "size",
+            label: "Font Size",
+            type: "slider",
+            default: 48,
+            min: 8,
+            max: 500,
+            step: 1,
+            unit: "px"
+          },
+          { name: "color", label: "Text Color", type: "color", default: "#ffffff" },
+          {
+            name: "rotation",
+            label: "Rotation",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 360,
+            step: 1,
+            unit: "deg"
+          },
+          {
+            name: "font",
+            label: "Font",
+            type: "dropdown",
+            default: "sans-serif",
+            options: [
+              { value: "sans-serif", label: "Sans Serif" },
+              { value: "serif", label: "Serif" },
+              { value: "monospace", label: "Monospace" }
+            ]
+          },
+          {
+            name: "x",
+            label: "X Offset",
+            type: "slider",
+            default: 0,
+            min: -500,
+            max: 500,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "y",
+            label: "Y Offset",
+            type: "slider",
+            default: 0,
+            min: -500,
+            max: 500,
+            step: 1,
+            unit: "px"
+          },
+          { name: "shadowcolor", label: "Shadow Color", type: "color", default: "#000000" },
+          {
+            name: "shadowx",
+            label: "Shadow X",
+            type: "slider",
+            default: 0,
+            min: -20,
+            max: 20,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "shadowy",
+            label: "Shadow Y",
+            type: "slider",
+            default: 0,
+            min: -20,
+            max: 20,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "spacing",
+            label: "Tile Spacing",
+            type: "slider",
+            default: 20,
+            min: 0,
+            max: 200,
+            step: 1,
+            unit: "px",
+            note: "Only applies when Tiled is enabled"
+          }
+        ]
+      },
+      {
+        id: "svgoverlay",
+        name: "SVG Overlay",
+        shortName: "svg",
+        description: "Overlay an SVG graphic on the image",
+        params: [
+          { name: "data", label: "SVG Data (base64)", type: "text", default: "" },
+          {
+            name: "x",
+            label: "X Offset",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 4e3,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "y",
+            label: "Y Offset",
+            type: "slider",
+            default: 0,
+            min: 0,
+            max: 4e3,
+            step: 1,
+            unit: "px"
+          },
+          {
+            name: "scale",
+            label: "Scale",
+            type: "slider",
+            default: 1,
+            min: 0.1,
+            max: 5,
+            step: 0.1
+          },
+          {
+            name: "opacity",
+            label: "Opacity",
+            type: "slider",
+            default: 100,
+            min: 0,
+            max: 100,
+            step: 1,
+            unit: "%"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    id: "output",
+    name: "Output",
+    operations: [
+      {
+        id: "quality",
+        name: "Quality",
+        shortName: "q",
+        description: "Set output image quality (lower = smaller file)",
+        params: [
+          {
+            name: "value",
+            label: "Quality",
+            type: "slider",
+            default: 85,
+            min: 1,
+            max: 100,
+            step: 1,
+            unit: "%"
+          }
+        ]
+      },
+      {
+        id: "strip",
+        name: "Strip Metadata",
+        shortName: "strip",
+        description: "Remove EXIF and other metadata from the output",
+        params: [{ name: "enabled", label: "Strip Metadata", type: "toggle", default: true }]
+      },
+      {
+        id: "placeholder",
+        name: "Placeholder (LQIP)",
+        shortName: "lqip",
+        description: "Generate a tiny blurred placeholder for progressive loading",
+        params: [
+          {
+            name: "size",
+            label: "Size",
+            type: "slider",
+            default: 32,
+            min: 8,
+            max: 128,
+            step: 1,
+            unit: "px"
+          }
+        ]
+      },
+      {
+        id: "responsive",
+        name: "Responsive Srcset",
+        shortName: "resp",
+        description: "Generate responsive image variants with srcset",
+        params: [
+          { name: "widths", label: "Breakpoint Widths", type: "text", default: "320,640,1024" },
+          {
+            name: "format",
+            label: "Format",
+            type: "dropdown",
+            default: "webp",
+            options: [
+              { value: "webp", label: "WebP" },
+              { value: "jpg", label: "JPEG" },
+              { value: "png", label: "PNG" }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+];
+function isToggleOnly(op) {
+  return op.params.length === 1 && op.params[0].type === "toggle";
+}
+function buildSyntaxString(op) {
+  if (isToggleOnly(op)) return op.shortName;
+  const paramParts = op.params.filter((p) => p.type !== "toggle").map((p) => `<${p.name}>`);
+  if (paramParts.length === 0) return op.shortName;
+  return `${op.shortName}-${paramParts.join("-")}`;
+}
+function formatOpsSegment(op, values) {
+  if (isToggleOnly(op)) return op.shortName;
+  const parts = [op.shortName];
+  const nonToggleParams = op.params.filter((p) => p.type !== "toggle");
+  let lastNonDefault = -1;
+  for (let i = nonToggleParams.length - 1; i >= 0; i--) {
+    const p = nonToggleParams[i];
+    const val = values[p.name] ?? p.default;
+    const normalized = p.type === "color" ? String(val).replace(/^#/, "") : val;
+    const defaultNormalized = p.type === "color" ? String(p.default).replace(/^#/, "") : p.default;
+    if (normalized !== defaultNormalized) {
+      lastNonDefault = i;
+      break;
+    }
+  }
+  const includeUpTo = Math.max(0, lastNonDefault);
+  for (let i = 0; i <= includeUpTo; i++) {
+    const p = nonToggleParams[i];
+    const val = values[p.name] ?? p.default;
+    parts.push(p.type === "color" ? String(val).replace(/^#/, "") : val);
+  }
+  return parts.join("-");
+}
+function renderOperationsList(outputFormat) {
+  if (outputFormat === "json") {
+    printJson(OPERATIONS_CATALOG);
+    return;
+  }
+  for (const category of OPERATIONS_CATALOG) {
+    console.log();
+    console.log(chalk3.bold.underline(category.name));
+    console.log();
+    const nameWidth = 18;
+    const shortWidth = 10;
+    const syntaxWidth = 30;
+    console.log(
+      `  ${chalk3.dim(pad("Name", nameWidth))}${chalk3.dim(pad("Short", shortWidth))}${chalk3.dim(pad("Syntax", syntaxWidth))}${chalk3.dim("Description")}`
+    );
+    console.log(
+      `  ${chalk3.dim("\u2500".repeat(nameWidth))}${chalk3.dim("\u2500".repeat(shortWidth))}${chalk3.dim("\u2500".repeat(syntaxWidth))}${chalk3.dim("\u2500".repeat(30))}`
+    );
+    for (const op of category.operations) {
+      const syntax = buildSyntaxString(op);
+      console.log(
+        `  ${pad(op.name, nameWidth)}${chalk3.cyan(pad(op.shortName, shortWidth))}${chalk3.yellow(pad(syntax, syntaxWidth))}${chalk3.dim(op.description)}`
+      );
+    }
+  }
+  console.log();
+  console.log(chalk3.dim("Chain operations with /: resize-800-600/sharp-1.2/q-85"));
+  console.log(chalk3.dim("Use --interactive (-i) to build operations step by step."));
+  console.log();
+}
+async function buildOpsInteractively() {
+  const segments = [];
+  for (; ; ) {
+    if (segments.length > 0) {
+      console.log();
+      console.log(
+        `  ${chalk3.dim("Pipeline:")} ${segments.map((s) => chalk3.cyan(s)).join(chalk3.dim(" / "))}`
+      );
+    }
+    const categoryId = await select({
+      message: "Select a category:",
+      choices: OPERATIONS_CATALOG.map((cat) => ({
+        value: cat.id,
+        name: cat.name,
+        description: `${cat.operations.length} operations`
+      }))
+    });
+    const category = OPERATIONS_CATALOG.find((c) => c.id === categoryId);
+    const opId = await select({
+      message: `Select an operation:`,
+      choices: category.operations.map((op2) => ({
+        value: op2.id,
+        name: `${op2.name} (${op2.shortName})`,
+        description: op2.description
+      }))
+    });
+    const op = category.operations.find((o) => o.id === opId);
+    if (isToggleOnly(op)) {
+      const apply = await confirm2({
+        message: `Apply ${op.name}?`,
+        default: true
+      });
+      if (apply) {
+        segments.push(op.shortName);
+      }
+    } else {
+      const values = {};
+      for (const param of op.params) {
+        values[param.name] = await promptForParam(param);
+      }
+      const segment = formatOpsSegment(op, values);
+      segments.push(segment);
+      console.log(`  ${chalk3.dim("Added:")} ${chalk3.cyan(segment)}`);
+    }
+    const addMore = await confirm2({
+      message: "Add another operation?",
+      default: false
+    });
+    if (!addMore) break;
+  }
+  if (segments.length === 0) {
+    return "";
+  }
+  const opsString = segments.join("/");
+  console.log();
+  console.log(chalk3.bold("Operations string:"));
+  console.log(`  ${chalk3.green(opsString)}`);
+  console.log();
+  const proceed = await confirm2({
+    message: "Execute this transformation?",
+    default: true
+  });
+  return proceed ? opsString : "";
+}
+async function promptForParam(param) {
+  const label = param.unit ? `${param.label} (${param.unit})` : param.label;
+  const message = param.note ? `${label} \u2014 ${chalk3.dim(param.note)}` : label;
+  switch (param.type) {
+    case "slider":
+      return await number({
+        message,
+        default: param.default,
+        min: param.min,
+        max: param.max,
+        step: param.step
+      }) ?? param.default;
+    case "toggle":
+      return confirm2({
+        message,
+        default: param.default
+      });
+    case "dropdown":
+      return select({
+        message,
+        choices: (param.options ?? []).map((o) => ({
+          value: o.value,
+          name: o.label
+        })),
+        default: param.default
+      });
+    case "color":
+      return input2({
+        message,
+        default: param.default,
+        validate: (v) => /^#[0-9a-fA-F]{6}$/.test(v) || "Enter a valid hex color (#rrggbb)"
+      });
+    case "text":
+      return input2({
+        message,
+        default: param.default
+      });
+  }
+}
+function pad(str, width) {
+  return str.length >= width ? str + " " : str + " ".repeat(width - str.length);
+}
+
+// src/commands/images.ts
+function registerImagesCommands(program2) {
+  const images = program2.command("images").description("Upload, list, transform, and delete images");
+  images.command("list").description("List uploaded images").option("--page <number>", "Page number", "1").option("--limit <number>", "Results per page", "20").option("--search <query>", "Search by filename").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const params = {
+      page: opts.page,
+      limit: opts.limit
+    };
+    if (opts.search) params.q = opts.search;
+    const res = await client.get("/api/v1/cli/images", params);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    if (res.images.length === 0) {
+      console.log("No images found.");
+      return;
+    }
+    const rows = res.images.map((img) => ({
+      uuid: img.uuid,
+      filename: img.filename,
+      folder: img.folder,
+      size: formatBytes(img.size_bytes),
+      type: img.mime_type,
+      created: formatDate(img.created_at)
+    }));
+    printTable(
+      [
+        { header: "UUID", key: "uuid" },
+        { header: "Filename", key: "filename" },
+        { header: "Folder", key: "folder" },
+        { header: "Size", key: "size" },
+        { header: "Type", key: "type" },
+        { header: "Created", key: "created" }
+      ],
+      rows
+    );
+    const { page, total, limit } = res.pagination;
+    const totalPages = Math.ceil(total / limit);
+    console.log();
+    console.log(chalk4.dim(`Page ${page}/${totalPages} (${total} total images)`));
+  });
+  images.command("upload").description("Upload one or more images").argument("<files...>", "Files to upload").option("--folder <path>", "Destination folder", "/").option("--ops <operations>", "Transform operations to apply after upload").option("--format <ext>", "Output format for transform (jpg, png, webp)").action(async (files, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    if (opts.format && !opts.ops) {
+      console.error(chalk4.yellow("Note: --format ignored without --ops."));
+    }
+    const results = [];
+    for (const filePath of files) {
+      const fileName = basename2(filePath);
+      const spinner = ora(`Uploading ${fileName}...`).start();
+      try {
+        statSync3(filePath);
+      } catch {
+        spinner.fail(`File not found: ${filePath}`);
+        results.push({
+          file: fileName,
+          status: "error",
+          uuid: "",
+          url: ""
+        });
+        continue;
+      }
+      try {
+        const fileBuffer = readFileSync2(filePath);
+        const blob = new Blob([fileBuffer]);
+        const form = new FormData();
+        form.append("file", blob, fileName);
+        form.append("folder", opts.folder);
+        const res = await client.postForm("/api/v1/cli/images/upload", form);
+        if (res.status === "duplicate") {
+          spinner.warn(`${fileName} (duplicate)`);
+        } else {
+          spinner.succeed(fileName);
+        }
+        results.push({
+          file: fileName,
+          status: res.status,
+          uuid: res.image_id,
+          url: res.url
+        });
+      } catch (err) {
+        spinner.fail(`${fileName}: ${err.message}`);
+        results.push({
+          file: fileName,
+          status: "error",
+          uuid: "",
+          url: ""
+        });
+      }
+    }
+    if (opts.ops) {
+      for (const result of results) {
+        if (result.status === "error" || !result.uuid) continue;
+        const spinner = ora(`Transforming ${result.file}...`).start();
+        try {
+          const body = {
+            uuid: result.uuid,
+            operations: opts.ops
+          };
+          if (opts.format) body.format = opts.format;
+          const tres = await client.post(
+            "/api/v1/cli/images/transform",
+            body
+          );
+          result.transform_url = tres.url;
+          spinner.succeed(`Transformed ${result.file}`);
+        } catch (err) {
+          result.transform_url = `error: ${err.message}`;
+          spinner.fail(`Transform failed for ${result.file}`);
+        }
+      }
+    }
+    console.log();
+    if (globalOpts.output === "json") {
+      printJson(results);
+      return;
+    }
+    const columns = [
+      { header: "File", key: "file" },
+      { header: "Status", key: "status" },
+      { header: "UUID", key: "uuid" },
+      { header: "URL", key: "url" }
+    ];
+    if (opts.ops) {
+      columns.push({ header: "Transform URL", key: "transform_url" });
+    }
+    printTable(columns, results);
+  });
+  images.command("delete").description("Delete one or more images").argument("<uuid...>", "Image UUID(s)").option("-y, --yes", "Skip confirmation prompt").action(async (uuids, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    if (!opts.yes) {
+      const msg = uuids.length === 1 ? `Delete image ${uuids[0]}? This cannot be undone.` : `Delete ${uuids.length} images? This cannot be undone.`;
+      const proceed = await confirm3({ message: msg, default: false });
+      if (!proceed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    const results = [];
+    for (const uuid of uuids) {
+      try {
+        await client.delete(`/api/v1/cli/images/${uuid}`);
+        results.push({ uuid, status: "deleted" });
+        console.log(chalk4.green(`  \u2713 ${uuid}`));
+      } catch (err) {
+        const msg = err.message;
+        results.push({ uuid, status: "error", error: msg });
+        console.log(chalk4.red(`  \u2717 ${uuid}: ${msg}`));
+      }
+    }
+    if (globalOpts.output === "json") {
+      printJson(results);
+    }
+    const deleted = results.filter((r) => r.status === "deleted").length;
+    const failed = results.filter((r) => r.status === "error").length;
+    console.log();
+    if (failed > 0) {
+      console.log(`${deleted} deleted, ${chalk4.red(`${failed} failed`)}.`);
+      process.exit(1);
+    } else {
+      console.log(chalk4.green(`${deleted} deleted.`));
+    }
+  });
+  images.command("info").description("Show image metadata").argument("<uuid>", "Image UUID").action(async (uuid) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.get(`/api/v1/images/${uuid}/metadata`);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    for (const [key, value] of Object.entries(res)) {
+      console.log(`  ${chalk4.bold(key)}: ${value}`);
+    }
+  });
+  images.command("transform").description("Transform an image").option("--image <uuid>", "Image UUID").option("--ops <operations>", "Operations string (e.g. resize-800-600/sharp-1.2)").option("--format <ext>", "Output format (jpg, png, webp)").option("--list-ops", "List available operations and syntax").option("-i, --interactive", "Build operations string interactively").option("--open", "Open result URL in default browser").option("--download <path>", "Download result to local file").action(async (opts) => {
+    const globalOpts = program2.opts();
+    if (opts.listOps) {
+      renderOperationsList(globalOpts.output);
+      return;
+    }
+    if (opts.interactive) {
+      if (!opts.image) {
+        console.error(
+          chalk4.red(
+            "--image <uuid> is required. Use `viucraft images list` to find image UUIDs."
+          )
+        );
+        process.exit(1);
+      }
+      if (opts.ops) {
+        console.error(chalk4.yellow("Note: --ops ignored when --interactive is used."));
+      }
+      const opsString = await buildOpsInteractively();
+      if (!opsString) {
+        console.log("Aborted.");
+        return;
+      }
+      opts.ops = opsString;
+    }
+    if (!opts.image) {
+      console.error(chalk4.red("Missing required option: --image <uuid>"));
+      process.exit(1);
+    }
+    if (!opts.ops) {
+      console.error(chalk4.red("Missing required option: --ops <operations>"));
+      console.error(chalk4.dim("Use --interactive (-i) to build operations step by step."));
+      console.error(chalk4.dim("Use --list-ops to see available operations."));
+      process.exit(1);
+    }
+    const client = createClientFromGlobalOpts(globalOpts);
+    const body = {
+      uuid: opts.image,
+      operations: opts.ops
+    };
+    if (opts.format) body.format = opts.format;
+    const res = await client.post("/api/v1/cli/images/transform", body);
+    if (globalOpts.output === "json") {
+      printJson(res);
+    } else {
+      console.log(res.url);
+    }
+    if (opts.open) {
+      openInBrowser(res.url);
+      console.log(chalk4.dim("Opened in browser."));
+    }
+    if (opts.download) {
+      const spinner = ora("Downloading...").start();
+      try {
+        const saved = await downloadFile(res.url, opts.download);
+        spinner.succeed(`Downloaded to ${saved}`);
+      } catch (err) {
+        spinner.fail(`Download failed: ${err.message}`);
+        process.exit(1);
+      }
+    }
+  });
+  images.command("download").description("Download an image to a local file").argument("<uuid>", "Image UUID").option("--output <path>", "Output file path").option("--ops <operations>", "Apply operations before downloading").option("--format <ext>", "Output format (jpg, png, webp)").action(async (uuid, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const creds = resolveCredentials({
+      apiKey: globalOpts.apiKey,
+      profile: globalOpts.profile
+    });
+    let subdomain = creds.subdomain;
+    if (!subdomain) {
+      const whoami = await client.get("/api/v1/cli/whoami");
+      subdomain = whoami.customer.subdomain;
+    }
+    const metadata = await client.get(`/api/v1/images/${uuid}/metadata`);
+    const mimeType = metadata.mime_type ?? "image/jpeg";
+    const originalExt = mimeType.split("/").pop() ?? "jpg";
+    const format = opts.format ?? originalExt;
+    const url = buildImageUrl({
+      subdomain,
+      apiUrl: creds.apiUrl,
+      uuid,
+      format,
+      ops: opts.ops,
+      insecure: creds.insecure
+    });
+    const outputPath = opts.output ?? `${uuid}.${format}`;
+    const spinner = ora(`Downloading ${uuid}...`).start();
+    try {
+      const saved = await downloadFile(url, outputPath);
+      spinner.succeed(`Downloaded to ${saved}`);
+    } catch (err) {
+      spinner.fail(`Download failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  images.command("open").description("Open an image in the default browser").argument("<uuid>", "Image UUID").option("--ops <operations>", "Apply operations to the URL").option("--format <ext>", "Output format (jpg, png, webp)").action(async (uuid, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const creds = resolveCredentials({
+      apiKey: globalOpts.apiKey,
+      profile: globalOpts.profile
+    });
+    let subdomain = creds.subdomain;
+    if (!subdomain) {
+      const whoami = await client.get("/api/v1/cli/whoami");
+      subdomain = whoami.customer.subdomain;
+    }
+    const metadata = await client.get(`/api/v1/images/${uuid}/metadata`);
+    const mimeType = metadata.mime_type ?? "image/jpeg";
+    const originalExt = mimeType.split("/").pop() ?? "jpg";
+    const format = opts.format ?? originalExt;
+    const url = buildImageUrl({
+      subdomain,
+      apiUrl: creds.apiUrl,
+      uuid,
+      format,
+      ops: opts.ops,
+      insecure: creds.insecure
+    });
+    if (globalOpts.output === "json") {
+      printJson({ url });
+      return;
+    }
+    console.log(url);
+    openInBrowser(url);
+    console.log(chalk4.dim("Opened in browser."));
+  });
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / 1024 ** i;
+  return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+function formatDate(iso) {
+  const d = new Date(iso);
+  return d.toLocaleDateString("en-CA");
+}
+
+// src/commands/usage.ts
+import chalk5 from "chalk";
+function registerUsageCommand(program2) {
+  program2.command("usage").description("View account usage and limits").option("--daily", "Show daily breakdown").option("--start <date>", "Start date for daily view (YYYY-MM-DD)").option("--end <date>", "End date for daily view (YYYY-MM-DD)").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    if (opts.daily) {
+      const params = { period: "daily" };
+      if (opts.start) params.start_date = opts.start;
+      if (opts.end) params.end_date = opts.end;
+      const res = await client.get("/api/v1/usage", params);
+      if (globalOpts.output === "json") {
+        printJson(res);
+        return;
+      }
+      if (res.data.length === 0) {
+        console.log("No usage data for this period.");
+        return;
+      }
+      const rows = res.data.map((entry) => ({
+        date: entry.date,
+        requests: String(entry.requests),
+        storage: formatBytes2(entry.storage_bytes),
+        bandwidth: formatBytes2(entry.bandwidth_bytes)
+      }));
+      printTable(
+        [
+          { header: "Date", key: "date" },
+          { header: "Requests", key: "requests" },
+          { header: "Storage", key: "storage" },
+          { header: "Bandwidth", key: "bandwidth" }
+        ],
+        rows
+      );
+      console.log();
+      console.log(
+        chalk5.dim(
+          `${res.period.start_date} to ${res.period.end_date} | Plan: ${res.meta.plan} | ${res.meta.total_records} records`
+        )
+      );
+    } else {
+      const res = await client.get("/api/v1/usage", {
+        period: "current"
+      });
+      if (globalOpts.output === "json") {
+        printJson(res);
+        return;
+      }
+      console.log(chalk5.bold("Current Billing Cycle"));
+      console.log(
+        chalk5.dim(`Plan: ${res.meta.plan} | Ends: ${formatDate2(res.meta.billing_cycle_ends)}`)
+      );
+      console.log();
+      printMetric("Requests", res.data.requests);
+      printStorageMetric("Storage", res.data.storage);
+      printStorageMetric("Bandwidth", res.data.bandwidth);
+    }
+  });
+}
+function printMetric(label, metric) {
+  if (!metric) {
+    console.log(`  ${chalk5.bold(label.padEnd(12))} ${chalk5.dim("n/a")}`);
+    return;
+  }
+  const bar = progressBar2(metric.percent);
+  const pct = Math.round(metric.percent);
+  const color = pct >= 90 ? chalk5.red : pct >= 75 ? chalk5.yellow : chalk5.green;
+  console.log(
+    `  ${chalk5.bold(label.padEnd(12))} ${color(`${bar} ${pct}%`)}  ${metric.used.toLocaleString()} / ${metric.limit.toLocaleString()}`
+  );
+}
+function printStorageMetric(label, metric) {
+  if (!metric) {
+    console.log(`  ${chalk5.bold(label.padEnd(12))} ${chalk5.dim("n/a")}`);
+    return;
+  }
+  const bar = progressBar2(metric.percent);
+  const pct = Math.round(metric.percent);
+  const color = pct >= 90 ? chalk5.red : pct >= 75 ? chalk5.yellow : chalk5.green;
+  console.log(
+    `  ${chalk5.bold(label.padEnd(12))} ${color(`${bar} ${pct}%`)}  ${metric.formatted_used} / ${metric.formatted_limit}`
+  );
+}
+function progressBar2(percent, width = 20) {
+  if (percent == null || isNaN(percent)) return "\u2591".repeat(width);
+  const clamped = Math.max(0, Math.min(percent, 100));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / 1024 ** i;
+  return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+function formatDate2(iso) {
+  return new Date(iso).toLocaleDateString("en-CA");
+}
+
+// src/commands/presets.ts
+import { confirm as confirm4 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+function registerPresetsCommands(program2) {
+  const presets = program2.command("presets").description("Manage transformation presets");
+  presets.command("list").description("List all presets").action(async () => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.get("/api/v1/presets");
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    if (res.presets.length === 0) {
+      console.log("No presets found.");
+      return;
+    }
+    const rows = res.presets.map((p) => ({
+      name: p.name,
+      operations: formatOperations(p.operations),
+      format: p.format ?? "-",
+      quality: p.quality != null ? String(p.quality) : "-",
+      custom: p.is_custom ? "yes" : ""
+    }));
+    printTable(
+      [
+        { header: "Name", key: "name" },
+        { header: "Operations", key: "operations" },
+        { header: "Format", key: "format" },
+        { header: "Quality", key: "quality" },
+        { header: "Custom", key: "custom" }
+      ],
+      rows
+    );
+  });
+  presets.command("get").description("Get preset details").argument("<name>", "Preset name").action(async (name) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.get(`/api/v1/presets/${name}`);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log(`  ${chalk6.bold("Name")}:        ${res.name}`);
+    console.log(`  ${chalk6.bold("Operations")}:  ${formatOperations(res.operations)}`);
+    console.log(`  ${chalk6.bold("Format")}:      ${res.format ?? "-"}`);
+    console.log(`  ${chalk6.bold("Quality")}:     ${res.quality != null ? res.quality : "-"}`);
+    console.log(`  ${chalk6.bold("Custom")}:      ${res.is_custom ? "yes" : "no"}`);
+  });
+  presets.command("create").description("Create a custom preset").requiredOption("--name <name>", "Preset name").requiredOption("--ops <operations>", "Operations (comma-separated)").option("--description <text>", "Preset description").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const operations = opts.ops.split(",").map((s) => s.trim());
+    const res = await client.post("/api/v1/presets", {
+      name: opts.name,
+      operations,
+      description: opts.description
+    });
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log(chalk6.green(`Preset "${res.name}" created.`));
+  });
+  presets.command("delete").description("Delete a custom preset").argument("<name>", "Preset name").option("-y, --yes", "Skip confirmation prompt").action(async (name, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    if (!opts.yes) {
+      const proceed = await confirm4({
+        message: `Delete preset "${name}"?`,
+        default: false
+      });
+      if (!proceed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    await client.delete(`/api/v1/presets/${name}`);
+    console.log(chalk6.green(`Preset "${name}" deleted.`));
+  });
+}
+function formatOperations(ops) {
+  if (!Array.isArray(ops)) return String(ops);
+  return ops.map((op) => {
+    if (typeof op === "string") return op;
+    if (typeof op === "object" && op !== null && "name" in op) {
+      const o = op;
+      if (o.params) {
+        const params = Object.entries(o.params).map(([k, v]) => `${k}=${v}`).join(",");
+        return `${o.name}(${params})`;
+      }
+      return o.name;
+    }
+    return JSON.stringify(op);
+  }).join(" \u2192 ");
+}
+
+// src/commands/batch.ts
+import { readFileSync as readFileSync3, createWriteStream as createWriteStream2 } from "fs";
+import { pipeline as pipeline2 } from "stream/promises";
+import { Readable as Readable2 } from "stream";
+import chalk7 from "chalk";
+import ora2 from "ora";
+
+// src/lib/sse.ts
+import { createParser } from "eventsource-parser";
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["job.completed", "job.failed"]);
+async function streamSSE(opts) {
+  const { client, path, onEvent, onError } = opts;
+  let lastEventId = opts.lastEventId;
+  const response = await client.stream(path, lastEventId);
+  if (!response.body) {
+    throw new Error("No response body for SSE stream.");
+  }
+  return new Promise((resolve, reject) => {
+    let done = false;
+    const parser = createParser({
+      onEvent(event) {
+        if (done) return;
+        if (event.id) lastEventId = event.id;
+        if (!event.event) return;
+        try {
+          const data = JSON.parse(event.data);
+          const sseEvent = { type: event.event, data };
+          onEvent(sseEvent);
+          if (TERMINAL_EVENTS.has(event.event)) {
+            done = true;
+            resolve();
+          }
+        } catch (err) {
+          onError?.(err);
+        }
+      }
+    });
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    function read() {
+      reader.read().then(({ done: streamDone, value }) => {
+        if (done) return;
+        if (streamDone) {
+          resolve();
+          return;
+        }
+        const text = decoder.decode(value, { stream: true });
+        parser.feed(text);
+        read();
+      }).catch((err) => {
+        if (done) return;
+        reject(err);
+      });
+    }
+    read();
+  });
+}
+
+// src/commands/batch.ts
+function registerBatchCommands(program2) {
+  const batch = program2.command("batch").description("Create and manage batch processing jobs");
+  batch.command("create").description("Create a batch job").option("--file <path>", "JSON file with task definitions").option("--images <uuids>", "Comma-separated image UUIDs (alternative to --file)").option("--ops <operations>", "Operations string (required with --images)").option("--format <ext>", "Output format for inline tasks (jpg, png, webp)").option("--name <name>", "Job name").option("--webhook-url <url>", "Webhook URL for notifications").option("--priority <level>", "Priority: normal, high", "normal").action(async (opts) => {
+    const globalOpts = program2.opts();
+    if (opts.file && opts.images) {
+      console.error(chalk7.red("Options --file and --images are mutually exclusive."));
+      process.exit(1);
+    }
+    if (!opts.file && !opts.images) {
+      console.error(chalk7.red("Provide --file <path> or --images <uuids> with --ops."));
+      process.exit(1);
+    }
+    let tasks;
+    if (opts.images) {
+      if (!opts.ops) {
+        console.error(chalk7.red("--ops is required when using --images."));
+        process.exit(1);
+      }
+      const uuids = opts.images.split(",").map((s) => s.trim()).filter(Boolean);
+      if (uuids.length === 0) {
+        console.error(chalk7.red("No valid image UUIDs provided."));
+        process.exit(1);
+      }
+      tasks = uuids.map((uuid) => ({
+        image_id: uuid,
+        operations: opts.ops,
+        ...opts.format ? { format: opts.format } : {}
+      }));
+    } else {
+      try {
+        const raw = readFileSync3(opts.file, "utf-8");
+        const parsed = JSON.parse(raw);
+        tasks = Array.isArray(parsed) ? parsed : parsed.tasks;
+      } catch (err) {
+        console.error(chalk7.red(`Failed to read task file: ${err.message}`));
+        process.exit(1);
+      }
+    }
+    const client = createClientFromGlobalOpts(globalOpts);
+    const body = { tasks };
+    if (opts.name) body.name = opts.name;
+    if (opts.webhookUrl) body.webhook_url = opts.webhookUrl;
+    if (opts.priority) body.priority = opts.priority;
+    const spinner = ora2("Submitting batch job...").start();
+    const res = await client.post("/api/v1/jobs", body);
+    spinner.succeed("Batch job created.");
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log();
+    console.log(`  Job ID:     ${chalk7.bold(res.job_id)}`);
+    console.log(`  Name:       ${res.name ?? "-"}`);
+    console.log(`  Status:     ${res.status}`);
+    console.log(`  Tasks:      ${res.task_count}`);
+    console.log(`  ETA:        ${res.estimated_duration_seconds}s`);
+    console.log();
+    console.log(chalk7.dim(`Stream: viucraft batch stream ${res.job_id}`));
+  });
+  batch.command("list").description("List batch jobs").option("--page <number>", "Page number", "1").option("--per-page <number>", "Results per page", "20").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.get("/api/v1/jobs", {
+      page: opts.page,
+      per_page: opts.perPage
+    });
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    if (res.jobs.length === 0) {
+      console.log("No batch jobs found.");
+      return;
+    }
+    const rows = res.jobs.map((j) => ({
+      job_id: j.job_id,
+      name: j.name ?? "-",
+      status: colorStatus(j.status),
+      tasks: String(j.task_count),
+      completed: String(j.completed_count),
+      failed: j.failed_count > 0 ? chalk7.red(String(j.failed_count)) : "0",
+      priority: j.priority,
+      created: formatDate3(j.created_at)
+    }));
+    printTable(
+      [
+        { header: "Job ID", key: "job_id" },
+        { header: "Name", key: "name" },
+        { header: "Status", key: "status" },
+        { header: "Tasks", key: "tasks" },
+        { header: "Done", key: "completed" },
+        { header: "Failed", key: "failed" },
+        { header: "Priority", key: "priority" },
+        { header: "Created", key: "created" }
+      ],
+      rows
+    );
+  });
+  batch.command("status").description("Show job status").argument("<id>", "Job ID").action(async (id) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.get(`/api/v1/jobs/${id}`);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    const p = res.progress;
+    console.log(`Job ${chalk7.bold(res.job_id)} \u2014 ${colorStatus(res.status)}`);
+    console.log(
+      `${progressBar3(p.percent)} ${Math.round(p.percent)}%  ${p.completed}/${p.total} completed  ${p.failed} failed`
+    );
+    console.log();
+    if (res.tasks.data.length > 0) {
+      const rows = res.tasks.data.map((t) => ({
+        task_id: t.task_id,
+        status: colorStatus(t.status),
+        image: truncate(t.image_url, 40),
+        time: t.processing_ms != null ? `${t.processing_ms}ms` : "-",
+        error: t.error_message ?? ""
+      }));
+      printTable(
+        [
+          { header: "Task", key: "task_id" },
+          { header: "Status", key: "status" },
+          { header: "Image", key: "image" },
+          { header: "Time", key: "time" },
+          { header: "Error", key: "error" }
+        ],
+        rows
+      );
+      const pg = res.tasks.pagination;
+      console.log();
+      console.log(chalk7.dim(`Page ${pg.page}/${pg.total_pages} (${pg.total} total tasks)`));
+    }
+  });
+  batch.command("stream").description("Live stream job progress (SSE)").argument("<id>", "Job ID").action(async (id) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    let completed = 0;
+    let failed = 0;
+    let total = 0;
+    let status = "connecting";
+    function updateProgress() {
+      const pct = total > 0 ? Math.round((completed + failed) / total * 100) : 0;
+      const bar = progressBar3(pct);
+      const failedStr = failed > 0 ? chalk7.red(`  ${failed} failed`) : "";
+      process.stderr.write(`\r${bar} ${pct}%  ${completed}/${total} completed${failedStr}   `);
+    }
+    console.log(`Streaming job ${chalk7.bold(id)}...
+`);
+    try {
+      await streamSSE({
+        client,
+        path: `/api/v1/jobs/${id}/stream`,
+        onEvent(event) {
+          switch (event.type) {
+            case "job.started":
+              status = event.data.status;
+              console.log(chalk7.dim(`Job started \u2014 ${status}`));
+              break;
+            case "item.completed":
+              completed++;
+              updateProgress();
+              console.log(
+                `
+  ${chalk7.green("\u2713")} ${event.data.task_id}  ${event.data.processing_ms}ms`
+              );
+              break;
+            case "item.failed":
+              failed++;
+              updateProgress();
+              console.log(
+                `
+  ${chalk7.red("\u2717")} ${event.data.task_id}  ${event.data.error_message}`
+              );
+              break;
+            case "job.progress":
+              completed = event.data.completed;
+              failed = event.data.failed;
+              total = event.data.total;
+              updateProgress();
+              break;
+            case "job.completed":
+            case "job.failed":
+              status = event.data.status;
+              completed = event.data.completed_count;
+              failed = event.data.failed_count;
+              total = event.data.task_count;
+              updateProgress();
+              console.log(`
+
+Job ${colorStatus(status)}.`);
+              console.log(`  ${completed} completed, ${failed} failed out of ${total} tasks.`);
+              if (status === "completed" || status === "completed_with_errors") {
+                console.log(
+                  chalk7.dim(`
+Download: viucraft batch download ${event.data.job_id}`)
+                );
+              }
+              break;
+          }
+        }
+      });
+    } catch (err) {
+      console.error(chalk7.red(`
+Stream error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  batch.command("cancel").description("Cancel a job").argument("<id>", "Job ID").action(async (id) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.post(`/api/v1/jobs/${id}/cancel`);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log(chalk7.yellow(`Job ${res.job_id} cancelled.`));
+  });
+  batch.command("retry").description("Retry failed tasks in a job").argument("<id>", "Job ID").action(async (id) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.post(`/api/v1/jobs/${id}/retry`);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log(chalk7.green(`Job ${res.job_id} retry submitted.`));
+    console.log(`  Status: ${res.status}`);
+    console.log(`  Tasks:  ${res.task_count}`);
+    console.log();
+    console.log(chalk7.dim(`Stream: viucraft batch stream ${res.job_id}`));
+  });
+  batch.command("download").description("Download job results as ZIP").argument("<id>", "Job ID").option("--output <file>", "Output filename").action(async (id, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const outputFile = opts.output ?? `batch-${id}.zip`;
+    const spinner = ora2(`Downloading to ${outputFile}...`).start();
+    try {
+      const response = await client.getRaw(`/api/v1/jobs/${id}/download`);
+      if (!response.body) {
+        throw new Error("No response body.");
+      }
+      const nodeStream = Readable2.fromWeb(
+        response.body
+      );
+      const fileStream = createWriteStream2(outputFile);
+      await pipeline2(nodeStream, fileStream);
+      spinner.succeed(`Downloaded ${outputFile}`);
+    } catch (err) {
+      spinner.fail(`Download failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+function progressBar3(percent, width = 20) {
+  const clamped = Math.max(0, Math.min(percent, 100));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+function colorStatus(status) {
+  switch (status) {
+    case "completed":
+      return chalk7.green(status);
+    case "completed_with_errors":
+      return chalk7.yellow(status);
+    case "failed":
+    case "cancelled":
+      return chalk7.red(status);
+    case "processing":
+      return chalk7.cyan(status);
+    case "queued":
+    case "pending":
+      return chalk7.dim(status);
+    default:
+      return status;
+  }
+}
+function formatDate3(iso) {
+  return new Date(iso).toLocaleDateString("en-CA");
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+
+// src/commands/cache.ts
+import { confirm as confirm5 } from "@inquirer/prompts";
+import ora3 from "ora";
+function registerCacheCommands(program2) {
+  const cache = program2.command("cache").description("Purge and warm image caches");
+  cache.command("purge").description("Purge cached images").option("--image <uuid>", "Purge specific image (default: entire account)").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const scope = opts.image ? "image" : "account";
+    if (scope === "account" && !opts.yes) {
+      const proceed = await confirm5({
+        message: "Purge all cached images for the entire account?",
+        default: false
+      });
+      if (!proceed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    const body = { scope };
+    if (opts.image) body.image_id = opts.image;
+    const spinner = ora3("Purging cache...").start();
+    const res = await client.post("/api/cache/purge", body);
+    spinner.succeed("Cache purged.");
+    if (globalOpts.output === "json") {
+      printJson(res);
+    }
+  });
+  cache.command("warm").description("Pre-generate image variants").requiredOption("--image <uuid>", "Image UUID to warm").option("--ops <operations>", "Operations string (e.g. resize-300)").option("--format <ext>", "Output format (webp, jpg, png)", "webp").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const body = {
+      image_id: opts.image
+    };
+    if (opts.ops) {
+      body.variants = [
+        {
+          name: "CLI warm",
+          operations: opts.ops,
+          format: opts.format
+        }
+      ];
+    }
+    const spinner = ora3("Warming cache...").start();
+    const res = await client.post("/api/cache/warm", body);
+    spinner.succeed("Cache warmed.");
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log();
+    console.log(`  Warmed:     ${res.warmed}`);
+    console.log(`  Skipped:    ${res.skipped}`);
+    console.log(`  Failed:     ${res.failed}`);
+    console.log(`  Duration:   ${res.duration_ms}ms`);
+    console.log(`  Generated:  ${formatBytes3(res.bytes_generated)}`);
+  });
+}
+function formatBytes3(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / 1024 ** i;
+  return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+
+// src/commands/webhooks.ts
+import { confirm as confirm6 } from "@inquirer/prompts";
+import chalk8 from "chalk";
+function registerWebhooksCommands(program2) {
+  const webhooks = program2.command("webhooks").description("Manage webhook endpoints");
+  webhooks.command("list").description("List configured webhooks").action(async () => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.get("/api/webhooks");
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    if (res.endpoints.length === 0) {
+      console.log("No webhooks configured.");
+      return;
+    }
+    const rows = res.endpoints.map((ep) => ({
+      id: String(ep.id),
+      url: ep.url,
+      events: ep.events.join(", "),
+      active: ep.is_active ? "yes" : "no",
+      created: formatDate4(ep.created_at)
+    }));
+    printTable(
+      [
+        { header: "ID", key: "id" },
+        { header: "URL", key: "url" },
+        { header: "Events", key: "events" },
+        { header: "Active", key: "active" },
+        { header: "Created", key: "created" }
+      ],
+      rows
+    );
+    console.log();
+    console.log(chalk8.dim(`${res.endpoints.length}/${res.limit} endpoints used`));
+  });
+  webhooks.command("create").description("Create a webhook").requiredOption("--url <url>", "Webhook endpoint URL (must be HTTPS)").requiredOption("--events <events>", "Comma-separated event types").option("--description <text>", "Endpoint description").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const events = opts.events.split(",").map((s) => s.trim());
+    const res = await client.post("/api/webhooks", {
+      url: opts.url,
+      events,
+      description: opts.description
+    });
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    console.log(chalk8.green("Webhook created."));
+    console.log();
+    console.log(`  ID:      ${res.id}`);
+    console.log(`  URL:     ${res.url}`);
+    console.log(`  Events:  ${res.events.join(", ")}`);
+    console.log();
+    console.log(chalk8.yellow.bold("  Secret:  " + res.secret));
+    console.log(chalk8.yellow("  Save this secret now \u2014 it will not be shown again."));
+  });
+  webhooks.command("delete").description("Delete a webhook").argument("<id>", "Webhook ID").option("-y, --yes", "Skip confirmation prompt").action(async (id, opts) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    if (!opts.yes) {
+      const proceed = await confirm6({
+        message: `Delete webhook ${id}?`,
+        default: false
+      });
+      if (!proceed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    await client.delete(`/api/webhooks/${id}`);
+    console.log(chalk8.green(`Webhook ${id} deleted.`));
+  });
+  webhooks.command("test").description("Send a test event to a webhook").argument("<id>", "Webhook ID").action(async (id) => {
+    const globalOpts = program2.opts();
+    const client = createClientFromGlobalOpts(globalOpts);
+    const res = await client.post(`/api/webhooks/${id}/test`);
+    if (globalOpts.output === "json") {
+      printJson(res);
+      return;
+    }
+    if (res.success) {
+      console.log(
+        chalk8.green(`\u2713 Webhook responded with ${res.statusCode} in ${res.responseTime}ms`)
+      );
+    } else {
+      console.log(
+        chalk8.red(
+          `\u2717 Webhook failed: ${res.error ?? `HTTP ${res.statusCode}`} (${res.responseTime}ms)`
+        )
+      );
+    }
+  });
+}
+function formatDate4(iso) {
+  return new Date(iso).toLocaleDateString("en-CA");
+}
+
+// src/commands/config.ts
+import chalk9 from "chalk";
+var KNOWN_KEYS = {
+  "defaults.output_format": "Default output format (table or json)",
+  "defaults.color": "Enable colored output (true or false)"
+};
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("View and modify CLI configuration");
+  config.command("set").description("Set a config value").argument("<key>", "Config key (e.g. defaults.output_format)").argument("<value>", "Config value").action(async (key, value) => {
+    const cfg = loadConfig();
+    if (!KNOWN_KEYS[key]) {
+      console.error(chalk9.yellow(`Warning: "${key}" is not a recognized config key.`));
+      console.log("Known keys:");
+      for (const [k, desc] of Object.entries(KNOWN_KEYS)) {
+        console.log(`  ${k} \u2014 ${desc}`);
+      }
+      return;
+    }
+    const parts = key.split(".");
+    let target = cfg;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (typeof target[parts[i]] !== "object" || target[parts[i]] === null) {
+        target[parts[i]] = {};
+      }
+      target = target[parts[i]];
+    }
+    const finalKey = parts[parts.length - 1];
+    const parsed = value === "true" ? true : value === "false" ? false : value;
+    target[finalKey] = parsed;
+    saveConfig(cfg);
+    console.log(chalk9.green(`Set ${key} = ${value}`));
+  });
+  config.command("get").description("Get a config value").argument("<key>", "Config key (e.g. defaults.output_format)").action(async (key) => {
+    const cfg = loadConfig();
+    const parts = key.split(".");
+    let value = cfg;
+    for (const part of parts) {
+      if (typeof value !== "object" || value === null) {
+        console.error(chalk9.red(`Key "${key}" not found.`));
+        process.exit(1);
+      }
+      value = value[part];
+    }
+    if (value === void 0) {
+      console.error(chalk9.red(`Key "${key}" not found.`));
+      process.exit(1);
+    }
+    console.log(String(value));
+  });
+  config.command("list").description("Show all configuration").action(async () => {
+    const globalOpts = program2.opts();
+    const cfg = loadConfig();
+    const masked = structuredClone(cfg);
+    for (const profile of Object.values(masked.profiles)) {
+      profile.api_key = maskApiKey(profile.api_key);
+    }
+    if (globalOpts.output === "json") {
+      printJson(masked);
+      return;
+    }
+    console.log(chalk9.bold("Configuration"));
+    console.log(chalk9.dim(`File: ${getConfigPath()}`));
+    console.log();
+    console.log(`  current_profile: ${cfg.current_profile || chalk9.dim("(none)")}`);
+    console.log();
+    console.log(chalk9.bold("  Defaults"));
+    console.log(`    output_format: ${cfg.defaults.output_format}`);
+    console.log(`    color:         ${cfg.defaults.color}`);
+    const profileNames = Object.keys(cfg.profiles);
+    if (profileNames.length > 0) {
+      console.log();
+      console.log(chalk9.bold("  Profiles"));
+      for (const name of profileNames) {
+        const p = cfg.profiles[name];
+        const marker = name === cfg.current_profile ? chalk9.green(" *") : "";
+        console.log(`    ${name}${marker}`);
+        console.log(`      api_key:    ${maskApiKey(p.api_key)}`);
+        console.log(`      api_url:    ${p.api_url}`);
+        console.log(`      env:        ${p.environment}`);
+        console.log(`      email:      ${p.customer_email}`);
+        console.log(`      plan:       ${p.plan}`);
+        console.log(`      subdomain:  ${p.subdomain}`);
+      }
+    }
+  });
+}
+
+// src/commands/version.ts
+import { arch as arch2, platform as platform3 } from "os";
+function registerVersionCommand(program2) {
+  program2.command("version").description("Show CLI version information").option("--json", "Output as JSON").action((opts) => {
+    const info = {
+      version: "0.1.1",
+      node: process.version,
+      platform: `${platform3()}/${arch2()}`
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(info, null, 2));
+    } else {
+      console.log(`viucraft ${info.version}`);
+      console.log(`  Node:      ${info.node}`);
+      console.log(`  Platform:  ${info.platform}`);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("viucraft").description("Official CLI for the VIUCraft image manipulation API").version("0.1.1", "-v, --version").option("--api-key <key>", "API key (overrides profile config)").option("--profile <name>", "Named profile to use").option("--output <format>", "Output format: table, json", "table").option("--no-color", "Disable colored output").option("--debug", "Enable debug output (shows HTTP requests)").option("--insecure", "Allow HTTP connections (dev only)");
+registerAuthCommands(program);
+registerImagesCommands(program);
+registerUsageCommand(program);
+registerPresetsCommands(program);
+registerBatchCommands(program);
+registerCacheCommands(program);
+registerWebhooksCommands(program);
+registerConfigCommands(program);
+registerVersionCommand(program);
+var CMDS = "auth images usage presets batch cache webhooks config completion docs version";
+var SUBCMDS = {
+  auth: "login status switch list logout",
+  images: "list upload delete info transform download open",
+  presets: "list get create delete",
+  batch: "create list status stream cancel retry download",
+  cache: "purge warm",
+  webhooks: "list create delete test",
+  config: "set get list",
+  completion: "bash zsh fish"
+};
+function generateCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return [
+        "# viucraft bash completion",
+        "_viucraft() {",
+        "  local cur prev cmds",
+        '  cur="${COMP_WORDS[COMP_CWORD]}"',
+        '  prev="${COMP_WORDS[COMP_CWORD-1]}"',
+        `  cmds="${CMDS}"`,
+        '  case "${prev}" in',
+        ...Object.entries(SUBCMDS).map(
+          ([cmd, subs]) => `    ${cmd}) COMPREPLY=( $(compgen -W "${subs}" -- "\${cur}") ); return ;;`
+        ),
+        "  esac",
+        "  if [[ ${COMP_CWORD} -eq 1 ]]; then",
+        '    COMPREPLY=( $(compgen -W "${cmds}" -- "${cur}") )',
+        "  fi",
+        "}",
+        "complete -F _viucraft viucraft"
+      ].join("\n");
+    case "zsh":
+      return [
+        "#compdef viucraft",
+        "_viucraft() {",
+        "  local -a commands",
+        "  commands=(",
+        ...CMDS.split(" ").map((c) => `    '${c}:${c} command'`),
+        "  )",
+        "  _arguments '1: :->cmd' '2: :->sub'",
+        "  case $state in",
+        "    cmd) _describe 'command' commands ;;",
+        "    sub)",
+        "      case $words[2] in",
+        ...Object.entries(SUBCMDS).map(([cmd, subs]) => `        ${cmd}) compadd ${subs} ;;`),
+        "      esac ;;",
+        "  esac",
+        "}",
+        "_viucraft"
+      ].join("\n");
+    case "fish":
+      return [
+        "# viucraft fish completion",
+        ...CMDS.split(" ").map((c) => `complete -c viucraft -n '__fish_use_subcommand' -a '${c}'`),
+        ...Object.entries(SUBCMDS).flatMap(
+          ([cmd, subs]) => subs.split(" ").map((s) => `complete -c viucraft -n '__fish_seen_subcommand_from ${cmd}' -a '${s}'`)
+        )
+      ].join("\n");
+    default:
+      return `# Unsupported shell: ${shell}`;
+  }
+}
+var completion = program.command("completion").description("Generate shell completion scripts");
+for (const shell of ["bash", "zsh", "fish"]) {
+  completion.command(shell).description(`Output ${shell} completion script`).action(() => {
+    console.log(generateCompletion(shell));
+  });
+}
+program.command("docs").description("Open VIUCraft documentation in browser").action(() => {
+  const url = "https://docs.viucraft.com/cli";
+  openInBrowser(url);
+});
+program.parseAsync().catch((err) => {
+  if (err instanceof CliError) {
+    console.error(err.message);
+    if (err.requestId) {
+      console.error(`Request ID: ${err.requestId}`);
+    }
+    process.exit(err.exitCode);
+  }
+  console.error(err.message ?? err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map