@geminilight/mindos 0.5.5 → 0.5.6

package/bin/cli.js

@@ -317,8 +317,18 @@ const commands = {
   stop: () => stopMindos(),
 
   restart: async () => {
+    loadConfig();
+    const webPort = Number(process.env.MINDOS_WEB_PORT || '3000');
+    const mcpPort = Number(process.env.MINDOS_MCP_PORT || '8787');
     stopMindos();
-    await new Promise((r) => setTimeout(r, 1500));
+    // Wait until both ports are actually free (up to 15s)
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+      const webBusy = await isPortInUse(webPort);
+      const mcpBusy = await isPortInUse(mcpPort);
+      if (!webBusy && !mcpBusy) break;
+      await new Promise((r) => setTimeout(r, 500));
+    }
     await commands[getStartMode()]();
   },
 

package/bin/lib/stop.js

@@ -6,60 +6,100 @@ 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;
 }
 
+/**
+ * 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;
+}
+
 export function stopMindos() {
+  // 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);
-    }
-    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 {}
+    for (const pid of pids) {
+      if (killTree(pid)) stopped++;
     }
-    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.
+  let portKilled = 0;
+  for (const port of [webPort, mcpPort]) {
+    portKilled += killByPort(port);
   }
-  clearPids();
-  console.log(stopped
-    ? green(`\u2714 Stopped ${stopped} process${stopped > 1 ? 'es' : ''}`)
-    : dim('No running processes found'));
+
+  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 {}
+  }
+
+  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.6",
   "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

@@ -746,34 +746,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 +1194,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'));
       }