@geminilight/mindos 0.5.63 → 0.5.65

package/app/lib/mcp-agents.ts

@@ -33,6 +33,13 @@ export interface AgentDef {
   presenceDirs?: string[];
 }
 
+export type SkillInstallMode = 'universal' | 'additional' | 'unsupported';
+export interface SkillAgentRegistration {
+  mode: SkillInstallMode;
+  /** npx skills `-a` value for additional agents. */
+  skillAgentName?: string;
+}
+
 export const MCP_AGENTS: Record<string, AgentDef> = {
   'claude-code': {
     name: 'Claude Code',
@@ -161,6 +168,15 @@ export const MCP_AGENTS: Record<string, AgentDef> = {
     presenceCli: 'qwen',
     presenceDirs: ['~/.qwen/'],
   },
+  'qoder': {
+    name: 'Qoder',
+    project: null,
+    global: '~/.qoder.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceCli: 'qoder',
+    presenceDirs: ['~/.qoder/', '~/.qoder.json'],
+  },
   'trae-cn': {
     name: 'Trae CN',
     project: '.trae/mcp.json',
@@ -215,6 +231,259 @@ export const MCP_AGENTS: Record<string, AgentDef> = {
   },
 };
 
+/**
+ * Skill-install registry keyed by MCP agent key.
+ * Keep in sync with docs and bin/lib/mcp-agents.js.
+ */
+export const SKILL_AGENT_REGISTRY: Record<string, SkillAgentRegistration> = {
+  'claude-code': { mode: 'additional', skillAgentName: 'claude-code' },
+  'cursor': { mode: 'universal' },
+  'windsurf': { mode: 'additional', skillAgentName: 'windsurf' },
+  'cline': { mode: 'universal' },
+  'trae': { mode: 'additional', skillAgentName: 'trae' },
+  'gemini-cli': { mode: 'universal' },
+  'openclaw': { mode: 'additional', skillAgentName: 'openclaw' },
+  'codebuddy': { mode: 'additional', skillAgentName: 'codebuddy' },
+  'iflow-cli': { mode: 'additional', skillAgentName: 'iflow-cli' },
+  'kimi-cli': { mode: 'universal' },
+  'opencode': { mode: 'universal' },
+  'pi': { mode: 'additional', skillAgentName: 'pi' },
+  'augment': { mode: 'additional', skillAgentName: 'augment' },
+  'qwen-code': { mode: 'additional', skillAgentName: 'qwen-code' },
+  'qoder': { mode: 'additional', skillAgentName: 'qoder' },
+  'trae-cn': { mode: 'additional', skillAgentName: 'trae-cn' },
+  'roo': { mode: 'additional', skillAgentName: 'roo' },
+  'vscode': { mode: 'universal' },
+  'codex': { mode: 'universal' },
+};
+
+export interface SkillWorkspaceProfile {
+  mode: SkillInstallMode;
+  skillAgentName?: string;
+  workspacePath: string;
+}
+
+export interface AgentRuntimeSignals {
+  hiddenRootPath: string;
+  hiddenRootPresent: boolean;
+  conversationSignal: boolean;
+  usageSignal: boolean;
+  lastActivityAt?: string;
+}
+
+export interface AgentConfiguredMcpServers {
+  servers: string[];
+  sources: string[];
+}
+
+export interface AgentInstalledSkills {
+  skills: string[];
+  sourcePath: string;
+}
+
+function resolveHiddenRootPath(agent: AgentDef): string {
+  const dirs = agent.presenceDirs ?? [];
+  for (const entry of dirs) {
+    const abs = expandHome(entry);
+    if (!fs.existsSync(abs)) continue;
+    try {
+      const stat = fs.statSync(abs);
+      if (stat.isDirectory()) return abs;
+      if (stat.isFile()) return path.dirname(abs);
+    } catch {
+      continue;
+    }
+  }
+  return path.dirname(expandHome(agent.global));
+}
+
+function readDirectoryEntries(dir: string): fs.Dirent[] {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function detectSignalsFromName(name: string): { conversation: boolean; usage: boolean } {
+  const lowered = name.toLowerCase();
+  return {
+    conversation: /(session|history|conversation|chat|transcript)/.test(lowered),
+    usage: /(usage|token|cost|billing|metric|analytics)/.test(lowered),
+  };
+}
+
+function readNestedRecord(obj: Record<string, unknown>, nestedPath: string): Record<string, unknown> | null {
+  const parts = nestedPath.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];
+  }
+  if (!current || typeof current !== 'object') return null;
+  return current as Record<string, unknown>;
+}
+
+function parseJsonServerNames(content: string, configKey: string, globalNestedKey?: string): string[] {
+  try {
+    const config = parseJsonc(content) as Record<string, unknown>;
+    const section = globalNestedKey
+      ? readNestedRecord(config, globalNestedKey)
+      : (config[configKey] as unknown);
+    if (!section || typeof section !== 'object') return [];
+    return Object.keys(section as Record<string, unknown>);
+  } catch {
+    return [];
+  }
+}
+
+function parseTomlServerNames(content: string, sectionKey: string): string[] {
+  const names = new Set<string>();
+  const lines = content.split('\n');
+  let inRootSection = false;
+  const sectionPrefix = `${sectionKey}.`;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      const section = trimmed.slice(1, -1).trim();
+      inRootSection = section === sectionKey;
+      if (section.startsWith(sectionPrefix)) {
+        const name = section.slice(sectionPrefix.length).split('.')[0]?.trim();
+        if (name) names.add(name);
+      }
+      continue;
+    }
+    if (!inRootSection) continue;
+    const kv = trimmed.match(/^([a-zA-Z0-9_-]+)\s*=\s*/);
+    if (!kv) continue;
+    const name = kv[1]?.trim();
+    if (name) names.add(name);
+  }
+  return [...names];
+}
+
+export function resolveSkillWorkspaceProfile(agentKey: string): SkillWorkspaceProfile {
+  const registration = SKILL_AGENT_REGISTRY[agentKey] ?? { mode: 'unsupported' as const };
+  if (registration.mode === 'universal') {
+    return { mode: registration.mode, workspacePath: expandHome('~/.agents/skills') };
+  }
+  const agent = MCP_AGENTS[agentKey];
+  const root = agent ? resolveHiddenRootPath(agent) : expandHome('~/.agents');
+  const workspacePath = path.join(root, 'skills');
+  return {
+    mode: registration.mode,
+    skillAgentName: registration.skillAgentName,
+    workspacePath,
+  };
+}
+
+export function detectAgentConfiguredMcpServers(agentKey: string): AgentConfiguredMcpServers {
+  const agent = MCP_AGENTS[agentKey];
+  if (!agent) return { servers: [], sources: [] };
+  const serverSet = new Set<string>();
+  const sources: string[] = [];
+  for (const [scopeType, cfgPath] of [['global', agent.global], ['project', agent.project]] as Array<[string, string | null]>) {
+    if (!cfgPath) continue;
+    const absPath = expandHome(cfgPath);
+    if (!fs.existsSync(absPath)) continue;
+    try {
+      const content = fs.readFileSync(absPath, 'utf-8');
+      const nestedPath = scopeType === 'global' ? agent.globalNestedKey : undefined;
+      const names =
+        agent.format === 'toml'
+          ? parseTomlServerNames(content, agent.key)
+          : parseJsonServerNames(content, agent.key, nestedPath);
+      for (const name of names) serverSet.add(name);
+      sources.push(`${scopeType}:${cfgPath}`);
+    } catch {
+      continue;
+    }
+  }
+  return {
+    servers: [...serverSet].sort((a, b) => a.localeCompare(b)),
+    sources,
+  };
+}
+
+export function detectAgentInstalledSkills(agentKey: string): AgentInstalledSkills {
+  const profile = resolveSkillWorkspaceProfile(agentKey);
+  const sourcePath = profile.workspacePath;
+  if (!fs.existsSync(sourcePath)) return { skills: [], sourcePath };
+  let entries: fs.Dirent[] = [];
+  try {
+    entries = fs.readdirSync(sourcePath, { withFileTypes: true });
+  } catch {
+    return { skills: [], sourcePath };
+  }
+  const skills = entries
+    .filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith('.'))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b));
+  return { skills, sourcePath };
+}
+
+export function detectAgentRuntimeSignals(agentKey: string): AgentRuntimeSignals {
+  const agent = MCP_AGENTS[agentKey];
+  if (!agent) {
+    return {
+      hiddenRootPath: '',
+      hiddenRootPresent: false,
+      conversationSignal: false,
+      usageSignal: false,
+    };
+  }
+  const hiddenRootPath = resolveHiddenRootPath(agent);
+  if (!fs.existsSync(hiddenRootPath)) {
+    return {
+      hiddenRootPath,
+      hiddenRootPresent: false,
+      conversationSignal: false,
+      usageSignal: false,
+    };
+  }
+
+  const maxDepth = 3;
+  const maxEntries = 300;
+  let scanned = 0;
+  let conversationSignal = false;
+  let usageSignal = false;
+  let latestMtime = 0;
+  const queue: Array<{ dir: string; depth: number }> = [{ dir: hiddenRootPath, depth: 0 }];
+
+  while (queue.length > 0 && scanned < maxEntries) {
+    const current = queue.shift();
+    if (!current) break;
+    const entries = readDirectoryEntries(current.dir);
+    for (const entry of entries) {
+      if (scanned >= maxEntries) break;
+      scanned += 1;
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      const fullPath = path.join(current.dir, entry.name);
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.mtimeMs > latestMtime) latestMtime = stat.mtimeMs;
+        const signals = detectSignalsFromName(entry.name);
+        if (signals.conversation) conversationSignal = true;
+        if (signals.usage) usageSignal = true;
+        if (entry.isDirectory() && current.depth < maxDepth) {
+          queue.push({ dir: fullPath, depth: current.depth + 1 });
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return {
+    hiddenRootPath,
+    hiddenRootPresent: true,
+    conversationSignal,
+    usageSignal,
+    lastActivityAt: latestMtime > 0 ? new Date(latestMtime).toISOString() : undefined,
+  };
+}
+
 /* ── MindOS MCP Install Detection ──────────────────────────────────────── */
 
 export function detectInstalled(agentKey: string): { installed: boolean; scope?: string; transport?: string; configPath?: string } {
@@ -238,9 +507,11 @@ export function detectInstalled(agentKey: string): { installed: boolean; scope?:
       } else {
         // JSON format (default)
         const config = parseJsonc(content);
-        const servers = config[agent.key];
+        const servers = scopeType === 'global' && agent.globalNestedKey
+          ? readNestedRecord(config as Record<string, unknown>, agent.globalNestedKey)
+          : (config[agent.key] as Record<string, unknown> | undefined);
         if (servers?.mindos) {
-          const entry = servers.mindos;
+          const entry = servers.mindos as Record<string, unknown>;
           const transport = entry.type === 'stdio' ? 'stdio' : entry.url ? 'http' : 'unknown';
           return { installed: true, scope: scopeType, transport, configPath: cfgPath };
         }

package/app/lib/renderers/index.ts

@@ -7,7 +7,6 @@ import { manifest as agentInspector } from '@/components/renderers/agent-inspect
 import { manifest as backlinks } from '@/components/renderers/backlinks/manifest';
 import { manifest as config } from '@/components/renderers/config/manifest';
 import { manifest as csv } from '@/components/renderers/csv/manifest';
-import { manifest as diff } from '@/components/renderers/diff/manifest';
 import { manifest as summary } from '@/components/renderers/summary/manifest';
 import { manifest as timeline } from '@/components/renderers/timeline/manifest';
 import { manifest as todo } from '@/components/renderers/todo/manifest';
@@ -15,7 +14,7 @@ import { manifest as workflow } from '@/components/renderers/workflow/manifest';
 import { manifest as graph } from '@/components/renderers/graph/manifest';
 
 const manifests = [
-  agentInspector, backlinks, config, csv, diff, summary, timeline, todo, workflow, graph,
+  agentInspector, backlinks, config, csv, summary, timeline, todo, workflow, graph,
 ];
 
 for (const m of manifests) {

package/app/lib/renderers/registry.ts

@@ -16,6 +16,11 @@ export interface RendererDefinition {
   tags: string[];
   builtin: boolean;      // true = ships with MindOS; false = user-installed (future)
   core?: boolean;        // true = default renderer for a file type, cannot be disabled by user
+  /**
+   * App-builtin feature (not a user-facing plugin).
+   * When true, keep renderer functional but hide from Plugins surfaces.
+   */
+  appBuiltinFeature?: boolean;
   entryPath?: string;    // canonical entry file shown on home page (e.g. 'TODO.md')
   match: (ctx: Pick<RendererContext, 'filePath' | 'extension'>) => boolean;
   // Provide either `component` (eager) or `load` (lazy). Prefer `load` for code-splitting.
@@ -78,3 +83,8 @@ export function resolveRenderer(
 export function getAllRenderers(): RendererDefinition[] {
   return registry;
 }
+
+/** User-facing plugins only (exclude app-builtin features like CSV). */
+export function getPluginRenderers(): RendererDefinition[] {
+  return registry.filter((r) => !r.appBuiltinFeature);
+}

package/app/lib/types.ts

@@ -37,6 +37,8 @@ export type MessagePart = TextPart | ToolCallPart | ReasoningPart;
 export interface Message {
   role: 'user' | 'assistant';
   content: string;
+  /** Unix timestamp in milliseconds when this message was created */
+  timestamp?: number;
   /** Structured parts for assistant messages (tool calls + text segments) */
   parts?: MessagePart[];
 }

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/bin/lib/mcp-agents.js

@@ -26,16 +26,6 @@ export const MCP_AGENTS = {
     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',
@@ -94,11 +84,11 @@ export const MCP_AGENTS = {
   'codebuddy': {
     name: 'CodeBuddy',
     project: null,
-    global: '~/.claude-internal/.claude.json',
+    global: '~/.codebuddy/mcp.json',
     key: 'mcpServers',
     preferredTransport: 'stdio',
-    presenceCli: 'claude-internal',
-    presenceDirs: ['~/.claude-internal/'],
+    presenceCli: 'codebuddy',
+    presenceDirs: ['~/.codebuddy/'],
   },
   'iflow-cli': {
     name: 'iFlow CLI',
@@ -154,6 +144,15 @@ export const MCP_AGENTS = {
     presenceCli: 'qwen',
     presenceDirs: ['~/.qwen/'],
   },
+  'qoder': {
+    name: 'Qoder',
+    project: null,
+    global: '~/.qoder.json',
+    key: 'mcpServers',
+    preferredTransport: 'stdio',
+    presenceCli: 'qoder',
+    presenceDirs: ['~/.qoder/', '~/.qoder.json'],
+  },
   'trae-cn': {
     name: 'Trae CN',
     project: '.trae/mcp.json',
@@ -183,6 +182,32 @@ export const MCP_AGENTS = {
   },
 };
 
+/**
+ * Skill-install registry keyed by MCP agent key.
+ * Keep in sync with app/lib/mcp-agents.ts.
+ */
+export const SKILL_AGENT_REGISTRY = {
+  'claude-code': { mode: 'additional', skillAgentName: 'claude-code' },
+  'cursor': { mode: 'universal' },
+  'windsurf': { mode: 'additional', skillAgentName: 'windsurf' },
+  'cline': { mode: 'universal' },
+  'trae': { mode: 'additional', skillAgentName: 'trae' },
+  'gemini-cli': { mode: 'universal' },
+  'openclaw': { mode: 'additional', skillAgentName: 'openclaw' },
+  'codebuddy': { mode: 'additional', skillAgentName: 'codebuddy' },
+  'iflow-cli': { mode: 'additional', skillAgentName: 'iflow-cli' },
+  'kimi-cli': { mode: 'universal' },
+  'opencode': { mode: 'universal' },
+  'pi': { mode: 'additional', skillAgentName: 'pi' },
+  'augment': { mode: 'additional', skillAgentName: 'augment' },
+  'qwen-code': { mode: 'additional', skillAgentName: 'qwen-code' },
+  'qoder': { mode: 'additional', skillAgentName: 'qoder' },
+  'trae-cn': { mode: 'additional', skillAgentName: 'trae-cn' },
+  'roo': { mode: 'additional', skillAgentName: 'roo' },
+  'vscode': { mode: 'universal' },
+  'codex': { mode: 'universal' },
+};
+
 export function detectAgentPresence(agentKey) {
   const agent = MCP_AGENTS[agentKey];
   if (!agent) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.63",
+  "version": "0.5.65",
   "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/migrate-agent-audit-log.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * One-shot migration helper:
+ * Import legacy Agent-Audit.md and .agent-log.json into .mindos/agent-audit-log.json.
+ *
+ * Usage:
+ *   node scripts/migrate-agent-audit-log.js --mind-root /abs/path/to/mindRoot
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const MAX_EVENTS = 1000;
+
+function parseArgs(argv) {
+  let mindRoot = '';
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--mind-root') {
+      mindRoot = argv[i + 1] || '';
+      i += 1;
+    }
+  }
+  return { mindRoot };
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function validIso(ts) {
+  if (typeof ts !== 'string') return nowIso();
+  const ms = new Date(ts).getTime();
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : nowIso();
+}
+
+function normalizeMessage(message) {
+  if (typeof message !== 'string') return undefined;
+  return message.slice(0, 2000);
+}
+
+function readJson(file, fallback) {
+  try {
+    if (!fs.existsSync(file)) return fallback;
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function parseMdBlocks(raw) {
+  const blocks = [];
+  const re = /```agent-op\s*\n([\s\S]*?)```/g;
+  let match;
+  while ((match = re.exec(raw)) !== null) {
+    try {
+      blocks.push(JSON.parse(match[1].trim()));
+    } catch {
+      // Keep migration best-effort.
+    }
+  }
+  return blocks;
+}
+
+function parseJsonLines(raw) {
+  const lines = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    try {
+      lines.push(JSON.parse(trimmed));
+    } catch {
+      // Ignore malformed line.
+    }
+  }
+  return lines;
+}
+
+function toEvent(entry, op, idx) {
+  const tool = typeof entry?.tool === 'string' && entry.tool.trim() ? entry.tool.trim() : 'unknown-tool';
+  return {
+    id: `legacy-script-${Date.now().toString(36)}-${idx.toString(36)}`,
+    ts: validIso(entry?.ts),
+    tool,
+    params: entry?.params && typeof entry.params === 'object' ? entry.params : {},
+    result: entry?.result === 'error' ? 'error' : 'ok',
+    message: normalizeMessage(entry?.message),
+    durationMs: typeof entry?.durationMs === 'number' ? entry.durationMs : undefined,
+    op,
+  };
+}
+
+function main() {
+  const { mindRoot } = parseArgs(process.argv.slice(2));
+  if (!mindRoot) {
+    console.error('Missing --mind-root');
+    process.exit(1);
+  }
+  const root = path.resolve(mindRoot);
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    console.error('Invalid mind root:', root);
+    process.exit(1);
+  }
+
+  const legacyMd = path.join(root, 'Agent-Audit.md');
+  const legacyJsonl = path.join(root, '.agent-log.json');
+  if (!fs.existsSync(legacyMd) && !fs.existsSync(legacyJsonl)) {
+    console.log('No legacy Agent-Audit.md or .agent-log.json found. Nothing to migrate.');
+    return;
+  }
+
+  const logDir = path.join(root, '.mindos');
+  const logFile = path.join(logDir, 'agent-audit-log.json');
+  const state = readJson(logFile, {
+    version: 1,
+    events: [],
+    legacy: { mdImportedCount: 0, jsonlImportedCount: 0, lastImportedAt: null },
+  });
+  const baseEvents = Array.isArray(state.events) ? state.events : [];
+  const legacy = {
+    mdImportedCount: Number(state?.legacy?.mdImportedCount || 0),
+    jsonlImportedCount: Number(state?.legacy?.jsonlImportedCount || 0),
+    lastImportedAt: typeof state?.legacy?.lastImportedAt === 'string' ? state.legacy.lastImportedAt : null,
+  };
+
+  const imported = [];
+
+  if (fs.existsSync(legacyMd)) {
+    const blocks = parseMdBlocks(fs.readFileSync(legacyMd, 'utf-8'));
+    if (blocks.length > legacy.mdImportedCount) {
+      const incoming = blocks.slice(legacy.mdImportedCount);
+      imported.push(...incoming.map((entry, idx) => toEvent(entry, 'legacy_agent_audit_md_import', idx)));
+      legacy.mdImportedCount = blocks.length;
+      legacy.lastImportedAt = nowIso();
+    }
+    if (blocks.length > 0) fs.rmSync(legacyMd, { force: true });
+  }
+
+  if (fs.existsSync(legacyJsonl)) {
+    const lines = parseJsonLines(fs.readFileSync(legacyJsonl, 'utf-8'));
+    if (lines.length > legacy.jsonlImportedCount) {
+      const incoming = lines.slice(legacy.jsonlImportedCount);
+      imported.push(...incoming.map((entry, idx) => toEvent(entry, 'legacy_agent_log_jsonl_import', idx)));
+      legacy.jsonlImportedCount = lines.length;
+      legacy.lastImportedAt = nowIso();
+    }
+    if (lines.length > 0) fs.rmSync(legacyJsonl, { force: true });
+  }
+
+  if (imported.length === 0) {
+    console.log('No new legacy entries to import.');
+    return;
+  }
+
+  const merged = [...baseEvents, ...imported]
+    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
+    .slice(0, MAX_EVENTS);
+
+  const next = {
+    version: 1,
+    events: merged,
+    legacy,
+  };
+
+  fs.mkdirSync(logDir, { recursive: true });
+  fs.writeFileSync(logFile, JSON.stringify(next, null, 2), 'utf-8');
+  console.log(`Imported ${imported.length} legacy entry(s) into ${logFile}`);
+}
+
+main();
+