@motherbase/cli 0.2.6 → 0.2.8

package/src/api.js

@@ -107,35 +107,57 @@ function consoleRequest(ctx, method, apiPath, { body, query } = {}) {
   return doFetch(url, { method, token, body });
 }
 
-// Login is special: no token yet. Uses Better Auth's native sign-in endpoint;
-// the session token comes back in the body and/or the `set-auth-token` header
-// (bearer plugin). Returns `{ token, user }` so the caller can persist it.
-async function loginRequest(consoleUrl, email, password) {
-  const url = `${consoleUrl}/api/auth/sign-in/email`;
+// Login is special: no token yet, so it talks to Better Auth's native endpoints
+// directly. Returns the raw response next to the parsed body because the token
+// lives in the `set-auth-token` header (bearer plugin) and the 2FA step needs
+// the response cookies.
+async function authPost(url, body, headers = {}) {
+  const finalHeaders = { 'content-type': 'application/json', ...headers };
+  const origin = originFor(url);
+  if (origin) finalHeaders['origin'] = origin;
   let res;
   try {
-    const headers = { 'content-type': 'application/json' };
-    const origin = originFor(url);
-    if (origin) headers['origin'] = origin;
-    res = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ email, password }),
-    });
+    res = await fetch(url, { method: 'POST', headers: finalHeaders, body: JSON.stringify(body) });
   } catch (err) {
     throw new CliError(`Cannot reach ${url}: ${err.message}`);
   }
   trace('POST', url, res);
   const text = await res.text();
-  let body;
-  if (text) { try { body = JSON.parse(text); } catch { body = undefined; } }
+  let parsed;
+  if (text) { try { parsed = JSON.parse(text); } catch { parsed = undefined; } }
   if (!res.ok) {
-    throw new CliError(errorMessage(res.status, body, text));
+    throw new CliError(errorMessage(res.status, parsed, text));
   }
+  return { res, body: parsed };
+}
+
+// The `two_factor` cookie (prefixed `__Secure-` on https) scopes the
+// verify-totp call to the pending sign-in.
+function twoFactorCookie(res) {
+  const setCookies = typeof res.headers.getSetCookie === 'function' ? res.headers.getSetCookie() : [];
+  const pair = setCookies.map(c => c.split(';')[0]).find(c => /two_factor=./.test(c));
+  if (!pair) throw new CliError('two-factor sign-in started but the server sent no two_factor cookie');
+  return pair;
+}
+
+// Returns `{ token, user }`, or `{ twoFactorCookie }` when the account has 2FA
+// enrolled. In that case Better Auth answers `{ twoFactorRedirect: true }` and
+// the `set-auth-token` header still carries the pre-2FA session it has just
+// deleted, so the header must not be trusted (see the console login route).
+async function loginRequest(consoleUrl, email, password) {
+  const { res, body } = await authPost(`${consoleUrl}/api/auth/sign-in/email`, { email, password });
+  if (body && body.twoFactorRedirect) return { twoFactorCookie: twoFactorCookie(res) };
   const token = (body && body.token) || res.headers.get('set-auth-token') || undefined;
   return { token, user: body && body.user };
 }
 
+// Second step of a 2FA sign-in: trade the TOTP code for the real session token.
+async function verifyTotpRequest(consoleUrl, cookie, code) {
+  const { res, body } = await authPost(`${consoleUrl}/api/auth/two-factor/verify-totp`, { code }, { cookie });
+  const token = res.headers.get('set-auth-token') || (body && body.token) || undefined;
+  return { token, user: body && body.user };
+}
+
 // ── Admin / resource (via proxy or direct) ───────────────────────────────────
 
 function adminBase(target) {
@@ -224,6 +246,7 @@ async function downloadFile(ctx, apiPath, destPath, { query } = {}) {
 module.exports = {
   consoleRequest,
   loginRequest,
+  verifyTotpRequest,
   adminRequest,
   projectUrl,
   uploadFile,

package/src/commands/_util.js

@@ -1,106 +1,106 @@
-'use strict';
-
-// Small shared helpers for command modules.
-
-const path = require('path');
-const { CliError } = require('../context');
-const { outputFormat, toYaml, toEnv } = require('../format');
-
-// Parse `key=value` tokens into an object. Values that look like numbers/bools are
-// coerced unless `raw` is set. Supports dotted keys via `--json`-style callers.
-function parseKeyValues(tokens, { coerce = true } = {}) {
-  const out = {};
-  for (const tok of tokens) {
-    const idx = tok.indexOf('=');
-    if (idx <= 0) throw new CliError(`expected key=value, got "${tok}"`);
-    const key = tok.slice(0, idx).trim();
-    let value = tok.slice(idx + 1);
-    if (coerce) {
-      if (value === 'true') value = true;
-      else if (value === 'false') value = false;
-      else if (value !== '' && !Number.isNaN(Number(value)) && /^-?\d+(\.\d+)?$/.test(value)) value = Number(value);
-    }
-    out[key] = value;
-  }
-  return out;
-}
-
-// Render a command's result in the selected `-o/--output` format; `pretty` is
-// the command's own human renderer.
-function output(ctx, data, humanFn) {
-  const ui = require('../ui');
-  switch (outputFormat(ctx.flags)) {
-    case 'json': ui.json(data); return;
-    case 'yaml': process.stdout.write(toYaml(data)); return;
-    case 'env': process.stdout.write(toEnv(data)); return;
-    default: humanFn(data, ui);
-  }
-}
-
-// The same command under a second (Supabase) name: one implementation, with
-// help that shows the name it was reached by.
-function alias(entry, usage, summary = entry.summary) {
-  return { ...entry, usage, summary };
-}
-
-// Parse a dotenv file: `KEY=value`, `export KEY=value`, `#` comments, and
-// single- or double-quoted values (double quotes expand \n).
-function parseDotenv(text) {
-  const out = {};
-  for (const raw of String(text).split(/\r?\n/)) {
-    const line = raw.trim().replace(/^export\s+/, '');
-    if (!line || line.startsWith('#')) continue;
-    const idx = line.indexOf('=');
-    if (idx <= 0) throw new CliError(`invalid env line: "${raw}"`);
-    const key = line.slice(0, idx).trim();
-    let value = line.slice(idx + 1).trim();
-    const quote = value[0];
-    if ((quote === '"' || quote === "'") && value.endsWith(quote) && value.length > 1) {
-      value = value.slice(1, -1);
-      if (quote === '"') value = value.replace(/\\n/g, '\n');
-    } else {
-      value = value.replace(/\s+#.*$/, '');
-    }
-    out[key] = value;
-  }
-  return out;
-}
-
-function requireArg(value, name) {
-  if (value === undefined || value === null || value === '') {
-    throw new CliError(`missing required argument: <${name}>`);
-  }
-  return value;
-}
-
-// Split "bucket:path" into { bucket, rest }.
-function splitRef(ref) {
-  const idx = ref.indexOf(':');
-  if (idx < 0) return { bucket: undefined, rest: ref };
-  return { bucket: ref.slice(0, idx), rest: ref.slice(idx + 1) };
-}
-
-// `/projects/<linked project>` on the Console, for the per-project platform
-// surfaces (branches, domains) that live on the Console rather than the
-// project API. They need a Console, so direct mode cannot reach them.
-function consoleProjectPath(ctx, suffix = '') {
-  ctx.requireConsole();
-  if (!ctx.projectId) {
-    throw new CliError('No project linked. Run `motherbase link` or pass --project-ref <id>.');
-  }
-  return `/projects/${encodeURIComponent(ctx.projectId)}${suffix}`;
-}
-
-// Join `parts` under `root`, refusing a result that escapes it. Names that come
-// from the server (object keys, function routes) must not write outside the
-// directory the user picked: `../../.bashrc` is a valid object key.
-function resolveInside(root, ...parts) {
-  const target = path.resolve(root, ...parts);
-  const rel = path.relative(root, target);
-  if (rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
-    throw new CliError(`Refusing to write outside ${root}: ${parts.join('/')}`);
-  }
-  return target;
-}
-
-module.exports = { parseKeyValues, output, alias, parseDotenv, requireArg, splitRef, consoleProjectPath, resolveInside };
+'use strict';
+
+// Small shared helpers for command modules.
+
+const path = require('path');
+const { CliError } = require('../context');
+const { outputFormat, toYaml, toEnv } = require('../format');
+
+// Parse `key=value` tokens into an object. Values that look like numbers/bools are
+// coerced unless `raw` is set. Supports dotted keys via `--json`-style callers.
+function parseKeyValues(tokens, { coerce = true } = {}) {
+  const out = {};
+  for (const tok of tokens) {
+    const idx = tok.indexOf('=');
+    if (idx <= 0) throw new CliError(`expected key=value, got "${tok}"`);
+    const key = tok.slice(0, idx).trim();
+    let value = tok.slice(idx + 1);
+    if (coerce) {
+      if (value === 'true') value = true;
+      else if (value === 'false') value = false;
+      else if (value !== '' && !Number.isNaN(Number(value)) && /^-?\d+(\.\d+)?$/.test(value)) value = Number(value);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// Render a command's result in the selected `-o/--output` format; `pretty` is
+// the command's own human renderer.
+function output(ctx, data, humanFn) {
+  const ui = require('../ui');
+  switch (outputFormat(ctx.flags)) {
+    case 'json': ui.json(data); return;
+    case 'yaml': process.stdout.write(toYaml(data)); return;
+    case 'env': process.stdout.write(toEnv(data)); return;
+    default: humanFn(data, ui);
+  }
+}
+
+// The same command under a second (Supabase) name: one implementation, with
+// help that shows the name it was reached by.
+function alias(entry, usage, summary = entry.summary) {
+  return { ...entry, usage, summary };
+}
+
+// Parse a dotenv file: `KEY=value`, `export KEY=value`, `#` comments, and
+// single- or double-quoted values (double quotes expand \n).
+function parseDotenv(text) {
+  const out = {};
+  for (const raw of String(text).split(/\r?\n/)) {
+    const line = raw.trim().replace(/^export\s+/, '');
+    if (!line || line.startsWith('#')) continue;
+    const idx = line.indexOf('=');
+    if (idx <= 0) throw new CliError(`invalid env line: "${raw}"`);
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    const quote = value[0];
+    if ((quote === '"' || quote === "'") && value.endsWith(quote) && value.length > 1) {
+      value = value.slice(1, -1);
+      if (quote === '"') value = value.replace(/\\n/g, '\n');
+    } else {
+      value = value.replace(/\s+#.*$/, '');
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+function requireArg(value, name) {
+  if (value === undefined || value === null || value === '') {
+    throw new CliError(`missing required argument: <${name}>`);
+  }
+  return value;
+}
+
+// Split "bucket:path" into { bucket, rest }.
+function splitRef(ref) {
+  const idx = ref.indexOf(':');
+  if (idx < 0) return { bucket: undefined, rest: ref };
+  return { bucket: ref.slice(0, idx), rest: ref.slice(idx + 1) };
+}
+
+// `/projects/<linked project>` on the Console, for the per-project platform
+// surfaces (branches, domains) that live on the Console rather than the
+// project API. They need a Console, so direct mode cannot reach them.
+function consoleProjectPath(ctx, suffix = '') {
+  ctx.requireConsole();
+  if (!ctx.projectId) {
+    throw new CliError('No project linked. Run `motherbase link` or pass --project-ref <id>.');
+  }
+  return `/projects/${encodeURIComponent(ctx.projectId)}${suffix}`;
+}
+
+// Join `parts` under `root`, refusing a result that escapes it. Names that come
+// from the server (object keys, function routes) must not write outside the
+// directory the user picked: `../../.bashrc` is a valid object key.
+function resolveInside(root, ...parts) {
+  const target = path.resolve(root, ...parts);
+  const rel = path.relative(root, target);
+  if (rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+    throw new CliError(`Refusing to write outside ${root}: ${parts.join('/')}`);
+  }
+  return target;
+}
+
+module.exports = { parseKeyValues, output, alias, parseDotenv, requireArg, splitRef, consoleProjectPath, resolveInside };

package/src/commands/backups.js

@@ -1,16 +1,16 @@
-'use strict';
-
-// Supabase's top-level `backups`. The implementations live under `db`, which
-// keeps its own names for them.
-
-const db = require('./db');
-const { alias } = require('./_util');
-
-module.exports = {
-  summary: 'List and restore database backups',
-  usage: 'motherbase backups <list|restore> ...',
-  subcommands: {
-    list: alias(db.subcommands.backups, 'motherbase backups list', 'List database backups'),
-    restore: alias(db.subcommands.restore, 'motherbase backups restore <file> | --key <remoteKey>  --confirm'),
-  },
-};
+'use strict';
+
+// Supabase's top-level `backups`. The implementations live under `db`, which
+// keeps its own names for them.
+
+const db = require('./db');
+const { alias } = require('./_util');
+
+module.exports = {
+  summary: 'List and restore database backups',
+  usage: 'motherbase backups <list|restore> ...',
+  subcommands: {
+    list: alias(db.subcommands.backups, 'motherbase backups list', 'List database backups'),
+    restore: alias(db.subcommands.restore, 'motherbase backups restore <file> | --key <remoteKey>  --confirm'),
+  },
+};

package/src/commands/branches.js

@@ -1,113 +1,113 @@
-'use strict';
-
-// Preview branches (Supabase's `supabase branches`). A branch is a project of
-// its own on the Console, cut from the linked project; these commands address
-// it by its name (e.g. the git branch) or its project id.
-
-const api = require('../api');
-const config = require('../config');
-const { output, requireArg, consoleProjectPath } = require('./_util');
-
-const COLUMNS = [
-  { key: 'name', label: 'NAME' },
-  { key: 'project', label: 'PROJECT' },
-  { key: 'gitBranch', label: 'GIT BRANCH' },
-  { key: 'status', label: 'STATUS' },
-  { key: 'running', label: 'RUNNING' },
-  { key: 'createdAt', label: 'CREATED' },
-];
-
-const branchPath = (ctx, name, action = '') =>
-  consoleProjectPath(ctx, `/branches/${encodeURIComponent(requireArg(name, 'name'))}${action}`);
-
-function action(verb, summary, render) {
-  return {
-    summary,
-    usage: `motherbase branches ${verb} <name>`,
-    async run(ctx, args) {
-      const data = await api.consoleRequest(ctx, 'POST', branchPath(ctx, args[0], `/${verb}`));
-      output(ctx, data, (d, ui) => render(d, ui));
-    },
-  };
-}
-
-const subcommands = {
-  create: {
-    summary: 'Create a preview branch of the linked project',
-    usage: 'motherbase branches create <name> [--git-branch <ref>] [--with-data]',
-    async run(ctx, args, flags) {
-      const body = { name: requireArg(args[0], 'name'), withData: Boolean(flags['with-data']) };
-      if (flags['git-branch']) body.gitBranch = String(flags['git-branch']);
-      const data = await api.consoleRequest(ctx, 'POST', consoleProjectPath(ctx, '/branches'), { body });
-      output(ctx, data, (d, ui) => {
-        ui.success(`Creating branch ${d.name} as project ${d.project} (${d.domain})`);
-        ui.info('This takes a few minutes. Follow it with `motherbase branches get ' + d.name + '`.');
-      });
-    },
-  },
-  list: {
-    summary: 'List the branches of the linked project, main first',
-    usage: 'motherbase branches list',
-    async run(ctx) {
-      const rows = await api.consoleRequest(ctx, 'GET', consoleProjectPath(ctx, '/branches'));
-      output(ctx, { branches: rows }, (d, ui) => ui.table(d.branches, COLUMNS));
-    },
-  },
-  get: {
-    summary: 'Show one branch, with the migrations it is ahead and behind',
-    usage: 'motherbase branches get <name>',
-    async run(ctx, args) {
-      const data = await api.consoleRequest(ctx, 'GET', branchPath(ctx, args[0]));
-      output(ctx, data, (d, ui) => {
-        const { migrations, ...rest } = d;
-        ui.keyValue(rest);
-        if (migrations) ui.keyValue({ ahead: migrations.ahead.join(', ') || '-', behind: migrations.behind.join(', ') || '-' });
-      });
-    },
-  },
-  update: {
-    summary: 'Change a branch\'s git branch',
-    usage: 'motherbase branches update <name> --git-branch <ref>',
-    async run(ctx, args, flags) {
-      const body = {};
-      if (flags['git-branch'] !== undefined) body.gitBranch = String(flags['git-branch']);
-      const data = await api.consoleRequest(ctx, 'PATCH', branchPath(ctx, args[0]), { body });
-      output(ctx, data, (d, ui) => ui.success(`Updated branch ${d.name}`));
-    },
-  },
-  delete: {
-    summary: 'Delete a branch and its whole stack',
-    usage: 'motherbase branches delete <name>',
-    async run(ctx, args) {
-      const data = await api.consoleRequest(ctx, 'DELETE', branchPath(ctx, args[0]));
-      output(ctx, data, (d, ui) => ui.success(`Deleted branch ${d.name}`));
-    },
-  },
-  pause: action('pause', 'Stop a branch\'s stack, keeping its data', (d, ui) => ui.success(`Paused ${d.name}`)),
-  unpause: action('unpause', 'Start a paused branch again', (d, ui) => ui.success(`Unpaused ${d.name}`)),
-  reset: action('reset', 'Recreate a branch from the parent as it is now (its changes are lost)',
-    (d, ui) => ui.success(`Resetting ${d.name}; it is being cut again from ${d.parent}`)),
-  merge: action('merge', 'Apply the branch\'s new migrations to the parent',
-    (d, ui) => ui.success(d.applied.length ? `Merged ${d.applied.length} migration(s): ${d.applied.join(', ')}` : 'Nothing to merge')),
-  rebase: action('rebase', 'Apply the parent\'s newer migrations to the branch',
-    (d, ui) => ui.success(d.applied.length ? `Rebased ${d.applied.length} migration(s): ${d.applied.join(', ')}` : 'Already up to date')),
-  switch: {
-    summary: 'Point this directory\'s link at a branch (or back at main)',
-    usage: 'motherbase branches switch <name|main>',
-    async run(ctx, args) {
-      const name = requireArg(args[0], 'name');
-      const rows = await api.consoleRequest(ctx, 'GET', consoleProjectPath(ctx, '/branches'));
-      const match = rows.find(b => b.name === name || b.project === name || (name === 'main' && b.isDefault));
-      if (!match) throw new Error(`No branch ${name}. See \`motherbase branches list\`.`);
-      const link = config.readLink(ctx.cwd) || {};
-      config.writeLink(ctx.cwd, { ...link, consoleUrl: ctx.consoleUrl, projectId: match.project, projectName: match.project });
-      output(ctx, { project: match.project, branch: match.name }, (d, ui) => ui.success(`Linked ${ctx.cwd} → ${d.project} (${d.branch})`));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Manage preview branches of the linked project',
-  usage: 'motherbase branches <create|list|get|update|delete|pause|unpause|reset|merge|rebase|switch> ...',
-  subcommands,
-};
+'use strict';
+
+// Preview branches (Supabase's `supabase branches`). A branch is a project of
+// its own on the Console, cut from the linked project; these commands address
+// it by its name (e.g. the git branch) or its project id.
+
+const api = require('../api');
+const config = require('../config');
+const { output, requireArg, consoleProjectPath } = require('./_util');
+
+const COLUMNS = [
+  { key: 'name', label: 'NAME' },
+  { key: 'project', label: 'PROJECT' },
+  { key: 'gitBranch', label: 'GIT BRANCH' },
+  { key: 'status', label: 'STATUS' },
+  { key: 'running', label: 'RUNNING' },
+  { key: 'createdAt', label: 'CREATED' },
+];
+
+const branchPath = (ctx, name, action = '') =>
+  consoleProjectPath(ctx, `/branches/${encodeURIComponent(requireArg(name, 'name'))}${action}`);
+
+function action(verb, summary, render) {
+  return {
+    summary,
+    usage: `motherbase branches ${verb} <name>`,
+    async run(ctx, args) {
+      const data = await api.consoleRequest(ctx, 'POST', branchPath(ctx, args[0], `/${verb}`));
+      output(ctx, data, (d, ui) => render(d, ui));
+    },
+  };
+}
+
+const subcommands = {
+  create: {
+    summary: 'Create a preview branch of the linked project',
+    usage: 'motherbase branches create <name> [--git-branch <ref>] [--with-data]',
+    async run(ctx, args, flags) {
+      const body = { name: requireArg(args[0], 'name'), withData: Boolean(flags['with-data']) };
+      if (flags['git-branch']) body.gitBranch = String(flags['git-branch']);
+      const data = await api.consoleRequest(ctx, 'POST', consoleProjectPath(ctx, '/branches'), { body });
+      output(ctx, data, (d, ui) => {
+        ui.success(`Creating branch ${d.name} as project ${d.project} (${d.domain})`);
+        ui.info('This takes a few minutes. Follow it with `motherbase branches get ' + d.name + '`.');
+      });
+    },
+  },
+  list: {
+    summary: 'List the branches of the linked project, main first',
+    usage: 'motherbase branches list',
+    async run(ctx) {
+      const rows = await api.consoleRequest(ctx, 'GET', consoleProjectPath(ctx, '/branches'));
+      output(ctx, { branches: rows }, (d, ui) => ui.table(d.branches, COLUMNS));
+    },
+  },
+  get: {
+    summary: 'Show one branch, with the migrations it is ahead and behind',
+    usage: 'motherbase branches get <name>',
+    async run(ctx, args) {
+      const data = await api.consoleRequest(ctx, 'GET', branchPath(ctx, args[0]));
+      output(ctx, data, (d, ui) => {
+        const { migrations, ...rest } = d;
+        ui.keyValue(rest);
+        if (migrations) ui.keyValue({ ahead: migrations.ahead.join(', ') || '-', behind: migrations.behind.join(', ') || '-' });
+      });
+    },
+  },
+  update: {
+    summary: 'Change a branch\'s git branch',
+    usage: 'motherbase branches update <name> --git-branch <ref>',
+    async run(ctx, args, flags) {
+      const body = {};
+      if (flags['git-branch'] !== undefined) body.gitBranch = String(flags['git-branch']);
+      const data = await api.consoleRequest(ctx, 'PATCH', branchPath(ctx, args[0]), { body });
+      output(ctx, data, (d, ui) => ui.success(`Updated branch ${d.name}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a branch and its whole stack',
+    usage: 'motherbase branches delete <name>',
+    async run(ctx, args) {
+      const data = await api.consoleRequest(ctx, 'DELETE', branchPath(ctx, args[0]));
+      output(ctx, data, (d, ui) => ui.success(`Deleted branch ${d.name}`));
+    },
+  },
+  pause: action('pause', 'Stop a branch\'s stack, keeping its data', (d, ui) => ui.success(`Paused ${d.name}`)),
+  unpause: action('unpause', 'Start a paused branch again', (d, ui) => ui.success(`Unpaused ${d.name}`)),
+  reset: action('reset', 'Recreate a branch from the parent as it is now (its changes are lost)',
+    (d, ui) => ui.success(`Resetting ${d.name}; it is being cut again from ${d.parent}`)),
+  merge: action('merge', 'Apply the branch\'s new migrations to the parent',
+    (d, ui) => ui.success(d.applied.length ? `Merged ${d.applied.length} migration(s): ${d.applied.join(', ')}` : 'Nothing to merge')),
+  rebase: action('rebase', 'Apply the parent\'s newer migrations to the branch',
+    (d, ui) => ui.success(d.applied.length ? `Rebased ${d.applied.length} migration(s): ${d.applied.join(', ')}` : 'Already up to date')),
+  switch: {
+    summary: 'Point this directory\'s link at a branch (or back at main)',
+    usage: 'motherbase branches switch <name|main>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'name');
+      const rows = await api.consoleRequest(ctx, 'GET', consoleProjectPath(ctx, '/branches'));
+      const match = rows.find(b => b.name === name || b.project === name || (name === 'main' && b.isDefault));
+      if (!match) throw new Error(`No branch ${name}. See \`motherbase branches list\`.`);
+      const link = config.readLink(ctx.cwd) || {};
+      config.writeLink(ctx.cwd, { ...link, consoleUrl: ctx.consoleUrl, projectId: match.project, projectName: match.project });
+      output(ctx, { project: match.project, branch: match.name }, (d, ui) => ui.success(`Linked ${ctx.cwd} → ${d.project} (${d.branch})`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Manage preview branches of the linked project',
+  usage: 'motherbase branches <create|list|get|update|delete|pause|unpause|reset|merge|rebase|switch> ...',
+  subcommands,
+};