@geminilight/mindos 0.6.28 → 0.6.30

package/README.md

@@ -162,11 +162,15 @@ npx skills add https://github.com/GeminiLight/MindOS --skill mindos-zh -g -y   #
 
 - **GUI Workbench**: browse, edit, search notes with unified search + AI entry (`⌘K` / `⌘/`), designed for human-AI co-creation.
 - **Built-in Agent Assistant**: converse with the knowledge base in context; edits seamlessly capture human-curated knowledge.
-- **Plugin Extensions**: multiple built-in renderer plugins — TODO Board, CSV Views, Wiki Graph, Timeline, Agent Inspector, and more.
+- **One-Click Import**: drag-and-drop files with Inline AI Organize — auto-analyzes, categorizes, and writes into the knowledge base with progress tracking and undo support.
+- **Guided Onboarding**: step-by-step first-run experience that helps new users set up their knowledge base and connect their first Agent.
+- **Plugin Extensions**: multiple built-in renderer plugins — TODO Board, CSV Views, Wiki Graph, Timeline, Workflow Editor, Agent Inspector, and more.
 
 **For Agents**
 
-- **MCP Server + Skills**: stdio + HTTP dual transport, full-lineup Agent compatible (OpenClaw, Claude Code, Cursor, etc.). Zero-config access.
+- **MCP Server + Skills**: stdio + HTTP dual transport, full-lineup Agent compatible (Claude Code, Cursor, Gemini CLI, etc.). Zero-config access.
+- **ACP / A2A Protocols**: Agent Communication Protocol for inter-agent discovery, delegation, and orchestration. Phase 1 live with Agent Card discovery + JSON-RPC messaging.
+- **Workflow Orchestration**: YAML-based workflow editor with step execution engine — define, edit, and run multi-step agent workflows visually.
 - **Structured Templates**: pre-set directory structures for Profiles, Workflows, Configurations, etc., to jumpstart personal context.
 - **Agent-Ready Docs**: everyday notes naturally double as high-quality executable Agent commands — no format conversion needed, write and dispatch.
 
@@ -175,15 +179,17 @@ npx skills add https://github.com/GeminiLight/MindOS --skill mindos-zh -g -y   #
 - **Security**: Bearer Token auth, path sandboxing, INSTRUCTION.md write-protection, atomic writes.
 - **Knowledge Graph**: dynamically parses and visualizes inter-file references and dependencies.
 - **Backlinks View**: displays all files that reference the current file, helping you understand how a note fits into the knowledge network.
+- **Agent Inspector**: renders Agent operation logs as a filterable timeline to audit every tool call in detail.
 - **Git Time Machine**: Git auto-sync (commit/push/pull), records every edit by both humans and Agents. One-click rollback, cross-device sync.
 - **Desktop App**: native macOS/Windows/Linux app with system tray, auto-start, and local process management.
 
 <details>
 <summary><strong>Coming Soon</strong></summary>
 
-- [ ] ACP (Agent Communication Protocol): connect external Agents (e.g., Claude Code, Cursor) and turn the knowledge base into a multi-Agent collaboration hub
 - [ ] Deep RAG integration: retrieval-augmented generation grounded in your knowledge base for more accurate, context-aware AI responses
-- [ ] Agent Inspector: render Agent operation logs as a filterable timeline to audit every tool call in detail
+- [ ] ACP / A2A Phase 2: deep multi-agent collaboration with task delegation, shared context, and workflow chaining
+- [ ] Experience Compiler: auto-extract corrections and preferences from agent interactions into reusable Skills/SOPs
+- [ ] Knowledge Health Dashboard: visualize cognitive compound metrics — rules accumulated, agent reuse count, knowledge freshness
 
 </details>
 

package/app/app/api/a2a/agents/route.ts

@@ -0,0 +1,9 @@
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { getDiscoveredAgents } from '@/lib/a2a/client';
+
+export async function GET() {
+  const agents = getDiscoveredAgents();
+  return NextResponse.json({ agents });
+}

package/app/app/api/a2a/delegations/route.ts

@@ -0,0 +1,9 @@
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { getDelegationHistory } from '@/lib/a2a/client';
+
+export async function GET() {
+  const delegations = getDelegationHistory();
+  return NextResponse.json({ delegations });
+}

package/app/app/api/a2a/discover/route.ts

@@ -1,3 +1,5 @@
+export const dynamic = 'force-dynamic';
+
 import { NextResponse } from 'next/server';
 import { discoverAgent } from '@/lib/a2a/client';
 

package/app/app/api/a2a/route.ts

@@ -74,12 +74,12 @@ export async function POST(req: NextRequest) {
         if (!params?.id) {
           return respond(jsonRpcError(rpc.id, A2A_ERRORS.INVALID_PARAMS));
         }
-        const task = handleCancelTask(params);
-        if (!task) {
-          return respond(jsonRpcError(rpc.id, {
-            ...A2A_ERRORS.TASK_NOT_FOUND,
-            message: 'Task not found or not cancelable',
-          }));
+        const { task, reason } = handleCancelTask(params);
+        if (reason === 'not_found') {
+          return respond(jsonRpcError(rpc.id, A2A_ERRORS.TASK_NOT_FOUND));
+        }
+        if (reason === 'not_cancelable') {
+          return respond(jsonRpcError(rpc.id, A2A_ERRORS.TASK_NOT_CANCELABLE));
         }
         return respond(jsonRpcOk(rpc.id, task));
       }

package/app/app/api/acp/config/route.ts

@@ -0,0 +1,82 @@
+export const dynamic = 'force-dynamic';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { readSettings, writeSettings } from '@/lib/settings';
+import type { AcpAgentOverride } from '@/lib/acp/agent-descriptors';
+
+/** GET /api/acp/config — Returns all per-agent ACP overrides from settings. */
+export async function GET() {
+  const settings = readSettings();
+  return NextResponse.json({ agents: settings.acpAgents ?? {} });
+}
+
+/** POST /api/acp/config — Save a per-agent override. Body: { agentId, config } */
+export async function POST(req: NextRequest) {
+  let body: { agentId?: string; config?: AcpAgentOverride };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { agentId, config } = body;
+  if (!agentId || typeof agentId !== 'string') {
+    return NextResponse.json({ error: 'agentId is required' }, { status: 400 });
+  }
+
+  const settings = readSettings();
+  const existing = settings.acpAgents ?? {};
+
+  if (config && typeof config === 'object') {
+    // Sanitize the override
+    const sanitized: AcpAgentOverride = {};
+    if (typeof config.command === 'string' && config.command.trim()) {
+      sanitized.command = config.command.trim();
+    }
+    if (Array.isArray(config.args)) {
+      sanitized.args = config.args.filter((a): a is string => typeof a === 'string');
+    }
+    if (config.env && typeof config.env === 'object' && !Array.isArray(config.env)) {
+      const env: Record<string, string> = {};
+      for (const [k, v] of Object.entries(config.env)) {
+        if (typeof v === 'string') env[k] = v;
+      }
+      if (Object.keys(env).length > 0) sanitized.env = env;
+    }
+    if (typeof config.enabled === 'boolean') {
+      sanitized.enabled = config.enabled;
+    }
+
+    existing[agentId] = sanitized;
+  }
+
+  settings.acpAgents = existing;
+  writeSettings(settings);
+  return NextResponse.json({ ok: true, agents: settings.acpAgents });
+}
+
+/** DELETE /api/acp/config — Reset a single agent to defaults. Body: { agentId } */
+export async function DELETE(req: NextRequest) {
+  let body: { agentId?: string };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { agentId } = body;
+  if (!agentId || typeof agentId !== 'string') {
+    return NextResponse.json({ error: 'agentId is required' }, { status: 400 });
+  }
+
+  const settings = readSettings();
+  if (settings.acpAgents) {
+    delete settings.acpAgents[agentId];
+    if (Object.keys(settings.acpAgents).length === 0) {
+      settings.acpAgents = undefined;
+    }
+  }
+
+  writeSettings(settings);
+  return NextResponse.json({ ok: true, agents: settings.acpAgents ?? {} });
+}

package/app/app/api/acp/detect/route.ts

@@ -0,0 +1,114 @@
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { exec } from 'child_process';
+import { getAcpAgents } from '@/lib/acp/registry';
+import { getDescriptorBinary, getDescriptorInstallCmd, resolveAgentCommand } from '@/lib/acp/agent-descriptors';
+import { readSettings } from '@/lib/settings';
+
+/* ── Types ─────────────────────────────────────────────────────────────── */
+
+interface InstalledAgent {
+  id: string;
+  name: string;
+  binaryPath: string;
+  resolvedCommand: {
+    cmd: string;
+    args: string[];
+    source: 'user-override' | 'descriptor' | 'registry';
+  };
+}
+
+interface NotInstalledAgent {
+  id: string;
+  name: string;
+  installCmd: string;
+  packageName?: string;
+}
+
+/* ── Server-side detection cache (5 min TTL) ──────────────────────────── */
+
+const DETECT_CACHE_TTL_MS = 5 * 60 * 1000;
+let detectCache: { data: { installed: InstalledAgent[]; notInstalled: NotInstalledAgent[] }; ts: number } | null = null;
+
+/* ── Async detection helpers ──────────────────────────────────────────── */
+
+function whichAsync(binary: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    const child = exec(`which ${binary}`, { encoding: 'utf-8', timeout: 2000 }, (err, stdout) => {
+      resolve(err ? null : (stdout.trim() || null));
+    });
+    child.on('error', () => resolve(null));
+  });
+}
+
+/**
+ * Batch `which` for multiple unique binaries in a single call.
+ * Returns a Map<binary, path | null>.
+ */
+async function whichBatch(binaries: string[]): Promise<Map<string, string | null>> {
+  const unique = [...new Set(binaries)];
+  if (unique.length === 0) return new Map();
+
+  const results = await Promise.all(unique.map(async (bin) => {
+    const path = await whichAsync(bin);
+    return [bin, path] as const;
+  }));
+
+  return new Map(results);
+}
+
+/* ── Route handler ─────────────────────────────────────────────────────── */
+
+export async function GET(req: Request) {
+  try {
+    const force = new URL(req.url).searchParams.get('force') === '1';
+    if (!force && detectCache && Date.now() - detectCache.ts < DETECT_CACHE_TTL_MS) {
+      return NextResponse.json(detectCache.data);
+    }
+
+    const agents = await getAcpAgents();
+    const settings = readSettings();
+
+    const binaryNames = agents.map((a) => getDescriptorBinary(a.id)).filter(Boolean) as string[];
+    const whichMap = await whichBatch(binaryNames);
+
+    const installed: InstalledAgent[] = [];
+    const notInstalled: NotInstalledAgent[] = [];
+
+    for (const agent of agents) {
+      const binary = getDescriptorBinary(agent.id);
+      const binaryPath = binary ? (whichMap.get(binary) ?? null) : null;
+
+      if (binaryPath) {
+        const userOverride = settings.acpAgents?.[agent.id];
+        const resolved = resolveAgentCommand(agent.id, agent, userOverride);
+        installed.push({
+          id: agent.id,
+          name: agent.name,
+          binaryPath,
+          resolvedCommand: { cmd: resolved.cmd, args: resolved.args, source: resolved.source },
+        });
+      } else {
+        const installCmd =
+          getDescriptorInstallCmd(agent.id) ??
+          (agent.packageName ? `npm install -g ${agent.packageName}` : '');
+        notInstalled.push({
+          id: agent.id,
+          name: agent.name,
+          installCmd,
+          packageName: agent.packageName,
+        });
+      }
+    }
+
+    const data = { installed, notInstalled };
+    detectCache = { data, ts: Date.now() };
+    return NextResponse.json(data);
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message, installed: [], notInstalled: [] },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,51 @@
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { exec } from 'child_process';
+
+interface InstallRequest {
+  agentId: string;
+  packageName: string;
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = (await request.json()) as InstallRequest;
+
+    if (!body.agentId || !body.packageName) {
+      return NextResponse.json(
+        { error: 'agentId and packageName are required' },
+        { status: 400 },
+      );
+    }
+
+    // Validate packageName to prevent command injection
+    // Allow scoped packages like @scope/name and plain names
+    if (!/^(@[\w-]+\/)?[\w][\w./-]*$/.test(body.packageName)) {
+      return NextResponse.json(
+        { error: 'Invalid package name' },
+        { status: 400 },
+      );
+    }
+
+    // Run npm install -g in background (fire-and-forget for the HTTP response)
+    const child = exec(
+      `npm install -g ${body.packageName}`,
+      { timeout: 120_000 },
+    );
+
+    // Detach so the process continues after response
+    child.unref();
+
+    return NextResponse.json({
+      status: 'installing',
+      agentId: body.agentId,
+      packageName: body.packageName,
+    });
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/acp/registry/route.ts

@@ -0,0 +1,31 @@
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { fetchAcpRegistry, findAcpAgent } from '@/lib/acp/registry';
+
+export async function GET(req: Request) {
+  try {
+    const { searchParams } = new URL(req.url);
+    const agentId = searchParams.get('agent');
+
+    if (agentId) {
+      const agent = await findAcpAgent(agentId);
+      if (!agent) {
+        return NextResponse.json({ error: 'Agent not found', agent: null }, { status: 404 });
+      }
+      return NextResponse.json({ agent });
+    }
+
+    const registry = await fetchAcpRegistry();
+    if (!registry) {
+      return NextResponse.json({ error: 'Failed to fetch registry', registry: null }, { status: 502 });
+    }
+
+    return NextResponse.json({ registry });
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/acp/session/route.ts

@@ -0,0 +1,185 @@
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import {
+  createSession,
+  loadSession,
+  listSessions,
+  closeSession,
+  prompt,
+  cancelPrompt,
+  setMode,
+  setConfigOption,
+  getSession,
+  getActiveSessions,
+} from '@/lib/acp/session';
+
+export async function GET() {
+  try {
+    const sessions = getActiveSessions();
+    return NextResponse.json({ sessions });
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * POST /api/acp/session
+ * Action-based dispatch for all ACP session operations.
+ *
+ * Actions:
+ *   create          — { action: "create", agentId, env?, cwd?, prompt? }
+ *   load            — { action: "load", agentId, sessionId, env?, cwd? }
+ *   prompt          — { action: "prompt", sessionId, text }
+ *   cancel          — { action: "cancel", sessionId }
+ *   set_mode        — { action: "set_mode", sessionId, modeId }
+ *   set_config      — { action: "set_config", sessionId, configId, value }
+ *   list_sessions   — { action: "list_sessions", sessionId, cursor?, cwd? }
+ *
+ * Legacy (no action field): treated as "create" for backwards compat.
+ */
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const action = body.action ?? 'create';
+
+    switch (action) {
+      case 'create': {
+        const { agentId, env, cwd, prompt: promptText } = body as {
+          agentId?: string;
+          env?: Record<string, string>;
+          cwd?: string;
+          prompt?: string;
+        };
+
+        if (!agentId || typeof agentId !== 'string') {
+          return NextResponse.json({ error: 'agentId is required' }, { status: 400 });
+        }
+
+        const session = await createSession(agentId, { env, cwd });
+
+        // One-shot mode: send prompt, get response, close session
+        if (promptText && typeof promptText === 'string') {
+          try {
+            const response = await prompt(session.id, promptText);
+            await closeSession(session.id).catch(() => {});
+            return NextResponse.json({ session, response });
+          } catch (promptErr) {
+            await closeSession(session.id).catch(() => {});
+            return NextResponse.json(
+              { error: `Prompt failed: ${(promptErr as Error).message}`, session },
+              { status: 500 },
+            );
+          }
+        }
+
+        return NextResponse.json({ session });
+      }
+
+      case 'load': {
+        const { agentId, sessionId, env, cwd } = body as {
+          agentId?: string;
+          sessionId?: string;
+          env?: Record<string, string>;
+          cwd?: string;
+        };
+
+        if (!agentId || typeof agentId !== 'string') {
+          return NextResponse.json({ error: 'agentId is required' }, { status: 400 });
+        }
+        if (!sessionId || typeof sessionId !== 'string') {
+          return NextResponse.json({ error: 'sessionId is required' }, { status: 400 });
+        }
+
+        const session = await loadSession(agentId, sessionId, { env, cwd });
+        return NextResponse.json({ session });
+      }
+
+      case 'prompt': {
+        const { sessionId, text } = body as { sessionId?: string; text?: string };
+
+        if (!sessionId || typeof sessionId !== 'string') {
+          return NextResponse.json({ error: 'sessionId is required' }, { status: 400 });
+        }
+        if (!text || typeof text !== 'string') {
+          return NextResponse.json({ error: 'text is required' }, { status: 400 });
+        }
+
+        const response = await prompt(sessionId, text);
+        return NextResponse.json({ response });
+      }
+
+      case 'cancel': {
+        const { sessionId } = body as { sessionId?: string };
+        if (!sessionId || typeof sessionId !== 'string') {
+          return NextResponse.json({ error: 'sessionId is required' }, { status: 400 });
+        }
+
+        await cancelPrompt(sessionId);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'set_mode': {
+        const { sessionId, modeId } = body as { sessionId?: string; modeId?: string };
+        if (!sessionId || !modeId) {
+          return NextResponse.json({ error: 'sessionId and modeId are required' }, { status: 400 });
+        }
+
+        await setMode(sessionId, modeId);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'set_config': {
+        const { sessionId, configId, value } = body as { sessionId?: string; configId?: string; value?: string };
+        if (!sessionId || !configId || value === undefined) {
+          return NextResponse.json({ error: 'sessionId, configId, and value are required' }, { status: 400 });
+        }
+
+        const configOptions = await setConfigOption(sessionId, configId, String(value));
+        return NextResponse.json({ configOptions });
+      }
+
+      case 'list_sessions': {
+        const { sessionId, cursor, cwd } = body as { sessionId?: string; cursor?: string; cwd?: string };
+        if (!sessionId || typeof sessionId !== 'string') {
+          return NextResponse.json({ error: 'sessionId is required' }, { status: 400 });
+        }
+
+        const result = await listSessions(sessionId, { cursor, cwd });
+        return NextResponse.json(result);
+      }
+
+      default:
+        return NextResponse.json({ error: `Unknown action: ${action}` }, { status: 400 });
+    }
+  } catch (err) {
+    const msg = (err as Error).message;
+    const status = msg.includes('not found') ? 404 : msg.includes('not support') ? 501 : 500;
+    return NextResponse.json({ error: msg }, { status });
+  }
+}
+
+export async function DELETE(req: Request) {
+  try {
+    const { sessionId } = await req.json();
+    if (!sessionId || typeof sessionId !== 'string') {
+      return NextResponse.json({ error: 'sessionId is required' }, { status: 400 });
+    }
+
+    const session = getSession(sessionId);
+    if (!session) {
+      return NextResponse.json({ error: 'Session not found' }, { status: 404 });
+    }
+
+    await closeSession(sessionId);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}