@motherbase/cli 0.2.6 → 0.2.9

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,
+};

package/src/commands/completion.js

@@ -1,90 +1,90 @@
-'use strict';
-
-// `completion <shell>`: a completion script generated from the command
-// registry, so it can never list a command that does not exist.
-
-const { requireArg } = require('./_util');
-const { CliError } = require('../context');
-
-// Every command path that has children, with those children:
-// [{ path: 'storage buckets', children: [{ name: 'list', summary }] }, ...].
-// The root is the path ''.
-function commandPaths(registry) {
-  const out = [];
-  const walk = (path, subcommands) => {
-    const names = Object.keys(subcommands);
-    out.push({ path, children: names.map(name => ({ name, summary: subcommands[name].summary || '' })) });
-    for (const name of names) {
-      const sub = subcommands[name].subcommands;
-      if (sub) walk(path ? `${path} ${name}` : name, sub);
-    }
-  };
-  walk('', registry);
-  return out;
-}
-
-// The words typed so far, flags skipped, are the path whose children complete.
-function bash(paths) {
-  const cases = paths
-    .map(p => `    "${p.path}") words="${p.children.map(c => c.name).join(' ')}" ;;`)
-    .join('\n');
-  return `# motherbase bash completion. Load with: source <(motherbase completion bash)
-_motherbase() {
-  local cur="\${COMP_WORDS[COMP_CWORD]}" path="" words="" i
-  for ((i = 1; i < COMP_CWORD; i++)); do
-    [[ \${COMP_WORDS[i]} == -* ]] && continue
-    path="\${path:+$path }\${COMP_WORDS[i]}"
-  done
-  case "$path" in
-${cases}
-  esac
-  COMPREPLY=($(compgen -W "$words" -- "$cur"))
-}
-complete -F _motherbase motherbase
-`;
-}
-
-// zsh runs the bash function through its bashcompinit shim.
-function zsh(paths) {
-  return `# motherbase zsh completion. Load with: source <(motherbase completion zsh)
-autoload -U +X bashcompinit && bashcompinit
-${bash(paths).split('\n').slice(1).join('\n')}`;
-}
-
-function fishQuote(text) {
-  return `'${String(text).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
-}
-
-function fish(paths) {
-  const lines = paths.flatMap(p =>
-    p.children.map(
-      c => `complete -c motherbase -f -n ${fishQuote(`__motherbase_at '${p.path}'`)} -a ${fishQuote(c.name)} -d ${fishQuote(c.summary)}`,
-    ),
-  );
-  return `# motherbase fish completion. Load with: motherbase completion fish | source
-function __motherbase_at
-    set -l path (string join ' ' -- (string match -v -- '-*' (commandline -opc)[2..-1]))
-    test "$path" = "$argv[1]"
-end
-${lines.join('\n')}
-`;
-}
-
-const SHELLS = { bash, zsh, fish };
-
-function completionScript(shell, registry) {
-  if (!SHELLS[shell]) throw new CliError(`shell must be one of: ${Object.keys(SHELLS).join(', ')}`);
-  return SHELLS[shell](commandPaths(registry));
-}
-
-module.exports = {
-  summary: 'Generate the autocompletion script for a shell',
-  usage: 'motherbase completion <bash|zsh|fish>',
-  run(ctx, args) {
-    const shell = requireArg(args[0], 'shell');
-    // Required here, not at the top: the registry itself requires this file.
-    const { registry } = require('./index');
-    process.stdout.write(completionScript(shell, registry));
-  },
-  completionScript,
-};
+'use strict';
+
+// `completion <shell>`: a completion script generated from the command
+// registry, so it can never list a command that does not exist.
+
+const { requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+// Every command path that has children, with those children:
+// [{ path: 'storage buckets', children: [{ name: 'list', summary }] }, ...].
+// The root is the path ''.
+function commandPaths(registry) {
+  const out = [];
+  const walk = (path, subcommands) => {
+    const names = Object.keys(subcommands);
+    out.push({ path, children: names.map(name => ({ name, summary: subcommands[name].summary || '' })) });
+    for (const name of names) {
+      const sub = subcommands[name].subcommands;
+      if (sub) walk(path ? `${path} ${name}` : name, sub);
+    }
+  };
+  walk('', registry);
+  return out;
+}
+
+// The words typed so far, flags skipped, are the path whose children complete.
+function bash(paths) {
+  const cases = paths
+    .map(p => `    "${p.path}") words="${p.children.map(c => c.name).join(' ')}" ;;`)
+    .join('\n');
+  return `# motherbase bash completion. Load with: source <(motherbase completion bash)
+_motherbase() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}" path="" words="" i
+  for ((i = 1; i < COMP_CWORD; i++)); do
+    [[ \${COMP_WORDS[i]} == -* ]] && continue
+    path="\${path:+$path }\${COMP_WORDS[i]}"
+  done
+  case "$path" in
+${cases}
+  esac
+  COMPREPLY=($(compgen -W "$words" -- "$cur"))
+}
+complete -F _motherbase motherbase
+`;
+}
+
+// zsh runs the bash function through its bashcompinit shim.
+function zsh(paths) {
+  return `# motherbase zsh completion. Load with: source <(motherbase completion zsh)
+autoload -U +X bashcompinit && bashcompinit
+${bash(paths).split('\n').slice(1).join('\n')}`;
+}
+
+function fishQuote(text) {
+  return `'${String(text).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+function fish(paths) {
+  const lines = paths.flatMap(p =>
+    p.children.map(
+      c => `complete -c motherbase -f -n ${fishQuote(`__motherbase_at '${p.path}'`)} -a ${fishQuote(c.name)} -d ${fishQuote(c.summary)}`,
+    ),
+  );
+  return `# motherbase fish completion. Load with: motherbase completion fish | source
+function __motherbase_at
+    set -l path (string join ' ' -- (string match -v -- '-*' (commandline -opc)[2..-1]))
+    test "$path" = "$argv[1]"
+end
+${lines.join('\n')}
+`;
+}
+
+const SHELLS = { bash, zsh, fish };
+
+function completionScript(shell, registry) {
+  if (!SHELLS[shell]) throw new CliError(`shell must be one of: ${Object.keys(SHELLS).join(', ')}`);
+  return SHELLS[shell](commandPaths(registry));
+}
+
+module.exports = {
+  summary: 'Generate the autocompletion script for a shell',
+  usage: 'motherbase completion <bash|zsh|fish>',
+  run(ctx, args) {
+    const shell = requireArg(args[0], 'shell');
+    // Required here, not at the top: the registry itself requires this file.
+    const { registry } = require('./index');
+    process.stdout.write(completionScript(shell, registry));
+  },
+  completionScript,
+};

package/src/commands/config.js

@@ -1,47 +1,47 @@
-'use strict';
-
-const api = require('../api');
-const { output, requireArg, parseKeyValues } = require('./_util');
-
-const subcommands = {
-  list: {
-    summary: 'List setting groups',
-    usage: 'motherbase config list',
-    async run(ctx) {
-      const data = await api.adminRequest(ctx, 'GET', '/settings');
-      const groups = (data && data.groups) || [];
-      output(ctx, data, (_d, ui) =>
-        ui.table(groups, [
-          { key: 'key', label: 'GROUP' },
-          { key: 'label', label: 'LABEL' },
-          { key: 'source', label: 'SOURCE' },
-        ]),
-      );
-    },
-  },
-  get: {
-    summary: 'Get a settings group',
-    usage: 'motherbase config get <group>',
-    async run(ctx, args) {
-      const group = requireArg(args[0], 'group');
-      const data = await api.adminRequest(ctx, 'GET', `/settings/${group}`);
-      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
-    },
-  },
-  set: {
-    summary: 'Set values in a settings group',
-    usage: 'motherbase config set <group> key=value [key2=value2 ...]',
-    async run(ctx, args) {
-      const group = requireArg(args[0], 'group');
-      const body = parseKeyValues(args.slice(1));
-      const data = await api.adminRequest(ctx, 'PUT', `/settings/${group}`, { body });
-      output(ctx, data, (d, ui) => ui.success(`Saved settings for ${group}`));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Project settings groups',
-  usage: 'motherbase config <list|get|set> ...',
-  subcommands,
-};
+'use strict';
+
+const api = require('../api');
+const { output, requireArg, parseKeyValues } = require('./_util');
+
+const subcommands = {
+  list: {
+    summary: 'List setting groups',
+    usage: 'motherbase config list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/settings');
+      const groups = (data && data.groups) || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(groups, [
+          { key: 'key', label: 'GROUP' },
+          { key: 'label', label: 'LABEL' },
+          { key: 'source', label: 'SOURCE' },
+        ]),
+      );
+    },
+  },
+  get: {
+    summary: 'Get a settings group',
+    usage: 'motherbase config get <group>',
+    async run(ctx, args) {
+      const group = requireArg(args[0], 'group');
+      const data = await api.adminRequest(ctx, 'GET', `/settings/${group}`);
+      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
+    },
+  },
+  set: {
+    summary: 'Set values in a settings group',
+    usage: 'motherbase config set <group> key=value [key2=value2 ...]',
+    async run(ctx, args) {
+      const group = requireArg(args[0], 'group');
+      const body = parseKeyValues(args.slice(1));
+      const data = await api.adminRequest(ctx, 'PUT', `/settings/${group}`, { body });
+      output(ctx, data, (d, ui) => ui.success(`Saved settings for ${group}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Project settings groups',
+  usage: 'motherbase config <list|get|set> ...',
+  subcommands,
+};

package/src/commands/cron.js

@@ -1,65 +1,65 @@
-'use strict';
-
-const api = require('../api');
-const { output, requireArg } = require('./_util');
-const { CliError } = require('../context');
-
-const subcommands = {
-  list: {
-    summary: 'List pg_cron jobs (and app jobs with --app)',
-    usage: 'motherbase cron list [--app]',
-    async run(ctx, args, flags) {
-      if (flags.app) {
-        const data = await api.adminRequest(ctx, 'GET', '/cron/app/jobs');
-        const jobs = (data && data.jobs) || [];
-        output(ctx, data, (_d, ui) => ui.table(jobs, [{ key: 'name', label: 'NAME' }, { key: 'schedule', label: 'SCHEDULE' }]));
-        return;
-      }
-      const data = await api.adminRequest(ctx, 'GET', '/cron/pg/jobs');
-      const jobs = Array.isArray(data) ? data : (data && data.jobs) || [];
-      output(ctx, data, (_d, ui) =>
-        ui.table(jobs, [
-          { key: 'jobid', label: 'ID' },
-          { key: 'jobname', label: 'NAME' },
-          { key: 'schedule', label: 'SCHEDULE' },
-          { key: 'active', label: 'ACTIVE' },
-        ]),
-      );
-    },
-  },
-  create: {
-    summary: 'Create a pg_cron job',
-    usage: 'motherbase cron create --name <n> --schedule "<cron>" --command "<sql>"',
-    async run(ctx, args, flags) {
-      if (!flags.name || !flags.schedule || !flags.command) throw new CliError('--name, --schedule and --command are required');
-      const body = { name: flags.name, schedule: flags.schedule, command: flags.command };
-      const data = await api.adminRequest(ctx, 'POST', '/cron/pg/jobs', { body });
-      output(ctx, data, (d, ui) => ui.success(`Created cron job ${flags.name}`));
-    },
-  },
-  delete: {
-    summary: 'Delete a pg_cron job by numeric id',
-    usage: 'motherbase cron delete <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'DELETE', `/cron/pg/jobs/${id}`);
-      output(ctx, data, (d, ui) => ui.success(`Deleted cron job ${id}`));
-    },
-  },
-  toggle: {
-    summary: 'Enable/disable a pg_cron job',
-    usage: 'motherbase cron toggle <id> --active <true|false>',
-    async run(ctx, args, flags) {
-      const id = requireArg(args[0], 'id');
-      const active = flags.active === undefined ? true : flags.active === 'true' || flags.active === true;
-      const data = await api.adminRequest(ctx, 'PATCH', `/cron/pg/jobs/${id}`, { body: { active } });
-      output(ctx, data, (d, ui) => ui.success(`Cron job ${id} active=${active}`));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Scheduled jobs (pg_cron)',
-  usage: 'motherbase cron <list|create|delete|toggle> ...',
-  subcommands,
-};
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const subcommands = {
+  list: {
+    summary: 'List pg_cron jobs (and app jobs with --app)',
+    usage: 'motherbase cron list [--app]',
+    async run(ctx, args, flags) {
+      if (flags.app) {
+        const data = await api.adminRequest(ctx, 'GET', '/cron/app/jobs');
+        const jobs = (data && data.jobs) || [];
+        output(ctx, data, (_d, ui) => ui.table(jobs, [{ key: 'name', label: 'NAME' }, { key: 'schedule', label: 'SCHEDULE' }]));
+        return;
+      }
+      const data = await api.adminRequest(ctx, 'GET', '/cron/pg/jobs');
+      const jobs = Array.isArray(data) ? data : (data && data.jobs) || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(jobs, [
+          { key: 'jobid', label: 'ID' },
+          { key: 'jobname', label: 'NAME' },
+          { key: 'schedule', label: 'SCHEDULE' },
+          { key: 'active', label: 'ACTIVE' },
+        ]),
+      );
+    },
+  },
+  create: {
+    summary: 'Create a pg_cron job',
+    usage: 'motherbase cron create --name <n> --schedule "<cron>" --command "<sql>"',
+    async run(ctx, args, flags) {
+      if (!flags.name || !flags.schedule || !flags.command) throw new CliError('--name, --schedule and --command are required');
+      const body = { name: flags.name, schedule: flags.schedule, command: flags.command };
+      const data = await api.adminRequest(ctx, 'POST', '/cron/pg/jobs', { body });
+      output(ctx, data, (d, ui) => ui.success(`Created cron job ${flags.name}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a pg_cron job by numeric id',
+    usage: 'motherbase cron delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/cron/pg/jobs/${id}`);
+      output(ctx, data, (d, ui) => ui.success(`Deleted cron job ${id}`));
+    },
+  },
+  toggle: {
+    summary: 'Enable/disable a pg_cron job',
+    usage: 'motherbase cron toggle <id> --active <true|false>',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const active = flags.active === undefined ? true : flags.active === 'true' || flags.active === true;
+      const data = await api.adminRequest(ctx, 'PATCH', `/cron/pg/jobs/${id}`, { body: { active } });
+      output(ctx, data, (d, ui) => ui.success(`Cron job ${id} active=${active}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Scheduled jobs (pg_cron)',
+  usage: 'motherbase cron <list|create|delete|toggle> ...',
+  subcommands,
+};