peakurl 0.1.2 → 0.3.0

package/bin/peakurl.js

@@ -1,19 +1,25 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 
+// src/commands/links.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, resolve } from "path";
+
 // src/lib/errors.ts
 var CliError = class extends Error {
   exitCode;
+  kind;
   constructor(message, exitCode = 1, options) {
     super(message, options);
     this.name = "CliError";
     this.exitCode = exitCode;
+    this.kind = options?.kind;
   }
 };
-function wrapCliError(error) {
+function ensureCliError(error) {
   if (error instanceof CliError) {
     return error;
   }
@@ -32,28 +38,30 @@ function validateHttpUrl(parsed, label) {
     throw new CliError(`${label} must not include embedded credentials.`);
   }
 }
-function normalizeBaseUrl(value) {
+function getApiBaseUrl(value) {
   const input = value.trim();
   if (!input) {
-    throw new CliError("A PeakURL base URL is required.");
+    throw new CliError("A PeakURL API base URL is required.");
   }
   let parsed;
   try {
     parsed = new URL(input);
   } catch {
-    throw new CliError(`Invalid base URL: ${value}`);
+    throw new CliError(`Invalid API base URL: ${value}`);
   }
-  validateHttpUrl(parsed, "PeakURL base URL");
+  validateHttpUrl(parsed, "PeakURL API base URL");
   parsed.hash = "";
   parsed.search = "";
   const pathname = parsed.pathname.replace(/\/+$/, "");
-  const installPath = pathname.replace(/\/api\/v1$/i, "");
-  return installPath ? `${parsed.origin}${installPath}` : parsed.origin;
+  if (!/\/api\/v1$/i.test(pathname)) {
+    throw new CliError("PeakURL API base URL must end with /api/v1.");
+  }
+  return `${parsed.origin}${pathname}`;
 }
-function buildApiUrl(baseUrl, path, query) {
-  const cleanBaseUrl = normalizeBaseUrl(baseUrl);
+function buildApiUrl(apiBaseUrl, path, query) {
+  const cleanBaseUrl = getApiBaseUrl(apiBaseUrl);
   const cleanPath = path.replace(/^\/+/, "");
-  const url = new URL(`api/v1/${cleanPath}`, `${cleanBaseUrl}/`);
+  const url = new URL(cleanPath, `${cleanBaseUrl}/`);
   for (const [key, value] of Object.entries(query ?? {})) {
     if (value === void 0 || value === "") {
       continue;
@@ -78,24 +86,40 @@ function normalizeDestinationUrl(value) {
     throw new CliError(`Invalid destination URL: ${value}`);
   }
 }
+function normalizeWebhookUrl(value) {
+  const input = value.trim();
+  if (!input) {
+    throw new CliError("A webhook URL is required.");
+  }
+  try {
+    const parsed = new URL(input);
+    validateHttpUrl(parsed, "Webhook URL");
+    return parsed.toString();
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    throw new CliError(`Invalid webhook URL: ${value}`);
+  }
+}
 
 // src/api/client.ts
-function isEnvelope(value) {
+function isApiResponse(value) {
   return Boolean(
     value && typeof value === "object" && "success" in value && "message" in value && "timestamp" in value
   );
 }
-function formatNetworkError(baseUrl, error) {
+function networkError(apiBaseUrl, error) {
   if (error instanceof Error && error.message) {
-    return `Could not reach PeakURL at ${baseUrl}. ${error.message}`;
+    return `Could not reach PeakURL at ${apiBaseUrl}. ${error.message}`;
   }
-  return `Could not reach PeakURL at ${baseUrl}.`;
+  return `Could not reach PeakURL at ${apiBaseUrl}.`;
 }
-var PeakUrlApiClient = class {
+var ApiClient = class {
   /**
    * Creates a client bound to one resolved credential set.
    *
-   * @param config Normalized base URL plus bearer API key.
+   * @param config Explicit API base URL plus bearer API key.
    */
   constructor(config) {
     this.config = config;
@@ -112,6 +136,14 @@ var PeakUrlApiClient = class {
   whoami() {
     return this.request("GET", "users/me");
   }
+  /**
+   * Loads the current system status snapshot for the authenticated site.
+   *
+   * @returns API response envelope containing system status sections.
+   */
+  getStatus() {
+    return this.request("GET", "system/status");
+  }
   /**
    * Creates a short URL.
    *
@@ -131,13 +163,31 @@ var PeakUrlApiClient = class {
    * @returns API response envelope containing list data.
    */
   listUrls(query) {
+    return this.request("GET", "urls", void 0, query);
+  }
+  /**
+   * Exports the full accessible link dataset for the authenticated user.
+   *
+   * @param query Optional search and sort values.
+   * @returns API response envelope containing the full export payload.
+   */
+  exportUrls(query) {
     return this.request(
       "GET",
-      "urls",
+      "urls/export",
       void 0,
       query
     );
   }
+  /**
+   * Imports multiple short links in one bulk request.
+   *
+   * @param payload Request body accepted by `POST /api/v1/urls/bulk`.
+   * @returns API response envelope containing created rows plus row errors.
+   */
+  importUrls(payload) {
+    return this.request("POST", "urls/bulk", payload);
+  }
   /**
    * Loads a single short URL by identifier or alias.
    *
@@ -167,6 +217,35 @@ var PeakUrlApiClient = class {
       `urls/${encodeURIComponent(id)}`
     );
   }
+  /**
+   * Lists outbound webhooks for the authenticated user.
+   *
+   * @returns API response envelope containing webhook rows.
+   */
+  listWebhooks() {
+    return this.request("GET", "webhooks");
+  }
+  /**
+   * Creates one outbound webhook subscription.
+   *
+   * @param payload Request body accepted by `POST /api/v1/webhooks`.
+   * @returns API response envelope containing the created webhook.
+   */
+  createWebhook(payload) {
+    return this.request("POST", "webhooks", payload);
+  }
+  /**
+   * Deletes one webhook by its stable row ID.
+   *
+   * @param id Webhook identifier returned by the list/create endpoints.
+   * @returns API response envelope containing the deletion result.
+   */
+  deleteWebhook(id) {
+    return this.request(
+      "DELETE",
+      `webhooks/${encodeURIComponent(id)}`
+    );
+  }
   /**
    * Performs one authenticated API request and normalizes the response.
    *
@@ -178,7 +257,7 @@ var PeakUrlApiClient = class {
    * @throws {CliError} When the network request fails or the API returns an error.
    */
   async request(method, path, body, query) {
-    const url = buildApiUrl(this.config.baseUrl, path, query);
+    const url = buildApiUrl(this.config.apiBaseUrl, path, query);
     let response;
     try {
       response = await fetch(url, {
@@ -191,13 +270,9 @@ var PeakUrlApiClient = class {
         body: body ? JSON.stringify(body) : void 0
       });
     } catch (error) {
-      throw new CliError(
-        formatNetworkError(this.config.baseUrl, error),
-        1,
-        {
-          cause: error instanceof Error ? error : void 0
-        }
-      );
+      throw new CliError(networkError(this.config.apiBaseUrl, error), 1, {
+        cause: error instanceof Error ? error : void 0
+      });
     }
     const rawText = await response.text();
     if (!rawText) {
@@ -224,7 +299,7 @@ var PeakUrlApiClient = class {
       }
       throw new CliError("PeakURL returned an invalid JSON response.");
     }
-    if (!isEnvelope(parsed)) {
+    if (!isApiResponse(parsed)) {
       throw new CliError(
         "PeakURL returned an unexpected response envelope."
       );
@@ -241,18 +316,18 @@ var PeakUrlApiClient = class {
 };
 
 // src/config/store.ts
-import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { chmod, mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { dirname, join } from "path";
 import envPaths from "env-paths";
 var CONFIG_FILENAME = "config.json";
 var STATE_FILENAME = "state.json";
-function defaultConfigPath() {
+function getConfigPath() {
   return join(envPaths("peakurl", { suffix: "" }).config, CONFIG_FILENAME);
 }
-function defaultStatePath() {
+function getStatePath() {
   return join(envPaths("peakurl", { suffix: "" }).config, STATE_FILENAME);
 }
-async function prepareFileDirectory(filePath) {
+async function ensureParentDir(filePath) {
   const directory = dirname(filePath);
   await mkdir(directory, { recursive: true, mode: 448 });
   return directory;
@@ -264,7 +339,7 @@ var ConfigStore = class {
    *
    * @param filePath Optional override used by tests or advanced callers.
    */
-  constructor(filePath = defaultConfigPath()) {
+  constructor(filePath = getConfigPath()) {
     this.filePath = filePath;
   }
   /**
@@ -280,11 +355,12 @@ var ConfigStore = class {
     try {
       const content = await readFile(this.filePath, "utf8");
       const parsed = JSON.parse(content);
-      if (typeof parsed.baseUrl !== "string" || typeof parsed.apiKey !== "string") {
+      const apiBaseUrl = typeof parsed?.apiBaseUrl === "string" ? parsed.apiBaseUrl : typeof parsed?.baseUrl === "string" ? parsed.baseUrl : void 0;
+      if (typeof apiBaseUrl !== "string" || typeof parsed?.apiKey !== "string") {
         throw new CliError(`Invalid config file: ${this.filePath}`);
       }
       return {
-        baseUrl: parsed.baseUrl,
+        apiBaseUrl,
         apiKey: parsed.apiKey
       };
     } catch (error) {
@@ -312,7 +388,7 @@ var ConfigStore = class {
    * @param config Normalized credential set to write.
    */
   async save(config) {
-    const directory = await prepareFileDirectory(this.filePath);
+    const directory = await ensureParentDir(this.filePath);
     await writeFile(this.filePath, `${JSON.stringify(config, null, 2)}
 `, {
       mode: 384
@@ -323,6 +399,29 @@ var ConfigStore = class {
     } catch {
     }
   }
+  /**
+   * Removes the stored credential file.
+   *
+   * @returns `true` when a saved config file existed and was removed.
+   * @throws {CliError} When the file exists but cannot be removed.
+   */
+  async clear() {
+    try {
+      await unlink(this.filePath);
+      return true;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && typeof error.code === "string" && error.code === "ENOENT") {
+        return false;
+      }
+      throw new CliError(
+        `Could not remove PeakURL config at ${this.filePath}.`,
+        1,
+        {
+          cause: error instanceof Error ? error : void 0
+        }
+      );
+    }
+  }
 };
 var StateStore = class {
   filePath;
@@ -331,7 +430,7 @@ var StateStore = class {
    *
    * @param filePath Optional override used by tests or advanced callers.
    */
-  constructor(filePath = defaultStatePath()) {
+  constructor(filePath = getStatePath()) {
     this.filePath = filePath;
   }
   /**
@@ -357,7 +456,7 @@ var StateStore = class {
    * @param state State payload to save.
    */
   async save(state) {
-    const directory = await prepareFileDirectory(this.filePath);
+    const directory = await ensureParentDir(this.filePath);
     await writeFile(this.filePath, `${JSON.stringify(state, null, 2)}
 `, {
       mode: 384
@@ -371,34 +470,159 @@ var StateStore = class {
 };
 
 // src/lib/auth.ts
-function resolveLoginConfig(input, env) {
-  const baseUrl = input.baseUrl?.trim() || env.PEAKURL_BASE_URL?.trim();
+var AUTH_REQUIRED_MESSAGE = "PeakURL credentials are not configured.";
+var EXAMPLE_BASE_URL = "https://example.com/api/v1";
+var EXAMPLE_API_KEY = "YOUR_API_KEY";
+function authRows(commandName) {
+  const retryCommand = commandName ? `peakurl ${commandName}` : "peakurl whoami";
+  const rows2 = [
+    [
+      "Save credentials",
+      `peakurl login --base-url ${EXAMPLE_BASE_URL}
+--api-key ${EXAMPLE_API_KEY}`,
+      "Regular use on this machine"
+    ],
+    [
+      "Set environment variables",
+      `PEAKURL_BASE_URL=${EXAMPLE_BASE_URL}
+PEAKURL_API_KEY=${EXAMPLE_API_KEY}`,
+      "CI, scripts, or one-off use"
+    ],
+    ["Then run", retryCommand, "After completing one of the steps above"]
+  ];
+  return rows2;
+}
+function getLoginConfig(input, env) {
+  const apiBaseUrl = input.baseUrl?.trim() || env.PEAKURL_BASE_URL?.trim();
   const apiKey = input.apiKey?.trim() || env.PEAKURL_API_KEY?.trim();
-  if (!baseUrl || !apiKey) {
+  if (!apiBaseUrl || !apiKey) {
     throw new CliError(
       "Missing credentials. Provide --base-url and --api-key, or set PEAKURL_BASE_URL and PEAKURL_API_KEY."
     );
   }
   return {
-    baseUrl: normalizeBaseUrl(baseUrl),
+    apiBaseUrl: getApiBaseUrl(apiBaseUrl),
     apiKey
   };
 }
-async function resolveStoredConfig(env, store = new ConfigStore()) {
+async function getAuthConfig(env, store = new ConfigStore()) {
   const saved = await store.load();
-  const baseUrl = env.PEAKURL_BASE_URL?.trim() || saved?.baseUrl;
+  const apiBaseUrl = env.PEAKURL_BASE_URL?.trim() || saved?.apiBaseUrl;
   const apiKey = env.PEAKURL_API_KEY?.trim() || saved?.apiKey;
-  if (!baseUrl || !apiKey) {
-    throw new CliError(
-      "PeakURL credentials are not configured. Run `peakurl login --base-url ... --api-key ...` or set PEAKURL_BASE_URL and PEAKURL_API_KEY."
-    );
+  if (!apiBaseUrl || !apiKey) {
+    throw new CliError(AUTH_REQUIRED_MESSAGE, 1, {
+      kind: "auth_required"
+    });
   }
   return {
-    baseUrl: normalizeBaseUrl(baseUrl),
+    apiBaseUrl: getApiBaseUrl(apiBaseUrl),
     apiKey
   };
 }
 
+// src/lib/exports.ts
+var EXPORT_HEADERS = [
+  "url",
+  "alias",
+  "title",
+  "password",
+  "expires",
+  "short_url",
+  "clicks",
+  "unique_clicks",
+  "created_at"
+];
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function csvValue(value) {
+  const content = value == null ? "" : String(value);
+  if (/[",\r\n]/.test(content)) {
+    return `"${content.replace(/"/g, '""')}"`;
+  }
+  return content;
+}
+function xmlValue(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function aliasValue(link) {
+  return text(link.alias) || text(link.shortCode);
+}
+function parseFileFormat(value) {
+  const format = value.trim().toLowerCase();
+  if (format === "csv" || format === "json" || format === "xml") {
+    return format;
+  }
+  throw new CliError(
+    `Unsupported file format: ${value}. Use csv, json, or xml.`
+  );
+}
+function getFileFormatFromPath(filePath) {
+  const value = filePath.trim().toLowerCase();
+  if (value.endsWith(".csv")) {
+    return "csv";
+  }
+  if (value.endsWith(".json")) {
+    return "json";
+  }
+  if (value.endsWith(".xml")) {
+    return "xml";
+  }
+  return void 0;
+}
+function getExportFileName(format) {
+  return `peakurl-links.${format}`;
+}
+function buildExportRows(links) {
+  return links.map((link) => ({
+    url: text(link.destinationUrl),
+    alias: aliasValue(link),
+    title: text(link.title),
+    password: "",
+    expires: text(link.expiresAt),
+    short_url: text(link.shortUrl),
+    clicks: typeof link.clicks === "number" ? link.clicks : "",
+    unique_clicks: typeof link.uniqueClicks === "number" ? link.uniqueClicks : "",
+    created_at: text(link.createdAt)
+  }));
+}
+function serializeLinkExport(links, format) {
+  const rows2 = buildExportRows(links);
+  if (format === "json") {
+    return JSON.stringify(rows2, null, 2);
+  }
+  if (format === "xml") {
+    const body = rows2.map(
+      (row2) => `  <url>
+    <destinationUrl>${xmlValue(row2.url)}</destinationUrl>
+    <alias>${xmlValue(row2.alias)}</alias>
+    <title>${xmlValue(row2.title)}</title>
+    <password>${xmlValue(row2.password)}</password>
+    <expiresAt>${xmlValue(row2.expires)}</expiresAt>
+    <shortUrl>${xmlValue(row2.short_url)}</shortUrl>
+    <clicks>${xmlValue(row2.clicks)}</clicks>
+    <uniqueClicks>${xmlValue(row2.unique_clicks)}</uniqueClicks>
+    <createdAt>${xmlValue(row2.created_at)}</createdAt>
+  </url>`
+    ).join("\n");
+    return `<urls>
+${body}
+</urls>
+`;
+  }
+  const lines = [
+    EXPORT_HEADERS.join(","),
+    ...rows2.map(
+      (row2) => EXPORT_HEADERS.map((key) => csvValue(row2[key])).join(",")
+    )
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
+// src/lib/imports.ts
+import { readFile as readFile2 } from "fs/promises";
+
 // src/lib/output.ts
 function writeStdout(message = "") {
   process.stdout.write(`${message}
@@ -449,7 +673,7 @@ function writeNoticeBox(title, lines, target = "stderr") {
   }
   writeLine(bottomBorder);
 }
-function formatTable(headers, rows, target = "stdout") {
+function formatTable(headers, rows2, target = "stdout") {
   const stream = target === "stdout" ? process.stdout : process.stderr;
   const useTuiBox = stream.isTTY;
   const border = useTuiBox ? {
@@ -477,14 +701,26 @@ function formatTable(headers, rows, target = "stdout") {
     middleJunction: "+",
     bottomJunction: "+"
   };
+  const getLines = (value) => (value ?? "").split("\n");
   const widths = headers.map(
     (header, index) => Math.max(
       header.length,
-      ...rows.map((row) => (row[index] ?? "").length)
+      ...rows2.flatMap(
+        (row2) => getLines(row2[index]).map((line) => line.length)
+      )
     )
   );
   const formatTableBorder = (left, join2, right) => `${left}${widths.map((width) => border.horizontal.repeat(width + 2)).join(join2)}${right}`;
-  const formatTableRow = (cells) => `${border.vertical}${cells.map((cell, index) => ` ${(cell ?? "").padEnd(widths[index])} `).join(border.vertical)}${border.vertical}`;
+  const formatTableRow = (cells) => {
+    const linesByCell = cells.map(getLines);
+    const rowHeight = Math.max(...linesByCell.map((lines) => lines.length));
+    return Array.from(
+      { length: rowHeight },
+      (_value, rowIndex) => `${border.vertical}${linesByCell.map(
+        (lines, cellIndex) => ` ${(lines[rowIndex] ?? "").padEnd(widths[cellIndex])} `
+      ).join(border.vertical)}${border.vertical}`
+    ).join("\n");
+  };
   return [
     formatTableBorder(border.topLeft, border.topJunction, border.topRight),
     formatTableRow(headers),
@@ -493,7 +729,7 @@ function formatTable(headers, rows, target = "stdout") {
       border.middleJunction,
       border.separatorRight
     ),
-    ...rows.map(formatTableRow),
+    ...rows2.map(formatTableRow),
     formatTableBorder(
       border.bottomLeft,
       border.bottomJunction,
@@ -505,20 +741,275 @@ function writeJson(value) {
   writeStdout(JSON.stringify(value, null, 2));
 }
 
+// src/lib/imports.ts
+function text2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function normalizeHeader(value) {
+  return value.replace(/^\uFEFF/, "").trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function parseCsvRows(text6) {
+  const rows2 = [];
+  const source = text6.replace(/^\uFEFF/, "");
+  let row2 = [];
+  let value = "";
+  let inQuotes = false;
+  const pushRow = () => {
+    row2.push(value);
+    if (row2.some((cell) => cell.trim() !== "")) {
+      rows2.push(row2);
+    }
+    row2 = [];
+    value = "";
+  };
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === '"') {
+      if (inQuotes && source[index + 1] === '"') {
+        value += '"';
+        index += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      row2.push(value);
+      value = "";
+      continue;
+    }
+    if ((char === "\n" || char === "\r") && !inQuotes) {
+      if (char === "\r" && source[index + 1] === "\n") {
+        index += 1;
+      }
+      pushRow();
+      continue;
+    }
+    value += char;
+  }
+  if (value.length > 0 || row2.length > 0) {
+    pushRow();
+  }
+  return rows2;
+}
+function extractAlias(value) {
+  const input = value.trim();
+  if (!input) {
+    return void 0;
+  }
+  try {
+    const url = new URL(input);
+    const pathname = url.pathname.replace(/^\/+|\/+$/g, "");
+    return pathname ? decodeURIComponent(pathname.split("/").pop() || "") : void 0;
+  } catch {
+    const pathname = input.replace(/^\/+|\/+$/g, "");
+    return pathname ? pathname.split("/").pop() || void 0 : void 0;
+  }
+}
+function decodeXml(value) {
+  return value.replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+function normalizeImportRow(value) {
+  const destinationUrl = text2(value.destinationUrl) || text2(value.url) || text2(value.destination);
+  if (!destinationUrl) {
+    return null;
+  }
+  const alias = text2(value.alias) || text2(value.shortCode) || text2(value.shortcode) || text2(value.code) || extractAlias(
+    text2(value.shortUrl) || text2(value.short_url) || text2(value.shortLink) || text2(value.shortlink) || ""
+  );
+  return {
+    destinationUrl,
+    ...alias ? { alias } : {},
+    ...text2(value.title) ? { title: text2(value.title) } : {},
+    ...text2(value.password) ? { password: text2(value.password) } : {},
+    ...text2(value.status) ? { status: text2(value.status) } : {},
+    ...text2(value.expiresAt) || text2(value.expires) ? { expiresAt: text2(value.expiresAt) || text2(value.expires) } : {},
+    ...text2(value.utmSource) ? { utmSource: text2(value.utmSource) } : {},
+    ...text2(value.utmMedium) ? { utmMedium: text2(value.utmMedium) } : {},
+    ...text2(value.utmCampaign) ? { utmCampaign: text2(value.utmCampaign) } : {},
+    ...text2(value.utmTerm) ? { utmTerm: text2(value.utmTerm) } : {},
+    ...text2(value.utmContent) ? { utmContent: text2(value.utmContent) } : {}
+  };
+}
+function parseJson(text6) {
+  const parsed = JSON.parse(text6);
+  const items = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.urls) ? parsed.urls ?? [] : [];
+  return items.map(
+    (item) => item && typeof item === "object" ? normalizeImportRow(item) : null
+  ).filter((item) => Boolean(item));
+}
+function parseCsv(text6) {
+  const rows2 = parseCsvRows(text6);
+  if (rows2.length < 2) {
+    return [];
+  }
+  const headers = rows2[0].map((header) => normalizeHeader(header));
+  const links = [];
+  for (let index = 1; index < rows2.length; index += 1) {
+    const row2 = rows2[index];
+    const entry = {};
+    headers.forEach((header, column) => {
+      const value = row2[column]?.trim();
+      if (!value) {
+        return;
+      }
+      if (header === "url" || header === "destinationurl" || header === "destination") {
+        entry.destinationUrl = value;
+        return;
+      }
+      if (header === "alias" || header === "shortcode" || header === "code") {
+        entry.alias = value;
+        return;
+      }
+      if (header === "shorturl" || header === "shortlink") {
+        entry.alias = entry.alias || extractAlias(value);
+        return;
+      }
+      if (header === "password") {
+        entry.password = value;
+        return;
+      }
+      if (header === "expires" || header === "expiresat") {
+        entry.expiresAt = value;
+        return;
+      }
+      if (header === "title") {
+        entry.title = value;
+        return;
+      }
+      if (header === "status") {
+        entry.status = value;
+        return;
+      }
+      if (header === "utmsource") {
+        entry.utmSource = value;
+        return;
+      }
+      if (header === "utmmedium") {
+        entry.utmMedium = value;
+        return;
+      }
+      if (header === "utmcampaign") {
+        entry.utmCampaign = value;
+        return;
+      }
+      if (header === "utmterm") {
+        entry.utmTerm = value;
+        return;
+      }
+      if (header === "utmcontent") {
+        entry.utmContent = value;
+      }
+    });
+    const link = normalizeImportRow(entry);
+    if (link) {
+      links.push(link);
+    }
+  }
+  return links;
+}
+function parseXml(text6) {
+  const entries = Array.from(
+    text6.matchAll(/<(url|item)\b[^>]*>([\s\S]*?)<\/\1>/gi),
+    (match) => match[2]
+  );
+  return entries.map((entry) => {
+    const getValue = (tag) => {
+      const match = new RegExp(
+        `<${tag}>([\\s\\S]*?)</${tag}>`,
+        "i"
+      ).exec(entry);
+      return match ? decodeXml(match[1].trim()) : void 0;
+    };
+    return normalizeImportRow({
+      destinationUrl: getValue("destinationUrl"),
+      url: getValue("url"),
+      alias: getValue("alias"),
+      shortCode: getValue("shortCode"),
+      shortUrl: getValue("shortUrl"),
+      password: getValue("password"),
+      expiresAt: getValue("expiresAt"),
+      expires: getValue("expires"),
+      title: getValue("title"),
+      status: getValue("status"),
+      utmSource: getValue("utmSource"),
+      utmMedium: getValue("utmMedium"),
+      utmCampaign: getValue("utmCampaign"),
+      utmTerm: getValue("utmTerm"),
+      utmContent: getValue("utmContent")
+    });
+  }).filter((item) => Boolean(item));
+}
+function getImportFormat(filePath, value) {
+  if (value) {
+    return parseFileFormat(value);
+  }
+  const format = getFileFormatFromPath(filePath);
+  if (format) {
+    return format;
+  }
+  throw new CliError(
+    "Could not determine the import file format. Use a .csv, .json, or .xml file, or pass --format."
+  );
+}
+async function readImportRows(filePath, format) {
+  let textContent = "";
+  try {
+    textContent = await readFile2(filePath, "utf8");
+  } catch (error) {
+    throw new CliError(`Could not read import file ${filePath}.`, 1, {
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+  try {
+    const rows2 = format === "json" ? parseJson(textContent) : format === "xml" ? parseXml(textContent) : parseCsv(textContent);
+    if (rows2.length === 0) {
+      throw new CliError(`No import rows were found in ${filePath}.`);
+    }
+    return rows2;
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    throw new CliError(
+      `Could not parse ${filePath} as ${format.toUpperCase()}.`,
+      1,
+      {
+        cause: error instanceof Error ? error : void 0
+      }
+    );
+  }
+}
+function formatImportErrors(errors) {
+  return formatTable(
+    ["Destination", "Alias", "Error"],
+    errors.map((item) => [
+      item.destinationUrl || "-",
+      item.alias || "-",
+      item.error || "Unknown error"
+    ])
+  );
+}
+function formatImportSummary(data) {
+  const created = data.results?.length ?? 0;
+  const errors = data.errors?.length ?? 0;
+  return `${created} link${created === 1 ? "" : "s"} created. ${errors} error${errors === 1 ? "" : "s"}.`;
+}
+
 // src/lib/links.ts
 var LIST_KEYS = ["urls", "items", "results"];
-function objectValue(value) {
+function asObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function stringValue(value) {
+function asString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function numberValue(value) {
+function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function pickString(link, keys) {
+function pickText(link, keys) {
   for (const key of keys) {
-    const value = stringValue(link[key]);
+    const value = asString(link[key]);
     if (value) {
       return value;
     }
@@ -528,32 +1019,32 @@ function pickString(link, keys) {
 function truncate(value, maxLength) {
   return value.length > maxLength ? `${value.slice(0, maxLength - 1)}\u2026` : value;
 }
-function extractListMeta(data) {
-  const record = objectValue(data);
+function getListMeta(data) {
+  const record = asObject(data);
   if (!record) {
     return null;
   }
-  const meta = objectValue(record.meta);
+  const meta = asObject(record.meta);
   if (meta) {
     return {
-      page: numberValue(meta.page),
-      limit: numberValue(meta.limit),
-      totalItems: numberValue(meta.totalItems),
-      totalPages: numberValue(meta.totalPages)
+      page: asNumber(meta.page),
+      limit: asNumber(meta.limit),
+      totalItems: asNumber(meta.totalItems),
+      totalPages: asNumber(meta.totalPages)
     };
   }
   return {
-    page: numberValue(record.page),
-    limit: numberValue(record.limit),
-    totalItems: numberValue(record.total),
-    totalPages: numberValue(record.totalPages)
+    page: asNumber(record.page),
+    limit: asNumber(record.limit),
+    totalItems: asNumber(record.total),
+    totalPages: asNumber(record.totalPages)
   };
 }
 function extractLinks(data) {
   if (Array.isArray(data)) {
     return data;
   }
-  const record = objectValue(data);
+  const record = asObject(data);
   if (record) {
     for (const key of LIST_KEYS) {
       const value = record[key];
@@ -565,16 +1056,16 @@ function extractLinks(data) {
   return [];
 }
 function getLinkId(link) {
-  return pickString(link, ["id", "_id", "urlId"]) || (link.id !== void 0 ? String(link.id) : void 0);
+  return pickText(link, ["id", "_id", "urlId"]) || (link.id !== void 0 ? String(link.id) : void 0);
 }
 function getLinkAlias(link) {
-  return pickString(link, ["alias", "shortCode", "slug", "code"]);
+  return pickText(link, ["alias", "shortCode", "slug", "code"]);
 }
 function getLinkShortUrl(link) {
-  return pickString(link, ["shortUrl", "shortLink", "shortURL", "url"]);
+  return pickText(link, ["shortUrl", "shortLink", "shortURL", "url"]);
 }
 function getLinkDestination(link) {
-  return pickString(link, [
+  return pickText(link, [
     "destinationUrl",
     "originalUrl",
     "targetUrl",
@@ -590,14 +1081,14 @@ function formatLinkDetails(link) {
     ["Alias", getLinkAlias(link)],
     ["Short URL", getLinkShortUrl(link)],
     ["Destination", getLinkDestination(link)],
-    ["Title", stringValue(link.title)],
-    ["Status", stringValue(link.status)],
+    ["Title", asString(link.title)],
+    ["Status", asString(link.status)],
     [
       "Clicks",
-      numberValue(link.clicks) === void 0 ? void 0 : String(link.clicks)
+      asNumber(link.clicks) === void 0 ? void 0 : String(link.clicks)
     ],
-    ["Created", stringValue(link.createdAt)],
-    ["Updated", stringValue(link.updatedAt)]
+    ["Created", asString(link.createdAt)],
+    ["Updated", asString(link.updatedAt)]
   ].filter((entry) => Boolean(entry[1]));
   return lines.map(([label, value]) => `${label}: ${value}`).join("\n");
 }
@@ -606,17 +1097,17 @@ function formatLinksTable(links) {
     return "No links found.";
   }
   const headers = ["ID", "Alias", "Short URL", "Destination", "Status"];
-  const rows = links.map((link) => [
+  const rows2 = links.map((link) => [
     truncate(getLinkId(link) || "-", 18),
     truncate(getLinkAlias(link) || "-", 12),
     truncate(getLinkShortUrl(link) || "-", 36),
     truncate(getLinkDestination(link) || "-", 52),
-    truncate(stringValue(link.status) || "-", 12)
+    truncate(asString(link.status) || "-", 12)
   ]);
-  return formatTable(headers, rows);
+  return formatTable(headers, rows2);
 }
 function formatListSummary(data, count) {
-  const meta = extractListMeta(data);
+  const meta = getListMeta(data);
   if (!meta) {
     return `${count} link${count === 1 ? "" : "s"} returned.`;
   }
@@ -629,157 +1120,321 @@ function formatListSummary(data, count) {
   return `${count} link${count === 1 ? "" : "s"} returned.`;
 }
 
-// src/commands/create.ts
-function normalizeExpiresAt(value) {
-  if (!value) {
-    return void 0;
-  }
-  if (Number.isNaN(Date.parse(value))) {
-    throw new CliError(`Invalid expiration timestamp: ${value}`);
-  }
-  return value;
+// src/lib/status.ts
+function text3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-async function createCommand(destinationUrl, options) {
-  const config = await resolveStoredConfig(process.env);
-  const response = await new PeakUrlApiClient(config).createUrl({
-    destinationUrl: normalizeDestinationUrl(destinationUrl),
-    ...options.alias ? { alias: options.alias } : {},
-    ...options.title ? { title: options.title } : {},
-    ...options.password ? { password: options.password } : {},
-    ...options.status ? { status: options.status } : {},
-    ...options.expiresAt ? { expiresAt: normalizeExpiresAt(options.expiresAt) } : {},
-    ...options.utmSource ? { utmSource: options.utmSource } : {},
-    ...options.utmMedium ? { utmMedium: options.utmMedium } : {},
-    ...options.utmCampaign ? { utmCampaign: options.utmCampaign } : {},
-    ...options.utmTerm ? { utmTerm: options.utmTerm } : {},
-    ...options.utmContent ? { utmContent: options.utmContent } : {}
-  });
-  if (options.json) {
-    writeJson(response);
-    return;
+function integer(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
   }
-  if (options.quiet) {
-    writeStdout(getQuietLinkValue(response.data));
-    return;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
   }
-  writeStdout(response.message);
-  writeStdout(formatLinkDetails(response.data));
+  return void 0;
 }
-
-// src/commands/delete.ts
-async function deleteCommand(idOrAlias, options) {
-  const config = await resolveStoredConfig(process.env);
-  const client = new PeakUrlApiClient(config);
-  const lookupResponse = await client.getUrl(idOrAlias);
-  const resolvedId = getLinkId(lookupResponse.data);
-  if (!resolvedId) {
-    throw new CliError(
-      "PeakURL returned a link record without an ID, so the CLI cannot delete it safely."
-    );
+function flag(value) {
+  if (typeof value === "boolean") {
+    return value;
   }
-  const response = await client.deleteUrl(resolvedId);
-  if (options.json) {
-    writeJson(response);
-    return;
+  if (value === 1 || value === "1") {
+    return true;
   }
-  if (options.quiet) {
-    return;
+  if (value === 0 || value === "0") {
+    return false;
   }
-  writeStdout(response.message);
+  return void 0;
 }
-
-// src/commands/get.ts
-async function getCommand(idOrAlias, options) {
-  const config = await resolveStoredConfig(process.env);
-  const response = await new PeakUrlApiClient(config).getUrl(idOrAlias);
-  if (options.json) {
-    writeJson(response);
-    return;
-  }
-  if (options.quiet) {
-    writeStdout(getQuietLinkValue(response.data));
-    return;
+function yesNo(value, yes = "Yes", no = "No") {
+  const normalized = flag(value);
+  if (normalized === void 0) {
+    return void 0;
   }
-  writeStdout(response.message);
-  writeStdout(formatLinkDetails(response.data));
+  return normalized ? yes : no;
 }
-
-// src/commands/list.ts
-async function listCommand(options) {
-  const config = await resolveStoredConfig(process.env);
-  const response = await new PeakUrlApiClient(config).listUrls({
-    page: options.page,
-    limit: options.limit,
-    search: options.search,
-    sortBy: options.sortBy,
-    sortOrder: options.sortOrder
-  });
-  const links = extractLinks(response.data);
-  if (options.json) {
-    writeJson(response);
-    return;
+function formatState(value) {
+  const normalized = text3(value)?.toLowerCase();
+  if (!normalized) {
+    return void 0;
   }
-  if (options.quiet) {
-    for (const link of links) {
-      const value = getQuietLinkValue(link);
-      if (value) {
-        writeStdout(value);
-      }
-    }
-    return;
+  switch (normalized) {
+    case "ok":
+      return "Good";
+    case "warning":
+      return "Warning";
+    case "error":
+      return "Error";
+    default:
+      return normalized;
   }
-  writeStdout(response.message);
-  writeStdout(formatLinksTable(links));
-  writeStdout(formatListSummary(response.data, links.length));
 }
-
-// src/lib/users.ts
-function stringValue2(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+function formatCount(value) {
+  const normalized = integer(value);
+  return normalized === void 0 ? text3(value) : String(normalized);
 }
-function getUserLabel(user) {
-  const fullName = [stringValue2(user.firstName), stringValue2(user.lastName)].filter(Boolean).join(" ");
-  return fullName || stringValue2(user.username) || stringValue2(user.email) || String(user.id ?? "unknown");
+function formatSize(value) {
+  const bytes = integer(value);
+  if (bytes === void 0) {
+    return text3(value);
+  }
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex += 1;
+  }
+  const amount = size >= 10 || unitIndex === 0 ? size.toFixed(0) : size.toFixed(1);
+  return `${amount} ${units[unitIndex]}`;
 }
-function getQuietUserValue(user) {
-  return stringValue2(user.username) || stringValue2(user.email) || String(user.id ?? "");
+function formatSeconds(value) {
+  const normalized = integer(value);
+  return normalized === void 0 ? text3(value) : `${normalized} seconds`;
 }
-function formatUserDetails(user) {
-  const lines = [
-    ["Name", getUserLabel(user)],
-    ["Username", stringValue2(user.username)],
-    ["Email", stringValue2(user.email)],
-    ["Role", stringValue2(user.role)],
-    ["ID", user.id === void 0 ? void 0 : String(user.id)]
-  ].filter((entry) => Boolean(entry[1]));
-  return lines.map(([label, value]) => `${label}: ${value}`).join("\n");
+function wrapText(value, width = 68) {
+  const lines = [];
+  for (const line of value.split("\n")) {
+    if (line.length <= width) {
+      lines.push(line);
+      continue;
+    }
+    for (let index = 0; index < line.length; index += width) {
+      lines.push(line.slice(index, index + width));
+    }
+  }
+  return lines.join("\n");
 }
-
-// src/commands/login.ts
-async function loginCommand(options) {
-  const credentials = resolveLoginConfig(options, process.env);
-  const client = new PeakUrlApiClient(credentials);
-  const response = await client.whoami();
-  await new ConfigStore().save(credentials);
-  const responseBody = {
-    success: true,
-    message: `Saved credentials for ${credentials.baseUrl}.`,
-    data: {
-      baseUrl: credentials.baseUrl,
-      user: response.data
-    },
-    timestamp: response.timestamp
+function row(label, value, width) {
+  const normalized = typeof value === "string" ? value : typeof value === "number" ? String(value) : void 0;
+  if (!normalized) {
+    return null;
+  }
+  return [label, wrapText(normalized, width)];
+}
+function rows(values) {
+  return values.filter((value) => Boolean(value));
+}
+function getSummary(status2) {
+  const summary = status2.summary ?? {};
+  const checks = status2.checks ?? [];
+  if (summary.okCount !== void 0 && summary.warningCount !== void 0 && summary.errorCount !== void 0 && summary.totalChecks !== void 0) {
+    return summary;
+  }
+  let okCount = 0;
+  let warningCount = 0;
+  let errorCount = 0;
+  for (const check of checks) {
+    switch (text3(check.status)?.toLowerCase()) {
+      case "error":
+        errorCount += 1;
+        break;
+      case "warning":
+        warningCount += 1;
+        break;
+      case "ok":
+        okCount += 1;
+        break;
+    }
+  }
+  return {
+    overall: summary.overall ?? (errorCount > 0 ? "error" : warningCount > 0 ? "warning" : "ok"),
+    okCount: summary.okCount ?? okCount,
+    warningCount: summary.warningCount ?? warningCount,
+    errorCount: summary.errorCount ?? errorCount,
+    totalChecks: summary.totalChecks ?? checks.length
   };
-  if (options.json) {
-    writeJson(responseBody);
-    return;
+}
+function summaryRows(status2) {
+  const summary = getSummary(status2);
+  return rows([
+    row("Overall", formatState(summary.overall)),
+    row("Generated at", text3(status2.generatedAt)),
+    row("Total checks", formatCount(summary.totalChecks)),
+    row("Good checks", formatCount(summary.okCount)),
+    row("Warnings", formatCount(summary.warningCount)),
+    row("Errors", formatCount(summary.errorCount))
+  ]);
+}
+function siteRows(site) {
+  if (!site) {
+    return [];
+  }
+  return rows([
+    row("Name", text3(site.name)),
+    row("URL", text3(site.url)),
+    row("Version", text3(site.version)),
+    row("Environment", text3(site.environment)),
+    row("Install type", text3(site.installType)),
+    row("Locale", text3(site.locale)),
+    row("HTML lang", text3(site.htmlLang)),
+    row(
+      "Language",
+      text3(site.languageNativeName) || text3(site.languageLabel)
+    ),
+    row("Installed languages", formatCount(site.installedLanguagesCount)),
+    row("Default locale", text3(site.defaultLocale)),
+    row("Debug", yesNo(site.debugEnabled, "Enabled", "Disabled"))
+  ]);
+}
+function serverRows(server) {
+  if (!server) {
+    return [];
+  }
+  return rows([
+    row("PHP version", text3(server.phpVersion)),
+    row("PHP SAPI", text3(server.phpSapi)),
+    row("Server software", text3(server.serverSoftware), 56),
+    row("Operating system", text3(server.operatingSystem)),
+    row("Timezone", text3(server.timezone)),
+    row("Memory limit", text3(server.memoryLimit)),
+    row("Max execution time", formatSeconds(server.maxExecutionTime)),
+    row("Upload max filesize", text3(server.uploadMaxFilesize)),
+    row("Post max size", text3(server.postMaxSize)),
+    row("Intl extension", yesNo(server.extensions?.intl)),
+    row("cURL extension", yesNo(server.extensions?.curl)),
+    row("ZipArchive", yesNo(server.extensions?.zip))
+  ]);
+}
+function databaseRows(database) {
+  if (!database) {
+    return [];
+  }
+  return rows([
+    row("Connected", yesNo(database.connected)),
+    row("Server type", text3(database.serverType)),
+    row("Version", text3(database.version)),
+    row("Host", text3(database.host)),
+    row("Port", formatCount(database.port)),
+    row("Name", text3(database.name)),
+    row("Charset", text3(database.charset)),
+    row("Prefix", text3(database.prefix)),
+    row("Schema version", formatCount(database.schemaVersion)),
+    row(
+      "Required schema version",
+      formatCount(database.requiredSchemaVersion)
+    ),
+    row("Schema compatible", yesNo(database.schemaCompatible)),
+    row("Schema upgrade required", yesNo(database.schemaUpgradeRequired)),
+    row("Schema issues", formatCount(database.schemaIssuesCount)),
+    row("Last upgraded", text3(database.schemaLastUpgradedAt)),
+    row("Last error", text3(database.schemaLastError), 56)
+  ]);
+}
+function storageRows(storage) {
+  if (!storage) {
+    return [];
+  }
+  return rows([
+    row("Content directory", text3(storage.contentDirectory), 60),
+    row("Content exists", yesNo(storage.contentExists)),
+    row("Content writable", yesNo(storage.contentWritable)),
+    row("Content size", formatSize(storage.contentDirectorySizeBytes)),
+    row("Languages directory", text3(storage.languagesDirectory), 60),
+    row("Languages exists", yesNo(storage.languagesDirectoryExists)),
+    row("Languages readable", yesNo(storage.languagesDirectoryReadable)),
+    row("Languages size", formatSize(storage.languagesDirectorySizeBytes)),
+    row("Config path", text3(storage.configPath), 60),
+    row("Config exists", yesNo(storage.configExists)),
+    row("Config size", formatSize(storage.configSizeBytes)),
+    row("Debug log path", text3(storage.debugLogPath), 60),
+    row("Debug log exists", yesNo(storage.debugLogExists)),
+    row("Debug log readable", yesNo(storage.debugLogReadable)),
+    row("Debug log size", formatSize(storage.debugLogSizeBytes)),
+    row("App directory", text3(storage.appDirectory), 60),
+    row("App writable", yesNo(storage.appWritable)),
+    row("App size", formatSize(storage.appDirectorySizeBytes)),
+    row("Release root", text3(storage.releaseRoot), 60),
+    row("Release size", formatSize(storage.releaseRootSizeBytes))
+  ]);
+}
+function mailRows(mail) {
+  if (!mail) {
+    return [];
+  }
+  return rows([
+    row("Driver", text3(mail.driver)),
+    row("Transport", yesNo(mail.transportReady, "Ready", "Not ready")),
+    row("From email", text3(mail.fromEmail)),
+    row("From name", text3(mail.fromName)),
+    row("SMTP host", text3(mail.smtpHost)),
+    row("SMTP port", text3(mail.smtpPort)),
+    row("SMTP encryption", text3(mail.smtpEncryption)),
+    row("SMTP auth", yesNo(mail.smtpAuth)),
+    row("Configuration", text3(mail.configurationLabel)),
+    row("Configuration path", text3(mail.configurationPath), 60)
+  ]);
+}
+function locationRows(location) {
+  if (!location) {
+    return [];
+  }
+  return rows([
+    row(
+      "Analytics",
+      yesNo(location.locationAnalyticsReady, "Ready", "Not ready")
+    ),
+    row("Last downloaded", text3(location.lastDownloadedAt)),
+    row("Database updated", text3(location.databaseUpdatedAt)),
+    row("Database size", formatSize(location.databaseSizeBytes)),
+    row("Credentials configured", yesNo(location.credentialsConfigured)),
+    row("Account ID", text3(location.accountId)),
+    row("Database path", text3(location.databasePath), 60),
+    row("Database readable", yesNo(location.databaseReadable)),
+    row("Download command", text3(location.downloadCommand), 60)
+  ]);
+}
+function dataRows(data) {
+  if (!data) {
+    return [];
+  }
+  return rows([
+    row("Users", formatCount(data.users)),
+    row("Links", formatCount(data.links)),
+    row("Clicks", formatCount(data.clicks)),
+    row("Sessions", formatCount(data.sessions)),
+    row("API keys", formatCount(data.apiKeys)),
+    row("Webhooks", formatCount(data.webhooks)),
+    row("Audit events", formatCount(data.auditEvents)),
+    row("Managed tables", formatCount(data.managedTables))
+  ]);
+}
+function checksTable(checks) {
+  if (checks.length === 0) {
+    return void 0;
   }
-  if (options.quiet) {
-    return;
+  const rows2 = checks.map((check) => [
+    wrapText(text3(check.label) || "Check", 24),
+    formatState(check.status) || "Unknown",
+    wrapText(text3(check.description) || "Not available", 56)
+  ]);
+  return formatTable(["Check", "Status", "Description"], rows2);
+}
+function section(title, rows2) {
+  if (rows2.length === 0) {
+    return void 0;
   }
-  writeStdout(`Saved credentials for ${credentials.baseUrl}`);
-  writeStdout(`Authenticated as ${getUserLabel(response.data)}`);
-  writeStdout(formatUserDetails(response.data));
+  return `${title}
+${formatTable(["Field", "Value"], rows2)}`;
+}
+function getStatusValue(status2) {
+  return text3(getSummary(status2).overall) || "unknown";
+}
+function formatStatusReport(status2) {
+  const checks = checksTable(status2.checks ?? []);
+  const sections = [
+    section("Summary", summaryRows(status2)),
+    checks ? `Checks
+${checks}` : void 0,
+    section("Site", siteRows(status2.site)),
+    section("Server", serverRows(status2.server)),
+    section("Database", databaseRows(status2.database)),
+    section("Storage", storageRows(status2.storage)),
+    section("Mail", mailRows(status2.mail)),
+    section("Location", locationRows(status2.location)),
+    section("Data", dataRows(status2.data))
+  ].filter((value) => Boolean(value));
+  return sections.length > 0 ? sections.join("\n\n") : "No system status fields returned.";
 }
 
 // src/lib/update.ts
@@ -886,7 +1541,7 @@ function compareSemver(left, right) {
 function getUpdateInstallCommand() {
   return `npm install -g ${PACKAGE_NAME}@latest`;
 }
-async function fetchLatestPackageVersion(env) {
+async function fetchLatestVersion(env) {
   const registryUrl = normalizeRegistryUrl(getRegistryBaseUrl(env));
   const url = `${registryUrl}/${PACKAGE_NAME}/latest`;
   const controller = new AbortController();
@@ -909,7 +1564,7 @@ async function fetchLatestPackageVersion(env) {
     clearTimeout(timeout);
   }
 }
-async function getCachedUpdateState(store) {
+async function getUpdateState(store) {
   const state = await store.load();
   return state.update ?? {};
 }
@@ -920,15 +1575,15 @@ async function saveUpdateState(store, update) {
     update
   });
 }
-async function getLatestPackageVersion(env, options) {
+async function loadLatestVersion(env, options) {
   const store = options?.store ?? new StateStore();
-  const updateState = await getCachedUpdateState(store);
+  const updateState = await getUpdateState(store);
   const lastCheckedAt = parseTime(updateState.lastCheckedAt);
   const now = Date.now();
   if (!options?.forceRefresh && updateState.latestVersion && lastCheckedAt !== null && now - lastCheckedAt < CACHE_TTL_MS) {
     return updateState.latestVersion;
   }
-  const latestVersion = await fetchLatestPackageVersion(env);
+  const latestVersion = await fetchLatestVersion(env);
   if (!latestVersion) {
     return updateState.latestVersion ?? null;
   }
@@ -940,7 +1595,7 @@ async function getLatestPackageVersion(env, options) {
   return latestVersion;
 }
 async function getUpdateStatus(currentVersion, env, options) {
-  const resolvedLatestVersion = await getLatestPackageVersion(env, {
+  const resolvedLatestVersion = await loadLatestVersion(env, {
     forceRefresh: options?.forceRefresh,
     store: options?.store
   });
@@ -957,13 +1612,13 @@ async function getUpdateStatus(currentVersion, env, options) {
     installCommand: getUpdateInstallCommand()
   };
 }
-function writeUpdateNotice(status) {
+function showUpdateNotice(status2) {
   writeNoticeBox("Update Available", [
-    `${PACKAGE_NAME} ${status.currentVersion} -> ${status.latestVersion}`,
-    `Run: ${status.installCommand}`
+    `${PACKAGE_NAME} ${status2.currentVersion} -> ${status2.latestVersion}`,
+    `Run: ${status2.installCommand}`
   ]);
 }
-async function maybeShowUpdateNotice(options) {
+async function checkUpdates(options) {
   if (options.env.PEAKURL_DISABLE_UPDATE_CHECK === "1" || options.commandName === "update" || options.options?.json || options.options?.quiet) {
     return;
   }
@@ -971,39 +1626,412 @@ async function maybeShowUpdateNotice(options) {
     return;
   }
   const store = new StateStore();
-  const updateState = await getCachedUpdateState(store);
-  const status = await getUpdateStatus(options.currentVersion, options.env, {
+  const updateState = await getUpdateState(store);
+  const status2 = await getUpdateStatus(options.currentVersion, options.env, {
     store
   });
-  if (!status.isOutdated) {
+  if (!status2.isOutdated) {
     return;
   }
   const lastNotifiedAt = parseTime(updateState.lastNotifiedAt);
-  const alreadyNotifiedForVersion = updateState.lastNotifiedVersion === status.latestVersion;
+  const alreadyNotifiedForVersion = updateState.lastNotifiedVersion === status2.latestVersion;
   if (alreadyNotifiedForVersion && lastNotifiedAt !== null && Date.now() - lastNotifiedAt < NOTICE_TTL_MS) {
     return;
   }
   await saveUpdateState(store, {
     ...updateState,
     lastNotifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    lastNotifiedVersion: status.latestVersion
+    lastNotifiedVersion: status2.latestVersion
   });
-  writeUpdateNotice(status);
+  showUpdateNotice(status2);
+}
+
+// src/lib/users.ts
+function text4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function userLabel(user) {
+  const fullName = [text4(user.firstName), text4(user.lastName)].filter((value) => Boolean(value)).join(" ");
+  return fullName || text4(user.username) || text4(user.email) || String(user.id ?? "unknown");
+}
+function userValue(user) {
+  return text4(user.username) || text4(user.email) || String(user.id ?? "");
+}
+function userTable(user) {
+  const rows2 = [
+    ["Name", userLabel(user)],
+    ["Username", text4(user.username)],
+    ["Email", text4(user.email)],
+    ["Role", text4(user.role)],
+    ["ID", user.id === void 0 ? void 0 : String(user.id)]
+  ].filter((entry) => Boolean(entry[1]));
+  if (rows2.length === 0) {
+    return "No user fields returned.";
+  }
+  return formatTable(["Field", "Value"], rows2);
+}
+
+// src/lib/webhooks.ts
+var WEBHOOK_EVENTS = [
+  {
+    id: "link.created",
+    label: "Link Created",
+    description: "Send a delivery when a short link is created."
+  },
+  {
+    id: "link.clicked",
+    label: "Link Clicked",
+    description: "Send a delivery when a visitor clicks a short link."
+  },
+  {
+    id: "link.updated",
+    label: "Link Updated",
+    description: "Send a delivery when a short link is updated."
+  },
+  {
+    id: "link.deleted",
+    label: "Link Deleted",
+    description: "Send a delivery when a short link is deleted."
+  }
+];
+function text5(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function textList(value) {
+  return Array.isArray(value) ? value.map((item) => text5(item)).filter((item) => Boolean(item)) : [];
+}
+function truncate2(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength - 1)}\u2026` : value;
+}
+function parseWebhookEvents(value, previous = []) {
+  const allowed = new Set(WEBHOOK_EVENTS.map((event) => event.id));
+  const values = value.split(",").map((part) => part.trim()).filter(Boolean);
+  if (values.length === 0) {
+    throw new CliError("A webhook event value is required.");
+  }
+  for (const event of values) {
+    if (!allowed.has(event)) {
+      throw new CliError(
+        `Unknown webhook event: ${event}. Run \`peakurl webhook events\` to see the supported values.`
+      );
+    }
+  }
+  return [...previous, ...values];
+}
+function getWebhookId(webhook) {
+  return text5(webhook.id) || (webhook.id !== void 0 ? String(webhook.id) : void 0);
+}
+function getWebhookUrl(webhook) {
+  return text5(webhook.url);
+}
+function getWebhookEvents(webhook) {
+  return textList(webhook.events);
+}
+function getQuietWebhookValue(webhook) {
+  return getWebhookId(webhook) || getWebhookUrl(webhook) || "";
+}
+function formatWebhookEventsTable() {
+  return formatTable(
+    ["Event", "Label", "Description"],
+    WEBHOOK_EVENTS.map((event) => [
+      event.id,
+      event.label,
+      event.description
+    ])
+  );
+}
+function formatWebhooksTable(webhooks) {
+  if (webhooks.length === 0) {
+    return "No webhooks found.";
+  }
+  return formatTable(
+    ["ID", "URL", "Events", "Status", "Secret"],
+    webhooks.map((webhook) => [
+      truncate2(getWebhookId(webhook) || "-", 18),
+      truncate2(getWebhookUrl(webhook) || "-", 42),
+      truncate2(getWebhookEvents(webhook).join(", ") || "-", 30),
+      webhook.isActive === false ? "inactive" : "active",
+      truncate2(text5(webhook.secretHint) || "-", 18)
+    ])
+  );
+}
+function formatWebhookDetails(webhook) {
+  const rows2 = [
+    ["ID", getWebhookId(webhook)],
+    ["URL", getWebhookUrl(webhook)],
+    [
+      "Events",
+      getWebhookEvents(webhook).length > 0 ? getWebhookEvents(webhook).join(", ") : void 0
+    ],
+    ["Status", webhook.isActive === false ? "inactive" : "active"],
+    ["Secret", text5(webhook.secret)],
+    ["Secret Hint", text5(webhook.secretHint)],
+    ["Created", text5(webhook.createdAt)]
+  ].filter((entry) => Boolean(entry[1]));
+  if (rows2.length === 0) {
+    return "No webhook fields returned.";
+  }
+  return formatTable(["Field", "Value"], rows2);
+}
+function formatWebhooksSummary(webhooks) {
+  return `${webhooks.length} webhook${webhooks.length === 1 ? "" : "s"} returned.`;
+}
+
+// src/commands/links.ts
+function normalizeExpiresAt(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (Number.isNaN(Date.parse(value))) {
+    throw new CliError(`Invalid expiration timestamp: ${value}`);
+  }
+  return value;
+}
+async function createLink(destinationUrl, options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).createUrl({
+    destinationUrl: normalizeDestinationUrl(destinationUrl),
+    ...options.alias ? { alias: options.alias } : {},
+    ...options.title ? { title: options.title } : {},
+    ...options.password ? { password: options.password } : {},
+    ...options.status ? { status: options.status } : {},
+    ...options.expiresAt ? { expiresAt: normalizeExpiresAt(options.expiresAt) } : {},
+    ...options.utmSource ? { utmSource: options.utmSource } : {},
+    ...options.utmMedium ? { utmMedium: options.utmMedium } : {},
+    ...options.utmCampaign ? { utmCampaign: options.utmCampaign } : {},
+    ...options.utmTerm ? { utmTerm: options.utmTerm } : {},
+    ...options.utmContent ? { utmContent: options.utmContent } : {}
+  });
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    writeStdout(getQuietLinkValue(response.data));
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatLinkDetails(response.data));
+}
+async function importLinks(filePath, options) {
+  const format = getImportFormat(filePath, options.format);
+  const urls = await readImportRows(filePath, format);
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).importUrls({ urls });
+  const links = extractLinks(response.data?.results ?? []);
+  const errors = response.data?.errors ?? [];
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    for (const link of links) {
+      const value = getQuietLinkValue(link);
+      if (value) {
+        writeStdout(value);
+      }
+    }
+    return;
+  }
+  writeStdout(response.message);
+  if (links.length > 0) {
+    writeStdout(formatLinksTable(links));
+  } else {
+    writeStdout("No links were created.");
+  }
+  if (errors.length > 0) {
+    writeStdout(formatImportErrors(errors));
+  }
+  writeStdout(formatImportSummary(response.data ?? {}));
+}
+async function exportLinks(options) {
+  if (options.stdout && options.output) {
+    throw new CliError("Use either --stdout or --output, not both.");
+  }
+  const format = options.format ? parseFileFormat(options.format) : options.output ? getFileFormatFromPath(options.output) || "csv" : "csv";
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).exportUrls({
+    search: options.search,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder
+  });
+  const links = extractLinks(response.data);
+  const content = serializeLinkExport(links, format);
+  if (options.stdout) {
+    process.stdout.write(content);
+    return;
+  }
+  const filePath = resolve(options.output || getExportFileName(format));
+  try {
+    await mkdir2(dirname2(filePath), { recursive: true });
+    await writeFile2(filePath, content, "utf8");
+  } catch (error) {
+    throw new CliError(`Could not write export file ${filePath}.`, 1, {
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+  if (options.quiet) {
+    writeStdout(filePath);
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(
+    `Saved ${links.length} link${links.length === 1 ? "" : "s"} to ${filePath}.`
+  );
+}
+async function listLinks(options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).listUrls({
+    page: options.page,
+    limit: options.limit,
+    search: options.search,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder
+  });
+  const links = extractLinks(response.data);
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    for (const link of links) {
+      const value = getQuietLinkValue(link);
+      if (value) {
+        writeStdout(value);
+      }
+    }
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatLinksTable(links));
+  writeStdout(formatListSummary(response.data, links.length));
+}
+async function getLink(idOrAlias, options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).getUrl(idOrAlias);
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    writeStdout(getQuietLinkValue(response.data));
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatLinkDetails(response.data));
+}
+async function deleteLink(idOrAlias, options) {
+  const config = await getAuthConfig(process.env);
+  const client = new ApiClient(config);
+  const lookupResponse = await client.getUrl(idOrAlias);
+  const resolvedId = getLinkId(lookupResponse.data);
+  if (!resolvedId) {
+    throw new CliError(
+      "PeakURL returned a link record without an ID, so the CLI cannot delete it safely."
+    );
+  }
+  const response = await client.deleteUrl(resolvedId);
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    return;
+  }
+  writeStdout(response.message);
+}
+
+// src/commands/login.ts
+async function login(options) {
+  const credentials = getLoginConfig(options, process.env);
+  const client = new ApiClient(credentials);
+  const response = await client.whoami();
+  await new ConfigStore().save(credentials);
+  const responseBody = {
+    success: true,
+    message: `Saved credentials for ${credentials.apiBaseUrl}.`,
+    data: {
+      apiBaseUrl: credentials.apiBaseUrl,
+      user: response.data
+    },
+    timestamp: response.timestamp
+  };
+  if (options.json) {
+    writeJson(responseBody);
+    return;
+  }
+  if (options.quiet) {
+    return;
+  }
+  writeStdout(`Saved credentials for ${credentials.apiBaseUrl}`);
+  writeStdout(`Authenticated as ${userLabel(response.data)}`);
+  writeStdout(userTable(response.data));
+}
+
+// src/commands/logout.ts
+function hasEnvConfig(env) {
+  return Boolean(env.PEAKURL_BASE_URL?.trim() || env.PEAKURL_API_KEY?.trim());
+}
+async function logout(options) {
+  const store = new ConfigStore();
+  const saved = await store.load();
+  const removed = await store.clear();
+  const envConfig = hasEnvConfig(process.env);
+  const message = removed && saved?.apiBaseUrl ? `Logged out. Removed saved credentials for ${saved.apiBaseUrl}.` : removed ? "Logged out. Removed saved PeakURL credentials." : "Already logged out. No saved PeakURL credentials were found.";
+  const responseBody = {
+    success: true,
+    message,
+    data: {
+      removed,
+      apiBaseUrl: saved?.apiBaseUrl,
+      envCredentialsActive: envConfig
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (options.json) {
+    writeJson(responseBody);
+    return;
+  }
+  if (options.quiet) {
+    return;
+  }
+  writeStdout(message);
+  if (envConfig) {
+    writeStdout(
+      "Environment credentials in PEAKURL_BASE_URL or PEAKURL_API_KEY still apply in this shell."
+    );
+  }
+}
+
+// src/commands/status.ts
+async function status(options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).getStatus();
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    writeStdout(getStatusValue(response.data));
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatStatusReport(response.data));
 }
 
 // src/commands/update.ts
-async function updateCommand(options, currentVersion) {
-  const status = await getUpdateStatus(currentVersion, process.env, {
+async function checkUpdate(options, currentVersion) {
+  const status2 = await getUpdateStatus(currentVersion, process.env, {
     forceRefresh: true
   });
   const responseBody = {
     success: true,
-    message: status.isOutdated ? `A newer PeakURL CLI version is available (${status.latestVersion}).` : `PeakURL CLI ${status.currentVersion} is up to date.`,
+    message: status2.isOutdated ? `A newer PeakURL CLI version is available (${status2.latestVersion}).` : `PeakURL CLI ${status2.currentVersion} is up to date.`,
     data: {
-      currentVersion: status.currentVersion,
-      latestVersion: status.latestVersion,
-      isOutdated: status.isOutdated,
-      installCommand: status.installCommand,
+      currentVersion: status2.currentVersion,
+      latestVersion: status2.latestVersion,
+      isOutdated: status2.isOutdated,
+      installCommand: status2.installCommand,
       checkOnly: Boolean(options.check)
     },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1012,44 +2040,124 @@ async function updateCommand(options, currentVersion) {
     writeJson(responseBody);
     return;
   }
-  if (!status.isOutdated) {
+  if (!status2.isOutdated) {
     if (!options.quiet) {
-      writeStdout(`PeakURL CLI ${status.currentVersion} is up to date.`);
+      writeStdout(`PeakURL CLI ${status2.currentVersion} is up to date.`);
     }
     return;
   }
   if (options.quiet) {
-    writeStdout(status.installCommand);
+    writeStdout(status2.installCommand);
     return;
   }
   writeNoticeBox(
     "Update Available",
     [
-      `peakurl ${status.currentVersion} -> ${status.latestVersion}`,
-      `Run: ${status.installCommand}`
+      `peakurl ${status2.currentVersion} -> ${status2.latestVersion}`,
+      `Run: ${status2.installCommand}`
     ],
     "stdout"
   );
 }
 
+// src/commands/webhooks.ts
+async function listWebhooks(options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).listWebhooks();
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    for (const webhook of response.data ?? []) {
+      const value = getQuietWebhookValue(webhook);
+      if (value) {
+        writeStdout(value);
+      }
+    }
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatWebhooksTable(response.data ?? []));
+  writeStdout(formatWebhooksSummary(response.data ?? []));
+}
+async function createWebhook(url, options) {
+  const events = Array.from(new Set(options.event ?? []));
+  if (events.length === 0) {
+    throw new CliError(
+      "At least one webhook event is required. Use `--event <event>` and run `peakurl webhook events` to see the supported values."
+    );
+  }
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).createWebhook({
+    url: normalizeWebhookUrl(url),
+    events
+  });
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    writeStdout(getQuietWebhookValue(response.data));
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatWebhookDetails(response.data));
+  if (response.data.secret) {
+    writeStdout("Save the signing secret now. PeakURL only shows it once.");
+  }
+}
+async function deleteWebhook(id, options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).deleteWebhook(id.trim());
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    return;
+  }
+  writeStdout(response.message);
+}
+async function listWebhookEvents(options) {
+  const response = {
+    success: true,
+    message: "Webhook events loaded.",
+    data: WEBHOOK_EVENTS,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (options.json) {
+    writeJson(response);
+    return;
+  }
+  if (options.quiet) {
+    for (const event of WEBHOOK_EVENTS) {
+      writeStdout(event.id);
+    }
+    return;
+  }
+  writeStdout(response.message);
+  writeStdout(formatWebhookEventsTable());
+}
+
 // src/commands/whoami.ts
-async function whoamiCommand(options) {
-  const config = await resolveStoredConfig(process.env);
-  const response = await new PeakUrlApiClient(config).whoami();
+async function whoami(options) {
+  const config = await getAuthConfig(process.env);
+  const response = await new ApiClient(config).whoami();
   if (options.json) {
     writeJson(response);
     return;
   }
   if (options.quiet) {
-    writeStdout(getQuietUserValue(response.data));
+    writeStdout(userValue(response.data));
     return;
   }
   writeStdout(response.message);
-  writeStdout(formatUserDetails(response.data));
+  writeStdout(userTable(response.data));
 }
 
 // src/index.ts
-function parsePositiveInteger(label) {
+function parseNumber(label) {
   return (value) => {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -1062,10 +2170,23 @@ function parsePositiveInteger(label) {
 }
 async function getCliVersion() {
   const packageJson = new URL("../package.json", import.meta.url);
-  const content = await readFile2(packageJson, "utf8");
+  const content = await readFile3(packageJson, "utf8");
   const parsed = JSON.parse(content);
   return parsed.version || "0.0.0";
 }
+function getRetryCommandName(argv) {
+  const first = argv[2]?.trim();
+  if (!first || first.startsWith("-")) {
+    return void 0;
+  }
+  if (first === "webhook" || first === "webhooks") {
+    const second = argv[3]?.trim();
+    if (second && !second.startsWith("-")) {
+      return `${first} ${second}`;
+    }
+  }
+  return first;
+}
 async function main() {
   const program = new Command();
   const version = await getCliVersion();
@@ -1073,17 +2194,23 @@ async function main() {
     "after",
     `
 Examples:
-  peakurl login --base-url https://peakurl.org --api-key 0123456789abcdef0123456789abcdef0123456789abcdef
+  peakurl login --base-url https://example.com/api/v1 --api-key 0123456789abcdef0123456789abcdef0123456789abcdef
   peakurl whoami --json
+  peakurl logout
+  peakurl status
   peakurl create https://example.com --alias example
+  peakurl import ./links.csv
+  peakurl export --format csv
   peakurl list --limit 10
+  peakurl webhook list
+  peakurl webhook create https://example.com/api/webhooks/peakurl --event link.clicked
   peakurl update --check
   peakurl get example
   peakurl delete example --quiet`
   ).exitOverride();
   program.hook("preAction", async (_command, actionCommand) => {
     const options = actionCommand.optsWithGlobals();
-    await maybeShowUpdateNotice({
+    await checkUpdates({
       currentVersion: version,
       commandName: actionCommand.name(),
       options,
@@ -1094,30 +2221,63 @@ Examples:
     "Save PeakURL credentials after verifying them with GET /users/me."
   ).option(
     "--base-url <url>",
-    "PeakURL base URL, for example https://peakurl.org"
-  ).option("--api-key <token>", "PeakURL API key to store").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(loginCommand);
-  program.command("whoami").description("Show the current authenticated PeakURL user.").option("--json", "Print machine-readable output").option("--quiet", "Print a minimal identity value").action(whoamiCommand);
+    "PeakURL API base URL, for example https://example.com/api/v1"
+  ).option("--api-key <token>", "PeakURL API key to store").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(login);
+  program.command("whoami").description("Show the current authenticated PeakURL user.").option("--json", "Print machine-readable output").option("--quiet", "Print a minimal identity value").action(whoami);
+  program.command("logout").description("Remove saved PeakURL credentials from this device.").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(logout);
+  program.command("status").description("Show the current PeakURL system status snapshot.").option("--json", "Print machine-readable output").option("--quiet", "Print only the overall health value").action(status);
   program.command("create").description("Create a PeakURL short link.").argument("<url>", "Destination URL to shorten").option("--alias <alias>", "Custom alias for the short link").option("--title <title>", "Title to store with the short link").option("--password <password>", "Password-protect the short link").option(
     "--status <status>",
     "Link status, for example active or paused"
-  ).option("--expires-at <iso>", "Expiration timestamp in ISO-8601 format").option("--utm-source <value>", "UTM source").option("--utm-medium <value>", "UTM medium").option("--utm-campaign <value>", "UTM campaign").option("--utm-term <value>", "UTM term").option("--utm-content <value>", "UTM content").option("--json", "Print machine-readable output").option("--quiet", "Print only the created short URL").action(createCommand);
-  program.command("list").description("List PeakURL short links.").option("--page <number>", "Page number", parsePositiveInteger("page")).option("--limit <number>", "Page size", parsePositiveInteger("limit")).option("--search <query>", "Search term").option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order, for example asc or desc").option("--json", "Print machine-readable output").option("--quiet", "Print a minimal per-link value").action(listCommand);
-  program.command("get").description("Fetch a single PeakURL short link by id or alias.").argument("<id-or-alias>", "Link identifier or alias").option("--json", "Print machine-readable output").option("--quiet", "Print only the short URL").action(getCommand);
-  program.command("delete").description("Delete a PeakURL short link by id or alias.").argument("<id-or-alias>", "Link identifier or alias").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(deleteCommand);
+  ).option("--expires-at <iso>", "Expiration timestamp in ISO-8601 format").option("--utm-source <value>", "UTM source").option("--utm-medium <value>", "UTM medium").option("--utm-campaign <value>", "UTM campaign").option("--utm-term <value>", "UTM term").option("--utm-content <value>", "UTM content").option("--json", "Print machine-readable output").option("--quiet", "Print only the created short URL").action(createLink);
+  program.command("import").description(
+    "Import multiple short links from a local CSV, JSON, or XML file."
+  ).argument("<file>", "Path to the import file").option("--format <format>", "File format: csv, json, or xml").option("--json", "Print machine-readable output").option("--quiet", "Print only the created short URLs").action(importLinks);
+  program.command("export").description(
+    "Export accessible links as a local CSV, JSON, or XML file."
+  ).option("--format <format>", "File format: csv, json, or xml").option("--output <path>", "Write the export to a specific file").option("--stdout", "Write the raw export content to stdout").option("--search <query>", "Search term").option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order, for example asc or desc").option("--quiet", "Print only the saved export path").action(exportLinks);
+  program.command("list").description("List PeakURL short links.").option("--page <number>", "Page number", parseNumber("page")).option("--limit <number>", "Page size", parseNumber("limit")).option("--search <query>", "Search term").option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order, for example asc or desc").option("--json", "Print machine-readable output").option("--quiet", "Print a minimal per-link value").action(listLinks);
+  program.command("get").description("Fetch a single PeakURL short link by id or alias.").argument("<id-or-alias>", "Link identifier or alias").option("--json", "Print machine-readable output").option("--quiet", "Print only the short URL").action(getLink);
+  program.command("delete").description("Delete a PeakURL short link by id or alias.").argument("<id-or-alias>", "Link identifier or alias").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(deleteLink);
   program.command("update").description(
     "Check for a newer CLI version and print the npm command to install it."
   ).option(
     "--check",
     "Alias for checking update status without changing anything"
-  ).option("--json", "Print machine-readable output").option("--quiet", "Print minimal output").action((options) => updateCommand(options, version));
+  ).option("--json", "Print machine-readable output").option("--quiet", "Print minimal output").action((options) => checkUpdate(options, version));
+  const webhook = program.command("webhook").alias("webhooks").description("Manage outbound webhook integrations.");
+  webhook.command("list").description("List outbound webhooks.").option("--json", "Print machine-readable output").option("--quiet", "Print minimal webhook identifiers").action(listWebhooks);
+  webhook.command("create").description("Create an outbound webhook.").argument("<url>", "Webhook endpoint URL").option(
+    "--event <event>",
+    "Webhook event id, for example link.clicked",
+    parseWebhookEvents
+  ).option("--json", "Print machine-readable output").option("--quiet", "Print only the created webhook ID").action(createWebhook);
+  webhook.command("delete").description("Delete an outbound webhook by id.").argument("<id>", "Webhook identifier").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(deleteWebhook);
+  webhook.command("events").description("List the webhook events supported by the CLI.").option("--json", "Print machine-readable output").option("--quiet", "Print only event ids").action(listWebhookEvents);
   try {
     await program.parseAsync(process.argv);
   } catch (error) {
     if (error instanceof CommanderError) {
       process.exit(error.exitCode);
     }
-    const cliError = wrapCliError(error);
-    writeStderr(cliError.message);
+    const cliError = ensureCliError(error);
+    if (cliError.kind === "auth_required") {
+      const commandName = getRetryCommandName(process.argv);
+      writeStderr("Authentication required.");
+      writeStderr("PeakURL could not find credentials for this command.");
+      writeStderr(
+        "Use one of the first two steps below, then run the last command."
+      );
+      writeStderr(
+        formatTable(
+          ["Step", "Command", "Notes"],
+          authRows(commandName),
+          "stderr"
+        )
+      );
+    } else {
+      writeStderr(cliError.message);
+    }
     process.exit(cliError.exitCode);
   }
 }