@geminilight/mindos 0.6.41 → 0.6.43

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

@@ -2,8 +2,8 @@ export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
 import fs from 'fs';
 import path from 'path';
-import { MCP_AGENTS, expandHome } from '@/lib/mcp-agents';
-import { readSettings } from '@/lib/settings';
+import { MCP_AGENTS, expandHome, resolveSkillWorkspaceProfile } from '@/lib/mcp-agents';
+import { readSettings, recordSkillInstall } from '@/lib/settings';
 
 /** Parse JSONC — strips comments before JSON.parse. Returns {} for empty/whitespace-only input. */
 function parseJsonc(text: string): Record<string, unknown> {
@@ -204,6 +204,17 @@ export async function POST(req: NextRequest) {
 
         const result: typeof results[number] = { agent: key, status: 'ok', path: configPath, transport: effectiveTransport };
 
+        // Record skill install path for auto-update on future version bumps.
+        // Always record — even if skill file doesn't exist yet (user may install
+        // it later via `npx skills add`). skill-check gracefully skips missing paths.
+        try {
+          const skillProfile = resolveSkillWorkspaceProfile(key);
+          const settings = readSettings();
+          const activeSkill = settings.disabledSkills?.includes('mindos') ? 'mindos-zh' : 'mindos';
+          const skillPath = path.join(skillProfile.workspacePath, activeSkill, 'SKILL.md');
+          recordSkillInstall(key, activeSkill, skillPath);
+        } catch { /* best-effort, don't fail the install */ }
+
         // Verify http connections
         if (effectiveTransport === 'http') {
           const mcpUrl = (entry as Record<string, unknown>).url as string;

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

@@ -0,0 +1,130 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { MCP_AGENTS, expandHome } from '@/lib/mcp-agents';
+
+/** Parse JSONC — strips comments before JSON.parse. Returns {} for empty/whitespace-only input. */
+function parseJsonc(text: string): Record<string, unknown> {
+  let stripped = text.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)/gm, (m, g) => g ? '' : m);
+  stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
+  if (!stripped.trim()) return {};
+  return JSON.parse(stripped);
+}
+
+/** Navigate a dot-path (e.g. "mcp.servers") and return the leaf container, or null. */
+function getNestedPath(obj: Record<string, unknown>, dotPath: string): Record<string, unknown> | null {
+  const parts = dotPath.split('.').filter(Boolean);
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (!current || typeof current !== 'object') return null;
+    current = (current as Record<string, unknown>)[part];
+  }
+  return (current && typeof current === 'object') ? current as Record<string, unknown> : null;
+}
+
+/** Remove a [section.server] block from a TOML file */
+function removeTomlEntry(existing: string, sectionKey: string, serverName: string): string {
+  const sectionHeader = `[${sectionKey}.${serverName}]`;
+  const envHeader = `[${sectionKey}.${serverName}.env]`;
+  const headersHeader = `[${sectionKey}.${serverName}.headers]`;
+
+  const lines = existing.split('\n');
+  const result: string[] = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === sectionHeader || trimmed === envHeader || trimmed === headersHeader) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith('[')) {
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+
+  // Clean up consecutive blank lines
+  const cleaned: string[] = [];
+  for (const line of result) {
+    if (line.trim() === '' && cleaned.length > 0 && cleaned[cleaned.length - 1].trim() === '') continue;
+    cleaned.push(line);
+  }
+
+  return cleaned.join('\n');
+}
+
+interface UninstallRequest {
+  agents: Array<{
+    key: string;
+    scope: 'project' | 'global';
+  }>;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = (await req.json()) as UninstallRequest;
+    const { agents } = body;
+    const results: Array<{
+      agent: string;
+      status: string;
+      path?: string;
+      message?: string;
+    }> = [];
+
+    for (const item of agents) {
+      const { key, scope } = item;
+      const agent = MCP_AGENTS[key];
+      if (!agent) {
+        results.push({ agent: key, status: 'error', message: `Unknown agent: ${key}` });
+        continue;
+      }
+
+      const isGlobal = scope === 'global';
+      const configPath = isGlobal ? agent.global : agent.project;
+      if (!configPath) {
+        results.push({ agent: key, status: 'error', message: `${agent.name} does not support ${scope} scope` });
+        continue;
+      }
+
+      const absPath = expandHome(configPath);
+
+      if (!fs.existsSync(absPath)) {
+        results.push({ agent: key, status: 'ok', message: 'Config file does not exist' });
+        continue;
+      }
+
+      try {
+        if (agent.format === 'toml') {
+          const existing = fs.readFileSync(absPath, 'utf-8');
+          const updated = removeTomlEntry(existing, agent.key, 'mindos');
+          fs.writeFileSync(absPath, updated, 'utf-8');
+        } else {
+          const config = parseJsonc(fs.readFileSync(absPath, 'utf-8'));
+
+          // Handle nested keys (e.g. VS Code: mcp.servers)
+          const useNestedKey = isGlobal && agent.globalNestedKey;
+          const container = useNestedKey
+            ? getNestedPath(config, agent.globalNestedKey!)
+            : (config[agent.key] as Record<string, unknown> | undefined);
+
+          if (container && 'mindos' in container) {
+            delete container.mindos;
+            fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+          }
+        }
+
+        results.push({ agent: key, status: 'ok', path: configPath });
+      } catch (err) {
+        results.push({ agent: key, status: 'error', message: String(err) });
+      }
+    }
+
+    return NextResponse.json({ results });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/skills/route.ts

@@ -32,7 +32,7 @@ export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
     const { action, name, description, content, enabled, sourcePath } = body as {
-      action: 'create' | 'update' | 'delete' | 'toggle' | 'read' | 'read-native';
+      action: 'create' | 'update' | 'delete' | 'toggle' | 'read' | 'read-native' | 'record-install';
       name?: string;
       description?: string;
       content?: string;
@@ -130,6 +130,19 @@ export async function POST(req: NextRequest) {
         return NextResponse.json({ content: nativeContent, description: nativeDesc });
       }
 
+      case 'record-install': {
+        // Record that a skill was installed to a specific agent (for auto-update tracking)
+        const agentKey = (body as { agentKey?: string }).agentKey;
+        const skillName = name;
+        const installPath = (body as { installPath?: string }).installPath;
+        if (!agentKey || !skillName || !installPath) {
+          return NextResponse.json({ error: 'agentKey, name, and installPath are required' }, { status: 400 });
+        }
+        const { recordSkillInstall } = await import('@/lib/settings');
+        recordSkillInstall(agentKey, skillName, installPath);
+        return NextResponse.json({ ok: true });
+      }
+
       default:
         return NextResponse.json({ error: `Unknown action: ${action}` }, { status: 400 });
     }

package/app/components/agents/AgentsMcpSection.tsx

@@ -3,6 +3,7 @@
 import { useCallback, useMemo, useState } from 'react';
 import Link from 'next/link';
 import { RefreshCw, Search, Server } from 'lucide-react';
+import { apiFetch } from '@/lib/api';
 import type { McpContextValue } from '@/lib/stores/mcp-store';
 import type { AgentBuckets, AgentStatusFilter, AgentTransportFilter } from './agents-content-model';
 import {
@@ -58,6 +59,8 @@ export default function AgentsMcpSection({
     cancel: string;
     noAvailableAgents: string;
     manualRemoveHint: string;
+    removeSuccess: string;
+    removeFailed: string;
     reconnectAllInServer: string;
     reconnectAllRunning: string;
     reconnectAllDone: (ok: number, failed: number) => string;
@@ -383,7 +386,7 @@ function ByServerView({
   onReconnect: (agent: ReturnType<typeof sortAgentsByStatus>[number]) => Promise<void>;
 }) {
   const [pickerServer, setPickerServer] = useState<string | null>(null);
-  const [confirmState, setConfirmState] = useState<{ agentName: string; serverName: string } | null>(null);
+  const [confirmState, setConfirmState] = useState<{ agentKey: string; agentName: string; serverName: string } | null>(null);
   const [hintMessage, setHintMessage] = useState<string | null>(null);
   const [reconnectingServer, setReconnectingServer] = useState<string | null>(null);
   const [reconnectMsg, setReconnectMsg] = useState<Record<string, string>>({});
@@ -396,11 +399,27 @@ function ByServerView({
     [onInstallMindos],
   );
 
-  const handleConfirmRemove = useCallback(() => {
+  const handleConfirmRemove = useCallback(async () => {
+    if (!confirmState) return;
+    const { agentKey } = confirmState;
     setConfirmState(null);
-    setHintMessage(copy.manualRemoveHint);
+
+    // Find agent info to determine scope
+    const agent = allAgents.find(a => a.key === agentKey);
+    const scope = agent?.scope === 'project' ? 'project' : 'global';
+
+    try {
+      await apiFetch('/api/mcp/uninstall', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ agents: [{ key: agentKey, scope }] }),
+      });
+      setHintMessage(copy.removeSuccess ?? 'Removed. Restart your agent to apply.');
+    } catch {
+      setHintMessage(copy.removeFailed ?? 'Failed to remove. Try editing the config file manually.');
+    }
     setTimeout(() => setHintMessage(null), 4000);
-  }, [copy.manualRemoveHint]);
+  }, [confirmState, allAgents, copy]);
 
   const handleReconnectAllInServer = useCallback(
     async (serverName: string, agents: typeof allAgents) => {
@@ -520,7 +539,7 @@ function ByServerView({
                       <AgentAvatar
                         name={agent.name}
                         status={agentStatus}
-                        onRemove={() => setConfirmState({ agentName: agent.name, serverName: srv.serverName })}
+                        onRemove={() => setConfirmState({ agentKey: agent.key, agentName: agent.name, serverName: srv.serverName })}
                       />
                     </Link>
                   );

package/app/components/setup/index.tsx

@@ -216,7 +216,7 @@ export default function SetupWizard() {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [step]);
 
-  // Load agents when entering Agents step
+  // Load agents when entering Agents step (exclude builtin — MindOS itself)
   useEffect(() => {
     if (step === STEP_AGENTS && !agentsLoaded && !agentsLoading) {
       setAgentsLoading(true);
@@ -224,9 +224,10 @@ export default function SetupWizard() {
         .then(r => r.json())
         .then(data => {
           if (data.agents) {
-            setAgents(data.agents);
+            const externalAgents = (data.agents as AgentEntry[]).filter(a => a.scope !== 'builtin');
+            setAgents(externalAgents);
             setSelectedAgents(new Set(
-              (data.agents as AgentEntry[]).filter(a => a.installed || a.present).map(a => a.key)
+              externalAgents.filter(a => a.installed || a.present).map(a => a.key)
             ));
           }
           setAgentsLoaded(true);

package/app/components/setup/types.ts

@@ -48,6 +48,7 @@ export interface AgentEntry {
   name: string;
   present: boolean;
   installed: boolean;
+  scope?: string;
   hasProjectScope: boolean;
   hasGlobalScope: boolean;
   preferredTransport: 'stdio' | 'http';

package/app/instrumentation.ts

@@ -33,5 +33,26 @@ export async function register() {
         // mindRoot not configured yet — skip prewarming
       }
     });
+
+    // Skill auto-update: check if bundled skills are newer than installed
+    // ones (covers both CLI startup and Desktop hot-update restarts).
+    process.nextTick(async () => {
+      try {
+        const projRoot = process.env.MINDOS_PROJECT_ROOT || resolve(process.cwd(), '..');
+        const skillCheckModule = resolve(projRoot, 'bin', 'lib', 'skill-check.js');
+        const { checkSkillVersions, updateSkill } = await import(skillCheckModule);
+        const mismatches = checkSkillVersions(projRoot);
+        for (const m of mismatches) {
+          try {
+            updateSkill(m.bundledPath, m.installPath);
+            console.log(`[SkillSync] Updated ${m.name}${m.agent ? ` (${m.agent})` : ''}: v${m.installed} → v${m.bundled}`);
+          } catch (err) {
+            console.warn(`[SkillSync] Failed to update ${m.name}: ${err instanceof Error ? err.message : err}`);
+          }
+        }
+      } catch {
+        // skill-check not available or failed — silently skip
+      }
+    });
   }
 }

package/app/lib/i18n/modules/panels.ts

@@ -370,10 +370,12 @@ export const panelsEn = {
       addAgent: 'Add',
       removeFromServer: 'Remove',
       confirmRemoveTitle: 'Remove from server?',
-      confirmRemoveMessage: (agent: string, server: string) => `Remove "${agent}" from "${server}"? This requires editing the agent config file.`,
+      confirmRemoveMessage: (agent: string, server: string) => `Remove "${agent}" from "${server}"? The agent config will be updated automatically.`,
       cancel: 'Cancel',
       noAvailableAgents: 'All agents already connected.',
       manualRemoveHint: 'Flagged for removal — edit the agent config to finalize.',
+      removeSuccess: 'Removed. Restart your agent to apply.',
+      removeFailed: 'Failed to remove. Try editing the config file manually.',
       reconnectAllInServer: 'Reconnect all',
       reconnectAllRunning: 'Reconnecting...',
       reconnectAllDone: (ok: number, failed: number) => `Done: ${ok} reconnected${failed > 0 ? `, ${failed} failed` : ''}.`,
@@ -995,10 +997,12 @@ export const panelsZh = {
       addAgent: '添加',
       removeFromServer: '移除',
       confirmRemoveTitle: '从服务器移除？',
-      confirmRemoveMessage: (agent: string, server: string) => `将"${agent}"从"${server}"移除？需编辑 Agent 配置文件完成操作。`,
+      confirmRemoveMessage: (agent: string, server: string) => `将"${agent}"从"${server}"移除？配置文件将自动更新。`,
       cancel: '取消',
       noAvailableAgents: '所有 Agent 均已添加。',
       manualRemoveHint: '已标记移除，请编辑 Agent 配置文件完成操作。',
+      removeSuccess: '已移除，重启 Agent 后生效。',
+      removeFailed: '移除失败，请手动编辑配置文件。',
       reconnectAllInServer: '全部重连',
       reconnectAllRunning: '正在重连...',
       reconnectAllDone: (ok: number, failed: number) => `完成：${ok} 已重连${failed > 0 ? `，${failed} 失败` : ''}。`,

package/app/lib/settings.ts

@@ -214,6 +214,38 @@ export function writeSettings(settings: ServerSettings): void {
   fs.writeFileSync(SETTINGS_PATH, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
 }
 
+/* ── Skill install tracking ────────────────────────────────────── */
+
+export interface SkillInstallRecord {
+  agent: string;
+  skill: string;
+  path: string;
+}
+
+/**
+ * Record that a skill was installed to a specific agent path.
+ * Stored in config.json → installedSkillAgents[].
+ * Idempotent — updates existing entry if agent+skill match.
+ */
+export function recordSkillInstall(agentKey: string, skillName: string, installPath: string): void {
+  let config: Record<string, unknown> = {};
+  try { config = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8')); } catch { /* fresh */ }
+
+  const list: SkillInstallRecord[] = Array.isArray(config.installedSkillAgents)
+    ? (config.installedSkillAgents as SkillInstallRecord[])
+    : [];
+
+  const entry: SkillInstallRecord = { agent: agentKey, skill: skillName, path: installPath };
+  const idx = list.findIndex(e => e.agent === agentKey && e.skill === skillName);
+  if (idx >= 0) list[idx] = entry;
+  else list.push(entry);
+
+  config.installedSkillAgents = list;
+  const dir = path.dirname(SETTINGS_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(SETTINGS_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
 /** Effective AI config — unified interface for all providers.
  *  Resolves: saved config → env var → preset default, in that priority order.
  *  When `providerOverride` is given, resolves that provider's config instead. */

package/bin/commands/start.js

@@ -63,6 +63,16 @@ export const run = async (args, flags) => {
   const isVerbose = Boolean(flags.verbose);
   const extra = args.join(' ');
 
+  // Ensure `mindos` CLI is in PATH (silent, best-effort, dev installs only)
+  try {
+    execSync('command -v mindos', { stdio: 'ignore' });
+  } catch {
+    const isDesktop = !!(process.env.ELECTRON_RUN_AS_NODE || process.env.MINDOS_DESKTOP);
+    if (!isDesktop && existsSync(resolve(ROOT, '.git'))) {
+      try { execSync('npm link', { cwd: ROOT, stdio: 'ignore' }); } catch { /* best effort */ }
+    }
+  }
+
   // Check for incomplete setup
   if (existsSync(CONFIG_PATH)) {
     try {

package/bin/lib/skill-check.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, copyFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
 import { ROOT } from './constants.js';
@@ -7,11 +7,10 @@ import { bold, dim, cyan, green, yellow, isTTY } from './colors.js';
 
 const SKILLS = ['mindos', 'mindos-zh'];
 const INSTALLED_BASE = resolve(homedir(), '.agents', 'skills');
+const CONFIG_PATH = resolve(homedir(), '.mindos', 'config.json');
 
 /**
  * Simple semver "a > b" comparison (major.minor.patch only).
- * Intentionally inlined (same as update-check.js) to keep this module
- * self-contained — no cross-module dependency for a 10-line function.
  */
 function semverGt(a, b) {
   const pa = a.split('.').map(Number);
@@ -37,53 +36,150 @@ export function extractSkillVersion(filePath) {
   }
 }
 
+/* ── Config helpers (read/write installedSkillAgents) ─────────── */
+
+/**
+ * Read config.json, best-effort.
+ */
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge fields into config.json (preserves all existing fields).
+ */
+function mergeConfig(patch) {
+  const config = readConfig();
+  Object.assign(config, patch);
+  const dir = dirname(CONFIG_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Read the installed-skill-agents list from config.
+ * @returns {Array<{ agent: string, skill: string, path: string }>}
+ */
+export function getInstalledSkillAgents() {
+  const config = readConfig();
+  return Array.isArray(config.installedSkillAgents) ? config.installedSkillAgents : [];
+}
+
+/**
+ * Record that a skill was installed to a specific agent.
+ * Idempotent — updates existing entry if agent+skill already recorded.
+ */
+export function recordSkillInstall(agentKey, skillName, installPath) {
+  const list = getInstalledSkillAgents();
+  const idx = list.findIndex(e => e.agent === agentKey && e.skill === skillName);
+  const entry = { agent: agentKey, skill: skillName, path: installPath };
+  if (idx >= 0) {
+    list[idx] = entry;
+  } else {
+    list.push(entry);
+  }
+  mergeConfig({ installedSkillAgents: list });
+}
+
+/**
+ * Remove a skill record for an agent.
+ */
+export function removeSkillRecord(agentKey, skillName) {
+  const list = getInstalledSkillAgents();
+  const filtered = list.filter(e => !(e.agent === agentKey && e.skill === skillName));
+  if (filtered.length !== list.length) {
+    mergeConfig({ installedSkillAgents: filtered });
+  }
+}
+
+/* ── Version checking ─────────────────────────────────────────── */
+
 /**
  * Compare installed vs bundled skill versions.
- * @param {string} [root] — package root to read bundled skills from.
- *   Defaults to the static ROOT (fine for startup). Pass the post-update
- *   root when called from `mindos update` so we read the NEW package's skills.
- * Returns array of mismatches where bundled > installed.
+ * Checks both the default ~/.agents/skills/ path AND all agent-specific
+ * paths recorded in config.installedSkillAgents.
+ *
+ * @param {string} [root] — package root (defaults to ROOT)
+ * @returns {Array<{ name, installed, bundled, installPath, bundledPath, agent? }>}
  */
 export function checkSkillVersions(root) {
   const base = root || ROOT;
   const mismatches = [];
+  const seen = new Set(); // dedup by installPath
+
+  // 1. Check default ~/.agents/skills/ (legacy path)
   for (const name of SKILLS) {
     const installPath = resolve(INSTALLED_BASE, name, 'SKILL.md');
     const bundledPath = resolve(base, 'skills', name, 'SKILL.md');
+    if (!existsSync(installPath) || !existsSync(bundledPath)) continue;
+    const installed = extractSkillVersion(installPath);
+    const bundled = extractSkillVersion(bundledPath);
+    if (!installed || !bundled) continue;
+    if (semverGt(bundled, installed)) {
+      mismatches.push({ name, installed, bundled, installPath, bundledPath });
+    }
+    seen.add(installPath);
+  }
 
-    if (!existsSync(installPath)) continue;
+  // 2. Check agent-specific paths from config
+  const agentRecords = getInstalledSkillAgents();
+  for (const record of agentRecords) {
+    const installPath = record.path;
+    if (!installPath || seen.has(installPath)) continue;
+    seen.add(installPath);
+
+    const skillName = record.skill || 'mindos';
+    const bundledPath = resolve(base, 'skills', skillName, 'SKILL.md');
     if (!existsSync(bundledPath)) continue;
 
+    if (!existsSync(installPath)) {
+      // Path doesn't exist — skill not installed yet or was removed.
+      // Don't clean up the record: user may install the skill later,
+      // and we want to auto-update it when they do.
+      continue;
+    }
+
     const installed = extractSkillVersion(installPath);
     const bundled = extractSkillVersion(bundledPath);
-
     if (!installed || !bundled) continue;
     if (semverGt(bundled, installed)) {
-      mismatches.push({ name, installed, bundled, installPath, bundledPath });
+      mismatches.push({
+        name: skillName,
+        installed,
+        bundled,
+        installPath,
+        bundledPath,
+        agent: record.agent,
+      });
     }
   }
+
   return mismatches;
 }
 
 /**
  * Copy bundled SKILL.md over the installed version.
+ * Creates parent directory if needed.
  */
 export function updateSkill(bundledPath, installPath) {
+  const dir = dirname(installPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   copyFileSync(bundledPath, installPath);
 }
 
 /**
  * Print skill update hints and optionally prompt user to update.
- *
- * - TTY + not daemon: interactive readline prompt (default Y)
- * - Non-TTY / daemon / MINDOS_NO_SKILL_CHECK=1: one-line hint, no block
  */
 export async function promptSkillUpdate(mismatches) {
   if (!mismatches || mismatches.length === 0) return;
 
-  // Print mismatch info
   for (const m of mismatches) {
-    console.log(`\n  ${yellow('⬆')}  Skill ${bold(m.name)}: ${dim(`v${m.installed}`)} → ${cyan(`v${m.bundled}`)}`);
+    const agentLabel = m.agent ? ` (${m.agent})` : '';
+    console.log(`\n  ${yellow('⬆')}  Skill ${bold(m.name)}${agentLabel}: ${dim(`v${m.installed}`)} → ${cyan(`v${m.bundled}`)}`);
   }
 
   // Non-interactive mode: just print hint
@@ -92,15 +188,14 @@ export async function promptSkillUpdate(mismatches) {
     return;
   }
 
-  // Interactive prompt (10s timeout to avoid blocking startup indefinitely)
+  // Interactive prompt (10s timeout)
   return new Promise((res) => {
     let done = false;
     const finish = () => { if (!done) { done = true; res(); } };
 
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     const timer = setTimeout(() => { rl.close(); finish(); }, 10_000);
-
-    rl.on('close', finish); // handles broken pipe / EOF
+    rl.on('close', finish);
 
     rl.question(`     Update skill${mismatches.length > 1 ? 's' : ''}? ${dim('(Y/n)')} `, (answer) => {
       clearTimeout(timer);
@@ -110,7 +205,8 @@ export async function promptSkillUpdate(mismatches) {
         for (const m of mismatches) {
           try {
             updateSkill(m.bundledPath, m.installPath);
-            console.log(`  ${green('✓')} ${dim(`Updated ${m.name} → v${m.bundled}`)}`);
+            const agentLabel = m.agent ? ` (${m.agent})` : '';
+            console.log(`  ${green('✓')} ${dim(`Updated ${m.name}${agentLabel} → v${m.bundled}`)}`);
           } catch (err) {
             console.log(`  ${yellow('!')} ${dim(`Failed to update ${m.name}: ${err.message}`)}`);
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.6.41",
+  "version": "0.6.43",
   "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/setup.js

@@ -1314,10 +1314,38 @@ async function main() {
     console.log(c.dim(t('syncLater')));
   }
 
+  // ── Register CLI globally if not already in PATH ────────────────────────────
+  ensureCliInPath();
+
   const installDaemon = startMode === 'daemon' || process.argv.includes('--install-daemon');
   finish(mindDir, config.startMode, config.mcpPort, config.authToken, installDaemon, needsRestart, resumeCfg.port ?? 3456);
 }
 
+function ensureCliInPath() {
+  try {
+    execSync('command -v mindos', { stdio: 'ignore' });
+    return; // already in PATH (npm -g install or previous link)
+  } catch { /* not found */ }
+
+  // Only auto-register for source/dev installations.
+  // Desktop (Electron) manages its own process; npx is ephemeral.
+  const isDesktop = !!(process.env.ELECTRON_RUN_AS_NODE || process.env.MINDOS_DESKTOP);
+  const isDevInstall = existsSync(resolve(ROOT, '.git'));
+  if (isDesktop || !isDevInstall) return;
+
+  write('\n');
+  try {
+    execSync('npm link', { cwd: ROOT, stdio: 'ignore' });
+    write(c.green(uiLang === 'zh'
+      ? '  ✔ mindos CLI 已注册到全局路径\n'
+      : '  ✔ mindos CLI registered globally\n'));
+  } catch {
+    write(c.yellow(uiLang === 'zh'
+      ? '  ⚠ 无法自动注册 CLI，请手动运行：npm link\n'
+      : '  ⚠ Could not register CLI automatically. Run manually: npm link\n'));
+  }
+}
+
 function getLocalIP() {
   for (const ifaces of Object.values(networkInterfaces())) {
     for (const iface of ifaces) {