@liquidmetal-ai/raindrop 0.7.0 → 0.8.1

package/bundle/commands/build/workos/env/set.js

@@ -0,0 +1,138 @@
+import {
+  source_default
+} from "../../../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../../../chunk-MCRKUPJY.js";
+import {
+  EnvironmentType,
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../../chunk-G6NE675D.js";
+
+// src/commands/build/workos/env/set.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Set = class extends BaseCommand {
+  static args = {
+    appName: import_core.Args.string({
+      description: "raindrop app name",
+      required: true
+    })
+  };
+  static description = "Configure complete WorkOS environment for a Raindrop app (including production environments)";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> my-app \\
+  --environment-id env_123 \\
+  --client-id client_123 \\
+  --api-key sk_test_123 \\
+  --workos-organization-id org_456 \\
+  --workos-connect-hostname auth.myapp.com \\
+  --type production
+
+Configure a production WorkOS environment
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    environmentId: import_core.Flags.string({
+      description: "WorkOS environment ID",
+      required: true
+    }),
+    clientId: import_core.Flags.string({
+      description: "WorkOS client ID",
+      required: true
+    }),
+    apiKey: import_core.Flags.string({
+      description: "WorkOS API key value",
+      required: true
+    }),
+    workosOrganizationId: import_core.Flags.string({
+      description: "WorkOS organization ID",
+      required: true
+    }),
+    workosConnectHostname: import_core.Flags.string({
+      description: "WorkOS Connect hostname (e.g., auth.myapp.com)",
+      required: true
+    }),
+    workosApiHostname: import_core.Flags.string({
+      description: "WorkOS API hostname",
+      default: "api.workos.com"
+    }),
+    type: import_core.Flags.string({
+      description: "environment type",
+      default: "staging",
+      options: ["staging", "production"]
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      await workosService.setEnvironment({
+        userId,
+        organizationId,
+        environmentName: this.args.appName,
+        environmentId: this.flags.environmentId,
+        clientId: this.flags.clientId,
+        apiKeyValue: this.flags.apiKey,
+        environmentType: this.flags.type === "staging" ? EnvironmentType.STAGING : EnvironmentType.PRODUCTION,
+        workosOrganizationId: this.flags.workosOrganizationId,
+        workosConnectHostname: this.flags.workosConnectHostname,
+        workosApiHostname: this.flags.workosApiHostname
+      });
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                appName: this.args.appName,
+                environmentId: this.flags.environmentId,
+                clientId: this.flags.clientId,
+                environmentType: this.flags.type,
+                workosOrganizationId: this.flags.workosOrganizationId,
+                workosConnectHostname: this.flags.workosConnectHostname,
+                workosApiHostname: this.flags.workosApiHostname
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + ` WorkOS environment configured for ${source_default.bold(this.args.appName)}`);
+          this.log("");
+          this.log(`  ${source_default.cyan("App Name:")}              ${this.args.appName}`);
+          this.log(`  ${source_default.cyan("Environment ID:")}        ${this.flags.environmentId}`);
+          this.log(`  ${source_default.cyan("Client ID:")}             ${this.flags.clientId}`);
+          this.log(`  ${source_default.cyan("Environment:")}           ${this.flags.type}`);
+          this.log(`  ${source_default.cyan("WorkOS Organization:")}   ${this.flags.workosOrganizationId}`);
+          this.log(`  ${source_default.cyan("Connect Hostname:")}      ${this.flags.workosConnectHostname}`);
+          this.log(`  ${source_default.cyan("API Hostname:")}          ${this.flags.workosApiHostname}`);
+          this.log("");
+          this.log(source_default.dim("API key has been stored securely."));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      if (err.message.includes("team not found")) {
+        this.error(
+          "WorkOS integration not activated. Run: raindrop build workos setup --admin-email <email>",
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to configure WorkOS environment: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Set as default
+};

package/bundle/commands/build/workos/invite.js

@@ -0,0 +1,91 @@
+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/build/workos/invite.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Invite = class extends BaseCommand {
+  static args = {
+    email: import_core.Args.string({
+      description: "email address to invite",
+      required: true
+    })
+  };
+  static description = "Invite a user to join the WorkOS team";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> user@example.com --role admin
+Invite a user as admin
+
+<%= config.bin %> <%= command.id %> user@example.com --role member
+Invite a user as member
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    role: import_core.Flags.string({
+      description: "role slug for the invited user (e.g., admin, member)",
+      required: true
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      await workosService.inviteTeamMember({
+        userId,
+        organizationId,
+        email: this.args.email,
+        roleSlug: this.flags.role
+      });
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                email: this.args.email,
+                role: this.flags.role
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + ` Invitation sent to ${source_default.bold(this.args.email)}`);
+          this.log("");
+          this.log(`  ${source_default.cyan("Role:")} ${this.flags.role}`);
+          this.log("");
+          this.log(source_default.dim("The user will receive an email invitation to join the team."));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      if (err.message.includes("not found")) {
+        this.error(
+          "WorkOS integration not activated. Run: raindrop build workos setup --admin-email <email>",
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to invite team member: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Invite as default
+};

package/bundle/commands/build/workos/setup.js

@@ -0,0 +1,124 @@
+import {
+  source_default
+} from "../../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  readState,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/build/workos/setup.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Setup = class extends BaseCommand {
+  static args = {};
+  static description = "Activate WorkOS integration by creating a team";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Activate WorkOS integration using defaults from config
+
+<%= config.bin %> <%= command.id %> --admin-email admin@example.com
+Activate with explicit admin email
+
+<%= config.bin %> <%= command.id %> --admin-email admin@example.com --name "Acme Inc"
+Activate with explicit organization name
+
+<%= config.bin %> <%= command.id %> --output json
+Get JSON output with team details
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    adminEmail: import_core.Flags.string({
+      description: "email address for the team admin (defaults to user email from config)",
+      required: false
+    }),
+    name: import_core.Flags.string({
+      description: "organization name (defaults to organization name from config)",
+      required: false
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json", "table"]
+    })
+  };
+  async run() {
+    const state = await readState(this.config.configDir);
+    let defaultAdminEmail;
+    let defaultOrgName;
+    if (state.currentOrganizationId) {
+      const token = state.organizationIdToBearerToken[state.currentOrganizationId];
+      if (token) {
+        defaultAdminEmail = token.userEmail;
+        defaultOrgName = token.organizationName;
+      }
+    }
+    const adminEmail = this.flags.adminEmail || defaultAdminEmail;
+    const name = this.flags.name || defaultOrgName;
+    if (!adminEmail) {
+      this.error("Admin email is required. Please specify --admin-email or ensure you are logged in.", { exit: 1 });
+    }
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      const response = await workosService.createTeam({
+        userId,
+        organizationId,
+        adminEmail,
+        name
+      });
+      if (!response.team) {
+        this.error("Failed to create WorkOS team: no team returned", { exit: 1 });
+      }
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                id: response.team.id,
+                name: response.team.name,
+                createdAt: response.team.createdAt,
+                updatedAt: response.team.updatedAt
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "table":
+          console.table({
+            "Team ID": response.team.id,
+            "Team Name": response.team.name,
+            "Created": response.team.createdAt ? new Date(Number(response.team.createdAt.seconds) * 1e3).toLocaleString() : "N/A",
+            "Updated": response.team.updatedAt ? new Date(Number(response.team.updatedAt.seconds) * 1e3).toLocaleString() : "N/A"
+          });
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + " WorkOS integration activated successfully!");
+          this.log("");
+          this.log(source_default.bold("Team Details:"));
+          this.log(`  ${source_default.cyan("Team ID:")}   ${response.team.id}`);
+          this.log(`  ${source_default.cyan("Team Name:")} ${response.team.name}`);
+          this.log(`  ${source_default.cyan("Created:")}   ${response.team.createdAt ? new Date(Number(response.team.createdAt.seconds) * 1e3).toLocaleString() : "N/A"}`);
+          this.log("");
+          this.log(source_default.dim("Next steps:"));
+          this.log(source_default.dim("  \u2022 Check your email for the team admin invitation"));
+          this.log(source_default.dim("  \u2022 Create environments for your apps: raindrop build workos env create <app-name>"));
+          this.log(source_default.dim("  \u2022 Invite team members: raindrop build workos invite <email> --role <role>"));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      this.error(`Failed to create WorkOS team: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Setup as default
+};

package/bundle/commands/build/workos/status.js

@@ -0,0 +1,93 @@
+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/build/workos/status.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Status = class extends BaseCommand {
+  static args = {};
+  static description = "View WorkOS team information";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+View WorkOS team status
+
+<%= config.bin %> <%= command.id %> --output json
+Get JSON output with team details
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json", "table"]
+    })
+  };
+  async run() {
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      const response = await workosService.getTeam({
+        userId,
+        organizationId
+      });
+      if (!response.team) {
+        this.error("No WorkOS team found for this organization", { exit: 1 });
+      }
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                id: response.team.id,
+                name: response.team.name,
+                createdAt: response.team.createdAt,
+                updatedAt: response.team.updatedAt
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "table":
+          console.table({
+            "Team ID": response.team.id,
+            "Team Name": response.team.name,
+            "Created": response.team.createdAt ? new Date(Number(response.team.createdAt.seconds) * 1e3).toLocaleString() : "N/A",
+            "Updated": response.team.updatedAt ? new Date(Number(response.team.updatedAt.seconds) * 1e3).toLocaleString() : "N/A"
+          });
+          break;
+        case "text":
+        default:
+          this.log(source_default.bold("WorkOS Team Status"));
+          this.log("");
+          this.log(`  ${source_default.cyan("Team ID:")}   ${response.team.id}`);
+          this.log(`  ${source_default.cyan("Team Name:")} ${response.team.name}`);
+          this.log(`  ${source_default.cyan("Created:")}   ${response.team.createdAt ? new Date(Number(response.team.createdAt.seconds) * 1e3).toLocaleString() : "N/A"}`);
+          this.log(`  ${source_default.cyan("Updated:")}   ${response.team.updatedAt ? new Date(Number(response.team.updatedAt.seconds) * 1e3).toLocaleString() : "N/A"}`);
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      if (err.message.includes("not found")) {
+        this.error(
+          "WorkOS integration not activated. Run: raindrop build workos setup --admin-email <email>",
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to get WorkOS team: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Status as default
+};

package/bundle/commands/dns/create.js

@@ -0,0 +1,128 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/dns/create.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Create = class extends BaseCommand {
+  static args = {
+    domain: import_core.Args.string({
+      description: "Fully qualified domain name (e.g., example.com)",
+      required: true
+    })
+  };
+  static description = "Create a new DNS zone";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> example.com
+Creates a new full DNS zone for example.com
+`,
+    `<%= config.bin %> <%= command.id %> subdomain.example.com --description "My subdomain zone"
+Creates a new DNS zone with a description
+`,
+    `<%= config.bin %> <%= command.id %> example.com --type partial --jump-start
+Creates a partial DNS zone with jump start enabled
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    description: import_core.Flags.string({
+      char: "d",
+      description: "Description for the DNS zone"
+    }),
+    jumpStart: import_core.Flags.boolean({
+      char: "j",
+      description: "Enable CloudFlare jump start (automatically detect and create DNS records)",
+      default: false
+    }),
+    type: import_core.Flags.string({
+      description: "DNS zone type configuration (full or partial)",
+      default: "full",
+      options: ["full", "partial"]
+    }),
+    zoneType: import_core.Flags.string({
+      char: "t",
+      description: "Legacy zone type for internal use",
+      default: "custom",
+      options: ["custom", "tenant"],
+      hidden: true
+    }),
+    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 {
+      this.log(`Creating DNS zone for ${this.args.domain}...`);
+      const typeEnum = this.flags.type === "partial" ? 2 : 1;
+      const response = await dnsService.createDNSZone({
+        organizationId,
+        userId,
+        fullyQualifiedDomainName: this.args.domain,
+        jumpStart: this.flags.jumpStart,
+        type: typeEnum,
+        description: this.flags.description
+      });
+      if (!response.zone) {
+        this.error("Failed to create DNS zone: No zone returned", { 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
+            }
+          }, null, 2));
+          break;
+        case "text":
+        default:
+          this.log("\n\u2705 DNS zone created successfully!\n");
+          this.log(`Domain: ${response.zone.fullyQualifiedDomainName}`);
+          this.log(`Status: ${response.zone.status}`);
+          this.log(`Type: ${response.zone.zoneType}`);
+          if (response.zone.nameServers && response.zone.nameServers.length > 0) {
+            this.log("\nNameservers:");
+            for (const ns of response.zone.nameServers) {
+              this.log(`  - ${ns}`);
+            }
+            this.log("\n\u{1F4DD} Update your domain registrar to use these nameservers.");
+          }
+          if (response.zone.description) {
+            this.log(`
+Description: ${response.zone.description}`);
+          }
+          if (response.zone.tags && response.zone.tags.length > 0) {
+            this.log(`Tags: ${response.zone.tags.join(", ")}`);
+          }
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to create DNS zone: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Create as default
+};

package/bundle/commands/dns/delete.js

@@ -0,0 +1,80 @@
+import {
+  resolveDnsNameToZoneId
+} from "../../chunk-GLIYVKQA.js";
+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/delete.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Delete = class extends BaseCommand {
+  static args = {
+    dnsName: import_core.Args.string({
+      description: "DNS name to delete (e.g., example.com)",
+      required: true
+    })
+  };
+  static description = "Delete a DNS zone";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> example.com
+Deletes the DNS zone for example.com
+`,
+    `<%= config.bin %> <%= command.id %> subdomain.example.com --force
+Deletes the DNS zone 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 {
+      const zoneId = await resolveDnsNameToZoneId(
+        dnsService,
+        organizationId,
+        userId,
+        this.args.dnsName
+      );
+      if (!this.flags.force) {
+        const shouldDelete = await esm_default({
+          message: `Are you sure you want to delete DNS zone for ${this.args.dnsName}? This action cannot be undone.`,
+          default: false
+        });
+        if (!shouldDelete) {
+          this.log("Deletion cancelled");
+          return;
+        }
+      }
+      this.log(`Deleting DNS zone for ${this.args.dnsName}...`);
+      const response = await dnsService.deleteDNSZone({
+        organizationId,
+        userId,
+        zoneId
+      });
+      if (response.success) {
+        this.log(`\u2705 DNS zone for ${this.args.dnsName} deleted successfully`);
+      } else {
+        this.error("Failed to delete DNS zone", { exit: 1 });
+      }
+    } catch (error) {
+      this.error(`Failed to delete DNS zone: ${error}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Delete as default
+};