@deepsql/mcp 0.5.0 → 0.8.0

package/src/commands/slow-queries.js

@@ -0,0 +1,340 @@
+"use strict";
+
+/**
+ * `deepsql slow-queries` — read slow-query analyses, trigger new ones, stream
+ * AI optimization steps live, and clean up history.
+ *
+ *   deepsql slow-queries latest --connection <name> [--json]
+ *   deepsql slow-queries history --connection <name> [N] [--json]
+ *   deepsql slow-queries analyze --connection <name>
+ *       [--time-range LAST_24_HOURS|LAST_HOUR] [--threshold-ms <ms>] [--limit <n>]
+ *   deepsql slow-queries optimize --connection <name> --query-id <id>
+ *       (streams SSE; use --query-text to skip history lookup)
+ *   deepsql slow-queries delete --history-id <id> [--yes]
+ *
+ * The optimize subcommand follows the SSE protocol from
+ * /slow-queries/optimize/stream — `step` events go to stderr, the final
+ * `result` event prints to stdout. Honours SIGINT.
+ */
+
+const { ApiError, request } = require("../api/client");
+const { streamSse } = require("../ui/sse");
+const { resolveSession } = require("./_session");
+const { resolveConnectionId } = require("./_connections");
+const ui = require("../ui/prompts");
+
+const SUBCOMMANDS = {
+  latest: cmdLatest,
+  history: cmdHistory,
+  analyze: cmdAnalyze,
+  optimize: cmdOptimize,
+  delete: cmdDelete,
+};
+
+async function run(opts, io = {}) {
+  const sub = opts.positional[0];
+  if (!sub) {
+    throw new Error("Usage: deepsql slow-queries <latest|history|analyze|optimize|delete> ...");
+  }
+  const handler = SUBCOMMANDS[sub];
+  if (!handler) throw new Error(`Unknown slow-queries subcommand: ${sub}.`);
+  if (!opts.connection && sub !== "delete") {
+    throw new Error("--connection <name> is required.");
+  }
+  return wrap(handler)({ ...opts, positional: opts.positional.slice(1) }, io);
+}
+
+function wrap(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 — slow-query operations require permissions on this connection.");
+      }
+      throw err;
+    }
+  };
+}
+
+// ─── latest ────────────────────────────────────────────────────────────────
+
+async function cmdLatest(opts, { stdout = process.stdout } = {}) {
+  const session = resolveSession(opts);
+  const connectionId = await resolveConnectionId(session, opts.connection);
+  const result = await request(
+    session.baseUrl,
+    `/slow-queries/latest/${encodeURIComponent(connectionId)}`,
+    { token: session.token },
+  );
+  stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+// ─── history ───────────────────────────────────────────────────────────────
+
+async function cmdHistory(opts, { stdout = process.stdout } = {}) {
+  const session = resolveSession(opts);
+  const connectionId = await resolveConnectionId(session, opts.connection);
+  const summaries = await request(
+    session.baseUrl,
+    `/slow-queries/history/${encodeURIComponent(connectionId)}`,
+    { token: session.token },
+  );
+  const items = Array.isArray(summaries) ? summaries : [];
+  const limitArg = parseCount(opts.positional[0]) || parseCount(opts.count);
+  const trimmed = limitArg ? items.slice(0, limitArg) : items;
+
+  if (opts.json) {
+    stdout.write(`${JSON.stringify(trimmed, null, 2)}\n`);
+    return;
+  }
+  if (trimmed.length === 0) {
+    stdout.write("No history.\n");
+    return;
+  }
+  printHistory(stdout, trimmed);
+}
+
+// ─── analyze ───────────────────────────────────────────────────────────────
+
+async function cmdAnalyze(opts, { stdout = process.stdout, stderr = process.stderr } = {}) {
+  const session = resolveSession(opts);
+  const connectionId = await resolveConnectionId(session, opts.connection);
+  const timeRange = (opts.timeRange || "LAST_24_HOURS").toUpperCase();
+  const thresholdMs = parseNum(opts.thresholdMs) || 100;
+  const limit = parseNum(opts.limit) || 10;
+
+  stderr.write(`Analyzing slow queries on ${opts.connection} (range=${timeRange}, threshold=${thresholdMs}ms)…\n`);
+  const result = await request(session.baseUrl, "/slow-queries/analyze", {
+    method: "POST",
+    token: session.token,
+    timeoutMs: 240000,
+    json: { connectionId, timeRange, thresholdMs, limit },
+  });
+  if (opts.json) {
+    stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  const queries = (result && (result.queries || result.slowQueries)) || [];
+  if (queries.length === 0) {
+    stdout.write("No slow queries detected in the selected window.\n");
+    return;
+  }
+  printQueries(stdout, queries);
+}
+
+// ─── optimize (SSE) ────────────────────────────────────────────────────────
+
+async function cmdOptimize(opts, { stdout = process.stdout, stderr = process.stderr } = {}) {
+  const session = resolveSession(opts);
+  const connectionId = await resolveConnectionId(session, opts.connection);
+
+  let queryText = opts.queryText;
+  let queryId = opts.queryId;
+
+  // If --query-id is given, look up the queryText from the latest analysis so
+  // the user doesn't have to paste raw SQL into the terminal.
+  if (!queryText) {
+    if (!queryId) throw new Error("Pass --query-id <id> or --query-text \"<sql>\".");
+    queryText = await lookupQueryText(session, connectionId, queryId);
+    if (!queryText) {
+      throw new Error(`Could not find query ${queryId} in the latest analysis. Pass --query-text "<sql>" instead.`);
+    }
+  }
+
+  const controller = new AbortController();
+  const onSigint = () => {
+    stderr.write("\n[deepsql] cancelling optimization…\n");
+    controller.abort();
+  };
+  process.once("SIGINT", onSigint);
+
+  try {
+    const stream = streamSse(session.baseUrl, "/slow-queries/optimize/stream", {
+      token: session.token,
+      query: { connectionId, queryText, queryId, sampleQuery: opts.sampleQuery },
+      signal: controller.signal,
+    });
+    for await (const message of stream) {
+      if (message.event === "step") {
+        const parsed = safeParse(message.data);
+        const status = parsed?.status || "step";
+        const text = parsed?.message || message.data;
+        stderr.write(`[${status}] ${text}\n`);
+      } else if (message.event === "result") {
+        if (opts.json) {
+          stdout.write(`${message.data}\n`);
+        } else {
+          const parsed = safeParse(message.data);
+          if (parsed && parsed.optimizedQuery) {
+            stdout.write(`\n--- Optimized query ---\n${parsed.optimizedQuery}\n`);
+          }
+          if (parsed && parsed.recommendations && parsed.recommendations.length) {
+            stdout.write("\n--- Recommendations ---\n");
+            for (const r of parsed.recommendations) {
+              stdout.write(`• ${r.title || r.summary || JSON.stringify(r)}\n`);
+            }
+          }
+          if (!parsed || (!parsed.optimizedQuery && !(parsed.recommendations || []).length)) {
+            stdout.write(`${message.data}\n`);
+          }
+        }
+      } else if (message.event === "error") {
+        const parsed = safeParse(message.data);
+        throw new Error(`Optimization failed: ${parsed?.message || message.data}`);
+      }
+    }
+  } catch (err) {
+    if (controller.signal.aborted) {
+      process.exitCode = 130; // 128 + SIGINT
+      return;
+    }
+    throw err;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+
+async function lookupQueryText(session, connectionId, queryId) {
+  const latest = await request(
+    session.baseUrl,
+    `/slow-queries/latest/${encodeURIComponent(connectionId)}`,
+    { token: session.token },
+  );
+  const data = latest?.analysisData || latest?.analysis || latest || {};
+  const queries = data.queries || data.slowQueries || [];
+  const hit = queries.find((q) => String(q.queryId || q.id) === String(queryId));
+  return hit ? (hit.queryText || hit.normalizedQuery || hit.query) : null;
+}
+
+// ─── delete ────────────────────────────────────────────────────────────────
+
+async function cmdDelete(opts, { stdout = process.stdout, stderr = process.stderr } = {}) {
+  const session = resolveSession(opts);
+
+  if (opts.historyId) {
+    if (!opts.yes) {
+      const ok = await ui.confirm({
+        message: `Delete history entry ${opts.historyId}?`,
+        default: false,
+      });
+      if (!ok) {
+        stderr.write("Aborted.\n");
+        return;
+      }
+    }
+    await request(session.baseUrl, `/slow-queries/history/${encodeURIComponent(opts.historyId)}`, {
+      method: "DELETE",
+      token: session.token,
+    });
+    stdout.write(`Deleted history entry ${opts.historyId}.\n`);
+    return;
+  }
+  if (opts.connection) {
+    if (!opts.yes) {
+      const ok = await ui.confirm({
+        message: `Delete ALL slow-query history for ${opts.connection}? This is destructive.`,
+        default: false,
+      });
+      if (!ok) {
+        stderr.write("Aborted.\n");
+        return;
+      }
+    }
+    const connectionId = await resolveConnectionId(session, opts.connection);
+    await request(
+      session.baseUrl,
+      `/slow-queries/history/connection/${encodeURIComponent(connectionId)}`,
+      { method: "DELETE", token: session.token },
+    );
+    stdout.write(`Deleted all history for ${opts.connection}.\n`);
+    return;
+  }
+  throw new Error("Pass --history-id <id> or --connection <name>.");
+}
+
+// ─── helpers ───────────────────────────────────────────────────────────────
+
+function parseCount(v) {
+  if (v == null) return null;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+function parseNum(v) {
+  if (v == null) return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+function safeParse(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function printHistory(stdout, items) {
+  const rows = items.map((h) => ({
+    id: String(h.id ?? h.historyId ?? ""),
+    createdAt: formatTime(h.createdAt || h.timestamp || h.analysisTime),
+    queries: String(h.queryCount ?? h.totalQueries ?? "?"),
+    summary: trim(h.summary || h.headline || "", 70),
+  }));
+  const cols = [
+    { key: "id", label: "ID" },
+    { key: "createdAt", label: "WHEN" },
+    { key: "queries", label: "#" },
+    { key: "summary", label: "SUMMARY" },
+  ];
+  printTable(stdout, cols, rows);
+}
+
+function printQueries(stdout, queries) {
+  const rows = queries.map((q) => ({
+    id: String(q.queryId || q.id || ""),
+    severity: q.severity || "?",
+    avgMs: q.avgExecutionTimeMs != null ? Math.round(q.avgExecutionTimeMs).toString() : "?",
+    calls: String(q.callCount ?? q.executionCount ?? "?"),
+    sample: trim(q.queryText || q.normalizedQuery || q.query || "", 60),
+  }));
+  const cols = [
+    { key: "id", label: "QUERY ID" },
+    { key: "severity", label: "SEVERITY" },
+    { key: "avgMs", label: "AVG MS" },
+    { key: "calls", label: "CALLS" },
+    { key: "sample", label: "QUERY" },
+  ];
+  printTable(stdout, cols, rows);
+}
+
+function printTable(stdout, cols, rows) {
+  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`);
+  }
+}
+
+function formatTime(value) {
+  if (!value) return "—";
+  try {
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) return String(value);
+    return d.toISOString().replace("T", " ").slice(0, 16) + "Z";
+  } catch {
+    return String(value);
+  }
+}
+
+function trim(text, max) {
+  if (!text) return "";
+  const s = String(text).replace(/\s+/g, " ").trim();
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+module.exports = { run };

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