@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

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

@@ -0,0 +1,118 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/dns/records/get.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Get = 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 get details for",
+      required: true
+    })
+  };
+  static description = "Get details of a specific DNS record";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> zone-123 record-456
+Shows details for DNS record with ID record-456
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 record-789 --output json
+Shows record 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 response = await dnsService.getDNSRecord({
+        organizationId,
+        userId,
+        zoneId: this.args.zoneId,
+        recordId: this.args.recordId
+      });
+      if (!response.record) {
+        this.error(`DNS record ${this.args.recordId} not found`, { 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("DNS Record Details\n");
+          this.log(`Record ID: ${response.record.recordId}`);
+          this.log(`Zone ID: ${response.record.zoneId}`);
+          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(", ")}`);
+          }
+          if (response.record.cloudflareRecordId) {
+            this.log(`
+CloudFlare Record ID: ${response.record.cloudflareRecordId}`);
+          }
+          if (response.record.createdAt) {
+            this.log(`
+Created: ${response.record.createdAt}`);
+          }
+          if (response.record.updatedAt) {
+            this.log(`Updated: ${response.record.updatedAt}`);
+          }
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to get DNS record: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Get as default
+};

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

@@ -0,0 +1,153 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/dns/records/list.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var List = class extends BaseCommand {
+  static args = {
+    zoneId: import_core.Args.string({
+      description: "Zone ID to list records for",
+      required: true
+    })
+  };
+  static description = "List DNS records in a zone";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> zone-123
+Lists all DNS records in zone-123
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 --type A
+Lists only A records in zone-123
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 --name www
+Lists only records with name 'www'
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "table",
+      options: ["text", "table", "json"]
+    }),
+    type: import_core.Flags.string({
+      char: "t",
+      description: "Filter by record type (A, AAAA, CNAME, MX, TXT, NS, etc.)"
+    }),
+    name: import_core.Flags.string({
+      char: "n",
+      description: "Filter by record name"
+    }),
+    pageSize: import_core.Flags.integer({
+      description: "number of records to return per page",
+      default: 20
+    }),
+    pageToken: import_core.Flags.string({
+      description: "page token for pagination"
+    })
+  };
+  async run() {
+    const { client: dnsService, userId, organizationId } = await this.dnsService();
+    try {
+      const response = await dnsService.listDNSRecords({
+        organizationId,
+        userId,
+        zoneId: this.args.zoneId,
+        type: this.flags.type,
+        name: this.flags.name,
+        pageSize: this.flags.pageSize,
+        pageToken: this.flags.pageToken
+      });
+      if (!response.records || response.records.length === 0) {
+        this.log("No DNS records found");
+        return;
+      }
+      switch (this.flags.output) {
+        case "text":
+          for (const record of response.records) {
+            this.log(`${record.name} (${record.recordId})`);
+            this.log(`  Type: ${record.type}`);
+            this.log(`  Content: ${record.content}`);
+            this.log(`  TTL: ${record.ttl || "Auto"}`);
+            if (record.priority !== void 0) {
+              this.log(`  Priority: ${record.priority}`);
+            }
+            if (record.proxied !== void 0) {
+              this.log(`  Proxied: ${record.proxied ? "Yes" : "No"}`);
+            }
+            if (record.comment) {
+              this.log(`  Comment: ${record.comment}`);
+            }
+            this.log("");
+          }
+          if (response.nextPageToken) {
+            this.log(`Next page token: ${response.nextPageToken}`);
+          }
+          if (response.totalCount !== void 0) {
+            this.log(`Total records: ${response.totalCount}`);
+          }
+          break;
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                records: response.records.map((record) => ({
+                  recordId: record.recordId,
+                  zoneId: record.zoneId,
+                  name: record.name,
+                  type: record.type,
+                  content: record.content,
+                  ttl: record.ttl,
+                  priority: record.priority,
+                  proxied: record.proxied,
+                  cloudflareRecordId: record.cloudflareRecordId,
+                  comment: record.comment,
+                  tags: record.tags,
+                  createdAt: record.createdAt,
+                  updatedAt: record.updatedAt
+                })),
+                nextPageToken: response.nextPageToken,
+                totalCount: response.totalCount
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "table":
+          console.table(
+            response.records.map((record) => ({
+              "Record ID": record.recordId,
+              Name: record.name,
+              Type: record.type,
+              Content: record.content,
+              TTL: record.ttl || "Auto",
+              Priority: record.priority || "-",
+              Proxied: record.proxied ? "Yes" : "No",
+              Comment: record.comment || ""
+            }))
+          );
+          if (response.nextPageToken) {
+            this.log(`
+Next page token: ${response.nextPageToken}`);
+          }
+          if (response.totalCount !== void 0) {
+            this.log(`Total records: ${response.totalCount}`);
+          }
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to list DNS records: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  List as default
+};

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

@@ -0,0 +1,146 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/dns/records/update.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Update = 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 update",
+      required: true
+    })
+  };
+  static description = "Update an existing DNS record";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> zone-123 record-456 --content 192.0.2.2
+Updates the content of a record
+`,
+    `<%= config.bin %> <%= command.id %> zone-123 record-456 --ttl 3600 --proxied
+Updates TTL and proxy settings
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    type: import_core.Flags.string({
+      char: "t",
+      description: "Record type (required if changing)"
+    }),
+    name: import_core.Flags.string({
+      char: "n",
+      description: "Record name"
+    }),
+    content: import_core.Flags.string({
+      char: "c",
+      description: "Record content"
+    }),
+    ttl: import_core.Flags.integer({
+      description: "Time to live in seconds (1 = automatic)"
+    }),
+    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",
+      allowNo: true
+    }),
+    comment: import_core.Flags.string({
+      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 {
+      if (!this.flags.type && !this.flags.name && !this.flags.content && this.flags.ttl === void 0 && this.flags.priority === void 0 && this.flags.proxied === void 0 && !this.flags.comment && !this.flags.tags) {
+        this.error("No fields to update. Specify at least one field to change.", { exit: 1 });
+      }
+      this.log(`Updating DNS record ${this.args.recordId}...`);
+      const response = await dnsService.updateDNSRecord({
+        organizationId,
+        userId,
+        zoneId: this.args.zoneId,
+        recordId: this.args.recordId,
+        type: this.flags.type,
+        name: this.flags.name,
+        content: this.flags.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 update 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 updated 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 update DNS record: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Update as default
+};

package/bundle/commands/logs/query.js

@@ -0,0 +1,237 @@
+import {
+  displayTraceGroupedEvents
+} from "../../chunk-KXEV6E63.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  QueryLogsRequestSchema,
+  TimeQuerySchema,
+  __toESM,
+  create,
+  init_cjs_shims,
+  require_lib,
+  timestampFromDate,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/logs/query.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Query = class extends BaseCommand {
+  static args = {};
+  static description = "query logs of applications with time range filtering";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>`,
+    `<%= config.bin %> <%= command.id %> --application my-app`,
+    `<%= config.bin %> <%= command.id %> --application my-app --version v1.2.3`,
+    `<%= config.bin %> <%= command.id %> --application my-app --start-time 1638360000000 --end-time 1638363600000`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "m",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application",
+      required: false
+    }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version",
+      required: false
+    }),
+    startTime: import_core.Flags.string({
+      char: "s",
+      description: "start time for query (Unix timestamp in milliseconds or ISO string)",
+      required: false
+    }),
+    endTime: import_core.Flags.string({
+      char: "e",
+      description: "end time for query (Unix timestamp in milliseconds or ISO string)",
+      required: false
+    }),
+    last: import_core.Flags.string({
+      char: "l",
+      description: 'query logs from last duration (e.g., "1h", "30m", "2d")',
+      required: false
+    }),
+    limit: import_core.Flags.integer({
+      char: "n",
+      description: "maximum number of log events to return",
+      required: false,
+      default: 100
+    }),
+    traceId: import_core.Flags.string({
+      description: "filter logs by trace ID",
+      required: false
+    }),
+    status: import_core.Flags.string({
+      description: "filter logs by status (ok, error)",
+      required: false,
+      options: ["ok", "error"]
+    }),
+    rainbowAuthService: import_core.Flags.string({
+      default: "https://liquidmetal.run/api/connect",
+      hidden: true,
+      env: "LIQUIDMETAL_RAINBOW_AUTH_SERVICE"
+    }),
+    raindropCatalogService: import_core.Flags.string({
+      env: "RAINDROP_CATALOG_SERVICE",
+      description: "URL of the catalog service",
+      hidden: true
+    })
+  };
+  parseTimeToMillis(timeStr) {
+    const timestamp = Number(timeStr);
+    if (!isNaN(timestamp)) {
+      if (timestamp > 1e12) {
+        return timestamp;
+      }
+      return timestamp * 1e3;
+    }
+    const date = new Date(timeStr);
+    if (!isNaN(date.getTime())) {
+      return date.getTime();
+    }
+    throw new Error(`Invalid time format: ${timeStr}. Use Unix timestamp (ms) or ISO string.`);
+  }
+  parseDurationToMillis(duration) {
+    const match = duration.match(/^(\d+)([smhd])$/);
+    if (!match) {
+      throw new Error(`Invalid duration format: ${duration}. Use format like "1h", "30m", "2d".`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      case "d":
+        return value * 24 * 60 * 60 * 1e3;
+      default:
+        throw new Error(`Unsupported duration unit: ${unit}`);
+    }
+  }
+  async run() {
+    const apps = await this.loadManifest();
+    const config = await this.loadConfig();
+    if (!this.flags.version) {
+      if (!config.versionId) {
+        this.error("No version provided or found in config", { exit: 1 });
+      }
+      this.flags.version = config.versionId;
+    }
+    if (!this.flags.application) {
+      const app = apps[0];
+      if (app === void 0) {
+        this.error("No application provided or found in manifest", { exit: 1 });
+      }
+      this.flags.application = valueOf(app.name);
+    }
+    const {
+      userId,
+      client: riverjackService,
+      organizationId: defaultOrganizationId
+    } = await this.tenantRiverjackService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    let startTimeMs;
+    let endTimeMs;
+    const now = Date.now();
+    if (this.flags.last) {
+      try {
+        const durationMs = this.parseDurationToMillis(this.flags.last);
+        startTimeMs = now - durationMs;
+        endTimeMs = now;
+      } catch (error) {
+        this.error(`Invalid duration: ${error instanceof Error ? error.message : String(error)}`, { exit: 1 });
+      }
+    } else if (this.flags.startTime || this.flags.endTime) {
+      try {
+        startTimeMs = this.flags.startTime ? this.parseTimeToMillis(this.flags.startTime) : now - 60 * 60 * 1e3;
+        endTimeMs = this.flags.endTime ? this.parseTimeToMillis(this.flags.endTime) : now;
+      } catch (error) {
+        this.error(`Invalid time format: ${error instanceof Error ? error.message : String(error)}`, { exit: 1 });
+      }
+    } else {
+      startTimeMs = now - 60 * 60 * 1e3;
+      endTimeMs = now;
+    }
+    this.log(`Using organization: ${organizationId}`);
+    this.log(`Using user: ${userId}`);
+    this.log(`Querying logs for ${this.flags.application}@${this.flags.version}`);
+    this.log(`Time range: ${new Date(startTimeMs).toLocaleString()} - ${new Date(endTimeMs).toLocaleString()}`);
+    this.log("");
+    try {
+      const timeQuery = create(TimeQuerySchema, {
+        startTime: timestampFromDate(new Date(startTimeMs)),
+        endTime: timestampFromDate(new Date(endTimeMs))
+      });
+      const request = create(QueryLogsRequestSchema, {
+        organizationId,
+        userId,
+        applicationName: this.flags.application,
+        applicationVersionId: this.flags.version,
+        timeQuery,
+        limit: this.flags.limit,
+        ...this.flags.traceId && { traceId: this.flags.traceId },
+        ...this.flags.status && { status: this.flags.status }
+      });
+      const response = await riverjackService.queryLogs(request);
+      if (this.flags.output === "json") {
+        this.log(
+          JSON.stringify(
+            response,
+            (key, value) => {
+              if (typeof value === "bigint") {
+                return value.toString();
+              }
+              return value;
+            },
+            2
+          )
+        );
+      } else {
+        if (response.events.length === 0) {
+          this.log("No log events found for the specified criteria.");
+        } else {
+          this.log(`Found ${response.events.length} log events (total: ${response.totalCount}):
+`);
+          displayTraceGroupedEvents(response.events, { log: (message) => this.log(message) });
+          if (response.hasMore) {
+            this.log("\u2139\uFE0F  More results available. Use --limit to increase the number of results.");
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        this.error(`Failed to query logs: ${error.message}`, { exit: 1 });
+      } else {
+        this.error("Failed to query logs: Unknown error", { exit: 1 });
+      }
+    }
+  }
+};
+export {
+  Query as default
+};