@deepsql/mcp 0.5.0 → 0.8.0

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

package/src/commands/ask.js

@@ -1,44 +0,0 @@
-"use strict";
-
-const os = require("node:os");
-const { request } = require("../api/client");
-const { resolveSession } = require("./_session");
-const { resolveConnectionId } = require("./_connections");
-
-async function run(opts, { stdout = process.stdout } = {}) {
-  const question = opts.positional.join(" ").trim();
-  if (!question) throw new Error("Pass a question: `deepsql ask \"why is this query slow?\" --connection <name>`.");
-  if (!opts.connection) throw new Error("--connection <name> is required.");
-
-  const session = resolveSession(opts);
-  const connectionId = await resolveConnectionId(session, opts.connection);
-  const userId = opts.user || `cli-${os.userInfo().username}`;
-  const projectId = opts.project || "deepsql-cli";
-
-  const response = await request(session.baseUrl, "/chat", {
-    method: "POST",
-    token: session.token,
-    timeoutMs: 240000,
-    json: {
-      connectionId,
-      message: question,
-      chatId: opts.chat || null,
-      userId,
-      projectId,
-    },
-  });
-
-  if (opts.json) {
-    stdout.write(`${JSON.stringify(response, null, 2)}\n`);
-    return;
-  }
-
-  const answer = response?.answer || response?.message || response?.content || null;
-  if (answer) {
-    stdout.write(`${answer}\n`);
-  } else {
-    stdout.write(`${JSON.stringify(response, null, 2)}\n`);
-  }
-}
-
-module.exports = { run };