@geminilight/mindos 0.5.3 → 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/mcp-agents.js

@@ -4,13 +4,13 @@
  */
 
 export const MCP_AGENTS = {
-  'claude-code':    { name: 'Claude Code',    project: '.mcp.json',                       global: '~/.claude.json',                                                                         key: 'mcpServers' },
-  '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' },
-  'cursor':         { name: 'Cursor',          project: '.cursor/mcp.json',                global: '~/.cursor/mcp.json',                                                                     key: 'mcpServers' },
-  'windsurf':       { name: 'Windsurf',        project: null,                               global: '~/.codeium/windsurf/mcp_config.json',                                                   key: 'mcpServers' },
-  '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' },
-  'trae':           { name: 'Trae',            project: '.trae/mcp.json',                  global: '~/.trae/mcp.json',                                                                       key: 'mcpServers' },
-  'gemini-cli':     { name: 'Gemini CLI',      project: '.gemini/settings.json',           global: '~/.gemini/settings.json',                                                                key: 'mcpServers' },
-  'openclaw':       { name: 'OpenClaw',        project: null,                               global: '~/.openclaw/mcp.json',                                                                   key: 'mcpServers' },
-  'codebuddy':      { name: 'CodeBuddy',       project: null,                               global: '~/.claude-internal/.claude.json',                                                        key: 'mcpServers' },
+  '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' },
 };

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.3",
+  "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

@@ -133,6 +133,12 @@ const T = {
   mcpInstallDone: { en: (n) => `✔ ${n} agent(s) configured`, zh: (n) => `✔ 已配置 ${n} 个 Agent` },
   mcpSkipped:     { en: '  → Skipped. Run `mindos mcp install` anytime to configure agents.', zh: '  → 已跳过。随时运行 `mindos mcp install` 配置 Agent。' },
 
+  // skill install step
+  skillInstalling:  { en: (name) => `⏳ Installing Skill "${name}"...`, zh: (name) => `⏳ 正在安装 Skill "${name}"...` },
+  skillInstallOk:   { en: (name) => `  ${c.green('✔')} Skill "${name}" installed`, zh: (name) => `  ${c.green('✔')} Skill "${name}" 已安装` },
+  skillInstallFail: { en: (name, msg) => `  ${c.red('✘')} Skill "${name}" failed: ${msg}`, zh: (name, msg) => `  ${c.red('✘')} Skill "${name}" 安装失败：${msg}` },
+  skillSkipped:     { en: '  → No agents selected, skill install skipped.', zh: '  → 未选择 Agent，跳过 Skill 安装。' },
+
   // restart prompts (re-onboard with config changes)
   restartRequired:   { en: 'Config changed. Service restart required.', zh: '配置已变更，需要重启服务。' },
   restartNow:        { en: 'Restart now?', zh: '立即重启？' },
@@ -441,8 +447,13 @@ async function isSelfPort(port) {
         res.on('end', () => {
           try {
             const data = JSON.parse(body);
-            resolve(data.service === 'mindos');
-          } catch { resolve(false); }
+            // 200 with service=mindos → definitely us.
+            // 401 Unauthorized → also us (webPassword is set).
+            resolve(data.service === 'mindos' || res.statusCode === 401);
+          } catch {
+            // Non-JSON but got a response on /api/health → likely us
+            resolve(res.statusCode === 401 || res.statusCode === 200);
+          }
         });
       });
       req.on('error', () => resolve(false));
@@ -671,7 +682,7 @@ async function runMcpInstallStep(mcpPort, authToken) {
 
   if (selected.length === 0) {
     write(c.dim(t('mcpSkipped') + '\n'));
-    return;
+    return [];
   }
 
   write('\n' + c.dim(tf('mcpInstalling', selected.length) + '\n'));
@@ -705,6 +716,71 @@ async function runMcpInstallStep(mcpPort, authToken) {
   }
 
   console.log(`\n${c.green(tf('mcpInstallDone', okCount))}`);
+  return selected;
+}
+
+/* ── Skill auto-install ────────────────────────────────────────────────────── */
+
+const UNIVERSAL_AGENTS = new Set([
+  'amp', 'cline', 'codex', 'cursor', 'gemini-cli',
+  'github-copilot', 'kimi-cli', 'opencode', 'warp',
+]);
+const SKILL_UNSUPPORTED = new Set(['claude-desktop']);
+const AGENT_NAME_MAP = {
+  'claude-code': 'claude-code',
+  'windsurf': 'windsurf',
+  'trae': 'trae',
+  'openclaw': 'openclaw',
+  'codebuddy': 'codebuddy',
+};
+
+/**
+ * Install the appropriate MindOS Skill to selected agents via `npx skills add`.
+ * @param {string} template - 'en' | 'zh' | 'empty' | 'custom'
+ * @param {string[]} selectedAgents - MCP agent keys from the multi-select step
+ */
+function runSkillInstallStep(template, selectedAgents) {
+  if (!selectedAgents || selectedAgents.length === 0) {
+    write(c.dim(t('skillSkipped') + '\n'));
+    return;
+  }
+
+  const skillName = template === 'zh' ? 'mindos-zh' : 'mindos';
+  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);
+
+  // 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');
+
+  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 ─────────────────────────────────────────────────────────────────
@@ -739,16 +815,34 @@ async function startGuiSetup() {
   // Read or create config, set setupPending
   let config = {};
   try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { /* ignore */ }
+
+  const isFirstTime = !config.mindRoot;
   config.setupPending = true;
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
 
-  // Find a free port
-  const port = await findFreePort(3000);
-  if (config.port === undefined) {
-    config.port = port;
-    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+  // Determine which port to use for the setup wizard
+  let usePort;
+  if (isFirstTime) {
+    // First-time onboard: use a temporary port (scan from 9100) so the user's
+    // chosen port in Step 3 can differ without a mid-setup restart.
+    // 9100 is chosen to avoid conflicts with common services (5000=AirPlay, 3000/8080=dev).
+    usePort = await findFreePort(9100);
+  } else {
+    // Re-onboard: service is already running on config.port — reuse it.
+    const existingPort = config.port || 3000;
+    if (await isSelfPort(existingPort)) {
+      // Service already running — just open the setup page, no need to spawn.
+      const url = `http://localhost:${existingPort}/setup`;
+      console.log(`\n${c.green(tf('guiReady', url))}\n`);
+      const opened = openBrowser(url);
+      if (!opened) console.log(c.dim(tf('guiOpenFailed', url)));
+      process.exit(0);
+    }
+    // Service not running — start on existing port
+    usePort = await isPortInUse(existingPort)
+      ? await findFreePort(9100)  // existing port occupied by another process
+      : existingPort;
   }
-  const usePort = config.port || port;
 
   write(c.yellow(t('guiStarting') + '\n'));
 
@@ -841,6 +935,15 @@ async function main() {
 
   const { readdirSync } = await import('node:fs');
   let mindDir;
+  let selectedTemplate = 'en'; // hoisted — set by template selection or inferred from existing config
+  // Infer template from existing config's disabledSkills or UI language
+  if (resumeCfg.disabledSkills?.includes('mindos')) {
+    selectedTemplate = 'zh';
+  } else if (resumeCfg.disabledSkills?.includes('mindos-zh')) {
+    selectedTemplate = 'en';
+  } else {
+    selectedTemplate = uiLang; // fallback to UI language for first-time existing KB
+  }
 
   // Default KB path: existing mindRoot if set, otherwise ~/MindOS (same as GUI default)
   const HOME = homedir();
@@ -875,9 +978,9 @@ async function main() {
     } else {
       // ── Template selection (part of Step 1) ─────────────────────────────
       write('\n');
-      const tpl = await select('tplPrompt', 'tplOptions', 'tplValues');
+      selectedTemplate = await select('tplPrompt', 'tplOptions', 'tplValues');
       mkdirSync(mindDir, { recursive: true });
-      await applyTemplate(tpl, mindDir);
+      await applyTemplate(selectedTemplate, mindDir);
       break;
     }
   }
@@ -1000,12 +1103,13 @@ async function main() {
   }
 
   const config = {
-    mindRoot:    mindDir,
-    port:        webPort,
-    mcpPort:     mcpPort,
-    authToken:   authToken,
-    webPassword: webPassword || '',
-    startMode:   startMode,
+    mindRoot:       mindDir,
+    port:           webPort,
+    mcpPort:        mcpPort,
+    authToken:      authToken,
+    webPassword:    webPassword || '',
+    startMode:      startMode,
+    disabledSkills: selectedTemplate === 'zh' ? ['mindos'] : ['mindos-zh'],
     ai: {
       provider:  isSkip ? existingAiProvider : (isAnthropic ? 'anthropic' : 'openai'),
       providers: existingProviders,
@@ -1052,7 +1156,13 @@ async function main() {
   stepHeader(7);
   write(c.dim(tf('mcpStepHint') + '\n\n'));
 
-  await runMcpInstallStep(mcpPort, authToken);
+  const selectedAgents = await runMcpInstallStep(mcpPort, authToken);
+
+  // ── Skill auto-install ────────────────────────────────────────────────────
+  if (selectedAgents && selectedAgents.length > 0) {
+    write('\n');
+    runSkillInstallStep(selectedTemplate, selectedAgents);
+  }
 
   // ── Sync setup (optional) ──────────────────────────────────────────────────
   const wantSync = await askYesNo('syncSetup');
@@ -1084,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'));
       }