@vaultgradient/pipequery-cli 0.3.3 → 0.4.0

package/dist/index.js

@@ -83,7 +83,7 @@ async function initCommand() {
 
 // src/commands/serve.ts
 import { writeFile as writeFile3, mkdir, readFile as readFile3, unlink } from "fs/promises";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { spawn } from "child_process";
 
@@ -236,11 +236,11 @@ var WebSocketSourceAdapter = class {
   listeners = /* @__PURE__ */ new Set();
   maxBuffer;
   async start() {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       this.ws = new WebSocket(this.config.url);
       this.ws.on("open", () => {
         this.error = void 0;
-        resolve9();
+        resolve10();
       });
       this.ws.on("message", (raw) => {
         try {
@@ -394,6 +394,455 @@ var StaticSourceAdapter = class {
   }
 };
 
+// src/server/sources/postgres.ts
+import pg from "pg";
+var DEFAULT_INTERVAL_MS = 3e4;
+var DEFAULT_MAX_ROWS = 1e4;
+function expandEnv(input) {
+  return input.replace(/\$\{([A-Z0-9_]+)\}/gi, (_, name) => {
+    const value = process.env[name];
+    if (value === void 0) {
+      process.stderr.write(
+        `[pipequery] env var "${name}" referenced in postgres source URL is not set
+`
+      );
+      return "";
+    }
+    return value;
+  });
+}
+function resolveSsl(ssl) {
+  if (ssl === false) return false;
+  if (ssl === "no-verify") return { rejectUnauthorized: false };
+  return { rejectUnauthorized: true };
+}
+var PostgresSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS;
+  }
+  config;
+  pool = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    const connectionString = expandEnv(this.config.url);
+    this.pool = new pg.Pool({
+      connectionString,
+      ssl: resolveSsl(this.config.ssl),
+      // Small pool — we're read-only polling, not a transactional app.
+      min: 0,
+      max: 2,
+      idleTimeoutMillis: 1e4
+    });
+    this.pool.on("error", (err) => {
+      this.error = err.message;
+    });
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.pool) {
+      void this.pool.end();
+      this.pool = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  async fetch() {
+    if (!this.pool) {
+      this.error = "Postgres pool not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const res = await this.pool.query(capQuery);
+      if (res.rows.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = res.rows;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/mysql.ts
+import mysql from "mysql2/promise";
+var DEFAULT_INTERVAL_MS2 = 3e4;
+var DEFAULT_MAX_ROWS2 = 1e4;
+function expandEnv2(input) {
+  return input.replace(/\$\{([A-Z0-9_]+)\}/gi, (_, name) => {
+    const value = process.env[name];
+    if (value === void 0) {
+      process.stderr.write(
+        `[pipequery] env var "${name}" referenced in mysql source URL is not set
+`
+      );
+      return "";
+    }
+    return value;
+  });
+}
+function resolveSsl2(ssl) {
+  if (ssl === false) return void 0;
+  if (ssl === "no-verify") return { rejectUnauthorized: false };
+  return { rejectUnauthorized: true };
+}
+var MysqlSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS2;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS2;
+  }
+  config;
+  pool = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    const uri = expandEnv2(this.config.url);
+    this.pool = mysql.createPool({
+      uri,
+      ssl: resolveSsl2(this.config.ssl),
+      connectionLimit: 2,
+      waitForConnections: true,
+      // mysql2 returns BigInt for large integers by default — stringify so the
+      // data serializes cleanly to JSON (which can't encode BigInt).
+      supportBigNumbers: true,
+      bigNumberStrings: true
+    });
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.pool) {
+      void this.pool.end();
+      this.pool = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  async fetch() {
+    if (!this.pool) {
+      this.error = "MySQL pool not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon2(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const [rows] = await this.pool.query(capQuery);
+      const asArray = Array.isArray(rows) ? rows : [];
+      if (asArray.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = asArray;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon2(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/sqlite.ts
+import { resolve as resolve4 } from "path";
+import Database from "better-sqlite3";
+var DEFAULT_INTERVAL_MS3 = 3e4;
+var DEFAULT_MAX_ROWS3 = 1e4;
+var IN_MEMORY = ":memory:";
+var SqliteSourceAdapter = class {
+  constructor(config, cwd) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS3;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS3;
+    this.readonly = config.readonly ?? true;
+    this.resolvedPath = config.path === IN_MEMORY ? IN_MEMORY : resolve4(cwd, config.path);
+  }
+  config;
+  db = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  resolvedPath;
+  readonly;
+  async start() {
+    const opts = this.resolvedPath === IN_MEMORY ? {} : { readonly: this.readonly, fileMustExist: this.readonly };
+    this.db = new Database(this.resolvedPath, opts);
+    if (this.resolvedPath !== IN_MEMORY && !this.readonly) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  async fetch() {
+    if (!this.db) {
+      this.error = "SQLite database not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon3(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const rows = this.db.prepare(capQuery).all();
+      if (rows.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = rows;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon3(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/kafka.ts
+import { randomBytes } from "crypto";
+import { Kafka, logLevel } from "kafkajs";
+var DEFAULT_MAX_BUFFER = 1e3;
+function expandEnv3(input) {
+  return input.replace(/\$\{([A-Z0-9_]+)\}/gi, (_, name) => {
+    const value = process.env[name];
+    if (value === void 0) {
+      process.stderr.write(
+        `[pipequery] env var "${name}" referenced in kafka source is not set
+`
+      );
+      return "";
+    }
+    return value;
+  });
+}
+function normalizeBrokers(brokers) {
+  const list = Array.isArray(brokers) ? brokers : brokers.split(",");
+  return list.map((b) => expandEnv3(b.trim())).filter(Boolean);
+}
+var KafkaSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.maxBuffer = config.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    this.groupId = config.groupId ?? `pipequery-${randomBytes(6).toString("hex")}`;
+  }
+  config;
+  data = [];
+  kafka = null;
+  consumer = null;
+  lastFetch = null;
+  error;
+  connected = false;
+  listeners = /* @__PURE__ */ new Set();
+  maxBuffer;
+  groupId;
+  async start() {
+    const brokers = normalizeBrokers(this.config.brokers);
+    if (brokers.length === 0) {
+      throw new Error("Kafka source has no brokers configured");
+    }
+    this.kafka = new Kafka({
+      clientId: `pipequery-${this.config.topic}`,
+      brokers,
+      ssl: this.config.ssl ?? false,
+      sasl: this.config.sasl ? {
+        mechanism: this.config.sasl.mechanism,
+        username: expandEnv3(this.config.sasl.username),
+        password: expandEnv3(this.config.sasl.password)
+      } : void 0,
+      // Silence kafkajs's own logger — we surface errors via SourceStatus.
+      logLevel: logLevel.ERROR
+    });
+    this.consumer = this.kafka.consumer({ groupId: this.groupId });
+    await this.consumer.connect();
+    await this.consumer.subscribe({
+      topic: this.config.topic,
+      fromBeginning: this.config.fromBeginning ?? false
+    });
+    this.connected = true;
+    this.error = void 0;
+    void this.consumer.run({
+      eachMessage: async ({ message, partition }) => {
+        try {
+          const row = this.decode(message.value, message.key, message.timestamp, partition, message.offset);
+          this.data.push(row);
+          if (this.data.length > this.maxBuffer) {
+            this.data = this.data.slice(-this.maxBuffer);
+          }
+          this.lastFetch = /* @__PURE__ */ new Date();
+          this.error = void 0;
+          this.notify();
+        } catch {
+        }
+      }
+    });
+  }
+  stop() {
+    this.connected = false;
+    if (this.consumer) {
+      const consumer = this.consumer;
+      this.consumer = null;
+      void consumer.disconnect().catch(() => {
+      });
+    }
+    this.kafka = null;
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: this.connected && !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  decode(value, key, timestamp, partition, offset) {
+    const base = {
+      _kafka_topic: this.config.topic,
+      _kafka_partition: partition,
+      _kafka_offset: offset,
+      _kafka_timestamp: Number.parseInt(timestamp, 10),
+      _kafka_key: key ? key.toString("utf8") : null
+    };
+    if (!value) {
+      return { ...base, value: null };
+    }
+    const format = this.config.valueFormat ?? "json";
+    if (format === "string") {
+      return { ...base, value: value.toString("utf8") };
+    }
+    if (format === "raw") {
+      return { ...base, value: value.toString("base64") };
+    }
+    const decoded = JSON.parse(value.toString("utf8"));
+    if (decoded !== null && typeof decoded === "object" && !Array.isArray(decoded)) {
+      return { ...base, ...decoded };
+    }
+    return { ...base, value: decoded };
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+
 // src/server/sources/manager.ts
 var SourceManager = class {
   constructor(cwd) {
@@ -479,6 +928,14 @@ var SourceManager = class {
         return new FileSourceAdapter(config, this.cwd);
       case "static":
         return new StaticSourceAdapter(config);
+      case "postgres":
+        return new PostgresSourceAdapter(config);
+      case "mysql":
+        return new MysqlSourceAdapter(config);
+      case "sqlite":
+        return new SqliteSourceAdapter(config, this.cwd);
+      case "kafka":
+        return new KafkaSourceAdapter(config);
       default:
         throw new Error(`Unknown source type: ${config.type}`);
     }
@@ -2665,8 +3122,8 @@ function printServerStartup(opts) {
 // src/commands/serve.ts
 async function serveCommand(opts) {
   const cwd = process.cwd();
-  const pqDir = resolve4(cwd, ".pipequery");
-  const serverJsonPath = resolve4(pqDir, "server.json");
+  const pqDir = resolve5(cwd, ".pipequery");
+  const serverJsonPath = resolve5(pqDir, "server.json");
   if (opts.stop) {
     return stopDaemon(serverJsonPath);
   }
@@ -2678,7 +3135,7 @@ async function serveCommand(opts) {
   }
   const { app, sourceManager } = await createServer(config, configPath, cwd);
   await mkdir(pqDir, { recursive: true });
-  const logPath = resolve4(pqDir, "server.log");
+  const logPath = resolve5(pqDir, "server.log");
   await writeFile3(serverJsonPath, JSON.stringify({ url: `http://localhost:${port}`, pid: process.pid, daemon: false, log: logPath }));
   await app.listen({ port, host });
   const sourceCount = sourceManager.getSourceNames().length;
@@ -2700,9 +3157,9 @@ async function serveCommand(opts) {
   process.on("SIGTERM", shutdown);
 }
 async function startDaemon(cwd, port, host) {
-  const pqDir = resolve4(cwd, ".pipequery");
-  const serverJsonPath = resolve4(pqDir, "server.json");
-  const logPath = resolve4(pqDir, "server.log");
+  const pqDir = resolve5(cwd, ".pipequery");
+  const serverJsonPath = resolve5(pqDir, "server.json");
+  const logPath = resolve5(pqDir, "server.log");
   if (existsSync3(serverJsonPath)) {
     try {
       const info2 = JSON.parse(await readFile3(serverJsonPath, "utf-8"));
@@ -2759,11 +3216,11 @@ import chalk4 from "chalk";
 
 // src/utils/server-discovery.ts
 import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import { existsSync as existsSync4 } from "fs";
 async function getServerUrl() {
   const cwd = process.cwd();
-  const serverJsonPath = resolve5(cwd, ".pipequery", "server.json");
+  const serverJsonPath = resolve6(cwd, ".pipequery", "server.json");
   if (existsSync4(serverJsonPath)) {
     try {
       const info2 = JSON.parse(await readFile4(serverJsonPath, "utf-8"));
@@ -2906,8 +3363,60 @@ async function sourceAddCommand(name, opts) {
         ...opts.watch ? { watch: true } : {}
       };
       break;
+    case "postgres":
+      if (!opts.url) throw new Error("--url is required for Postgres sources");
+      if (!opts.query) throw new Error("--query is required for Postgres sources");
+      sourceConfig = {
+        type: "postgres",
+        url: opts.url,
+        query: opts.query,
+        interval: opts.interval ?? "30s",
+        ...opts.ssl === "no-verify" ? { ssl: "no-verify" } : {},
+        ...opts.ssl === "false" ? { ssl: false } : {},
+        ...opts.maxRows ? { maxRows: Number.parseInt(opts.maxRows, 10) } : {}
+      };
+      break;
+    case "mysql":
+      if (!opts.url) throw new Error("--url is required for MySQL sources");
+      if (!opts.query) throw new Error("--query is required for MySQL sources");
+      sourceConfig = {
+        type: "mysql",
+        url: opts.url,
+        query: opts.query,
+        interval: opts.interval ?? "30s",
+        ...opts.ssl === "no-verify" ? { ssl: "no-verify" } : {},
+        ...opts.ssl === "false" ? { ssl: false } : {},
+        ...opts.maxRows ? { maxRows: Number.parseInt(opts.maxRows, 10) } : {}
+      };
+      break;
+    case "sqlite":
+      if (!opts.path) throw new Error("--path is required for SQLite sources");
+      if (!opts.query) throw new Error("--query is required for SQLite sources");
+      sourceConfig = {
+        type: "sqlite",
+        path: opts.path,
+        query: opts.query,
+        interval: opts.interval ?? "30s",
+        ...opts.maxRows ? { maxRows: Number.parseInt(opts.maxRows, 10) } : {},
+        ...opts.readonly === false ? { readonly: false } : {}
+      };
+      break;
+    case "kafka":
+      if (!opts.brokers) throw new Error("--brokers is required for Kafka sources (comma-separated)");
+      if (!opts.topic) throw new Error("--topic is required for Kafka sources");
+      sourceConfig = {
+        type: "kafka",
+        brokers: opts.brokers,
+        topic: opts.topic,
+        ...opts.groupId ? { groupId: opts.groupId } : {},
+        ...opts.fromBeginning ? { fromBeginning: true } : {},
+        ...opts.maxBuffer ? { maxBuffer: Number.parseInt(opts.maxBuffer, 10) } : {},
+        ...opts.valueFormat ? { valueFormat: opts.valueFormat } : {},
+        ...opts.ssl === "true" ? { ssl: true } : {}
+      };
+      break;
     default:
-      throw new Error(`Unknown source type: ${opts.type}. Use: rest, websocket, file`);
+      throw new Error(`Unknown source type: ${opts.type}. Use: rest, websocket, file, postgres, mysql, sqlite, kafka`);
   }
   config.sources[name] = sourceConfig;
   await saveConfig(config, configPath);
@@ -3862,7 +4371,7 @@ async function dashboardCommand(opts) {
 import React6 from "react";
 import { render as render2 } from "ink";
 import { existsSync as existsSync5, readFileSync } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 
 // src/tui/MonitorApp.tsx
 import { useState as useState5, useEffect as useEffect4 } from "react";
@@ -4046,7 +4555,7 @@ function MonitorApp({ serverUrl }) {
 // src/commands/monitor.ts
 async function monitorCommand() {
   const serverUrl = await getServerUrl();
-  const discoveryPath = resolve6(process.cwd(), ".pipequery", "server.json");
+  const discoveryPath = resolve7(process.cwd(), ".pipequery", "server.json");
   let logPath;
   if (existsSync5(discoveryPath)) {
     try {
@@ -4058,7 +4567,7 @@ async function monitorCommand() {
     }
   }
   if (!logPath) {
-    const fallback = resolve6(process.cwd(), ".pipequery", "server.log");
+    const fallback = resolve7(process.cwd(), ".pipequery", "server.log");
     if (existsSync5(fallback)) {
       logPath = fallback;
     }
@@ -4078,7 +4587,7 @@ async function monitorCommand() {
 
 // src/commands/remote.ts
 import { writeFile as writeFile4 } from "fs/promises";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 
 // src/docker/templates.ts
 function generateDockerfile(port) {
@@ -4128,9 +4637,9 @@ async function remoteDeployCommand() {
   const cwd = process.cwd();
   const { config } = await loadConfig(cwd);
   const port = config.server.port;
-  await writeFile4(resolve7(cwd, "Dockerfile"), generateDockerfile(port));
-  await writeFile4(resolve7(cwd, "docker-compose.yaml"), generateDockerCompose(port));
-  await writeFile4(resolve7(cwd, ".dockerignore"), generateDockerignore());
+  await writeFile4(resolve8(cwd, "Dockerfile"), generateDockerfile(port));
+  await writeFile4(resolve8(cwd, "docker-compose.yaml"), generateDockerCompose(port));
+  await writeFile4(resolve8(cwd, ".dockerignore"), generateDockerignore());
   log.success("Generated Dockerfile, docker-compose.yaml, and .dockerignore");
   log.info(`Run: docker compose up -d --build`);
   log.info(`Then: pq remote connect http://localhost:${port}`);
@@ -4140,7 +4649,7 @@ async function loadOrCreateConfig(cwd) {
   if (existing) {
     return loadConfig(cwd);
   }
-  const configPath = resolve7(cwd, "pipequery.yaml");
+  const configPath = resolve8(cwd, "pipequery.yaml");
   const config = {
     server: { ...DEFAULT_CONFIG.server },
     sources: {},
@@ -4188,6 +4697,479 @@ async function remoteStatusCommand() {
   }
 }
 
+// src/mcp/provider.ts
+var LocalProvider = class {
+  constructor(config, cwd) {
+    this.config = config;
+    this.sourceManager = new SourceManager(cwd);
+    this.endpoints = new Map(Object.entries(config.endpoints));
+    this.ready = this.bootSources();
+  }
+  config;
+  sourceManager;
+  endpoints;
+  ready;
+  async bootSources() {
+    for (const [name, src] of Object.entries(this.config.sources)) {
+      try {
+        await this.sourceManager.addSource(name, src);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[pipequery-mcp] Source "${name}" failed to start: ${msg}
+`);
+      }
+    }
+  }
+  async listSources() {
+    await this.ready;
+    const statuses = this.sourceManager.getAllStatuses();
+    return Object.entries(statuses).map(([name, status]) => ({ name, status }));
+  }
+  async describeSource(name, sampleSize = 5) {
+    await this.ready;
+    const status = this.sourceManager.getSourceStatus(name);
+    const data = this.sourceManager.getSourceData(name);
+    if (!status || !data) return void 0;
+    const sample = data.slice(0, sampleSize);
+    const fields = inferFields(data);
+    return { name, status, sample, fields };
+  }
+  async listEndpoints() {
+    await this.ready;
+    return [...this.endpoints].map(([path, config]) => ({ path, config }));
+  }
+  async callEndpoint(path) {
+    await this.ready;
+    const endpoint2 = this.endpoints.get(path);
+    if (!endpoint2) {
+      throw new Error(`Endpoint "${path}" not found`);
+    }
+    const context = this.sourceManager.getContext();
+    return query(context, endpoint2.query);
+  }
+  async runQuery(expression) {
+    await this.ready;
+    const context = this.sourceManager.getContext();
+    return query(context, expression);
+  }
+  async dispose() {
+    await this.sourceManager.dispose();
+  }
+  // Exposed for the HTTP plugin that wants to mount the MCP server into an
+  // existing `createServer` instance; the caller passes in their own manager.
+  static withSourceManager(sourceManager, endpoints) {
+    return new AttachedLocalProvider(sourceManager, endpoints);
+  }
+};
+var AttachedLocalProvider = class {
+  constructor(sourceManager, endpoints) {
+    this.sourceManager = sourceManager;
+    this.endpoints = endpoints;
+  }
+  sourceManager;
+  endpoints;
+  async listSources() {
+    const statuses = this.sourceManager.getAllStatuses();
+    return Object.entries(statuses).map(([name, status]) => ({ name, status }));
+  }
+  async describeSource(name, sampleSize = 5) {
+    const status = this.sourceManager.getSourceStatus(name);
+    const data = this.sourceManager.getSourceData(name);
+    if (!status || !data) return void 0;
+    return { name, status, sample: data.slice(0, sampleSize), fields: inferFields(data) };
+  }
+  async listEndpoints() {
+    return [...this.endpoints].map(([path, config]) => ({ path, config }));
+  }
+  async callEndpoint(path) {
+    const endpoint2 = this.endpoints.get(path);
+    if (!endpoint2) throw new Error(`Endpoint "${path}" not found`);
+    return query(this.sourceManager.getContext(), endpoint2.query);
+  }
+  async runQuery(expression) {
+    return query(this.sourceManager.getContext(), expression);
+  }
+  async dispose() {
+  }
+};
+var AttachedProvider = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  baseUrl;
+  async get(path) {
+    const res = await fetch(`${this.baseUrl}${path}`);
+    if (!res.ok) throw new Error(`GET ${path} failed: HTTP ${res.status}`);
+    return res.json();
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) throw new Error(`POST ${path} failed: HTTP ${res.status}`);
+    return res.json();
+  }
+  async listSources() {
+    const statuses = await this.get("/api/_control/sources");
+    return Object.entries(statuses).map(([name, status]) => ({ name, status }));
+  }
+  async describeSource(name, sampleSize = 5) {
+    const res = await this.post(`/api/_control/sources/${encodeURIComponent(name)}/test`, {});
+    if (!res.ok || !res.status || !res.sample) return void 0;
+    return {
+      name,
+      status: res.status,
+      sample: res.sample.slice(0, sampleSize),
+      fields: inferFields(res.sample)
+    };
+  }
+  async listEndpoints() {
+    const endpoints = await this.get("/api/_control/endpoints");
+    return Object.entries(endpoints).map(([path, config]) => ({ path, config }));
+  }
+  async callEndpoint(path) {
+    const normalized = path.startsWith("/") ? path : `/${path}`;
+    const res = await fetch(`${this.baseUrl}${normalized}`);
+    if (!res.ok) throw new Error(`GET ${normalized} failed: HTTP ${res.status}`);
+    return res.json();
+  }
+  async runQuery(expression) {
+    const res = await this.post(
+      "/api/_control/query",
+      { query: expression }
+    );
+    if (!res.ok) throw new Error(res.error ?? "Query failed");
+    return res.result;
+  }
+  async dispose() {
+  }
+};
+function inferFields(rows) {
+  const fields = /* @__PURE__ */ new Set();
+  for (const row of rows.slice(0, 20)) {
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      for (const k of Object.keys(row)) fields.add(k);
+    }
+  }
+  return [...fields];
+}
+
+// src/mcp/stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+var DEFAULT_INFO = {
+  name: "pipequery",
+  version: "0.1.0"
+};
+function createMcpServer(provider, info2 = DEFAULT_INFO) {
+  const mcp2 = new McpServer(info2);
+  mcp2.registerTool(
+    "query",
+    {
+      title: "Run a PipeQuery expression",
+      description: "Execute a PipeQuery pipe-based expression (e.g. `crypto | where(price > 100) | sort(price desc) | first(5)`) against all currently configured sources. Returns the computed result as JSON.",
+      inputSchema: {
+        expression: z.string().min(1).describe("The PipeQuery expression. Source names used in the expression must be configured; call `list_sources` to see them.")
+      }
+    },
+    async ({ expression }) => {
+      const result = await provider.runQuery(expression);
+      return toolResult(result);
+    }
+  );
+  mcp2.registerTool(
+    "list_sources",
+    {
+      title: "List configured data sources",
+      description: "List every data source configured in pipequery.yaml along with its current health, row count, and last-fetch timestamp."
+    },
+    async () => {
+      const sources = await provider.listSources();
+      return toolResult({ count: sources.length, sources });
+    }
+  );
+  mcp2.registerTool(
+    "describe_source",
+    {
+      title: "Describe a data source",
+      description: "Return a sample of rows and the inferred field names for a single source. Useful before constructing a query.",
+      inputSchema: {
+        name: z.string().min(1).describe("Source name as returned by list_sources."),
+        sample_size: z.number().int().positive().max(100).optional().describe("Number of rows to include in the sample. Defaults to 5, max 100.")
+      }
+    },
+    async ({ name, sample_size }) => {
+      const description = await provider.describeSource(name, sample_size);
+      if (!description) {
+        return toolError(`Source "${name}" not found`);
+      }
+      return toolResult(description);
+    }
+  );
+  mcp2.registerTool(
+    "list_endpoints",
+    {
+      title: "List pre-configured query endpoints",
+      description: "Return every endpoint declared in pipequery.yaml along with its stored query expression. These endpoints can be invoked via `call_endpoint`."
+    },
+    async () => {
+      const endpoints = await provider.listEndpoints();
+      return toolResult({ count: endpoints.length, endpoints });
+    }
+  );
+  mcp2.registerTool(
+    "call_endpoint",
+    {
+      title: "Invoke a pre-configured endpoint",
+      description: "Execute the stored query for an endpoint path (e.g. `/api/top-coins`) and return its JSON result. Equivalent to the HTTP endpoint on `pq serve`, without needing a live HTTP call.",
+      inputSchema: {
+        path: z.string().min(1).describe("Endpoint path, exactly as declared in pipequery.yaml (typically begins with `/`).")
+      }
+    },
+    async ({ path }) => {
+      try {
+        const result = await provider.callEndpoint(path);
+        return toolResult(result);
+      } catch (err) {
+        return toolError(err instanceof Error ? err.message : String(err));
+      }
+    }
+  );
+  return mcp2;
+}
+function toolResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function toolError(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+// src/mcp/stdio.ts
+async function runStdio(provider, info2) {
+  const mcp2 = createMcpServer(provider, info2);
+  const transport = new StdioServerTransport();
+  await mcp2.connect(transport);
+  const cleanup = async () => {
+    try {
+      await mcp2.close();
+    } finally {
+      await provider.dispose();
+    }
+  };
+  process.stdin.on("close", () => {
+    void cleanup().then(() => process.exit(0));
+  });
+  process.on("SIGINT", () => void cleanup().then(() => process.exit(0)));
+  process.on("SIGTERM", () => void cleanup().then(() => process.exit(0)));
+}
+
+// src/mcp/http.ts
+import { createServer as createHttpServer } from "http";
+import { randomUUID } from "crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+async function runHttp(provider, opts) {
+  const host = opts.host ?? "127.0.0.1";
+  const port = opts.port;
+  const mountPath = opts.path ?? "/mcp";
+  const transports = /* @__PURE__ */ new Map();
+  const authToken = opts.authToken;
+  if (!authToken) {
+    process.stderr.write(
+      "[pipequery-mcp] WARNING: HTTP endpoint is UNAUTHENTICATED. Set --auth-token or PIPEQUERY_MCP_TOKEN for anything beyond localhost.\n"
+    );
+  }
+  const attachTransport = async () => {
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID(),
+      onsessioninitialized: (sessionId) => {
+        transports.set(sessionId, transport);
+      },
+      onsessionclosed: (sessionId) => {
+        transports.delete(sessionId);
+      }
+    });
+    const mcp2 = createMcpServer(provider, opts.info);
+    await mcp2.connect(transport);
+    return transport;
+  };
+  const server = createHttpServer(async (req, res) => {
+    if (!req.url) {
+      res.statusCode = 400;
+      res.end("Bad Request");
+      return;
+    }
+    const requestPath = req.url.split("?")[0];
+    if (requestPath !== mountPath) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    if (authToken && !isAuthorized(req, authToken)) {
+      res.statusCode = 401;
+      res.setHeader("content-type", "application/json");
+      res.setHeader("www-authenticate", 'Bearer realm="pipequery-mcp"');
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32001, message: "Unauthorized: missing or invalid bearer token" },
+          id: null
+        })
+      );
+      return;
+    }
+    try {
+      const body = await readJsonBody(req);
+      const sessionId = getSessionId(req);
+      let transport = sessionId ? transports.get(sessionId) : void 0;
+      if (!transport) {
+        transport = await attachTransport();
+      }
+      await transport.handleRequest(req, res, body);
+    } catch (err) {
+      process.stderr.write(
+        `[pipequery-mcp] transport error: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`
+      );
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: err instanceof Error ? err.message : String(err)
+          },
+          id: null
+        }));
+      } else {
+        res.end();
+      }
+    }
+  });
+  await new Promise((resolve10) => server.listen(port, host, resolve10));
+  return {
+    url: `http://${host}:${port}${mountPath}`,
+    async close() {
+      await new Promise((resolve10, reject) => {
+        server.close((err) => err ? reject(err) : resolve10());
+      });
+      for (const t of transports.values()) {
+        await t.close();
+      }
+      transports.clear();
+      await provider.dispose();
+    }
+  };
+}
+function isAuthorized(req, expected) {
+  const header = req.headers["authorization"];
+  const raw = typeof header === "string" ? header : Array.isArray(header) ? header[0] : void 0;
+  if (!raw) return false;
+  const match = raw.match(/^Bearer\s+(.+)$/i);
+  if (!match) return false;
+  const token = match[1].trim();
+  return timingSafeEqual(token, expected);
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function getSessionId(req) {
+  const header = req.headers["mcp-session-id"];
+  if (typeof header === "string") return header;
+  if (Array.isArray(header)) return header[0];
+  return void 0;
+}
+async function readJsonBody(req) {
+  const method = req.method?.toUpperCase();
+  if (method === "GET" || method === "DELETE") return void 0;
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return void 0;
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text.trim()) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error("Invalid JSON body");
+  }
+}
+
+// src/commands/mcp.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+async function mcpServeCommand(opts) {
+  const provider = await buildProvider(opts.attach);
+  const isStdio = !opts.http;
+  if (isStdio) {
+    await runStdio(provider);
+    return;
+  }
+  const port = opts.port ?? 3001;
+  const host = opts.host ?? "127.0.0.1";
+  const authToken = opts.authToken ?? process.env.PIPEQUERY_MCP_TOKEN;
+  const handle = await runHttp(provider, { port, host, authToken });
+  log.success(`PipeQuery MCP server listening on ${handle.url}`);
+  log.info("Connect any MCP client to the URL above (Claude, Cursor, custom agents).");
+  log.info("Press Ctrl+C to stop.");
+  const shutdown = async () => {
+    log.info("Shutting down MCP server...");
+    await handle.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+}
+async function mcpInspectCommand(opts) {
+  const provider = await buildProvider(opts.attach);
+  const mcp2 = createMcpServer(provider);
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await mcp2.connect(serverTransport);
+  const client = new Client({ name: "pq-mcp-inspect", version: "0.1.0" });
+  await client.connect(clientTransport);
+  try {
+    const { tools } = await client.listTools();
+    const summary = {
+      server: "pipequery",
+      toolCount: tools.length,
+      tools: tools.map((t) => ({
+        name: t.name,
+        title: t.title,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }))
+    };
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+  } finally {
+    await client.close();
+    await mcp2.close();
+    await provider.dispose();
+  }
+}
+async function buildProvider(attachUrl) {
+  if (attachUrl) {
+    return new AttachedProvider(attachUrl);
+  }
+  const cwd = process.cwd();
+  const { config } = await loadConfig(cwd);
+  return new LocalProvider(config, cwd);
+}
+
 // src/commands/completion.ts
 var BASH_COMPLETION = `###-begin-pq-completions-###
 _pq_completions() {
@@ -4352,11 +5334,11 @@ function detectShell() {
 
 // src/commands/stop.ts
 import { readFile as readFile5, unlink as unlink2 } from "fs/promises";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 import { existsSync as existsSync6 } from "fs";
 async function stopCommand(opts) {
   const cwd = process.cwd();
-  const serverJsonPath = resolve8(cwd, ".pipequery", "server.json");
+  const serverJsonPath = resolve9(cwd, ".pipequery", "server.json");
   if (!existsSync6(serverJsonPath)) {
     log.error("No running server found.");
     log.dim("Start one with: pq serve  or  pq serve -d");
@@ -4608,7 +5590,7 @@ program.command("serve").description("Start the PipeQuery server").option("-p, -
 program.command("query <expression>").description("Run an ad-hoc PipeQuery expression").option("-f, --format <format>", "Output format: table, json", "table").action(queryCommand);
 var source = program.command("source").description("Manage data sources");
 source.command("list").description("List configured data sources").action(sourceListCommand);
-source.command("add <name>").description("Add a data source").requiredOption("-t, --type <type>", "Source type: rest, websocket, file").option("-u, --url <url>", "URL for REST or WebSocket sources").option("-i, --interval <interval>", "Poll interval for REST (e.g., 30s, 5m)", "30s").option("-d, --data-path <path>", "Dot-path to extract data from response").option("-p, --path <path>", "File path for file sources").option("-w, --watch", "Watch file for changes").action(sourceAddCommand);
+source.command("add <name>").description("Add a data source").requiredOption("-t, --type <type>", "Source type: rest, websocket, file, postgres, mysql, sqlite, kafka").option("-u, --url <url>", "Connection URL for REST / WebSocket / Postgres / MySQL sources").option("-i, --interval <interval>", "Poll interval (e.g., 30s, 5m)", "30s").option("-d, --data-path <path>", "Dot-path to extract data from REST response").option("-p, --path <path>", "File path for file or sqlite sources").option("-w, --watch", "Watch file for changes (file sources)").option("-q, --query <sql>", "SELECT query for Postgres / MySQL / SQLite sources").option("--ssl <mode>", "Postgres / MySQL SSL: require (default), no-verify, false; Kafka: true / false").option("--max-rows <n>", "DB sources: safety cap on rows per fetch (default 10000)").option("--no-readonly", "SQLite: open the database read-write instead of read-only").option("-b, --brokers <list>", "Kafka: comma-separated bootstrap brokers (supports ${ENV_VAR})").option("--topic <topic>", "Kafka topic to subscribe to").option("--group-id <id>", "Kafka consumer group (default: ephemeral per-process)").option("--from-beginning", "Kafka: read topic from the start instead of latest").option("--value-format <fmt>", "Kafka value decoding: json (default), string, raw").option("--max-buffer <n>", "Kafka / WebSocket: ring buffer size (default 1000)").action(sourceAddCommand);
 source.command("remove <name>").description("Remove a data source").action(sourceRemoveCommand);
 source.command("test <name>").description("Test a data source and show sample data").action(sourceTestCommand);
 var endpoint = program.command("endpoint").description("Manage API endpoints");
@@ -4621,6 +5603,9 @@ var remote = program.command("remote").description("Manage remote deployment");
 remote.command("deploy").description("Generate Dockerfile and docker-compose.yaml").action(remoteDeployCommand);
 remote.command("connect <url>").description("Connect CLI to a remote PipeQuery server").action(remoteConnectCommand);
 remote.command("status").description("Check remote server health").action(remoteStatusCommand);
+var mcp = program.command("mcp").description("Model Context Protocol server for AI clients");
+mcp.command("serve").description("Start an MCP server exposing pipequery as tools (for Claude, Cursor, Copilot, etc.)").option("--http", "Serve over HTTP/SSE instead of stdio").option("-p, --port <port>", "HTTP port (when --http is set)", parseInt).option("-H, --host <host>", "HTTP host (when --http is set)").option("--attach <url>", "Attach to a running `pq serve` instance at the given URL instead of loading pipequery.yaml locally").option("--auth-token <token>", "Require Authorization: Bearer <token> on HTTP requests. Falls back to $PIPEQUERY_MCP_TOKEN. Without either, the endpoint is unauthenticated.").action(mcpServeCommand);
+mcp.command("inspect").description("Print the MCP tool schemas as JSON (useful for directory submission / debugging)").option("--attach <url>", "Attach to a running `pq serve` instance at the given URL instead of loading pipequery.yaml locally").action(mcpInspectCommand);
 program.command("stop").description("Stop the running PipeQuery server (daemon or foreground)").option("-f, --force", "Force kill (SIGKILL instead of SIGTERM)").action(stopCommand);
 program.command("completion").description("Generate shell completion script").option("-s, --shell <shell>", "Shell type: bash, zsh, fish").action(completionCommand);
 if (process.argv.length <= 2) {