@liquidmetal-ai/raindrop 0.9.0 → 0.9.1

package/bundle/chunk-IXNEFD7W.js

@@ -0,0 +1,133 @@
+import {
+  init_cjs_shims,
+  timestampMs
+} from "./chunk-VEVVJAL6.js";
+
+// src/log-helpers.ts
+init_cjs_shims();
+function formatLogAttribute(key, value, displayValue) {
+  if (key === "http.status") {
+    const statusCode = parseInt(value);
+    const statusEmoji = statusCode >= 200 && statusCode < 300 ? "\u2705" : statusCode >= 400 ? "\u274C" : "\u26A0\uFE0F";
+    return `${key}: ${statusEmoji} ${value}`;
+  } else if (key === "http.method" || key === "http.url") {
+    return `${key}: ${value}`;
+  } else if (key === "query") {
+    return `\u{1F5C4}\uFE0F  SQL Query: ${value}`;
+  } else if (key === "rows_read") {
+    return `\u{1F4CA} Rows Read: ${value}`;
+  } else if (key === "rows_written") {
+    return `\u270D\uFE0F  Rows Written: ${value}`;
+  } else if (key === "db") {
+    return `\u{1F3E6} Database: ${value}`;
+  } else if (key === "error") {
+    if (value && value !== "undefined") {
+      return `\u274C Error: ${value}`;
+    }
+    return null;
+  } else if (key === "fields" || key === "meta") {
+    try {
+      const parsed = JSON.parse(displayValue);
+      if (key === "meta" && parsed) {
+        const metrics = [];
+        if (parsed.duration) metrics.push(`${parsed.duration}ms`);
+        if (parsed.rows_read) metrics.push(`${parsed.rows_read} rows read`);
+        if (parsed.rows_written && parsed.rows_written > 0) metrics.push(`${parsed.rows_written} rows written`);
+        if (parsed.served_by_region) metrics.push(`${parsed.served_by_region}`);
+        if (parsed.size_after) metrics.push(`DB: ${(parsed.size_after / 1024).toFixed(1)}KB`);
+        if (metrics.length > 0) {
+          return `\u{1F4CA} ${key}: ${metrics.join(", ")}`;
+        } else {
+          return `${key}: ${JSON.stringify(parsed, (_, v) => typeof v === "bigint" ? v.toString() : v)}`;
+        }
+      } else {
+        return `${key}: ${JSON.stringify(parsed, (_, v) => typeof v === "bigint" ? v.toString() : v)}`;
+      }
+    } catch {
+      return `${key}: ${displayValue}`;
+    }
+  } else {
+    return `${key}: ${displayValue}`;
+  }
+}
+function displayEventAttributes(event, logger, indentLevel = "     ") {
+  if (event.attributes && Object.keys(event.attributes).length > 0) {
+    Object.entries(event.attributes).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        let displayValue = value;
+        try {
+          const parsed = JSON.parse(value);
+          if (typeof parsed === "object" && parsed !== null) {
+            displayValue = JSON.stringify(parsed, (_, v) => {
+              if (typeof v === "bigint") {
+                return v.toString();
+              }
+              return v;
+            }, 2);
+          }
+        } catch {
+        }
+        const formattedAttribute = formatLogAttribute(key, value, displayValue);
+        if (formattedAttribute) {
+          logger.log(`${indentLevel}${formattedAttribute}`);
+        }
+      }
+    });
+  }
+}
+function displayTraceGroupedEvents(events, logger) {
+  const eventsByTrace = /* @__PURE__ */ new Map();
+  events.forEach((event) => {
+    const traceId = event.trace?.eventId || "unknown";
+    if (!eventsByTrace.has(traceId)) {
+      eventsByTrace.set(traceId, []);
+    }
+    const traceEvents = eventsByTrace.get(traceId);
+    if (traceEvents) {
+      traceEvents.push(event);
+    }
+  });
+  for (const [traceId, traceEvents] of eventsByTrace) {
+    if (traceEvents.length === 0) continue;
+    traceEvents.sort((a, b) => {
+      if (a.eventOrder !== void 0 && b.eventOrder !== void 0) {
+        return a.eventOrder - b.eventOrder;
+      }
+      const aTime = a.trace?.startTime ? timestampMs(a.trace.startTime) : 0;
+      const bTime = b.trace?.startTime ? timestampMs(b.trace.startTime) : 0;
+      return aTime - bTime;
+    });
+    const firstEvent = traceEvents[0];
+    const lastEvent = traceEvents[traceEvents.length - 1];
+    const startTime = firstEvent.trace?.startTime ? timestampMs(firstEvent.trace.startTime) : 0;
+    const endTime = lastEvent.trace?.endTime ? timestampMs(lastEvent.trace.endTime) : lastEvent.trace?.startTime ? timestampMs(lastEvent.trace.startTime) : 0;
+    const traceDuration = endTime > startTime ? ` (${endTime - startTime}ms total)` : "";
+    const timestamp = firstEvent.trace?.startTime ? new Date(timestampMs(firstEvent.trace.startTime)).toLocaleString() : "Unknown time";
+    logger.log(`[${timestamp}] \u{1F517} Trace: ${traceId}${traceDuration}`);
+    if (firstEvent.organization?.id || firstEvent.application?.name) {
+      const contextParts = [];
+      if (firstEvent.organization?.id) contextParts.push(`Org: ${firstEvent.organization.id}`);
+      if (firstEvent.application?.name) contextParts.push(`App: ${firstEvent.application.name}`);
+      if (firstEvent.application?.version?.id) contextParts.push(`v${firstEvent.application.version.id}`);
+      if (firstEvent.script?.name) contextParts.push(`Script: ${firstEvent.script.name}`);
+      logger.log(`  ${contextParts.join(", ")}`);
+    }
+    traceEvents.forEach((event, index) => {
+      const eventName = event.name || "Event";
+      const status = event.status || "ok";
+      const statusEmoji = status === "error" ? "\u274C" : "\u2705";
+      let duration = "";
+      if (event.trace?.endTime && event.trace?.startTime) {
+        const durationMs = timestampMs(event.trace.endTime) - timestampMs(event.trace.startTime);
+        duration = ` (${durationMs}ms)`;
+      }
+      logger.log(`  ${index + 1}. ${statusEmoji} ${eventName}${duration}`);
+      displayEventAttributes(event, logger, "     ");
+    });
+    logger.log("");
+  }
+}
+
+export {
+  displayTraceGroupedEvents
+};

package/bundle/chunk-JDMAG4KE.js

@@ -0,0 +1,147 @@
+import {
+  source_default
+} from "./chunk-IMQTVYRB.js";
+import {
+  UnitState,
+  init_cjs_shims,
+  valueOf
+} from "./chunk-JXNZYHAI.js";
+
+// src/status.ts
+init_cjs_shims();
+import * as readline from "readline";
+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"
+};
+async function getStatus(options) {
+  const { command, impersonate } = options;
+  let applicationName = options.applicationName;
+  let versionId = options.versionId;
+  if (!versionId) {
+    const config = await command.loadConfig();
+    versionId = config.versionId;
+  }
+  if (!applicationName) {
+    const apps = await command.loadManifest();
+    const app = apps[0];
+    if (app === void 0) {
+      command.error("No application provided or found in manifest");
+    }
+    applicationName = valueOf(app.name);
+  }
+  const { client: catalogService, userId, organizationId: defaultOrganizationId } = await command.catalogService();
+  const organizationId = impersonate ?? defaultOrganizationId;
+  const status = await catalogService.status({
+    userId,
+    organizationId,
+    applicationName,
+    currentVersionId: versionId || ""
+  });
+  if (status === void 0) {
+    command.error(`Application ${applicationName} not found`);
+  }
+  return status;
+}
+async function watchStatus(options) {
+  const { command } = options;
+  const renderer = new StatusRenderer();
+  let applicationName = options.applicationName;
+  let versionId = options.versionId;
+  if (!applicationName) {
+    const apps = await command.loadManifest();
+    const app = apps[0];
+    if (app) {
+      applicationName = valueOf(app.name);
+    }
+  }
+  if (!versionId) {
+    const config = await command.loadConfig();
+    versionId = config.versionId;
+  }
+  let status = await getStatus(options);
+  while (true) {
+    renderer.renderLive(status, applicationName, versionId);
+    if (status.state === UnitState.RUNNING || status.state === UnitState.STOPPED) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    status = await getStatus(options);
+  }
+}
+var StatusRenderer = class {
+  linesLastRendered = 0;
+  getStatusColor(state) {
+    switch (state) {
+      case UnitState.RUNNING:
+        return source_default.green;
+      case UnitState.PENDING:
+      case UnitState.STARTING:
+        return source_default.yellow;
+      case UnitState.STOPPING:
+      case UnitState.DELETING:
+        return source_default.yellow;
+      case UnitState.STOPPED:
+      case UnitState.DELETED:
+        return source_default.red;
+      default:
+        return source_default.gray;
+    }
+  }
+  renderLive(status, applicationName, versionId) {
+    if (this.linesLastRendered > 0) {
+      readline.moveCursor(process.stdout, 0, -this.linesLastRendered);
+      readline.clearScreenDown(process.stdout);
+    }
+    const lines = [];
+    lines.push("");
+    lines.push(`${source_default.bold(applicationName)} ${source_default.dim(versionId ? `@${versionId.substring(0, 8)}...` : "")}`);
+    lines.push(source_default.dim(`Status: ${this.getStatusColor(status.state)(statusString[status.state])}`));
+    lines.push("");
+    lines.push(`${source_default.bold("Modules")} ${source_default.dim(`(${status.modules.length})`)}`);
+    for (const module of status.modules) {
+      const statusColor = this.getStatusColor(module.state);
+      const notification = module.notification ? ` - ${source_default.cyan(module.notification)}` : "";
+      lines.push(`  \u2514\u2500 ${source_default.yellow(module.name)} - ${statusColor(statusString[module.state])}${notification}`);
+    }
+    const runningModules = status.modules.filter((m) => m.state === UnitState.RUNNING).length;
+    const totalModules = status.modules.length;
+    lines.push("");
+    lines.push(source_default.dim("\u2500".repeat(50)));
+    lines.push(source_default.dim(`Total: ${totalModules} modules (${runningModules} running)`));
+    for (const line of lines) {
+      console.log(line);
+    }
+    this.linesLastRendered = lines.length;
+  }
+  renderCompact(status, applicationName, versionId) {
+    console.log(`
+${source_default.bold(applicationName)} ${source_default.dim(versionId ? `@${versionId.substring(0, 8)}...` : "")}`);
+    console.log(source_default.dim(`Status: ${this.getStatusColor(status.state)(statusString[status.state])}`));
+    console.log(`
+${source_default.bold("Modules")} ${source_default.dim(`(${status.modules.length})`)}`);
+    for (const module of status.modules) {
+      const statusColor = this.getStatusColor(module.state);
+      const notification = module.notification ? ` - ${source_default.cyan(module.notification)}` : "";
+      console.log(`  \u2514\u2500 ${source_default.yellow(module.name)} - ${statusColor(statusString[module.state])}${notification}`);
+    }
+    const runningModules = status.modules.filter((m) => m.state === UnitState.RUNNING).length;
+    const totalModules = status.modules.length;
+    console.log("");
+    console.log(source_default.dim("\u2500".repeat(50)));
+    console.log(source_default.dim(`Total: ${totalModules} modules (${runningModules} running)`));
+  }
+};
+
+export {
+  statusString,
+  getStatus,
+  watchStatus,
+  StatusRenderer
+};