@liquidmetal-ai/raindrop 0.7.0 → 0.8.1

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

@@ -0,0 +1,176 @@
+import {
+  source_default
+} from "../../../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../../../chunk-MCRKUPJY.js";
+import {
+  EnvironmentType,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../../../chunk-G6NE675D.js";
+
+// src/commands/build/workos/env/create.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Create = class extends BaseCommand {
+  static args = {
+    envName: import_core.Args.string({
+      description: "environment name (defaults to application name)",
+      required: false
+    })
+  };
+  static description = "Create a WorkOS environment for a Raindrop app";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Create WorkOS environment with application name and auto-attach
+
+<%= config.bin %> <%= command.id %> my-env
+Create environment with specific name and auto-attach
+
+<%= config.bin %> <%= command.id %> my-env --noattach
+Create environment without attaching to current version
+
+<%= config.bin %> <%= command.id %> my-env --name "Acme Inc"
+Create with explicit organization name
+
+<%= config.bin %> <%= command.id %> my-env --output json
+Get JSON output
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    root: import_core.Flags.string({
+      char: "r",
+      description: "root directory",
+      required: false,
+      default: process.cwd()
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest"
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application name",
+      required: false
+    }),
+    versionId: import_core.Flags.string({
+      char: "v",
+      aliases: ["version"],
+      description: "version ID",
+      required: false
+    }),
+    name: import_core.Flags.string({
+      description: "primary organization name (optional if cached)",
+      required: false
+    }),
+    noattach: import_core.Flags.boolean({
+      description: "do not attach environment to current version after creation",
+      default: false
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const app = apps.find((app2) => valueOf(app2.name) === this.flags.application) || apps[0];
+    if (app === void 0) {
+      this.error(`application ${this.flags.application} not found in manifest`, { exit: 1 });
+    }
+    const applicationName = valueOf(app.name);
+    const environmentName = this.args.envName || applicationName;
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      await workosService.createEnvironment({
+        userId,
+        organizationId,
+        environmentName,
+        environmentType: EnvironmentType.STAGING,
+        primaryOrganizationName: this.flags.name
+      });
+      let attached = false;
+      if (!this.flags.noattach) {
+        try {
+          const config = await this.loadConfig();
+          const versionId = this.flags.versionId || config.versionId;
+          if (versionId) {
+            await workosService.attachEnvironmentToVersion({
+              userId,
+              organizationId,
+              applicationName,
+              versionId,
+              environmentName
+            });
+            attached = true;
+          }
+        } catch (attachError) {
+          const err = attachError;
+          if (this.flags.output === "text") {
+            this.log(source_default.yellow("Warning: ") + `Failed to auto-attach environment: ${err.message}`);
+            this.log(source_default.dim("You can manually attach with: raindrop build workos env attach " + environmentName));
+          }
+        }
+      }
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                environmentName,
+                environmentType: "staging",
+                attached,
+                applicationName
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + ` WorkOS environment created for ${source_default.bold(environmentName)}`);
+          this.log("");
+          this.log(`  ${source_default.cyan("Environment:")}   ${environmentName}`);
+          this.log(`  ${source_default.cyan("Type:")}          staging`);
+          if (attached) {
+            this.log(`  ${source_default.cyan("Attached to:")}   ${applicationName} (current version)`);
+          }
+          this.log("");
+          this.log(source_default.dim("The environment, organization, and API key have been automatically configured."));
+          if (attached) {
+            this.log(source_default.dim("Environment has been attached to the current version."));
+          }
+          this.log(source_default.dim("View details with: raindrop build workos env get " + environmentName));
+          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 }
+        );
+      }
+      if (err.message.includes("already exists")) {
+        this.error(
+          `WorkOS environment already exists for ${environmentName}. Use 'raindrop build workos env get ${environmentName}' to view it.`,
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to create WorkOS environment: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Create as default
+};

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

@@ -0,0 +1,84 @@
+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/env/delete.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Delete = class extends BaseCommand {
+  static args = {
+    appName: import_core.Args.string({
+      description: "raindrop app name",
+      required: true
+    })
+  };
+  static description = "Remove WorkOS environment configuration (does NOT delete from WorkOS)";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> my-app
+Remove WorkOS environment configuration for app
+
+<%= config.bin %> <%= command.id %> my-app --output json
+Get JSON output
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    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.deleteEnvironment({
+        userId,
+        organizationId,
+        environmentName: this.args.appName
+      });
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                appName: this.args.appName
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + ` WorkOS environment configuration removed for ${source_default.bold(this.args.appName)}`);
+          this.log("");
+          this.log(source_default.yellow("\u26A0") + "  " + source_default.dim("Note: This only removes the configuration from Raindrop."));
+          this.log(source_default.dim("   To delete the environment from WorkOS, manage it in the WorkOS dashboard."));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      if (err.message.includes("not found")) {
+        this.error(
+          `WorkOS environment not found for ${this.args.appName}`,
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to delete WorkOS environment: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Delete as default
+};

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

@@ -0,0 +1,115 @@
+import {
+  source_default
+} from "../../../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../../../chunk-G6NE675D.js";
+
+// src/commands/build/workos/env/detach.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Detach = class extends BaseCommand {
+  static description = "Detach WorkOS environment from an application version";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Detach WorkOS environment from current version
+
+<%= config.bin %> <%= command.id %> --application my-app --versionId abc123
+Detach from specific application and version
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    root: import_core.Flags.string({
+      char: "r",
+      description: "root directory",
+      required: false,
+      default: process.cwd()
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest"
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application name",
+      required: false
+    }),
+    versionId: import_core.Flags.string({
+      char: "v",
+      aliases: ["version"],
+      description: "version ID",
+      required: false
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const app = apps.find((app2) => valueOf(app2.name) === this.flags.application) || apps[0];
+    if (app === void 0) {
+      this.error(`application ${this.flags.application} not found in manifest`, { exit: 1 });
+    }
+    const applicationName = valueOf(app.name);
+    const config = await this.loadConfig();
+    const versionId = this.flags.versionId || config.versionId;
+    if (!versionId) {
+      this.error(
+        "No version ID found. Deploy your application first with: raindrop build deploy",
+        { exit: 1 }
+      );
+    }
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      await workosService.detachEnvironmentFromVersion({
+        userId,
+        organizationId,
+        applicationName,
+        versionId
+      });
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                applicationName,
+                versionId
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + ` WorkOS environment detached`);
+          this.log("");
+          this.log(`  ${source_default.cyan("Application:")}   ${applicationName}`);
+          this.log(`  ${source_default.cyan("Version ID:")}    ${versionId}`);
+          this.log("");
+          this.log(source_default.dim("The WORKOS_ENVIRONMENT variable has been removed from this version."));
+          this.log(source_default.dim("Changes will take effect after convergence completes."));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      this.error(`Failed to detach WorkOS environment: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Detach as default
+};

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

@@ -0,0 +1,117 @@
+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/env/get.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Get = class extends BaseCommand {
+  static args = {
+    appName: import_core.Args.string({
+      description: "raindrop app name",
+      required: true
+    })
+  };
+  static description = "Get WorkOS environment details for a Raindrop app";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> my-app
+View WorkOS environment details
+
+<%= config.bin %> <%= command.id %> my-app --output json
+Get JSON output
+`
+  ];
+  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.getEnvironment({
+        userId,
+        organizationId,
+        environmentName: this.args.appName
+      });
+      if (!response.environment) {
+        this.error(`WorkOS environment not found for ${this.args.appName}`, { exit: 1 });
+      }
+      const env = response.environment;
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                name: env.name,
+                environmentId: env.environmentId,
+                clientId: env.clientId,
+                environmentType: env.environmentType,
+                connect: env.workosConnectHostname,
+                apiHostname: env.workosApiHostname,
+                organizationId: env.workosOrganizationId
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "table":
+          console.table({
+            "App Name": env.name,
+            "Environment ID": env.environmentId,
+            "Client ID": env.clientId,
+            "Type": env.environmentType || "staging",
+            "Connect": env.workosConnectHostname || "",
+            "API": env.workosApiHostname || "",
+            "Org ID": env.workosOrganizationId || ""
+          });
+          break;
+        case "text":
+        default:
+          this.log(source_default.bold(`WorkOS Environment: ${env.name}`));
+          this.log("");
+          this.log(`  ${source_default.cyan("App Name:")}        ${env.name}`);
+          this.log(`  ${source_default.cyan("Environment ID:")}  ${env.environmentId}`);
+          this.log(`  ${source_default.cyan("Client ID:")}       ${env.clientId}`);
+          this.log(`  ${source_default.cyan("Type:")}            ${env.environmentType || "staging"}`);
+          if (env.workosConnectHostname) {
+            this.log(`  ${source_default.cyan("Connect:")}         ${env.workosConnectHostname}`);
+          }
+          if (env.workosApiHostname) {
+            this.log(`  ${source_default.cyan("API:")}             ${env.workosApiHostname}`);
+          }
+          if (env.workosOrganizationId) {
+            this.log(`  ${source_default.cyan("Org ID:")}          ${env.workosOrganizationId}`);
+          }
+          this.log("");
+          this.log(source_default.dim("Note: API key value is stored securely and not displayed."));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      if (err.message.includes("not found")) {
+        this.error(
+          `WorkOS environment not found for ${this.args.appName}. Create one with: raindrop build workos env create ${this.args.appName}`,
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to get WorkOS environment: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Get as default
+};

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

@@ -0,0 +1,139 @@
+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/list.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var List = class extends BaseCommand {
+  static args = {};
+  static description = "List all WorkOS environments for the organization";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+List all WorkOS environments in compact format (default)
+
+<%= config.bin %> <%= command.id %> --output table
+List all environments in table format
+
+<%= config.bin %> <%= command.id %> --output json
+List all environments in JSON format
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "compact",
+      options: ["text", "table", "json", "compact"]
+    })
+  };
+  async run() {
+    const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+    try {
+      const response = await workosService.listEnvironments({
+        userId,
+        organizationId
+      });
+      if (!response.environments || response.environments.length === 0) {
+        this.log(source_default.dim("No WorkOS environments found in this organization"));
+        this.log(source_default.dim("Create a new environment with: raindrop build workos env create <app-name>"));
+        return;
+      }
+      switch (this.flags.output) {
+        case "compact":
+          for (const env of response.environments) {
+            const envTypeStr = env.environmentType === EnvironmentType.STAGING ? "staging" : "production";
+            const typeColor = env.environmentType === EnvironmentType.STAGING ? source_default.yellow : source_default.green;
+            console.log(`
+${source_default.bold(env.name)}`);
+            console.log(`  \u2514\u2500 ${typeColor(envTypeStr)} - ${source_default.dim(env.environmentId)}`);
+            console.log(`     ${source_default.dim(`Client ID: ${env.clientId}`)}`);
+            if (env.workosConnectHostname) {
+              console.log(`     ${source_default.dim(`Connect: ${env.workosConnectHostname}`)}`);
+            }
+            if (env.workosApiHostname) {
+              console.log(`     ${source_default.dim(`API: ${env.workosApiHostname}`)}`);
+            }
+            if (env.workosOrganizationId) {
+              console.log(`     ${source_default.dim(`Org ID: ${env.workosOrganizationId}`)}`);
+            }
+          }
+          console.log("");
+          console.log(source_default.dim("\u2500".repeat(50)));
+          console.log(source_default.dim(`Total: ${response.environments.length} environments`));
+          break;
+        case "text":
+          for (const env of response.environments) {
+            console.log(`App: ${source_default.bold(env.name)}`);
+            console.log(`  Environment ID: ${source_default.dim(env.environmentId)}`);
+            console.log(`  Client ID: ${source_default.dim(env.clientId)}`);
+            console.log(`  Type: ${source_default.cyan(env.environmentType || "staging")}`);
+            if (env.workosConnectHostname) {
+              console.log(`  Connect: ${source_default.dim(env.workosConnectHostname)}`);
+            }
+            if (env.workosApiHostname) {
+              console.log(`  API: ${source_default.dim(env.workosApiHostname)}`);
+            }
+            if (env.workosOrganizationId) {
+              console.log(`  Org ID: ${source_default.dim(env.workosOrganizationId)}`);
+            }
+            console.log(source_default.dim("\u2500".repeat(50)));
+          }
+          this.log(source_default.bold(`
+Total environments: ${response.environments.length}`));
+          break;
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                environments: response.environments.map((env) => ({
+                  name: env.name,
+                  environmentId: env.environmentId,
+                  clientId: env.clientId,
+                  environmentType: env.environmentType,
+                  connect: env.workosConnectHostname,
+                  apiHostname: env.workosApiHostname,
+                  organizationId: env.workosOrganizationId
+                })),
+                totalCount: response.environments.length
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "table":
+          console.table(
+            response.environments.map((env) => ({
+              "App Name": env.name,
+              "Environment ID": env.environmentId,
+              "Client ID": env.clientId,
+              "Type": env.environmentType || "staging",
+              "Connect": env.workosConnectHostname || "",
+              "API": env.workosApiHostname || "",
+              "Org ID": env.workosOrganizationId || ""
+            }))
+          );
+          this.log(source_default.bold(`
+Total environments: ${response.environments.length}`));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      this.error(`Failed to list WorkOS environments: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  List as default
+};