@geminilight/mindos 0.5.5 → 0.5.7

package/app/proxy.ts

@@ -16,8 +16,9 @@ export async function proxy(req: NextRequest) {
 
   // --- API protection (AUTH_TOKEN) ---
   if (pathname.startsWith('/api/')) {
-    // /api/auth handles its own password validation — never block it
-    if (pathname === '/api/auth') return NextResponse.next();
+    // /api/auth handles its own password validation — never block it.
+    // /api/health is unauthenticated so check-port can detect this MindOS instance.
+    if (pathname === '/api/auth' || pathname === '/api/health') return NextResponse.next();
 
     if (!authToken) return NextResponse.next();
 

package/app/vitest.config.ts

@@ -3,7 +3,7 @@ import path from 'path';
 
 export default defineConfig({
   test: {
-    include: ['__tests__/**/*.test.ts'],
+    include: ['__tests__/**/*.test.ts', '../tests/unit/**/*.test.ts'],
     setupFiles: ['__tests__/setup.ts'],
   },
   resolve: {

package/bin/cli.js

@@ -317,8 +317,41 @@ const commands = {
   stop: () => stopMindos(),
 
   restart: async () => {
-    stopMindos();
-    await new Promise((r) => setTimeout(r, 1500));
+    // Capture old ports BEFORE loadConfig overwrites env vars, so we can
+    // clean up processes that are still listening on the previous ports
+    // (e.g. user changed ports in the GUI and config was already saved).
+    // Sources: (1) MINDOS_OLD_* set by /api/restart when it strips the
+    //              current env, (2) current MINDOS_*_PORT env vars.
+    const oldWebPort = process.env.MINDOS_OLD_WEB_PORT || process.env.MINDOS_WEB_PORT;
+    const oldMcpPort = process.env.MINDOS_OLD_MCP_PORT || process.env.MINDOS_MCP_PORT;
+
+    loadConfig();
+
+    // After loadConfig, env vars reflect the NEW config (or old if unchanged).
+    const newWebPort = Number(process.env.MINDOS_WEB_PORT || '3000');
+    const newMcpPort = Number(process.env.MINDOS_MCP_PORT || '8787');
+
+    // Collect old ports that differ from new ones — processes may still be
+    // listening there even though config already points to the new ports.
+    const extraPorts = [];
+    if (oldWebPort && Number(oldWebPort) !== newWebPort) extraPorts.push(oldWebPort);
+    if (oldMcpPort && Number(oldMcpPort) !== newMcpPort) extraPorts.push(oldMcpPort);
+
+    stopMindos({ extraPorts });
+
+    // Wait until ALL ports (old + new) are actually free (up to 15s)
+    const allPorts = new Set([newWebPort, newMcpPort]);
+    for (const p of extraPorts) allPorts.add(Number(p));
+
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+      let anyBusy = false;
+      for (const p of allPorts) {
+        if (await isPortInUse(p)) { anyBusy = true; break; }
+      }
+      if (!anyBusy) break;
+      await new Promise((r) => setTimeout(r, 500));
+    }
     await commands[getStartMode()]();
   },
 

package/bin/lib/mcp-agents.js

@@ -1,16 +1,119 @@
 /**
  * Shared MCP agent definitions for CLI tools.
  * Mirrors app/lib/mcp-agents.ts — keep in sync manually.
+ *
+ * Each agent entry includes presenceCli / presenceDirs for detecting
+ * whether the agent is installed on the user's machine. To add a new
+ * agent, add a single entry here — no separate table needed.
  */
 
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+
+function expandHome(p) {
+  return p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
+}
+
 export const MCP_AGENTS = {
-  'claude-code':    { name: 'Claude Code',    project: '.mcp.json',                       global: '~/.claude.json',                                                                         key: 'mcpServers', preferredTransport: 'stdio' },
-  'claude-desktop': { name: 'Claude Desktop', project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Claude/claude_desktop_config.json' : '~/.config/Claude/claude_desktop_config.json', key: 'mcpServers', preferredTransport: 'http' },
-  'cursor':         { name: 'Cursor',          project: '.cursor/mcp.json',                global: '~/.cursor/mcp.json',                                                                     key: 'mcpServers', preferredTransport: 'stdio' },
-  'windsurf':       { name: 'Windsurf',        project: null,                               global: '~/.codeium/windsurf/mcp_config.json',                                                   key: 'mcpServers', preferredTransport: 'stdio' },
-  'cline':          { name: 'Cline',           project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json' : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json', key: 'mcpServers', preferredTransport: 'stdio' },
-  'trae':           { name: 'Trae',            project: '.trae/mcp.json',                  global: '~/.trae/mcp.json',                                                                       key: 'mcpServers', preferredTransport: 'stdio' },
-  'gemini-cli':     { name: 'Gemini CLI',      project: '.gemini/settings.json',           global: '~/.gemini/settings.json',                                                                key: 'mcpServers', preferredTransport: 'stdio' },
-  'openclaw':       { name: 'OpenClaw',        project: null,                               global: '~/.openclaw/mcp.json',                                                                   key: 'mcpServers', preferredTransport: 'stdio' },
-  'codebuddy':      { name: 'CodeBuddy',       project: null,                               global: '~/.claude-internal/.claude.json',                                                        key: 'mcpServers', preferredTransport: 'stdio' },
+  'claude-code': {
+    name: 'Claude Code',
+    project: '.mcp.json',
+    global: '~/.claude.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceCli: 'claude',
+    presenceDirs: ['~/.claude/'],
+  },
+  'claude-desktop': {
+    name: 'Claude Desktop',
+    project: null,
+    global: process.platform === 'darwin'
+      ? '~/Library/Application Support/Claude/claude_desktop_config.json'
+      : '~/.config/Claude/claude_desktop_config.json',
+    key: 'mcpServers',
+    preferredTransport: 'http',
+    presenceDirs: ['~/Library/Application Support/Claude/', '~/.config/Claude/'],
+  },
+  'cursor': {
+    name: 'Cursor',
+    project: '.cursor/mcp.json',
+    global: '~/.cursor/mcp.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceDirs: ['~/.cursor/'],
+  },
+  'windsurf': {
+    name: 'Windsurf',
+    project: null,
+    global: '~/.codeium/windsurf/mcp_config.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceDirs: ['~/.codeium/windsurf/'],
+  },
+  'cline': {
+    name: 'Cline',
+    project: null,
+    global: process.platform === 'darwin'
+      ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'
+      : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceDirs: [
+      '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/',
+      '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/',
+    ],
+  },
+  'trae': {
+    name: 'Trae',
+    project: '.trae/mcp.json',
+    global: '~/.trae/mcp.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceDirs: ['~/.trae/'],
+  },
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    project: '.gemini/settings.json',
+    global: '~/.gemini/settings.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceCli: 'gemini',
+    presenceDirs: ['~/.gemini/'],
+  },
+  'openclaw': {
+    name: 'OpenClaw',
+    project: null,
+    global: '~/.openclaw/mcp.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceCli: 'openclaw',
+    presenceDirs: ['~/.openclaw/'],
+  },
+  'codebuddy': {
+    name: 'CodeBuddy',
+    project: null,
+    global: '~/.claude-internal/.claude.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceCli: 'claude-internal',
+    presenceDirs: ['~/.claude-internal/'],
+  },
 };
+
+export function detectAgentPresence(agentKey) {
+  const agent = MCP_AGENTS[agentKey];
+  if (!agent) return false;
+  if (agent.presenceCli) {
+    try {
+      execSync(
+        process.platform === 'win32' ? `where ${agent.presenceCli}` : `which ${agent.presenceCli}`,
+        { stdio: 'pipe' },
+      );
+      return true;
+    } catch { /* not found */ }
+  }
+  if (agent.presenceDirs?.some(d => existsSync(expandHome(d)))) return true;
+  return false;
+}

package/bin/lib/stop.js

@@ -6,60 +6,113 @@ import { CONFIG_PATH } from './constants.js';
 
 /**
  * Kill processes listening on the given port.
+ * Tries lsof first, then falls back to parsing `ss` output.
  * Returns number of processes killed.
  */
 function killByPort(port) {
-  let killed = 0;
+  const pidsToKill = new Set();
+
+  // Method 1: lsof
   try {
     const output = execSync(`lsof -ti :${port} 2>/dev/null`, { encoding: 'utf-8' }).trim();
     if (output) {
       for (const p of output.split('\n')) {
         const pid = Number(p);
-        if (pid > 0) {
-          try { process.kill(pid, 'SIGTERM'); killed++; } catch {}
-        }
+        if (pid > 0) pidsToKill.add(pid);
       }
     }
   } catch {
     // lsof not available or no processes found
   }
+
+  // Method 2: ss -tlnp (fallback — works when lsof can't see the process)
+  if (pidsToKill.size === 0) {
+    try {
+      const output = execSync(`ss -tlnp 2>/dev/null`, { encoding: 'utf-8' });
+      // Match lines like: LISTEN ... *:3003 ... users:(("next-server",pid=12345,fd=21))
+      // Match `:PORT` followed by a non-digit to avoid partial matches
+      // (e.g. port 80 must not match :8080)
+      const portRe = new RegExp(`:${port}(?!\\d)`);
+      for (const line of output.split('\n')) {
+        if (!portRe.test(line)) continue;
+        const pidMatch = line.match(/pid=(\d+)/g);
+        if (pidMatch) {
+          for (const m of pidMatch) {
+            const pid = Number(m.slice(4));
+            if (pid > 0) pidsToKill.add(pid);
+          }
+        }
+      }
+    } catch {
+      // ss not available
+    }
+  }
+
+  let killed = 0;
+  for (const pid of pidsToKill) {
+    try { process.kill(pid, 'SIGTERM'); killed++; } catch {}
+  }
   return killed;
 }
 
-export function stopMindos() {
+/**
+ * Kill a process and all its children (process group).
+ */
+function killTree(pid) {
+  // Try to kill the entire process group first
+  try { process.kill(-pid, 'SIGTERM'); return true; } catch {}
+  // Fallback: kill individual process
+  try { process.kill(pid, 'SIGTERM'); return true; } catch {}
+  return false;
+}
+
+/**
+ * Stop MindOS processes.
+ * @param {Object} [opts] - Optional overrides.
+ * @param {string[]} [opts.extraPorts] - Additional ports to clean up (e.g. old
+ *   ports before a config change).  These are cleaned in addition to the ports
+ *   read from the current config file.
+ */
+export function stopMindos(opts = {}) {
+  // Read ports from config for port-based cleanup
+  let webPort = '3000', mcpPort = '8787';
+  try {
+    const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    if (config.port) webPort = String(config.port);
+    if (config.mcpPort) mcpPort = String(config.mcpPort);
+  } catch {}
+
   const pids = loadPids();
   if (!pids.length) {
     console.log(yellow('No PID file found, trying port-based stop...'));
-    // Read ports from config
-    let webPort = '3000', mcpPort = '8787';
-    try {
-      const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-      if (config.port) webPort = String(config.port);
-      if (config.mcpPort) mcpPort = String(config.mcpPort);
-    } catch {}
+  } else {
+    // Kill saved PIDs (parent process + MCP) and their child processes
     let stopped = 0;
-    for (const port of [webPort, mcpPort]) {
-      stopped += killByPort(port);
+    for (const pid of pids) {
+      if (killTree(pid)) stopped++;
     }
-    if (stopped === 0) {
-      // Fallback: pkill pattern match (for envs without lsof)
-      try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: 'inherit' }); } catch {}
-      try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: 'inherit' }); } catch {}
-    }
-    console.log(green('\u2714 Done'));
-    return;
+    clearPids();
+    if (stopped) console.log(green(`\u2714 Stopped ${stopped} process${stopped > 1 ? 'es' : ''}`));
   }
-  let stopped = 0;
-  for (const pid of pids) {
-    try {
-      process.kill(pid, 'SIGTERM');
-      stopped++;
-    } catch {
-      // process already gone — ignore
-    }
+
+  // Always do port-based cleanup — Next.js spawns worker processes whose PIDs
+  // are not recorded in the PID file and would otherwise become orphaned.
+  // Include any extra ports (e.g. old ports from before a config change).
+  const portsToClean = new Set([webPort, mcpPort]);
+  if (opts.extraPorts) {
+    for (const p of opts.extraPorts) portsToClean.add(String(p));
+  }
+
+  let portKilled = 0;
+  for (const port of portsToClean) {
+    portKilled += killByPort(port);
+  }
+
+  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: 'inherit' }); } catch {}
+    try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: 'inherit' }); } catch {}
   }
-  clearPids();
-  console.log(stopped
-    ? green(`\u2714 Stopped ${stopped} process${stopped > 1 ? 'es' : ''}`)
-    : dim('No running processes found'));
+
+  if (!pids.length) console.log(green('\u2714 Done'));
 }

package/mcp/src/index.ts

@@ -484,6 +484,11 @@ async function main() {
 
     const expressApp = createMcpExpressApp({ host: MCP_HOST });
 
+    // Health endpoint — allows check-port to detect this is a MindOS MCP instance
+    expressApp.get("/api/health", (_req, res) => {
+      res.json({ ok: true, service: "mindos" });
+    });
+
     // Auth middleware
     if (AUTH_TOKEN) {
       expressApp.use(MCP_ENDPOINT, (req, res, next) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",

package/scripts/gen-renderer-index.js

@@ -20,6 +20,13 @@ const dirs = fs.readdirSync(renderersDir, { withFileTypes: true })
   .map(d => d.name)
   .sort();
 
+// Opt-in-only renderers (match: () => false) go last for consistent ordering.
+const LAST = new Set(['graph']);
+const sorted = [
+  ...dirs.filter(d => !LAST.has(d)),
+  ...dirs.filter(d => LAST.has(d)),
+];
+
 if (dirs.length === 0) {
   console.error('No manifest.ts files found in', renderersDir);
   process.exit(1);
@@ -30,12 +37,12 @@ function toCamel(s) {
   return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 
-const imports = dirs.map(dir => {
+const imports = sorted.map(dir => {
   const varName = toCamel(dir);
   return `import { manifest as ${varName} } from '@/components/renderers/${dir}/manifest';`;
 }).join('\n');
 
-const varNames = dirs.map(toCamel);
+const varNames = sorted.map(toCamel);
 
 const code = `/**
  * AUTO-GENERATED by scripts/gen-renderer-index.js — do not edit manually.

package/scripts/setup.js

@@ -30,7 +30,7 @@ import { execSync, spawn } from 'node:child_process';
 import { randomBytes, createHash } from 'node:crypto';
 import { createConnection } from 'node:net';
 import http from 'node:http';
-import { MCP_AGENTS } from '../bin/lib/mcp-agents.js';
+import { MCP_AGENTS, detectAgentPresence } from '../bin/lib/mcp-agents.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, '..');
@@ -616,14 +616,15 @@ function isAgentInstalled(agentKey) {
 async function runMcpInstallStep(mcpPort, authToken) {
   const keys = Object.keys(MCP_AGENTS);
 
-  // Build options with installed status shown as hint
+  // Build options with installed/detected status shown as hint
   const options = keys.map(k => {
     const installed = isAgentInstalled(k);
+    const present = detectAgentPresence(k);
     return {
       label: MCP_AGENTS[k].name,
-      hint:  installed ? (uiLang === 'zh' ? '已安装' : 'installed') : (uiLang === 'zh' ? '未安装' : 'not installed'),
+      hint:  installed ? (uiLang === 'zh' ? '已配置' : 'configured') : present ? (uiLang === 'zh' ? '已检测' : 'detected') : (uiLang === 'zh' ? '未找到' : 'not found'),
       value: k,
-      preselect: installed,
+      preselect: installed || present,
     };
   });
 
@@ -746,34 +747,41 @@ function runSkillInstallStep(template, selectedAgents) {
   }
 
   const skillName = template === 'zh' ? 'mindos-zh' : 'mindos';
-  const source = resolve(ROOT, 'skills');
+  const localSource = resolve(ROOT, 'skills');
+  const githubSource = 'GeminiLight/MindOS';
 
   // Filter to non-universal, skill-capable agents
   const additionalAgents = selectedAgents
     .filter(key => !UNIVERSAL_AGENTS.has(key) && !SKILL_UNSUPPORTED.has(key))
     .map(key => AGENT_NAME_MAP[key] || key);
 
-  let cmd;
-  if (additionalAgents.length > 0) {
-    cmd = `npx skills add "${source}" -s ${skillName} -a ${additionalAgents.join(',')} -g -y`;
-  } else {
-    cmd = `npx skills add "${source}" -s ${skillName} -a universal -g -y`;
-  }
+  // Each agent needs its own -a flag (skills CLI does NOT accept comma-separated)
+  const agentFlags = additionalAgents.length > 0
+    ? additionalAgents.map(a => `-a ${a}`).join(' ')
+    : '-a universal';
+
+  // Try GitHub source first, fall back to local path
+  const sources = [githubSource, localSource];
 
   write(tf('skillInstalling', skillName) + '\n');
 
-  try {
-    execSync(cmd, {
-      encoding: 'utf-8',
-      timeout: 30_000,
-      env: { ...process.env, NODE_ENV: 'production' },
-      stdio: 'pipe',
-    });
-    write(tf('skillInstallOk', skillName) + '\n');
-  } catch (err) {
-    const msg = err.stderr || err.message || 'Unknown error';
-    write(tf('skillInstallFail', skillName, msg.split('\n')[0]) + '\n');
+  for (const source of sources) {
+    // Quote local paths for shell safety
+    const quotedSource = /[/\\]/.test(source) ? `"${source}"` : source;
+    const cmd = `npx skills add ${quotedSource} --skill ${skillName} ${agentFlags} -g -y`;
+    try {
+      execSync(cmd, {
+        encoding: 'utf-8',
+        timeout: 30_000,
+        env: { ...process.env, NODE_ENV: 'production' },
+        stdio: 'pipe',
+      });
+      write(tf('skillInstallOk', skillName) + '\n');
+      return;
+    } catch { /* try next source */ }
   }
+
+  write(tf('skillInstallFail', skillName, 'All sources failed') + '\n');
 }
 
 // ── GUI Setup ─────────────────────────────────────────────────────────────────
@@ -1187,7 +1195,9 @@ async function finish(mindDir, startMode = 'start', mcpPort = 8787, authToken =
       const doRestart = await askYesNoDefault('restartNow');
       if (doRestart) {
         const cliPath = resolve(__dirname, '../bin/cli.js');
-        execSync(`node "${cliPath}" start`, { stdio: 'inherit' });
+        // Use 'restart' (stop → start) instead of bare 'start' which would
+        // fail assertPortFree because the old process is still running.
+        execSync(`node "${cliPath}" restart`, { stdio: 'inherit' });
       } else {
         write(c.dim(t('restartManual') + '\n'));
       }