@liquidmetal-ai/raindrop 0.6.4 → 0.8.0

package/bundle/commands/build/branch.js

@@ -0,0 +1,126 @@
+import {
+  watchStatus
+} from "../../chunk-NG7CZTTE.js";
+import {
+  deploy,
+  sandbox
+} from "../../chunk-XYJACVNA.js";
+import "../../chunk-MGM2L2T3.js";
+import "../../chunk-VXAZKB3J.js";
+import "../../chunk-W2L3MYN6.js";
+import "../../chunk-MVQYQJHI.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/branch.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Branch = class extends BaseCommand {
+  static args = {
+    branch: import_core.Args.string({ description: "branch name", required: true })
+  };
+  static description = "branch a Raindrop application";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Branch 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"
+    }),
+    output: import_core.Flags.string({ char: "o", description: "output directory", required: false, default: "dist" }),
+    versionId: import_core.Flags.string({
+      char: "p",
+      aliases: ["version"],
+      description: "branch from this version",
+      required: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    start: import_core.Flags.boolean({
+      description: "start the application after deploying",
+      default: false,
+      required: false
+    }),
+    "no-watch": import_core.Flags.boolean({
+      description: "skip watching deployment status after branch",
+      required: false,
+      default: false
+    }),
+    show: import_core.Flags.boolean({ description: "show the current branch", required: false })
+  };
+  async run() {
+    const config = await this.loadConfig();
+    if (config.lock) {
+      this.error("Operation not allowed: application is in a locked state");
+    }
+    if (config.sandbox) {
+      this.error("Branching is not allowed in sandbox mode");
+    }
+    if (this.flags.show) {
+      console.log(`Current versionId: ${config.versionId}`);
+      return;
+    }
+    const versionId = this.flags.versionId || config.versionId;
+    await deploy({
+      command: this,
+      root: this.flags.root,
+      manifest: this.flags.manifest,
+      output: this.flags.output,
+      previousVersionId: versionId,
+      branch: this.args.branch,
+      amend: false,
+      start: this.flags.start,
+      impersonate: this.flags.impersonate
+    });
+    const updatedConfig = await this.loadConfig();
+    if (!updatedConfig.versionId) {
+      this.error("VersionId is not set in the config file");
+    }
+    this.log("Branching complete, sandboxing the new branch");
+    try {
+      await sandbox({
+        command: this,
+        isSandboxed: true,
+        impersonate: this.flags.impersonate,
+        versionId
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        this.error(error.message);
+      }
+      throw error;
+    }
+    this.log(`\u{1F514} Branch is in Sandbox mode`);
+    if (!this.flags["no-watch"]) {
+      this.log("\n\u{1F4CA} Watching deployment status...\n");
+      await watchStatus({
+        command: this,
+        root: this.flags.root,
+        manifest: this.flags.manifest,
+        output: "watch",
+        impersonate: this.flags.impersonate
+      });
+    }
+  }
+};
+export {
+  Branch as default
+};

package/bundle/commands/build/checkout.js

@@ -0,0 +1,198 @@
+import {
+  statusString
+} from "../../chunk-CMCEP64V.js";
+import {
+  source_default
+} from "../../chunk-MVQYQJHI.js";
+import {
+  esm_default2 as esm_default
+} from "../../chunk-5GH4FS6C.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  EPOCH_TS,
+  UnitState,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  timestampDate,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/checkout.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Branch = class extends BaseCommand {
+  static args = {
+    version: import_core.Args.string({ description: "version id", required: false })
+  };
+  static description = "switch the current context to a specific version";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Currently on version: 01jac6p20m4gahn1kaa2mhm2js
+
+<%= config.bin %> <%= command.id %> 01jux6z20m4gbhn5kaa4mcm2jr
+Switched to version: 01jux6z20m4gbhn5kaa4mcm2jr
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({ char: "o", description: "output format", required: false, default: "text" }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest"
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    })
+  };
+  // Build a version tree from applications
+  buildVersionTree(applications) {
+    const nodesMap = /* @__PURE__ */ new Map();
+    const rootNodes = [];
+    applications.forEach((app) => {
+      const node = {
+        versionId: app.versionId,
+        previousVersionId: app.previousVersionId || null,
+        application: app,
+        children: [],
+        branch: app.branch
+      };
+      nodesMap.set(app.versionId, node);
+    });
+    for (const node of nodesMap.values()) {
+      if (node.previousVersionId && nodesMap.has(node.previousVersionId)) {
+        nodesMap.get(node.previousVersionId).children.push(node);
+      } else {
+        rootNodes.push(node);
+      }
+    }
+    return { rootNodes, nodesMap };
+  }
+  // Fetch all versions of the application
+  async fetchApplicationVersions(applicationName, userId, organizationId) {
+    const { client: catalogService } = await this.catalogService();
+    const resp = await catalogService.applications({
+      userId,
+      organizationId,
+      showDeleted: true
+    });
+    return resp.applications.filter((app) => app.name === applicationName);
+  }
+  // Prompt user to select a version from the tree
+  async promptVersionSelection(versions) {
+    const { rootNodes } = this.buildVersionTree(versions);
+    const choices = [];
+    const buildChoices = (node, prefix = "", isLast = true) => {
+      const app = node.application;
+      const date = timestampDate(app.createdAt || EPOCH_TS).toLocaleDateString();
+      const branch = app.branch ? source_default.cyan(` (${app.branch})`) : "";
+      let status;
+      if (app.state === UnitState.RUNNING) {
+        status = source_default.green(statusString[app.state]);
+      } else if (app.state === UnitState.DELETING) {
+        status = source_default.yellow(statusString[app.state]);
+      } else if (app.state === UnitState.DELETED) {
+        status = source_default.red(statusString[app.state]);
+      } else {
+        status = source_default.gray(statusString[app.state]);
+      }
+      const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+      const shortId = app.versionId.substring(0, 8);
+      const displayName = `${prefix}${connector} ${shortId}...${branch} - ${status} - ${source_default.dim(date)}`;
+      choices.push({
+        name: displayName,
+        value: app.versionId
+      });
+      const childPrefix = prefix + (isLast ? "   " : "\u2502  ");
+      node.children.forEach((child, index) => {
+        buildChoices(child, childPrefix, index === node.children.length - 1);
+      });
+    };
+    rootNodes.forEach((root, index) => {
+      buildChoices(root, "", index === rootNodes.length - 1);
+    });
+    choices.push({
+      name: source_default.dim("(None - clear version)"),
+      value: "__NONE__"
+    });
+    const selectedVersion = await esm_default({
+      message: "Select a version to checkout:",
+      choices
+    });
+    return selectedVersion === "__NONE__" ? void 0 : selectedVersion;
+  }
+  async run() {
+    const config = await this.loadConfig();
+    if (config.lock) {
+      this.error("Operation not allowed: application is in a locked state");
+    }
+    if (["text", "json"].indexOf(this.flags.output) === -1) {
+      this.error(`unsupported output format: ${this.flags.output}`, { exit: 1 });
+    }
+    if (!this.args.version) {
+      if (this.flags.output === "json") {
+        console.log(JSON.stringify({ versionId: config.versionId }, null, 2));
+        return;
+      }
+      if (!config.versionId) {
+        console.log("No version currently set.\n");
+      } else {
+        console.log(`Currently on version: ${config.versionId}
+`);
+      }
+      const apps = await this.loadManifest();
+      const app = apps[0];
+      if (app === void 0) {
+        this.error("No application found in manifest", { exit: 1 });
+      }
+      const applicationName = valueOf(app.name);
+      const { userId, organizationId } = await this.catalogService();
+      console.log("Fetching versions...");
+      const allVersions = await this.fetchApplicationVersions(
+        applicationName,
+        userId,
+        this.flags.impersonate ?? organizationId
+      );
+      const activeVersions = allVersions.filter(
+        (app2) => !app2.deletedAt
+      );
+      if (activeVersions.length === 0) {
+        config.sandbox = false;
+        await this.saveConfig(config);
+        console.log("No versions found.");
+        return;
+      }
+      console.log(`
+Found ${activeVersions.length} version${activeVersions.length !== 1 ? "s" : ""}:`);
+      const selectedVersion = await this.promptVersionSelection(activeVersions);
+      const activeApp = activeVersions.find((a) => a.versionId === selectedVersion);
+      config.versionId = selectedVersion;
+      config.sandbox = activeApp?.isSandboxed === true;
+      await this.saveConfig(config);
+      if (selectedVersion) {
+        console.log(`
+Switched to version: ${selectedVersion}`);
+      } else {
+        console.log("\nCleared version from config.");
+      }
+      return;
+    }
+    config.versionId = this.args.version;
+    await this.saveConfig(config);
+    if (this.flags.output === "json") {
+      console.log(JSON.stringify({ versionId: config.versionId }, null, 2));
+    } else {
+      console.log(`Switched to version ${config.versionId}`);
+    }
+  }
+};
+export {
+  Branch as default
+};

package/bundle/commands/build/clone.js

@@ -0,0 +1,153 @@
+import {
+  codegenPlan,
+  fileExists,
+  renderCodegenPlan
+} from "../../chunk-W2L3MYN6.js";
+import {
+  $,
+  spinner
+} from "../../chunk-PU4RCSXF.js";
+import {
+  esm_default
+} from "../../chunk-5GH4FS6C.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  getCurrentVersion,
+  init_cjs_shims,
+  mustManifestFromString,
+  readState,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/clone.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import fs from "node:fs/promises";
+import * as path from "node:path";
+async function getSelectedOrganizationName(configDir) {
+  const state = await readState(configDir);
+  if (!state.currentOrganizationId) {
+    throw new Error("Not logged in. Run `raindrop auth login` before deploying.");
+  }
+  const token = state.organizationIdToBearerToken[state.currentOrganizationId];
+  if (!token) {
+    throw new Error("No credentials found for current organization. Run `raindrop auth login` again.");
+  }
+  return token.organizationName;
+}
+var Clone = class extends BaseCommand {
+  static args = {
+    id: import_core.Args.string({ description: "liquidmetal project ID to clone (e.g., liquidmetal/smartbucket)", required: true }),
+    path: import_core.Args.directory({ default: ".", description: "Path to initialize the project in", required: false })
+  };
+  static description = "clone a LiquidMetal.AI project";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Clone a project in the current directory.
+`,
+    `<%= config.bin %> <%= command.id %> <%= config.path %>
+Clone a project in the specified 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 });
+    }
+    if (this.args.id !== "liquidmetal/smartbucket") {
+      this.error(`Unsupported project ID: ${this.args.id}`, { exit: 1 });
+    }
+    await this.initSmartbucketTemplate();
+  }
+  async initSmartbucketTemplate() {
+    this.log("Initializing liquidmetal/smartbucket project...");
+    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 });
+    }
+    const projectName = path.basename(this.args.path);
+    const sanitizedProjectName = projectName.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-_]/g, "").toLowerCase();
+    const manifest = `application "${sanitizedProjectName}" {
+    service "${sanitizedProjectName}-service" {}
+    smartbucket "${sanitizedProjectName}-smartbucket" {}
+  }
+`;
+    await fs.writeFile(path.join(this.args.path, "raindrop.manifest"), manifest);
+    await spinner("Installing dependencies...", async () => {
+      const $1 = $({ cwd: this.args.path, verbose: true });
+      await $1`npm install`;
+    });
+    await spinner("Generating code...", async () => {
+      const $1 = $({ cwd: this.args.path, verbose: true });
+      await $1`raindrop build generate`;
+    });
+    await spinner("Validating code...", async () => {
+      const $1 = $({ cwd: this.args.path, verbose: true });
+      await $1`raindrop build validate`;
+    });
+    let orgReady = false;
+    while (!orgReady) {
+      try {
+        const orgName = await getSelectedOrganizationName(this.config.configDir);
+        const confirmed = await esm_default({
+          message: `Using organization: ${orgName}. Is this correct?`
+        });
+        if (confirmed) {
+          orgReady = true;
+          break;
+        }
+      } catch (_) {
+      }
+      await spinner("Logging in...", async () => {
+        const $1 = $({ cwd: this.args.path, verbose: true });
+        await $1`raindrop auth login`;
+      });
+    }
+    await spinner("Branching...", async () => {
+      const $1 = $({ cwd: this.args.path, verbose: true });
+      await $1`raindrop build branch main`;
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+    });
+    this.log(`Initialized Smartbucket project "${sanitizedProjectName}" in ${this.args.path}`);
+    this.log(`To view your application, run:
+  cd ${this.args.path}
+  raindrop build list`);
+  }
+};
+export {
+  Clone as default,
+  getSelectedOrganizationName
+};

package/bundle/commands/build/delete.js

@@ -0,0 +1,227 @@
+import {
+  statusString
+} from "../../chunk-CMCEP64V.js";
+import {
+  source_default
+} from "../../chunk-MVQYQJHI.js";
+import {
+  esm_default2 as esm_default
+} from "../../chunk-5GH4FS6C.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  EPOCH_TS,
+  UnitState,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  timestampDate,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/delete.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Delete = class extends BaseCommand {
+  static args = {
+    application: import_core.Args.string({ char: "a", description: "application name", required: false })
+  };
+  static description = "delete Raindrop applications";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Deleted (application) at version (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"
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "table",
+      options: ["text", "table", "json"]
+    }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version to delete",
+      required: false,
+      exclusive: ["all"]
+    }),
+    all: import_core.Flags.boolean({
+      char: "a",
+      description: "delete all application versions",
+      required: false,
+      exclusive: ["version"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    })
+  };
+  // Build a version tree from applications (reused from list.ts)
+  buildVersionTree(applications) {
+    const nodesMap = /* @__PURE__ */ new Map();
+    const rootNodes = [];
+    applications.forEach((app) => {
+      const node = {
+        versionId: app.versionId,
+        previousVersionId: app.previousVersionId || null,
+        application: app,
+        children: [],
+        branch: app.branch
+      };
+      nodesMap.set(app.versionId, node);
+    });
+    for (const node of nodesMap.values()) {
+      if (node.previousVersionId && nodesMap.has(node.previousVersionId)) {
+        nodesMap.get(node.previousVersionId).children.push(node);
+      } else {
+        rootNodes.push(node);
+      }
+    }
+    return { rootNodes, nodesMap };
+  }
+  // Fetch all versions of the application
+  async fetchApplicationVersions(applicationName, userId, organizationId) {
+    const { client: catalogService } = await this.catalogService();
+    const resp = await catalogService.applications({
+      userId,
+      organizationId,
+      showDeleted: true
+    });
+    return resp.applications.filter((app) => app.name === applicationName);
+  }
+  // Prompt user to select a version from the tree
+  async promptVersionSelection(versions, defaultVersion) {
+    const { rootNodes } = this.buildVersionTree(versions);
+    const choices = [];
+    const buildChoices = (node, prefix = "", isLast = true) => {
+      const app = node.application;
+      const date = timestampDate(app.createdAt || EPOCH_TS).toLocaleDateString();
+      const branch = app.branch ? source_default.cyan(` (${app.branch})`) : "";
+      let status;
+      if (app.state === UnitState.RUNNING) {
+        status = source_default.green(statusString[app.state]);
+      } else if (app.state === UnitState.DELETING) {
+        status = source_default.yellow(statusString[app.state]);
+      } else if (app.state === UnitState.DELETED) {
+        status = source_default.red(statusString[app.state]);
+      } else {
+        status = source_default.gray(statusString[app.state]);
+      }
+      const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+      const shortId = app.versionId.substring(0, 8);
+      const isDefault = defaultVersion === app.versionId;
+      const defaultMarker = isDefault ? source_default.bold.green(" (parent - default)") : "";
+      const displayName = `${prefix}${connector} ${shortId}...${branch} - ${status} - ${source_default.dim(date)}${defaultMarker}`;
+      choices.push({
+        name: displayName,
+        value: app.versionId
+      });
+      const childPrefix = prefix + (isLast ? "   " : "\u2502  ");
+      node.children.forEach((child, index) => {
+        buildChoices(child, childPrefix, index === node.children.length - 1);
+      });
+    };
+    rootNodes.forEach((root, index) => {
+      buildChoices(root, "", index === rootNodes.length - 1);
+    });
+    choices.push({
+      name: source_default.dim("(None - clear version)"),
+      value: "__NONE__"
+    });
+    const selectedVersion = await esm_default({
+      message: "Select a version to checkout:",
+      choices,
+      default: defaultVersion
+    });
+    return selectedVersion === "__NONE__" ? void 0 : selectedVersion;
+  }
+  async run() {
+    const { client: catalogService, userId, organizationId } = await this.catalogService();
+    let versionId = this.flags.version;
+    if (this.flags.all) {
+      versionId = void 0;
+    } else if (this.flags.version === void 0) {
+      const config2 = await this.loadConfig();
+      versionId = config2.versionId;
+    }
+    if (this.args.application === void 0) {
+      const apps = await this.loadManifest();
+      const app = apps[0];
+      if (app === void 0) {
+        this.error("No application found in manifest and no application name specified", { exit: 1 });
+      }
+      this.args.application = valueOf(app.name);
+    }
+    let parentVersionId;
+    if (versionId) {
+      const allVersionsBeforeDelete = await this.fetchApplicationVersions(
+        this.args.application,
+        userId,
+        this.flags.impersonate ?? organizationId
+      );
+      const versionToDelete = allVersionsBeforeDelete.find((v) => v.versionId === versionId);
+      parentVersionId = versionToDelete?.previousVersionId || void 0;
+    }
+    try {
+      await catalogService.delete({
+        userId,
+        organizationId: this.flags.impersonate ?? organizationId,
+        // Omitting versionId will delete all versions of the application
+        applications: [{ applicationName: this.args.application, currentVersionId: versionId || "" }]
+      });
+    } catch (e) {
+      if (e instanceof Error) {
+        this.error(`Failed to delete application ${this.args.application}: ${e.message}`, { exit: 1 });
+      }
+      throw e;
+    }
+    if (this.flags.all) {
+      console.log(`Deleted all versions of ${this.args.application}`);
+    } else {
+      console.log(`Deleted ${this.args.application} at version ${versionId}`);
+    }
+    console.log("\nFetching remaining versions...");
+    const allVersions = await this.fetchApplicationVersions(
+      this.args.application,
+      userId,
+      this.flags.impersonate ?? organizationId
+    );
+    const activeVersions = allVersions.filter((app) => !app.deletedAt);
+    const config = await this.loadConfig();
+    if (activeVersions.length === 0) {
+      console.log("No undeleted versions remaining.");
+      config.versionId = void 0;
+      config.sandbox = false;
+      await this.saveConfig(config);
+      console.log("Cleared version from config.");
+    } else {
+      console.log(`
+Found ${activeVersions.length} undeleted version${activeVersions.length !== 1 ? "s" : ""}:`);
+      const selectedVersion = await this.promptVersionSelection(activeVersions, parentVersionId);
+      const activeApp = activeVersions.find((a) => a.versionId === selectedVersion);
+      config.versionId = selectedVersion;
+      config.sandbox = activeApp?.isSandboxed === true;
+      await this.saveConfig(config);
+      if (selectedVersion) {
+        console.log(`
+Checked out version: ${selectedVersion}`);
+      } else {
+        console.log("\nCleared version from config.");
+      }
+    }
+  }
+};
+export {
+  Delete as default
+};