porkbun-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,1418 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import "dotenv/config";
+import { defineCommand as defineCommand8, runMain } from "citty";
+
+// src/cli/commands/dns.ts
+import { defineCommand } from "citty";
+
+// src/cli/config.ts
+import { PorkbunClient } from "porkbun-sdk";
+var getClient = () => {
+  const apikey = process.env.PORKBUN_API_KEY;
+  const secretapikey = process.env.PORKBUN_API_SECRET;
+  if (!apikey || !secretapikey) {
+    console.error(
+      JSON.stringify({
+        error: "Missing credentials",
+        message: "Set PORKBUN_API_KEY and PORKBUN_API_SECRET environment variables"
+      })
+    );
+    process.exit(1);
+  }
+  return new PorkbunClient({ apikey, secretapikey });
+};
+
+// src/cli/output.ts
+import Table from "cli-table3";
+import consola from "consola";
+var resolveValue = (row, col) => {
+  const val = col.get ? col.get(row) : row[col.key];
+  if (val === null || val === void 0) return "";
+  return String(val);
+};
+var autoColumns = (data) => {
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of data) {
+    for (const key of Object.keys(row)) {
+      keys.add(key);
+    }
+  }
+  return [...keys].map((key) => ({ key, header: key }));
+};
+var unwrapData = (data) => {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    const obj = data;
+    let bestKey = "";
+    let bestLen = 0;
+    for (const [key, val] of Object.entries(obj)) {
+      if (Array.isArray(val) && val.length > bestLen) {
+        bestKey = key;
+        bestLen = val.length;
+      }
+    }
+    if (bestKey) return obj[bestKey];
+  }
+  return [data];
+};
+var outputTable = (data, columns) => {
+  const rows = unwrapData(data);
+  if (rows.length === 0) {
+    consola.info("No data to display");
+    return;
+  }
+  const cols = columns ?? autoColumns(rows);
+  const table = new Table({
+    head: cols.map((c) => c.header),
+    style: { head: ["cyan"], border: ["gray"] }
+  });
+  for (const row of rows) {
+    table.push(cols.map((col) => resolveValue(row, col)));
+  }
+  console.log(table.toString());
+};
+var escapeCsv = (val) => {
+  if (val.includes(",") || val.includes('"') || val.includes("\n")) {
+    return `"${val.replace(/"/g, '""')}"`;
+  }
+  return val;
+};
+var outputCsv = (data, columns) => {
+  const rows = unwrapData(data);
+  if (rows.length === 0) return;
+  const cols = columns ?? autoColumns(rows);
+  console.log(cols.map((c) => escapeCsv(c.header)).join(","));
+  for (const row of rows) {
+    console.log(cols.map((col) => escapeCsv(resolveValue(row, col))).join(","));
+  }
+};
+var output = (data, options) => {
+  const format = options?.format ?? "json";
+  switch (format) {
+    case "table":
+      outputTable(data, options?.columns);
+      break;
+    case "csv":
+      outputCsv(data, options?.columns);
+      break;
+    default:
+      console.log(JSON.stringify(data, null, 2));
+  }
+};
+var outputError = (error) => {
+  if (error && typeof error === "object" && "toJSON" in error) {
+    console.error(
+      JSON.stringify(error.toJSON(), null, 2)
+    );
+  } else {
+    console.error(
+      JSON.stringify(
+        {
+          error: "UnknownError",
+          message: error instanceof Error ? error.message : String(error)
+        },
+        null,
+        2
+      )
+    );
+  }
+  process.exit(1);
+};
+
+// src/cli/table-columns.ts
+var domainColumns = [
+  { key: "domain", header: "Domain" },
+  { key: "status", header: "Status" },
+  { key: "tld", header: "TLD" },
+  { key: "createDate", header: "Created" },
+  { key: "expireDate", header: "Expires" },
+  {
+    key: "autoRenew",
+    header: "Auto-Renew",
+    get: (r) => String(r.autoRenew) === "1" ? "on" : "off"
+  },
+  { key: "securityLock", header: "Lock" }
+];
+var dnsColumns = [
+  { key: "id", header: "ID" },
+  { key: "name", header: "Name" },
+  { key: "type", header: "Type" },
+  { key: "content", header: "Content" },
+  { key: "ttl", header: "TTL" },
+  { key: "prio", header: "Priority" },
+  { key: "notes", header: "Notes" }
+];
+var urlForwardColumns = [
+  { key: "id", header: "ID" },
+  { key: "subdomain", header: "Subdomain" },
+  { key: "location", header: "Location" },
+  { key: "type", header: "Type" },
+  { key: "includePath", header: "Include Path" },
+  { key: "wildcard", header: "Wildcard" }
+];
+var glueColumns = [
+  { key: "hostname", header: "Hostname" },
+  {
+    key: "ips",
+    header: "IPs",
+    get: (r) => Array.isArray(r.ips) ? r.ips.join(", ") : String(r.ips ?? "")
+  }
+];
+var dnssecColumns = [
+  { key: "keyTag", header: "Key Tag" },
+  { key: "alg", header: "Algorithm" },
+  { key: "digestType", header: "Digest Type" },
+  { key: "digest", header: "Digest" }
+];
+
+// src/cli/commands/dns.ts
+var list = defineCommand({
+  meta: { name: "list", description: "List DNS records for a domain" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    id: {
+      type: "string",
+      description: "Filter by record ID"
+    },
+    type: {
+      type: "string",
+      description: "Filter by record type (A, CNAME, MX, etc.)"
+    },
+    subdomain: {
+      type: "string",
+      description: "Filter by subdomain (used with --type)"
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const records = args.type ? await client.dns.retrieveByNameType(
+        args.domain,
+        args.type,
+        args.subdomain
+      ) : await client.dns.retrieve(args.domain, args.id);
+      output(records, {
+        format: args.format,
+        columns: dnsColumns
+      });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var create = defineCommand({
+  meta: { name: "create", description: "Create a DNS record" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Record type (A, CNAME, MX, TXT, AAAA, etc.)",
+      required: true
+    },
+    content: {
+      type: "string",
+      description: "Record content/value",
+      required: true
+    },
+    name: {
+      type: "string",
+      description: "Subdomain (empty for root, * for wildcard)"
+    },
+    ttl: {
+      type: "string",
+      description: "TTL in seconds (min 600)"
+    },
+    prio: {
+      type: "string",
+      description: "Priority (for MX, SRV records)"
+    },
+    notes: {
+      type: "string",
+      description: "Notes for this record"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const params = {
+        type: args.type,
+        content: args.content,
+        ...args.name && { name: args.name },
+        ...args.ttl && { ttl: Number(args.ttl) },
+        ...args.prio && { prio: Number(args.prio) },
+        ...args.notes && { notes: args.notes }
+      };
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          payload: params
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dns.create(args.domain, params);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var edit = defineCommand({
+  meta: { name: "edit", description: "Edit a DNS record by ID" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    id: {
+      type: "string",
+      description: "Record ID to edit",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Record type",
+      required: true
+    },
+    content: {
+      type: "string",
+      description: "Record content/value",
+      required: true
+    },
+    name: {
+      type: "string",
+      description: "Subdomain"
+    },
+    ttl: {
+      type: "string",
+      description: "TTL in seconds"
+    },
+    prio: {
+      type: "string",
+      description: "Priority"
+    },
+    notes: {
+      type: "string",
+      description: "Notes"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const params = {
+        type: args.type,
+        content: args.content,
+        ...args.name && { name: args.name },
+        ...args.ttl && { ttl: Number(args.ttl) },
+        ...args.prio && { prio: Number(args.prio) },
+        ...args.notes !== void 0 && { notes: args.notes }
+      };
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          recordId: args.id,
+          payload: params
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dns.edit(args.domain, args.id, params);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var editByNameType = defineCommand({
+  meta: {
+    name: "edit-by-name-type",
+    description: "Edit DNS records by domain, type and subdomain"
+  },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Record type",
+      required: true
+    },
+    content: {
+      type: "string",
+      description: "Record content/value",
+      required: true
+    },
+    subdomain: {
+      type: "string",
+      description: "Subdomain"
+    },
+    ttl: {
+      type: "string",
+      description: "TTL in seconds"
+    },
+    prio: {
+      type: "string",
+      description: "Priority"
+    },
+    notes: {
+      type: "string",
+      description: "Notes"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const params = {
+        content: args.content,
+        ...args.ttl && { ttl: Number(args.ttl) },
+        ...args.prio && { prio: Number(args.prio) },
+        ...args.notes !== void 0 && { notes: args.notes }
+      };
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          type: args.type,
+          subdomain: args.subdomain ?? "(root)",
+          payload: params
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dns.editByNameType(
+        args.domain,
+        args.type,
+        args.subdomain,
+        params
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var deleteRecord = defineCommand({
+  meta: { name: "delete", description: "Delete a DNS record by ID" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    id: {
+      type: "string",
+      description: "Record ID to delete",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          action: "delete_dns_record",
+          recordId: args.id
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dns.delete(args.domain, args.id);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var deleteByNameType = defineCommand({
+  meta: {
+    name: "delete-by-name-type",
+    description: "Delete DNS records by domain, type and subdomain"
+  },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Record type",
+      required: true
+    },
+    subdomain: {
+      type: "string",
+      description: "Subdomain"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          action: "delete_dns_by_name_type",
+          type: args.type,
+          subdomain: args.subdomain ?? "(root)"
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dns.deleteByNameType(
+        args.domain,
+        args.type,
+        args.subdomain
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var dns = defineCommand({
+  meta: { name: "dns", description: "Manage DNS records" },
+  subCommands: {
+    list,
+    create,
+    edit,
+    "edit-by-name-type": editByNameType,
+    delete: deleteRecord,
+    "delete-by-name-type": deleteByNameType
+  }
+});
+
+// src/cli/commands/dnssec.ts
+import { defineCommand as defineCommand2 } from "citty";
+var list2 = defineCommand2({
+  meta: { name: "list", description: "List DNSSEC records" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const records = await client.dnssec.get(args.domain);
+      if (args.format === "table" || args.format === "csv") {
+        const rows = Object.values(records);
+        output(rows, {
+          format: args.format,
+          columns: dnssecColumns
+        });
+      } else {
+        output(records);
+      }
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var create2 = defineCommand2({
+  meta: { name: "create", description: "Create a DNSSEC record" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    "key-tag": {
+      type: "string",
+      description: "Key tag",
+      required: true
+    },
+    alg: {
+      type: "string",
+      description: "DS Data algorithm",
+      required: true
+    },
+    "digest-type": {
+      type: "string",
+      description: "Digest type",
+      required: true
+    },
+    digest: {
+      type: "string",
+      description: "Digest",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const params = {
+        keyTag: args["key-tag"],
+        alg: args.alg,
+        digestType: args["digest-type"],
+        digest: args.digest
+      };
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          payload: params
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dnssec.create(args.domain, params);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var deleteRecord2 = defineCommand2({
+  meta: { name: "delete", description: "Delete a DNSSEC record" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    "key-tag": {
+      type: "string",
+      description: "Key tag to delete",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          action: "delete_dnssec",
+          keyTag: args["key-tag"]
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.dnssec.delete(args.domain, args["key-tag"]);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var dnssec = defineCommand2({
+  meta: { name: "dnssec", description: "Manage DNSSEC records" },
+  subCommands: { list: list2, create: create2, delete: deleteRecord2 }
+});
+
+// src/cli/commands/domain.ts
+import { defineCommand as defineCommand3 } from "citty";
+var list3 = defineCommand3({
+  meta: { name: "list", description: "List all domains" },
+  args: {
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    },
+    start: {
+      type: "string",
+      description: "Pagination start index (increments of 1000)"
+    },
+    labels: {
+      type: "boolean",
+      description: "Include domain labels",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.domain.listAll({
+        start: args.start ? Number(args.start) : void 0,
+        includeLabels: args.labels
+      });
+      output(result.domains, {
+        format: args.format,
+        columns: domainColumns
+      });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var check = defineCommand3({
+  meta: { name: "check", description: "Check domain availability" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name to check (e.g. example.com)",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.domain.check(args.domain);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var create3 = defineCommand3({
+  meta: { name: "create", description: "Register a new domain" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name to register",
+      required: true
+    },
+    cost: {
+      type: "string",
+      description: "Cost in cents (integer)",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const params = {
+        cost: Number(args.cost),
+        agreeToTerms: "yes"
+      };
+      if (args["dry-run"]) {
+        output({ dry_run: true, domain: args.domain, payload: params });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.create(args.domain, params);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var nsGet = defineCommand3({
+  meta: { name: "get", description: "Get name servers for a domain" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.domain.getNameServers(args.domain);
+      if (args.format === "table" || args.format === "csv") {
+        output(
+          result.ns.map((ns2, i) => ({ index: i + 1, nameserver: ns2 })),
+          {
+            format: args.format,
+            columns: [
+              { key: "index", header: "#" },
+              { key: "nameserver", header: "Name Server" }
+            ]
+          }
+        );
+      } else {
+        output(result);
+      }
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var nsUpdate = defineCommand3({
+  meta: { name: "update", description: "Update name servers for a domain" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    ns: {
+      type: "string",
+      description: "Name servers (comma-separated)",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const nameservers = args.ns.split(",").map((s) => s.trim());
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          payload: { ns: nameservers }
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.updateNameServers(
+        args.domain,
+        nameservers
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var ns = defineCommand3({
+  meta: { name: "ns", description: "Manage domain name servers" },
+  subCommands: { get: nsGet, update: nsUpdate }
+});
+var autoRenew = defineCommand3({
+  meta: { name: "auto-renew", description: "Update auto-renew status" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    status: {
+      type: "string",
+      description: "Auto-renew status: on or off",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const status = args.status;
+      if (status !== "on" && status !== "off") {
+        outputError(new Error("Status must be 'on' or 'off'"));
+        return;
+      }
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          payload: { status }
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.updateAutoRenew(
+        { status },
+        args.domain
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var forwardList = defineCommand3({
+  meta: { name: "list", description: "List URL forwards for a domain" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.domain.getUrlForwarding(args.domain);
+      output(result, {
+        format: args.format,
+        columns: urlForwardColumns
+      });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var forwardAdd = defineCommand3({
+  meta: { name: "add", description: "Add a URL forward" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    location: {
+      type: "string",
+      description: "Destination URL",
+      required: true
+    },
+    subdomain: {
+      type: "string",
+      description: "Subdomain (empty for root)"
+    },
+    type: {
+      type: "string",
+      description: "Redirect type: temporary or permanent",
+      default: "permanent"
+    },
+    "include-path": {
+      type: "string",
+      description: "Include path: yes or no",
+      default: "no"
+    },
+    wildcard: {
+      type: "string",
+      description: "Wildcard: yes or no",
+      default: "no"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const params = {
+        location: args.location,
+        type: args.type,
+        includePath: args["include-path"],
+        wildcard: args.wildcard,
+        ...args.subdomain && { subdomain: args.subdomain }
+      };
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          payload: params
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.addUrlForward(args.domain, params);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var forwardDelete = defineCommand3({
+  meta: { name: "delete", description: "Delete a URL forward" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    id: {
+      type: "string",
+      description: "Forward record ID",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          action: "delete_url_forward",
+          recordId: args.id
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.deleteUrlForward(args.domain, args.id);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var forward = defineCommand3({
+  meta: { name: "forward", description: "Manage URL forwarding" },
+  subCommands: { list: forwardList, add: forwardAdd, delete: forwardDelete }
+});
+var glueList = defineCommand3({
+  meta: { name: "list", description: "List glue records" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.domain.getGlueRecords(args.domain);
+      output(result.hosts ?? [], {
+        format: args.format,
+        columns: glueColumns
+      });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var glueCreate = defineCommand3({
+  meta: { name: "create", description: "Create a glue record" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    subdomain: {
+      type: "string",
+      description: "Glue host subdomain",
+      required: true
+    },
+    ips: {
+      type: "string",
+      description: "IP addresses (comma-separated)",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const ips = args.ips.split(",").map((s) => s.trim());
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          subdomain: args.subdomain,
+          payload: { ips }
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.createGlueRecord(
+        args.domain,
+        args.subdomain,
+        ips
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var glueUpdate = defineCommand3({
+  meta: { name: "update", description: "Update a glue record" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    subdomain: {
+      type: "string",
+      description: "Glue host subdomain",
+      required: true
+    },
+    ips: {
+      type: "string",
+      description: "IP addresses (comma-separated)",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const ips = args.ips.split(",").map((s) => s.trim());
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          subdomain: args.subdomain,
+          payload: { ips }
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.updateGlueRecord(
+        args.domain,
+        args.subdomain,
+        ips
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var glueDelete = defineCommand3({
+  meta: { name: "delete", description: "Delete a glue record" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    subdomain: {
+      type: "string",
+      description: "Glue host subdomain",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the request without executing",
+      default: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args["dry-run"]) {
+        output({
+          dry_run: true,
+          domain: args.domain,
+          action: "delete_glue_record",
+          subdomain: args.subdomain
+        });
+        return;
+      }
+      const client = getClient();
+      const result = await client.domain.deleteGlueRecord(
+        args.domain,
+        args.subdomain
+      );
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+var glue = defineCommand3({
+  meta: { name: "glue", description: "Manage glue records" },
+  subCommands: {
+    list: glueList,
+    create: glueCreate,
+    update: glueUpdate,
+    delete: glueDelete
+  }
+});
+var domain = defineCommand3({
+  meta: { name: "domain", description: "Manage domains" },
+  subCommands: {
+    list: list3,
+    check,
+    create: create3,
+    ns,
+    "auto-renew": autoRenew,
+    forward,
+    glue
+  }
+});
+
+// src/cli/commands/ping.ts
+import { defineCommand as defineCommand4 } from "citty";
+var ping = defineCommand4({
+  meta: { name: "ping", description: "Test API authentication" },
+  args: {
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.ping();
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+
+// src/cli/commands/pricing.ts
+import { defineCommand as defineCommand5 } from "citty";
+var pricing = defineCommand5({
+  meta: { name: "pricing", description: "Get domain pricing for all TLDs" },
+  args: {
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    },
+    tld: {
+      type: "string",
+      description: "Filter by specific TLD (e.g. com, net, dev)"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.pricing.get();
+      if (args.tld) {
+        const tld = args.tld.replace(/^\./, "");
+        const pricing2 = result.pricing[tld];
+        if (!pricing2) {
+          outputError(new Error(`TLD ".${tld}" not found`));
+          return;
+        }
+        output(
+          { tld, ...pricing2 },
+          {
+            format: args.format,
+            columns: [
+              { key: "tld", header: "TLD" },
+              { key: "registration", header: "Registration" },
+              { key: "renewal", header: "Renewal" },
+              { key: "transfer", header: "Transfer" }
+            ]
+          }
+        );
+        return;
+      }
+      if (args.format === "table" || args.format === "csv") {
+        const rows = Object.entries(result.pricing).map(([tld, p]) => ({
+          tld,
+          registration: p.registration,
+          renewal: p.renewal,
+          transfer: p.transfer
+        }));
+        output(rows, {
+          format: args.format,
+          columns: [
+            { key: "tld", header: "TLD" },
+            { key: "registration", header: "Registration" },
+            { key: "renewal", header: "Renewal" },
+            { key: "transfer", header: "Transfer" }
+          ]
+        });
+      } else {
+        output(result);
+      }
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+
+// src/cli/commands/ssl.ts
+import { defineCommand as defineCommand6 } from "citty";
+var ssl = defineCommand6({
+  meta: { name: "ssl", description: "Retrieve SSL certificate bundle" },
+  args: {
+    domain: {
+      type: "positional",
+      description: "Domain name",
+      required: true
+    },
+    format: {
+      type: "string",
+      description: "Output format: json, table, csv",
+      default: "json"
+    }
+  },
+  async run({ args }) {
+    try {
+      const client = getClient();
+      const result = await client.ssl.retrieve(args.domain);
+      output(result, { format: args.format });
+    } catch (e) {
+      outputError(e);
+    }
+  }
+});
+
+// src/cli/commands/version.ts
+import { defineCommand as defineCommand7 } from "citty";
+var version = defineCommand7({
+  meta: { name: "version", description: "Show CLI version" },
+  run() {
+    console.log("1.0.0");
+  }
+});
+
+// src/cli/index.ts
+var main = defineCommand8({
+  meta: {
+    name: "porkbun",
+    version: "1.0.0",
+    description: "Porkbun CLI \u2014 manage domains, DNS, SSL and more"
+  },
+  subCommands: {
+    ping,
+    pricing,
+    domain,
+    dns,
+    dnssec,
+    ssl,
+    version
+  }
+});
+runMain(main);