@motherbase/cli 0.2.1

package/src/commands/realtime.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const api = require('../api');
+const { output } = require('./_util');
+
+const subcommands = {
+  config: {
+    summary: 'Show realtime config, or set enabled models with --models a,b,c',
+    usage: 'motherbase realtime config [--models a,b,c]',
+    async run(ctx, args, flags) {
+      if (flags.models !== undefined) {
+        const models = String(flags.models).split(',').map(s => s.trim()).filter(Boolean);
+        const data = await api.adminRequest(ctx, 'PATCH', '/realtime/config', { body: { models } });
+        output(ctx, data, (d, ui) => ui.success(`Enabled models: ${(d && d.models ? d.models : models).join(', ') || '(none)'}`));
+        return;
+      }
+      const data = await api.adminRequest(ctx, 'GET', '/realtime/config');
+      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
+    },
+  },
+  channels: {
+    summary: 'List active realtime channels',
+    usage: 'motherbase realtime channels',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/realtime/channels');
+      output(ctx, data, (d, ui) => ui.json((d && d.channels) || d));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Realtime configuration and channels',
+  usage: 'motherbase realtime <config|channels> ...',
+  subcommands,
+};

package/src/commands/rls.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const policy = {
+  summary: 'Manage RLS policies',
+  usage: 'motherbase rls policy create --table <t> --name <n> --command <SELECT|INSERT|UPDATE|DELETE|ALL> [--using <expr>] [--check <expr>] [--roles a,b] | motherbase rls policy delete <table> <name>',
+  subcommands: {
+    create: {
+      summary: 'Create an RLS policy',
+      usage: 'motherbase rls policy create --table <t> --name <n> --command <cmd> [--using <expr>] [--check <expr>] [--roles a,b]',
+      async run(ctx, args, flags) {
+        const body = {
+          table: flags.table,
+          name: flags.name,
+          command: (flags.command || 'ALL').toUpperCase(),
+        };
+        if (!body.table || !body.name) throw new CliError('--table and --name are required');
+        if (flags.using) body.using = flags.using;
+        if (flags.check) body.check = flags.check;
+        if (flags.roles) body.roles = String(flags.roles).split(',').map(s => s.trim()).filter(Boolean);
+        const data = await api.adminRequest(ctx, 'POST', '/rls/policies', { body });
+        output(ctx, data, (d, ui) => ui.success(`Created policy ${body.name} on ${body.table}`));
+      },
+    },
+    delete: {
+      summary: 'Delete an RLS policy',
+      usage: 'motherbase rls policy delete <table> <name>',
+      async run(ctx, args) {
+        const table = requireArg(args[0], 'table');
+        const name = requireArg(args[1], 'name');
+        const data = await api.adminRequest(ctx, 'DELETE', '/rls/policies', { body: { table, name } });
+        output(ctx, data, (d, ui) => ui.success(`Dropped policy ${name} on ${table}`));
+      },
+    },
+  },
+};
+
+const subcommands = {
+  list: {
+    summary: 'List tables with RLS status and policies',
+    usage: 'motherbase rls list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/rls/tables');
+      output(ctx, data, (rows, ui) =>
+        ui.table((Array.isArray(rows) ? rows : []).map(r => ({
+          table: r.table,
+          rls: r.rlsEnabled ? 'on' : 'off',
+          policies: Array.isArray(r.policies) ? r.policies.length : 0,
+        })), [
+          { key: 'table', label: 'TABLE' },
+          { key: 'rls', label: 'RLS' },
+          { key: 'policies', label: 'POLICIES' },
+        ]),
+      );
+    },
+  },
+  enable: {
+    summary: 'Enable RLS on a table',
+    usage: 'motherbase rls enable <table>',
+    async run(ctx, args) {
+      const table = requireArg(args[0], 'table');
+      const data = await api.adminRequest(ctx, 'POST', `/rls/tables/${table}/rls`, { body: { enabled: true } });
+      output(ctx, data, (d, ui) => ui.success(`RLS enabled on ${table}`));
+    },
+  },
+  disable: {
+    summary: 'Disable RLS on a table',
+    usage: 'motherbase rls disable <table>',
+    async run(ctx, args) {
+      const table = requireArg(args[0], 'table');
+      const data = await api.adminRequest(ctx, 'POST', `/rls/tables/${table}/rls`, { body: { enabled: false } });
+      output(ctx, data, (d, ui) => ui.success(`RLS disabled on ${table}`));
+    },
+  },
+  policy,
+};
+
+module.exports = {
+  summary: 'Row-level security (tables + policies)',
+  usage: 'motherbase rls <list|enable|disable|policy> ...',
+  subcommands,
+};

package/src/commands/secrets.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+
+const subcommands = {
+  list: {
+    summary: 'List edge secrets (names only)',
+    usage: 'motherbase secrets list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/edge-secrets');
+      const secrets = (data && data.secrets) || data || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table((Array.isArray(secrets) ? secrets : []).map(s => (typeof s === 'string' ? { name: s } : s)), [
+          { key: 'name', label: 'NAME' },
+        ]),
+      );
+    },
+  },
+  set: {
+    summary: 'Set a secret',
+    usage: 'motherbase secrets set <NAME> <value>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'NAME');
+      const value = requireArg(args[1], 'value');
+      const data = await api.adminRequest(ctx, 'PUT', '/edge-secrets', { body: { name, value } });
+      output(ctx, data, (d, ui) => ui.success(`Set secret ${name}`));
+    },
+  },
+  unset: {
+    summary: 'Remove a secret',
+    usage: 'motherbase secrets unset <NAME>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'NAME');
+      const data = await api.adminRequest(ctx, 'DELETE', `/edge-secrets/${encodeURIComponent(name)}`);
+      output(ctx, data, (d, ui) => ui.success(`Removed secret ${name}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Edge function secrets',
+  usage: 'motherbase secrets <list|set|unset> ...',
+  subcommands,
+};

package/src/commands/status.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const api = require('../api');
+const { output } = require('./_util');
+
+module.exports = {
+  summary: 'Show connection status: console, link, and a project health probe',
+  usage: 'motherbase status',
+  async run(ctx) {
+    const data = {
+      console: ctx.consoleUrl || null,
+      loggedIn: Boolean(ctx.token),
+      mode: ctx.mode,
+      project: ctx.projectId || null,
+      reachable: null,
+      api: null,
+    };
+
+    if (ctx.projectId || ctx.mode === 'direct') {
+      try {
+        const info = await api.adminRequest(ctx, 'GET', '/connect-info');
+        data.reachable = true;
+        data.api = info && info.apiUrl;
+      } catch (err) {
+        data.reachable = false;
+        data.error = err.message;
+      }
+    }
+
+    output(ctx, data, (d, ui) => {
+      ui.keyValue({
+        Console: d.console || '(none)',
+        'Logged in': d.loggedIn ? 'yes' : 'no',
+        Mode: d.mode,
+        Project: d.project || '(not linked)',
+        Reachable: d.reachable === null ? 'n/a' : d.reachable ? 'yes' : 'no',
+        'API URL': d.api || '',
+      });
+      if (d.error) ui.warn(d.error);
+    });
+  },
+};

package/src/commands/storage.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const api = require('../api');
+const { output, requireArg, splitRef } = require('./_util');
+
+const buckets = {
+  summary: 'Manage storage buckets',
+  usage: 'motherbase storage buckets <list|create|delete> ...',
+  subcommands: {
+    list: {
+      summary: 'List buckets',
+      usage: 'motherbase storage buckets list',
+      async run(ctx) {
+        const data = await api.adminRequest(ctx, 'GET', '/storage/buckets');
+        const rows = Array.isArray(data) ? data : (data && data.buckets) || [];
+        output(ctx, data, (_d, ui) =>
+          ui.table(rows, [
+            { key: 'slug', label: 'SLUG' },
+            { key: 'name', label: 'NAME' },
+            { key: 'visibility', label: 'VISIBILITY' },
+          ]),
+        );
+      },
+    },
+    create: {
+      summary: 'Create a bucket',
+      usage: 'motherbase storage buckets create <slug> [--name n] [--visibility public|private]',
+      async run(ctx, args, flags) {
+        const slug = requireArg(args[0], 'slug');
+        const body = { slug, name: flags.name || slug };
+        if (flags.visibility) body.visibility = flags.visibility;
+        const data = await api.adminRequest(ctx, 'POST', '/storage/buckets', { body });
+        output(ctx, data, (d, ui) => ui.success(`Created bucket ${slug}`));
+      },
+    },
+    delete: {
+      summary: 'Delete a bucket',
+      usage: 'motherbase storage buckets delete <slug> [--force]',
+      async run(ctx, args, flags) {
+        const slug = requireArg(args[0], 'slug');
+        const query = flags.force ? { force: 'true' } : undefined;
+        const data = await api.adminRequest(ctx, 'DELETE', `/storage/buckets/${slug}`, { query });
+        output(ctx, data, (d, ui) => ui.success(`Deleted bucket ${slug}`));
+      },
+    },
+  },
+};
+
+const subcommands = {
+  buckets,
+  ls: {
+    summary: 'List files (optionally within a bucket)',
+    usage: 'motherbase storage ls [bucket]',
+    async run(ctx, args) {
+      const bucket = args[0];
+      const apiPath = bucket ? `/storage/buckets/${bucket}/files` : '/storage/files';
+      const data = await api.adminRequest(ctx, 'GET', apiPath);
+      const rows = (data && (data.files || data.items)) || (Array.isArray(data) ? data : []);
+      output(ctx, data, (_d, ui) =>
+        ui.table(rows, [
+          { key: 'id', label: 'ID' },
+          { key: 'filename', label: 'FILENAME' },
+          { key: 'size', label: 'SIZE' },
+          { key: 'visibility', label: 'VISIBILITY' },
+        ]),
+      );
+    },
+  },
+  cp: {
+    summary: 'Upload (local -> bucket) or download (fileId -> local)',
+    usage: 'motherbase storage cp <src> <dst>   e.g. cp ./a.png mybucket:  |  cp <fileId> ./a.png',
+    async run(ctx, args, flags) {
+      const src = requireArg(args[0], 'src');
+      const dst = requireArg(args[1], 'dst');
+      const srcLocal = fs.existsSync(path.resolve(ctx.cwd, src));
+
+      if (srcLocal) {
+        // Upload: dst is "bucket" or "bucket:path" (path is advisory; server keys by id).
+        const { bucket } = splitRef(dst);
+        const fields = {};
+        if (bucket) fields.bucket = bucket;
+        if (flags.visibility) fields.visibility = flags.visibility;
+        const data = await api.uploadFile(ctx, '/storage/files', path.resolve(ctx.cwd, src), fields);
+        output(ctx, data, (d, ui) => ui.success(`Uploaded ${src}${d && d.id ? ` → ${d.id}` : ''}`));
+      } else {
+        // Download: src is a fileId (optionally "bucket:id"), dst is a local path.
+        const { rest } = splitRef(src);
+        const fileId = rest || src;
+        const destPath = path.resolve(ctx.cwd, dst);
+        const res = await api.downloadFile(ctx, `/storage/files/${fileId}/raw`, destPath);
+        if (ctx.flags.json) require('../ui').json(res);
+        else require('../ui').success(`Downloaded ${fileId} → ${dst}`);
+      }
+    },
+  },
+  rm: {
+    summary: 'Delete a file by id',
+    usage: 'motherbase storage rm <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/storage/files/${id}`);
+      output(ctx, data, (d, ui) => ui.success(`Deleted file ${id}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Storage buckets and files',
+  usage: 'motherbase storage <buckets|ls|cp|rm> ...',
+  subcommands,
+};

package/src/commands/unlink.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const { CliError } = require('../context');
+
+module.exports = {
+  summary: 'Remove the project link from the current directory',
+  usage: 'motherbase unlink',
+  async run(ctx) {
+    const removed = config.removeLink(ctx.cwd);
+    if (!removed) throw new CliError('No project link found in this directory.');
+    ui.success('Unlinked project.');
+  },
+};

package/src/commands/users.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+// Collect known user fields from flags into a body.
+function userBody(flags) {
+  const body = {};
+  for (const key of ['email', 'password', 'name', 'role']) {
+    if (flags[key] !== undefined) body[key] = flags[key];
+  }
+  return body;
+}
+
+const subcommands = {
+  list: {
+    summary: 'List project users',
+    usage: 'motherbase users list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/users');
+      const users = (data && data.users) || data || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(Array.isArray(users) ? users : [], [
+          { key: 'id', label: 'ID' },
+          { key: 'email', label: 'EMAIL' },
+          { key: 'role', label: 'ROLE' },
+        ]),
+      );
+    },
+  },
+  get: {
+    summary: 'Get a user by id',
+    usage: 'motherbase users get <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/users/${id}`);
+      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
+    },
+  },
+  create: {
+    summary: 'Create a user',
+    usage: 'motherbase users create --email <e> --password <p> [--name <n>] [--role <r>]',
+    async run(ctx, args, flags) {
+      const body = userBody(flags);
+      if (!body.email || !body.password) throw new CliError('--email and --password are required');
+      const data = await api.adminRequest(ctx, 'POST', '/users', { body });
+      output(ctx, data, (d, ui) => ui.success(`Created user ${body.email}`));
+    },
+  },
+  update: {
+    summary: 'Update a user',
+    usage: 'motherbase users update <id> [--email ...] [--name ...] [--role ...]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const body = userBody(flags);
+      const data = await api.adminRequest(ctx, 'PATCH', `/users/${id}`, { body });
+      output(ctx, data, (d, ui) => ui.success(`Updated user ${id}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a user',
+    usage: 'motherbase users delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/users/${id}`);
+      output(ctx, data, (d, ui) => ui.success(`Deleted user ${id}`));
+    },
+  },
+  'reset-password': {
+    summary: 'Reset a user password',
+    usage: 'motherbase users reset-password <id> [--password <p>]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const body = flags.password ? { password: flags.password } : {};
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/reset-password`, { body });
+      output(ctx, data, (d, ui) => ui.success(`Password reset for ${id}`));
+    },
+  },
+  promote: {
+    summary: 'Promote a user to ADMIN',
+    usage: 'motherbase users promote <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/promote`);
+      output(ctx, data, (d, ui) => ui.success(`Promoted ${id}`));
+    },
+  },
+  demote: {
+    summary: 'Demote a user to USER',
+    usage: 'motherbase users demote <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/demote`);
+      output(ctx, data, (d, ui) => ui.success(`Demoted ${id}`));
+    },
+  },
+  'revoke-sessions': {
+    summary: 'Revoke all sessions for a user',
+    usage: 'motherbase users revoke-sessions <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/revoke-sessions`);
+      output(ctx, data, (d, ui) => ui.success(`Sessions revoked for ${id}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Project auth users',
+  usage: 'motherbase users <list|get|create|update|delete|reset-password|promote|demote|revoke-sessions> ...',
+  subcommands,
+};

package/src/commands/webhooks.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const subcommands = {
+  list: {
+    summary: 'List webhooks',
+    usage: 'motherbase webhooks list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/webhooks');
+      const rows = (data && data.webhooks) || data || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(Array.isArray(rows) ? rows : [], [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'url', label: 'URL' },
+          { key: 'events', label: 'EVENTS' },
+        ]),
+      );
+    },
+  },
+  create: {
+    summary: 'Create a webhook',
+    usage: 'motherbase webhooks create --name <n> --url <u> --events a,b',
+    async run(ctx, args, flags) {
+      if (!flags.name || !flags.url || !flags.events) throw new CliError('--name, --url and --events are required');
+      const body = {
+        name: flags.name,
+        url: flags.url,
+        events: String(flags.events).split(',').map(s => s.trim()).filter(Boolean),
+      };
+      const data = await api.adminRequest(ctx, 'POST', '/webhooks', { body });
+      output(ctx, data, (d, ui) => ui.success(`Created webhook ${flags.name}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a webhook',
+    usage: 'motherbase webhooks delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/webhooks/${id}`);
+      output(ctx, data, (d, ui) => ui.success(`Deleted webhook ${id}`));
+    },
+  },
+  test: {
+    summary: 'Send a test event to a webhook',
+    usage: 'motherbase webhooks test <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/webhooks/${id}/test`);
+      output(ctx, data, (d, ui) => ui.json(d));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Outgoing webhooks',
+  usage: 'motherbase webhooks <list|create|delete|test> ...',
+  subcommands,
+};

package/src/commands/whoami.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const api = require('../api');
+const { output } = require('./_util');
+
+module.exports = {
+  summary: 'Show the current console, account and platform info',
+  usage: 'motherbase whoami',
+  async run(ctx) {
+    const { consoleUrl } = ctx.requireConsole();
+    const info = await api.consoleRequest(ctx, 'GET', '/info');
+    const data = {
+      console: consoleUrl,
+      email: ctx.accountEmail || null,
+      mode: info && info.mode,
+      domainSuffix: info && info.domainSuffix,
+    };
+    output(ctx, data, (d, ui) => ui.keyValue(d));
+  },
+};

package/src/config.js

@@ -0,0 +1,98 @@
+'use strict';
+
+// Config persistence. Two files:
+//   Global creds : ~/.motherbase/config.json  (contains tokens; written 0o600)
+//     { "consoles": { "<url>": { "token": "...", "email": "..." } }, "current": "<url>" }
+//   Project link : ./.motherbase/config.json  (versionable, non-secret)
+//     { "consoleUrl": "<url>", "projectId": "abc", "projectName": "my-app" }
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const GLOBAL_DIR = path.join(os.homedir(), '.motherbase');
+const GLOBAL_FILE = path.join(GLOBAL_DIR, 'config.json');
+const LINK_DIRNAME = '.motherbase';
+const LINK_BASENAME = 'config.json';
+
+function normalizeUrl(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// ── Global credentials ───────────────────────────────────────────────────────
+
+function readGlobal() {
+  return readJson(GLOBAL_FILE) || { consoles: {}, current: null };
+}
+
+function writeGlobal(cfg) {
+  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs.writeFileSync(GLOBAL_FILE, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+  // Best-effort tighten perms even if the file already existed with looser mode.
+  try { fs.chmodSync(GLOBAL_FILE, 0o600); } catch { /* windows / noop */ }
+}
+
+function saveConsoleToken(url, token, email) {
+  const u = normalizeUrl(url);
+  const cfg = readGlobal();
+  cfg.consoles = cfg.consoles || {};
+  cfg.consoles[u] = { ...(cfg.consoles[u] || {}), token, email };
+  cfg.current = u;
+  writeGlobal(cfg);
+  return u;
+}
+
+function clearConsoleToken(url) {
+  const cfg = readGlobal();
+  const u = normalizeUrl(url);
+  if (cfg.consoles && cfg.consoles[u]) delete cfg.consoles[u];
+  if (cfg.current === u) cfg.current = null;
+  writeGlobal(cfg);
+}
+
+function consoleEntry(url) {
+  const cfg = readGlobal();
+  return (cfg.consoles && cfg.consoles[normalizeUrl(url)]) || null;
+}
+
+// ── Per-project link ─────────────────────────────────────────────────────────
+
+function linkPath(cwd) {
+  return path.join(cwd || process.cwd(), LINK_DIRNAME, LINK_BASENAME);
+}
+
+function readLink(cwd) {
+  return readJson(linkPath(cwd));
+}
+
+function writeLink(cwd, data) {
+  const dir = path.join(cwd || process.cwd(), LINK_DIRNAME);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(linkPath(cwd), JSON.stringify(data, null, 2) + '\n');
+}
+
+function removeLink(cwd) {
+  try { fs.unlinkSync(linkPath(cwd)); return true; } catch { return false; }
+}
+
+module.exports = {
+  GLOBAL_FILE,
+  normalizeUrl,
+  readGlobal,
+  writeGlobal,
+  saveConsoleToken,
+  clearConsoleToken,
+  consoleEntry,
+  readLink,
+  writeLink,
+  removeLink,
+  linkPath,
+};