@mybase-dev/cli 1.0.6 → 1.0.8

package/dist/mybase.js

@@ -116,6 +116,7 @@ var KEY_RESOURCES = [
   { id: "vector", name: "Vector search", description: "Indexes, documents, and queries (read), and changing them (write)" },
   { id: "users", name: "Users", description: "Your app's users and sessions (read), revoking and deleting them, and sending sign-in events (write)" },
   { id: "captcha", name: "Captcha", description: "Captcha settings (read), and verifying tokens (write)" },
+  { id: "realtime", name: "Realtime", description: "Channels, members, and settings (read), and publishing messages (write)" },
   { id: "audit", name: "Audit log", description: "Who did what: sign-ins, key and project changes, secret reads (read only)" }
 ];
 function parseDotenv(text) {
@@ -139,7 +140,7 @@ function parseDotenv(text) {
 // package.json
 var package_default = {
   name: "@mybase-dev/cli",
-  version: "1.0.6",
+  version: "1.0.8",
   description: "The mybase CLI: projects, keys, cron, queues, cache, rate limits, analytics, docs, and agent setup for a self-hosted mybase.",
   type: "module",
   repository: {
@@ -652,6 +653,9 @@ function contextMarkdown(c) {
   }
   if (c.captcha)
     out.push("## Captcha", "", `Script: ${c.captcha.scriptUrl} (data-project="${c.project}"). Check tokens with \`createCaptchaClient\` (\`captcha:write\` key) or Better Auth's captcha plugin via \`mybaseCaptcha()\`.`, "");
+  if (c.realtime) {
+    out.push("## Realtime", "", `Browsers: \`connectRealtime({ apiUrl, project: "${c.project}", token })\` (socket ${c.realtime.socketUrl}) with tokens your server signs via \`createRealtimeToken(MYBASE_REALTIME_SECRET, \u2026)\`. Publish from the server: POST ${c.realtime.publishUrl} (\`realtime:write\` key, \`createRealtimeClient\`).`, "");
+  }
   if (c.analytics)
     out.push("## Analytics", "", `Public write key \`${c.analytics.writeKey}\`, script ${c.analytics.scriptUrl}`, "");
   out.push("## Env vars", "", ...c.env.map((e) => `- \`${e.name}\`: ${e.description}`), "");
@@ -2077,6 +2081,145 @@ async function sync4(file, dryRun) {
   printSync(config.project, dryRun, await api(`${base6(config.project)}/rules`, { method: "PUT", body: JSON.stringify(body) }));
 }
 
+// src/realtime.ts
+var realtimeUsage = `  realtime enable <project>      Turn on realtime and print the socket URL and secret
+  realtime info <project>        Settings, connections, and messages in the last 24 hours
+  realtime key <project> [--rotate]  Show (or replace) the secret that signs browser tokens and webhooks
+                                 (rotating closes every open connection)
+  realtime settings <project> [--origins a,b|none] [--public on|off] [--webhook <url>|none]
+                                 [--events message,presence,channel] [--max-connections n]
+                                 [--max-channels n] [--max-message-bytes n] [--max-rate n]
+  realtime channels <project> [--prefix p]   Channels with subscribers right now
+  realtime publish <project> <channel> <event> [json]   Send a message to everyone subscribed
+  realtime disable <project> [--yes]  Turn it off (closes every connection)`;
+var base7 = (project) => `/projects/${encodeURIComponent(project)}/realtime`;
+function printSettings3(s) {
+  console.log(`  socket      ${s.socketUrl}  (connectRealtime in @mybase-dev/sdk/realtime)`);
+  console.log(`  publish     POST ${s.publishUrl}  (realtime:write key)`);
+  console.log(`  secret      ${s.secret}  (server-side only: MYBASE_REALTIME_SECRET)`);
+  console.log(`  public      ${s.publicChannels ? "on: public:\u2026 channels need no token" : "off: every connection needs a token"}`);
+  console.log(`  origins     ${s.allowedOrigins.length ? s.allowedOrigins.join(", ") : "any"}`);
+  console.log(`  webhook     ${s.webhookUrl ? `${s.webhookUrl} (${s.webhookEvents.join(", ") || "no events"})` : "none"}`);
+  console.log(`  limits      ${s.maxConnections} connections, ${s.maxChannels} channels each, ${s.maxMessageBytes} B frames, ${s.maxRate}/s`);
+}
+var list2 = (value) => value === "none" ? [] : value.split(",").map((v) => v.trim()).filter(Boolean);
+function onOff(value, name) {
+  if (value === undefined)
+    return;
+  if (value === "on" || value === "off")
+    return value === "on";
+  throw usageError(`--${name} takes on or off`);
+}
+async function realtime(sub, args) {
+  const { positional, flags } = parseArgs(args);
+  const [project, channel, event, data] = positional;
+  switch (sub) {
+    case "enable": {
+      const p = need(project, "project name");
+      const { linked } = await enableService(p, "realtime", flags);
+      const s = await api(base7(p));
+      print({ enabled: "realtime", project: p, linked, ...s }, () => {
+        console.log(`Realtime enabled for "${p}"
+`);
+        printSettings3(s);
+        printLinked(p, linked, flags);
+      });
+      return true;
+    }
+    case "info": {
+      const p = need(project, "project name");
+      const [s, stats] = await Promise.all([api(base7(p)), api(`${base7(p)}/stats`)]);
+      const { secret: _secret, ...settings } = s;
+      print({ ...settings, stats }, () => {
+        printSettings3({ ...s, secret: "(mybase realtime key)" });
+        const out = stats.hours.reduce((n, h) => n + h.messagesOut, 0);
+        console.log(`
+  now         ${stats.connections} connections (peak ${stats.peakConnections}), ${stats.channels} channels`);
+        console.log(`  24 hours    ${out} messages delivered`);
+        if (stats.webhook.lastError)
+          console.log(`  webhook     failing: ${stats.webhook.lastError} (${stats.webhook.queued} queued, ${stats.webhook.dropped} dropped)`);
+      });
+      return true;
+    }
+    case "key": {
+      const p = need(project, "project name");
+      if (flags.has("rotate"))
+        confirm(args.includes("--yes"), `Every open realtime connection on "${p}" closes, and tokens signed with the old secret stop working.`, p, "the project name");
+      const s = flags.has("rotate") ? await api(`${base7(p)}/secret/rotate`, { method: "POST" }) : await api(base7(p));
+      print({ secret: s.secret }, () => {
+        if (flags.has("rotate"))
+          console.log(`Rotated. Update MYBASE_REALTIME_SECRET where your server signs tokens.
+`);
+        console.log(s.secret);
+      });
+      return true;
+    }
+    case "settings": {
+      const p = need(project, "project name");
+      const body = {};
+      const origins = flagString(flags, "origins");
+      if (origins !== undefined)
+        body.allowedOrigins = list2(origins);
+      const pub = onOff(flagString(flags, "public"), "public");
+      if (pub !== undefined)
+        body.publicChannels = pub;
+      const webhook = flagString(flags, "webhook");
+      if (webhook !== undefined)
+        body.webhookUrl = webhook === "none" ? null : webhook;
+      const events = flagString(flags, "events");
+      if (events !== undefined)
+        body.webhookEvents = list2(events);
+      const ints = { maxConnections: "max-connections", maxChannels: "max-channels", maxMessageBytes: "max-message-bytes", maxRate: "max-rate" };
+      for (const [key, flag] of Object.entries(ints)) {
+        const n = flagInt(flags, flag);
+        if (n !== undefined)
+          body[key] = n;
+      }
+      const s = Object.keys(body).length ? await api(base7(p), { method: "PATCH", body: JSON.stringify(body) }) : await api(base7(p));
+      const { secret: _secret, ...shown } = s;
+      print(shown, () => printSettings3({ ...s, secret: "(mybase realtime key)" }));
+      return true;
+    }
+    case "channels": {
+      const p = need(project, "project name");
+      const prefix = flagString(flags, "prefix");
+      const { channels } = await api(`${base7(p)}/channels${prefix ? `?prefix=${encodeURIComponent(prefix)}` : ""}`);
+      print(channels, () => {
+        if (!channels.length)
+          return console.log("No channels have subscribers right now.");
+        for (const c of channels)
+          console.log(`${c.channel}  ${c.subscribers} subscribers${c.members === undefined ? "" : `, ${c.members} members`}`);
+      });
+      return true;
+    }
+    case "publish": {
+      const p = need(project, "project name");
+      let payload = null;
+      if (data !== undefined) {
+        try {
+          payload = JSON.parse(data);
+        } catch {
+          payload = data;
+        }
+      }
+      const { ids } = await api(`${base7(p)}/publish`, {
+        method: "POST",
+        body: JSON.stringify({ channel: need(channel, "channel"), event: need(event, "event"), data: payload })
+      });
+      print({ id: ids[0] }, () => console.log(`Published ${event} to ${channel}`));
+      return true;
+    }
+    case "disable": {
+      const p = need(project, "project name");
+      confirm(args.includes("--yes"), `Every open realtime connection on "${p}" closes, and pages listening for updates stop getting them.`, p, "the project name");
+      await api(`/projects/${encodeURIComponent(p)}/services/realtime`, { method: "DELETE" });
+      print({ disabled: "realtime", project: p }, () => console.log(`Realtime disabled for "${p}"`));
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/run.ts
 import { constants } from "os";
 
@@ -2113,8 +2256,8 @@ async function target(flags, needEnv = true) {
   }
   return { project, env: env ?? "" };
 }
-var base7 = (project) => `/projects/${encodeURIComponent(project)}/secrets`;
-var envPath = (project, env, rest = "") => `${base7(project)}/envs/${encodeURIComponent(env)}${rest}`;
+var base8 = (project) => `/projects/${encodeURIComponent(project)}/secrets`;
+var envPath = (project, env, rest = "") => `${base8(project)}/envs/${encodeURIComponent(env)}${rest}`;
 var fetchSecrets = (project, env) => api(`/secrets/${encodeURIComponent(project)}/${encodeURIComponent(env)}`);
 var describeEnv = (e) => [e.name, e.parent ? `branch of ${e.parent}` : "root", `${e.keys} keys`, `rev ${e.revision}`, e.linked ? "linked" : ""].filter(Boolean).join("\t");
 async function readStdin() {
@@ -2133,7 +2276,7 @@ async function secrets(sub, args) {
     case "enable": {
       const p = need(positional[0] ?? flagString(flags, "project"), "project name");
       await api(`/projects/${encodeURIComponent(p)}/services/secrets`, { method: "PUT" });
-      const overview = await api(base7(p));
+      const overview = await api(base8(p));
       print({ enabled: "secrets", project: p, ...overview }, () => {
         console.log(`Secrets enabled for "${p}": ${overview.envs.map((e) => e.name).join(", ")}
 `);
@@ -2153,7 +2296,7 @@ async function secrets(sub, args) {
     }
     case "setup": {
       const { project, env } = await target(flags);
-      const overview = await api(base7(project));
+      const overview = await api(base8(project));
       if (!overview.envs.some((e) => e.name === env)) {
         throw usageError(`"${project}" has no env "${env}" (envs: ${overview.envs.map((e) => e.name).join(", ")})`);
       }
@@ -2163,7 +2306,7 @@ async function secrets(sub, args) {
     }
     case "envs": {
       const { project } = await target(flags, false);
-      const overview = await api(base7(project));
+      const overview = await api(base8(project));
       print(overview.envs, () => {
         for (const e of overview.envs)
           console.log(describeEnv(e));
@@ -2174,7 +2317,7 @@ async function secrets(sub, args) {
       const [action, name, next] = positional;
       const { project } = await target(flags, false);
       if (action === "create") {
-        const env = await api(`${base7(project)}/envs`, {
+        const env = await api(`${base8(project)}/envs`, {
           method: "POST",
           body: JSON.stringify({ name: need(name, "env name"), parent: flagString(flags, "from") ?? null })
         });
@@ -2277,7 +2420,7 @@ async function secrets(sub, args) {
       const { project, env } = await target(flags);
       const envs = env.split(",").map((e) => e.trim()).filter(Boolean);
       confirm(yes, `This rotates the credentials of "${project}" (database password, storage key, cache password if the cache is on, and the API key link made before) and stores the new ones, with the other services' keys, in ${envs.join(", ")} plus any env linked before. Apps still using the old credentials will stop working.`, project, "the project name");
-      const result = await api(`${base7(project)}/link`, { method: "POST", body: JSON.stringify({ envs }) });
+      const result = await api(`${base8(project)}/link`, { method: "POST", body: JSON.stringify({ envs }) });
       print(result, () => {
         console.log(`Rotated and stored in ${result.envs.join(", ")}: ${result.keys.join(", ")}`);
         console.log("Restart your apps with `mybase run` to pick them up.");
@@ -2287,7 +2430,7 @@ async function secrets(sub, args) {
     case "unlink": {
       const { project, env } = await target(flags);
       confirm(yes, `This removes the project credentials from "${env}". They stay valid; nothing is rotated.`, env, "the env name");
-      await api(`${base7(project)}/link/${encodeURIComponent(env)}`, { method: "DELETE" });
+      await api(`${base8(project)}/link/${encodeURIComponent(env)}`, { method: "DELETE" });
       print({ unlinked: env, project }, () => console.log(`Removed the credentials from "${env}"`));
       return true;
     }
@@ -3717,6 +3860,110 @@ ${i}
 import { join as join4 } from "path";
 import { styleText as styleText4 } from "util";
 
+// ../../packages/shared/src/logger.ts
+var LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+var isLogLevel = (value) => (value in LEVELS);
+var levelAtLeast = (level, min) => LEVELS[level] >= LEVELS[min];
+var ansi = (code) => (s) => useColor() ? `\x1B[${code}m${s}\x1B[0m` : s;
+var color = {
+  dim: ansi(2),
+  bold: ansi(1),
+  red: ansi(31),
+  green: ansi(32),
+  yellow: ansi(33),
+  blue: ansi(34),
+  magenta: ansi(35),
+  cyan: ansi(36),
+  gray: ansi(90)
+};
+var LEVEL_STYLE = {
+  debug: color.gray,
+  info: color.green,
+  warn: color.yellow,
+  error: color.red
+};
+var SERVICE_COLORS = {
+  api: color.cyan,
+  dashboard: color.magenta,
+  cli: color.blue,
+  cron: color.yellow,
+  analytics: color.green,
+  cache: color.red,
+  ratelimit: color.magenta,
+  queue: color.blue,
+  search: color.cyan,
+  mcp: color.green,
+  docs: color.gray,
+  audit: color.yellow,
+  alerts: color.red,
+  users: color.green,
+  captcha: color.blue,
+  realtime: color.magenta,
+  "db-public": color.cyan,
+  dev: color.gray
+};
+var FALLBACK_COLORS = [color.cyan, color.magenta, color.blue, color.yellow, color.green];
+function serviceColor(service) {
+  const known = SERVICE_COLORS[service];
+  if (known)
+    return known;
+  let hash = 0;
+  for (const ch of service)
+    hash = hash * 31 + ch.charCodeAt(0) >>> 0;
+  return FALLBACK_COLORS[hash % FALLBACK_COLORS.length];
+}
+function useColor() {
+  if (process.env.NO_COLOR)
+    return false;
+  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0")
+    return true;
+  return Boolean(process.stdout.isTTY);
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return /\s|=|"/.test(value) ? JSON.stringify(value) : value;
+  if (value instanceof Error)
+    return JSON.stringify(value.message);
+  return JSON.stringify(value);
+}
+function formatPretty(service, level, msg, fields, at = new Date) {
+  const time = color.dim(at.toISOString().slice(11, 23));
+  const lvl = LEVEL_STYLE[level](level.toUpperCase().padEnd(5));
+  const tag = process.env.MYBASE_LOG_PREFIXED ? "" : `${serviceColor(service)(`[${service}]`)} `;
+  let errorStack = "";
+  const pairs = [];
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined)
+      continue;
+    if (value instanceof Error && value.stack)
+      errorStack = `
+${color.dim(value.stack)}`;
+    pairs.push(`${color.gray(`${key}=`)}${formatValue(value)}`);
+  }
+  return `${time} ${lvl} ${tag}${msg}${pairs.length ? ` ${pairs.join(" ")}` : ""}${errorStack}`;
+}
+function prettyJsonLine(line) {
+  if (!line.startsWith("{"))
+    return null;
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const { time, level, service, msg, ...fields } = entry;
+  if (typeof level !== "string" || !isLogLevel(level) || typeof service !== "string" || typeof msg !== "string")
+    return null;
+  for (const [key, value] of Object.entries(fields)) {
+    const err = value;
+    if (err && typeof err === "object" && typeof err.message === "string" && typeof err.stack === "string") {
+      fields[key] = Object.assign(new Error(err.message), { name: String(err.name ?? "Error"), stack: err.stack });
+    }
+  }
+  const at = typeof time === "string" && !Number.isNaN(Date.parse(time)) ? new Date(time) : new Date;
+  return { level, entry, text: formatPretty(service, level, msg, fields, at) };
+}
+
 // src/server-docker.ts
 import { existsSync, readFileSync } from "fs";
 import { statfs } from "fs/promises";
@@ -4278,6 +4525,35 @@ function tunnelConnections(logs) {
   }
   return [...conns.values()].sort((a, b) => a.index - b.index);
 }
+var LOG_SERVICES = ["mybase", "postgres", "garage", "valkey", "searxng", "cloudflared"];
+var LOG_ALIASES = {
+  api: "mybase",
+  dashboard: "mybase",
+  db: "postgres",
+  database: "postgres",
+  storage: "garage",
+  s3: "garage",
+  cache: "valkey",
+  search: "searxng",
+  tunnel: "cloudflared"
+};
+function logService(name) {
+  const lower = name.toLowerCase();
+  return LOG_SERVICES.includes(lower) ? lower : LOG_ALIASES[lower] ?? null;
+}
+function splitComposeLine(line) {
+  const m = /^([a-z0-9][\w.-]*?)(?:[-_]\d+)?\s+\| ?(.*)$/i.exec(line);
+  return m ? { service: m[1], text: m[2] } : null;
+}
+function guessLevel(text) {
+  if (/\b(ERR|ERROR|FATAL|PANIC|CRIT|CRITICAL)\b|level=(error|fatal)/.test(text))
+    return "error";
+  if (/\b(WRN|WARN|WARNING)\b|level=warn/.test(text))
+    return "warn";
+  if (/\b(DBG|DEBUG)\b|level=debug/.test(text))
+    return "debug";
+  return "info";
+}
 
 // src/server-setup.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
@@ -5070,6 +5346,9 @@ var serverUsage = `  server setup [--dir <dir>]     Install mybase on this machi
   server status [--dir <dir>]    Containers, health, and whether mybase starts on boot
   server update [--dir <dir>]    Download new images and restart (also refreshes compose.yml)
   server restart [--dir <dir>]   Restart every container (API, Postgres, storage, cache, search, tunnel)
+  server logs [<service>\u2026] [--dir <dir>]   Live logs (all services, or api|postgres|storage|cache|search|tunnel)
+    [-f | --no-follow] [--tail <n>|all] [--since <10m|timestamp>] [--level warn] [--raw]
+                                 Follows in a terminal; without one prints the tail and exits
   server tunnel [--dir <dir>]    Add or replace the Cloudflare Tunnel [--tunnel-token <t> --domain <d>] | --off
   server database-public [--dir <dir>]   A normal postgres:// URL from anywhere: router port forward +
                                  Let's Encrypt TLS + DNS kept on your IP (Cloudflare)
@@ -5181,6 +5460,74 @@ ${res.stderr}`);
       console.log(`mybase ${version} is running at ${localUrl(values)}`);
   });
 }
+var LOGS_VALUE_FLAGS = new Set(["--dir", "--tail", "--since", "--level"]);
+async function logs(args) {
+  const dir = await serverDir(args);
+  await loadEnv(dir);
+  if (!await stackExists(dir))
+    throw new CliError("no containers yet. Start them: mybase server update", 4);
+  const services = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (LOGS_VALUE_FLAGS.has(arg))
+      i++;
+    if (arg.startsWith("-"))
+      continue;
+    const service = logService(arg);
+    if (!service)
+      throw usageError(`unknown service "${arg}": one of ${LOG_SERVICES.join(", ")} (or api, db, storage, cache, search, tunnel)`);
+    if (!services.includes(service))
+      services.push(service);
+  }
+  const min = flag(args, "--level") ?? "debug";
+  if (!isLogLevel(min))
+    throw usageError("--level is one of debug, info, warn, error");
+  const tail = flag(args, "--tail") ?? "100";
+  if (tail !== "all" && !/^\d+$/.test(tail))
+    throw usageError("--tail is a number of lines, or all");
+  const since = flag(args, "--since");
+  const follow = args.includes("-f") || args.includes("--follow") || !args.includes("--no-follow") && !jsonMode && process.stdout.isTTY === true;
+  const raw = args.includes("--raw");
+  const cmd = ["docker", "compose", "logs", "--no-color", "--tail", tail, ...since ? ["--since", since] : [], ...follow ? ["--follow"] : [], ...services];
+  const proc = Bun.spawn(cmd, { cwd: dir, stdout: "pipe", stderr: "pipe", env: composeEnv() });
+  const colored = !jsonMode && color.red("x") !== "x";
+  const width = Math.max(...(services.length > 0 ? services : LOG_SERVICES).map((s) => s.length));
+  const show = (line) => {
+    if (!colored)
+      line = line.replace(/\x1b\[[0-9;]*m/g, "");
+    const parts = splitComposeLine(line);
+    if (!parts)
+      return line && console.error(line);
+    const ours = prettyJsonLine(parts.text);
+    const level = ours?.level ?? guessLevel(parts.text);
+    if (!levelAtLeast(level, min))
+      return;
+    if (jsonMode)
+      console.log(JSON.stringify(ours ? { container: parts.service, ...ours.entry } : { container: parts.service, level, line: parts.text }));
+    else if (raw)
+      console.log(line);
+    else
+      console.log(`${serviceColor(parts.service)(parts.service.padEnd(width))} ${color.dim("|")} ${ours?.text ?? parts.text}`);
+  };
+  await Promise.all([eachLine(proc.stdout, show), eachLine(proc.stderr, show)]);
+  if (await proc.exited !== 0)
+    process.exitCode = 1;
+}
+async function eachLine(stream, fn) {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += decoder.decode(chunk, { stream: true });
+    for (let i = buffer.indexOf(`
+`);i !== -1; i = buffer.indexOf(`
+`)) {
+      fn(buffer.slice(0, i).replace(/\r$/, ""));
+      buffer = buffer.slice(i + 1);
+    }
+  }
+  if (buffer)
+    fn(buffer);
+}
 async function tunnel(args) {
   const dir = await serverDir(args);
   const { text, values } = await loadEnv(dir);
@@ -5339,6 +5686,8 @@ async function server(command, args) {
     await update(args);
   else if (command === "restart")
     await restart(args);
+  else if (command === "logs")
+    await logs(args);
   else if (command === "tunnel")
     await tunnel(args);
   else if (command === "database-public")
@@ -5477,7 +5826,7 @@ var usersUsage = `  users enable <project>         Turn on users: an auth schema
   users revoke <project> <user-id> [<session-id>]  Sign a user out (one session, or everywhere)
   users delete <project> <user-id> [--yes]  Delete a user and their sessions
   users disable <project> [--yes]  Turn it off, deleting every user account`;
-var base8 = (project) => `/projects/${encodeURIComponent(project)}/users`;
+var base9 = (project) => `/projects/${encodeURIComponent(project)}/users`;
 function authSnippet(project, apiUrl) {
   return `// auth.ts: npm i better-auth pg @mybase-dev/sdk
 import { betterAuth } from "better-auth";
@@ -5508,7 +5857,7 @@ async function users(sub, args) {
     case "enable": {
       const p = need(project, "project name");
       const { linked } = await enableService(p, "users", flags);
-      const o = await api(base8(p));
+      const o = await api(base9(p));
       print({ enabled: "users", project: p, linked, ...o }, () => {
         console.log(`Users enabled for "${p}". Better Auth's tables go in the "${o.schema}" schema.
 `);
@@ -5522,7 +5871,7 @@ async function users(sub, args) {
     }
     case "init": {
       const p = need(project, "project name");
-      const o = await api(base8(p));
+      const o = await api(base9(p));
       const env = flagString(flags, "env");
       let stored = null;
       if (env) {
@@ -5545,7 +5894,7 @@ Set BETTER_AUTH_SECRET to 32+ random bytes (openssl rand -base64 32), or rerun w
     case "list": {
       const p = need(project, "project name");
       const search = flagString(flags, "search");
-      const list = await api(`${base8(p)}/accounts?limit=100${search ? `&search=${encodeURIComponent(search)}` : ""}`);
+      const list = await api(`${base9(p)}/accounts?limit=100${search ? `&search=${encodeURIComponent(search)}` : ""}`);
       print(list, () => {
         if (list.users.length === 0)
           console.log(search ? "No users match." : "No users yet.");
@@ -5558,7 +5907,7 @@ Set BETTER_AUTH_SECRET to 32+ random bytes (openssl rand -base64 32), or rerun w
     }
     case "show": {
       const p = need(project, "project name");
-      const u = await api(`${base8(p)}/accounts/${encodeURIComponent(need(userId, "user id"))}`);
+      const u = await api(`${base9(p)}/accounts/${encodeURIComponent(need(userId, "user id"))}`);
       print(u, () => {
         console.log(`${u.email ?? u.id}${u.name ? ` (${u.name})` : ""}${u.banned ? "  BANNED" : ""}`);
         console.log(`  id          ${u.id}`);
@@ -5576,10 +5925,10 @@ Active sessions (${u.sessions.length}):`);
       const p = need(project, "project name");
       const id = encodeURIComponent(need(userId, "user id"));
       if (sessionId) {
-        await api(`${base8(p)}/accounts/${id}/sessions/${encodeURIComponent(sessionId)}`, { method: "DELETE" });
+        await api(`${base9(p)}/accounts/${id}/sessions/${encodeURIComponent(sessionId)}`, { method: "DELETE" });
         print({ revoked: 1 }, () => console.log("Signed out that session."));
       } else {
-        const r = await api(`${base8(p)}/accounts/${id}/sessions`, { method: "DELETE" });
+        const r = await api(`${base9(p)}/accounts/${id}/sessions`, { method: "DELETE" });
         print(r, () => console.log(`Signed out ${r.revoked} session(s).`));
       }
       return true;
@@ -5588,7 +5937,7 @@ Active sessions (${u.sessions.length}):`);
       const p = need(project, "project name");
       const id = need(userId, "user id");
       confirm(args.includes("--yes"), `This deletes user ${id} of "${p}" and signs them out.`, id, "the user id");
-      await api(`${base8(p)}/accounts/${encodeURIComponent(id)}`, { method: "DELETE" });
+      await api(`${base9(p)}/accounts/${encodeURIComponent(id)}`, { method: "DELETE" });
       print({ deleted: id }, () => console.log(`Deleted user ${id}`));
       return true;
     }
@@ -5630,6 +5979,7 @@ var USAGE = {
   vector: vectorUsage,
   users: usersUsage,
   captcha: captchaUsage,
+  realtime: realtimeUsage,
   run: runUsage
 };
 var GLOBAL_FLAGS = `  --json                         Print results as JSON (errors too, on stderr)
@@ -5762,6 +6112,10 @@ async function main(args) {
     if (await captcha(sub, rest))
       return;
   }
+  if (command === "realtime" && sub) {
+    if (await realtime(sub, rest))
+      return;
+  }
   if (command && command !== "help")
     throw usageError(`unknown command: mybase ${args.filter((a) => !a.startsWith("-")).slice(0, 2).join(" ")}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mybase-dev/cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "The mybase CLI: projects, keys, cron, queues, cache, rate limits, analytics, docs, and agent setup for a self-hosted mybase.",
   "type": "module",
   "repository": {