@mybase-dev/cli 1.0.6 → 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.6",
+  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";
@@ -4278,6 +4381,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 +5202,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 +5316,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 +5542,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")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mybase-dev/cli",
-  "version": "1.0.6",
+  "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": {