@liquidmetal-ai/raindrop 0.6.4 → 0.8.0

package/bundle/commands/build/find.js

@@ -0,0 +1,333 @@
+import {
+  source_default
+} from "../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  EPOCH_TS,
+  QueryModulesResponseSchema,
+  QueryResourcesResponseSchema,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  timestampDate,
+  toJsonString,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/find.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Find = class extends BaseCommand {
+  static args = {};
+  static description = "find resources in Raindrop";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Find all modules with full details (default).
+
+<%= config.bin %> <%= command.id %> -o compact
+Find all modules in compact view.
+
+<%= config.bin %> <%= command.id %> --moduleType service
+Find only service modules with their routes.
+
+<%= config.bin %> <%= command.id %> --moduleType actor
+Find only actor modules with their routes.
+
+<%= config.bin %> <%= command.id %> --moduleType smartbucket
+Find only smartbucket modules.
+
+<%= config.bin %> <%= command.id %> -a myapp -v 1.0.0
+Find modules for a 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",
+      required: false
+    }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version",
+      required: false
+    }),
+    moduleType: import_core.Flags.string({
+      description: "filter by module type (e.g. smartbucket)",
+      required: false
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "full",
+      options: ["text", "full", "json", "compact"]
+    }),
+    sudo: import_core.Flags.boolean({
+      char: "s",
+      default: false,
+      description: "superuser mode",
+      required: false,
+      hidden: true
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    all: import_core.Flags.boolean({
+      description: "query modules for all applications"
+    })
+  };
+  // Helper method to fetch WorkOS environment name for an application version
+  async getWorkOSEnvironment(catalogService, userId, organizationId, applicationName, versionId) {
+    try {
+      const envResp = await catalogService.getEnvs({
+        userId,
+        organizationId,
+        envs: [
+          {
+            applicationName,
+            currentVersionId: versionId,
+            key: "env:WORKOS_ENVIRONMENT"
+          }
+        ]
+      });
+      const workosEnv = envResp.envs.find((e) => e.key === "env:WORKOS_ENVIRONMENT");
+      return workosEnv?.value;
+    } catch {
+      return void 0;
+    }
+  }
+  async queryModules(flags) {
+    let applicationName;
+    let applicationVersionId;
+    if (!flags.all) {
+      if (!flags.version) {
+        const config = await this.loadConfig();
+        applicationVersionId = config.versionId;
+      }
+      if (!flags.application) {
+        const apps = await this.loadManifest();
+        const app = apps[0];
+        if (app === void 0) {
+          this.error("No application provided or found in manifest", { exit: 1 });
+        }
+        applicationName = valueOf(app.name);
+      }
+    }
+    const { client: catalogService, userId, organizationId: defaultOrganizationId } = await this.catalogService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    const resp = await catalogService.queryModules({
+      userId,
+      applicationName: applicationName || "",
+      applicationVersionId: applicationVersionId || "",
+      organizationId,
+      moduleType: flags.moduleType || ""
+    });
+    if (flags.output === "compact") {
+      const modulesByApp = resp.modules.reduce((acc, module) => {
+        const appKey = `${module.applicationName}@${module.applicationVersionId}`;
+        if (!acc[appKey]) {
+          acc[appKey] = [];
+        }
+        acc[appKey].push(module);
+        return acc;
+      }, {});
+      for (const [appKey, modules] of Object.entries(modulesByApp)) {
+        const firstModule = modules[0];
+        const workosEnv = firstModule ? await this.getWorkOSEnvironment(
+          catalogService,
+          userId,
+          organizationId,
+          firstModule.applicationName,
+          firstModule.applicationVersionId
+        ) : void 0;
+        const workosInfo = workosEnv ? ` ${source_default.magenta(`[WorkOS: ${workosEnv}]`)}` : "";
+        console.log(`
+${source_default.bold(appKey)}${workosInfo} ${source_default.dim(`(${modules.length} module${modules.length !== 1 ? "s" : ""})`)}`);
+        for (const module of modules) {
+          const convergedStatus = module.convergedAt ? source_default.green("converged") : source_default.yellow("pending");
+          const date = module.convergedAt ? timestampDate(module.convergedAt).toLocaleDateString() : "N/A";
+          const routeCount = module.service?.routes?.length || module.actor?.routes?.length || 0;
+          const routeInfo = routeCount > 0 ? ` - ${source_default.green(`${routeCount} route${routeCount !== 1 ? "s" : ""}`)}` : "";
+          console.log(`  \u2514\u2500 ${source_default.cyan(module.name)} ${source_default.dim(`(${module.moduleId.substring(0, 8)}...)`)} ${source_default.yellow(module.type)}${routeInfo} - ${convergedStatus} - ${source_default.dim(date)}`);
+        }
+      }
+      const totalApps = Object.keys(modulesByApp).length;
+      const totalModules = resp.modules.length;
+      const convergedModules = resp.modules.filter((m) => m.convergedAt).length;
+      console.log("");
+      console.log(source_default.dim("\u2500".repeat(50)));
+      console.log(source_default.dim(`Total: ${totalApps} application${totalApps !== 1 ? "s" : ""}, ${totalModules} modules (${convergedModules} converged)`));
+    } else if (flags.output === "full") {
+      const modulesByApp = resp.modules.reduce((acc, module) => {
+        const appKey = `${module.applicationName}@${module.applicationVersionId}`;
+        if (!acc[appKey]) {
+          acc[appKey] = [];
+        }
+        acc[appKey].push(module);
+        return acc;
+      }, {});
+      for (const [appKey, modules] of Object.entries(modulesByApp)) {
+        const firstModule = modules[0];
+        const workosEnv = firstModule ? await this.getWorkOSEnvironment(
+          catalogService,
+          userId,
+          organizationId,
+          firstModule.applicationName,
+          firstModule.applicationVersionId
+        ) : void 0;
+        const workosInfo = workosEnv ? ` ${source_default.magenta(`[WorkOS: ${workosEnv}]`)}` : "";
+        console.log(`
+${source_default.bold(appKey)}${workosInfo} ${source_default.dim(`(${modules.length} module${modules.length !== 1 ? "s" : ""})`)}`);
+        for (const module of modules) {
+          const convergedStatus = module.convergedAt ? source_default.green("converged") : source_default.yellow("pending");
+          const date = module.convergedAt ? timestampDate(module.convergedAt).toISOString() : "N/A";
+          console.log(`  \u2514\u2500 ${source_default.cyan(module.name)} ${source_default.dim(`(${module.moduleId})`)} ${source_default.yellow(module.type)}`);
+          console.log(`     Status: ${convergedStatus} at ${source_default.dim(date)}`);
+          if (module.service || module.actor || module.mcpService) {
+            const moduleData = module.service || module.actor || module.mcpService;
+            if (moduleData?.routes && moduleData.routes.length > 0) {
+              console.log(`     ${source_default.bold("Routes:")}`);
+              for (const route of moduleData.routes) {
+                const routeInfo = route.id ? `${source_default.green(route.domain)} ${source_default.cyan(`[${route.id}]`)}` : source_default.green(route.domain);
+                console.log(`       \u2192 ${routeInfo}`);
+              }
+            }
+          }
+          const attrs = this.extractModuleAttributes(module);
+          const filteredAttrs = Object.entries(attrs).filter(([key]) => !key.startsWith("routes"));
+          if (filteredAttrs.length > 0) {
+            console.log(`     ${source_default.bold("Attributes:")}`);
+            for (const [key, value] of filteredAttrs) {
+              console.log(`       ${key}: ${source_default.yellow(String(value))}`);
+            }
+          }
+        }
+      }
+      const totalApps = Object.keys(modulesByApp).length;
+      const totalModules = resp.modules.length;
+      const convergedModules = resp.modules.filter((m) => m.convergedAt).length;
+      console.log("");
+      console.log(source_default.dim("\u2500".repeat(50)));
+      console.log(source_default.dim(`Total: ${totalApps} application${totalApps !== 1 ? "s" : ""}, ${totalModules} modules (${convergedModules} converged)`));
+    } else if (flags.output === "json") {
+      console.log(toJsonString(QueryModulesResponseSchema, resp, { prettySpaces: 2 }));
+    } else {
+      for (const m of resp.modules) {
+        let details = `${m.name} ${m.moduleId} ${m.type}`;
+        const attrs = this.extractModuleAttributes(m);
+        const attrString = Object.entries(attrs).map(([k, v]) => `${k}=${v}`).join(" ");
+        if (attrString) {
+          details += ` ${attrString}`;
+        }
+        if (m.convergedAt) {
+          details += ` converged=${timestampDate(m.convergedAt).toISOString()}`;
+        }
+        console.log(details);
+      }
+    }
+  }
+  extractModuleAttributes(module) {
+    if (module.smartBucket) return this.flattenObject(module.smartBucket);
+    if (module.bucket) return this.flattenObject(module.bucket);
+    if (module.service) return this.flattenObject(module.service);
+    if (module.observer) return this.flattenObject(module.observer);
+    if (module.task) return this.flattenObject(module.task);
+    if (module.sqlDatabase) return this.flattenObject(module.sqlDatabase);
+    if (module.vectorIndex) return this.flattenObject(module.vectorIndex);
+    if (module.queue) return this.flattenObject(module.queue);
+    if (module.kvCache) return this.flattenObject(module.kvCache);
+    if (module.smartMemory) return this.flattenObject(module.smartMemory);
+    if (module.actor) return this.flattenObject(module.actor);
+    return {};
+  }
+  flattenObject(obj, parentKey = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === null || value === void 0) continue;
+      if (key === "$typeName" || key === "$unknown") continue;
+      const newKey = parentKey ? `${parentKey}.${key}` : key;
+      if (Array.isArray(value)) {
+        if (value.length > 0 && typeof value[0] === "object") {
+          value.forEach((item, index) => {
+            const itemKey = `${newKey}[${index}]`;
+            Object.assign(result, this.flattenObject(item, itemKey));
+          });
+        } else {
+          result[newKey] = value.join(", ");
+        }
+      } else if (typeof value === "object") {
+        Object.assign(result, this.flattenObject(value, newKey));
+      } else {
+        result[newKey] = value;
+      }
+    }
+    return result;
+  }
+  async queryResources(flags) {
+    if (!flags.version) {
+      const config = await this.loadConfig();
+      flags.version = config.versionId;
+    }
+    if (!flags.application) {
+      const apps = await this.loadManifest();
+      const app = apps[0];
+      if (app === void 0) {
+        this.error("No application provided or found in manifest", { exit: 1 });
+      }
+      flags.application = valueOf(app.name);
+    }
+    const { client: catalogService, userId, organizationId: defaultOrganizationId } = await this.catalogService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    const resp = await catalogService.queryResources({
+      userId,
+      applicationName: flags.application,
+      applicationVersionId: flags.version || "",
+      organizationId
+    });
+    if (flags.output === "table") {
+      console.table(
+        resp.resources.reduce(
+          (acc, v) => {
+            acc[v.name] = {
+              ...v
+            };
+            return acc;
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          {}
+        ),
+        ["name", "resourceId", "applicationName", "applicationVersionId", "type"]
+      );
+    } else if (flags.output === "json") {
+      console.log(toJsonString(QueryResourcesResponseSchema, resp, { prettySpaces: 2 }));
+    } else {
+      for (const r of resp.resources) {
+        console.log(
+          `${r.name} ${r.resourceId} ${r.applicationName} ${r.applicationVersionId} ${r.type} ${timestampDate(r.createdAt || EPOCH_TS).toISOString()} ${timestampDate(r.updatedAt || EPOCH_TS).toISOString()} ${JSON.stringify(r.attributes)}`
+        );
+      }
+    }
+  }
+  async run() {
+    if (this.flags.sudo) {
+      await this.queryResources(this.flags);
+    } else {
+      await this.queryModules(this.flags);
+    }
+  }
+};
+export {
+  Find as default
+};

package/bundle/commands/build/generate.js

@@ -0,0 +1,75 @@
+import {
+  HANDLERS_DIR,
+  RAINDROP_TYPES_FILENAME,
+  codegenPlan,
+  gatherEnvForHandler,
+  renderCodegenPlan
+} from "../../chunk-W2L3MYN6.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  getCurrentVersion,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/generate.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 Generate = class extends BaseCommand {
+  static args = {};
+  static description = "(re)generate all code for 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", default: "dist" })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const plan = codegenPlan(apps);
+    const app = apps[0];
+    const templateContext = {
+      applicationName: valueOf(app.name),
+      raindropFrameworkVersion: await getCurrentVersion()
+    };
+    await renderCodegenPlan(
+      plan,
+      this.flags.root,
+      {
+        renderScaffoldingCode: false,
+        renderUserModifiableCode: true,
+        renderNonUserModifiableCode: true,
+        overwrite: false,
+        mergePackageJson: true
+      },
+      templateContext
+    );
+    const handlers = app.handlers();
+    for (const handler of handlers) {
+      const dest = path.join(this.flags.root, HANDLERS_DIR, valueOf(handler.name), RAINDROP_TYPES_FILENAME);
+      await fs.mkdir(path.dirname(dest), { recursive: true });
+      await fs.writeFile(dest, gatherEnvForHandler(handler, app));
+    }
+  }
+};
+export {
+  Generate as default
+};

package/bundle/commands/build/init.js

@@ -0,0 +1,76 @@
+import {
+  codegenPlan,
+  fileExists,
+  renderCodegenPlan
+} from "../../chunk-W2L3MYN6.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  getCurrentVersion,
+  init_cjs_shims,
+  mustManifestFromString,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/init.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import fs from "node:fs/promises";
+import * as path from "node:path";
+var Init = class extends BaseCommand {
+  static args = {
+    path: import_core.Args.directory({ default: ".", description: "Path to initialize the project in", required: false })
+  };
+  static description = "start a new LiquidMetal.AI project";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Initialize a project in the current directory.
+`
+  ];
+  static flags = {
+    overwrite: import_core.Flags.boolean({ description: "Overwrite existing files", default: false })
+  };
+  async run() {
+    this.log(`path: ${this.args.path}`);
+    if (!await fileExists(this.args.path)) {
+      try {
+        await fs.mkdir(this.args.path, { recursive: true });
+      } catch {
+        this.error(`Could not create directory ${this.args.path}`, { exit: 1 });
+      }
+    }
+    const pathStat = await fs.lstat(this.args.path);
+    if (!pathStat.isDirectory()) {
+      this.error(`${this.args.path} is not a directory.`, { exit: 1 });
+    }
+    if (!this.flags.overwrite && await fileExists(path.join(this.args.path, "package.json"))) {
+      this.error(`A project ${this.args.path} has already been initialized.`, { exit: 1 });
+    }
+    const apps = await mustManifestFromString('application "hello-world" {}');
+    const plan = codegenPlan(apps);
+    try {
+      await renderCodegenPlan(
+        plan,
+        this.args.path,
+        {
+          renderScaffoldingCode: false,
+          renderUserModifiableCode: true,
+          renderNonUserModifiableCode: true,
+          overwrite: false
+        },
+        {
+          applicationName: path.basename(this.args.path),
+          raindropFrameworkVersion: await getCurrentVersion()
+        }
+      );
+    } catch (error) {
+      this.error(`Could not initialize project at ${this.args.path}: ${error}`, { exit: 1 });
+    }
+    console.log(`Initialized LiquidMetal.AI in ${this.args.path}`);
+  }
+};
+export {
+  Init as default
+};

package/bundle/commands/build/list.js

@@ -0,0 +1,11 @@
+import {
+  List,
+  statusString
+} from "../../chunk-CMCEP64V.js";
+import "../../chunk-MVQYQJHI.js";
+import "../../chunk-MCRKUPJY.js";
+import "../../chunk-G6NE675D.js";
+export {
+  List as default,
+  statusString
+};

package/bundle/commands/build/sandbox.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/sandbox.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Sandbox = class extends BaseCommand {
+  static args = {};
+  static description = "mark a version as sandboxed 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 sandbox",
+      required: false
+    })
+  };
+  async run() {
+    let applications;
+    try {
+      applications = await sandbox({
+        command: this,
+        isSandboxed: true,
+        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 sandboxed.`);
+    }
+  }
+};
+export {
+  Sandbox as default
+};

package/bundle/commands/build/start.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/start.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Start = class extends BaseCommand {
+  static args = {};
+  static description = "start a Raindrop application";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Start 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 start",
+      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: true
+        }
+      ]
+    });
+    console.log(`Set ${applicationName}@${currentVersionId} as active.`);
+  }
+};
+export {
+  Start as default
+};