neural-loom 0.2.48 → 0.2.49

package/bin/cli.js

@@ -4,6 +4,82 @@
 const { spawn } = require('child_process');
 const path = require('path');
 
+if (process.argv[2] === 'mcp') {
+  const readline = require('readline');
+  const http = require('http');
+  
+  let wsRoot = process.argv[3] || process.env.ORIGINAL_CWD || process.cwd();
+  wsRoot = path.resolve(wsRoot).replace(/\\/g, '/');
+
+  console.error(`[NeuralLoom MCP Bridge] Workspace context: ${wsRoot}`);
+  console.error(`[NeuralLoom MCP Bridge] Connecting to Next.js server on http://localhost:3000...`);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+
+  rl.on('line', (line) => {
+    if (!line.trim()) return;
+    
+    let requestObj;
+    try {
+      requestObj = JSON.parse(line);
+    } catch (e) {
+      const errResponse = {
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "Parse error" }
+      };
+      process.stdout.write(JSON.stringify(errResponse) + "\n");
+      return;
+    }
+
+    const payload = JSON.stringify(requestObj);
+    const options = {
+      hostname: 'localhost',
+      port: 3000,
+      path: '/api/sql/mcp',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+        'x-workspace-root': wsRoot
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 204) {
+          return;
+        }
+        process.stdout.write(data + "\n");
+      });
+    });
+
+    req.on('error', (err) => {
+      console.error(`[NeuralLoom MCP Bridge ERROR] Failed to connect to local server: ${err.message}`);
+      const errResponse = {
+        jsonrpc: "2.0",
+        id: requestObj.id || null,
+        error: {
+          code: -32603,
+          message: "NeuralLoom backend server is offline. Please launch the dashboard first using 'npm run dev' or 'neural-loom'."
+        }
+      };
+      process.stdout.write(JSON.stringify(errResponse) + "\n");
+    });
+
+    req.write(payload);
+    req.end();
+  });
+
+  return;
+}
+
 const originalCwd = process.cwd();
 const fs = require('fs');
 const os = require('os');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neural-loom",
-  "version": "0.2.48",
+  "version": "0.2.49",
   "bin": {
     "neural-loom": "./bin/cli.js"
   },
@@ -37,4 +37,4 @@
     "eslint-config-next": "16.2.6",
     "typescript": "^5"
   }
-}
+}

package/src/app/api/sql/connections/route.ts

@@ -0,0 +1,60 @@
+import { NextResponse } from "next/server";
+import { ConnectionManager } from "@/lib/sql/ConnectionManager";
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const root = searchParams.get("root") || undefined;
+    const data = await ConnectionManager.getProfiles(root);
+    return NextResponse.json({ success: true, ...data });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message || String(error) }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { action, profile, isGlobal, root, profileId } = body;
+
+    if (action === "save") {
+      if (!profile || !profile.id || !profile.name || !profile.type) {
+        return NextResponse.json({ error: "Missing required profile parameters" }, { status: 400 });
+      }
+      await ConnectionManager.saveProfile(profile, !!isGlobal, root);
+      return NextResponse.json({ success: true, message: "Profile saved successfully" });
+    }
+
+    if (action === "delete") {
+      if (!profileId) {
+        return NextResponse.json({ error: "Missing required parameter 'profileId'" }, { status: 400 });
+      }
+      await ConnectionManager.deleteProfile(profileId, !!isGlobal, root);
+      return NextResponse.json({ success: true, message: "Profile deleted successfully" });
+    }
+
+    if (action === "set_active") {
+      await ConnectionManager.setActiveProfile(profileId || null, !!isGlobal, root);
+      return NextResponse.json({ success: true, message: "Active profile updated successfully" });
+    }
+
+    if (action === "test") {
+      if (!profile) {
+        return NextResponse.json({ error: "Missing required parameter 'profile'" }, { status: 400 });
+      }
+      const adapter = ConnectionManager.createAdapter(profile, root);
+      try {
+        await adapter.connect();
+        await adapter.listTables(); // Quick verify
+        await adapter.disconnect();
+        return NextResponse.json({ success: true, message: "Connection test successful!" });
+      } catch (err: any) {
+        return NextResponse.json({ success: false, error: err.message || String(err) });
+      }
+    }
+
+    return NextResponse.json({ error: "Invalid action" }, { status: 400 });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message || String(error) }, { status: 500 });
+  }
+}

package/src/app/api/sql/mcp/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+import { McpServer } from "@/lib/sql/McpServer";
+
+export async function POST(request: Request) {
+  try {
+    const workspaceRoot = request.headers.get("x-workspace-root") || undefined;
+    const body = await request.json();
+
+    const mcpServer = new McpServer(workspaceRoot);
+    const response = await mcpServer.handleMessage(body);
+
+    if (response === null) {
+      return new Response("", { status: 204 });
+    }
+
+    return NextResponse.json(response);
+  } catch (error: any) {
+    return NextResponse.json({
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code: -32603,
+        message: "Internal server error: " + (error.message || String(error))
+      }
+    }, { status: 500 });
+  }
+}

package/src/app/api/sql/query/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import { ConnectionManager } from "@/lib/sql/ConnectionManager";
+
+const isMutation = (sql: string): boolean => {
+  const clean = sql.trim().toLowerCase();
+  return (
+    clean.startsWith("insert") ||
+    clean.startsWith("update") ||
+    clean.startsWith("delete") ||
+    clean.startsWith("drop") ||
+    clean.startsWith("alter") ||
+    clean.startsWith("create") ||
+    clean.startsWith("truncate") ||
+    clean.startsWith("replace")
+  );
+};
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { sql, root } = body;
+
+    if (!sql || !sql.trim()) {
+      return NextResponse.json({ error: "Missing parameter 'sql'" }, { status: 400 });
+    }
+
+    const active = await ConnectionManager.getActiveAdapter(root);
+    if (!active) {
+      return NextResponse.json({ 
+        error: "No active database connection configured. Please set up and select an active profile in the database panel." 
+      }, { status: 400 });
+    }
+
+    const { adapter, profile } = active;
+
+    if (profile.readOnly && isMutation(sql)) {
+      return NextResponse.json({ 
+        error: "This connection profile is configured as Read-Only. Modifications are disabled." 
+      }, { status: 403 });
+    }
+
+    const startTime = Date.now();
+    const result = await adapter.query(sql);
+    const durationMs = Date.now() - startTime;
+
+    return NextResponse.json({
+      success: true,
+      rows: result.rows,
+      fields: result.fields,
+      affectedRows: result.affectedRows,
+      durationMs
+    });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message || String(error) }, { status: 500 });
+  }
+}

package/src/app/api/sql/schema/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from "next/server";
+import { ConnectionManager } from "@/lib/sql/ConnectionManager";
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const root = searchParams.get("root") || undefined;
+    const action = searchParams.get("action");
+
+    const active = await ConnectionManager.getActiveAdapter(root);
+    if (!active) {
+      return NextResponse.json({ 
+        error: "No active database connection configured." 
+      }, { status: 400 });
+    }
+
+    const { adapter } = active;
+
+    if (action === "list_tables") {
+      const tables = await adapter.listTables();
+      return NextResponse.json({ success: true, tables });
+    }
+
+    if (action === "describe_table") {
+      const table = searchParams.get("table");
+      if (!table) {
+        return NextResponse.json({ error: "Missing required parameter 'table'" }, { status: 400 });
+      }
+      const columns = await adapter.describeTable(table);
+      return NextResponse.json({ success: true, columns });
+    }
+
+    if (action === "summary") {
+      const summary = await adapter.getSchemaSummary();
+      return NextResponse.json({ success: true, summary });
+    }
+
+    return NextResponse.json({ error: "Invalid action. Must be 'list_tables', 'describe_table', or 'summary'" }, { status: 400 });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message || String(error) }, { status: 500 });
+  }
+}