2ndbrain 2026.1.30 → 2026.1.31

package/src/mcp/config.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Generate the MCP configuration JSON for claude-cli and the runtime
+ * .claude/settings.json with subprocess hooks (spec sections 7 and 13.2).
+ *
+ * Writes:
+ *   $DATA_DIR/claude-runtime/mcp-config.json   -- MCP server definitions
+ *   $DATA_DIR/claude-runtime/.claude/settings.json -- subprocess hooks
+ *
+ * @param {object} config - Application configuration object.
+ *   Required: DATA_DIR, DATABASE_URL.
+ *   Optional: EMBEDDING_PROVIDER (enables embed server entry),
+ *             _embedServerUrl (runtime URL set by createEmbedTool).
+ * @returns {string} Absolute path to the written MCP config file.
+ */
+function generateMcpConfig(config) {
+  const runtimeDir = path.join(config.DATA_DIR, 'claude-runtime');
+  const claudeDir = path.join(runtimeDir, '.claude');
+  const hooksDir = path.join(runtimeDir, 'hooks');
+  const mcpConfigPath = path.join(runtimeDir, 'mcp-config.json');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  // Ensure the full directory tree exists
+  fs.mkdirSync(claudeDir, { recursive: true });
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  // ---- MCP server configuration ----
+
+  const mcpConfig = {
+    mcpServers: {
+      pg: {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-postgres', config.DATABASE_URL],
+      },
+    },
+  };
+
+  // Include the embed_query MCP server when embedding is enabled and the
+  // runtime HTTP server URL is available (set by createEmbedTool at startup).
+  if (config.EMBEDDING_PROVIDER && config._embedServerUrl) {
+    mcpConfig.mcpServers.embed = {
+      type: 'url',
+      url: config._embedServerUrl,
+    };
+  }
+
+  fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+
+  // ---- Runtime .claude/settings.json with subprocess hooks (section 13.2) ----
+
+  const settings = {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Bash',
+          hooks: [
+            {
+              type: 'command',
+              command: path.join(hooksDir, 'validate-command.sh'),
+            },
+          ],
+        },
+      ],
+    },
+  };
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+
+  return mcpConfigPath;
+}
+
+export { generateMcpConfig };
+export default generateMcpConfig;

package/src/mcp/embed-server.js

@@ -0,0 +1,242 @@
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+
+const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+
+/**
+ * Generate a vector embedding for the given text by calling the configured
+ * OpenAI-compatible embedding provider API.
+ *
+ * Uses the node:https built-in module for the outbound API call.
+ *
+ * @param {string} text - The text to embed.
+ * @param {object} config - Embedding configuration.
+ * @param {string} config.EMBEDDING_API_KEY - API key for the provider.
+ * @param {string} [config.EMBEDDING_MODEL] - Model name (default: text-embedding-3-small).
+ * @param {string} [config.EMBEDDING_BASE_URL] - Base URL (default: https://api.openai.com/v1).
+ * @param {string|number} [config.EMBEDDING_DIMENSIONS] - Override output dimensions.
+ * @returns {Promise<{ vector: number[], dimensions: number }>}
+ */
+function generateEmbedding(text, config) {
+  return new Promise((resolve, reject) => {
+    const baseUrl = config.EMBEDDING_BASE_URL || DEFAULT_BASE_URL;
+    const url = new URL(`${baseUrl}/embeddings`);
+    const model = config.EMBEDDING_MODEL || 'text-embedding-3-small';
+
+    const payload = { input: text, model };
+    if (config.EMBEDDING_DIMENSIONS) {
+      payload.dimensions = parseInt(config.EMBEDDING_DIMENSIONS, 10);
+    }
+
+    const body = JSON.stringify(payload);
+    const transport = url.protocol === 'https:' ? https : http;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.EMBEDDING_API_KEY}`,
+        'Content-Length': Buffer.byteLength(body),
+      },
+    };
+
+    const req = transport.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          if (res.statusCode !== 200) {
+            reject(new Error(`Embedding API error (HTTP ${res.statusCode}): ${data}`));
+            return;
+          }
+          const parsed = JSON.parse(data);
+          const embedding = parsed.data[0].embedding;
+          resolve({ vector: embedding, dimensions: embedding.length });
+        } catch (err) {
+          reject(new Error(`Failed to parse embedding response: ${err.message}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`Embedding API request failed: ${err.message}`));
+    });
+
+    req.write(body);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// MCP JSON-RPC handler
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle an incoming MCP JSON-RPC 2.0 request.
+ *
+ * Supported methods:
+ *   - initialize       -- handshake, returns server capabilities
+ *   - notifications/*  -- acknowledged silently (no response)
+ *   - tools/list       -- returns the embed_query tool definition
+ *   - tools/call       -- executes embed_query
+ *
+ * @param {object} request - JSON-RPC 2.0 request object.
+ * @param {object} config - Application configuration.
+ * @returns {Promise<object|null>} JSON-RPC response, or null for notifications.
+ */
+async function handleMcpRequest(request, config) {
+  const { method, id, params } = request;
+
+  // Notifications have no id and require no response
+  if (id === undefined || id === null) {
+    return null;
+  }
+
+  switch (method) {
+    case 'initialize':
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: '2ndbrain-embed', version: '0.5.0' },
+        },
+      };
+
+    case 'tools/list':
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          tools: [
+            {
+              name: 'embed_query',
+              description:
+                'Generate a vector embedding for a search query. ' +
+                'Returns { vector: [...], dimensions: N }.',
+              inputSchema: {
+                type: 'object',
+                properties: {
+                  text: {
+                    type: 'string',
+                    description: 'The search query text to embed',
+                  },
+                },
+                required: ['text'],
+              },
+            },
+          ],
+        },
+      };
+
+    case 'tools/call': {
+      if (params?.name !== 'embed_query') {
+        return {
+          jsonrpc: '2.0',
+          id,
+          error: { code: -32601, message: `Unknown tool: ${params?.name}` },
+        };
+      }
+
+      try {
+        const result = await generateEmbedding(params.arguments.text, config);
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+          },
+        };
+      } catch (err) {
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }],
+            isError: true,
+          },
+        };
+      }
+    }
+
+    default:
+      return {
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32601, message: `Method not found: ${method}` },
+      };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// HTTP-based MCP server
+// ---------------------------------------------------------------------------
+
+/**
+ * Create and start a lightweight HTTP-based MCP server that exposes the
+ * embed_query tool.  The server listens on 127.0.0.1 with an
+ * OS-assigned port so there is no conflict risk.
+ *
+ * @param {object} config - Application configuration.
+ * @returns {Promise<{ server: http.Server, port: number, url: string }|null>}
+ *   Resolves with server details, or null when EMBEDDING_PROVIDER is not set.
+ */
+function createEmbedTool(config) {
+  if (!config.EMBEDDING_PROVIDER) {
+    return Promise.resolve(null);
+  }
+
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      // Only POST is meaningful for MCP JSON-RPC
+      if (req.method !== 'POST') {
+        res.writeHead(405, { Allow: 'POST' });
+        res.end();
+        return;
+      }
+
+      let body = '';
+      req.on('data', (chunk) => { body += chunk; });
+      req.on('end', async () => {
+        try {
+          const request = JSON.parse(body);
+          const response = await handleMcpRequest(request, config);
+
+          if (response === null) {
+            // Notification -- acknowledge with 202 No Content
+            res.writeHead(202);
+            res.end();
+            return;
+          }
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(response));
+        } catch (err) {
+          const errorResponse = {
+            jsonrpc: '2.0',
+            id: null,
+            error: { code: -32700, message: `Parse error: ${err.message}` },
+          };
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(errorResponse));
+        }
+      });
+    });
+
+    server.on('error', reject);
+
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const url = `http://127.0.0.1:${port}`;
+      resolve({ server, port, url });
+    });
+  });
+}
+
+export { createEmbedTool, generateEmbedding };
+export default createEmbedTool;

package/src/rate-limiter.js

@@ -0,0 +1,114 @@
+import config from './config.js';
+
+const WINDOW_MS = 60_000; // 1-minute sliding window
+
+/**
+ * Sliding-window rate limiter. Tracks call timestamps and queues
+ * requests that exceed the per-minute limit until a slot opens.
+ */
+class RateLimiter {
+  /**
+   * @param {string} name - Identifier for this limiter (e.g. 'claude', 'telegram')
+   * @param {number} maxPerMinute - Maximum calls allowed per minute
+   */
+  constructor(name, maxPerMinute) {
+    this.name = name;
+    this.maxPerMinute = maxPerMinute;
+    /** @type {number[]} Timestamps (ms) of recent calls */
+    this._timestamps = [];
+    /** @type {Array<{ resolve: () => void }>} Queued waiters */
+    this._queue = [];
+    /** @type {ReturnType<typeof setTimeout> | null} */
+    this._drainTimer = null;
+  }
+
+  /**
+   * Prune timestamps older than the sliding window.
+   */
+  _prune() {
+    const cutoff = Date.now() - WINDOW_MS;
+    while (this._timestamps.length > 0 && this._timestamps[0] <= cutoff) {
+      this._timestamps.shift();
+    }
+  }
+
+  /**
+   * Attempt to drain queued waiters whenever a slot becomes available.
+   */
+  _scheduleDrain() {
+    if (this._drainTimer !== null || this._queue.length === 0) {
+      return;
+    }
+
+    // Determine when the oldest timestamp expires to free a slot
+    this._prune();
+    if (this._timestamps.length < this.maxPerMinute) {
+      // Slot available right now
+      this._drain();
+      return;
+    }
+
+    const waitMs = this._timestamps[0] + WINDOW_MS - Date.now() + 1;
+    this._drainTimer = setTimeout(() => {
+      this._drainTimer = null;
+      this._drain();
+    }, Math.max(waitMs, 0));
+  }
+
+  /**
+   * Release as many queued waiters as there are available slots.
+   */
+  _drain() {
+    this._prune();
+    while (this._queue.length > 0 && this._timestamps.length < this.maxPerMinute) {
+      this._timestamps.push(Date.now());
+      const waiter = this._queue.shift();
+      waiter.resolve();
+    }
+    // If there are still queued items, schedule the next drain
+    if (this._queue.length > 0) {
+      this._scheduleDrain();
+    }
+  }
+
+  /**
+   * Acquire a rate-limit slot. Resolves immediately if under the limit;
+   * otherwise queues and resolves when a slot opens.
+   * @returns {Promise<void>}
+   */
+  acquire() {
+    this._prune();
+
+    if (this._timestamps.length < this.maxPerMinute) {
+      this._timestamps.push(Date.now());
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve) => {
+      this._queue.push({ resolve });
+      this._scheduleDrain();
+    });
+  }
+
+  /**
+   * Returns the number of requests currently waiting in the queue.
+   * @returns {number}
+   */
+  queueDepth() {
+    return this._queue.length;
+  }
+}
+
+/**
+ * Factory that creates the standard rate limiters from config values.
+ * @returns {{ claude: RateLimiter, telegram: RateLimiter }}
+ */
+function createRateLimiters() {
+  return {
+    claude: new RateLimiter('claude', config.RATE_LIMIT_CLAUDE),
+    telegram: new RateLimiter('telegram', config.RATE_LIMIT_TELEGRAM),
+  };
+}
+
+export { RateLimiter, createRateLimiters };
+export default createRateLimiters;