@geminilight/mindos 0.6.5 → 0.6.7

package/app/app/api/mcp/restart/route.ts

@@ -42,26 +42,40 @@ function killByPort(port: number) {
  *
  * Unlike /api/restart which restarts the entire MindOS (Web + MCP),
  * this endpoint only restarts the MCP server. The Web UI stays up.
+ *
+ * When running under Desktop's ProcessManager, the crash handler
+ * auto-respawns MCP when it exits. We wait for the port to free,
+ * then spawn only if nothing re-bound (i.e. CLI mode with no crash
+ * handler). This avoids spawning a duplicate that races for the port.
  */
 export async function POST() {
   try {
     const cfg = readConfig();
-    const mcpPort = (cfg.mcpPort as number) ?? 8781;
+    const mcpPort = Number(process.env.MINDOS_MCP_PORT) || Number(cfg.mcpPort) || 8781;
     const webPort = process.env.MINDOS_WEB_PORT || '3456';
-    const authToken = cfg.authToken as string | undefined;
+    const authToken = process.env.AUTH_TOKEN || (cfg.authToken as string | undefined);
+    const managed = process.env.MINDOS_MANAGED === '1';
 
     // Step 1: Kill process on MCP port
     killByPort(mcpPort);
 
-    // Step 2: Wait briefly for port to free
-    await new Promise(r => setTimeout(r, 1000));
+    if (managed) {
+      // Desktop ProcessManager will auto-respawn MCP via its crash handler.
+      return NextResponse.json({ ok: true, port: mcpPort, note: 'ProcessManager will respawn' });
+    }
+
+    // Step 2 (CLI mode only): Wait for port to free, then spawn a new MCP
+    const portFree = await waitForPortFree(mcpPort, 5000);
+    if (!portFree) {
+      return NextResponse.json({ error: `MCP port ${mcpPort} still in use after kill` }, { status: 500 });
+    }
 
-    // Step 3: Spawn new MCP server
     const root = process.env.MINDOS_PROJECT_ROOT || resolve(process.cwd(), '..');
     const mcpDir = resolve(root, 'mcp');
 
-    if (!existsSync(resolve(mcpDir, 'node_modules'))) {
-      return NextResponse.json({ error: 'MCP dependencies not installed' }, { status: 500 });
+    const mcpBundle = resolve(mcpDir, 'dist', 'index.cjs');
+    if (!existsSync(mcpBundle)) {
+      return NextResponse.json({ error: 'MCP bundle not found — reinstall @geminilight/mindos' }, { status: 500 });
     }
 
     const env: NodeJS.ProcessEnv = {
@@ -73,7 +87,7 @@ export async function POST() {
       ...(authToken ? { AUTH_TOKEN: authToken } : {}),
     };
 
-    const child = spawn('npx', ['tsx', 'src/index.ts'], {
+    const child = spawn(process.execPath, [mcpBundle], {
       cwd: mcpDir,
       detached: true,
       stdio: 'ignore',
@@ -87,3 +101,22 @@ export async function POST() {
     return NextResponse.json({ error: message }, { status: 500 });
   }
 }
+
+function isPortInUse(port: number): Promise<boolean> {
+  return new Promise((res) => {
+    const net = require('net');
+    const server = net.createServer();
+    server.once('error', () => res(true));
+    server.once('listening', () => { server.close(); res(false); });
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+async function waitForPortFree(port: number, timeoutMs: number): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!(await isPortInUse(port))) return true;
+    await new Promise(r => setTimeout(r, 300));
+  }
+  return false;
+}

package/app/app/api/monitoring/route.ts

@@ -63,7 +63,7 @@ export async function GET() {
   const kbStats = getCachedKbStats(mindRoot);
 
   // Detect MCP status from environment / config
-  const mcpPort = Number(process.env.MCP_PORT) || 3457;
+  const mcpPort = Number(process.env.MINDOS_MCP_PORT) || Number(process.env.MCP_PORT) || 8781;
 
   return NextResponse.json({
     system: {

package/bin/cli.js

@@ -433,7 +433,7 @@ const commands = {
     if (process.env.MCP_TRANSPORT === 'http') {
       process.env.MCP_PORT = process.env.MINDOS_MCP_PORT || '8781';
     }
-    run(`npx tsx src/index.ts`, resolve(ROOT, 'mcp'));
+    run(`node dist/index.cjs`, resolve(ROOT, 'mcp'));
   },
 
   // ── stop / restart ─────────────────────────────────────────────────────────

package/bin/lib/mcp-spawn.js

@@ -1,59 +1,21 @@
-import { execSync, spawn } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { arch, platform } from 'node:os';
 import { ROOT, CONFIG_PATH } from './constants.js';
-import { bold, red, yellow } from './colors.js';
-import { npmInstall } from './utils.js';
-
-/**
- * If mcp/node_modules was installed on a different platform (e.g. Linux CI → macOS user),
- * native packages like esbuild will crash. Detect via stamp or @esbuild heuristics, then reinstall.
- */
-function ensureMcpNativeDeps() {
-  const mcpDir = resolve(ROOT, 'mcp');
-  const nm = resolve(mcpDir, 'node_modules');
-  if (!existsSync(nm)) return;
-
-  const host = `${platform()}-${arch()}`;
-  const stamp = resolve(mcpDir, '.mindos-npm-ci-platform');
-  let needsReinstall = false;
-
-  if (existsSync(stamp)) {
-    try {
-      needsReinstall = readFileSync(stamp, 'utf-8').trim() !== host;
-    } catch { /* fall through */ }
-  } else {
-    const esbuildDir = resolve(nm, '@esbuild');
-    if (existsSync(esbuildDir)) {
-      try {
-        const names = readdirSync(esbuildDir);
-        if (names.length > 0 && !names.includes(host)) needsReinstall = true;
-      } catch { /* ignore */ }
-    }
-  }
-
-  if (!needsReinstall) return;
-
-  console.log(yellow('MCP dependencies were built for another platform — reinstalling...'));
-  rmSync(nm, { recursive: true, force: true });
-  npmInstall(mcpDir, '--no-workspaces');
-  try { writeFileSync(stamp, host, 'utf-8'); } catch { /* non-fatal */ }
-}
+import { bold, red } from './colors.js';
 
 export function spawnMcp(verbose = false) {
   const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
   const webPort = process.env.MINDOS_WEB_PORT || '3456';
-  // Ensure mcp/node_modules exists (auto-install on first run)
-  const mcpSdk = resolve(ROOT, 'mcp', 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
-  if (!existsSync(mcpSdk)) {
-    console.log(yellow('Installing MCP dependencies (first run)...\n'));
-    npmInstall(resolve(ROOT, 'mcp'), '--no-workspaces');
+
+  const mcpBundle = resolve(ROOT, 'mcp', 'dist', 'index.cjs');
+  if (!existsSync(mcpBundle)) {
+    throw new Error(
+      `MCP bundle not found: ${mcpBundle}\n` +
+      `This MindOS installation may be corrupted. Try: npm install -g @geminilight/mindos@latest`,
+    );
   }
-  ensureMcpNativeDeps();
 
-  // Read AUTH_TOKEN directly from config to avoid stale system env overriding
-  // the user's configured token. Config is the source of truth for auth.
   let configAuthToken;
   try {
     const cfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
@@ -69,7 +31,7 @@ export function spawnMcp(verbose = false) {
     ...(configAuthToken ? { AUTH_TOKEN: configAuthToken } : {}),
     ...(verbose ? { MCP_VERBOSE: '1' } : {}),
   };
-  const child = spawn('npx', ['tsx', 'src/index.ts'], {
+  const child = spawn(process.execPath, [mcpBundle], {
     cwd: resolve(ROOT, 'mcp'),
     stdio: 'inherit',
     env,

package/bin/lib/stop.js

@@ -111,7 +111,7 @@ export function stopMindos(opts = {}) {
   if (!pids.length && portKilled === 0) {
     // Last resort: pattern match (for envs without lsof)
     try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
-    try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
+    try { execSync('pkill -f "mcp/(src/index|dist/index)" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
   }
 
   if (!pids.length) console.log(green('\u2714 Done'));