shorter.sh 1.0.0

package/dist/cli.js

@@ -0,0 +1,755 @@
+#!/usr/bin/env node
+
+// src/errors.ts
+var ShorterError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "ShorterError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var ValidationError = class extends ShorterError {
+  constructor(message, code = "VALIDATION_ERROR") {
+    super(message, 400, code);
+    this.name = "ValidationError";
+  }
+};
+var AuthenticationError = class extends ShorterError {
+  constructor(message, code = "AUTH_REQUIRED") {
+    super(message, 401, code);
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends ShorterError {
+  constructor(message, code = "FORBIDDEN") {
+    super(message, 403, code);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends ShorterError {
+  constructor(message, code = "NOT_FOUND") {
+    super(message, 404, code);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends ShorterError {
+  constructor(message, code = "RATE_LIMITED") {
+    super(message, 429, code);
+    this.name = "RateLimitError";
+  }
+};
+var ServerError = class extends ShorterError {
+  constructor(message, code = "SERVER_ERROR") {
+    super(message, 500, code);
+    this.name = "ServerError";
+  }
+};
+var NetworkError = class extends ShorterError {
+  constructor(message) {
+    super(message, 0, "NETWORK_ERROR");
+    this.name = "NetworkError";
+  }
+};
+function mapStatusToError(status, message, code) {
+  switch (status) {
+    case 400:
+      return new ValidationError(message, code);
+    case 401:
+      return new AuthenticationError(message, code);
+    case 403:
+      return new ForbiddenError(message, code);
+    case 404:
+      return new NotFoundError(message, code);
+    case 429:
+      return new RateLimitError(message, code);
+    default:
+      if (status >= 500) return new ServerError(message, code);
+      return new ShorterError(message, status, code);
+  }
+}
+
+// src/fetch-wrapper.ts
+var FetchWrapper = class {
+  baseUrl;
+  apiKey;
+  fetchFn;
+  constructor(baseUrl, apiKey, fetchFn) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+    this.fetchFn = fetchFn;
+  }
+  async request(path2, options = {}) {
+    const { method = "GET", body, params } = options;
+    let url = `${this.baseUrl}${path2}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      }
+      const qs = searchParams.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Accept": "application/json"
+    };
+    const init = { method, headers };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    let response;
+    try {
+      response = await this.fetchFn(url, init);
+    } catch (err) {
+      throw new NetworkError(
+        err instanceof Error ? err.message : "Network request failed"
+      );
+    }
+    const data = await response.json();
+    if (!response.ok || data.success === false) {
+      throw mapStatusToError(
+        response.status,
+        data.message || `Request failed with status ${response.status}`,
+        data.code || "UNKNOWN_ERROR"
+      );
+    }
+    return data;
+  }
+};
+
+// src/analytics.ts
+function mapTimeseries(raw) {
+  return raw.map((p) => ({
+    period: p.period,
+    clicks: p.clicks,
+    uniqueVisitors: p.unique_visitors
+  }));
+}
+function mapTopUrl(raw) {
+  return {
+    shortCode: raw.short_code,
+    shortUrl: raw.short_url,
+    originalUrl: raw.original_url,
+    clicks: raw.clicks
+  };
+}
+var AnalyticsClient = class {
+  fetch;
+  constructor(fetchWrapper) {
+    this.fetch = fetchWrapper;
+  }
+  async overview(options) {
+    const raw = await this.fetch.request("/api/v1/analytics/overview", {
+      params: {
+        start: options?.start !== void 0 ? String(options.start) : void 0,
+        end: options?.end !== void 0 ? String(options.end) : void 0
+      }
+    });
+    const timeseries = raw.timeseries;
+    const topUrls = raw.topUrls;
+    return {
+      totalClicks: raw.totalClicks,
+      uniqueVisitors: raw.uniqueVisitors,
+      prevPeriodClicks: raw.prevPeriodClicks,
+      prevPeriodUnique: raw.prevPeriodUnique,
+      timeseries: {
+        granularity: timeseries.granularity,
+        data: mapTimeseries(timeseries.data)
+      },
+      topUrls: topUrls.map(mapTopUrl),
+      countryBreakdown: raw.countryBreakdown,
+      deviceBreakdown: raw.deviceBreakdown,
+      browserBreakdown: raw.browserBreakdown,
+      osBreakdown: raw.osBreakdown,
+      referrerBreakdown: raw.referrerBreakdown
+    };
+  }
+  async url(shortCode, options) {
+    const raw = await this.fetch.request(`/api/v1/analytics/${shortCode}`, {
+      params: {
+        start: options?.start !== void 0 ? String(options.start) : void 0,
+        end: options?.end !== void 0 ? String(options.end) : void 0,
+        dimension: options?.dimension,
+        limit: options?.limit,
+        detail: options?.detail ? "true" : void 0
+      }
+    });
+    const timeseries = raw.timeseries;
+    const mappedTimeseries = {
+      granularity: timeseries.granularity,
+      data: mapTimeseries(timeseries.data)
+    };
+    if (options?.detail) {
+      return {
+        url: raw.url,
+        summary: raw.summary,
+        timeseries: mappedTimeseries,
+        breakdowns: raw.breakdowns
+      };
+    }
+    const result = {
+      summary: raw.summary,
+      timeseries: mappedTimeseries
+    };
+    if (raw.breakdown) {
+      result.breakdown = raw.breakdown;
+    }
+    return result;
+  }
+};
+
+// src/client.ts
+function mapUrl(raw) {
+  return {
+    id: raw.id,
+    shortCode: raw.short_code,
+    shortUrl: raw.short_url,
+    originalUrl: raw.original_url,
+    clickCount: raw.click_count,
+    createdAt: new Date(raw.created_at).toISOString()
+  };
+}
+var ShorterClient = class {
+  analytics;
+  fetch;
+  constructor(options) {
+    const apiKey = options?.apiKey || (typeof process !== "undefined" ? process.env.SHORTER_API_KEY : void 0);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "API key is required. Pass it as options.apiKey or set SHORTER_API_KEY environment variable.",
+        "AUTH_REQUIRED"
+      );
+    }
+    if (!apiKey.startsWith("sk_")) {
+      throw new AuthenticationError(
+        'Invalid API key format. Keys must start with "sk_".',
+        "INVALID_API_KEY"
+      );
+    }
+    const baseUrl = options?.baseUrl || "https://shorter.sh";
+    const fetchFn = options?.fetch || globalThis.fetch;
+    this.fetch = new FetchWrapper(baseUrl, apiKey, fetchFn);
+    this.analytics = new AnalyticsClient(this.fetch);
+  }
+  async shorten(url) {
+    const data = await this.fetch.request("/api/v1/shorten", {
+      method: "POST",
+      body: { url }
+    });
+    return {
+      shortCode: data.shortCode,
+      shortUrl: data.shortUrl,
+      originalUrl: data.originalUrl
+    };
+  }
+  async list(options) {
+    const data = await this.fetch.request("/api/v1/urls", {
+      params: {
+        page: options?.page,
+        limit: options?.limit
+      }
+    });
+    return {
+      urls: data.data.map(mapUrl),
+      pagination: data.pagination,
+      totalClicks: data.totalClicks
+    };
+  }
+  async delete(shortCode) {
+    const data = await this.fetch.request(`/api/v1/urls/${shortCode}`, {
+      method: "DELETE"
+    });
+    return { message: data.message };
+  }
+};
+
+// src/cli/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function getConfigDir() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "shorter");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(xdg, "shorter");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function resolveApiKey() {
+  return process.env.SHORTER_API_KEY || loadConfig().apiKey;
+}
+function resolveBaseUrl() {
+  return process.env.SHORTER_BASE_URL || loadConfig().baseUrl || "https://shorter.sh";
+}
+
+// src/cli/prompt.ts
+import * as readline from "readline";
+function prompt(question) {
+  if (!process.stdin.isTTY) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function confirm(question) {
+  const answer = await prompt(`${question} [y/N] `);
+  return answer !== null && /^y(es)?$/i.test(answer);
+}
+
+// src/cli/output.ts
+var isColorSupported = !process.env.NO_COLOR && process.stdout.isTTY;
+function wrap(code, text) {
+  return isColorSupported ? `\x1B[${code}m${text}\x1B[0m` : text;
+}
+var bold = (s) => wrap("1", s);
+var dim = (s) => wrap("2", s);
+var green = (s) => wrap("32", s);
+var red = (s) => wrap("31", s);
+var yellow = (s) => wrap("33", s);
+var cyan = (s) => wrap("36", s);
+function success(msg) {
+  console.log(`${green("\u2713")} ${msg}`);
+}
+function error(msg) {
+  console.error(`${red("\u2717")} ${msg}`);
+}
+function warning(msg) {
+  console.log(`${yellow("!")} ${msg}`);
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const maxRow = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
+    return Math.max(h.length, maxRow);
+  });
+  const headerLine = headers.map((h, i) => bold(h.padEnd(widths[i]))).join("  ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("  ");
+  console.log(headerLine);
+  console.log(dim(separator));
+  for (const row of rows) {
+    const line = row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+    console.log(line);
+  }
+}
+function progressBar(value, max, width = 20) {
+  const ratio = max > 0 ? value / max : 0;
+  const filled = Math.round(ratio * width);
+  return "\u2588".repeat(filled) + dim("\u2591".repeat(width - filled));
+}
+
+// src/cli/clipboard.ts
+import { execSync } from "child_process";
+function copyToClipboard(text) {
+  try {
+    const platform = process.platform;
+    let cmd;
+    if (platform === "darwin") {
+      cmd = "pbcopy";
+    } else if (platform === "win32") {
+      cmd = "clip.exe";
+    } else {
+      cmd = tryLinuxClipboard(text);
+      return cmd !== "";
+    }
+    execSync(cmd, {
+      input: text,
+      stdio: ["pipe", "ignore", "ignore"],
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tryLinuxClipboard(text) {
+  const commands = [
+    "xclip -selection clipboard",
+    "xsel --clipboard --input",
+    "wl-copy"
+  ];
+  for (const cmd of commands) {
+    try {
+      execSync(cmd, {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"],
+        timeout: 3e3
+      });
+      return cmd;
+    } catch {
+      continue;
+    }
+  }
+  return "";
+}
+
+// src/cli/commands/shorten.ts
+async function shortenCommand(client, url, flags) {
+  const result = await client.shorten(url);
+  success(bold(green(result.shortUrl)));
+  if (flags["no-copy"] !== true) {
+    const copied = copyToClipboard(result.shortUrl);
+    if (copied) {
+      console.log(`  ${dim("Copied to clipboard!")}`);
+    }
+  }
+}
+
+// src/cli/commands/list.ts
+async function listCommand(client, flags) {
+  const page = flags.page ? parseInt(String(flags.page), 10) : void 0;
+  const limit = flags.limit ? parseInt(String(flags.limit), 10) : void 0;
+  const result = await client.list({ page, limit });
+  if (result.urls.length === 0) {
+    warning("No URLs found. Shorten one with: shorter <url>");
+    return;
+  }
+  const headers = ["SHORT URL", "ORIGINAL", "CLICKS", "CREATED"];
+  const rows = result.urls.map((u) => [
+    u.shortUrl,
+    truncate(u.originalUrl, 35),
+    formatNumber(u.clickCount).padStart(6),
+    u.createdAt.split("T")[0]
+  ]);
+  table(headers, rows);
+  const { pagination, totalClicks } = result;
+  console.log(
+    `
+${dim(`Page ${pagination.page}/${pagination.totalPages} \xB7 ${formatNumber(pagination.total)} URLs \xB7 ${formatNumber(totalClicks)} total clicks`)}`
+  );
+}
+
+// src/cli/commands/delete.ts
+async function deleteCommand(client, shortCode, flags) {
+  if (!/^[a-zA-Z0-9]{6}$/.test(shortCode)) {
+    error("Invalid short code. Must be 6 alphanumeric characters.");
+    process.exit(1);
+  }
+  if (flags.yes !== true) {
+    const ok = await confirm(`Delete ${bold(shortCode)}?`);
+    if (!ok) {
+      console.log(dim("Cancelled."));
+      return;
+    }
+  }
+  await client.delete(shortCode);
+  success(`Deleted ${bold(shortCode)}`);
+}
+
+// src/cli/commands/analytics.ts
+function formatChange(current, previous) {
+  if (previous === 0) return "";
+  const pct = (current - previous) / previous * 100;
+  const sign = pct >= 0 ? "+" : "";
+  const color = pct >= 0 ? green : red;
+  return color(` (${sign}${pct.toFixed(1)}%)`);
+}
+function printBreakdown(title, items, maxItems = 5) {
+  if (!items || items.length === 0) return;
+  console.log(`
+${bold(title)}`);
+  const topItems = items.slice(0, maxItems);
+  const maxClicks = topItems[0]?.clicks || 1;
+  for (const item of topItems) {
+    const bar = progressBar(item.clicks, maxClicks);
+    console.log(
+      `  ${(item.value || "Unknown").padEnd(8)}${formatNumber(item.clicks).padStart(8)}  ${item.percentage.toFixed(1).padStart(5)}%  ${bar}`
+    );
+  }
+}
+async function analyticsCommand(client, shortCode, flags) {
+  const start = flags.start ? String(flags.start) : void 0;
+  const end = flags.end ? String(flags.end) : void 0;
+  const dimension = flags.dimension ? String(flags.dimension) : void 0;
+  if (!shortCode) {
+    const data = await client.analytics.overview({ start, end });
+    console.log(bold("\nAnalytics Overview") + dim(" (last 30 days)\n"));
+    console.log(`  Total Clicks:      ${bold(formatNumber(data.totalClicks))}${formatChange(data.totalClicks, data.prevPeriodClicks)}`);
+    if (data.uniqueVisitors !== null) {
+      console.log(`  Unique Visitors:   ${bold(formatNumber(data.uniqueVisitors))}${formatChange(data.uniqueVisitors, data.prevPeriodUnique ?? 0)}`);
+    }
+    if (data.topUrls.length > 0) {
+      console.log(`
+${bold("Top URLs")}`);
+      for (const url of data.topUrls.slice(0, 5)) {
+        console.log(`  ${url.shortUrl.padEnd(30)} ${formatNumber(url.clicks).padStart(6)} clicks  ${dim(truncate(url.originalUrl, 40))}`);
+      }
+    }
+    printBreakdown("Countries", data.countryBreakdown);
+    printBreakdown("Devices", data.deviceBreakdown);
+    printBreakdown("Browsers", data.browserBreakdown);
+    console.log();
+  } else {
+    const opts = { start, end };
+    if (dimension) {
+      opts.dimension = dimension;
+    }
+    const data = await client.analytics.url(shortCode, opts);
+    console.log(bold(`
+Analytics for ${shortCode}
+`));
+    console.log(`  Total Clicks:      ${bold(formatNumber(data.summary.totalClicks))}${formatChange(data.summary.totalClicks, data.summary.prevPeriodClicks)}`);
+    if (data.summary.uniqueVisitors !== null) {
+      console.log(`  Unique Visitors:   ${bold(formatNumber(data.summary.uniqueVisitors))}${formatChange(data.summary.uniqueVisitors, data.summary.prevPeriodUnique ?? 0)}`);
+    }
+    if (data.summary.topCountry) console.log(`  Top Country:       ${data.summary.topCountry}`);
+    if (data.summary.topReferrer) console.log(`  Top Referrer:      ${data.summary.topReferrer}`);
+    if (data.summary.topDevice) console.log(`  Top Device:        ${data.summary.topDevice}`);
+    if ("breakdown" in data && data.breakdown) {
+      printBreakdown(data.breakdown.dimension, data.breakdown.data);
+    }
+    console.log();
+  }
+}
+
+// src/cli/commands/config.ts
+function configCommand(positional) {
+  const action = positional[0];
+  if (action === "path") {
+    console.log(getConfigPath());
+    return;
+  }
+  if (action === "get") {
+    const key = positional[1];
+    const config = loadConfig();
+    if (key === "api-key") {
+      if (config.apiKey) {
+        const masked = config.apiKey.slice(0, 5) + "\u2022\u2022\u2022\u2022" + config.apiKey.slice(-4);
+        console.log(masked);
+      } else {
+        warning("No API key configured.");
+      }
+    } else if (key === "base-url") {
+      console.log(config.baseUrl || "https://shorter.sh (default)");
+    } else {
+      error(`Unknown config key: ${key}. Valid keys: api-key, base-url`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (action === "set") {
+    const key = positional[1];
+    const value = positional[2];
+    if (!value) {
+      error(`Missing value for ${key}.`);
+      process.exit(1);
+    }
+    const config = loadConfig();
+    if (key === "api-key") {
+      if (!value.startsWith("sk_")) {
+        error('Invalid API key format. Keys must start with "sk_".');
+        process.exit(1);
+      }
+      config.apiKey = value;
+      saveConfig(config);
+      success("API key saved.");
+    } else if (key === "base-url") {
+      try {
+        new URL(value);
+      } catch {
+        error("Invalid URL.");
+        process.exit(1);
+      }
+      config.baseUrl = value;
+      saveConfig(config);
+      success(`Base URL set to ${value}`);
+    } else {
+      error(`Unknown config key: ${key}. Valid keys: api-key, base-url`);
+      process.exit(1);
+    }
+    return;
+  }
+  error("Usage: shorter config <set|get|path> [key] [value]");
+  process.exit(1);
+}
+
+// src/cli/index.ts
+var VERSION = "1.0.0";
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+function showHelp() {
+  console.log(`
+${bold("shorter.sh")} \u2014 URL shortener CLI
+
+${bold("Usage:")}
+  shorter <url>                         Shorten a URL
+  shorter list [--page N] [--limit N]   List your URLs
+  shorter delete <shortCode> [--yes]    Delete a URL
+  shorter analytics [shortCode]         View analytics
+  shorter config <set|get|path> [...]   Manage configuration
+
+${bold("Options:")}
+  --no-copy          Don't copy to clipboard
+  --start <date>     Analytics start date
+  --end <date>       Analytics end date
+  --dimension <dim>  Analytics breakdown dimension
+  --yes              Skip confirmation prompts
+  -h, --help         Show help
+  -v, --version      Show version
+
+${bold("Aliases:")}
+  ls \u2192 list, rm \u2192 delete, stats \u2192 analytics
+
+${bold("Examples:")}
+  shorter https://example.com
+  shorter list --limit 10
+  shorter analytics xK9mP2 --dimension country
+  shorter config set api-key sk_your_key_here
+`);
+}
+async function ensureApiKey() {
+  let apiKey = resolveApiKey();
+  if (apiKey) return apiKey;
+  console.log(bold("\nWelcome to shorter.sh!\n"));
+  console.log("To get started, you need an API key.");
+  console.log(`Get one at: ${cyan("https://shorter.sh/dashboard")}
+`);
+  const input = await prompt("Enter your API key: ");
+  apiKey = input ?? void 0;
+  if (!apiKey) {
+    error("API key is required. Set it with: shorter config set api-key <key>");
+    process.exit(1);
+  }
+  if (!apiKey.startsWith("sk_")) {
+    error('Invalid API key format. Keys must start with "sk_".');
+    process.exit(1);
+  }
+  const config = loadConfig();
+  config.apiKey = apiKey;
+  saveConfig(config);
+  success("API key saved!\n");
+  return apiKey;
+}
+async function main() {
+  const { flags, positional } = parseArgs(process.argv.slice(2));
+  if (flags.h === true || flags.help === true || positional[0] === "help") {
+    showHelp();
+    return;
+  }
+  if (flags.v === true || flags.version === true) {
+    console.log(VERSION);
+    return;
+  }
+  if (positional[0] === "config") {
+    configCommand(positional.slice(1));
+    return;
+  }
+  let command;
+  let commandArgs;
+  const first = positional[0];
+  if (!first) {
+    showHelp();
+    return;
+  }
+  if (first.startsWith("http://") || first.startsWith("https://")) {
+    command = "shorten";
+    commandArgs = [first];
+  } else {
+    const aliases = { ls: "list", rm: "delete", stats: "analytics" };
+    command = aliases[first] || first;
+    commandArgs = positional.slice(1);
+  }
+  const apiKey = await ensureApiKey();
+  const client = new ShorterClient({ apiKey, baseUrl: resolveBaseUrl() });
+  switch (command) {
+    case "shorten":
+      if (!commandArgs[0]) {
+        error("URL is required. Usage: shorter <url>");
+        process.exit(1);
+      }
+      await shortenCommand(client, commandArgs[0], flags);
+      break;
+    case "list":
+      await listCommand(client, flags);
+      break;
+    case "delete":
+      if (!commandArgs[0]) {
+        error("Short code is required. Usage: shorter delete <shortCode>");
+        process.exit(1);
+      }
+      await deleteCommand(client, commandArgs[0], flags);
+      break;
+    case "analytics":
+      await analyticsCommand(client, commandArgs[0], flags);
+      break;
+    default:
+      error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  if (err instanceof ShorterError) {
+    error(err.message);
+    if (err.code) {
+      console.error(dim(`  Code: ${err.code}`));
+    }
+  } else {
+    error(err instanceof Error ? err.message : "An unexpected error occurred.");
+  }
+  process.exit(1);
+});