@deepsql/mcp 0.5.0 → 0.6.0

package/src/commands/users.js

@@ -0,0 +1,276 @@
+"use strict";
+
+/**
+ * `deepsql users` — manage workspace users (admin-only).
+ *
+ *   deepsql users list [--json]
+ *   deepsql users get <email-or-id>
+ *   deepsql users add [<email>] [--role <r>] [--name <n>] [--password <p>] [--password-stdin]
+ *   deepsql users set-role <email> <role>
+ *   deepsql users lock <email>
+ *   deepsql users unlock <email>
+ *   deepsql users disable <email>
+ *   deepsql users resend-invite <email>
+ *   deepsql users reset-password <email> [--password-stdin]
+ *   deepsql users delete <email> [--yes]
+ *
+ * All endpoints under /admin/users/** require ROLE_ADMIN on the calling token.
+ */
+
+const { ApiError, request } = require("../api/client");
+const { resolveSession } = require("./_session");
+const { resolveUser, listUsers, clearUserCache } = require("./_users");
+const { promptPassword, readSingleLineFromStdin } = require("../auth/prompt");
+const ui = require("../ui/prompts");
+
+async function run(opts, io = {}) {
+  const sub = opts.positional[0];
+  if (!sub) {
+    throw new Error(
+      "Usage: deepsql users <list|get|add|set-role|lock|unlock|disable|resend-invite|reset-password|delete> ...",
+    );
+  }
+  const handler = SUBCOMMANDS[sub];
+  if (!handler) {
+    throw new Error(`Unknown users subcommand: ${sub}.`);
+  }
+  return wrapAdminErrors(handler)(
+    {
+      ...opts,
+      // Drop the subcommand from positional so handlers see only their args.
+      positional: opts.positional.slice(1),
+    },
+    io,
+  );
+}
+
+function wrapAdminErrors(handler) {
+  return async (opts, io) => {
+    try {
+      return await handler(opts, io);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 403) {
+        throw new Error(
+          "Access denied — managing users requires ADMIN role on the calling token.",
+        );
+      }
+      throw err;
+    }
+  };
+}
+
+// ─── list ──────────────────────────────────────────────────────────────────
+
+async function cmdList(opts, { stdout = process.stdout } = {}) {
+  const session = resolveSession(opts);
+  const users = await listUsers(session);
+  if (opts.json) {
+    stdout.write(`${JSON.stringify(users, null, 2)}\n`);
+    return;
+  }
+  if (users.length === 0) {
+    stdout.write("No users.\n");
+    return;
+  }
+  printUsers(stdout, users);
+}
+
+// ─── get ───────────────────────────────────────────────────────────────────
+
+async function cmdGet(opts, { stdout = process.stdout } = {}) {
+  const ref = opts.positional[0];
+  if (!ref) throw new Error("Pass an email, username, or id: `deepsql users get <ref>`.");
+  const session = resolveSession(opts);
+  const user = await resolveUser(session, ref);
+  // Hit the by-id endpoint to get the full record (list returns a summary).
+  const full = await request(session.baseUrl, `/admin/users/${user.id}`, { token: session.token });
+  stdout.write(`${JSON.stringify(full, null, 2)}\n`);
+}
+
+// ─── add ───────────────────────────────────────────────────────────────────
+
+async function cmdAdd(opts, { stdout = process.stdout } = {}) {
+  const session = resolveSession(opts);
+
+  const email = opts.positional[0] || opts.email || (await ui.input({
+    message: "Email:",
+    validate: (v) => /.+@.+\..+/.test(v) ? true : "Looks invalid",
+  }));
+  const username = opts.name || opts.username || (await ui.input({
+    message: "Display name:",
+    default: email.split("@")[0],
+  }));
+  const role = (opts.role || (await ui.select({
+    message: "Role:",
+    choices: [
+      { name: "ADMIN", value: "ADMIN" },
+      { name: "DEVELOPER", value: "DEVELOPER" },
+      { name: "VIEWER", value: "VIEWER" },
+    ],
+    default: "DEVELOPER",
+  }))).toUpperCase();
+
+  // `opts.password` is the login-flow toggle (boolean) or unset; it's never a
+  // password value here on purpose — argv would expose it via `ps`. Always
+  // prompt, or read from stdin with --password-stdin for CI.
+  let password = null;
+  if (opts.passwordStdin) {
+    password = await readSingleLineFromStdin();
+  } else if (process.stdin.isTTY) {
+    password = await ui.password({
+      message: "Initial password (leave blank to send invite by email):",
+    });
+  }
+
+  const body = { email, username, role };
+  if (password) body.password = password;
+
+  const created = await request(session.baseUrl, "/admin/users", {
+    method: "POST",
+    token: session.token,
+    json: body,
+  });
+  clearUserCache();
+  if (opts.json) {
+    stdout.write(`${JSON.stringify(created, null, 2)}\n`);
+    return;
+  }
+  stdout.write(`Created user: ${created.email || email} (id ${created.id ?? "?"}, role ${created.role || role})\n`);
+}
+
+// ─── set-role ──────────────────────────────────────────────────────────────
+
+async function cmdSetRole(opts, { stdout = process.stdout } = {}) {
+  const ref = opts.positional[0];
+  const role = (opts.positional[1] || opts.role || "").toUpperCase();
+  if (!ref || !role) {
+    throw new Error("Usage: deepsql users set-role <email|id> <role>");
+  }
+  const session = resolveSession(opts);
+  const user = await resolveUser(session, ref);
+  const updated = await request(session.baseUrl, `/admin/users/${user.id}/role`, {
+    method: "PUT",
+    token: session.token,
+    json: { role },
+  });
+  stdout.write(`Updated ${user.email || user.username}: role=${updated.role || role}\n`);
+}
+
+// ─── state toggles ─────────────────────────────────────────────────────────
+
+const cmdLock = makeStateToggle("lock");
+const cmdUnlock = makeStateToggle("unlock");
+const cmdDisable = makeStateToggle("disable");
+const cmdResendInvite = makeStateToggle("resend-invite", "Sent invite email to");
+
+function makeStateToggle(action, verbPrefix) {
+  return async function (opts, { stdout = process.stdout } = {}) {
+    const ref = opts.positional[0];
+    if (!ref) throw new Error(`Usage: deepsql users ${action} <email|id>`);
+    const session = resolveSession(opts);
+    const user = await resolveUser(session, ref);
+    await request(session.baseUrl, `/admin/users/${user.id}/${action}`, {
+      method: "POST",
+      token: session.token,
+      json: {},
+    });
+    const verb = verbPrefix || `${action[0].toUpperCase()}${action.slice(1)}ed`;
+    stdout.write(`${verb} ${user.email || user.username}.\n`);
+  };
+}
+
+// ─── reset-password ────────────────────────────────────────────────────────
+
+async function cmdResetPassword(opts, { stdout = process.stdout } = {}) {
+  const ref = opts.positional[0];
+  if (!ref) throw new Error("Usage: deepsql users reset-password <email|id> [--password-stdin]");
+  const session = resolveSession(opts);
+  const user = await resolveUser(session, ref);
+
+  let password = null;
+  if (opts.passwordStdin) {
+    password = await readSingleLineFromStdin();
+  } else {
+    password = await promptPassword(`New password for ${user.email || user.username}: `);
+    const confirmPw = await promptPassword("Confirm: ");
+    if (password !== confirmPw) throw new Error("Passwords do not match.");
+  }
+  if (!password) throw new Error("Password is required.");
+
+  await request(session.baseUrl, `/admin/users/${user.id}/password`, {
+    method: "PUT",
+    token: session.token,
+    json: { password },
+  });
+  stdout.write(`Password reset for ${user.email || user.username}.\n`);
+}
+
+// ─── delete ────────────────────────────────────────────────────────────────
+
+async function cmdDelete(opts, { stdout = process.stdout, stderr = process.stderr } = {}) {
+  const ref = opts.positional[0];
+  if (!ref) throw new Error("Usage: deepsql users delete <email|id> [--yes]");
+  const session = resolveSession(opts);
+  const user = await resolveUser(session, ref);
+
+  if (!opts.yes) {
+    const ok = await ui.confirm({
+      message: `Delete ${user.email || user.username} (id ${user.id})? This cannot be undone.`,
+      default: false,
+    });
+    if (!ok) {
+      stderr.write("Aborted.\n");
+      return;
+    }
+  }
+  await request(session.baseUrl, `/admin/users/${user.id}`, {
+    method: "DELETE",
+    token: session.token,
+  });
+  clearUserCache();
+  stdout.write(`Deleted ${user.email || user.username}.\n`);
+}
+
+// ─── helpers ───────────────────────────────────────────────────────────────
+
+// Defined here, after all cmd* definitions, so the const-bound state-toggle
+// functions are initialized before this object captures them.
+const SUBCOMMANDS = {
+  list: cmdList,
+  get: cmdGet,
+  add: cmdAdd,
+  invite: cmdAdd, // alias — POST /admin/users/invite is identical to /admin/users
+  "set-role": cmdSetRole,
+  lock: cmdLock,
+  unlock: cmdUnlock,
+  disable: cmdDisable,
+  "resend-invite": cmdResendInvite,
+  "reset-password": cmdResetPassword,
+  delete: cmdDelete,
+};
+
+function printUsers(stdout, users) {
+  const rows = users.map((u) => ({
+    id: String(u.id ?? ""),
+    email: u.email || "",
+    username: u.username || "",
+    role: u.role || "",
+    status: u.accountStatus || u.status || "",
+  }));
+  const cols = [
+    { key: "id", label: "ID" },
+    { key: "email", label: "EMAIL" },
+    { key: "username", label: "NAME" },
+    { key: "role", label: "ROLE" },
+    { key: "status", label: "STATUS" },
+  ];
+  const widths = cols.map((c) => Math.max(c.label.length, ...rows.map((r) => r[c.key].length)));
+  const header = cols.map((c, i) => c.label.padEnd(widths[i])).join("  ");
+  const sep = widths.map((w) => "-".repeat(w)).join("  ");
+  stdout.write(`${header}\n${sep}\n`);
+  for (const row of rows) {
+    stdout.write(`${cols.map((c, i) => row[c.key].padEnd(widths[i])).join("  ")}\n`);
+  }
+}
+
+module.exports = { run };

package/src/ui/editor.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * Spawn the user's $EDITOR on a tempfile and return the edited contents.
+ *
+ * Resolution order: VISUAL → EDITOR → vi (POSIX) / notepad (Windows).
+ * Tempfile is created mode 0600 in os.tmpdir(), removed on exit (success or
+ * cancel), and uses a randomised suffix so concurrent edits don't clash.
+ */
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const { spawn } = require("node:child_process");
+
+function pickEditor() {
+  if (process.env.VISUAL) return process.env.VISUAL;
+  if (process.env.EDITOR) return process.env.EDITOR;
+  return process.platform === "win32" ? "notepad" : "vi";
+}
+
+async function editText(initial, { suffix = ".txt", header = null } = {}) {
+  const random = crypto.randomBytes(6).toString("hex");
+  const tmp = path.join(os.tmpdir(), `deepsql-${random}${suffix}`);
+  let body = initial == null ? "" : String(initial);
+  if (header) body = `${header}\n\n${body}`;
+
+  fs.writeFileSync(tmp, body, { mode: 0o600 });
+  const before = fs.readFileSync(tmp, "utf8");
+
+  try {
+    await new Promise((resolve, reject) => {
+      const editor = pickEditor();
+      const child = spawn(editor, [tmp], { stdio: "inherit" });
+      child.on("exit", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Editor exited with code ${code}`));
+      });
+      child.on("error", reject);
+    });
+
+    const after = fs.readFileSync(tmp, "utf8");
+    return {
+      content: stripHeader(after, header),
+      changed: stripHeader(after, header) !== stripHeader(before, header),
+    };
+  } finally {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {}
+  }
+}
+
+function stripHeader(text, header) {
+  if (!header) return text;
+  const headerBlock = `${header}\n\n`;
+  return text.startsWith(headerBlock) ? text.slice(headerBlock.length) : text;
+}
+
+module.exports = { editText, pickEditor };

package/src/ui/prompts.js

@@ -0,0 +1,60 @@
+"use strict";
+
+/**
+ * Thin wrapper over @inquirer/prompts so commands import from one place.
+ *
+ * Why a wrapper?
+ *   - Keeps the import surface stable if we ever swap libs.
+ *   - Lets us short-circuit to the existing `prompt`/`promptPassword` helpers
+ *     when stdin isn't a TTY (CI / piped input) — @inquirer requires a TTY
+ *     and aborts otherwise, which is the wrong UX for scripted use.
+ *   - Lazy-loads inquirer so plain CLI commands don't pay the load cost.
+ */
+
+const { prompt: tinyPrompt, promptPassword: tinyPromptPassword } = require("../auth/prompt");
+
+let inquirer;
+function loadInquirer() {
+  if (!inquirer) inquirer = require("@inquirer/prompts");
+  return inquirer;
+}
+
+async function input({ message, default: dflt, required = true, validate } = {}) {
+  if (!process.stdin.isTTY) {
+    const value = await tinyPrompt(`${message} `);
+    if (required && !value) throw new Error(`${message} is required.`);
+    return value;
+  }
+  return loadInquirer().input({ message, default: dflt, required, validate });
+}
+
+async function password({ message, mask = "*", validate } = {}) {
+  if (!process.stdin.isTTY) {
+    return tinyPromptPassword(`${message} `);
+  }
+  return loadInquirer().password({ message, mask, validate });
+}
+
+async function select({ message, choices, default: dflt } = {}) {
+  if (!process.stdin.isTTY) {
+    // Non-interactive: print the available choices and read one as a line.
+    const labels = choices.map((c) => c.value).join(", ");
+    const value = (await tinyPrompt(`${message} (${labels}): `)).trim();
+    if (!choices.some((c) => c.value === value)) {
+      throw new Error(`Invalid choice: ${value}. Pick one of: ${labels}`);
+    }
+    return value;
+  }
+  return loadInquirer().select({ message, choices, default: dflt });
+}
+
+async function confirm({ message, default: dflt = false } = {}) {
+  if (!process.stdin.isTTY) {
+    const raw = (await tinyPrompt(`${message} (y/N): `)).trim().toLowerCase();
+    if (!raw) return dflt;
+    return raw === "y" || raw === "yes";
+  }
+  return loadInquirer().confirm({ message, default: dflt });
+}
+
+module.exports = { input, password, select, confirm };

package/src/ui/sse.js

@@ -0,0 +1,97 @@
+"use strict";
+
+/**
+ * Minimal Server-Sent Events consumer using node:fetch's ReadableStream.
+ *
+ * Yields { event, data } objects. `data` is the raw string — caller decides
+ * whether to JSON.parse(). Honours SIGINT by aborting the underlying request
+ * and resolving the iterator cleanly.
+ *
+ * SSE wire format we parse (RFC):
+ *     event: <name>\n
+ *     data: <line1>\n
+ *     data: <line2>\n
+ *     \n      ← message boundary
+ *
+ * We don't implement reconnection, last-event-id, or comment lines (`:` prefix)
+ * because the optimize stream is short-lived and stateless.
+ */
+
+const { resolveUrl, normalizeBaseUrl } = require("../api/client");
+
+async function* streamSse(baseUrl, path, { token, query, signal } = {}) {
+  let url;
+  if (typeof path === "string" && /^https?:\/\//i.test(path)) {
+    url = path;
+  } else {
+    url = resolveUrl(baseUrl, path);
+  }
+  if (query && typeof query === "object") {
+    const u = new URL(url);
+    for (const [k, v] of Object.entries(query)) {
+      if (v == null) continue;
+      u.searchParams.set(k, String(v));
+    }
+    url = u.toString();
+  }
+
+  const headers = { Accept: "text/event-stream" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  const response = await fetch(url, { headers, signal });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const err = new Error(`SSE ${response.status}: ${text || response.statusText}`);
+    err.status = response.status;
+    throw err;
+  }
+  if (!response.body) {
+    throw new Error("SSE response has no body");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  for await (const chunk of response.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let idx;
+    // Each SSE message ends with a blank line (\n\n or \r\n\r\n).
+    while ((idx = nextMessageEnd(buffer)) !== -1) {
+      const raw = buffer.slice(0, idx);
+      buffer = buffer.slice(idx).replace(/^(\r?\n){2}/, "");
+      const message = parseMessage(raw);
+      if (message) yield message;
+    }
+  }
+
+  // Drain any remaining message that didn't end with a blank line (server
+  // close after final event).
+  const final = parseMessage(buffer);
+  if (final) yield final;
+}
+
+function nextMessageEnd(buffer) {
+  const lf = buffer.indexOf("\n\n");
+  const crlf = buffer.indexOf("\r\n\r\n");
+  if (lf === -1) return crlf;
+  if (crlf === -1) return lf;
+  return Math.min(lf, crlf);
+}
+
+function parseMessage(raw) {
+  if (!raw || !raw.trim()) return null;
+  let event = "message";
+  const dataLines = [];
+  for (const rawLine of raw.split(/\r?\n/)) {
+    if (!rawLine || rawLine.startsWith(":")) continue;
+    const colon = rawLine.indexOf(":");
+    const field = colon === -1 ? rawLine : rawLine.slice(0, colon);
+    const value = colon === -1 ? "" : rawLine.slice(colon + 1).replace(/^\s/, "");
+    if (field === "event") event = value;
+    else if (field === "data") dataLines.push(value);
+  }
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join("\n") };
+}
+
+module.exports = { streamSse };