@motherbase/cli 0.2.2 → 0.2.4

package/README.md

@@ -84,9 +84,33 @@ Global flags: `--json`, `--yes/-y`, `--project/-p <id>`, `--url/-u <consoleUrl>`
 - **Cron**: `cron list|create|delete|toggle`
 - **Config**: `config list|get|set`
 - **Inspect**: `inspect logs|stats|performance|requests|advisor|shield`
+- **Codegen**: `gen types typescript [--schema public] [--local] [--output <file>] [--check]`
 
 Run `motherbase <group> -h` for per-group usage.
 
+## Type generation
+
+Generate TypeScript definitions for the live schema, in the shape supabase-js
+emits, so `createClient<Database>(url, key)` types every row, rejects unknown
+columns and types `.rpc()` calls:
+
+```bash
+motherbase gen types typescript > database.types.ts
+motherbase gen types typescript --schema shop --output src/shop.types.ts
+```
+
+With no `--output` the file goes to stdout and nothing else does, so the
+redirect above produces a compiling file. `--local` skips the Console proxy and
+talks to a project API on this machine (`MOTHERBASE_URL`, default
+`http://localhost:5001`, with `MOTHERBASE_ADMIN_TOKEN`).
+
+Gate CI on schema drift with `--check`, which never writes and exits non-zero
+when the committed file differs from a fresh generation:
+
+```bash
+motherbase gen types typescript --check --output database.types.ts
+```
+
 ## Supabase migration
 
 Preview a Supabase import without writing to Motherbase:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motherbase/cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Motherbase operator CLI — drives the Platform Console and linked projects.",
   "type": "commonjs",
   "bin": {
@@ -10,7 +10,8 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "lint": "eslint ."
   },
   "files": [
     "bin",
@@ -21,7 +22,5 @@
     "access": "public"
   },
   "license": "MIT",
-  "dependencies": {
-    "@motherbase/cli": "^0.2.1"
-  }
+  "dependencies": {}
 }

package/src/api.js

@@ -143,12 +143,19 @@ function adminRequest(ctx, method, apiPath, { body, query } = {}) {
   return doFetch(url, { method, token, body });
 }
 
+// The public URL of a project path (`/edge/<route>`, `/rest/v1/<table>`), for
+// printing. Mirrors how the proxy addresses a project in each mode.
+function projectUrl(ctx, projectPath) {
+  const target = ctx.requireProject();
+  return target.mode === 'direct'
+    ? `${target.baseUrl}/api${projectPath}`
+    : `${target.consoleUrl}/api/projects/${target.projectId}${projectPath}`;
+}
+
 // Edge invoke goes through the un-authenticated edge route, not /admin.
 function edgeInvokeRequest(ctx, route, body) {
+  const url = projectUrl(ctx, `/edge/${encodeURIComponent(route)}`);
   const target = ctx.requireProject();
-  const url = target.mode === 'direct'
-    ? `${target.baseUrl}/api/edge/${encodeURIComponent(route)}`
-    : `${target.consoleUrl}/api/projects/${target.projectId}/edge/${encodeURIComponent(route)}`;
   return doFetch(url, { method: 'POST', token: target.token, body: body || {} });
 }
 
@@ -214,6 +221,7 @@ module.exports = {
   loginRequest,
   adminRequest,
   edgeInvokeRequest,
+  projectUrl,
   uploadFile,
   downloadFile,
   buildQuery,

package/src/commands/functions.js

@@ -1,112 +1,274 @@
-'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,
-};
+'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');
+
+// Functions live as repo files, one directory per function, the layout Supabase
+// projects already use:
+//
+//   functions/
+//     stripe-webhook/
+//       index.ts
+//
+// The directory name is both the function name and its route, so deploying is
+// `motherbase functions deploy` with nothing to remember.
+const DEFAULT_DIR = 'functions';
+const LEGACY_DIR = path.join('motherbase', 'functions');
+const ENTRY_NAMES = ['index.ts', 'index.js', 'index.mjs'];
+
+const TEMPLATE = `// Edge function: %NAME%
+//
+// Runs in a V8 isolate with the Fetch API available: Request, Response,
+// Headers, URL, TextEncoder/TextDecoder and crypto (including subtle.sign, for
+// webhook signature checks). npm imports are resolved at deploy time:
+//
+//   import { z } from 'zod';
+//
+// \`env\` holds this project's edge secrets.
+
+export default async (req: Request) => {
+  const body = req.method === 'GET' ? {} : await req.json().catch(() => ({}));
+  return Response.json({ hello: '%NAME%', received: body, at: new Date().toISOString() });
+};
+`;
+
+function functionsDir(ctx) {
+  for (const candidate of [DEFAULT_DIR, LEGACY_DIR]) {
+    if (fs.existsSync(path.join(ctx.cwd, candidate))) return path.join(ctx.cwd, candidate);
+  }
+  return path.join(ctx.cwd, DEFAULT_DIR);
+}
+
+/** Entry file of a function directory, or null when it has none. */
+function entryFile(dir) {
+  for (const name of ENTRY_NAMES) {
+    const file = path.join(dir, name);
+    if (fs.existsSync(file)) return file;
+  }
+  return null;
+}
+
+/** Every locally defined function: `{ name, dir, entry }`. */
+function localFunctions(ctx) {
+  const root = functionsDir(ctx);
+  if (!fs.existsSync(root)) return [];
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter(item => item.isDirectory())
+    .map(item => ({ name: item.name, dir: path.join(root, item.name), entry: entryFile(path.join(root, item.name)) }))
+    .filter(fn => fn.entry);
+}
+
+function resolveLocal(ctx, name) {
+  const all = localFunctions(ctx);
+  if (!name) return all;
+  const hit = all.find(fn => fn.name === name);
+  if (!hit) {
+    const expected = path.relative(ctx.cwd, path.join(functionsDir(ctx), name, 'index.ts'));
+    throw new CliError(`No local function "${name}". Expected ${expected}.`);
+  }
+  return [hit];
+}
+
+/** Upsert by route, so deploying twice updates instead of conflicting. */
+async function deployOne(ctx, fn, flags) {
+  const code = fs.readFileSync(fn.entry, 'utf8');
+  const body = { name: fn.name, route: fn.name, code };
+  if (flags && flags.memory) body.memoryLimitMb = Number(flags.memory);
+  if (flags && flags.timeout) body.timeoutMs = Number(flags.timeout);
+
+  const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
+  const existing = ((listing && listing.functions) || []).find(f => f.route === fn.name);
+  if (existing) return api.adminRequest(ctx, 'PATCH', `/edge-functions/${existing.id}`, { body });
+  return api.adminRequest(ctx, 'POST', '/edge-functions', { body: { ...body, enabled: true } });
+}
+
+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 functions/<name>/index.ts',
+    usage: 'motherbase functions new <name>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'name');
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+        throw new CliError('Function names are lowercase letters, digits and hyphens (the name is also the route).');
+      }
+      const dir = path.join(functionsDir(ctx), name);
+      if (entryFile(dir)) throw new CliError(`${path.relative(ctx.cwd, dir)} already has an entry file.`);
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(dir, 'index.ts');
+      fs.writeFileSync(file, TEMPLATE.replace(/%NAME%/g, name));
+      ui.success(`Created ${path.relative(ctx.cwd, file)}`);
+      ui.info(`Deploy it with: motherbase functions deploy ${name}`);
+    },
+  },
+  deploy: {
+    summary: 'Deploy local functions (all of them, or one by name)',
+    usage: 'motherbase functions deploy [name] [--memory <mb>] [--timeout <ms>] [--file <f> --route <r>]',
+    async run(ctx, args, flags) {
+      // The single-file form predates the directory layout and stays supported:
+      // scripts and older docs pass --file.
+      if (flags.file) {
+        const route = flags.route || args[0];
+        if (!route) throw new CliError('--route is required with --file');
+        const code = fs.readFileSync(path.resolve(ctx.cwd, flags.file), 'utf8');
+        const name = flags.name || route;
+        const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
+        const existing = ((listing && listing.functions) || []).find(f => f.route === route);
+        const data = existing
+          ? await api.adminRequest(ctx, 'PATCH', `/edge-functions/${existing.id}`, { body: { name, route, code } })
+          : await api.adminRequest(ctx, 'POST', '/edge-functions', { body: { name, route, code, enabled: true } });
+        return output(ctx, data, (_d, u) => u.success(`Deployed function ${name} (${route})`));
+      }
+
+      const targets = resolveLocal(ctx, args[0]);
+      if (!targets.length) {
+        const where = path.relative(ctx.cwd, functionsDir(ctx));
+        throw new CliError(`No functions in ${where}. Create one with: motherbase functions new <name>`);
+      }
+
+      const deployed = [];
+      for (const fn of targets) {
+        await deployOne(ctx, fn, flags);
+        deployed.push(fn.name);
+      }
+      output(ctx, { deployed }, (_d, u) => u.success(`Deployed ${deployed.join(', ')}`));
+    },
+  },
+  pull: {
+    summary: 'Write deployed function source back to disk',
+    usage: 'motherbase functions pull [name]',
+    async run(ctx, args) {
+      const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
+      const all = (listing && listing.functions) || [];
+      const wanted = args[0] ? all.filter(f => f.route === args[0] || f.name === args[0]) : all;
+      if (!wanted.length) throw new CliError(args[0] ? `No deployed function "${args[0]}"` : 'No deployed functions');
+
+      const written = [];
+      for (const fn of wanted) {
+        // The list endpoint may omit code, so read the function itself.
+        const detail = await api.adminRequest(ctx, 'GET', `/edge-functions/${fn.id}`);
+        const code = (detail && detail.function ? detail.function.code : detail && detail.code) || '';
+        const dir = path.join(functionsDir(ctx), fn.route || fn.name);
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'index.ts');
+        fs.writeFileSync(file, code);
+        written.push(path.relative(ctx.cwd, file));
+      }
+      output(ctx, { written }, (_d, u) => u.success(`Wrote ${written.join(', ')}`));
+    },
+  },
+  serve: {
+    summary: 'Watch local functions and redeploy on every save',
+    usage: 'motherbase functions serve [name]',
+    async run(ctx, args) {
+      // Deliberately not a second local runtime. The isolate, the secrets and
+      // the bundler all live in the project API, and a local re-implementation
+      // would differ from production in exactly the ways that matter. This
+      // watches and redeploys instead, so the edit-invoke loop is one save long.
+      const targets = resolveLocal(ctx, args[0]);
+      if (!targets.length) {
+        throw new CliError('Nothing to serve. Create a function with: motherbase functions new <name>');
+      }
+
+      for (const fn of targets) {
+        await deployOne(ctx, fn);
+        ui.success(`Deployed ${fn.name}`);
+        ui.info(`  POST ${api.projectUrl(ctx, `/edge/${fn.name}`)}`);
+      }
+      ui.info('Watching for changes. Ctrl-C to stop.');
+
+      const pending = new Map();
+      for (const fn of targets) {
+        fs.watch(fn.dir, { recursive: true }, () => {
+          // Editors save in bursts (write, rename, truncate). Coalescing them
+          // keeps one save from becoming three deploys.
+          clearTimeout(pending.get(fn.name));
+          pending.set(
+            fn.name,
+            setTimeout(async () => {
+              try {
+                await deployOne(ctx, fn);
+                ui.success(`Redeployed ${fn.name} at ${new Date().toLocaleTimeString()}`);
+              } catch (error) {
+                ui.warn(`${fn.name}: ${error.message}`);
+              }
+            }, 150),
+          );
+        });
+      }
+
+      // Hold the process open; the watchers are the work.
+      await new Promise(() => {});
+    },
+  },
+  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 (repo files, deploy, invoke, logs)',
+  usage: 'motherbase functions <list|get|new|deploy|pull|serve|delete|invoke|logs> ...',
+  subcommands,
+};

package/src/commands/gen.js

@@ -0,0 +1,126 @@
+'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 },
+};

package/src/commands/index.js

@@ -36,11 +36,18 @@ const registry = {
   storage: require('./storage'),
   functions: require('./functions'),
   secrets: require('./secrets'),
+  keys: require('./keys'),
   realtime: require('./realtime'),
   webhooks: require('./webhooks'),
   cron: require('./cron'),
   config: require('./config'),
   inspect: require('./inspect'),
+
+  // ── Codegen ────────────────────────────────────────────────────────────────
+  gen: require('./gen'),
+
+  // ── AI agents ──────────────────────────────────────────────────────────────
+  mcp: require('./mcp'),
 };
 
 // Grouping used only to render a tidy top-level help listing.
@@ -49,7 +56,9 @@ const groups = [
   { 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'] },
+  { title: 'Resources', names: ['rls', 'users', 'storage', 'functions', 'secrets', 'keys', 'realtime', 'webhooks', 'cron', 'config', 'inspect'] },
+  { title: 'Codegen', names: ['gen'] },
+  { title: 'AI agents', names: ['mcp'] },
 ];
 
 module.exports = { registry, groups };