@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

package/bundle/commands/build/stop.js

@@ -0,0 +1,84 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/stop.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Stop = class extends BaseCommand {
+  static args = {};
+  static description = "stop a Raindrop application";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Stop a Raindrop application.
+`
+  ];
+  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 to stop",
+      required: false
+    }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version to start",
+      required: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    })
+  };
+  async run() {
+    const config = await this.loadConfig();
+    if (config.lock) {
+      this.error("Operation not allowed: application is in a locked state");
+    }
+    const { client: catalogService, userId, organizationId: defaultOrganizationId } = await this.catalogService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    let applicationName = this.flags.application;
+    if (!applicationName) {
+      const apps = await this.loadManifest();
+      const app = apps[0];
+      if (!app) {
+        this.error("No application found");
+      }
+      applicationName = valueOf(app.name);
+    }
+    const currentVersionId = this.flags.version ?? config.versionId;
+    if (!currentVersionId) {
+      this.error("Expected a --version flag to be provided when a version is not currently set");
+    }
+    await catalogService.setActive({
+      userId,
+      organizationId,
+      applications: [
+        {
+          applicationName,
+          currentVersionId,
+          isActive: false
+        }
+      ]
+    });
+    console.log(`Set ${applicationName}@${currentVersionId} as stopped.`);
+  }
+};
+export {
+  Stop as default
+};

package/bundle/commands/build/tools/check.js

@@ -0,0 +1,32 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/build/tools/check.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Check = class extends BaseCommand {
+  static args = {};
+  static description = "validate a LiquidMetal.AI raindrop.manifest";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static 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"
+    })
+  };
+  async run() {
+    await this.loadManifest();
+  }
+};
+export {
+  Check as default
+};

package/bundle/commands/build/tools/fmt.js

@@ -0,0 +1,49 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  Parser,
+  Tokenizer,
+  __toESM,
+  fmt,
+  init_cjs_shims,
+  require_lib
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/build/tools/fmt.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var Fmt = class extends BaseCommand {
+  static args = {};
+  static description = "format a LiquidMetal.AI raindrop.manifest";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static 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"
+    })
+  };
+  async run() {
+    let manifestPath = this.flags.manifest;
+    if (this.flags.root) {
+      manifestPath = path.isAbsolute(this.flags.manifest) ? this.flags.manifest : path.join(this.flags.root, this.flags.manifest);
+    }
+    const contents = await fs.readFile(manifestPath, "utf-8");
+    const tokenizer = new Tokenizer(contents);
+    const parser = new Parser(tokenizer);
+    const ast = parser.parse();
+    if (parser.errors.length > 0) {
+      this.error("errors parsing manifest", { exit: 1 });
+    }
+    const formatted = fmt(ast);
+    await fs.writeFile(manifestPath, formatted);
+  }
+};
+export {
+  Fmt as default
+};

package/bundle/commands/build/unsandbox.js

@@ -0,0 +1,65 @@
+import {
+  sandbox
+} from "../../chunk-XYJACVNA.js";
+import "../../chunk-MGM2L2T3.js";
+import "../../chunk-VXAZKB3J.js";
+import "../../chunk-W2L3MYN6.js";
+import "../../chunk-PU4RCSXF.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/unsandbox.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Unsandbox = class extends BaseCommand {
+  static args = {};
+  static description = "mark a version as unsandboxed in the Raindrop catalog";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({ default: "raindrop.manifest", description: "project manifest" }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version to unsandbox",
+      required: false
+    })
+  };
+  async run() {
+    let applications;
+    try {
+      applications = await sandbox({
+        command: this,
+        isSandboxed: false,
+        impersonate: this.flags.impersonate,
+        versionId: this.flags.version
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        this.error(error.message);
+      }
+      throw error;
+    }
+    for (const app of applications) {
+      const { applicationName, currentVersionId } = app;
+      this.log(`Set ${applicationName}@${currentVersionId} as unsandboxed.`);
+    }
+  }
+};
+export {
+  Unsandbox as default
+};

package/bundle/commands/build/upload.js

@@ -0,0 +1,83 @@
+import {
+  FileSystemBundle,
+  archive
+} from "../../chunk-MGM2L2T3.js";
+import {
+  buildHandlers
+} from "../../chunk-VXAZKB3J.js";
+import "../../chunk-W2L3MYN6.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  BundleArchiveType,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/upload.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import path from "node:path";
+var Upload = class extends BaseCommand {
+  static args = {};
+  static description = "build and validate a LiquidMetal.AI project";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  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"
+    }),
+    output: import_core.Flags.string({ char: "o", description: "output directory", required: false, default: "dist" }),
+    versionId: import_core.Flags.string({ char: "v", description: "version ID", required: true }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const buildDir = path.isAbsolute(this.flags.output) ? this.flags.output : path.join(this.flags.root, this.flags.output);
+    await buildHandlers(this, apps, buildDir, this.flags.root);
+    const { client: catalogService, organizationId: defaultOrganizationId, userId } = await this.catalogService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    const config = await this.loadConfig();
+    const app = apps[0];
+    if (!app) {
+      this.error("No application found in manifest", { exit: 1 });
+    }
+    for (const handler of app.handlers()) {
+      const bundle = new FileSystemBundle(path.join(buildDir, valueOf(handler.name)));
+      await catalogService.uploadBundle({
+        userId,
+        organizationId,
+        applicationName: valueOf(app.name),
+        applicationVersionId: this.flags.versionId || config.versionId || "",
+        archiveType: BundleArchiveType.ZIP,
+        bundleName: valueOf(handler.name),
+        archive: Buffer.from(await archive(bundle))
+      });
+    }
+    const dbBundle = new FileSystemBundle(path.join(this.flags.root, "db"));
+    await catalogService.uploadBundle({
+      userId,
+      organizationId,
+      applicationName: valueOf(app.name),
+      applicationVersionId: this.flags.versionId || config.versionId || "",
+      archiveType: BundleArchiveType.ZIP,
+      bundleName: "db",
+      archive: Buffer.from(await archive(dbBundle))
+    });
+  }
+};
+export {
+  Upload as default
+};

package/bundle/commands/build/validate.js

@@ -0,0 +1,71 @@
+import {
+  buildHandlers
+} from "../../chunk-VXAZKB3J.js";
+import "../../chunk-W2L3MYN6.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/validate.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import { spawn } from "node:child_process";
+import path from "node:path";
+async function runTypeCheck(root) {
+  return new Promise((resolve) => {
+    const tsc = spawn("npx", ["tsc", "--noEmit"], {
+      cwd: root,
+      stdio: "inherit"
+      // Inherit stdio to show compiler output in real-time
+    });
+    tsc.on("exit", (code) => {
+      resolve(code === 0);
+    });
+  });
+}
+var Build = class extends BaseCommand {
+  static args = {};
+  static description = "build and validate a LiquidMetal.AI project";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static 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"
+    }),
+    config: import_core.Flags.string({
+      char: "c",
+      description: "config file",
+      required: false,
+      hidden: true,
+      default: ".raindrop/config.json"
+    }),
+    output: import_core.Flags.string({ char: "o", description: "output directory", required: false, default: "dist" })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const version = await this.raindropFrameworkVersion();
+    if (version === null) {
+      this.error("Failed to determine @liquidmetal-ai/raindrop-framework version; is it installed?", { exit: 1 });
+    }
+    console.log(`Using @liquidmetal-ai/raindrop-framework version ${version}`);
+    console.log("Running type check...");
+    const typeCheckPassed = await runTypeCheck(this.flags.root);
+    if (!typeCheckPassed) {
+      this.error("Type check failed. Please fix the TypeScript errors before building.");
+    }
+    console.log("Type check passed");
+    const buildDir = path.isAbsolute(this.flags.output) ? this.flags.output : path.join(this.flags.root, this.flags.output);
+    await buildHandlers(this, apps, buildDir, this.flags.root);
+  }
+};
+export {
+  Build as default
+};

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

@@ -0,0 +1,86 @@
+import {
+  source_default
+} from "../../../chunk-MVQYQJHI.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/build/workos/delete.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Delete = class extends BaseCommand {
+  static args = {};
+  static description = "Delete all WorkOS integration state from the organization";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Delete all WorkOS state with confirmation prompt
+
+<%= config.bin %> <%= command.id %> --force
+Delete all WorkOS state 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: workosService, userId, organizationId } = await this.workosIntegrationService();
+    this.log("");
+    this.log(source_default.red.bold("\u26A0\uFE0F  WARNING: DESTRUCTIVE OPERATION"));
+    this.log(source_default.red("\u2501".repeat(50)));
+    this.log("");
+    this.log("This command will permanently delete ALL WorkOS integration state:");
+    this.log("");
+    this.log(source_default.yellow("  \u2022 WorkOS team information"));
+    this.log(source_default.yellow("  \u2022 All environment configurations"));
+    this.log(source_default.yellow("  \u2022 All API keys stored in state"));
+    this.log(source_default.yellow("  \u2022 Primary organization name"));
+    this.log("");
+    this.log(source_default.dim("Note: This only affects local state. Nothing will be deleted from"));
+    this.log(source_default.dim("WorkOS itself. You must manage WorkOS resources separately."));
+    this.log("");
+    this.log(source_default.red("This action CANNOT be undone!"));
+    this.log(source_default.red("\u2501".repeat(50)));
+    this.log("");
+    if (!this.flags.force) {
+      const shouldDelete = await esm_default({
+        message: "Are you absolutely sure you want to delete all WorkOS state?",
+        default: false
+      });
+      if (!shouldDelete) {
+        this.log(source_default.dim("Deletion cancelled"));
+        return;
+      }
+    }
+    try {
+      this.log("Deleting all WorkOS state...");
+      await workosService.deleteAllWorkOSState({
+        userId,
+        organizationId
+      });
+      this.log("");
+      this.log(source_default.green("\u2713 All WorkOS state has been deleted successfully"));
+      this.log("");
+      this.log(source_default.dim("To re-activate WorkOS integration, run:"));
+      this.log(source_default.dim("  raindrop build workos setup --admin-email <email>"));
+    } catch (error) {
+      const err = error;
+      this.error(`Failed to delete WorkOS state: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Delete as default
+};

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

@@ -0,0 +1,134 @@
+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/attach.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Attach = class extends BaseCommand {
+  static args = {
+    envName: import_core.Args.string({
+      description: "WorkOS environment name (defaults to application name)",
+      required: false
+    })
+  };
+  static description = "Attach a WorkOS environment to an application version";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Attach environment with same name as application
+
+<%= config.bin %> <%= command.id %> my-env
+Attach specific environment
+
+<%= config.bin %> <%= command.id %> my-env --application my-app --versionId abc123
+Attach to 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 environmentName = this.args.envName || applicationName;
+    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.attachEnvironmentToVersion({
+        userId,
+        organizationId,
+        applicationName,
+        versionId,
+        environmentName
+      });
+      switch (this.flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                applicationName,
+                versionId,
+                environmentName
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+        default:
+          this.log(source_default.green("\u2713") + ` WorkOS environment attached`);
+          this.log("");
+          this.log(`  ${source_default.cyan("Application:")}   ${applicationName}`);
+          this.log(`  ${source_default.cyan("Version ID:")}    ${versionId}`);
+          this.log(`  ${source_default.cyan("Environment:")}   ${environmentName}`);
+          this.log("");
+          this.log(source_default.dim("The WORKOS_ENVIRONMENT variable has been set for this version."));
+          this.log(source_default.dim("Changes will take effect after convergence completes."));
+          break;
+      }
+    } catch (error) {
+      const err = error;
+      if (err.message.includes("not found")) {
+        this.error(
+          `WorkOS environment '${environmentName}' not found. Create it first with: raindrop build workos env create ${environmentName}`,
+          { exit: 1 }
+        );
+      }
+      this.error(`Failed to attach WorkOS environment: ${err.message}`, { exit: 1 });
+    }
+  }
+};
+export {
+  Attach as default
+};