@liquidmetal-ai/raindrop 0.7.0 → 0.8.1

package/bundle/commands/dns/get.js

@@ -0,0 +1,167 @@
+import {
+  resolveDnsNameToZoneId
+} from "../../chunk-GLIYVKQA.js";
+import {
+  source_default
+} from "../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/dns/get.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Get = class extends BaseCommand {
+  static args = {
+    dnsName: import_core.Args.string({
+      description: "DNS name to get details for (e.g., example.com)",
+      required: true
+    })
+  };
+  static description = "Get details of a specific DNS zone";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> example.com
+Shows details for DNS zone for example.com
+`,
+    `<%= config.bin %> <%= command.id %> subdomain.example.com --output json
+Shows zone details in JSON format
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const { client: dnsService, userId, organizationId } = await this.dnsService();
+    try {
+      const zoneId = await resolveDnsNameToZoneId(
+        dnsService,
+        organizationId,
+        userId,
+        this.args.dnsName
+      );
+      const response = await dnsService.getDNSZone({
+        organizationId,
+        userId,
+        zoneId
+      });
+      if (!response.zone) {
+        this.error(`DNS zone for ${this.args.dnsName} not found`, { exit: 1 });
+        return;
+      }
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                zone: {
+                  organizationId: response.zone.organizationId,
+                  fullyQualifiedDomainName: response.zone.fullyQualifiedDomainName,
+                  zoneType: response.zone.zoneType,
+                  status: response.zone.status,
+                  nameServers: response.zone.nameServers,
+                  description: response.zone.description,
+                  createdAt: response.zone.createdAt,
+                  updatedAt: response.zone.updatedAt,
+                  tags: response.zone.tags,
+                  verificationKey: response.zone.verificationKey
+                }
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default: {
+          console.log(`
+${source_default.bold.underline(`DNS Zone: ${response.zone.fullyQualifiedDomainName}`)}
+`);
+          let statusColor;
+          if (response.zone.status === "active") {
+            statusColor = source_default.green;
+          } else if (response.zone.status === "pending") {
+            statusColor = source_default.yellow;
+          } else if (response.zone.status === "error") {
+            statusColor = source_default.red;
+          } else {
+            statusColor = source_default.gray;
+          }
+          console.log(`${source_default.bold("Status:")} ${statusColor(response.zone.status || "unknown")}`);
+          console.log(`${source_default.bold("Type:")} ${source_default.cyan(response.zone.zoneType || "custom")}`);
+          if (response.zone.nameServers && response.zone.nameServers.length > 0) {
+            console.log(`
+${source_default.bold("Nameservers:")}`);
+            for (const ns of response.zone.nameServers) {
+              console.log(`  ${source_default.green("\u2022")} ${ns}`);
+            }
+          }
+          if (response.zone.verificationKey) {
+            console.log(`
+${source_default.bold("Verification Key:")}`);
+            console.log(`  ${source_default.yellow(response.zone.verificationKey)}`);
+          }
+          if (response.zone.description) {
+            console.log(`
+${source_default.bold("Description:")}`);
+            console.log(`  ${response.zone.description}`);
+          }
+          if (response.zone.tags && response.zone.tags.length > 0) {
+            console.log(`
+${source_default.bold("Tags:")}`);
+            console.log(`  ${response.zone.tags.map((tag) => source_default.magenta(tag)).join(", ")}`);
+          }
+          if (response.zone.createdAt || response.zone.updatedAt) {
+            console.log(`
+${source_default.bold("Timestamps:")}`);
+            if (response.zone.createdAt) {
+              const createdDate = new Date(response.zone.createdAt);
+              const formattedCreated = createdDate.toLocaleString("en-US", {
+                weekday: "short",
+                year: "numeric",
+                month: "short",
+                day: "numeric",
+                hour: "2-digit",
+                minute: "2-digit",
+                second: "2-digit",
+                timeZoneName: "short"
+              });
+              console.log(`  ${source_default.dim("Created:")} ${formattedCreated}`);
+            }
+            if (response.zone.updatedAt) {
+              const updatedDate = new Date(response.zone.updatedAt);
+              const formattedUpdated = updatedDate.toLocaleString("en-US", {
+                weekday: "short",
+                year: "numeric",
+                month: "short",
+                day: "numeric",
+                hour: "2-digit",
+                minute: "2-digit",
+                second: "2-digit",
+                timeZoneName: "short"
+              });
+              console.log(`  ${source_default.dim("Updated:")} ${formattedUpdated}`);
+            }
+          }
+          console.log("");
+          break;
+        }
+      }
+    } catch (error) {
+      this.error(`Failed to get DNS zone: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Get as default
+};

package/bundle/commands/dns/list.js

@@ -0,0 +1,193 @@
+import {
+  source_default
+} from "../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/dns/list.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var List = class extends BaseCommand {
+  static args = {};
+  static description = "List DNS zones for your organization";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Lists all DNS zones in compact format (default)
+
+<%= config.bin %> <%= command.id %> --output table
+Lists all DNS zones in table format
+
+<%= config.bin %> <%= command.id %> --output text
+Lists all DNS zones with detailed information
+
+<%= config.bin %> <%= command.id %> --output json
+Lists all DNS zones in JSON format
+
+<%= config.bin %> <%= command.id %> --zone-type custom
+Lists only custom DNS zones
+
+<%= config.bin %> <%= command.id %> --page-size 10
+Lists DNS zones with pagination (10 per page)
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "compact",
+      options: ["text", "table", "json", "compact"]
+    }),
+    pageSize: import_core.Flags.integer({
+      description: "number of zones to return per page",
+      default: 20
+    }),
+    pageToken: import_core.Flags.string({
+      description: "page token for pagination"
+    }),
+    zoneType: import_core.Flags.string({
+      description: "filter by zone type",
+      options: ["custom", "tenant"]
+    })
+  };
+  async run() {
+    const { client: dnsService, userId, organizationId } = await this.dnsService();
+    try {
+      const response = await dnsService.listDNSZones({
+        organizationId,
+        userId,
+        pageSize: this.flags.pageSize,
+        pageToken: this.flags.pageToken,
+        zoneType: this.flags.zoneType
+      });
+      if (!response.zones || response.zones.length === 0) {
+        this.log(source_default.dim("No DNS zones found in this organization"));
+        this.log(source_default.dim("Create a new DNS zone with: raindrop dns create <domain>"));
+        return;
+      }
+      switch (this.flags.output) {
+        case "compact":
+          for (const zone of response.zones) {
+            let statusColor;
+            if (zone.status === "active") {
+              statusColor = source_default.green;
+            } else if (zone.status === "pending") {
+              statusColor = source_default.yellow;
+            } else if (zone.status === "error") {
+              statusColor = source_default.red;
+            } else {
+              statusColor = source_default.gray;
+            }
+            const createdAt = zone.createdAt ? new Date(zone.createdAt).toLocaleDateString() : "N/A";
+            const typeInfo = zone.zoneType && zone.zoneType !== "custom" ? source_default.dim(` (${zone.zoneType})`) : "";
+            console.log(`
+${source_default.bold(zone.fullyQualifiedDomainName)}${typeInfo}`);
+            console.log(`  \u2514\u2500 ${statusColor(zone.status || "unknown")} - ${source_default.dim(createdAt)}`);
+            if (zone.nameServers && zone.nameServers.length > 0) {
+              const nsDisplay = zone.nameServers.length > 2 ? `${zone.nameServers.slice(0, 2).join(", ")} (+${zone.nameServers.length - 2} more)` : zone.nameServers.join(", ");
+              console.log(`     ${source_default.dim(`NS: ${nsDisplay}`)}`);
+            }
+            if (zone.description) {
+              const desc = zone.description.length > 60 ? zone.description.substring(0, 57) + "..." : zone.description;
+              console.log(`     ${source_default.dim(desc)}`);
+            }
+          }
+          console.log("");
+          console.log(source_default.dim("\u2500".repeat(50)));
+          console.log(source_default.dim(`Total: ${response.zones.length} DNS zones`));
+          break;
+        case "text":
+          for (const zone of response.zones) {
+            let statusColor;
+            if (zone.status === "active") {
+              statusColor = source_default.green;
+            } else if (zone.status === "pending") {
+              statusColor = source_default.yellow;
+            } else if (zone.status === "error") {
+              statusColor = source_default.red;
+            } else {
+              statusColor = source_default.gray;
+            }
+            const createdAt = zone.createdAt ? new Date(zone.createdAt).toLocaleDateString() : "N/A";
+            console.log(`Domain: ${source_default.bold(zone.fullyQualifiedDomainName)}`);
+            console.log(`  Status: ${statusColor(zone.status || "unknown")}`);
+            console.log(`  Type: ${source_default.cyan(zone.zoneType || "custom")}`);
+            console.log(`  Created: ${source_default.dim(createdAt)}`);
+            if (zone.nameServers && zone.nameServers.length > 0) {
+              console.log(`  Nameservers:`);
+              for (const ns of zone.nameServers) {
+                console.log(`    - ${source_default.dim(ns)}`);
+              }
+            }
+            if (zone.description) {
+              console.log(`  Description: ${zone.description}`);
+            }
+            if (zone.tags && zone.tags.length > 0) {
+              console.log(`  Tags: ${source_default.magenta(zone.tags.join(", "))}`);
+            }
+            console.log(source_default.dim("\u2500".repeat(50)));
+          }
+          if (response.nextPageToken) {
+            this.log(source_default.dim(`
+Next page token: ${response.nextPageToken}`));
+          }
+          this.log(source_default.bold(`
+Total DNS zones: ${response.zones.length}`));
+          break;
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                zones: response.zones.map((zone) => ({
+                  organizationId: zone.organizationId,
+                  fullyQualifiedDomainName: zone.fullyQualifiedDomainName,
+                  verificationKey: zone.verificationKey,
+                  zoneType: zone.zoneType,
+                  status: zone.status,
+                  nameServers: zone.nameServers,
+                  description: zone.description,
+                  createdAt: zone.createdAt,
+                  updatedAt: zone.updatedAt,
+                  tags: zone.tags
+                })),
+                nextPageToken: response.nextPageToken,
+                totalCount: response.totalCount
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "table":
+          console.table(
+            response.zones.map((zone) => ({
+              Domain: zone.fullyQualifiedDomainName,
+              Type: zone.zoneType || "custom",
+              Status: zone.status || "unknown",
+              Created: zone.createdAt ? new Date(zone.createdAt).toLocaleDateString() : "N/A",
+              Nameservers: zone.nameServers?.slice(0, 2).join(", ") + (zone.nameServers && zone.nameServers.length > 2 ? "..." : "") || "",
+              Description: zone.description ? zone.description.substring(0, 30) + (zone.description.length > 30 ? "..." : "") : ""
+            }))
+          );
+          if (response.nextPageToken) {
+            this.log(source_default.dim(`
+Next page token: ${response.nextPageToken}`));
+          }
+          this.log(source_default.bold(`
+Total DNS zones: ${response.zones.length}`));
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to list DNS zones: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  List as default
+};

package/bundle/commands/dns/records/create.js

@@ -0,0 +1,150 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/dns/records/create.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Create = class extends BaseCommand {
+  static args = {
+    zoneId: import_core.Args.string({
+      description: "Zone ID to create record in",
+      required: true
+    }),
+    type: import_core.Args.string({
+      description: "Record type (A, AAAA, CNAME, MX, TXT, NS, etc.)",
+      required: true
+    }),
+    name: import_core.Args.string({
+      description: "Record name (e.g., www, @, subdomain)",
+      required: true
+    }),
+    content: import_core.Args.string({
+      description: "Record content (IP address, domain, text value, etc.)",
+      required: true
+    })
+  };
+  static description = "Create a new DNS record";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> zone-123 A www 192.0.2.1
+Creates an A record for www pointing to 192.0.2.1
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 MX @ mail.example.com --priority 10
+Creates an MX record with priority 10
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 TXT @ "v=spf1 include:_spf.google.com ~all"
+Creates a TXT record for SPF
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    ttl: import_core.Flags.integer({
+      description: "Time to live in seconds (1 = automatic)",
+      default: 1
+    }),
+    priority: import_core.Flags.integer({
+      char: "p",
+      description: "Priority (for MX and SRV records)"
+    }),
+    proxied: import_core.Flags.boolean({
+      description: "Whether the record should be proxied through CloudFlare",
+      default: false
+    }),
+    comment: import_core.Flags.string({
+      char: "c",
+      description: "Comment for the record"
+    }),
+    tags: import_core.Flags.string({
+      description: "Comma-separated list of tags",
+      multiple: true
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const { client: dnsService, userId, organizationId } = await this.dnsService();
+    try {
+      const validTypes = ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SOA", "SRV", "CAA", "PTR"];
+      if (!validTypes.includes(this.args.type.toUpperCase())) {
+        this.warn(`Record type ${this.args.type} may not be supported`);
+      }
+      if (this.args.type.toUpperCase() === "MX" && this.flags.priority === void 0) {
+        this.error("MX records require a priority value", { exit: 1 });
+      }
+      this.log(`Creating ${this.args.type} record...`);
+      const response = await dnsService.createDNSRecord({
+        organizationId,
+        userId,
+        zoneId: this.args.zoneId,
+        type: this.args.type.toUpperCase(),
+        name: this.args.name,
+        content: this.args.content,
+        ttl: this.flags.ttl,
+        priority: this.flags.priority,
+        proxied: this.flags.proxied,
+        comment: this.flags.comment,
+        tags: this.flags.tags || []
+      });
+      if (!response.record) {
+        this.error("Failed to create DNS record: No record returned", { exit: 1 });
+        return;
+      }
+      switch (this.flags.output) {
+        case "json":
+          console.log(JSON.stringify({
+            record: {
+              recordId: response.record.recordId,
+              zoneId: response.record.zoneId,
+              name: response.record.name,
+              type: response.record.type,
+              content: response.record.content,
+              ttl: response.record.ttl,
+              priority: response.record.priority,
+              proxied: response.record.proxied,
+              cloudflareRecordId: response.record.cloudflareRecordId,
+              comment: response.record.comment,
+              tags: response.record.tags,
+              createdAt: response.record.createdAt,
+              updatedAt: response.record.updatedAt
+            }
+          }, null, 2));
+          break;
+        case "text":
+        default:
+          this.log("\n\u2705 DNS record created successfully!\n");
+          this.log(`Record ID: ${response.record.recordId}`);
+          this.log(`Name: ${response.record.name}`);
+          this.log(`Type: ${response.record.type}`);
+          this.log(`Content: ${response.record.content}`);
+          this.log(`TTL: ${response.record.ttl === 1 ? "Auto" : `${response.record.ttl} seconds`}`);
+          if (response.record.priority !== void 0) {
+            this.log(`Priority: ${response.record.priority}`);
+          }
+          if (response.record.proxied !== void 0) {
+            this.log(`Proxied: ${response.record.proxied ? "Yes" : "No"}`);
+          }
+          if (response.record.comment) {
+            this.log(`Comment: ${response.record.comment}`);
+          }
+          if (response.record.tags && response.record.tags.length > 0) {
+            this.log(`Tags: ${response.record.tags.join(", ")}`);
+          }
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to create DNS record: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Create as default
+};

package/bundle/commands/dns/records/delete.js

@@ -0,0 +1,76 @@
+import {
+  esm_default
+} from "../../../chunk-5GH4FS6C.js";
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/dns/records/delete.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Delete = class extends BaseCommand {
+  static args = {
+    zoneId: import_core.Args.string({
+      description: "Zone ID containing the record",
+      required: true
+    }),
+    recordId: import_core.Args.string({
+      description: "Record ID to delete",
+      required: true
+    })
+  };
+  static description = "Delete a DNS record";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> zone-123 record-456
+Deletes the DNS record with ID record-456 from zone-123
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 record-789 --force
+Deletes the DNS record without confirmation prompt
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    force: import_core.Flags.boolean({
+      char: "f",
+      description: "Skip confirmation prompt",
+      default: false
+    })
+  };
+  async run() {
+    const { client: dnsService, userId, organizationId } = await this.dnsService();
+    try {
+      if (!this.flags.force) {
+        const shouldDelete = await esm_default({
+          message: `Are you sure you want to delete record ${this.args.recordId}? This action cannot be undone.`,
+          default: false
+        });
+        if (!shouldDelete) {
+          this.log("Deletion cancelled");
+          return;
+        }
+      }
+      this.log(`Deleting DNS record ${this.args.recordId}...`);
+      const response = await dnsService.deleteDNSRecord({
+        organizationId,
+        userId,
+        zoneId: this.args.zoneId,
+        recordId: this.args.recordId
+      });
+      if (response.success) {
+        this.log(`\u2705 DNS record ${this.args.recordId} deleted successfully`);
+      } else {
+        this.error("Failed to delete DNS record", { exit: 1 });
+      }
+    } catch (error) {
+      this.error(`Failed to delete DNS record: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Delete as default
+};