@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

package/bundle/chunk-AU3EGGJP.js

@@ -0,0 +1,44 @@
+import {
+  init_cjs_shims
+} from "./chunk-G6NE675D.js";
+
+// ../drizzle/dist/mrn.js
+init_cjs_shims();
+function parseMRN(mrn) {
+  const parts = mrn.split(":");
+  if (parts.length !== 6) {
+    throw new Error(`Invalid MRN format: ${mrn}`);
+  }
+  const [type, applicationName, versionId, module, itemOrKey, revision] = parts;
+  if (!type || !applicationName || !versionId) {
+    throw new Error(`MRN must contain type, applicationName, and versionId: ${mrn}`);
+  }
+  if (!["annotation", "label"].includes(type)) {
+    throw new Error(`Invalid MRN type: ${type}`);
+  }
+  const mrnObject = {
+    type,
+    applicationName,
+    versionId
+  };
+  if (module) {
+    mrnObject.module = module;
+  }
+  if (itemOrKey) {
+    if (itemOrKey.includes("^")) {
+      const [item, keyValue] = itemOrKey.split("^");
+      mrnObject.item = item;
+      mrnObject.key = keyValue || "";
+    } else {
+      mrnObject.key = itemOrKey;
+    }
+  }
+  if (revision) {
+    mrnObject.revision = revision;
+  }
+  return mrnObject;
+}
+
+export {
+  parseMRN
+};

package/bundle/chunk-CDQRD3JA.js

@@ -0,0 +1,75 @@
+import {
+  init_cjs_shims
+} from "./chunk-G6NE675D.js";
+
+// ../drizzle/dist/ulid.js
+init_cjs_shims();
+var BASE32_ENCODING = "0123456789abcdefghjkmnpqrstvwxyz";
+var ENCODING_LEN = BASE32_ENCODING.length;
+var TIME_MAX = Math.pow(2, 48) - 1;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function monotonic() {
+  let lastTime = 0;
+  let lastRandom;
+  return function ulid2() {
+    const seed = (/* @__PURE__ */ new Date()).getTime();
+    if (seed <= lastTime) {
+      lastRandom = incrementBase32(lastRandom);
+      return encodeTime(lastTime) + lastRandom;
+    }
+    lastTime = seed;
+    lastRandom = encodeRandom();
+    return encodeTime(seed) + lastRandom;
+  };
+}
+var ulid = monotonic();
+function encodeRandom() {
+  const bytes = crypto.getRandomValues(new Uint8Array(RANDOM_LEN));
+  let str = "";
+  for (let i = 0; i < RANDOM_LEN; i++) {
+    str = str + BASE32_ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function encodeTime(ms) {
+  if (ms > TIME_MAX)
+    throw new Error("cannot encode time greater than " + TIME_MAX);
+  if (ms < 0)
+    throw new Error("time must be positive");
+  let mod;
+  let str = "";
+  for (let len = TIME_LEN; len > 0; len--) {
+    mod = ms % ENCODING_LEN;
+    str = BASE32_ENCODING[mod] + str;
+    ms = (ms - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function incrementBase32(str) {
+  function replaceCharAt(str2, index2, char2) {
+    if (index2 > str2.length - 1)
+      return str2;
+    return str2.substring(0, index2) + char2 + str2.substring(index2 + 1);
+  }
+  const maxCharIndex = ENCODING_LEN - 1;
+  let index = str ? str.length : 0;
+  let char;
+  let charIndex;
+  while (index-- >= 0) {
+    char = str[index];
+    charIndex = BASE32_ENCODING.indexOf(char);
+    if (charIndex === -1)
+      throw new Error("incorrectly encoded string");
+    if (charIndex === maxCharIndex) {
+      str = replaceCharAt(str, index, BASE32_ENCODING[0]);
+      continue;
+    }
+    return replaceCharAt(str, index, BASE32_ENCODING[charIndex + 1]);
+  }
+  return str;
+}
+
+export {
+  ulid
+};

package/bundle/chunk-CMCEP64V.js

@@ -0,0 +1,380 @@
+import {
+  source_default
+} from "./chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "./chunk-MCRKUPJY.js";
+import {
+  ApplicationsResponseSchema,
+  EPOCH_TS,
+  UnitState,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  timestampDate,
+  toJsonString
+} from "./chunk-G6NE675D.js";
+
+// src/commands/build/list.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var statusString = {
+  [UnitState.UNSPECIFIED]: "<unknown>",
+  [UnitState.PENDING]: "pending...",
+  [UnitState.STARTING]: "starting...",
+  [UnitState.RUNNING]: "running",
+  [UnitState.STOPPING]: "stopping...",
+  [UnitState.STOPPED]: "stopped",
+  [UnitState.DELETING]: "deleting...",
+  [UnitState.DELETED]: "deleted"
+};
+var List = class extends BaseCommand {
+  static args = {};
+  static description = "list Raindrop catalog resources";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+List applications in compact view (default).
+
+<%= config.bin %> <%= command.id %> -o tree
+Show applications in tree view with version hierarchy.
+
+<%= config.bin %> <%= command.id %> -o log
+Show git-log style view with branch visualization.
+
+<%= config.bin %> <%= command.id %> --app demo-fts --limit 5
+Show only demo-fts application, limited to 5 versions.
+
+<%= config.bin %> <%= command.id %> --active
+Show only running/active versions.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    all: import_core.Flags.boolean({ char: "a", description: "show deleted resources", default: false }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "compact",
+      options: ["text", "table", "json", "log", "compact", "tree"]
+    }),
+    app: import_core.Flags.string({
+      description: "filter by application name",
+      required: false
+    }),
+    limit: import_core.Flags.integer({
+      char: "n",
+      description: "limit number of versions shown per application",
+      required: false
+    }),
+    active: import_core.Flags.boolean({
+      description: "show only running/active versions",
+      default: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      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 };
+  }
+  // Render the version tree in git-log style with branch lines
+  renderGitLogStyle(applications) {
+    const groups = this.groupApplicationsByName(applications);
+    const result = [];
+    for (const [_appName, appVersions] of groups) {
+      result.push("");
+      const firstApp = appVersions[0];
+      if (!firstApp) continue;
+      const formattedAppName = this.formatAppName(firstApp);
+      result.push(source_default.bold.underline(`=== ${formattedAppName} ===`));
+      result.push("");
+      const { rootNodes } = this.buildVersionTree(appVersions);
+      const columnMap = /* @__PURE__ */ new Map();
+      let maxColumn = 0;
+      const assignColumns = (node, parentColumn) => {
+        if (columnMap.has(node.versionId)) return;
+        if (parentColumn !== void 0) {
+          columnMap.set(node.versionId, parentColumn);
+        } else {
+          columnMap.set(node.versionId, maxColumn++);
+        }
+        node.children.forEach((child) => {
+          assignColumns(child, columnMap.get(node.versionId));
+        });
+      };
+      rootNodes.forEach((root) => assignColumns(root));
+      const flattenedNodes = [];
+      const flatten = (node) => {
+        flattenedNodes.push(node);
+        node.children.forEach((child) => flatten(child));
+      };
+      rootNodes.forEach((root) => flatten(root));
+      flattenedNodes.sort((a, b) => {
+        const aTime = timestampDate(a.application.createdAt || EPOCH_TS).getTime() || 0;
+        const bTime = timestampDate(b.application.createdAt || EPOCH_TS).getTime() || 0;
+        return bTime - aTime;
+      });
+      const processed = /* @__PURE__ */ new Set();
+      const linesInUse = /* @__PURE__ */ new Set();
+      for (const node of flattenedNodes) {
+        if (processed.has(node.versionId)) continue;
+        processed.add(node.versionId);
+        const app = node.application;
+        const column = columnMap.get(node.versionId) || 0;
+        linesInUse.add(column);
+        const date = timestampDate(app.createdAt || EPOCH_TS);
+        const timestamp = date.toLocaleString("en-US", {
+          weekday: "short",
+          month: "short",
+          day: "numeric",
+          year: "numeric",
+          hour: "numeric",
+          minute: "numeric",
+          second: "numeric",
+          hour12: false,
+          timeZoneName: "short"
+        });
+        let graphLine = "";
+        for (let i = 0; i <= maxColumn; i++) {
+          if (i === column) {
+            graphLine += "*";
+          } else if (linesInUse.has(i)) {
+            graphLine += "|";
+          } else {
+            graphLine += " ";
+          }
+        }
+        let branchInfo = "";
+        if (app.branch) {
+          branchInfo = ` (${app.branch})`;
+        }
+        let parentInfo = "";
+        if (app.previousVersionId) {
+          parentInfo = ` [parent: ${app.previousVersionId}]`;
+        }
+        const versionLine = `${graphLine} ${source_default.yellow("version")} ${source_default.yellow(app.versionId)}${source_default.cyan(branchInfo)}${source_default.dim(parentInfo)}`;
+        result.push(versionLine);
+        graphLine = graphLine.replace("*", "|");
+        let statusColor;
+        if (app.state === UnitState.RUNNING) {
+          statusColor = source_default.green;
+        } else if (app.state === UnitState.DELETING) {
+          statusColor = source_default.yellow;
+        } else if (app.state === UnitState.DELETED) {
+          statusColor = source_default.red;
+        } else {
+          statusColor = source_default.gray;
+        }
+        result.push(`${graphLine} ${source_default.bold("Status:")} ${statusColor(statusString[app.state])}`);
+        result.push(`${graphLine} ${source_default.bold("Date:")}   ${source_default.dim(timestamp)}`);
+        result.push(`${graphLine} `);
+        result.push(`${graphLine}     ${source_default.bold(this.formatAppName(app))}`);
+        result.push(`${graphLine}`);
+      }
+    }
+    return result.join("\n");
+  }
+  // Helper function to format app name with privileged indicator
+  formatAppName(app) {
+    const privilegedIcon = app.privileged ? source_default.magenta("\u{1F512} ") : "";
+    return `${privilegedIcon}${app.name}`;
+  }
+  // Group applications by name
+  groupApplicationsByName(applications) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const app of applications) {
+      const name = app.name;
+      if (!groups.has(name)) {
+        groups.set(name, []);
+      }
+      groups.get(name).push(app);
+    }
+    for (const apps of groups.values()) {
+      apps.sort((a, b) => {
+        const aTime = timestampDate(a.createdAt || EPOCH_TS).getTime();
+        const bTime = timestampDate(b.createdAt || EPOCH_TS).getTime();
+        return bTime - aTime;
+      });
+    }
+    return groups;
+  }
+  // Render compact view
+  renderCompactView(applications) {
+    const groups = this.groupApplicationsByName(applications);
+    const result = [];
+    const sortedGroups = Array.from(groups.entries()).sort((a, b) => {
+      const aLatest = a[1][0];
+      const bLatest = b[1][0];
+      if (!aLatest || !bLatest) return 0;
+      const aTime = timestampDate(aLatest.createdAt || EPOCH_TS).getTime();
+      const bTime = timestampDate(bLatest.createdAt || EPOCH_TS).getTime();
+      return bTime - aTime;
+    });
+    for (const [_appName, versions] of sortedGroups) {
+      const activeVersions2 = versions.filter((v) => v.state === UnitState.RUNNING);
+      const deletedVersions = versions.filter((v) => v.state === UnitState.DELETED || v.state === UnitState.DELETING);
+      const firstVersion = versions[0];
+      if (!firstVersion) continue;
+      const formattedAppName = this.formatAppName(firstVersion);
+      result.push(`
+${source_default.bold(formattedAppName)} ${source_default.dim(`(${versions.length} version${versions.length !== 1 ? "s" : ""})`)}`);
+      let shown = 0;
+      for (const version of activeVersions2) {
+        if (this.flags.limit && shown >= this.flags.limit) break;
+        const date = timestampDate(version.createdAt || EPOCH_TS).toLocaleDateString();
+        const branch = version.branch ? source_default.cyan(` (${version.branch})`) : "";
+        const status = source_default.green(statusString[version.state]);
+        result.push(`  \u2514\u2500 ${source_default.yellow(version.versionId)}...${branch} - ${status} - ${source_default.dim(date)}`);
+        shown++;
+      }
+      if (!this.flags.active && deletedVersions.length > 0) {
+        const remaining = this.flags.limit ? Math.max(0, this.flags.limit - shown) : deletedVersions.length;
+        const toShow = Math.min(remaining, deletedVersions.length);
+        for (let i = 0; i < toShow && i < 3; i++) {
+          const version = deletedVersions[i];
+          if (!version) continue;
+          const date = timestampDate(version.createdAt || EPOCH_TS).toLocaleDateString();
+          const status = version.state === UnitState.DELETING ? source_default.yellow(statusString[version.state]) : source_default.red(statusString[version.state]);
+          result.push(`  \u2514\u2500 ${source_default.gray(version.versionId)}... - ${status} - ${source_default.dim(date)}`);
+        }
+        if (deletedVersions.length > toShow) {
+          result.push(source_default.dim(`  ... ${deletedVersions.length - toShow} more deleted versions`));
+        }
+      }
+    }
+    const totalApps = sortedGroups.length;
+    const totalVersions = applications.length;
+    const activeVersions = applications.filter((app) => app.state === UnitState.RUNNING).length;
+    result.push("");
+    result.push(source_default.dim("\u2500".repeat(50)));
+    result.push(source_default.dim(`Total: ${totalApps} applications, ${totalVersions} versions (${activeVersions} active)`));
+    return result.join("\n");
+  }
+  // Render tree view for a specific application
+  renderTreeView(applications) {
+    const groups = this.groupApplicationsByName(applications);
+    const result = [];
+    for (const [_appName, versions] of groups) {
+      const firstVersion = versions[0];
+      if (!firstVersion) continue;
+      const formattedAppName = this.formatAppName(firstVersion);
+      result.push(`
+${source_default.bold.underline(`=== ${formattedAppName} ===`)}`);
+      const { rootNodes } = this.buildVersionTree(versions);
+      const renderNode = (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 current = app.state === UnitState.RUNNING && app.branch === "main" ? source_default.bold.green(" \u2190 current") : "";
+        const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+        const shortId = source_default.yellow(app.versionId);
+        result.push(`${prefix}${connector} ${shortId}...${branch} - ${status} - ${source_default.dim(date)}${current}`);
+        const childPrefix = prefix + (isLast ? "   " : "\u2502  ");
+        node.children.forEach((child, index) => {
+          renderNode(child, childPrefix, index === node.children.length - 1);
+        });
+      };
+      rootNodes.forEach((root, index) => {
+        renderNode(root, "", index === rootNodes.length - 1);
+      });
+    }
+    return result.join("\n");
+  }
+  async listApplications() {
+    const { client: catalogService, organizationId: defaultOrganizationId, userId } = await this.catalogService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    if (this.flags.output === "log" || this.flags.output === "table") {
+      this.log(source_default.dim(`Listing applications for organization ${organizationId}`));
+    }
+    const resp = await catalogService.applications({
+      userId,
+      organizationId,
+      showDeleted: this.flags.all
+    });
+    let applications = resp.applications;
+    if (this.flags.app) {
+      applications = applications.filter((app) => app.name === this.flags.app);
+    }
+    if (this.flags.active) {
+      applications = applications.filter((app) => app.state === UnitState.RUNNING);
+    }
+    if (this.flags.output === "log") {
+      this.log(this.renderGitLogStyle(applications));
+    } else if (this.flags.output === "compact") {
+      this.log(this.renderCompactView(applications));
+    } else if (this.flags.output === "tree") {
+      this.log(this.renderTreeView(applications));
+    } else if (this.flags.output === "table") {
+      console.table(
+        applications.reduce(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (acc, a) => {
+            const dateStr = a.createdAt ? timestampDate(a.createdAt).toISOString() : "";
+            acc[dateStr] = {
+              ...a,
+              status: statusString[a.state],
+              locked: a.lock ? "locked" : "",
+              privileged: a.privileged ? "system" : "user"
+            };
+            return acc;
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          {}
+        ),
+        ["organizationId", "name", "versionId", "branch", "status", "locked", "privileged", ...this.flags.all ? ["deletedAt"] : []]
+      );
+    } else if (this.flags.output === "json") {
+      console.log(toJsonString(ApplicationsResponseSchema, resp, { prettySpaces: 2 }));
+    } else {
+      this.log(this.renderCompactView(applications));
+    }
+  }
+  async run() {
+    await this.listApplications();
+  }
+};
+
+export {
+  statusString,
+  List
+};