@motherbase/cli 0.2.6 → 0.2.8

package/src/commands/network.js

@@ -1,83 +1,83 @@
-'use strict';
-
-// Who may open a direct Postgres connection (Supabase's `network-restrictions`
-// and `ssl-enforcement`). Both are project admin routes, so they work through
-// the Console proxy and in direct mode alike.
-
-const api = require('../api');
-const { output } = require('./_util');
-const { CliError } = require('../context');
-
-function renderRestrictions(d, ui) {
-  ui.keyValue({
-    'IPv4 allowed': d.dbAllowedCidrs.join(', ') || '(none)',
-    'IPv6 allowed': d.dbAllowedCidrsV6.join(', ') || '(none)',
-    status: d.status,
-    exposure: d.exposure,
-  });
-  if (d.status !== 'applied') ui.warn('Stored only: this API does not manage its database access (not a Console stack).');
-  if (d.exposure !== 'public') ui.info('The database port is not public, so only the stack and SSH tunnels reach it today.');
-}
-
-const networkRestrictions = {
-  summary: 'IP ranges allowed to connect to the database directly',
-  usage: 'motherbase network-restrictions <get|update> ...',
-  subcommands: {
-    get: {
-      summary: 'Show the allowed ranges',
-      usage: 'motherbase network-restrictions get',
-      async run(ctx) {
-        output(ctx, await api.adminRequest(ctx, 'GET', '/network-restrictions'), renderRestrictions);
-      },
-    },
-    update: {
-      summary: 'Replace the allowed ranges (repeat --db-allow-cidr; IPv4 and IPv6 are told apart)',
-      usage: 'motherbase network-restrictions update --db-allow-cidr <cidr> [--db-allow-cidr <cidr> ...]',
-      async run(ctx, _args, flags) {
-        const cidrs = [].concat(flags['db-allow-cidr'] ?? []).map(String);
-        if (!cidrs.length) {
-          throw new CliError('Pass at least one --db-allow-cidr (0.0.0.0/0 and ::/0 allow everyone).');
-        }
-        const body = {
-          dbAllowedCidrs: cidrs.filter(c => !c.includes(':')),
-          dbAllowedCidrsV6: cidrs.filter(c => c.includes(':')),
-        };
-        output(ctx, await api.adminRequest(ctx, 'PUT', '/network-restrictions', { body }), renderRestrictions);
-      },
-    },
-  },
-};
-
-function renderSsl(d, ui) {
-  ui.keyValue({ enforced: d.enforced, 'TLS active': d.sslActive, status: d.status });
-  if (d.enforced) ui.info('External clients must connect with sslmode=require.');
-}
-
-const sslEnforcement = {
-  summary: 'Require TLS for direct database connections',
-  usage: 'motherbase ssl-enforcement <get|update> ...',
-  subcommands: {
-    get: {
-      summary: 'Show whether TLS is enforced',
-      usage: 'motherbase ssl-enforcement get',
-      async run(ctx) {
-        output(ctx, await api.adminRequest(ctx, 'GET', '/ssl-enforcement'), renderSsl);
-      },
-    },
-    update: {
-      summary: 'Turn enforcement on or off',
-      usage: 'motherbase ssl-enforcement update --enable-db-ssl-enforcement | --disable-db-ssl-enforcement',
-      async run(ctx, _args, flags) {
-        const enable = Boolean(flags['enable-db-ssl-enforcement']);
-        const disable = Boolean(flags['disable-db-ssl-enforcement']);
-        if (enable === disable) {
-          throw new CliError('Pass exactly one of --enable-db-ssl-enforcement or --disable-db-ssl-enforcement.');
-        }
-        const data = await api.adminRequest(ctx, 'PUT', '/ssl-enforcement', { body: { enforced: enable } });
-        output(ctx, data, renderSsl);
-      },
-    },
-  },
-};
-
-module.exports = { networkRestrictions, sslEnforcement };
+'use strict';
+
+// Who may open a direct Postgres connection (Supabase's `network-restrictions`
+// and `ssl-enforcement`). Both are project admin routes, so they work through
+// the Console proxy and in direct mode alike.
+
+const api = require('../api');
+const { output } = require('./_util');
+const { CliError } = require('../context');
+
+function renderRestrictions(d, ui) {
+  ui.keyValue({
+    'IPv4 allowed': d.dbAllowedCidrs.join(', ') || '(none)',
+    'IPv6 allowed': d.dbAllowedCidrsV6.join(', ') || '(none)',
+    status: d.status,
+    exposure: d.exposure,
+  });
+  if (d.status !== 'applied') ui.warn('Stored only: this API does not manage its database access (not a Console stack).');
+  if (d.exposure !== 'public') ui.info('The database port is not public, so only the stack and SSH tunnels reach it today.');
+}
+
+const networkRestrictions = {
+  summary: 'IP ranges allowed to connect to the database directly',
+  usage: 'motherbase network-restrictions <get|update> ...',
+  subcommands: {
+    get: {
+      summary: 'Show the allowed ranges',
+      usage: 'motherbase network-restrictions get',
+      async run(ctx) {
+        output(ctx, await api.adminRequest(ctx, 'GET', '/network-restrictions'), renderRestrictions);
+      },
+    },
+    update: {
+      summary: 'Replace the allowed ranges (repeat --db-allow-cidr; IPv4 and IPv6 are told apart)',
+      usage: 'motherbase network-restrictions update --db-allow-cidr <cidr> [--db-allow-cidr <cidr> ...]',
+      async run(ctx, _args, flags) {
+        const cidrs = [].concat(flags['db-allow-cidr'] ?? []).map(String);
+        if (!cidrs.length) {
+          throw new CliError('Pass at least one --db-allow-cidr (0.0.0.0/0 and ::/0 allow everyone).');
+        }
+        const body = {
+          dbAllowedCidrs: cidrs.filter(c => !c.includes(':')),
+          dbAllowedCidrsV6: cidrs.filter(c => c.includes(':')),
+        };
+        output(ctx, await api.adminRequest(ctx, 'PUT', '/network-restrictions', { body }), renderRestrictions);
+      },
+    },
+  },
+};
+
+function renderSsl(d, ui) {
+  ui.keyValue({ enforced: d.enforced, 'TLS active': d.sslActive, status: d.status });
+  if (d.enforced) ui.info('External clients must connect with sslmode=require.');
+}
+
+const sslEnforcement = {
+  summary: 'Require TLS for direct database connections',
+  usage: 'motherbase ssl-enforcement <get|update> ...',
+  subcommands: {
+    get: {
+      summary: 'Show whether TLS is enforced',
+      usage: 'motherbase ssl-enforcement get',
+      async run(ctx) {
+        output(ctx, await api.adminRequest(ctx, 'GET', '/ssl-enforcement'), renderSsl);
+      },
+    },
+    update: {
+      summary: 'Turn enforcement on or off',
+      usage: 'motherbase ssl-enforcement update --enable-db-ssl-enforcement | --disable-db-ssl-enforcement',
+      async run(ctx, _args, flags) {
+        const enable = Boolean(flags['enable-db-ssl-enforcement']);
+        const disable = Boolean(flags['disable-db-ssl-enforcement']);
+        if (enable === disable) {
+          throw new CliError('Pass exactly one of --enable-db-ssl-enforcement or --disable-db-ssl-enforcement.');
+        }
+        const data = await api.adminRequest(ctx, 'PUT', '/ssl-enforcement', { body: { enforced: enable } });
+        output(ctx, data, renderSsl);
+      },
+    },
+  },
+};
+
+module.exports = { networkRestrictions, sslEnforcement };

package/src/commands/orgs.js

@@ -1,40 +1,40 @@
-'use strict';
-
-// Tenant organizations on the Platform Console. Projects sit under an org, as
-// they do on Supabase.
-
-const api = require('../api');
-const { output, requireArg } = require('./_util');
-
-const subcommands = {
-  list: {
-    summary: 'List the organizations you belong to',
-    usage: 'motherbase orgs list',
-    async run(ctx) {
-      const data = await api.consoleRequest(ctx, 'GET', '/orgs');
-      output(ctx, data, (rows, ui) =>
-        ui.table(Array.isArray(rows) ? rows : [], [
-          { key: 'id', label: 'ID' },
-          { key: 'name', label: 'NAME' },
-          { key: 'role', label: 'ROLE' },
-          { key: 'projectCount', label: 'PROJECTS' },
-        ]),
-      );
-    },
-  },
-  create: {
-    summary: 'Create an organization',
-    usage: 'motherbase orgs create <name>',
-    async run(ctx, args) {
-      const name = requireArg(args[0], 'name');
-      const data = await api.consoleRequest(ctx, 'POST', '/orgs', { body: { name } });
-      output(ctx, data, (d, ui) => ui.success(`Created org ${d.name} (${d.id})`));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Manage organizations on the Platform Console',
-  usage: 'motherbase orgs <list|create> ...',
-  subcommands,
-};
+'use strict';
+
+// Tenant organizations on the Platform Console. Projects sit under an org, as
+// they do on Supabase.
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+
+const subcommands = {
+  list: {
+    summary: 'List the organizations you belong to',
+    usage: 'motherbase orgs list',
+    async run(ctx) {
+      const data = await api.consoleRequest(ctx, 'GET', '/orgs');
+      output(ctx, data, (rows, ui) =>
+        ui.table(Array.isArray(rows) ? rows : [], [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'role', label: 'ROLE' },
+          { key: 'projectCount', label: 'PROJECTS' },
+        ]),
+      );
+    },
+  },
+  create: {
+    summary: 'Create an organization',
+    usage: 'motherbase orgs create <name>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'name');
+      const data = await api.consoleRequest(ctx, 'POST', '/orgs', { body: { name } });
+      output(ctx, data, (d, ui) => ui.success(`Created org ${d.name} (${d.id})`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Manage organizations on the Platform Console',
+  usage: 'motherbase orgs <list|create> ...',
+  subcommands,
+};

package/src/commands/postgres-config.js

@@ -1,113 +1,113 @@
-'use strict';
-
-// `motherbase postgres-config get|update|delete`, Supabase's command of the
-// same name. The one difference is where a value lands: the server picks the
-// narrowest scope Postgres allows (a per-database override for
-// `statement_timeout`, ALTER SYSTEM for `shared_buffers`), and `--scope`
-// overrides that. Motherbase never restarts Postgres itself, so `--no-restart`
-// is accepted for script compatibility and a restart-only change is reported.
-
-const api = require('../api');
-const { output, parseKeyValues } = require('./_util');
-const { CliError } = require('../context');
-
-const SCOPES = ['database', 'role', 'system'];
-
-function scopeFlags(flags) {
-  if (flags.scope !== undefined && !SCOPES.includes(flags.scope)) {
-    throw new CliError(`--scope must be one of: ${SCOPES.join(', ')}`);
-  }
-  if (flags.scope === 'role' && !flags.role) throw new CliError('--scope role needs --role <name>');
-  return {
-    ...(flags.scope ? { scope: flags.scope } : {}),
-    ...(flags.role ? { role: String(flags.role) } : {}),
-  };
-}
-
-// What `get` prints: one row per setting that has an override, like Supabase,
-// or every curated setting with --all.
-function overrideRows(config, all) {
-  return config.settings.flatMap(setting => {
-    if (!setting.overrides.length) {
-      return all ? [{ name: setting.name, value: setting.value, scope: '', role: '', restart: setting.context === 'postmaster' }] : [];
-    }
-    return setting.overrides.map(o => ({
-      name: setting.name,
-      value: o.value,
-      scope: o.scope,
-      role: o.role || '',
-      restart: setting.context === 'postmaster',
-    }));
-  });
-}
-
-function reportChange(result, ui) {
-  for (const change of result.applied) {
-    ui.success(`${change.name}: ${change.scope}${change.role ? ` (${change.role})` : ''}`);
-  }
-  if (result.restartRequired.length) {
-    ui.warn(`Restart Postgres to apply: ${result.restartRequired.join(', ')}`);
-  }
-}
-
-const subcommands = {
-  get: {
-    summary: 'Show Postgres config overrides (--all for every managed setting)',
-    usage: 'motherbase postgres-config get [--all]',
-    async run(ctx, args, flags) {
-      const data = await api.adminRequest(ctx, 'GET', '/database/config');
-      output(ctx, data, (d, ui) => {
-        ui.table(overrideRows(d, Boolean(flags.all)), [
-          { key: 'name', label: 'PARAMETER' },
-          { key: 'value', label: 'VALUE' },
-          { key: 'scope', label: 'SCOPE' },
-          { key: 'role', label: 'ROLE' },
-          { key: 'restart', label: 'NEEDS RESTART' },
-        ]);
-        if (!d.systemOverridesReadable) ui.warn('System-level overrides could not be read with this connection.');
-      });
-    },
-  },
-  update: {
-    summary: 'Set Postgres config values',
-    usage: 'motherbase postgres-config update --config key=value [--config ...] [--scope database|role|system] [--role r] [--replace-existing-overrides]',
-    async run(ctx, args, flags) {
-      const values = parseKeyValues([].concat(flags.config || []).filter(Boolean), { coerce: false });
-      if (!Object.keys(values).length) throw new CliError('Provide at least one --config key=value.');
-      const target = scopeFlags(flags);
-      const changes = Object.entries(values).map(([name, value]) => ({ name, value, ...target }));
-
-      // Supabase's flag: anything overridden before and not named now goes back to its default.
-      if (flags['replace-existing-overrides']) {
-        const current = await api.adminRequest(ctx, 'GET', '/database/config');
-        for (const setting of current.settings) {
-          if (setting.name in values) continue;
-          for (const o of setting.overrides) {
-            changes.push({ name: setting.name, value: null, scope: o.scope, ...(o.role ? { role: o.role } : {}) });
-          }
-        }
-      }
-
-      const data = await api.adminRequest(ctx, 'PATCH', '/database/config', { body: { changes } });
-      output(ctx, data, (d, ui) => reportChange(d, ui));
-    },
-  },
-  delete: {
-    summary: 'Remove Postgres config overrides, restoring the defaults',
-    usage: 'motherbase postgres-config delete --config key1,key2 [--scope database|role|system] [--role r]',
-    async run(ctx, args, flags) {
-      const names = [].concat(flags.config || []).flatMap(v => String(v).split(',')).map(s => s.trim()).filter(Boolean);
-      if (!names.length) throw new CliError('Provide the settings to reset with --config key1,key2.');
-      const target = scopeFlags(flags);
-      const changes = names.map(name => ({ name, value: null, ...target }));
-      const data = await api.adminRequest(ctx, 'PATCH', '/database/config', { body: { changes } });
-      output(ctx, data, (d, ui) => reportChange(d, ui));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Postgres configuration (statement_timeout, work_mem, max_connections, ...)',
-  usage: 'motherbase postgres-config <get|update|delete> ...',
-  subcommands,
-};
+'use strict';
+
+// `motherbase postgres-config get|update|delete`, Supabase's command of the
+// same name. The one difference is where a value lands: the server picks the
+// narrowest scope Postgres allows (a per-database override for
+// `statement_timeout`, ALTER SYSTEM for `shared_buffers`), and `--scope`
+// overrides that. Motherbase never restarts Postgres itself, so `--no-restart`
+// is accepted for script compatibility and a restart-only change is reported.
+
+const api = require('../api');
+const { output, parseKeyValues } = require('./_util');
+const { CliError } = require('../context');
+
+const SCOPES = ['database', 'role', 'system'];
+
+function scopeFlags(flags) {
+  if (flags.scope !== undefined && !SCOPES.includes(flags.scope)) {
+    throw new CliError(`--scope must be one of: ${SCOPES.join(', ')}`);
+  }
+  if (flags.scope === 'role' && !flags.role) throw new CliError('--scope role needs --role <name>');
+  return {
+    ...(flags.scope ? { scope: flags.scope } : {}),
+    ...(flags.role ? { role: String(flags.role) } : {}),
+  };
+}
+
+// What `get` prints: one row per setting that has an override, like Supabase,
+// or every curated setting with --all.
+function overrideRows(config, all) {
+  return config.settings.flatMap(setting => {
+    if (!setting.overrides.length) {
+      return all ? [{ name: setting.name, value: setting.value, scope: '', role: '', restart: setting.context === 'postmaster' }] : [];
+    }
+    return setting.overrides.map(o => ({
+      name: setting.name,
+      value: o.value,
+      scope: o.scope,
+      role: o.role || '',
+      restart: setting.context === 'postmaster',
+    }));
+  });
+}
+
+function reportChange(result, ui) {
+  for (const change of result.applied) {
+    ui.success(`${change.name}: ${change.scope}${change.role ? ` (${change.role})` : ''}`);
+  }
+  if (result.restartRequired.length) {
+    ui.warn(`Restart Postgres to apply: ${result.restartRequired.join(', ')}`);
+  }
+}
+
+const subcommands = {
+  get: {
+    summary: 'Show Postgres config overrides (--all for every managed setting)',
+    usage: 'motherbase postgres-config get [--all]',
+    async run(ctx, args, flags) {
+      const data = await api.adminRequest(ctx, 'GET', '/database/config');
+      output(ctx, data, (d, ui) => {
+        ui.table(overrideRows(d, Boolean(flags.all)), [
+          { key: 'name', label: 'PARAMETER' },
+          { key: 'value', label: 'VALUE' },
+          { key: 'scope', label: 'SCOPE' },
+          { key: 'role', label: 'ROLE' },
+          { key: 'restart', label: 'NEEDS RESTART' },
+        ]);
+        if (!d.systemOverridesReadable) ui.warn('System-level overrides could not be read with this connection.');
+      });
+    },
+  },
+  update: {
+    summary: 'Set Postgres config values',
+    usage: 'motherbase postgres-config update --config key=value [--config ...] [--scope database|role|system] [--role r] [--replace-existing-overrides]',
+    async run(ctx, args, flags) {
+      const values = parseKeyValues([].concat(flags.config || []).filter(Boolean), { coerce: false });
+      if (!Object.keys(values).length) throw new CliError('Provide at least one --config key=value.');
+      const target = scopeFlags(flags);
+      const changes = Object.entries(values).map(([name, value]) => ({ name, value, ...target }));
+
+      // Supabase's flag: anything overridden before and not named now goes back to its default.
+      if (flags['replace-existing-overrides']) {
+        const current = await api.adminRequest(ctx, 'GET', '/database/config');
+        for (const setting of current.settings) {
+          if (setting.name in values) continue;
+          for (const o of setting.overrides) {
+            changes.push({ name: setting.name, value: null, scope: o.scope, ...(o.role ? { role: o.role } : {}) });
+          }
+        }
+      }
+
+      const data = await api.adminRequest(ctx, 'PATCH', '/database/config', { body: { changes } });
+      output(ctx, data, (d, ui) => reportChange(d, ui));
+    },
+  },
+  delete: {
+    summary: 'Remove Postgres config overrides, restoring the defaults',
+    usage: 'motherbase postgres-config delete --config key1,key2 [--scope database|role|system] [--role r]',
+    async run(ctx, args, flags) {
+      const names = [].concat(flags.config || []).flatMap(v => String(v).split(',')).map(s => s.trim()).filter(Boolean);
+      if (!names.length) throw new CliError('Provide the settings to reset with --config key1,key2.');
+      const target = scopeFlags(flags);
+      const changes = names.map(name => ({ name, value: null, ...target }));
+      const data = await api.adminRequest(ctx, 'PATCH', '/database/config', { body: { changes } });
+      output(ctx, data, (d, ui) => reportChange(d, ui));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Postgres configuration (statement_timeout, work_mem, max_connections, ...)',
+  usage: 'motherbase postgres-config <get|update|delete> ...',
+  subcommands,
+};