@motherbase/cli 0.2.1

package/src/context.js

@@ -0,0 +1,102 @@
+'use strict';
+
+// Resolve the runtime context: which console, which token, which project, and
+// whether we talk through the Console proxy ('console' mode) or straight at a
+// single project API ('direct' mode). Precedence everywhere: flags > env > config.
+//
+// Resolution is LAZY: building a context never throws, so commands that need no
+// project (login, local docker, init) work with zero configuration. The
+// require*() helpers throw a clear, actionable error only when a value is
+// actually needed and missing.
+
+const config = require('./config');
+
+class CliError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CliError';
+    this.isCliError = true;
+  }
+}
+
+function firstDefined(...vals) {
+  for (const v of vals) if (v !== undefined && v !== null && v !== '') return v;
+  return undefined;
+}
+
+function createContext(flags = {}, env = process.env, cwd = process.cwd()) {
+  const link = config.readLink(cwd) || {};
+  const global = config.readGlobal();
+
+  const consoleUrl = firstDefined(
+    flags.url,
+    env.MOTHERBASE_CONSOLE_URL,
+    link.consoleUrl,
+    global.current,
+  );
+  const normConsoleUrl = consoleUrl ? config.normalizeUrl(consoleUrl) : undefined;
+
+  const token = firstDefined(
+    flags.token,
+    env.MOTHERBASE_TOKEN,
+    normConsoleUrl ? (config.consoleEntry(normConsoleUrl) || {}).token : undefined,
+  );
+
+  const projectId = firstDefined(flags.project, env.MOTHERBASE_PROJECT, link.projectId);
+  const projectName = firstDefined(link.projectName, projectId);
+
+  // Direct project mode: an admin JWT pointed straight at one project API. Only
+  // used as a fallback when there is no console link/flags to route through.
+  const directUrl = env.MOTHERBASE_URL ? config.normalizeUrl(env.MOTHERBASE_URL) : undefined;
+  const directToken = env.MOTHERBASE_ADMIN_TOKEN;
+  const hasConsole = Boolean(normConsoleUrl && token);
+  const hasProjectLink = Boolean(projectId);
+  const preferDirect = Boolean(directUrl && directToken) && !(hasConsole && hasProjectLink);
+  const mode = preferDirect ? 'direct' : 'console';
+
+  return {
+    flags,
+    env,
+    cwd,
+    mode,
+    consoleUrl: normConsoleUrl,
+    token,
+    projectId,
+    projectName,
+    directUrl,
+    directToken,
+    linkedConsoleUrl: link.consoleUrl,
+    accountEmail: normConsoleUrl ? (config.consoleEntry(normConsoleUrl) || {}).email : undefined,
+
+    // Console (account / multi-project) requests need URL + session token.
+    requireConsole() {
+      if (!this.consoleUrl) {
+        throw new CliError('No console URL. Run `motherbase login --url <consoleUrl>` or set MOTHERBASE_CONSOLE_URL.');
+      }
+      if (!this.token) {
+        throw new CliError('Not logged in. Run `motherbase login` or set MOTHERBASE_TOKEN.');
+      }
+      return { consoleUrl: this.consoleUrl, token: this.token };
+    },
+
+    // Admin/resource requests: resolve either the console proxy path or a direct
+    // project API, whichever the context selected.
+    requireProject() {
+      if (this.mode === 'direct') {
+        return { mode: 'direct', baseUrl: this.directUrl, token: this.directToken };
+      }
+      this.requireConsole();
+      if (!this.projectId) {
+        throw new CliError('No project linked. Run `motherbase link` or set MOTHERBASE_PROJECT (or use direct mode via MOTHERBASE_URL + MOTHERBASE_ADMIN_TOKEN).');
+      }
+      return {
+        mode: 'console',
+        consoleUrl: this.consoleUrl,
+        token: this.token,
+        projectId: this.projectId,
+      };
+    },
+  };
+}
+
+module.exports = { createContext, CliError };

package/src/main.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const path = require('path');
+const { registry, groups } = require('./commands');
+const { createContext, CliError } = require('./context');
+const ui = require('./ui');
+
+// Flags that never consume a following value.
+const PURE_BOOLEAN = new Set([
+  'json', 'yes', 'help', 'version', 'force', 'preview', 'app', 'no-data', 'no-auth', 'f',
+]);
+// Short flag aliases → canonical (with whether they take a value).
+const SHORT = {
+  y: { name: 'yes', boolean: true },
+  h: { name: 'help', boolean: true },
+  v: { name: 'version', boolean: true },
+  p: { name: 'project', boolean: false },
+  u: { name: 'url', boolean: false },
+  e: { name: 'e', boolean: false },
+  f: { name: 'f', boolean: true },
+};
+
+// Tokenize argv into positionals + flags. Repeated flags collapse into arrays.
+function tokenize(argv) {
+  const positionals = [];
+  const flags = {};
+  const setFlag = (key, value) => {
+    if (key in flags) {
+      flags[key] = [].concat(flags[key], value);
+    } else {
+      flags[key] = value;
+    }
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === '--') { positionals.push(...argv.slice(i + 1)); break; }
+
+    if (tok.startsWith('--')) {
+      const body = tok.slice(2);
+      const eq = body.indexOf('=');
+      if (eq >= 0) { setFlag(body.slice(0, eq), body.slice(eq + 1)); continue; }
+      const next = argv[i + 1];
+      if (!PURE_BOOLEAN.has(body) && next !== undefined && !next.startsWith('-')) {
+        setFlag(body, next); i++;
+      } else {
+        setFlag(body, true);
+      }
+    } else if (tok.startsWith('-') && tok.length > 1 && tok !== '-') {
+      const spec = SHORT[tok.slice(1)];
+      if (!spec) { setFlag(tok.slice(1), true); continue; }
+      const next = argv[i + 1];
+      if (!spec.boolean && next !== undefined && !next.startsWith('-')) { setFlag(spec.name, next); i++; }
+      else setFlag(spec.name, true);
+    } else {
+      positionals.push(tok);
+    }
+  }
+  return { positionals, flags };
+}
+
+function version() {
+  try {
+    return require(path.join(__dirname, '..', 'package.json')).version;
+  } catch { return '0.0.0'; }
+}
+
+function pad(s, n) { return String(s).padEnd(n); }
+
+function topLevelHelp() {
+  ui.print(ui.color.bold('Motherbase CLI') + ` v${version()}`);
+  ui.print('');
+  ui.print('Usage: motherbase <command> [subcommand] [args] [flags]');
+  ui.print('');
+  const width = Object.keys(registry).reduce((m, k) => Math.max(m, k.length), 0) + 2;
+  for (const group of groups) {
+    ui.print(ui.color.bold(group.title));
+    for (const name of group.names) {
+      const entry = registry[name];
+      if (!entry) continue;
+      ui.print('  ' + ui.color.cyan(pad(name, width)) + ui.color.dim(entry.summary || ''));
+    }
+    ui.print('');
+  }
+  ui.print('Global flags: --json  --yes/-y  --project/-p <id>  --url/-u <consoleUrl>  --token <t>  -h/--help  -v/--version');
+  ui.print('Run `motherbase <command> -h` for command-specific help.');
+}
+
+function commandHelp(name, entry, trail) {
+  const full = ['motherbase', ...trail].join(' ');
+  ui.print(ui.color.bold(full) + (entry.summary ? ` — ${entry.summary}` : ''));
+  ui.print('');
+  if (entry.usage) { ui.print('Usage: ' + entry.usage); ui.print(''); }
+  if (entry.subcommands) {
+    ui.print(ui.color.bold('Subcommands'));
+    const subs = Object.keys(entry.subcommands);
+    const width = subs.reduce((m, k) => Math.max(m, k.length), 0) + 2;
+    for (const sub of subs) {
+      const s = entry.subcommands[sub];
+      ui.print('  ' + ui.color.cyan(pad(sub, width)) + ui.color.dim(s.summary || ''));
+    }
+  }
+}
+
+async function main(argv) {
+  const { positionals, flags } = tokenize(argv);
+
+  if (flags.version) { ui.print(version()); return 0; }
+
+  if (positionals.length === 0) { topLevelHelp(); return 0; }
+
+  const name = positionals[0];
+  const entry = registry[name];
+  if (!entry) {
+    ui.printErr(ui.color.red(`Unknown command: ${name}`));
+    ui.printErr('Run `motherbase --help` to see available commands.');
+    return 1;
+  }
+
+  // Descend into subcommands.
+  let current = entry;
+  const trail = [name];
+  const rest = positionals.slice(1);
+  while (current.subcommands && rest.length && current.subcommands[rest[0]]) {
+    current = current.subcommands[rest[0]];
+    trail.push(rest.shift());
+  }
+
+  // Help requested, or a group with no runnable action here.
+  if (flags.help || (!current.run && !current.subcommands)) {
+    commandHelp(name, current, trail);
+    return 0;
+  }
+  if (!current.run) {
+    // Group node: either no subcommand given or an unknown one.
+    if (rest.length) ui.printErr(ui.color.red(`Unknown subcommand: ${trail.join(' ')} ${rest[0]}`));
+    commandHelp(name, current, trail);
+    return rest.length ? 1 : 0;
+  }
+
+  const ctx = createContext(flags);
+  try {
+    await current.run(ctx, rest, flags);
+    return 0;
+  } catch (err) {
+    if (err instanceof CliError || err.isCliError) {
+      ui.printErr(ui.color.red(err.message));
+    } else {
+      ui.printErr(ui.color.red(`Error: ${err.message}`));
+    }
+    return 1;
+  }
+}
+
+module.exports = { main, tokenize, version };

package/src/prompt.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// readline-based prompting, including hidden password entry. Built-ins only.
+
+const readline = require('readline');
+
+function question(query) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(query, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Hidden input: we mute the output stream by intercepting writes so the typed
+// characters (and the password) never echo.
+function password(query = 'Password: ') {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const onData = () => {
+      // Overwrite whatever readline just echoed with the prompt only.
+      process.stdout.write(`\r${query}`);
+    };
+    process.stdout.write(query);
+    process.stdin.on('data', onData);
+    rl.question('', answer => {
+      process.stdin.removeListener('data', onData);
+      rl.close();
+      process.stdout.write('\n');
+      resolve(answer);
+    });
+  });
+}
+
+async function confirm(query, defaultYes = false) {
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  const answer = (await question(query + suffix)).toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === 'y' || answer === 'yes';
+}
+
+module.exports = { question, password, confirm };

package/src/ui.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// Minimal, dependency-free presentation helpers: ANSI colour (auto-off when not a
+// TTY or NO_COLOR is set), a table printer, a key/value printer, a spinner, and a
+// --json passthrough.
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+function wrap(code) {
+  return s => (useColor ? `[${code}m${s}` : String(s));
+}
+
+const color = {
+  bold: wrap('1'),
+  dim: wrap('2'),
+  red: wrap('31'),
+  green: wrap('32'),
+  yellow: wrap('33'),
+  cyan: wrap('36'),
+  gray: wrap('90'),
+};
+
+function print(msg = '') {
+  process.stdout.write(msg + '\n');
+}
+
+function printErr(msg = '') {
+  process.stderr.write(msg + '\n');
+}
+
+function success(msg) {
+  print(color.green('✓ ') + msg);
+}
+
+function info(msg) {
+  print(color.cyan('• ') + msg);
+}
+
+function warn(msg) {
+  printErr(color.yellow('! ') + msg);
+}
+
+function json(value) {
+  print(JSON.stringify(value, null, 2));
+}
+
+// Render an array of flat objects as an aligned table using the given columns
+// (array of keys or { key, label } specs). Falls back to a friendly note if empty.
+function table(rows, columns) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    print(color.dim('(no rows)'));
+    return;
+  }
+  const cols = (columns || Object.keys(rows[0])).map(c =>
+    typeof c === 'string' ? { key: c, label: c } : c,
+  );
+  const widths = cols.map(c => c.label.length);
+  const cells = rows.map(row =>
+    cols.map((c, i) => {
+      const v = row[c.key];
+      const s = v === undefined || v === null ? '' : String(v);
+      if (s.length > widths[i]) widths[i] = s.length;
+      return s;
+    }),
+  );
+  const header = cols.map((c, i) => color.bold(c.label.padEnd(widths[i]))).join('  ');
+  print(header);
+  print(color.dim(cols.map((_, i) => '-'.repeat(widths[i])).join('  ')));
+  for (const rowCells of cells) {
+    print(rowCells.map((s, i) => s.padEnd(widths[i])).join('  '));
+  }
+}
+
+// Print a { key: value } object as aligned "key : value" lines.
+function keyValue(obj) {
+  if (!obj || typeof obj !== 'object') {
+    print(String(obj));
+    return;
+  }
+  const keys = Object.keys(obj);
+  const w = keys.reduce((m, k) => Math.max(m, k.length), 0);
+  for (const k of keys) {
+    let v = obj[k];
+    if (v && typeof v === 'object') v = JSON.stringify(v);
+    print(`${color.gray(k.padEnd(w))}  ${v === undefined || v === null ? '' : v}`);
+  }
+}
+
+// A tiny spinner. No-op (single status line) when stderr is not a TTY.
+function spinner(text) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  if (!process.stderr.isTTY) {
+    printErr(color.dim(text + ' ...'));
+    return { stop() {}, succeed() {}, fail() {} };
+  }
+  let i = 0;
+  const timer = setInterval(() => {
+    process.stderr.write(`\r${color.cyan(frames[i++ % frames.length])} ${text}`);
+  }, 80);
+  const clear = () => {
+    clearInterval(timer);
+    process.stderr.write('\r');
+  };
+  return {
+    stop: clear,
+    succeed(msg) { clear(); if (msg) printErr(color.green('✓ ') + msg); },
+    fail(msg) { clear(); if (msg) printErr(color.red('✗ ') + msg); },
+  };
+}
+
+module.exports = { color, print, printErr, success, info, warn, json, table, keyValue, spinner };