@deepsql/mcp 0.21.0 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepsql/mcp",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "DeepSQL CLI, DBA Agent TUI, and stdio MCP server for self-hosted deployments",
   "bin": {
     "deepsql": "bin/deepsql.js",

package/scripts/postinstall.js

@@ -1,57 +1,27 @@
 #!/usr/bin/env node
 "use strict";
 
-// Postinstall: pre-install the DeepSQL Agent (Hermes) runtime at `npm install -g`
-// time so the first `deepsql` launch is instant instead of triggering a heavy
-// one-time download. Best-effort and NON-FATAL — it never fails the npm install.
+// Postinstall: intentionally a no-op heavy-wise.
 //
-// Opt out (e.g. pure-MCP users who only want the editor tools, not the agent):
-//   DEEPSQL_SKIP_AGENT_SETUP=1 npm install -g @deepsql/mcp
+// The DeepSQL Agent is now a THIN client — `deepsql` / `deepsql agent` talk to
+// the server-side agent over the backend's brokered /agent/chat endpoint, so
+// there is NO local agent runtime to download. `npm install -g @deepsql/mcp` is
+// fast and quiet; nothing to pre-build.
 //
-// It auto-skips when there's nothing/no-one to set up for:
-//   - CI environments (process.env.CI)
-//   - non-global installs (local dev `npm install`, dependency installs)
-// The profile itself is provisioned later, on first `deepsql` after login,
-// because it needs the user's token.
-
-function log(msg) {
-  process.stdout.write(`${msg}\n`);
-}
-
-function skip(reason) {
-  // Silent for the common "not global / CI" cases; only note an explicit opt-out.
-  if (reason) log(`DeepSQL Agent: ${reason}`);
-  process.exit(0);
-}
+// We only print a short next-steps hint on a global install (and stay silent for
+// CI / local dependency installs so we never clutter other projects' logs).
 
 try {
-  if (process.env.DEEPSQL_SKIP_AGENT_SETUP) {
-    skip("agent runtime setup skipped (DEEPSQL_SKIP_AGENT_SETUP set).");
-  }
-  if (process.env.CI) skip();
-  // Only pre-install on an explicit global install (or a forced run). Local /
-  // dependency installs shouldn't pull a Python+Node runtime.
+  if (process.env.CI) process.exit(0);
   const isGlobal = String(process.env.npm_config_global || "") === "true";
-  if (!isGlobal && !process.env.DEEPSQL_FORCE_AGENT_SETUP) skip();
-
-  const { ensureHermes, hermesInstalled } = require("../src/agent/bootstrap");
-
-  if (hermesInstalled()) {
-    log("✓ DeepSQL Agent runtime already present.");
-    process.exit(0);
-  }
+  if (!isGlobal) process.exit(0);
 
-  log("DeepSQL Agent: pre-installing the agent runtime so `deepsql` starts instantly.");
-  log("  (Opt out next time with DEEPSQL_SKIP_AGENT_SETUP=1.)");
-  const ok = ensureHermes({ stderr: process.stdout });
-  if (ok) {
-    log("✓ DeepSQL Agent runtime ready. Run `deepsql login`, then `deepsql`.");
-  } else {
-    // Non-fatal: the lazy installer will retry on first `deepsql agent`.
-    log("DeepSQL Agent: runtime not pre-installed; it'll be set up on first `deepsql` run.");
-  }
-} catch (e) {
-  // Never break the npm install over agent pre-setup.
-  log(`DeepSQL Agent: skipped runtime pre-install (${e && e.message ? e.message : e}).`);
+  process.stdout.write(
+    "\nDeepSQL installed. Next:\n" +
+    "  deepsql login --url <your-deepsql-url>\n" +
+    "  deepsql                      # chat with the DeepSQL Agent (connects to your server)\n\n"
+  );
+} catch {
+  // Never let a cosmetic hint fail the install.
 }
 process.exit(0);

package/src/agent/bootstrap.js

@@ -113,7 +113,9 @@ function ensureHermes(io, { quiet = false } = {}) {
   });
 
   if (hermesInstalled()) {
-    err.write("✓ DeepSQL Agent runtime installed. (Ignore any \"run hermes setup\" note above — DeepSQL configures it for you.)\n");
+    err.write(quiet
+      ? "✓ DeepSQL Agent runtime installed.\n"
+      : "✓ DeepSQL Agent runtime installed. (Ignore any \"run hermes setup\" note above — DeepSQL configures it for you.)\n");
     return true;
   }
   err.write(

package/src/cli.js

@@ -90,13 +90,13 @@ const GLOBAL_OPTIONS = [
 
 const COMMAND_HELP = {
   agent: {
-    description: "Launch the DeepSQL Agent — an interactive chat TUI for DBA work, BI questions, and database guardrails. Running `deepsql` with no command in a terminal launches it too.",
-    usage: "deepsql agent [options]   (or just: deepsql)",
+    description: "Chat with the DeepSQL Agent — DBA work, BI questions, and database guardrails. A thin client: it connects to your server's agent (the same one behind the web Agent tab and Slack), nothing installs locally. Bare `deepsql` in a terminal opens interactive chat; pass a question for a one-shot.",
+    usage: 'deepsql agent ["<question>"] [options]   (or just: deepsql)',
     options: [
       ["--url <url>",          "DeepSQL instance to use (default: saved login)"],
-      ["--connection <name>",  "Default connection for the session"],
+      ["--connection <name>",  "Connection to ground answers on (default: saved active connection)"],
     ],
-    notes: "First run installs the agent runtime. Uses your saved `deepsql login` — no LLM key needed (the backend proxies the model).",
+    notes: "No local runtime or LLM key needed — the server runs the agent and proxies the model. Interactive chat resumes your most recent conversation (shared with the web Agent tab).",
   },
 
   login: {

package/src/commands/agent.js

@@ -1,15 +1,44 @@
 "use strict";
 
-// `deepsql agent` (and bare `deepsql` in a terminal): launch the DeepSQL Agent —
-// a branded Hermes TUI for DBA / BI / database-guard chat. Resolves the saved
-// login, lazily installs the runtime, provisions the `deepsql` profile pointed
-// at the backend LLM proxy (no LLM key needed), then hands the terminal to the TUI.
+// `deepsql agent` (and bare `deepsql` in a terminal): the DeepSQL Agent, as a
+// THIN client. It does not run an agent runtime locally — it talks to the
+// server-side agent through the backend's brokered, authenticated
+// `/agent/chat` endpoint (the same agent that powers the web Agent tab and
+// Slack). Identity, profile, connection scope, and conversation history are all
+// resolved server-side from your saved `deepsql login` — nothing heavy installs,
+// and your terminal shares the same conversations as the web app.
+//
+//   deepsql agent "how many active hotels?"   one-shot
+//   deepsql                                    interactive chat (resumes latest)
 
-const { spawn } = require("node:child_process");
+const readline = require("node:readline");
+const { request } = require("../api/client");
 const { resolveSession } = require("./_session");
-const { ensureHermes, ensureProfile, hermesBin, launchEnv, PROFILE } = require("../agent/bootstrap");
+const { resolveConnectionId } = require("./_connections");
+
+// The brokered turn can run a full multi-tool agent loop server-side; allow well
+// past the backend's own per-turn ceiling so we don't abandon a valid answer.
+const TURN_TIMEOUT_MS = 320000;
+
+async function runTurn(session, connectionId, message, conversationId) {
+  return request(session.baseUrl, "/agent/chat", {
+    method: "POST",
+    token: session.token,
+    json: { message, connectionId, conversationId },
+    timeoutMs: TURN_TIMEOUT_MS,
+  });
+}
+
+function renderReply(stdout, resp) {
+  if (resp && resp.ok && resp.answer && String(resp.answer).trim()) {
+    stdout.write(`\n${String(resp.answer).trim()}\n`);
+  } else {
+    stdout.write(`\n⚠ ${(resp && resp.error) || "the agent run ended early"}\n`);
+  }
+}
 
 async function run(opts, io = {}) {
+  const stdout = io.stdout || process.stdout;
   const stderr = io.stderr || process.stderr;
 
   let session;
@@ -20,26 +49,69 @@ async function run(opts, io = {}) {
     return 1;
   }
 
-  if (!ensureHermes(io)) {
-    stderr.write("Could not set up the DeepSQL Agent runtime. See https://github.com/NousResearch/hermes-agent for manual install.\n");
-    return 1;
+  // Connection is optional — the agent can chat without one and will ask if a
+  // question needs a database. Resolve the active default when present.
+  let connectionId = null;
+  try {
+    connectionId = await resolveConnectionId(session, opts.connection);
+  } catch {
+    /* no default connection set — fine */
   }
-  if (!ensureProfile(session, io)) {
-    stderr.write("Could not provision the DeepSQL Agent profile.\n");
-    return 1;
+
+  const message = (opts.positional || []).join(" ").trim();
+
+  // One-shot: a question on the command line.
+  if (message) {
+    try {
+      const resp = await runTurn(session, connectionId, message, null);
+      renderReply(stdout, resp);
+      return resp && resp.ok ? 0 : 1;
+    } catch (e) {
+      stderr.write(`Agent request failed: ${e.message}\n`);
+      return 1;
+    }
   }
-  // Branding is delivered via HERMES_TUI_DIR in launchEnv (Hermes runs our
-  // prebuilt branded TUI directly — no esbuild), set just below.
 
-  // Hand the terminal to the branded TUI (profile config sets interface=tui).
-  // launchEnv augments PATH (node/uv for the TUI + MCP server) and injects the
-  // provider vars that keep Hermes' first-run guard from ever firing.
-  const child = spawn(hermesBin(), ["-p", PROFILE, "--tui"], { stdio: "inherit", env: launchEnv(session) });
+  // Interactive: a line REPL against the server agent. Requires a TTY.
+  if (!stdout.isTTY) {
+    stderr.write('Usage: deepsql agent "<question>"   (or run in a terminal for interactive chat)\n');
+    return 2;
+  }
+
+  stdout.write("DeepSQL Agent — connected to your server agent. Type a question; `exit` or Ctrl-C to quit.\n");
+  // conversationId stays null on the first turn so the server resumes your most
+  // recent conversation for this connection (shared with the web Agent tab);
+  // subsequent turns reuse the id it returns.
+  let conversationId = null;
+  const rl = readline.createInterface({ input: process.stdin, output: stdout, prompt: "\nyou › " });
+  rl.prompt();
+
   return await new Promise((resolve) => {
-    child.on("exit", (code) => resolve(code ?? 0));
-    child.on("error", (err) => {
-      stderr.write(`Failed to launch the DeepSQL Agent: ${err.message}\n`);
-      resolve(1);
+    rl.on("line", async (line) => {
+      const text = line.trim();
+      if (!text) {
+        rl.prompt();
+        return;
+      }
+      if (text === "exit" || text === "quit") {
+        rl.close();
+        return;
+      }
+      rl.pause();
+      stdout.write("…thinking\n");
+      try {
+        const resp = await runTurn(session, connectionId, text, conversationId);
+        if (resp && resp.conversationId) conversationId = resp.conversationId;
+        renderReply(stdout, resp);
+      } catch (e) {
+        stdout.write(`\n⚠ ${e.message}\n`);
+      }
+      rl.resume();
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      stdout.write("\nBye.\n");
+      resolve(0);
     });
   });
 }