@radishbot/sdk 0.7.2 → 0.8.1

package/dist/cli.js

@@ -0,0 +1,696 @@
+#!/usr/bin/env node
+
+// src/module_bindings/index.ts
+import {
+  DbConnectionBuilder as __DbConnectionBuilder,
+  DbConnectionImpl as __DbConnectionImpl,
+  SubscriptionBuilderImpl as __SubscriptionBuilderImpl,
+  convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
+  procedures as __procedures,
+  reducerSchema as __reducerSchema,
+  reducers as __reducers,
+  schema as __schema,
+  table as __table
+} from "spacetimedb";
+
+// src/module_bindings/add_log_reducer.ts
+import {
+  t as __t
+} from "spacetimedb";
+var add_log_reducer_default = {
+  keyHash: __t.string(),
+  exportToken: __t.string(),
+  level: __t.string(),
+  message: __t.string(),
+  data: __t.string()
+};
+
+// src/module_bindings/add_logs_batch_reducer.ts
+import {
+  t as __t2
+} from "spacetimedb";
+var add_logs_batch_reducer_default = {
+  keyHash: __t2.string(),
+  exportToken: __t2.string(),
+  entries: __t2.string()
+};
+
+// src/module_bindings/create_root_flow_reducer.ts
+import {
+  t as __t3
+} from "spacetimedb";
+var create_root_flow_reducer_default = {
+  keyHash: __t3.string(),
+  runId: __t3.string(),
+  timeoutSeconds: __t3.u64(),
+  exportToken: __t3.string(),
+  release: __t3.string()
+};
+
+// src/module_bindings/create_sub_flow_reducer.ts
+import {
+  t as __t4
+} from "spacetimedb";
+var create_sub_flow_reducer_default = {
+  keyHash: __t4.string(),
+  parentExportToken: __t4.string(),
+  name: __t4.string(),
+  timeoutSeconds: __t4.u64(),
+  exportToken: __t4.string()
+};
+
+// src/module_bindings/finish_action_reducer.ts
+import {
+  t as __t5
+} from "spacetimedb";
+var finish_action_reducer_default = {
+  keyHash: __t5.string(),
+  actionId: __t5.u64(),
+  status: __t5.string()
+};
+
+// src/module_bindings/finish_flow_reducer.ts
+import {
+  t as __t6
+} from "spacetimedb";
+var finish_flow_reducer_default = {
+  keyHash: __t6.string(),
+  exportToken: __t6.string(),
+  status: __t6.string(),
+  errorMessage: __t6.string()
+};
+
+// src/module_bindings/register_key_reducer.ts
+import {
+  t as __t7
+} from "spacetimedb";
+var register_key_reducer_default = {
+  keyHash: __t7.string(),
+  label: __t7.string(),
+  retentionDays: __t7.u64()
+};
+
+// src/module_bindings/start_action_reducer.ts
+import {
+  t as __t8
+} from "spacetimedb";
+var start_action_reducer_default = {
+  keyHash: __t8.string(),
+  exportToken: __t8.string(),
+  name: __t8.string()
+};
+
+// src/module_bindings/update_error_group_status_reducer.ts
+import {
+  t as __t9
+} from "spacetimedb";
+var update_error_group_status_reducer_default = {
+  keyHash: __t9.string(),
+  errorGroupId: __t9.u64(),
+  status: __t9.string()
+};
+
+// src/module_bindings/action_table.ts
+import {
+  t as __t10
+} from "spacetimedb";
+var action_table_default = __t10.row({
+  id: __t10.u64().primaryKey(),
+  flowId: __t10.u64().name("flow_id"),
+  name: __t10.string(),
+  status: __t10.string(),
+  createdAt: __t10.timestamp().name("created_at"),
+  finishedAt: __t10.u64().name("finished_at")
+});
+
+// src/module_bindings/api_key_table.ts
+import {
+  t as __t11
+} from "spacetimedb";
+var api_key_table_default = __t11.row({
+  keyHash: __t11.string().primaryKey().name("key_hash"),
+  label: __t11.string(),
+  retentionDays: __t11.u64().name("retention_days"),
+  createdAt: __t11.timestamp().name("created_at")
+});
+
+// src/module_bindings/error_group_table.ts
+import {
+  t as __t12
+} from "spacetimedb";
+var error_group_table_default = __t12.row({
+  id: __t12.u64().primaryKey(),
+  keyHash: __t12.string().name("key_hash"),
+  fingerprint: __t12.string(),
+  message: __t12.string(),
+  path: __t12.string(),
+  release: __t12.string(),
+  count: __t12.u64(),
+  status: __t12.string(),
+  firstSeenAt: __t12.timestamp().name("first_seen_at"),
+  lastSeenAt: __t12.u64().name("last_seen_at"),
+  lastFlowId: __t12.u64().name("last_flow_id")
+});
+
+// src/module_bindings/flow_table.ts
+import {
+  t as __t13
+} from "spacetimedb";
+var flow_table_default = __t13.row({
+  id: __t13.u64().primaryKey(),
+  keyHash: __t13.string().name("key_hash"),
+  runId: __t13.string().name("run_id"),
+  parentFlowId: __t13.u64().name("parent_flow_id"),
+  name: __t13.string(),
+  path: __t13.string(),
+  status: __t13.string(),
+  release: __t13.string(),
+  timeoutSeconds: __t13.u64().name("timeout_seconds"),
+  createdAt: __t13.timestamp().name("created_at"),
+  finishedAt: __t13.u64().name("finished_at"),
+  exportToken: __t13.string().name("export_token")
+});
+
+// src/module_bindings/log_entry_table.ts
+import {
+  t as __t14
+} from "spacetimedb";
+var log_entry_table_default = __t14.row({
+  id: __t14.u64().primaryKey(),
+  flowId: __t14.u64().name("flow_id"),
+  level: __t14.string(),
+  message: __t14.string(),
+  data: __t14.string(),
+  createdAt: __t14.timestamp().name("created_at")
+});
+
+// src/module_bindings/index.ts
+var tablesSchema = __schema({
+  action: __table({
+    name: "action",
+    indexes: [
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "action_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, action_table_default),
+  apiKey: __table({
+    name: "api_key",
+    indexes: [
+      { name: "keyHash", algorithm: "btree", columns: [
+        "keyHash"
+      ] }
+    ],
+    constraints: [
+      { name: "api_key_key_hash_key", constraint: "unique", columns: ["keyHash"] }
+    ]
+  }, api_key_table_default),
+  errorGroup: __table({
+    name: "error_group",
+    indexes: [
+      { name: "fingerprint", algorithm: "btree", columns: [
+        "fingerprint"
+      ] },
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "error_group_fingerprint_key", constraint: "unique", columns: ["fingerprint"] },
+      { name: "error_group_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, error_group_table_default),
+  flow: __table({
+    name: "flow",
+    indexes: [
+      { name: "exportToken", algorithm: "btree", columns: [
+        "exportToken"
+      ] },
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "flow_export_token_key", constraint: "unique", columns: ["exportToken"] },
+      { name: "flow_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, flow_table_default),
+  logEntry: __table({
+    name: "log_entry",
+    indexes: [
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "log_entry_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, log_entry_table_default)
+});
+var reducersSchema = __reducers(__reducerSchema("add_log", add_log_reducer_default), __reducerSchema("add_logs_batch", add_logs_batch_reducer_default), __reducerSchema("create_root_flow", create_root_flow_reducer_default), __reducerSchema("create_sub_flow", create_sub_flow_reducer_default), __reducerSchema("finish_action", finish_action_reducer_default), __reducerSchema("finish_flow", finish_flow_reducer_default), __reducerSchema("register_key", register_key_reducer_default), __reducerSchema("start_action", start_action_reducer_default), __reducerSchema("update_error_group_status", update_error_group_status_reducer_default));
+var proceduresSchema = __procedures();
+var REMOTE_MODULE = {
+  versionInfo: {
+    cliVersion: "2.0.3"
+  },
+  tables: tablesSchema.schemaType.tables,
+  reducers: reducersSchema.reducersType.reducers,
+  ...proceduresSchema
+};
+var tables = __makeQueryBuilder(tablesSchema.schemaType);
+var reducers = __convertToAccessorMap(reducersSchema.reducersType.reducers);
+
+class SubscriptionBuilder extends __SubscriptionBuilderImpl {
+}
+
+class DbConnectionBuilder extends __DbConnectionBuilder {
+}
+
+class DbConnection extends __DbConnectionImpl {
+  static builder = () => {
+    return new DbConnectionBuilder(REMOTE_MODULE, (config) => new DbConnection(config));
+  };
+  subscriptionBuilder = () => {
+    return new SubscriptionBuilder(this);
+  };
+}
+
+// src/cli.ts
+var HOST = "wss://maincloud.spacetimedb.com";
+var DB_NAME = "radish-log";
+var c = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function levelColor(level) {
+  switch (level) {
+    case "info":
+      return c.blue;
+    case "warn":
+      return c.yellow;
+    case "error":
+      return c.red;
+    case "debug":
+      return c.gray;
+    default:
+      return c.dim;
+  }
+}
+function statusColor(status) {
+  switch (status) {
+    case "open":
+      return c.blue;
+    case "finished":
+      return c.green;
+    case "error":
+      return c.red;
+    case "timeout":
+      return c.yellow;
+    default:
+      return c.dim;
+  }
+}
+function errorStatusColor(status) {
+  switch (status) {
+    case "open":
+      return c.red;
+    case "regressed":
+      return c.yellow;
+    case "resolved":
+      return c.green;
+    case "ignored":
+      return c.gray;
+    default:
+      return c.dim;
+  }
+}
+async function hashKey(key) {
+  const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key));
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function tsMicros(ts) {
+  return ts.microsSinceUnixEpoch;
+}
+function fmtTime(ts) {
+  return new Date(Number(tsMicros(ts) / 1000n)).toLocaleTimeString();
+}
+function fmtDateTime(ts) {
+  const d = new Date(Number(tsMicros(ts) / 1000n));
+  return d.toLocaleString();
+}
+function fmtMs(us) {
+  const ms = us / 1000;
+  if (ms < 1)
+    return "<1ms";
+  if (ms < 1000)
+    return `${Math.round(ms)}ms`;
+  if (ms < 60000)
+    return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+function fmtDuration(startTs, endMicros) {
+  return fmtMs(Number(endMicros - tsMicros(startTs)));
+}
+function fmtData(data) {
+  if (!data || data === "{}")
+    return "";
+  try {
+    const parsed = JSON.parse(data);
+    const str = JSON.stringify(parsed, null, 2);
+    return str.split(`
+`).map((line, i) => i === 0 ? " " + c.dim + line + c.reset : "                          " + c.dim + line + c.reset).join(`
+`);
+  } catch {
+    return " " + c.dim + data + c.reset;
+  }
+}
+function padRight(s, n) {
+  return s.length >= n ? s.slice(0, n) : s + " ".repeat(n - s.length);
+}
+function connect(keyHash) {
+  return new Promise((resolve, reject) => {
+    const conn = DbConnection.builder().withUri(HOST).withDatabaseName(DB_NAME).onConnect((c2, _identity, _token) => {
+      c2.subscriptionBuilder().onApplied(() => {
+        const flows = () => [...c2.db.flow.iter()];
+        const logs = () => [...c2.db.logEntry.iter()];
+        const errorGroups = () => [...c2.db.errorGroup.iter()];
+        resolve({ conn: c2, flows, logs, errorGroups });
+      }).subscribe([
+        `SELECT * FROM flow WHERE key_hash = '${keyHash}'`,
+        `SELECT * FROM log_entry WHERE flow_id IN (SELECT id FROM flow WHERE key_hash = '${keyHash}')`,
+        `SELECT * FROM error_group WHERE key_hash = '${keyHash}'`
+      ]);
+    }).onConnectError((_ctx, err) => reject(new Error(`Connection failed: ${err}`))).build();
+  });
+}
+function cmdList(flows) {
+  const roots = flows.filter((f) => f.parentFlowId === 0n).sort((a, b) => {
+    const am = tsMicros(a.createdAt), bm = tsMicros(b.createdAt);
+    return am > bm ? -1 : am < bm ? 1 : 0;
+  });
+  if (roots.length === 0) {
+    console.log(`${c.dim}No flows found for this key.${c.reset}`);
+    return;
+  }
+  const hasRelease = roots.some((f) => f.release && f.release !== "");
+  const hasRunId = roots.some((f) => f.runId && f.runId !== "");
+  console.log(`${c.bold}Flows${c.reset} ${c.dim}(${roots.length} total)${c.reset}
+`);
+  const cols = [
+    "ID".padEnd(8),
+    "STATUS".padEnd(10),
+    ...hasRunId ? ["RUN".padEnd(18)] : [],
+    ...hasRelease ? ["RELEASE".padEnd(10)] : [],
+    "DURATION".padEnd(10),
+    "CREATED"
+  ];
+  const divs = [
+    "─".repeat(8),
+    "─".repeat(10),
+    ...hasRunId ? ["─".repeat(18)] : [],
+    ...hasRelease ? ["─".repeat(10)] : [],
+    "─".repeat(10),
+    "─".repeat(24)
+  ];
+  console.log(`${c.dim}  ${cols.join(" ")}${c.reset}`);
+  console.log(`${c.dim}  ${divs.join(" ")}${c.reset}`);
+  for (const f of roots.slice(0, 30)) {
+    const id = f.id.toString().padEnd(8);
+    const sc = statusColor(f.status);
+    const status = padRight(f.status, 10);
+    const dur = f.finishedAt !== 0n ? padRight(fmtDuration(f.createdAt, f.finishedAt), 10) : padRight("—", 10);
+    const time = fmtDateTime(f.createdAt);
+    const runIdCol = hasRunId ? padRight(f.runId ? f.runId.slice(0, 16) : "—", 18) : "";
+    const release = hasRelease ? padRight(f.release || "—", 10) + " " : "";
+    console.log(`  ${c.dim}${id}${c.reset} ${sc}${status}${c.reset} ${hasRunId ? runIdCol + " " : ""}${release}${dur} ${c.dim}${time}${c.reset}`);
+  }
+  if (roots.length > 30) {
+    console.log(`${c.dim}  ... and ${roots.length - 30} more${c.reset}`);
+  }
+}
+function cmdShow(flowId, allFlows, allLogs) {
+  const flow = allFlows.find((f) => f.id === flowId);
+  if (!flow) {
+    console.error(`${c.red}Flow ${flowId} not found.${c.reset}`);
+    process.exit(1);
+  }
+  const sc = statusColor(flow.status);
+  const releaseTag = flow.release ? `  ${c.dim}(${flow.release})${c.reset}` : "";
+  console.log(`${c.bold}Flow #${flow.id}${c.reset}  ${sc}${flow.status}${c.reset}${releaseTag}`);
+  if (flow.runId) {
+    console.log(`${c.dim}Run: ${flow.runId}${c.reset}`);
+  }
+  console.log(`${c.dim}Created: ${fmtDateTime(flow.createdAt)}${c.reset}`);
+  if (flow.finishedAt !== 0n) {
+    console.log(`${c.dim}Duration: ${fmtDuration(flow.createdAt, flow.finishedAt)}${c.reset}`);
+  }
+  if (flow.release) {
+    console.log(`${c.dim}Release: ${flow.release}${c.reset}`);
+  }
+  console.log();
+  const children = allFlows.filter((f) => f.parentFlowId === flowId).sort((a, b) => {
+    const am = tsMicros(a.createdAt), bm = tsMicros(b.createdAt);
+    return am < bm ? -1 : am > bm ? 1 : 0;
+  });
+  if (children.length > 0) {
+    console.log(`${c.bold}Actions${c.reset}
+`);
+    for (const ch of children) {
+      const sc2 = statusColor(ch.status);
+      const dur = ch.finishedAt !== 0n ? fmtDuration(ch.createdAt, ch.finishedAt) : "…";
+      console.log(`  ${sc2}●${c.reset} ${c.bold}${ch.name}${c.reset} ${c.dim}#${ch.id}${c.reset}  ${sc2}${ch.status}${c.reset}  ${c.dim}${dur}${c.reset}`);
+    }
+    console.log();
+  }
+  const flowIds = new Set;
+  function collectIds(parentId) {
+    flowIds.add(parentId);
+    for (const f of allFlows) {
+      if (f.parentFlowId === parentId)
+        collectIds(f.id);
+    }
+  }
+  collectIds(flowId);
+  const logs = allLogs.filter((l) => flowIds.has(l.flowId) && l.level !== "flow" && l.level !== "action").sort((a, b) => {
+    const am = tsMicros(a.createdAt), bm = tsMicros(b.createdAt);
+    return am < bm ? -1 : am > bm ? 1 : 0;
+  });
+  if (logs.length === 0) {
+    console.log(`${c.dim}No logs.${c.reset}`);
+    return;
+  }
+  const flowMap = new Map;
+  for (const f of allFlows)
+    flowMap.set(f.id, f.name === "/" ? "root" : f.name);
+  console.log(`${c.bold}Logs${c.reset}
+`);
+  for (const l of logs) {
+    const time = fmtTime(l.createdAt);
+    const lc = levelColor(l.level);
+    const lvl = padRight(l.level, 5);
+    const source = l.flowId !== flowId ? ` ${c.cyan}[${flowMap.get(l.flowId) || "?"}]${c.reset}` : "";
+    const data = fmtData(l.data);
+    console.log(`  ${c.dim}${time}${c.reset} ${lc}${lvl}${c.reset}${source} ${l.message}${data}`);
+  }
+}
+function cmdTree(flowId, allFlows) {
+  const flow = allFlows.find((f) => f.id === flowId);
+  if (!flow) {
+    console.error(`${c.red}Flow ${flowId} not found.${c.reset}`);
+    process.exit(1);
+  }
+  console.log(`${c.bold}Flow Tree #${flow.id}${c.reset}
+`);
+  function printNode(f, prefix, connector) {
+    const sc = statusColor(f.status);
+    const name = f.name === "/" ? "root" : f.name;
+    const dur = f.finishedAt !== 0n ? ` ${c.dim}${fmtDuration(f.createdAt, f.finishedAt)}${c.reset}` : "";
+    console.log(`${prefix}${connector}${sc}●${c.reset} ${c.bold}${name}${c.reset} ${c.dim}#${f.id}${c.reset} ${sc}${f.status}${c.reset}${dur}`);
+  }
+  function printChildren(parentId, prefix) {
+    const children = allFlows.filter((ch) => ch.parentFlowId === parentId).sort((a, b) => {
+      const am = tsMicros(a.createdAt), bm = tsMicros(b.createdAt);
+      return am < bm ? -1 : am > bm ? 1 : 0;
+    });
+    for (let i = 0;i < children.length; i++) {
+      const isLast = i === children.length - 1;
+      printNode(children[i], prefix, isLast ? "└─ " : "├─ ");
+      printChildren(children[i].id, prefix + (isLast ? "   " : "│  "));
+    }
+  }
+  printNode(flow, "", "");
+  printChildren(flowId, "");
+}
+async function cmdTail(keyHash) {
+  console.log(`${c.bold}Tailing logs...${c.reset} ${c.dim}(Ctrl+C to stop)${c.reset}
+`);
+  const seen = new Set;
+  const flowNames = new Map;
+  const conn = await new Promise((resolve, reject) => {
+    DbConnection.builder().withUri(HOST).withDatabaseName(DB_NAME).onConnect((c2, _identity, _token) => {
+      c2.subscriptionBuilder().onApplied(() => {
+        for (const f of c2.db.flow.iter()) {
+          flowNames.set(f.id, f.name === "/" ? "root" : f.name);
+        }
+        for (const l of c2.db.logEntry.iter())
+          seen.add(l.id);
+        resolve(c2);
+      }).subscribe([
+        `SELECT * FROM flow WHERE key_hash = '${keyHash}'`,
+        `SELECT * FROM log_entry WHERE flow_id IN (SELECT id FROM flow WHERE key_hash = '${keyHash}')`
+      ]);
+    }).onConnectError((_ctx, err) => reject(new Error(`Connection failed: ${err}`))).build();
+  });
+  setInterval(() => {
+    for (const f of conn.db.flow.iter()) {
+      if (!flowNames.has(f.id)) {
+        flowNames.set(f.id, f.name === "/" ? "root" : f.name);
+      }
+    }
+    const newLogs = [];
+    for (const l of conn.db.logEntry.iter()) {
+      if (!seen.has(l.id) && l.level !== "flow" && l.level !== "action") {
+        seen.add(l.id);
+        newLogs.push(l);
+      }
+    }
+    newLogs.sort((a, b) => {
+      const am = tsMicros(a.createdAt), bm = tsMicros(b.createdAt);
+      return am < bm ? -1 : am > bm ? 1 : 0;
+    });
+    for (const l of newLogs) {
+      const time = fmtTime(l.createdAt);
+      const lc = levelColor(l.level);
+      const lvl = padRight(l.level, 5);
+      const source = `${c.cyan}[${flowNames.get(l.flowId) || "?"}]${c.reset}`;
+      const data = fmtData(l.data);
+      console.log(`${c.dim}${time}${c.reset} ${lc}${lvl}${c.reset} ${source} ${l.message}${data}`);
+    }
+  }, 500);
+}
+function cmdErrors(errorGroups) {
+  const statusOrder = { open: 0, regressed: 1, resolved: 2, ignored: 3 };
+  const sorted = [...errorGroups].sort((a, b) => {
+    const ao = statusOrder[a.status] ?? 99, bo = statusOrder[b.status] ?? 99;
+    if (ao !== bo)
+      return ao - bo;
+    return a.count > b.count ? -1 : a.count < b.count ? 1 : 0;
+  });
+  if (sorted.length === 0) {
+    console.log(`${c.dim}No error groups found for this key.${c.reset}`);
+    return;
+  }
+  console.log(`${c.bold}Errors${c.reset} ${c.dim}(${sorted.length} groups)${c.reset}
+`);
+  console.log(`${c.dim}  ${"ID".padEnd(8)} ${"STATUS".padEnd(10)} ${"COUNT".padEnd(6)} ${"RELEASE".padEnd(10)} ${"PATH".padEnd(23)} MESSAGE${c.reset}`);
+  console.log(`${c.dim}  ${"─".repeat(8)} ${"─".repeat(10)} ${"─".repeat(6)} ${"─".repeat(10)} ${"─".repeat(23)} ${"─".repeat(25)}${c.reset}`);
+  for (const g of sorted) {
+    const id = g.id.toString().padEnd(8);
+    const esc = errorStatusColor(g.status);
+    const status = padRight(g.status, 10);
+    const count = g.count.toString().padEnd(6);
+    const release = padRight(g.release || "—", 10);
+    const path = padRight(g.path || "—", 23);
+    const message = g.message.length > 50 ? g.message.slice(0, 47) + "..." : g.message;
+    console.log(`  ${c.dim}${id}${c.reset} ${esc}${status}${c.reset} ${count} ${c.dim}${release}${c.reset} ${c.dim}${path}${c.reset} ${message}`);
+  }
+}
+async function cmdUpdateErrorGroupStatus(conn, keyHash, errorGroupId, status) {
+  conn.reducers.updateErrorGroupStatus({
+    keyHash,
+    errorGroupId: BigInt(errorGroupId),
+    status
+  });
+  const label = status === "resolved" ? "Resolved" : "Ignored";
+  console.log(`${c.green}${label} error group #${errorGroupId}.${c.reset}`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(`
+${c.bold}radish${c.reset} — inspect flows and logs
+
+${c.bold}Usage:${c.reset}
+  radish keygen                       Generate a new secret key
+  radish <key>                        List recent flows
+  radish <key> <flowId>               Show flow detail + logs
+  radish <key> tree <flowId>          Show flow tree
+  radish <key> tail                   Live-tail all logs
+  radish <key> errors                 Show error groups
+  radish <key> resolve <errorGroupId> Resolve an error group
+  radish <key> ignore <errorGroupId>  Ignore an error group
+`);
+    process.exit(0);
+  }
+  if (args[0] === "keygen") {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    const key = "rl_" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    console.log(`
+${c.bold}Generated key:${c.reset} ${key}
+`);
+    console.log(`Save this key — it's your dashboard login.`);
+    console.log(`Dashboard: ${c.cyan}https://radish-log.spacetimedb.com${c.reset}
+`);
+    process.exit(0);
+  }
+  const secretKey = args[0];
+  const keyHash = await hashKey(secretKey);
+  const subcmd = args[1];
+  if (subcmd === "tail") {
+    await cmdTail(keyHash);
+    return;
+  }
+  process.stderr.write(`${c.dim}Connecting...${c.reset}`);
+  const { conn, flows, logs, errorGroups } = await connect(keyHash);
+  process.stderr.write(`\r${" ".repeat(20)}\r`);
+  const allFlows = flows();
+  const allLogs = logs();
+  if (!subcmd) {
+    cmdList(allFlows);
+  } else if (subcmd === "tree") {
+    const flowId = BigInt(args[2] || "0");
+    if (flowId === 0n) {
+      console.error(`${c.red}Usage: radish <key> tree <flowId>${c.reset}`);
+      process.exit(1);
+    }
+    cmdTree(flowId, allFlows);
+  } else if (subcmd === "errors") {
+    cmdErrors(errorGroups());
+  } else if (subcmd === "resolve") {
+    const errorGroupId = args[2];
+    if (!errorGroupId) {
+      console.error(`${c.red}Usage: radish <key> resolve <errorGroupId>${c.reset}`);
+      process.exit(1);
+    }
+    await cmdUpdateErrorGroupStatus(conn, keyHash, errorGroupId, "resolved");
+  } else if (subcmd === "ignore") {
+    const errorGroupId = args[2];
+    if (!errorGroupId) {
+      console.error(`${c.red}Usage: radish <key> ignore <errorGroupId>${c.reset}`);
+      process.exit(1);
+    }
+    await cmdUpdateErrorGroupStatus(conn, keyHash, errorGroupId, "ignored");
+  } else {
+    const flowId = BigInt(subcmd);
+    cmdShow(flowId, allFlows, allLogs);
+  }
+  conn.disconnect();
+  process.exit(0);
+}
+main().catch((err) => {
+  console.error(`${c.red}${err.message}${c.reset}`);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -12,8 +12,8 @@ export declare class Flow {
   a<T>(name: string, fn: (action: Flow) => T | Promise<T>, timeoutSeconds?: number): Promise<T>;
   finish(): Promise<void>;
   finishWithError(err?: Error | string): Promise<void>;
-  exportID(): Promise<string>;
-  getId(): Promise<bigint>;
+  readonly token: string;
+  exportID(): string;
   disconnect(): void;
   finishAndDisconnect(): Promise<void>;
 }