@ng-annotate/mcp-server 0.4.0 → 0.4.1

package/dist/index.js

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { registerTools } from './tools.js';
+import { startWsServer } from './ws-server.js';
 function log(msg) {
     process.stderr.write(`[ng-annotate-mcp] ${msg}\n`);
 }
@@ -13,6 +14,7 @@ async function main() {
     });
     log('registering tools...');
     registerTools(server);
+    startWsServer();
     log('connecting stdio transport...');
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/store.js

@@ -11,7 +11,7 @@ const PROJECT_ROOT = process.env.NG_ANNOTATE_PROJECT_ROOT ?? process.cwd();
 export const STORE_PATH = path.join(PROJECT_ROOT, STORE_DIR, 'store.json');
 // ─── Store init ───────────────────────────────────────────────────────────────
 export function ensureStore() {
-    const dir = path.join(process.cwd(), STORE_DIR);
+    const dir = path.dirname(STORE_PATH);
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
     if (!fs.existsSync(STORE_PATH)) {

package/dist/ws-server.d.ts

@@ -0,0 +1 @@
+export declare function startWsServer(): void;

package/dist/ws-server.js

@@ -0,0 +1,132 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { WebSocketServer, WebSocket } from 'ws';
+import { store } from './store.js';
+const PORT = 4201;
+const SYNC_INTERVAL_MS = 2000;
+function buildManifest(projectRoot) {
+    const manifest = {};
+    const srcDir = path.join(projectRoot, 'src');
+    if (!fs.existsSync(srcDir))
+        return manifest;
+    function scan(dir) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                scan(fullPath);
+                continue;
+            }
+            if (!entry.name.endsWith('.ts') || entry.name.endsWith('.spec.ts'))
+                continue;
+            const code = fs.readFileSync(fullPath, 'utf8');
+            if (!code.includes('@Component'))
+                continue;
+            const classMatch = /export\s+class\s+(\w+)/.exec(code);
+            if (!classMatch)
+                continue;
+            const className = classMatch[1];
+            const relPath = path.relative(projectRoot, fullPath).replace(/\\/g, '/');
+            const item = { component: relPath };
+            const templateMatch = /templateUrl\s*:\s*['"`]([^'"`]+)['"`]/.exec(code);
+            if (templateMatch) {
+                const templateAbs = path.resolve(path.dirname(fullPath), templateMatch[1]);
+                item.template = path.relative(projectRoot, templateAbs).replace(/\\/g, '/');
+            }
+            manifest[className] = item;
+        }
+    }
+    scan(srcDir);
+    return manifest;
+}
+function safeSend(ws, data) {
+    if (ws.readyState !== WebSocket.OPEN)
+        return;
+    ws.send(JSON.stringify(data), (err) => {
+        if (err) { /* connection closed mid-send */ }
+    });
+}
+export function startWsServer() {
+    const projectRoot = process.env.NG_ANNOTATE_PROJECT_ROOT ?? process.cwd();
+    const sessionSockets = new Map();
+    const wss = new WebSocketServer({ noServer: true });
+    wss.on('connection', (ws, req) => {
+        void (async () => {
+            const referer = req.headers.referer ?? req.headers.origin ?? '';
+            let sessionId;
+            try {
+                const session = await store.createSession({ active: true, url: referer });
+                sessionId = session.id;
+                safeSend(ws, { type: 'session:created', session });
+                const manifest = buildManifest(projectRoot);
+                safeSend(ws, { type: 'manifest:update', manifest });
+                sessionSockets.set(sessionId, ws);
+            }
+            catch (err) {
+                process.stderr.write(`[ng-annotate] Failed to create session: ${String(err)}\n`);
+                return;
+            }
+            ws.on('message', (raw) => {
+                void (async () => {
+                    let msg;
+                    try {
+                        msg = JSON.parse(raw.toString());
+                    }
+                    catch {
+                        return;
+                    }
+                    try {
+                        if (msg.type === 'annotation:create' && msg.payload) {
+                            const annotation = await store.createAnnotation({
+                                ...msg.payload,
+                                sessionId,
+                            });
+                            safeSend(ws, { type: 'annotation:created', annotation });
+                        }
+                        else if (msg.type === 'annotation:reply' && msg.id && msg.message) {
+                            const annotation = await store.addReply(msg.id, { author: 'user', message: msg.message });
+                            if (annotation)
+                                safeSend(ws, { type: 'annotation:updated', annotation });
+                        }
+                        else if (msg.id) {
+                            const annotation = await store.updateAnnotation(msg.id, { status: 'dismissed' });
+                            if (annotation)
+                                safeSend(ws, { type: 'annotation:updated', annotation });
+                        }
+                    }
+                    catch (err) {
+                        process.stderr.write(`[ng-annotate] Failed to process message: ${String(err)}\n`);
+                    }
+                })();
+            });
+            ws.on('close', () => {
+                void store.updateSession(sessionId, { active: false });
+                sessionSockets.delete(sessionId);
+            });
+        })();
+    });
+    setInterval(() => {
+        void (async () => {
+            for (const [sessionId, ws] of sessionSockets) {
+                if (ws.readyState !== WebSocket.OPEN)
+                    continue;
+                const annotations = await store.listAnnotations(sessionId);
+                safeSend(ws, { type: 'annotations:sync', annotations });
+            }
+        })();
+    }, SYNC_INTERVAL_MS);
+    const server = http.createServer((_req, res) => {
+        res.writeHead(404);
+        res.end();
+    });
+    server.on('upgrade', (req, socket, head) => {
+        if (req.url !== '/__annotate')
+            return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+    });
+    server.listen(PORT, () => {
+        process.stderr.write(`[ng-annotate] WebSocket server listening on port ${String(PORT)}\n`);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-annotate/mcp-server",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "type": "module",
   "bin": {
     "ng-annotate-mcp": "bin/ng-annotate-mcp.js"