@motherbase/cli 0.2.1

package/src/commands/functions.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const api = require('../api');
+const ui = require('../ui');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const subcommands = {
+  list: {
+    summary: 'List edge functions',
+    usage: 'motherbase functions list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/edge-functions');
+      const rows = (data && data.functions) || [];
+      output(ctx, data, (_d, u) =>
+        u.table(rows, [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'route', label: 'ROUTE' },
+          { key: 'enabled', label: 'ENABLED' },
+        ]),
+      );
+    },
+  },
+  get: {
+    summary: 'Get an edge function by id',
+    usage: 'motherbase functions get <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/edge-functions/${id}`);
+      output(ctx, data, (d, u) => u.keyValue((d && d.function) || d || {}));
+    },
+  },
+  new: {
+    summary: 'Scaffold a local edge function file',
+    usage: 'motherbase functions new <name>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'name');
+      const dir = path.join(ctx.cwd, 'motherbase', 'functions');
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(dir, `${name}.js`);
+      fs.writeFileSync(file, `// Edge function: ${name}\n// The resolved value of this expression becomes the response body.\nasync () => {\n  return { hello: '${name}', at: new Date().toISOString() };\n}\n`);
+      ui.success(`Created ${path.relative(ctx.cwd, file)}`);
+    },
+  },
+  deploy: {
+    summary: 'Create or update an edge function (upsert by route)',
+    usage: 'motherbase functions deploy --name <n> --route <r> --file <f.js>',
+    async run(ctx, args, flags) {
+      const route = flags.route || args[0];
+      const file = flags.file || args[1];
+      const name = flags.name || route;
+      if (!route) throw new CliError('--route is required');
+      if (!file) throw new CliError('--file <f.js> is required');
+      const code = fs.readFileSync(path.resolve(ctx.cwd, file), 'utf8');
+
+      // Upsert: PATCH the existing function when a matching route is present.
+      const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
+      const existing = ((listing && listing.functions) || []).find(f => f.route === route);
+      let data;
+      if (existing) {
+        data = await api.adminRequest(ctx, 'PATCH', `/edge-functions/${existing.id}`, { body: { name, route, code } });
+      } else {
+        data = await api.adminRequest(ctx, 'POST', '/edge-functions', { body: { name, route, code, enabled: true } });
+      }
+      output(ctx, data, (d, u) => u.success(`Deployed function ${name} (${route})`));
+    },
+  },
+  delete: {
+    summary: 'Delete an edge function by id',
+    usage: 'motherbase functions delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/edge-functions/${id}`);
+      output(ctx, data, (d, u) => u.success(`Deleted function ${id}`));
+    },
+  },
+  invoke: {
+    summary: 'Invoke an edge function by route',
+    usage: 'motherbase functions invoke <route> [--body <json>]',
+    async run(ctx, args, flags) {
+      const route = requireArg(args[0], 'route');
+      let body = {};
+      if (flags.body) {
+        try { body = JSON.parse(flags.body); } catch { throw new CliError('--body must be valid JSON'); }
+      }
+      const data = await api.edgeInvokeRequest(ctx, route, body);
+      output(ctx, data, (d, u) => u.json(d));
+    },
+  },
+  logs: {
+    summary: 'Show logs for an edge function',
+    usage: 'motherbase functions logs <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/edge-functions/${id}/logs`);
+      output(ctx, data, (d, u) => {
+        const logs = (d && d.logs) || d || [];
+        if (Array.isArray(logs)) logs.forEach(l => u.print(typeof l === 'string' ? l : JSON.stringify(l)));
+        else u.json(d);
+      });
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Edge functions (list/deploy/invoke/logs)',
+  usage: 'motherbase functions <list|get|new|deploy|delete|invoke|logs> ...',
+  subcommands,
+};

package/src/commands/import.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const api = require('../api');
+const prompt = require('../prompt');
+const { output } = require('./_util');
+const { CliError } = require('../context');
+
+module.exports = {
+  summary: 'Import a Supabase project (schema + data + auth) into the linked project',
+  usage: 'motherbase import --from-supabase <connectionString> [--preview] [--no-data] [--no-auth]',
+  async run(ctx, args, flags) {
+    const connectionString = flags['from-supabase'] || flags.fromSupabase;
+    if (!connectionString) throw new CliError('--from-supabase <connectionString> is required');
+
+    const include = { schema: true, data: !flags['no-data'], auth: !flags['no-auth'] };
+    const preview = Boolean(flags.preview);
+
+    const body = { connectionString, include };
+    if (preview) {
+      body.preview = true;
+    } else {
+      if (!flags.yes) {
+        const ok = await prompt.confirm('This will import into the linked project. Continue?');
+        if (!ok) throw new CliError('Aborted.');
+      }
+      body.confirm = 'IMPORT';
+    }
+
+    const data = await api.adminRequest(ctx, 'POST', '/import/supabase', { body });
+    output(ctx, data, (d, ui) => {
+      if (preview) { ui.info('Import preview (dry run):'); ui.json(d); }
+      else { ui.success('Import complete'); ui.json(d); }
+    });
+  },
+};

package/src/commands/index.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// Command registry: name -> { summary, usage, subcommands?, run? }.
+// `main.js` builds all help/dispatch from this single map.
+
+const local = require('./local');
+
+const registry = {
+  // ── Connection ─────────────────────────────────────────────────────────────
+  login: require('./login'),
+  logout: require('./logout'),
+  whoami: require('./whoami'),
+  link: require('./link'),
+  unlink: require('./unlink'),
+  status: require('./status'),
+
+  // ── Projects (Platform Console) ────────────────────────────────────────────
+  projects: require('./projects'),
+
+  // ── Local self-host (docker compose) ───────────────────────────────────────
+  init: local.init,
+  start: local.start,
+  stop: local.stop,
+  deploy: local.deploy,
+  logs: local.logs,
+
+  // ── Database / migrations / import ─────────────────────────────────────────
+  db: require('./db'),
+  migrations: require('./migrations'),
+  migration: require('./migration'),
+  import: require('./import'),
+
+  // ── Resource domains ───────────────────────────────────────────────────────
+  rls: require('./rls'),
+  users: require('./users'),
+  storage: require('./storage'),
+  functions: require('./functions'),
+  secrets: require('./secrets'),
+  realtime: require('./realtime'),
+  webhooks: require('./webhooks'),
+  cron: require('./cron'),
+  config: require('./config'),
+  inspect: require('./inspect'),
+};
+
+// Grouping used only to render a tidy top-level help listing.
+const groups = [
+  { title: 'Connection', names: ['login', 'logout', 'whoami', 'link', 'unlink', 'status'] },
+  { title: 'Projects (Console)', names: ['projects'] },
+  { title: 'Local self-host', names: ['init', 'start', 'stop', 'deploy', 'logs'] },
+  { title: 'Database', names: ['db', 'migrations', 'migration', 'import'] },
+  { title: 'Resources', names: ['rls', 'users', 'storage', 'functions', 'secrets', 'realtime', 'webhooks', 'cron', 'config', 'inspect'] },
+];
+
+module.exports = { registry, groups };

package/src/commands/inspect.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const api = require('../api');
+const { output } = require('./_util');
+
+function simple(apiPath, summary, render) {
+  return {
+    summary,
+    usage: `motherbase inspect ${summary.split(' ')[0].toLowerCase()}`,
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', apiPath);
+      output(ctx, data, render || ((d, ui) => ui.json(d)));
+    },
+  };
+}
+
+const subcommands = {
+  logs: {
+    summary: 'Recent server logs',
+    usage: 'motherbase inspect logs [--limit n]',
+    async run(ctx, args, flags) {
+      const query = flags.limit ? { limit: flags.limit } : undefined;
+      const data = await api.adminRequest(ctx, 'GET', '/logs', { query });
+      const logs = (data && data.logs) || [];
+      output(ctx, data, (_d, ui) =>
+        logs.forEach(l => ui.print(typeof l === 'string' ? l : `${l.level || ''} ${l.source || ''} ${l.message || JSON.stringify(l)}`)),
+      );
+    },
+  },
+  stats: simple('/stats', 'Stats overview'),
+  performance: simple('/performance', 'Performance metrics'),
+  requests: simple('/metrics/requests', 'Request metrics'),
+  advisor: simple('/advisor', 'Advisor findings'),
+  shield: simple('/shield', 'Security shield report'),
+};
+
+module.exports = {
+  summary: 'Diagnostics: logs, stats, performance, advisor, shield',
+  usage: 'motherbase inspect <logs|stats|performance|requests|advisor|shield>',
+  subcommands,
+};

package/src/commands/link.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const api = require('../api');
+const config = require('../config');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const { CliError } = require('../context');
+
+module.exports = {
+  summary: 'Link the current directory to a project (writes ./.motherbase/config.json)',
+  usage: 'motherbase link [projectNameOrId]',
+  async run(ctx, args, flags) {
+    const { consoleUrl } = ctx.requireConsole();
+    const projects = await api.consoleRequest(ctx, 'GET', '/projects');
+    const list = Array.isArray(projects) ? projects : [];
+    if (list.length === 0) throw new CliError('No projects available on this console.');
+
+    let picked = args[0];
+    if (!picked) {
+      if (flags.yes) throw new CliError('Specify a project name/id when using --yes.');
+      ui.print(ui.color.bold('Available projects:'));
+      list.forEach((p, i) => ui.print(`  ${i + 1}. ${p.name || p.id}`));
+      const answer = await prompt.question('Pick a project (number or name): ');
+      const asNum = Number(answer);
+      picked = Number.isInteger(asNum) && list[asNum - 1] ? (list[asNum - 1].name || list[asNum - 1].id) : answer;
+    }
+
+    const match = list.find(p => p.name === picked || p.id === picked);
+    if (!match) throw new CliError(`Project "${picked}" not found on ${consoleUrl}.`);
+
+    const projectId = match.name || match.id;
+    config.writeLink(ctx.cwd, { consoleUrl, projectId, projectName: match.name || projectId });
+    ui.success(`Linked ${ctx.cwd} → ${projectId} (${consoleUrl})`);
+  },
+};

package/src/commands/local.js

@@ -0,0 +1,64 @@
+'use strict';
+
+// Local self-host workflow: thin wrappers over `docker compose`, plus `init`
+// scaffolding. No HTTP, no context resolution required. Ported and extended from
+// the original single-file CLI.
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const ui = require('../ui');
+const { CliError } = require('../context');
+
+function dockerCompose(composeArgs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('docker', ['compose', ...composeArgs], { stdio: 'inherit', windowsHide: true });
+    child.on('error', err => reject(new CliError(`failed to run docker: ${err.message}`)));
+    child.on('close', code => (code === 0 ? resolve() : reject(new CliError(`docker compose exited with code ${code}`))));
+  });
+}
+
+const init = {
+  summary: 'Scaffold a local project directory with a .env',
+  usage: 'motherbase init [dir]',
+  async run(ctx, args) {
+    const dir = args[0] || '.';
+    const target = path.resolve(ctx.cwd, dir);
+    fs.mkdirSync(target, { recursive: true });
+    const envPath = path.join(target, '.env');
+    if (!fs.existsSync(envPath)) {
+      const example = path.join(ctx.cwd, '.env.example');
+      const template = fs.existsSync(example)
+        ? fs.readFileSync(example, 'utf8')
+        : 'PORT=5001\nDATABASE_URL=postgresql://postgres:postgres@localhost:5432/app?schema=public\nJWT_SECRET=change-me\n';
+      fs.writeFileSync(envPath, template);
+    }
+    ui.success(`Initialized Motherbase project at ${target}`);
+  },
+};
+
+const start = {
+  summary: 'Start the local docker compose stack',
+  usage: 'motherbase start',
+  async run() { await dockerCompose(['up', '-d']); },
+};
+
+const stop = {
+  summary: 'Stop the local docker compose stack',
+  usage: 'motherbase stop',
+  async run() { await dockerCompose(['down']); },
+};
+
+const deploy = {
+  summary: 'Rebuild and start the local docker compose stack',
+  usage: 'motherbase deploy',
+  async run() { await dockerCompose(['up', '-d', '--build']); },
+};
+
+const logs = {
+  summary: 'Follow logs from the local docker compose stack',
+  usage: 'motherbase logs [service...]',
+  async run(ctx, args) { await dockerCompose(['logs', '-f', ...args]); },
+};
+
+module.exports = { init, start, stop, deploy, logs };

package/src/commands/login.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const api = require('../api');
+const config = require('../config');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const { CliError } = require('../context');
+
+module.exports = {
+  summary: 'Log in to a Motherbase Console (email/password → session token)',
+  usage: 'motherbase login [--url <consoleUrl>] [--email <email>]',
+  async run(ctx, args, flags) {
+    const consoleUrl = config.normalizeUrl(
+      flags.url || ctx.env.MOTHERBASE_CONSOLE_URL || ctx.consoleUrl || '',
+    );
+    if (!consoleUrl) {
+      throw new CliError('Console URL required. Use --url <consoleUrl> or set MOTHERBASE_CONSOLE_URL.');
+    }
+
+    // Non-interactive: accept a token directly (CI).
+    if (flags.token) {
+      const email = flags.email || 'token';
+      config.saveConsoleToken(consoleUrl, flags.token, email);
+      ui.success(`Stored token for ${consoleUrl}`);
+      return;
+    }
+
+    const email = flags.email || (await prompt.question('Email: '));
+    if (!email) throw new CliError('email is required');
+    const password = flags.password || (await prompt.password('Password: '));
+    if (!password) throw new CliError('password is required');
+
+    const data = await api.loginRequest(consoleUrl, email, password);
+    const token = data && data.token;
+    if (!token) throw new CliError('login succeeded but no token was returned');
+    config.saveConsoleToken(consoleUrl, token, email);
+    ui.success(`Logged in to ${consoleUrl} as ${email}`);
+  },
+};

package/src/commands/logout.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const { CliError } = require('../context');
+
+module.exports = {
+  summary: 'Remove the stored token for the current (or --url) console',
+  usage: 'motherbase logout [--url <consoleUrl>]',
+  async run(ctx) {
+    const url = config.normalizeUrl(ctx.flags.url || ctx.consoleUrl || '');
+    if (!url) throw new CliError('No console to log out of.');
+    config.clearConsoleToken(url);
+    ui.success(`Logged out of ${url}`);
+  },
+};

package/src/commands/migration.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// `migration new <name>` — local scaffold only. The real migration lifecycle
+// (list/apply/rollback) lives under the `migrations` group and hits the server.
+
+const fs = require('fs');
+const path = require('path');
+const ui = require('../ui');
+const { requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const subcommands = {
+  new: {
+    summary: 'Scaffold a local migration .sql file',
+    usage: 'motherbase migration new <name>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'name');
+      if (!/^[a-zA-Z0-9_-]+$/.test(name)) throw new CliError('name must be alphanumeric / dash / underscore');
+      const dir = path.join(ctx.cwd, 'motherbase', 'migrations');
+      fs.mkdirSync(dir, { recursive: true });
+      const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '');
+      const file = path.join(dir, `${stamp}_${name}.sql`);
+      fs.writeFileSync(file, `-- Migration: ${name}\n-- Up\n\n\n-- Down (optional; keep in a separate file for \`migrations create --down\`)\n`);
+      ui.success(`Created ${path.relative(ctx.cwd, file)}`);
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Scaffold local migration files',
+  usage: 'motherbase migration new <name>',
+  subcommands,
+};

package/src/commands/migrations.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+function readSql(cwd, file) {
+  if (!file) return undefined;
+  return fs.readFileSync(path.resolve(cwd, file), 'utf8');
+}
+
+const subcommands = {
+  list: {
+    summary: 'List schema migrations',
+    usage: 'motherbase migrations list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/migrations');
+      const rows = (data && data.migrations) || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(rows, [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'status', label: 'STATUS' },
+          { key: 'appliedAt', label: 'APPLIED' },
+        ]),
+      );
+    },
+  },
+  diff: {
+    summary: 'Show a diff between live schema and migrations',
+    usage: 'motherbase migrations diff',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/migrations/diff');
+      output(ctx, data, (d, ui) => ui.json(d));
+    },
+  },
+  get: {
+    summary: 'Show a single migration',
+    usage: 'motherbase migrations get <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/migrations/${id}`);
+      output(ctx, data, (d, ui) => ui.keyValue((d && d.migration) || d || {}));
+    },
+  },
+  create: {
+    summary: 'Create a migration from up/down SQL files',
+    usage: 'motherbase migrations create --name <name> --up <file.sql> [--down <file.sql>]',
+    async run(ctx, args, flags) {
+      const name = flags.name || args[0];
+      if (!name) throw new CliError('--name is required');
+      const upSql = readSql(ctx.cwd, flags.up);
+      const downSql = readSql(ctx.cwd, flags.down);
+      if (!upSql) throw new CliError('--up <file.sql> is required');
+      const data = await api.adminRequest(ctx, 'POST', '/migrations', { body: { name, upSql, downSql } });
+      output(ctx, data, (d, ui) => ui.success(`Created migration ${name}`));
+    },
+  },
+  apply: {
+    summary: 'Apply a migration',
+    usage: 'motherbase migrations apply <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/migrations/${id}/apply`);
+      output(ctx, data, (d, ui) => ui.success(`Applied ${id}`));
+    },
+  },
+  rollback: {
+    summary: 'Roll back a migration',
+    usage: 'motherbase migrations rollback <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/migrations/${id}/rollback`);
+      output(ctx, data, (d, ui) => ui.success(`Rolled back ${id}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Schema migrations (list/diff/create/apply/rollback)',
+  usage: 'motherbase migrations <list|diff|get|create|apply|rollback> ...',
+  subcommands,
+};

package/src/commands/projects.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const LIFECYCLE = ['start', 'stop', 'restart', 'update', 'rebuild'];
+
+function lifecycleCmd(action) {
+  return {
+    summary: `${action} a project`,
+    usage: `motherbase projects ${action} <id>`,
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.consoleRequest(ctx, 'POST', `/projects/${id}/${action}`);
+      output(ctx, data, (d, ui) => ui.success(`${action} → ${id}`));
+    },
+  };
+}
+
+const subcommands = {
+  list: {
+    summary: 'List all projects on the console',
+    usage: 'motherbase projects list',
+    async run(ctx) {
+      const data = await api.consoleRequest(ctx, 'GET', '/projects');
+      output(ctx, data, (rows, ui) =>
+        ui.table(Array.isArray(rows) ? rows : [], [
+          { key: 'name', label: 'NAME' },
+          { key: 'status', label: 'STATUS' },
+          { key: 'domain', label: 'DOMAIN' },
+        ]),
+      );
+    },
+  },
+  create: {
+    summary: 'Create a new project',
+    usage: 'motherbase projects create <name> [--domain <domain>]',
+    async run(ctx, args, flags) {
+      const name = requireArg(args[0], 'name');
+      const body = { name };
+      if (flags.domain) body.domain = flags.domain;
+      const data = await api.consoleRequest(ctx, 'POST', '/projects', { body });
+      output(ctx, data, (d, ui) => ui.success(`Created project ${name}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a project (requires --confirm <name>)',
+    usage: 'motherbase projects delete <id> --confirm <name>',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const confirm = flags.confirm;
+      if (confirm !== id) {
+        throw new CliError(`Refusing to delete. Pass --confirm ${id} to proceed.`);
+      }
+      const data = await api.consoleRequest(ctx, 'DELETE', `/projects/${id}`, { body: { confirm } });
+      output(ctx, data, (d, ui) => ui.success(`Deleted project ${id}`));
+    },
+  },
+  logs: {
+    summary: 'Show recent logs for a project',
+    usage: 'motherbase projects logs <id> [-f]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const fetchOnce = () => api.consoleRequest(ctx, 'GET', `/projects/${id}/logs`);
+      const data = await fetchOnce();
+      output(ctx, data, (d, ui) => {
+        if (d && d.stdout) ui.print(d.stdout);
+        if (d && d.stderr) ui.printErr(d.stderr);
+      });
+      if (flags.f && !ctx.flags.json) {
+        // The console logs endpoint returns a snapshot; approximate -f by polling.
+        const ui = require('../ui');
+        ui.warn('(-f) polling every 3s; Ctrl-C to stop');
+        setInterval(async () => {
+          try {
+            const next = await fetchOnce();
+            if (next && next.stdout) process.stdout.write(next.stdout);
+          } catch (e) { ui.warn(e.message); }
+        }, 3000);
+        await new Promise(() => {});
+      }
+    },
+  },
+  info: {
+    summary: 'Show project details and DNS checks',
+    usage: 'motherbase projects info <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const list = await api.consoleRequest(ctx, 'GET', '/projects');
+      const project = (Array.isArray(list) ? list : []).find(p => p.name === id || p.id === id) || { name: id };
+      let dns = null;
+      try { dns = await api.consoleRequest(ctx, 'GET', `/projects/${id}/dns`); } catch { /* optional */ }
+      const data = { ...project, dns: dns && dns.checks };
+      output(ctx, data, (d, ui) => ui.keyValue(d));
+    },
+  },
+  limits: {
+    summary: 'Get or set per-project resource limits',
+    usage: 'motherbase projects limits <id> [--api-cpus n --api-mem mb --db-cpus n --db-mem mb --minio-cpus n --minio-mem mb]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const map = {
+        'api-cpus': 'apiCpus', 'api-mem': 'apiMemMb',
+        'db-cpus': 'dbCpus', 'db-mem': 'dbMemMb',
+        'minio-cpus': 'minioCpus', 'minio-mem': 'minioMemMb',
+      };
+      const body = {};
+      for (const [flag, key] of Object.entries(map)) {
+        if (flags[flag] !== undefined) body[key] = Number(flags[flag]);
+      }
+      const method = Object.keys(body).length ? 'PATCH' : 'GET';
+      const data = await api.consoleRequest(ctx, method, `/projects/${id}/limits`, method === 'PATCH' ? { body } : {});
+      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
+    },
+  },
+};
+
+for (const action of LIFECYCLE) subcommands[action] = lifecycleCmd(action);
+
+module.exports = {
+  summary: 'Manage projects on the Platform Console',
+  usage: 'motherbase projects <list|create|start|stop|restart|update|rebuild|delete|logs|info|limits> ...',
+  subcommands,
+};