@motherbase/cli 0.2.4 → 0.2.5

package/src/commands/gen.js

@@ -1,126 +1,172 @@
-'use strict';
-
-// Code generation from the live schema. Today: TypeScript database types.
-//
-// The server owns the emitter (apps/server/services/admin/typegen.service.ts).
-// This command is a transport: it asks `GET /admin/schema/types` for the
-// rendered file and writes it. Re-implementing the emitter here would guarantee
-// drift between the CLI, the Studio download and the MCP tool within a release.
-
-const fs = require('fs');
-const path = require('path');
-const api = require('../api');
-const config = require('../config');
-const { output } = require('./_util');
-const { CliError } = require('../context');
-
-const DEFAULT_OUTPUT = 'database.types.ts';
-const DEFAULT_LOCAL_URL = 'http://localhost:5001';
-
-/**
- * `--local` bypasses the Console proxy and talks straight to a project API on
- * this machine, which is how someone iterating on a local stack works: there is
- * no console account, no link file, just a server on a port. Everything else
- * about the context (flags, cwd, json mode) is preserved.
- */
-function resolveTarget(ctx, flags) {
-  if (!flags.local) return ctx;
-  const baseUrl = config.normalizeUrl(flags.url || ctx.env.MOTHERBASE_URL || DEFAULT_LOCAL_URL);
-  const token = flags.token || ctx.env.MOTHERBASE_ADMIN_TOKEN || ctx.token;
-  return Object.assign({}, ctx, {
-    mode: 'direct',
-    requireProject: () => ({ mode: 'direct', baseUrl, token }),
-  });
-}
-
-// Git checkouts on Windows may rewrite line endings. The generator always emits
-// LF, so compare on normalised text: a CRLF working copy is not schema drift.
-function normalize(text) {
-  return String(text).replace(/\r\n/g, '\n');
-}
-
-/** First line where the two files diverge, 1-based, for a useful error. */
-function firstDifference(a, b) {
-  const left = normalize(a).split('\n');
-  const right = normalize(b).split('\n');
-  for (let i = 0; i < Math.max(left.length, right.length); i++) {
-    if (left[i] !== right[i]) {
-      return { line: i + 1, expected: right[i], actual: left[i] };
-    }
-  }
-  return null;
-}
-
-const typescript = {
-  summary: 'Generate TypeScript types for the database schema',
-  usage:
-    'motherbase gen types typescript [--schema public] [--local] [--output database.types.ts] [--check]',
-  async run(ctx, args, flags) {
-    const schema = flags.schema || 'public';
-    const data = await api.adminRequest(resolveTarget(ctx, flags), 'GET', '/schema/types', {
-      query: { schema },
-    });
-
-    const types = data && typeof data.types === 'string' ? data.types : null;
-    if (!types) {
-      throw new CliError(
-        'The server returned no generated types. Check that the project runs a build with GET /admin/schema/types.',
-      );
-    }
-
-    const outputPath = flags.output && flags.output !== true ? String(flags.output) : null;
-
-    // --check is the CI drift gate: compare the committed file with a fresh
-    // generation and fail loudly, without ever writing.
-    if (flags.check) {
-      const target = path.resolve(ctx.cwd, outputPath || DEFAULT_OUTPUT);
-      if (!fs.existsSync(target)) {
-        throw new CliError(`${target} does not exist. Run \`motherbase gen types typescript --output ${outputPath || DEFAULT_OUTPUT}\`.`);
-      }
-      const onDisk = fs.readFileSync(target, 'utf8');
-      const diff = firstDifference(onDisk, types);
-      if (diff) {
-        throw new CliError(
-          `${target} is out of date with the ${schema} schema (first difference at line ${diff.line}).\n` +
-            `  on disk:   ${diff.actual === undefined ? '(end of file)' : diff.actual}\n` +
-            `  generated: ${diff.expected === undefined ? '(end of file)' : diff.expected}\n` +
-            'Re-run without --check to update it.',
-        );
-      }
-      output(ctx, { schema, output: target, upToDate: true }, (d, ui) =>
-        ui.success(`${target} is up to date`),
-      );
-      return;
-    }
-
-    // No --output: write the file to stdout so `... > database.types.ts` works.
-    // Nothing else may go to stdout on this path or it lands in the file.
-    if (!outputPath) {
-      if (ctx.flags.json) {
-        output(ctx, { schema, types }, () => {});
-        return;
-      }
-      process.stdout.write(types);
-      return;
-    }
-
-    const target = path.resolve(ctx.cwd, outputPath);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.writeFileSync(target, types, 'utf8');
-    output(ctx, { schema, output: target, bytes: Buffer.byteLength(types) }, (d, ui) =>
-      ui.success(`Wrote ${target} (${schema} schema)`),
-    );
-  },
-};
-
-const types = {
-  summary: 'Generate types from the database schema',
-  usage: 'motherbase gen types typescript [flags]',
-  subcommands: { typescript },
-};
-
-module.exports = {
-  summary: 'Generate code from the live schema',
-  usage: 'motherbase gen types typescript [--schema public] [--local] [--output <file>] [--check]',
-  subcommands: { types },
-};
+'use strict';
+
+// Code generation from the live schema: TypeScript types and zod schemas.
+//
+// The server owns both emitters (apps/server/services/admin/typegen/).
+// This command is a transport: it asks `GET /admin/schema/types` for the
+// rendered file and writes it. Re-implementing the emitter here would guarantee
+// drift between the CLI, the Studio download and the MCP tool within a release.
+
+const fs = require('fs');
+const path = require('path');
+const api = require('../api');
+const config = require('../config');
+const { output } = require('./_util');
+const { outputFormat } = require('../format');
+const { CliError } = require('../context');
+
+const DEFAULT_OUTPUT = 'database.types.ts';
+const DEFAULT_ZOD_OUTPUT = 'database.schemas.ts';
+const DEFAULT_LOCAL_URL = 'http://localhost:5001';
+
+/**
+ * `--local` bypasses the Console proxy and talks straight to a project API on
+ * this machine, which is how someone iterating on a local stack works: there is
+ * no console account, no link file, just a server on a port. Everything else
+ * about the context (flags, cwd, json mode) is preserved.
+ */
+function resolveTarget(ctx, flags) {
+  if (!flags.local) return ctx;
+  const baseUrl = config.normalizeUrl(flags.url || ctx.env.MOTHERBASE_URL || DEFAULT_LOCAL_URL);
+  const token = flags.token || ctx.env.MOTHERBASE_ADMIN_TOKEN || ctx.token;
+  return Object.assign({}, ctx, {
+    mode: 'direct',
+    requireProject: () => ({ mode: 'direct', baseUrl, token }),
+  });
+}
+
+// Git checkouts on Windows may rewrite line endings. The generator always emits
+// LF, so compare on normalised text: a CRLF working copy is not schema drift.
+function normalize(text) {
+  return String(text).replace(/\r\n/g, '\n');
+}
+
+/** First line where the two files diverge, 1-based, for a useful error. */
+function firstDifference(a, b) {
+  const left = normalize(a).split('\n');
+  const right = normalize(b).split('\n');
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    if (left[i] !== right[i]) {
+      return { line: i + 1, expected: right[i], actual: left[i] };
+    }
+  }
+  return null;
+}
+
+/**
+ * Both targets are the same transport: ask the server for the rendered file,
+ * then write it, diff it or print it. `field` names which rendering to take
+ * from the one response, so a new target is a few lines rather than a copy of
+ * this whole flow.
+ */
+function emitter({ field, defaultOutput, label, command }) {
+  return async function run(ctx, args, flags) {
+    const schema = flags.schema || 'public';
+    const data = await api.adminRequest(resolveTarget(ctx, flags), 'GET', '/schema/types', {
+      query: { schema },
+    });
+
+    const types = data && typeof data[field] === 'string' ? data[field] : null;
+    if (!types) {
+      throw new CliError(
+        `The server returned no generated ${label}. Check that the project serves ` +
+          `GET /admin/schema/types with a build new enough for \`${command}\`.`,
+      );
+    }
+
+    const outputPath = flags.output && flags.output !== true ? String(flags.output) : null;
+    const DEFAULT_OUTPUT = defaultOutput;
+
+    // --check is the CI drift gate: compare the committed file with a fresh
+    // generation and fail loudly, without ever writing.
+    if (flags.check) {
+      const target = path.resolve(ctx.cwd, outputPath || DEFAULT_OUTPUT);
+      if (!fs.existsSync(target)) {
+        throw new CliError(`${target} does not exist. Run \`${command} --output ${outputPath || DEFAULT_OUTPUT}\`.`);
+      }
+      const onDisk = fs.readFileSync(target, 'utf8');
+      const diff = firstDifference(onDisk, types);
+      if (diff) {
+        throw new CliError(
+          `${target} is out of date with the ${schema} schema (first difference at line ${diff.line}).\n` +
+            `  on disk:   ${diff.actual === undefined ? '(end of file)' : diff.actual}\n` +
+            `  generated: ${diff.expected === undefined ? '(end of file)' : diff.expected}\n` +
+            'Re-run without --check to update it.',
+        );
+      }
+      output(ctx, { schema, output: target, upToDate: true }, (d, ui) =>
+        ui.success(`${target} is up to date`),
+      );
+      return;
+    }
+
+    // No --output: write the file to stdout so `... > database.types.ts` works.
+    // Nothing else may go to stdout on this path or it lands in the file.
+    if (!outputPath) {
+      if (outputFormat(ctx.flags) !== 'pretty') {
+        output(ctx, { schema, types }, () => {});
+        return;
+      }
+      process.stdout.write(types);
+      return;
+    }
+
+    const target = path.resolve(ctx.cwd, outputPath);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, types, 'utf8');
+    output(ctx, { schema, output: target, bytes: Buffer.byteLength(types) }, (d, ui) =>
+      ui.success(`Wrote ${target} (${schema} schema)`),
+    );
+  };
+}
+
+const typescript = {
+  summary: 'Generate TypeScript types for the database schema',
+  usage:
+    'motherbase gen types typescript [--schema public] [--local] [--output database.types.ts] [--check]',
+  // Here `--output` names the file to write, not the `-o` output format.
+  outputIsPath: true,
+  run: emitter({
+    field: 'types',
+    defaultOutput: DEFAULT_OUTPUT,
+    label: 'types',
+    command: 'motherbase gen types typescript',
+  }),
+};
+
+const zod = {
+  summary: 'Generate zod schemas for the database schema',
+  usage:
+    'motherbase gen types zod [--schema public] [--local] [--output database.schemas.ts] [--check]',
+  outputIsPath: true,
+  run: emitter({
+    field: 'zod',
+    defaultOutput: DEFAULT_ZOD_OUTPUT,
+    label: 'schemas',
+    command: 'motherbase gen types zod',
+  }),
+};
+
+const LANGS = { typescript, zod };
+
+// `gen types --lang typescript` is the Supabase spelling; `gen types typescript`
+// reaches the same emitter through the subcommand.
+const types = {
+  summary: 'Generate types from the database schema',
+  usage: 'motherbase gen types [--lang typescript|zod] [flags]  |  motherbase gen types <typescript|zod> [flags]',
+  subcommands: LANGS,
+  outputIsPath: true,
+  async run(ctx, args, flags) {
+    const lang = flags.lang || 'typescript';
+    if (!LANGS[lang]) throw new CliError(`--lang must be one of: ${Object.keys(LANGS).join(', ')}`);
+    return LANGS[lang].run(ctx, args, flags);
+  },
+};
+
+const signing = require('./signing');
+
+module.exports = {
+  summary: 'Generate code from the live schema, and signing keys, tokens and secrets',
+  usage: 'motherbase gen <types|signing-key|bearer-jwt|keys> ...',
+  subcommands: { types, 'signing-key': signing.signingKey, 'bearer-jwt': signing.bearerJwt, keys: signing.keys },
+};

package/src/commands/import.js

@@ -5,17 +5,37 @@ const prompt = require('../prompt');
 const { output } = require('./_util');
 const { CliError } = require('../context');
 
+// Sections beyond the database need their own credential, because that is where
+// Supabase keeps them: object bytes behind the Storage API (service_role key),
+// edge functions and project secrets behind the Management API (a personal
+// access token). Both are optional; without one, that section reports what it
+// could not read instead of failing the import.
 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]',
+  summary: 'Import a Supabase project (schema, data, auth, storage, edge functions, secrets)',
+  usage:
+    'motherbase import --from-supabase <connectionString> [--service-role-key <key>] [--management-token <sbp_…>] ' +
+    '[--preview] [--no-data] [--no-auth] [--no-storage] [--no-edge-functions] [--no-secrets]',
   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 include = {
+      schema: true,
+      data: !flags['no-data'],
+      auth: !flags['no-auth'],
+      storage: !flags['no-storage'],
+      edgeFunctions: !flags['no-edge-functions'],
+      secrets: !flags['no-secrets'],
+    };
     const preview = Boolean(flags.preview);
 
     const body = { connectionString, include };
+    const serviceRoleKey = flags['service-role-key'] || flags.serviceRoleKey;
+    const managementToken = flags['management-token'] || flags.managementToken;
+    if (serviceRoleKey) body.serviceRoleKey = serviceRoleKey;
+    if (managementToken) body.managementToken = managementToken;
+    if (flags['project-ref'] || flags.projectRef) body.projectRef = flags['project-ref'] || flags.projectRef;
+
     if (preview) {
       body.preview = true;
     } else {

package/src/commands/index.js

@@ -4,6 +4,8 @@
 // `main.js` builds all help/dispatch from this single map.
 
 const local = require('./local');
+const { alias } = require('./_util');
+const migration = require('./migration');
 
 const registry = {
   // ── Connection ─────────────────────────────────────────────────────────────
@@ -14,8 +16,12 @@ const registry = {
   unlink: require('./unlink'),
   status: require('./status'),
 
-  // ── Projects (Platform Console) ────────────────────────────────────────────
+  // ── Orgs & projects (Platform Console) ─────────────────────────────────────
+  orgs: require('./orgs'),
   projects: require('./projects'),
+  branches: require('./branches'),
+  domains: require('./domains').domains,
+  'vanity-subdomains': require('./domains').vanitySubdomains,
 
   // ── Local self-host (docker compose) ───────────────────────────────────────
   init: local.init,
@@ -26,9 +32,14 @@ const registry = {
 
   // ── Database / migrations / import ─────────────────────────────────────────
   db: require('./db'),
-  migrations: require('./migrations'),
-  migration: require('./migration'),
+  backups: require('./backups'),
+  migration,
+  // The name Motherbase used before it matched Supabase's `migration`.
+  migrations: alias(migration, 'motherbase migrations <new|list|up|down|repair|squash|fetch|diff|get|create|apply|rollback> ... (alias of `migration`)'),
   import: require('./import'),
+  migrate: require('./migrate'),
+  test: require('./test'),
+  'postgres-config': require('./postgres-config'),
 
   // ── Resource domains ───────────────────────────────────────────────────────
   rls: require('./rls'),
@@ -40,25 +51,35 @@ const registry = {
   realtime: require('./realtime'),
   webhooks: require('./webhooks'),
   cron: require('./cron'),
+  queues: require('./queues'),
+  vault: require('./vault'),
+  wrappers: require('./wrappers'),
   config: require('./config'),
   inspect: require('./inspect'),
+  'network-restrictions': require('./network').networkRestrictions,
+  'ssl-enforcement': require('./network').sslEnforcement,
+  snippets: require('./snippets'),
 
   // ── Codegen ────────────────────────────────────────────────────────────────
   gen: require('./gen'),
 
   // ── AI agents ──────────────────────────────────────────────────────────────
   mcp: require('./mcp'),
+
+  // ── Shell ──────────────────────────────────────────────────────────────────
+  completion: require('./completion'),
 };
 
 // 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: 'Orgs & projects (Console)', names: ['orgs', 'projects', 'branches', 'domains', 'vanity-subdomains'] },
   { 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', 'keys', 'realtime', 'webhooks', 'cron', 'config', 'inspect'] },
+  { title: 'Database', names: ['db', 'backups', 'migrations', 'migration', 'import', 'test', 'postgres-config'] },
+  { title: 'Resources', names: ['rls', 'users', 'storage', 'functions', 'secrets', 'keys', 'realtime', 'webhooks', 'cron', 'queues', 'vault', 'wrappers', 'config', 'inspect', 'snippets', 'network-restrictions', 'ssl-enforcement'] },
   { title: 'Codegen', names: ['gen'] },
   { title: 'AI agents', names: ['mcp'] },
+  { title: 'Shell', names: ['completion'] },
 ];
 
 module.exports = { registry, groups };

package/src/commands/inspect.js

@@ -1,12 +1,20 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const api = require('../api');
 const { output } = require('./_util');
+const { CliError } = require('../context');
+const { QUERIES, DEPRECATED, REPORT, resolveQuery } = require('../inspect/queries');
+const { toCsv } = require('../inspect/csv');
 
 function simple(apiPath, summary, render) {
   return {
     summary,
-    usage: `motherbase inspect ${summary.split(' ')[0].toLowerCase()}`,
+    // usage is filled in from the subcommand key below: deriving it from the
+    // summary printed `inspect security` for `shield` and `inspect request` for
+    // `requests`, neither of which is a command.
+    usage: '',
     async run(ctx) {
       const data = await api.adminRequest(ctx, 'GET', apiPath);
       output(ctx, data, render || ((d, ui) => ui.json(d)));
@@ -14,12 +22,115 @@ function simple(apiPath, summary, render) {
   };
 }
 
+// Postgres' two ways of saying pg_stat_statements is not usable here: the
+// extension was never created in this database, or the library is not preloaded.
+const STAT_STATEMENTS_MISSING = /pg_stat_statements.*(does not exist|must be loaded)/i;
+
+class StatStatementsMissing extends CliError {
+  constructor() {
+    super(
+      'pg_stat_statements is not enabled in this database. Enable it from Studio (Database > Extensions) '
+        + 'or run: motherbase db sql -e "create extension pg_stat_statements"',
+    );
+  }
+}
+
+/** Rows of one inspect query, run on the read-only SQL endpoint. */
+async function runQuery(ctx, query) {
+  try {
+    const data = await api.adminRequest(ctx, 'POST', '/sql/readonly', { body: { sql: query.sql } });
+    return (data && data.rows) || [];
+  } catch (err) {
+    if (query.needsStatStatements && STAT_STATEMENTS_MISSING.test(err.message)) {
+      throw new StatStatementsMissing();
+    }
+    throw err;
+  }
+}
+
+// Statements span lines and `to_char` pads numbers; a table cell wants neither.
+// A statement is also cut short, or one query pushes every other column off
+// screen; -o json keeps it whole.
+const CELL_WIDTH = 60;
+function cell(value) {
+  if (typeof value !== 'string') return value;
+  const text = value.replace(/\s+/g, ' ').trim();
+  return text.length > CELL_WIDTH ? `${text.slice(0, CELL_WIDTH - 1)}…` : text;
+}
+
+function dbCommand(name) {
+  const { name: canonical, query } = resolveQuery(name);
+  const replaced = canonical !== name;
+  return {
+    summary: replaced ? `Deprecated: use "${canonical}" instead` : query.summary,
+    usage: `motherbase inspect db ${name}`,
+    async run(ctx) {
+      const rows = await runQuery(ctx, query);
+      output(ctx, { query: canonical, rows }, (_d, ui) => {
+        if (replaced) ui.warn(`"inspect db ${name}" is deprecated: showing "${canonical}".`);
+        const display = rows.map(row => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, cell(v)])));
+        ui.table(display, query.columns);
+      });
+    },
+  };
+}
+
+const db = {
+  summary: 'Inspect the database: bloat, locks, slow queries, index and table stats',
+  usage: `motherbase inspect db <${Object.keys(QUERIES).join('|')}>`,
+  subcommands: Object.fromEntries(
+    [...Object.keys(QUERIES), ...Object.keys(DEPRECATED)].map(name => [name, dbCommand(name)]),
+  ),
+};
+
+// Local-time YYYY-MM-DD: the report's folder, one per day as upstream does.
+function dateFolder(now = new Date()) {
+  const pad = n => String(n).padStart(2, '0');
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+
+const report = {
+  summary: 'Write every inspect query to a CSV in a dated folder',
+  usage: 'motherbase inspect report [--output-dir <dir>]',
+  async run(ctx, _args, flags) {
+    const dir = path.resolve(ctx.cwd, String(flags['output-dir'] || '.'), dateFolder());
+    fs.mkdirSync(dir, { recursive: true });
+
+    const files = [];
+    const skipped = [];
+    // One at a time: fourteen catalog scans at once is a load spike on the
+    // database being diagnosed.
+    for (const { file, name, query } of REPORT) {
+      let rows;
+      try {
+        rows = await runQuery(ctx, query);
+      } catch (err) {
+        // A missing pg_stat_statements costs two files, not the whole report.
+        if (!(err instanceof StatStatementsMissing)) throw err;
+        skipped.push(name);
+        continue;
+      }
+      const target = path.join(dir, `${file}.csv`);
+      fs.writeFileSync(target, toCsv(query.columns, rows));
+      files.push(target);
+    }
+
+    output(ctx, { outputDir: dir, files, skipped }, (d, ui) => {
+      if (d.skipped.length) ui.warn(`Skipped ${d.skipped.join(', ')}: ${new StatStatementsMissing().message}`);
+      ui.success(`Saved ${d.files.length} CSV files to ${path.relative(ctx.cwd, d.outputDir) || '.'}`);
+    });
+  },
+};
+
 const subcommands = {
+  db,
+  report,
   logs: {
     summary: 'Recent server logs',
-    usage: 'motherbase inspect logs [--limit n]',
+    usage: 'motherbase inspect logs [--limit n] [--source api|rest|postgres|pooler|auth|storage|realtime|edge-function|cron|platform]',
     async run(ctx, args, flags) {
-      const query = flags.limit ? { limit: flags.limit } : undefined;
+      // A Logs Explorer "source" is the server's `service` filter.
+      const query = flags.limit || flags.source ? { limit: flags.limit, service: flags.source } : undefined;
       const data = await api.adminRequest(ctx, 'GET', '/logs', { query });
       const logs = (data && data.logs) || [];
       output(ctx, data, (_d, ui) =>
@@ -27,6 +138,26 @@ const subcommands = {
       );
     },
   },
+  'index-advisor': {
+    summary: 'Suggest indexes for a statement (hypopg + index_advisor)',
+    usage: 'motherbase inspect index-advisor --sql "<select ...>" | motherbase inspect index-advisor --enable',
+    async run(ctx, args, flags) {
+      if (flags.enable) {
+        const status = await api.adminRequest(ctx, 'POST', '/performance/index-advisor/enable');
+        output(ctx, status, (_d, ui) => ui.success('Index advisor enabled'));
+        return;
+      }
+      const query = flags.sql || flags.e;
+      if (typeof query !== 'string') throw new CliError('Provide the statement with --sql "..." (or --enable to install the advisor).');
+      const data = await api.adminRequest(ctx, 'POST', '/performance/index-advisor', { body: { query } });
+      output(ctx, data, (d, ui) => {
+        const statements = (d && d.indexStatements) || [];
+        if (!statements.length) ui.print('No index would help this statement.');
+        statements.forEach(s => ui.print(s));
+        if (d && d.improvementPct != null) ui.print(`Estimated cost drop: ${d.improvementPct}%`);
+      });
+    },
+  },
   stats: simple('/stats', 'Stats overview'),
   performance: simple('/performance', 'Performance metrics'),
   requests: simple('/metrics/requests', 'Request metrics'),
@@ -34,8 +165,14 @@ const subcommands = {
   shield: simple('/shield', 'Security shield report'),
 };
 
+for (const [name, def] of Object.entries(subcommands)) {
+  if (!def.usage) def.usage = `motherbase inspect ${name}`;
+}
+
 module.exports = {
-  summary: 'Diagnostics: logs, stats, performance, advisor, shield',
-  usage: 'motherbase inspect <logs|stats|performance|requests|advisor|shield>',
+  summary: 'Diagnostics: database inspection, report, logs, stats, index-advisor, advisor, shield',
+  usage: 'motherbase inspect <db|report|logs|stats|performance|index-advisor|requests|advisor|shield>',
   subcommands,
+  dateFolder,
+  cell,
 };