@geminilight/mindos 0.6.7 → 0.6.12

package/bin/lib/mcp-build.js

@@ -0,0 +1,74 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ROOT } from './constants.js';
+import { yellow } from './colors.js';
+import { run, npmInstall } from './utils.js';
+
+export const MCP_DIR = resolve(ROOT, 'mcp');
+export const MCP_SRC_DIR = resolve(MCP_DIR, 'src');
+export const MCP_BUNDLE = resolve(MCP_DIR, 'dist', 'index.cjs');
+
+const MCP_PACKAGE_JSON = resolve(MCP_DIR, 'package.json');
+const MCP_PACKAGE_LOCK = resolve(MCP_DIR, 'package-lock.json');
+const MCP_SDK = resolve(MCP_DIR, 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
+const MCP_ESBUILD = resolve(MCP_DIR, 'node_modules', 'esbuild', 'package.json');
+
+function safeMtime(filePath) {
+  try {
+    return statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function latestTreeMtime(dirPath) {
+  if (!existsSync(dirPath)) return 0;
+
+  let latest = safeMtime(dirPath);
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = resolve(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      latest = Math.max(latest, latestTreeMtime(fullPath));
+    } else {
+      latest = Math.max(latest, safeMtime(fullPath));
+    }
+  }
+  return latest;
+}
+
+function hasBuildDeps() {
+  return existsSync(MCP_SDK) && existsSync(MCP_ESBUILD);
+}
+
+export function needsMcpBuild() {
+  if (!existsSync(MCP_BUNDLE)) return true;
+
+  const bundleMtime = safeMtime(MCP_BUNDLE);
+  const sourceMtime = Math.max(
+    latestTreeMtime(MCP_SRC_DIR),
+    safeMtime(MCP_PACKAGE_JSON),
+    safeMtime(MCP_PACKAGE_LOCK),
+  );
+
+  return sourceMtime > bundleMtime;
+}
+
+export function ensureMcpBundle() {
+  if (!needsMcpBuild()) return;
+
+  const hadBundle = existsSync(MCP_BUNDLE);
+
+  if (!hasBuildDeps()) {
+    console.log(yellow('Installing MCP build dependencies...\n'));
+    npmInstall(MCP_DIR, '--no-workspaces');
+  }
+
+  console.log(yellow(hadBundle
+    ? 'Rebuilding MCP bundle (source changed)...\n'
+    : 'Building MCP bundle (first run)...\n'));
+  run('npm run build', MCP_DIR);
+
+  if (!existsSync(MCP_BUNDLE)) {
+    throw new Error(`MCP bundle build did not produce ${MCP_BUNDLE}`);
+  }
+}

package/bin/lib/mcp-spawn.js

@@ -1,17 +1,20 @@
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { ROOT, CONFIG_PATH } from './constants.js';
 import { bold, red } from './colors.js';
+import { ensureMcpBundle, MCP_BUNDLE } from './mcp-build.js';
 
 export function spawnMcp(verbose = false) {
   const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
   const webPort = process.env.MINDOS_WEB_PORT || '3456';
 
-  const mcpBundle = resolve(ROOT, 'mcp', 'dist', 'index.cjs');
-  if (!existsSync(mcpBundle)) {
+  try {
+    ensureMcpBundle();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
     throw new Error(
-      `MCP bundle not found: ${mcpBundle}\n` +
+      `${message}\n` +
       `This MindOS installation may be corrupted. Try: npm install -g @geminilight/mindos@latest`,
     );
   }
@@ -31,7 +34,7 @@ export function spawnMcp(verbose = false) {
     ...(configAuthToken ? { AUTH_TOKEN: configAuthToken } : {}),
     ...(verbose ? { MCP_VERBOSE: '1' } : {}),
   };
-  const child = spawn(process.execPath, [mcpBundle], {
+  const child = spawn(process.execPath, [MCP_BUNDLE], {
     cwd: resolve(ROOT, 'mcp'),
     stdio: 'inherit',
     env,

package/bin/lib/port.js

@@ -1,5 +1,5 @@
 import { createConnection } from 'node:net';
-import { bold, dim, red } from './colors.js';
+import { bold, dim, red, yellow } from './colors.js';
 
 export function isPortInUse(port) {
   return new Promise((resolve) => {
@@ -16,10 +16,25 @@ export function isPortInUse(port) {
 }
 
 export async function assertPortFree(port, name) {
+  if (!(await isPortInUse(port))) return;
+
+  // Port is occupied — try to clean up orphaned processes from a previous
+  // installation (e.g. user deleted MindOS.app from Finder without quitting,
+  // leaving behind zombie Next.js / MCP processes on the default ports).
+  console.warn(`${yellow('⚠')} Port ${port} in use (${name}) — attempting cleanup...`);
+  try {
+    const { stopMindos } = await import('./stop.js');
+    stopMindos();
+    // Wait briefly for ports to release after SIGTERM
+    await new Promise(r => setTimeout(r, 1500));
+  } catch { /* stopMindos may fail if no config exists yet — that's fine */ }
+
+  // Re-check after cleanup
   if (await isPortInUse(port)) {
-    console.error(`\n${red('\u2718')} ${bold(`Port ${port} is already in use`)} ${dim(`(${name})`)}`);
+    console.error(`\n${red('\u2718')} ${bold(`Port ${port} is still in use after cleanup`)} ${dim(`(${name})`)}`);
     console.error(`\n  ${dim('Stop MindOS:')}       mindos stop`);
     console.error(`  ${dim('Find the process:')}  lsof -i :${port}\n`);
     process.exit(1);
   }
+  console.log(`  ${dim('Cleaned up orphaned processes on port')} ${port}`);
 }

package/bin/lib/stop.js

@@ -74,6 +74,13 @@ function killTree(pid) {
  *   read from the current config file.
  */
 export function stopMindos(opts = {}) {
+  // In test environment, skip all real process killing to avoid
+  // destroying dev servers or other unrelated processes.
+  if (process.env.NODE_ENV === 'test') {
+    console.log('(test mode: skipping real process stop)');
+    return;
+  }
+
   // Read ports from config for port-based cleanup
   let webPort = '3456', mcpPort = '8781';
   try {
@@ -110,8 +117,11 @@ 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|dist/index)" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
+    // Skip in test environment to avoid killing unrelated dev servers
+    if (process.env.NODE_ENV !== 'test') {
+      try { execSync('pkill -f "next start|next dev" 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'));