bridge-workspace 0.1.0

package/src/gateway.js

@@ -0,0 +1,428 @@
+const http = require('node:http');
+const path = require('node:path');
+const readline = require('node:readline/promises');
+const express = require('express');
+const WebSocket = require('ws');
+
+const { loadBridgeConfig, parseIncludeInput, parsePort } = require('./config');
+const { startMcpServer } = require('./mcp-server');
+
+const DEFAULT_GATEWAY_PORT = 9999;
+
+function withProtocol(address, protocol) {
+  if (/^https?:\/\//.test(address) || /^wss?:\/\//.test(address)) {
+    const url = new URL(address);
+    url.protocol = protocol === 'ws' ? (url.protocol === 'https:' ? 'wss:' : 'ws:') : (url.protocol === 'wss:' ? 'https:' : 'http:');
+    return url.toString().replace(/\/$/, '');
+  }
+  return `${protocol === 'ws' ? 'ws' : 'http'}://${address}`;
+}
+
+function createPromptSession(options = {}) {
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  return readline.createInterface({ input, output });
+}
+
+function getBackendNames(config) {
+  return Object.keys(config.all_backends || {});
+}
+
+function parseBackendSelection(input, config) {
+  const backendNames = getBackendNames(config);
+  const trimmed = String(input || '').trim();
+  if (!trimmed) {
+    return [];
+  }
+
+  const selected = [];
+  for (const token of trimmed.split(',').map((item) => item.trim()).filter(Boolean)) {
+    const numericIndex = Number(token);
+    const name = Number.isInteger(numericIndex) && numericIndex >= 1
+      ? backendNames[numericIndex - 1]
+      : token;
+    if (!name || !config.all_backends[name]) {
+      throw new Error(`Unknown backend selection: ${token}`);
+    }
+    if (!selected.includes(name)) {
+      selected.push(name);
+    }
+  }
+
+  return selected;
+}
+
+async function promptBackendSelection(config, options = {}) {
+  const output = options.output || process.stdout;
+  const rl = options.rl || createPromptSession(options);
+  const backendNames = getBackendNames(config);
+
+  output.write('请选择要连接的后端服务（可多选，逗号分隔；直接回车则不启动）：\n\n');
+  backendNames.forEach((name, index) => {
+    output.write(`[${index + 1}] ${name}    ${config.all_backends[name]}\n`);
+  });
+  output.write('\n输入编号或名称，例如：1,2 或 li-si-order,wang-wu-pay > ');
+
+  try {
+    const answer = await rl.question('');
+    return parseBackendSelection(answer, config);
+  } finally {
+    if (!options.rl && options.close !== false) {
+      rl.close();
+    }
+  }
+}
+
+async function promptBackendInclude(backendName, options = {}) {
+  const output = options.output || process.stdout;
+  const rl = options.rl || createPromptSession(options);
+  try {
+    output.write(`${backendName} 本次会话 include（可为空，表示使用后端开放范围；逗号分隔）\n`);
+    output.write('示例：src/main/java/**/dto/**,src/main/java/**/controller/**,README.md\n');
+    return rl.question('include > ');
+  } finally {
+    if (!options.rl && options.close !== false) {
+      rl.close();
+    }
+  }
+}
+
+function selectBackendTargets(config, selectedNames, includeByBackend = {}) {
+  const names = Array.isArray(selectedNames) ? selectedNames : getBackendNames(config);
+
+  return names.map((name) => {
+    const address = config.all_backends && config.all_backends[name];
+    if (!address) {
+      throw new Error(`Backend "${name}" is missing from all_backends`);
+    }
+    const target = { name, httpUrl: withProtocol(address, 'http'), wsUrl: withProtocol(address, 'ws') };
+    if (includeByBackend[name] && includeByBackend[name].length) {
+      target.include = includeByBackend[name];
+    }
+    return target;
+  });
+}
+
+function createBackendStore() {
+  const filesByBackend = new Map();
+
+  function ensureBackend(name) {
+    if (!filesByBackend.has(name)) {
+      filesByBackend.set(name, new Map());
+    }
+    return filesByBackend.get(name);
+  }
+
+  return {
+    replaceSnapshot(name, files) {
+      const backendFiles = new Map();
+      for (const file of files || []) {
+        backendFiles.set(file.path, {
+          path: file.path,
+          size: file.size,
+          mtimeMs: file.mtimeMs,
+          content: file.content,
+        });
+      }
+      filesByBackend.set(name, backendFiles);
+    },
+    applyFileUpdate(name, filePath, content) {
+      const backendFiles = ensureBackend(name);
+      const existing = backendFiles.get(filePath) || { path: filePath };
+      backendFiles.set(filePath, { ...existing, path: filePath, content });
+    },
+    listBackends() {
+      return Array.from(filesByBackend.keys()).sort();
+    },
+    listFiles(name) {
+      return Array.from(ensureBackend(name).values())
+        .map((file) => ({
+          backend: name,
+          path: file.path,
+          size: file.size,
+          mtimeMs: file.mtimeMs,
+          hasContent: typeof file.content === 'string',
+        }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    },
+    getFile(name, filePath) {
+      const file = ensureBackend(name).get(filePath);
+      return file === undefined ? null : {
+        backend: name,
+        path: filePath,
+        size: file.size,
+        mtimeMs: file.mtimeMs,
+        content: file.content,
+      };
+    },
+    toJSON() {
+      return this.listBackends().map((name) => ({ backend: name, files: this.listFiles(name) }));
+    },
+    toMcpText() {
+      return this.listBackends()
+        .flatMap((name) => this.listFiles(name).map((file) => `[${name}] ${file.path} (${file.size || 0} bytes)`))
+        .join('\n\n---\n\n');
+    },
+  };
+}
+
+function findBackendTarget(targets, backendName) {
+  const target = targets.find((item) => item.name === backendName);
+  if (!target) {
+    throw new Error(`Backend "${backendName}" is not connected`);
+  }
+  return target;
+}
+
+async function proposeBackendChange(target, filePath, newContent, fetchImpl = fetch) {
+  const body = { filePath, newContent };
+  if (target.include && target.include.length) {
+    body.include = target.include;
+  }
+  const response = await fetchImpl(`${target.httpUrl}/api/propose-change`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(payload.error || `Change proposal failed with status ${response.status}`);
+  }
+  return payload;
+}
+
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Request failed ${response.status}: ${url}`);
+  }
+  return response.json();
+}
+
+async function fetchBackendFileContent(target, filePath, fetchImpl = fetch) {
+  const url = new URL(`${target.httpUrl}/file-content`);
+  url.searchParams.set('path', filePath);
+  for (const includeRule of target.include || []) {
+    url.searchParams.append('include', includeRule);
+  }
+  const response = await fetchImpl(url.toString());
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(payload.error || `File content request failed with status ${response.status}`);
+  }
+  return payload.content;
+}
+
+function searchBackendStore(store, query, options = {}) {
+  const normalizedQuery = String(query || '').toLowerCase();
+  if (!normalizedQuery) {
+    return [];
+  }
+  const limit = Number(options.limit || 20);
+  const backendFilter = options.backendName;
+  const results = [];
+
+  for (const backend of store.listBackends()) {
+    if (backendFilter && backend !== backendFilter) {
+      continue;
+    }
+    for (const file of store.listFiles(backend)) {
+      const cached = store.getFile(backend, file.path);
+      if (!cached || typeof cached.content !== 'string') {
+        continue;
+      }
+      const lines = cached.content.split(/\r?\n/);
+      for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index].toLowerCase().includes(normalizedQuery)) {
+          results.push({ backend, path: file.path, line: index + 1, snippet: lines[index].trim() });
+          if (results.length >= limit) {
+            return results;
+          }
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+async function syncBackendSnapshot(target, store) {
+  const url = new URL(`${target.httpUrl}/file-tree`);
+  for (const includeRule of target.include || []) {
+    url.searchParams.append('include', includeRule);
+  }
+  const snapshot = await fetchJson(url.toString());
+  store.replaceSnapshot(target.name, snapshot.files || []);
+}
+
+function connectBackendSocket(target, store) {
+  const ws = new WebSocket(target.wsUrl);
+  ws.on('message', (raw) => {
+    try {
+      const event = JSON.parse(raw.toString());
+      if (event.type === 'file:update') {
+        store.applyFileUpdate(target.name, event.path, event.content);
+      }
+    } catch (error) {
+      console.error(`Bridge gateway ignored invalid update from ${target.name}: ${error.message}`);
+    }
+  });
+  ws.on('error', (error) => {
+    console.error(`Bridge gateway socket error for ${target.name}: ${error.message}`);
+  });
+  return ws;
+}
+
+function canListen(port, host = '127.0.0.1') {
+  return new Promise((resolve, reject) => {
+    const probe = http.createServer();
+    probe.once('error', (error) => {
+      if (error.code === 'EADDRINUSE') {
+        resolve(false);
+        return;
+      }
+      reject(error);
+    });
+    probe.once('listening', () => {
+      probe.close(() => resolve(true));
+    });
+    probe.listen(port, host);
+  });
+}
+
+async function findAvailablePort(startPort, host = '127.0.0.1') {
+  let port = Number(startPort);
+  while (!(await canListen(port, host))) {
+    port += 1;
+  }
+  return port;
+}
+
+async function createGateway(options = {}) {
+  const rootDir = path.resolve(options.rootDir || process.cwd());
+  const requestedPort = Number(options.port || DEFAULT_GATEWAY_PORT);
+  const port = options.autoPort === false ? requestedPort : await findAvailablePort(requestedPort);
+  const config = options.config || await loadBridgeConfig(rootDir);
+  const targets = selectBackendTargets(config, options.selectedBackends, options.includeByBackend || {});
+  const store = createBackendStore();
+  const app = express();
+  const server = http.createServer(app);
+  const sockets = [];
+
+  app.get('/health', (req, res) => {
+    res.json({ ok: true, service: 'bridge-gateway', project: config.project });
+  });
+
+  app.get('/backends', (req, res) => {
+    res.json(store.toJSON());
+  });
+
+  app.get('/backends/:backend/files/*', (req, res) => {
+    const file = store.getFile(req.params.backend, req.params[0]);
+    if (!file) {
+      res.status(404).json({ error: 'File not found' });
+      return;
+    }
+    res.type('text/plain').send(file.content);
+  });
+
+  const mcp = startMcpServer({
+    app,
+    store,
+    project: config.project,
+    modifyBackendFile: (backendName, filePath, newContent) => proposeBackendChange(
+      findBackendTarget(targets, backendName),
+      filePath,
+      newContent,
+    ),
+    searchBackendCode: (query, options) => searchBackendStore(store, query, options),
+    readBackendFile: async (backendName, filePath) => {
+      const cached = store.getFile(backendName, filePath);
+      if (cached && typeof cached.content === 'string') {
+        return cached.content;
+      }
+      const target = findBackendTarget(targets, backendName);
+      const content = await fetchBackendFileContent(target, filePath);
+      store.applyFileUpdate(backendName, filePath, content);
+      return content;
+    },
+  });
+
+  return {
+    app,
+    server,
+    store,
+    targets,
+    port,
+    mcp,
+    async start() {
+      await Promise.all(targets.map((target) => syncBackendSnapshot(target, store).catch((error) => {
+        console.error(`Bridge gateway snapshot failed for ${target.name}: ${error.message}`);
+      })));
+      for (const target of targets) {
+        sockets.push(connectBackendSocket(target, store));
+      }
+      await new Promise((resolve) => server.listen(port, resolve));
+      return this;
+    },
+    async close() {
+      for (const socket of sockets) {
+        socket.close();
+      }
+      await mcp.close();
+      await new Promise((resolve) => server.close(resolve));
+    },
+  };
+}
+
+async function runGateway(argv = process.argv.slice(2)) {
+  const port = parsePort(argv, 'BRIDGE_GATEWAY_PORT', DEFAULT_GATEWAY_PORT);
+  const rootDir = process.cwd();
+  const config = await loadBridgeConfig(rootDir);
+  const rl = createPromptSession();
+  try {
+    const selectedBackends = await promptBackendSelection(config, { rl });
+    if (!selectedBackends.length) {
+      console.log('[Bridge] 未选择任何后端服务，gateway 未启动。');
+      return null;
+    }
+    const includeByBackend = {};
+    for (const backendName of selectedBackends) {
+      const answer = await promptBackendInclude(backendName, { rl });
+      const include = parseIncludeInput(answer);
+      if (include.length) {
+        includeByBackend[backendName] = include;
+      }
+    }
+    const gateway = await createGateway({ port, rootDir, config, selectedBackends, includeByBackend });
+    await gateway.start();
+    if (gateway.port !== port) {
+      console.log(`[Bridge] 端口 ${port} 已被占用，自动切换到 ${gateway.port}。`);
+    }
+    console.log(`Bridge frontend gateway listening on http://127.0.0.1:${gateway.port}`);
+    console.log(`MCP SSE endpoint: http://127.0.0.1:${gateway.port}/mcp/sse`);
+    return gateway;
+  } finally {
+    rl.close();
+  }
+}
+
+module.exports = {
+  DEFAULT_GATEWAY_PORT,
+  createBackendStore,
+  createGateway,
+  createPromptSession,
+  findBackendTarget,
+  findAvailablePort,
+  fetchBackendFileContent,
+  getBackendNames,
+  loadBridgeConfig,
+  parseBackendSelection,
+  parseIncludeInput,
+  promptBackendInclude,
+  promptBackendSelection,
+  proposeBackendChange,
+  runGateway,
+  searchBackendStore,
+  selectBackendTargets,
+};

package/src/mcp-server.js

@@ -0,0 +1,108 @@
+async function loadMcpSdk() {
+  const [{ McpServer }, { SSEServerTransport }, z] = await Promise.all([
+    import('@modelcontextprotocol/sdk/server/mcp.js'),
+    import('@modelcontextprotocol/sdk/server/sse.js'),
+    import('zod'),
+  ]);
+  return { McpServer, SSEServerTransport, z };
+}
+
+function startMcpServer({ app, store, project, modifyBackendFile, readBackendFile, searchBackendCode }) {
+  const transports = new Map();
+  let serverPromise;
+
+  async function getServer() {
+    if (!serverPromise) {
+      serverPromise = loadMcpSdk().then(({ McpServer, z }) => {
+        const server = new McpServer({ name: `bridge-workspace-${project || 'gateway'}`, version: '0.1.0' });
+
+        server.tool('list_backend_files', 'List synchronized backend files grouped by backend.', async () => ({
+          content: [{ type: 'text', text: JSON.stringify(store.toJSON(), null, 2) }],
+        }));
+
+        server.tool('read_backend_file', 'Read a synchronized backend file by backendName and filePath.', {
+          backendName: z.string(),
+          filePath: z.string(),
+        }, async ({ backendName, filePath }) => {
+          const file = store.getFile(backendName, filePath);
+          if (!file) {
+            return { content: [{ type: 'text', text: `File not found: ${backendName}/${filePath}` }], isError: true };
+          }
+          const text = typeof file.content === 'string'
+            ? file.content
+            : await readBackendFile(backendName, filePath);
+          return { content: [{ type: 'text', text }] };
+        });
+
+        server.tool('modify_backend_file', 'Propose a backend file change for human approval on the backend host.', {
+          backendName: z.string(),
+          filePath: z.string(),
+          newContent: z.string(),
+        }, async ({ backendName, filePath, newContent }) => {
+          if (!modifyBackendFile) {
+            return { content: [{ type: 'text', text: 'modify_backend_file is not configured.' }], isError: true };
+          }
+          const result = await modifyBackendFile(backendName, filePath, newContent);
+          return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        });
+
+        server.tool('search_backend_code', 'Search synchronized backend files by keyword and return lightweight snippets.', {
+          query: z.string(),
+          backendName: z.string().optional(),
+          limit: z.number().optional(),
+        }, async ({ query, backendName, limit }) => {
+          if (!searchBackendCode) {
+            return { content: [{ type: 'text', text: 'search_backend_code is not configured.' }], isError: true };
+          }
+          const results = await searchBackendCode(query, { backendName, limit });
+          return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+        });
+
+        server.resource('bridge_backend_context', 'bridge://backend-context', async (uri) => ({
+          contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(store.toJSON(), null, 2) }],
+        }));
+
+        return server;
+      });
+    }
+    return serverPromise;
+  }
+
+  app.get('/mcp/sse', async (req, res, next) => {
+    try {
+      const { SSEServerTransport } = await loadMcpSdk();
+      const transport = new SSEServerTransport('/mcp/messages', res);
+      transports.set(transport.sessionId, transport);
+      res.on('close', () => transports.delete(transport.sessionId));
+      const server = await getServer();
+      await server.connect(transport);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.post('/mcp/messages', async (req, res, next) => {
+    try {
+      const sessionId = req.query.sessionId;
+      const transport = transports.get(sessionId);
+      if (!transport) {
+        res.status(404).send('Unknown MCP session');
+        return;
+      }
+      await transport.handlePostMessage(req, res);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  return {
+    async close() {
+      for (const transport of transports.values()) {
+        await transport.close();
+      }
+      transports.clear();
+    },
+  };
+}
+
+module.exports = { startMcpServer };

package/src/stop.js

@@ -0,0 +1,77 @@
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const { parsePort } = require('./config');
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_STOP_PORT = 3001;
+
+function uniqueNumbers(values) {
+  return Array.from(new Set(values.map(Number).filter((value) => Number.isInteger(value) && value > 0)));
+}
+
+function parseNetstatPids(output, port) {
+  const target = `:${port}`;
+  return uniqueNumbers(output
+    .split(/\r?\n/)
+    .filter((line) => line.includes(target) && /LISTENING/i.test(line))
+    .map((line) => line.trim().split(/\s+/).pop()));
+}
+
+function parseLsofPids(output) {
+  return uniqueNumbers(output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+}
+
+async function findPidsByPort(port, platform = process.platform) {
+  if (platform === 'win32') {
+    const { stdout } = await execFileAsync('netstat', ['-ano', '-p', 'tcp']);
+    return parseNetstatPids(stdout, port);
+  }
+
+  try {
+    const { stdout } = await execFileAsync('lsof', ['-ti', `:${port}`]);
+    return parseLsofPids(stdout);
+  } catch (error) {
+    if (error.code === 1) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+async function killPid(pid, platform = process.platform) {
+  if (platform === 'win32') {
+    await execFileAsync('taskkill', ['/PID', String(pid), '/F']);
+    return;
+  }
+  process.kill(pid, 'SIGTERM');
+}
+
+async function stopPort(port, options = {}) {
+  const platform = options.platform || process.platform;
+  const pids = await findPidsByPort(port, platform);
+  for (const pid of pids) {
+    await killPid(pid, platform);
+  }
+  return pids;
+}
+
+async function runStop(argv = process.argv.slice(2), output = process.stdout) {
+  const port = parsePort(argv, 'BRIDGE_PORT', DEFAULT_STOP_PORT);
+  const pids = await stopPort(port);
+  if (!pids.length) {
+    output.write(`[Bridge] 端口 ${port} 未发现占用进程。\n`);
+    return [];
+  }
+  output.write(`[Bridge] 已清理端口 ${port}：${pids.join(', ')}\n`);
+  return pids;
+}
+
+module.exports = {
+  DEFAULT_STOP_PORT,
+  findPidsByPort,
+  parseLsofPids,
+  parseNetstatPids,
+  runStop,
+  stopPort,
+};