@geminilight/mindos 0.5.29 → 0.5.32

package/app/components/panels/PluginsPanel.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import { useRouter } from 'next/navigation';
 import { getAllRenderers, isRendererEnabled, setRendererEnabled, loadDisabledState } from '@/lib/renderers/registry';
 import { Toggle } from '../settings/Primitives';
@@ -16,6 +16,7 @@ interface PluginsPanelProps {
 export default function PluginsPanel({ active, maximized, onMaximize }: PluginsPanelProps) {
   const [mounted, setMounted] = useState(false);
   const [, forceUpdate] = useState(0);
+  const [existingFiles, setExistingFiles] = useState<Set<string>>(new Set());
   const router = useRouter();
   const { t } = useLocale();
   const p = t.panels.plugins;
@@ -26,14 +27,38 @@ export default function PluginsPanel({ active, maximized, onMaximize }: PluginsP
     setMounted(true);
   }, []);
 
+  // Check which entry files exist (once on mount + when active)
+  useEffect(() => {
+    if (!mounted || !active) return;
+    const entryPaths = getAllRenderers()
+      .map(r => r.entryPath)
+      .filter((p): p is string => !!p);
+    if (entryPaths.length === 0) return;
+
+    // Check each file via HEAD-like GET — lightweight
+    Promise.all(
+      entryPaths.map(path =>
+        fetch(`/api/file?path=${encodeURIComponent(path)}`, { method: 'GET' })
+          .then(r => r.ok ? path : null)
+          .catch(() => null)
+      )
+    ).then(results => {
+      setExistingFiles(new Set(results.filter((p): p is string => p !== null)));
+    });
+  }, [mounted, active]);
+
   const renderers = mounted ? getAllRenderers() : [];
   const enabledCount = mounted ? renderers.filter(r => isRendererEnabled(r.id)).length : 0;
 
-  const handleToggle = (id: string, enabled: boolean) => {
+  const handleToggle = useCallback((id: string, enabled: boolean) => {
     setRendererEnabled(id, enabled);
     forceUpdate(n => n + 1);
     window.dispatchEvent(new Event('renderer-state-changed'));
-  };
+  }, []);
+
+  const handleOpen = useCallback((entryPath: string) => {
+    router.push(`/view/${entryPath.split('/').map(encodeURIComponent).join('/')}`);
+  }, [router]);
 
   return (
     <div className={`flex flex-col h-full ${active ? '' : 'hidden'}`}>
@@ -49,48 +74,80 @@ export default function PluginsPanel({ active, maximized, onMaximize }: PluginsP
         )}
         {renderers.map(r => {
           const enabled = isRendererEnabled(r.id);
+          const fileExists = r.entryPath ? existingFiles.has(r.entryPath) : false;
+          const canOpen = enabled && r.entryPath && fileExists;
+
           return (
             <div
               key={r.id}
-              className="px-4 py-3 border-b border-border/50 hover:bg-muted/30 transition-colors"
+              className={`
+                px-4 py-3 border-b border-border/50 transition-colors
+                ${canOpen ? 'cursor-pointer hover:bg-muted/40' : 'hover:bg-muted/20'}
+                ${!enabled ? 'opacity-50' : ''}
+              `}
+              onClick={canOpen ? () => handleOpen(r.entryPath!) : undefined}
+              role={canOpen ? 'link' : undefined}
             >
-              {/* Top row: icon + name + toggle */}
+              {/* Top row: status dot + icon + name + toggle */}
               <div className="flex items-center justify-between gap-2">
                 <div className="flex items-center gap-2.5 min-w-0">
-                  <span className="text-base shrink-0">{r.icon}</span>
+                  {/* Status dot */}
+                  <span
+                    className="w-1.5 h-1.5 rounded-full shrink-0"
+                    style={{
+                      background: !enabled
+                        ? 'var(--muted-foreground)'
+                        : canOpen
+                          ? 'var(--success)'
+                          : 'var(--border)',
+                    }}
+                    title={
+                      !enabled
+                        ? p.disabled ?? 'Disabled'
+                        : canOpen
+                          ? p.ready ?? 'Ready'
+                          : p.noFile ?? 'File not found'
+                    }
+                  />
+                  <span className="text-base shrink-0" suppressHydrationWarning>{r.icon}</span>
                   <span className="text-sm font-medium text-foreground truncate">{r.name}</span>
                   {r.core && (
                     <span className="text-2xs px-1.5 py-0.5 rounded bg-muted text-muted-foreground shrink-0">{p.core}</span>
                   )}
                 </div>
-                <Toggle
-                  checked={enabled}
-                  onChange={(v) => handleToggle(r.id, v)}
-                  size="sm"
-                  disabled={r.core}
-                  title={r.core ? p.coreDisabled : undefined}
-                />
+                {/* Toggle — stop propagation to prevent row click */}
+                <div onClick={e => e.stopPropagation()}>
+                  <Toggle
+                    checked={enabled}
+                    onChange={(v) => handleToggle(r.id, v)}
+                    size="sm"
+                    disabled={r.core}
+                    title={r.core ? p.coreDisabled : undefined}
+                  />
+                </div>
               </div>
 
               {/* Description */}
-              <p className="mt-1 text-xs text-muted-foreground leading-relaxed pl-[30px]">
+              <p className="mt-1 text-xs text-muted-foreground leading-relaxed pl-[34px]">
                 {r.description}
               </p>
 
-              {/* Tags + entry path */}
-              <div className="mt-1.5 flex items-center gap-1.5 pl-[30px] flex-wrap">
+              {/* Tags + status hint */}
+              <div className="mt-1.5 flex items-center gap-1.5 pl-[34px] flex-wrap">
                 {r.tags.slice(0, 3).map(tag => (
                   <span key={tag} className="text-2xs px-1.5 py-0.5 rounded-full bg-muted/60 text-muted-foreground">
                     {tag}
                   </span>
                 ))}
-                {r.entryPath && enabled && (
-                  <button
-                    onClick={() => router.push(`/view/${r.entryPath!.split('/').map(encodeURIComponent).join('/')}`)}
-                    className="text-2xs px-1.5 py-0.5 rounded-full text-[var(--amber)] hover:bg-[var(--amber-dim)] transition-colors focus-visible:ring-2 focus-visible:ring-ring"
-                  >
+                {r.entryPath && enabled && !fileExists && (
+                  <span className="text-2xs" style={{ color: 'var(--amber)' }}>
+                    {(p.createFile ?? 'Create {file}').replace('{file}', r.entryPath)}
+                  </span>
+                )}
+                {canOpen && (
+                  <span className="text-2xs" style={{ color: 'var(--amber)' }}>
                     → {r.entryPath}
-                  </button>
+                  </span>
                 )}
               </div>
             </div>

package/app/components/settings/McpSkillsSection.tsx

@@ -6,6 +6,7 @@ import {
   Trash2, Plus, X, Search, Pencil,
 } from 'lucide-react';
 import { apiFetch } from '@/lib/api';
+import { useMcpDataOptional } from '@/hooks/useMcpData';
 import { Toggle } from './Primitives';
 import dynamic from 'next/dynamic';
 import type { SkillInfo, McpSkillsSectionProps } from './types';
@@ -83,6 +84,7 @@ const SKILL_TEMPLATES: Record<string, (name: string) => string> = {
 
 export default function SkillsSection({ t }: McpSkillsSectionProps) {
   const m = t.settings?.mcp;
+  const mcp = useMcpDataOptional();
   const [skills, setSkills] = useState<SkillInfo[]>([]);
   const [loading, setLoading] = useState(true);
   const [expanded, setExpanded] = useState<string | null>(null);
@@ -131,6 +133,13 @@ export default function SkillsSection({ t }: McpSkillsSectionProps) {
   const builtinSkills = useMemo(() => filtered.filter(s => s.source === 'builtin'), [filtered]);
 
   const handleToggle = async (name: string, enabled: boolean) => {
+    // Delegate to McpProvider when available — single API call, no event storm
+    if (mcp) {
+      await mcp.toggleSkill(name, enabled);
+      setSkills(prev => prev.map(s => s.name === name ? { ...s, enabled } : s));
+      return;
+    }
+    // Fallback: direct API call (no McpProvider context)
     try {
       await apiFetch('/api/skills', {
         method: 'POST',
@@ -160,6 +169,7 @@ export default function SkillsSection({ t }: McpSkillsSectionProps) {
       if (expanded === name) setExpanded(null);
       setLoadErrors(prev => { const next = { ...prev }; delete next[name]; return next; });
       fetchSkills();
+      window.dispatchEvent(new Event('mindos:skills-changed'));
     } catch (err) {
       const msg = err instanceof Error ? err.message : 'Failed to delete skill';
       console.error('handleDelete error:', msg);
@@ -212,6 +222,7 @@ export default function SkillsSection({ t }: McpSkillsSectionProps) {
       setFullContent(prev => ({ ...prev, [name]: editContent }));
       setEditing(null);
       fetchSkills(); // refresh description from updated frontmatter
+      window.dispatchEvent(new Event('mindos:skills-changed'));
     } catch (err: unknown) {
       setEditError(err instanceof Error ? err.message : 'Failed to save skill');
     } finally {
@@ -247,6 +258,7 @@ export default function SkillsSection({ t }: McpSkillsSectionProps) {
       setNewName('');
       setNewContent('');
       fetchSkills();
+      window.dispatchEvent(new Event('mindos:skills-changed'));
     } catch (err: unknown) {
       setCreateError(err instanceof Error ? err.message : 'Failed to create skill');
     } finally {

package/app/components/settings/McpTab.tsx

@@ -1,8 +1,6 @@
-import { useState, useEffect, useCallback } from 'react';
 import { Loader2 } from 'lucide-react';
-import { apiFetch } from '@/lib/api';
-import type { McpStatus, AgentInfo, McpTabProps } from './types';
-import ServerStatus from './McpServerStatus';
+import { useMcpDataOptional } from '@/hooks/useMcpData';
+import type { McpTabProps } from './types';
 import AgentInstall from './McpAgentInstall';
 import SkillsSection from './McpSkillsSection';
 
@@ -12,25 +10,10 @@ export type { McpStatus, AgentInfo, SkillInfo, McpTabProps } from './types';
 /* ── Main McpTab ───────────────────────────────────────────────── */
 
 export function McpTab({ t }: McpTabProps) {
-  const [mcpStatus, setMcpStatus] = useState<McpStatus | null>(null);
-  const [agents, setAgents] = useState<AgentInfo[]>([]);
-  const [loading, setLoading] = useState(true);
-
-  const fetchAll = useCallback(async () => {
-    try {
-      const [statusData, agentsData] = await Promise.all([
-        apiFetch<McpStatus>('/api/mcp/status'),
-        apiFetch<{ agents: AgentInfo[] }>('/api/mcp/agents'),
-      ]);
-      setMcpStatus(statusData);
-      setAgents(agentsData.agents);
-    } catch { /* ignore */ }
-    setLoading(false);
-  }, []);
-
-  useEffect(() => { fetchAll(); }, [fetchAll]);
+  const mcp = useMcpDataOptional();
+  const m = t.settings?.mcp;
 
-  if (loading) {
+  if (!mcp || mcp.loading) {
     return (
       <div className="flex justify-center py-8">
         <Loader2 size={18} className="animate-spin text-muted-foreground" />
@@ -38,23 +21,38 @@ export function McpTab({ t }: McpTabProps) {
     );
   }
 
-  const m = t.settings?.mcp;
-
   return (
     <div className="space-y-6">
-      {/* MCP Server Status */}
-      <ServerStatus status={mcpStatus} agents={agents} t={t} />
-
-      {/* Skills */}
+      {/* Server status summary (minimal — full status is in sidebar AgentsPanel) */}
+      {mcp.status && (
+        <div className="rounded-xl border p-4 space-y-2" style={{ borderColor: 'var(--border)', background: 'var(--card)' }}>
+          <div className="flex items-center gap-2.5 text-xs">
+            <span className={`inline-block w-1.5 h-1.5 rounded-full shrink-0 ${mcp.status.running ? 'bg-success' : 'bg-muted-foreground'}`} />
+            <span className="text-foreground font-medium">
+              {mcp.status.running ? (m?.running ?? 'Running') : (m?.stopped ?? 'Stopped')}
+            </span>
+            {mcp.status.running && (
+              <>
+                <span className="text-muted-foreground">·</span>
+                <span className="font-mono text-muted-foreground">{mcp.status.endpoint}</span>
+                <span className="text-muted-foreground">·</span>
+                <span className="text-muted-foreground">{mcp.status.toolCount} tools</span>
+              </>
+            )}
+          </div>
+        </div>
+      )}
+
+      {/* Skills (full CRUD — search, edit, delete, create, language switch) */}
       <div>
         <h3 className="text-sm font-medium text-foreground mb-3">{m?.skillsTitle ?? 'Skills'}</h3>
         <SkillsSection t={t} />
       </div>
 
-      {/* Agent Configuration */}
+      {/* Batch Agent Install */}
       <div>
         <h3 className="text-sm font-medium text-foreground mb-3">{m?.agentsTitle ?? 'Agent Configuration'}</h3>
-        <AgentInstall agents={agents} t={t} onRefresh={fetchAll} />
+        <AgentInstall agents={mcp.agents} t={t} onRefresh={mcp.refresh} />
       </div>
     </div>
   );

package/app/hooks/useMcpData.tsx

@@ -0,0 +1,166 @@
+'use client';
+
+import { createContext, useContext, useState, useCallback, useEffect, useMemo, useRef, type ReactNode } from 'react';
+import { apiFetch } from '@/lib/api';
+import type { McpStatus, AgentInfo, SkillInfo } from '@/components/settings/types';
+
+/* ── Context shape ── */
+
+export interface McpContextValue {
+  status: McpStatus | null;
+  agents: AgentInfo[];
+  skills: SkillInfo[];
+  loading: boolean;
+  refresh: () => Promise<void>;
+  toggleSkill: (name: string, enabled: boolean) => Promise<void>;
+  installAgent: (key: string, opts?: { scope?: string; transport?: string }) => Promise<boolean>;
+}
+
+const McpContext = createContext<McpContextValue | null>(null);
+
+export function useMcpData(): McpContextValue {
+  const ctx = useContext(McpContext);
+  if (!ctx) throw new Error('useMcpData must be used within McpProvider');
+  return ctx;
+}
+
+/** Optional hook that returns null outside provider (for components that may or may not be wrapped) */
+export function useMcpDataOptional(): McpContextValue | null {
+  return useContext(McpContext);
+}
+
+/* ── Provider ── */
+
+const POLL_INTERVAL = 30_000;
+
+export default function McpProvider({ children }: { children: ReactNode }) {
+  const [status, setStatus] = useState<McpStatus | null>(null);
+  const [agents, setAgents] = useState<AgentInfo[]>([]);
+  const [skills, setSkills] = useState<SkillInfo[]>([]);
+  const [loading, setLoading] = useState(true);
+  const abortRef = useRef<AbortController | null>(null);
+  // Ref for agents to avoid stale closure in installAgent
+  const agentsRef = useRef(agents);
+  agentsRef.current = agents;
+
+  const fetchAll = useCallback(async () => {
+    // Abort any in-flight request to prevent race conditions
+    abortRef.current?.abort();
+    const ac = new AbortController();
+    abortRef.current = ac;
+
+    try {
+      const [statusData, agentsData, skillsData] = await Promise.all([
+        apiFetch<McpStatus>('/api/mcp/status', { signal: ac.signal }),
+        apiFetch<{ agents: AgentInfo[] }>('/api/mcp/agents', { signal: ac.signal }),
+        apiFetch<{ skills: SkillInfo[] }>('/api/skills', { signal: ac.signal }),
+      ]);
+      if (!ac.signal.aborted) {
+        setStatus(statusData);
+        setAgents(agentsData.agents);
+        setSkills(skillsData.skills);
+      }
+    } catch (err: unknown) {
+      // Ignore abort errors
+      if (err instanceof DOMException && err.name === 'AbortError') return;
+      // On error, keep existing data
+    } finally {
+      if (!ac.signal.aborted) setLoading(false);
+    }
+  }, []);
+
+  // Initial fetch
+  useEffect(() => {
+    fetchAll();
+    return () => abortRef.current?.abort();
+  }, [fetchAll]);
+
+  // Listen for skill changes from SkillsSection (settings CRUD — create/delete/edit)
+  // Debounce to coalesce rapid mutations into a single refresh
+  useEffect(() => {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const handler = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => fetchAll(), 500);
+    };
+    window.addEventListener('mindos:skills-changed', handler);
+    return () => {
+      clearTimeout(timer);
+      window.removeEventListener('mindos:skills-changed', handler);
+    };
+  }, [fetchAll]);
+
+  // 30s polling when visible
+  useEffect(() => {
+    let timer: ReturnType<typeof setInterval> | undefined;
+
+    const startPolling = () => {
+      timer = setInterval(() => {
+        if (document.visibilityState === 'visible') fetchAll();
+      }, POLL_INTERVAL);
+    };
+
+    startPolling();
+    return () => clearInterval(timer);
+  }, [fetchAll]);
+
+  const refresh = useCallback(async () => {
+    await fetchAll();
+  }, [fetchAll]);
+
+  const toggleSkill = useCallback(async (name: string, enabled: boolean) => {
+    // Optimistic update
+    setSkills(prev => prev.map(s => s.name === name ? { ...s, enabled } : s));
+    try {
+      await apiFetch('/api/skills', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'toggle', name, enabled }),
+      });
+    } catch {
+      // Revert on failure
+      setSkills(prev => prev.map(s => s.name === name ? { ...s, enabled: !enabled } : s));
+    }
+  }, []);
+
+  const installAgent = useCallback(async (key: string, opts?: { scope?: string; transport?: string }): Promise<boolean> => {
+    const agent = agentsRef.current.find(a => a.key === key);
+    if (!agent) return false;
+
+    try {
+      const res = await apiFetch<{ results: Array<{ key: string; ok: boolean; error?: string }> }>('/api/mcp/install', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          agents: [{
+            key,
+            scope: opts?.scope ?? (agent.hasProjectScope ? 'project' : 'global'),
+            transport: opts?.transport ?? agent.preferredTransport,
+          }],
+          transport: 'auto',
+        }),
+      });
+
+      const ok = res.results?.[0]?.ok ?? false;
+      if (ok) {
+        // Refresh to pick up newly installed agent
+        await fetchAll();
+      }
+      return ok;
+    } catch {
+      return false;
+    }
+  }, [fetchAll]);
+
+  const value = useMemo<McpContextValue>(() => ({
+    status,
+    agents,
+    skills,
+    loading,
+    refresh,
+    toggleSkill,
+    installAgent,
+  }), [status, agents, skills, loading, refresh, toggleSkill, installAgent]);
+
+  return <McpContext.Provider value={value}>{children}</McpContext.Provider>;
+}

package/app/lib/api.ts

@@ -29,14 +29,30 @@ export async function apiFetch<T>(url: string, opts: ApiFetchOptions = {}): Prom
 
   let controller: AbortController | undefined;
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  let removeExternalAbortListener: (() => void) | undefined;
 
-  if (timeout > 0) {
+  if (timeout > 0 || externalSignal) {
     controller = new AbortController();
-    timeoutId = setTimeout(() => controller!.abort(), timeout);
   }
 
-  // Merge external signal if provided
-  const signal = externalSignal ?? controller?.signal;
+  if (timeout > 0 && controller) {
+    timeoutId = setTimeout(() => controller.abort(), timeout);
+  }
+
+  // Bridge caller-provided AbortSignal so both timeout and external cancel work.
+  if (externalSignal && controller) {
+    if (externalSignal.aborted) {
+      controller.abort();
+    } else {
+      const onAbort = () => controller?.abort();
+      externalSignal.addEventListener('abort', onAbort, { once: true });
+      removeExternalAbortListener = () => {
+        externalSignal.removeEventListener('abort', onAbort);
+      };
+    }
+  }
+
+  const signal = controller?.signal ?? externalSignal;
 
   try {
     const res = await fetch(url, { ...fetchOpts, signal });
@@ -60,5 +76,6 @@ export async function apiFetch<T>(url: string, opts: ApiFetchOptions = {}): Prom
     return (await res.json()) as T;
   } finally {
     if (timeoutId) clearTimeout(timeoutId);
+    if (removeExternalAbortListener) removeExternalAbortListener();
   }
 }

package/app/lib/i18n-en.ts

@@ -105,6 +105,20 @@ export const en = {
       connect: 'Connect',
       installing: 'Installing...',
       install: (name: string) => `Install ${name}`,
+      // Snippet section
+      copyConfig: 'Copy Config',
+      copied: 'Copied!',
+      transportLocal: 'Local',
+      transportRemote: 'Remote',
+      configPath: 'Config path',
+      noAuthWarning: 'No auth token — set in Advanced Config',
+      // Skills section
+      skillsTitle: 'Skills',
+      skillsActive: 'active',
+      builtinSkills: 'Built-in',
+      newSkill: '+ New',
+      // Footer
+      advancedConfig: 'Advanced Config →',
     },
     plugins: {
       title: 'Plugins',
@@ -113,6 +127,10 @@ export const en = {
       core: 'Core',
       coreDisabled: 'Core plugin — cannot be disabled',
       footer: 'Plugins customize how files render. Core plugins cannot be disabled.',
+      ready: 'Ready — click to open',
+      disabled: 'Disabled',
+      noFile: 'Entry file not found',
+      createFile: 'Create {file} to activate',
     },
   },
   shortcutPanel: {

package/app/lib/i18n-zh.ts

@@ -130,6 +130,20 @@ export const zh = {
       connect: '连接',
       installing: '安装中...',
       install: (name: string) => `安装 ${name}`,
+      // Snippet section
+      copyConfig: '复制配置',
+      copied: '已复制!',
+      transportLocal: '本地',
+      transportRemote: '远程',
+      configPath: '配置路径',
+      noAuthWarning: '未设置 Token — 请在高级配置中设置',
+      // Skills section
+      skillsTitle: 'Skills',
+      skillsActive: '已启用',
+      builtinSkills: '内置',
+      newSkill: '+ 新建',
+      // Footer
+      advancedConfig: '高级配置 →',
     },
     plugins: {
       title: '插件',
@@ -138,6 +152,10 @@ export const zh = {
       core: '核心',
       coreDisabled: '核心插件 — 不可禁用',
       footer: '插件用于自定义文件渲染方式。核心插件不可禁用。',
+      ready: '就绪 — 点击打开',
+      disabled: '已禁用',
+      noFile: '入口文件不存在',
+      createFile: '创建 {file} 以激活',
     },
   },
   shortcutPanel: {

package/app/lib/mcp-snippets.ts

@@ -0,0 +1,103 @@
+/**
+ * Shared MCP config snippet generation utilities.
+ * Extracted from McpServerStatus.tsx for reuse in AgentsPanel.
+ */
+
+import type { AgentInfo, McpStatus } from '@/components/settings/types';
+
+export interface ConfigSnippet {
+  /** Snippet with full token — for clipboard copy */
+  snippet: string;
+  /** Snippet with masked token — for display in UI */
+  displaySnippet: string;
+  /** Target config file path */
+  path: string;
+}
+
+export function generateStdioSnippet(agent: AgentInfo): ConfigSnippet {
+  const stdioEntry: Record<string, unknown> = { type: 'stdio', command: 'mindos', args: ['mcp'] };
+
+  if (agent.format === 'toml') {
+    const lines = [
+      `[${agent.configKey}.mindos]`,
+      `command = "mindos"`,
+      `args = ["mcp"]`,
+      '',
+      `[${agent.configKey}.mindos.env]`,
+      `MCP_TRANSPORT = "stdio"`,
+    ];
+    const s = lines.join('\n');
+    return { snippet: s, displaySnippet: s, path: agent.globalPath };
+  }
+
+  if (agent.globalNestedKey) {
+    const s = JSON.stringify({ [agent.configKey]: { mindos: stdioEntry } }, null, 2);
+    return { snippet: s, displaySnippet: s, path: agent.projectPath ?? agent.globalPath };
+  }
+
+  const s = JSON.stringify({ [agent.configKey]: { mindos: stdioEntry } }, null, 2);
+  return { snippet: s, displaySnippet: s, path: agent.globalPath };
+}
+
+export function generateHttpSnippet(
+  agent: AgentInfo,
+  endpoint: string,
+  token?: string,
+  maskedToken?: string,
+): ConfigSnippet {
+  // Full token for copy
+  const httpEntry: Record<string, unknown> = { url: endpoint };
+  if (token) httpEntry.headers = { Authorization: `Bearer ${token}` };
+
+  // Masked token for display
+  const displayEntry: Record<string, unknown> = { url: endpoint };
+  if (maskedToken) displayEntry.headers = { Authorization: `Bearer ${maskedToken}` };
+
+  const buildSnippet = (entry: Record<string, unknown>) => {
+    if (agent.format === 'toml') {
+      const lines = [
+        `[${agent.configKey}.mindos]`,
+        `type = "http"`,
+        `url = "${endpoint}"`,
+      ];
+      const authVal = (entry.headers as Record<string, string>)?.Authorization;
+      if (authVal) {
+        lines.push('');
+        lines.push(`[${agent.configKey}.mindos.headers]`);
+        lines.push(`Authorization = "${authVal}"`);
+      }
+      return lines.join('\n');
+    }
+
+    if (agent.globalNestedKey) {
+      return JSON.stringify({ [agent.configKey]: { mindos: entry } }, null, 2);
+    }
+
+    return JSON.stringify({ [agent.configKey]: { mindos: entry } }, null, 2);
+  };
+
+  return {
+    snippet: buildSnippet(httpEntry),
+    displaySnippet: buildSnippet(token ? displayEntry : httpEntry),
+    path: agent.format === 'toml'
+      ? agent.globalPath
+      : (agent.globalNestedKey ? (agent.projectPath ?? agent.globalPath) : agent.globalPath),
+  };
+}
+
+/** Generate snippet based on transport mode */
+export function generateSnippet(
+  agent: AgentInfo,
+  status: McpStatus | null,
+  transport: 'stdio' | 'http',
+): ConfigSnippet {
+  if (transport === 'stdio') {
+    return generateStdioSnippet(agent);
+  }
+  return generateHttpSnippet(
+    agent,
+    status?.endpoint ?? 'http://127.0.0.1:8781/mcp',
+    status?.authToken,
+    status?.maskedToken,
+  );
+}

package/package.json

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