@mybase-dev/cli 1.0.5 → 1.0.7

package/dist/mybase.js

@@ -139,7 +139,7 @@ function parseDotenv(text) {
 // package.json
 var package_default = {
   name: "@mybase-dev/cli",
-  version: "1.0.5",
+  version: "1.0.7",
   description: "The mybase CLI: projects, keys, cron, queues, cache, rate limits, analytics, docs, and agent setup for a self-hosted mybase.",
   type: "module",
   repository: {
@@ -3717,6 +3717,109 @@ ${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,
+  "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";
@@ -3759,6 +3862,7 @@ var compose_default = `# Runs mybase: the control plane (API + dashboard), the s
 #        MYBASE_S3_PUBLIC_URL=https://s3.<domain>
 #        MYBASE_TRUST_PROXY=cloudflare
 #      Optionally POSTGRES_BIND=127.0.0.1, GARAGE_S3_BIND=127.0.0.1, and VALKEY_BIND=127.0.0.1 to stop exposing those ports on the LAN.
+#      Optionally CLOUDFLARED_REGION=us if the tunnel lands on far-away data centers (see \`mybase server status\`).
 #   5. docker compose up -d
 # Apps on serverless hosts reach Postgres at wss://mybase.<domain>/db with @neondatabase/serverless,
 # or, with a router port forward, at a normal postgres:// URL (public Postgres, below).
@@ -3922,6 +4026,11 @@ services:
     command: tunnel --no-autoupdate run
     environment:
       TUNNEL_TOKEN: \${CLOUDFLARE_TUNNEL_TOKEN:-}
+      # Which Cloudflare data centers the tunnel connects to: empty = nearest by anycast, \`us\` = US only
+      # (if \`mybase server status\` shows far-away colos, every request takes the detour).
+      TUNNEL_REGION: \${CLOUDFLARED_REGION:-}
+      # auto (QUIC, falls back to HTTP/2), quic, or http2 (if your network blocks or throttles UDP).
+      TUNNEL_TRANSPORT_PROTOCOL: \${CLOUDFLARED_PROTOCOL:-auto}
     depends_on:
       - mybase
 
@@ -4253,6 +4362,54 @@ async function enableDockerOnBoot() {
     return false;
   }
 }
+function tunnelConnections(logs) {
+  const conns = new Map;
+  for (const line of logs.split(`
+`)) {
+    if (/Starting tunnel/.test(line))
+      conns.clear();
+    const index = Number(/connIndex=(\d+)/.exec(line)?.[1]);
+    if (Number.isNaN(index))
+      continue;
+    if (/Registered tunnel connection/.test(line)) {
+      const location = /location=(\S+)/.exec(line)?.[1];
+      if (location)
+        conns.set(index, { index, location, protocol: /protocol=(\S+)/.exec(line)?.[1] ?? null });
+    } else if (/Unregistered tunnel connection|Connection terminated|Retrying connection|Serve tunnel error/.test(line)) {
+      conns.delete(index);
+    }
+  }
+  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";
@@ -5044,6 +5201,10 @@ var serverUsage = `  server setup [--dir <dir>]     Install mybase on this machi
     [--admin-user <u> --admin-password-stdin]   Without a terminal: defaults plus these flags
   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)
@@ -5076,6 +5237,10 @@ async function status(args) {
   const health = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3000) }).then(async (r) => r.ok ? (await r.json()).version ?? "unknown" : null).catch(() => null);
   const autostart = values.MYBASE_RESTART !== "no";
   const docker = dockerOnBoot();
+  const tunnelOn = !!values.CLOUDFLARE_TUNNEL_TOKEN && containers.some((c) => c.Service === "cloudflared");
+  const tunnelLogs = tunnelOn ? await compose(dir, ["logs", "--no-log-prefix", "--tail", "500", "cloudflared"]) : null;
+  const tunnel = tunnelLogs?.ok ? tunnelConnections(`${tunnelLogs.stdout}
+${tunnelLogs.stderr}`) : null;
   const data = {
     dir,
     url,
@@ -5084,6 +5249,7 @@ async function status(args) {
     autostart: autostart && docker !== "disabled",
     dockerOnBoot: docker,
     publicUrl: values.CLOUDFLARE_TUNNEL_TOKEN ? values.MYBASE_PUBLIC_URL ?? null : null,
+    tunnel,
     containers: containers.map((c) => ({ service: c.Service, state: c.State, health: c.Health || null }))
   };
   print(data, () => {
@@ -5091,6 +5257,10 @@ async function status(args) {
     console.log(`  ${health ? green("\u25CF") : red("\u25CF")} ${url}  ${health ? `version ${health}` : "not answering"}`);
     if (data.publicUrl)
       console.log(`  ${dim2("public")}  ${data.publicUrl}`);
+    if (tunnel) {
+      const where = tunnel.map((c) => `${c.location}${c.protocol ? ` ${c.protocol}` : ""}`).join(", ");
+      console.log(`  ${tunnel.length > 0 ? green("\u25CF") : red("\u25CF")} ${dim2("tunnel")}  ${tunnel.length > 0 ? `${tunnel.length} connection(s): ${where}` : "not connected to Cloudflare (public URL answers 530)"}`);
+    }
     console.log(`  ${dim2("starts on boot")}  ${!autostart ? "no (mybase server autostart on)" : docker === "disabled" ? "no: Docker doesn't start at boot (sudo systemctl enable docker)" : "yes"}`);
     console.log("");
     if (containers.length === 0)
@@ -5121,6 +5291,99 @@ async function update(args) {
     return print({ dir, version, composeUpdated: replaced }, () => {});
   outro(`mybase ${version} is running at ${localUrl(values)}`);
 }
+async function restart(args) {
+  const dir = await serverDir(args);
+  const { values } = await loadEnv(dir);
+  if (!await stackExists(dir))
+    throw new CliError("no containers to restart. Start them: mybase server update", 4);
+  const s = ui.spinner();
+  s.start("Restarting containers");
+  const res = await compose(dir, ["restart"]);
+  if (!res.ok) {
+    s.stop("Restart failed");
+    throw new CliError(`docker compose restart failed:
+${res.stderr}`);
+  }
+  s.message("Waiting for mybase to answer");
+  const version = await waitHealthy(localUrl(values), 120000);
+  s.stop(version ? "Restarted" : "Containers restarted");
+  if (!version) {
+    ui.warn("mybase didn't answer yet; check `mybase server status`.");
+    process.exitCode = 1;
+  }
+  print({ dir, healthy: version !== null, version }, () => {
+    if (version)
+      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);
@@ -5277,6 +5540,10 @@ async function server(command, args) {
     await status(args);
   else if (command === "update")
     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")

package/package.json

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