peakurl 0.2.0 → 0.3.0

package/bin/peakurl.js

@@ -1,9 +1,13 @@
 #!/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;
@@ -34,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;
@@ -80,6 +86,22 @@ 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 isApiResponse(value) {
@@ -87,17 +109,17 @@ function isApiResponse(value) {
     value && typeof value === "object" && "success" in value && "message" in value && "timestamp" in value
   );
 }
-function networkError(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 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;
@@ -114,6 +136,14 @@ var ApiClient = 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.
    *
@@ -135,6 +165,29 @@ var ApiClient = class {
   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/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.
    *
@@ -164,6 +217,35 @@ var ApiClient = 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.
    *
@@ -175,7 +257,7 @@ var ApiClient = 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, {
@@ -188,7 +270,7 @@ var ApiClient = class {
         body: body ? JSON.stringify(body) : void 0
       });
     } catch (error) {
-      throw new CliError(networkError(this.config.baseUrl, error), 1, {
+      throw new CliError(networkError(this.config.apiBaseUrl, error), 1, {
         cause: error instanceof Error ? error : void 0
       });
     }
@@ -273,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) {
@@ -388,42 +471,158 @@ var StateStore = class {
 
 // src/lib/auth.ts
 var AUTH_REQUIRED_MESSAGE = "PeakURL credentials are not configured.";
-function authRows() {
-  return [
-    ["Reason", AUTH_REQUIRED_MESSAGE],
-    ["Command", "peakurl login"],
-    ["Flags", "--base-url <url> --api-key <key>"],
-    ["Env", "PEAKURL_BASE_URL, PEAKURL_API_KEY"]
+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 baseUrl = input.baseUrl?.trim() || env.PEAKURL_BASE_URL?.trim();
+  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 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) {
+  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}
@@ -474,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 ? {
@@ -502,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),
@@ -518,7 +729,7 @@ function formatTable(headers, rows, target = "stdout") {
       border.middleJunction,
       border.separatorRight
     ),
-    ...rows.map(formatTableRow),
+    ...rows2.map(formatTableRow),
     formatTableBorder(
       border.bottomLeft,
       border.bottomJunction,
@@ -530,6 +741,261 @@ 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 asObject(value) {
@@ -631,14 +1097,14 @@ 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(asString(link.status) || "-", 12)
   ]);
-  return formatTable(headers, rows);
+  return formatTable(headers, rows2);
 }
 function formatListSummary(data, count) {
   const meta = getListMeta(data);
@@ -654,6 +1120,323 @@ function formatListSummary(data, count) {
   return `${count} link${count === 1 ? "" : "s"} returned.`;
 }
 
+// src/lib/status.ts
+function text3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function integer(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function flag(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === 1 || value === "1") {
+    return true;
+  }
+  if (value === 0 || value === "0") {
+    return false;
+  }
+  return void 0;
+}
+function yesNo(value, yes = "Yes", no = "No") {
+  const normalized = flag(value);
+  if (normalized === void 0) {
+    return void 0;
+  }
+  return normalized ? yes : no;
+}
+function formatState(value) {
+  const normalized = text3(value)?.toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  switch (normalized) {
+    case "ok":
+      return "Good";
+    case "warning":
+      return "Warning";
+    case "error":
+      return "Error";
+    default:
+      return normalized;
+  }
+}
+function formatCount(value) {
+  const normalized = integer(value);
+  return normalized === void 0 ? text3(value) : String(normalized);
+}
+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 formatSeconds(value) {
+  const normalized = integer(value);
+  return normalized === void 0 ? text3(value) : `${normalized} seconds`;
+}
+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");
+}
+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
+  };
+}
+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;
+  }
+  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;
+  }
+  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
 var PACKAGE_NAME = "peakurl";
 var DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
@@ -829,10 +1612,10 @@ async function getUpdateStatus(currentVersion, env, options) {
     installCommand: getUpdateInstallCommand()
   };
 }
-function showUpdateNotice(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 checkUpdates(options) {
@@ -844,51 +1627,157 @@ async function checkUpdates(options) {
   }
   const store = new StateStore();
   const updateState = await getUpdateState(store);
-  const status = await getUpdateStatus(options.currentVersion, options.env, {
+  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
   });
-  showUpdateNotice(status);
+  showUpdateNotice(status2);
 }
 
 // src/lib/users.ts
-function text(value) {
+function text4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function userLabel(user) {
-  const fullName = [text(user.firstName), text(user.lastName)].filter((value) => Boolean(value)).join(" ");
-  return fullName || text(user.username) || text(user.email) || String(user.id ?? "unknown");
+  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 text(user.username) || text(user.email) || String(user.id ?? "");
+  return text4(user.username) || text4(user.email) || String(user.id ?? "");
 }
 function userTable(user) {
-  const rows = [
+  const rows2 = [
     ["Name", userLabel(user)],
-    ["Username", text(user.username)],
-    ["Email", text(user.email)],
-    ["Role", text(user.role)],
+    ["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 (rows.length === 0) {
+  if (rows2.length === 0) {
     return "No user fields returned.";
   }
-  return formatTable(["Field", "Value"], rows);
+  return formatTable(["Field", "Value"], rows2);
 }
 
-// src/commands/create.ts
+// 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;
@@ -898,7 +1787,7 @@ function normalizeExpiresAt(value) {
   }
   return value;
 }
-async function createCommand(destinationUrl, options) {
+async function createLink(destinationUrl, options) {
   const config = await getAuthConfig(process.env);
   const response = await new ApiClient(config).createUrl({
     destinationUrl: normalizeDestinationUrl(destinationUrl),
@@ -924,47 +1813,73 @@ async function createCommand(destinationUrl, options) {
   writeStdout(response.message);
   writeStdout(formatLinkDetails(response.data));
 }
-
-// src/commands/delete.ts
-async function deleteCommand(idOrAlias, options) {
+async function importLinks(filePath, options) {
+  const format = getImportFormat(filePath, options.format);
+  const urls = await readImportRows(filePath, format);
   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);
+  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 ?? {}));
 }
-
-// src/commands/get.ts
-async function getCommand(idOrAlias, options) {
+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).getUrl(idOrAlias);
-  if (options.json) {
-    writeJson(response);
+  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(getQuietLinkValue(response.data));
+    writeStdout(filePath);
     return;
   }
   writeStdout(response.message);
-  writeStdout(formatLinkDetails(response.data));
+  writeStdout(
+    `Saved ${links.length} link${links.length === 1 ? "" : "s"} to ${filePath}.`
+  );
 }
-
-// src/commands/list.ts
-async function listCommand(options) {
+async function listLinks(options) {
   const config = await getAuthConfig(process.env);
   const response = await new ApiClient(config).listUrls({
     page: options.page,
@@ -991,18 +1906,52 @@ async function listCommand(options) {
   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 loginCommand(options) {
+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.baseUrl}.`,
+    message: `Saved credentials for ${credentials.apiBaseUrl}.`,
     data: {
-      baseUrl: credentials.baseUrl,
+      apiBaseUrl: credentials.apiBaseUrl,
       user: response.data
     },
     timestamp: response.timestamp
@@ -1014,7 +1963,7 @@ async function loginCommand(options) {
   if (options.quiet) {
     return;
   }
-  writeStdout(`Saved credentials for ${credentials.baseUrl}`);
+  writeStdout(`Saved credentials for ${credentials.apiBaseUrl}`);
   writeStdout(`Authenticated as ${userLabel(response.data)}`);
   writeStdout(userTable(response.data));
 }
@@ -1023,18 +1972,18 @@ async function loginCommand(options) {
 function hasEnvConfig(env) {
   return Boolean(env.PEAKURL_BASE_URL?.trim() || env.PEAKURL_API_KEY?.trim());
 }
-async function logoutCommand(options) {
+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?.baseUrl ? `Logged out. Removed saved credentials for ${saved.baseUrl}.` : removed ? "Logged out. Removed saved PeakURL credentials." : "Already logged out. No saved PeakURL credentials were found.";
+  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,
-      baseUrl: saved?.baseUrl,
+      apiBaseUrl: saved?.apiBaseUrl,
       envCredentialsActive: envConfig
     },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1054,19 +2003,35 @@ async function logoutCommand(options) {
   }
 }
 
+// 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()
@@ -1075,28 +2040,108 @@ 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) {
+async function whoami(options) {
   const config = await getAuthConfig(process.env);
   const response = await new ApiClient(config).whoami();
   if (options.json) {
@@ -1125,10 +2170,23 @@ function parseNumber(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();
@@ -1136,11 +2194,16 @@ 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`
@@ -1158,23 +2221,39 @@ 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);
-  program.command("logout").description("Remove saved PeakURL credentials from this device.").option("--json", "Print machine-readable output").option("--quiet", "Suppress success output").action(logoutCommand);
+    "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", 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(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) {
@@ -1183,8 +2262,19 @@ Examples:
     }
     const cliError = ensureCliError(error);
     if (cliError.kind === "auth_required") {
-      writeStderr("Not logged in.");
-      writeStderr(formatTable(["Field", "Value"], authRows(), "stderr"));
+      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);
     }