@geminilight/mindos 0.6.6 → 0.6.8

package/app/app/api/ask/route.ts

@@ -103,6 +103,34 @@ function getTurnEndData(e: AgentEvent): { toolResults: Array<{ toolName: string;
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Strip large fields (file content) from tool args before SSE serialization.
+ * The client only needs path/name for progress display, not the full content.
+ * This prevents JSON.stringify failures on oversized payloads.
+ */
+function sanitizeToolArgs(toolName: string, args: unknown): unknown {
+  if (!args || typeof args !== 'object') return args;
+  const a = args as Record<string, unknown>;
+
+  if (toolName === 'batch_create_files' && Array.isArray(a.files)) {
+    return {
+      ...a,
+      files: (a.files as Array<Record<string, unknown>>).map(f => ({
+        path: f.path,
+        ...(f.description ? { description: f.description } : {}),
+      })),
+    };
+  }
+
+  if (typeof a.content === 'string' && a.content.length > 200) {
+    return { ...a, content: `[${a.content.length} chars]` };
+  }
+  if (typeof a.text === 'string' && a.text.length > 200) {
+    return { ...a, text: `[${a.text.length} chars]` };
+  }
+  return args;
+}
+
 function readKnowledgeFile(filePath: string): { ok: boolean; content: string; truncated: boolean; error?: string } {
   try {
     const raw = getFileContent(filePath);
@@ -457,7 +485,11 @@ export async function POST(req: NextRequest) {
         function send(event: MindOSSSEvent) {
           try {
             controller.enqueue(encoder.encode(`data:${JSON.stringify(event)}\n\n`));
-          } catch { /* controller may be closed */ }
+          } catch (err) {
+            if (err instanceof TypeError) {
+              console.error('[ask] SSE send failed (serialization):', (err as Error).message, 'event type:', (event as { type?: string }).type);
+            }
+          }
         }
 
         session.subscribe((event: AgentEvent) => {
@@ -467,11 +499,12 @@ export async function POST(req: NextRequest) {
             send({ type: 'thinking_delta', delta: getThinkingDelta(event) });
           } else if (isToolExecutionStartEvent(event)) {
             const { toolCallId, toolName, args } = getToolExecutionStart(event);
+            const safeArgs = sanitizeToolArgs(toolName, args);
             send({
               type: 'tool_start',
               toolCallId,
               toolName,
-              args,
+              args: safeArgs,
             });
           } else if (isToolExecutionEndEvent(event)) {
             const { toolCallId, output, isError } = getToolExecutionEnd(event);

package/app/app/api/file/route.ts

@@ -1,6 +1,11 @@
 export const dynamic = 'force-dynamic';
+import fs from 'fs';
+import path from 'path';
 import { NextRequest, NextResponse } from 'next/server';
 import { revalidatePath } from 'next/cache';
+import { resolveSafe } from '@/lib/core/security';
+import { sanitizeFileName, convertToMarkdown } from '@/lib/core/file-convert';
+import { effectiveSopRoot } from '@/lib/settings';
 import {
   getFileContent,
   saveFileContent,
@@ -57,6 +62,28 @@ export async function GET(req: NextRequest) {
     }
   }
 
+  if (op === 'check_conflicts') {
+    const names = req.nextUrl.searchParams.get('names');
+    const space = req.nextUrl.searchParams.get('space') ?? '';
+    if (!names) return err('missing names');
+    try {
+      const mindRoot = effectiveSopRoot().trim();
+      if (!mindRoot) return err('MIND_ROOT not configured');
+      const fileNames = names.split(',').map(n => n.trim()).filter(Boolean);
+      const conflicts: string[] = [];
+      for (const name of fileNames) {
+        const sanitized = sanitizeFileName(name);
+        const { targetName } = convertToMarkdown(sanitized, '');
+        const rel = space ? path.posix.join(space, targetName) : targetName;
+        const resolved = resolveSafe(mindRoot, rel);
+        if (fs.existsSync(resolved)) conflicts.push(name);
+      }
+      return NextResponse.json({ conflicts });
+    } catch (e) {
+      return err((e as Error).message, 500);
+    }
+  }
+
   if (!filePath) return err('missing path');
 
   try {

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

@@ -42,21 +42,34 @@ function killByPort(port: number) {
  *
  * Unlike /api/restart which restarts the entire MindOS (Web + MCP),
  * this endpoint only restarts the MCP server. The Web UI stays up.
+ *
+ * When running under Desktop's ProcessManager, the crash handler
+ * auto-respawns MCP when it exits. We wait for the port to free,
+ * then spawn only if nothing re-bound (i.e. CLI mode with no crash
+ * handler). This avoids spawning a duplicate that races for the port.
  */
 export async function POST() {
   try {
     const cfg = readConfig();
-    const mcpPort = (cfg.mcpPort as number) ?? 8781;
+    const mcpPort = Number(process.env.MINDOS_MCP_PORT) || Number(cfg.mcpPort) || 8781;
     const webPort = process.env.MINDOS_WEB_PORT || '3456';
-    const authToken = cfg.authToken as string | undefined;
+    const authToken = process.env.AUTH_TOKEN || (cfg.authToken as string | undefined);
+    const managed = process.env.MINDOS_MANAGED === '1';
 
     // Step 1: Kill process on MCP port
     killByPort(mcpPort);
 
-    // Step 2: Wait briefly for port to free
-    await new Promise(r => setTimeout(r, 1000));
+    if (managed) {
+      // Desktop ProcessManager will auto-respawn MCP via its crash handler.
+      return NextResponse.json({ ok: true, port: mcpPort, note: 'ProcessManager will respawn' });
+    }
+
+    // Step 2 (CLI mode only): Wait for port to free, then spawn a new MCP
+    const portFree = await waitForPortFree(mcpPort, 5000);
+    if (!portFree) {
+      return NextResponse.json({ error: `MCP port ${mcpPort} still in use after kill` }, { status: 500 });
+    }
 
-    // Step 3: Spawn new MCP server
     const root = process.env.MINDOS_PROJECT_ROOT || resolve(process.cwd(), '..');
     const mcpDir = resolve(root, 'mcp');
 
@@ -88,3 +101,22 @@ export async function POST() {
     return NextResponse.json({ error: message }, { status: 500 });
   }
 }
+
+function isPortInUse(port: number): Promise<boolean> {
+  return new Promise((res) => {
+    const net = require('net');
+    const server = net.createServer();
+    server.once('error', () => res(true));
+    server.once('listening', () => { server.close(); res(false); });
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+async function waitForPortFree(port: number, timeoutMs: number): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!(await isPortInUse(port))) return true;
+    await new Promise(r => setTimeout(r, 300));
+  }
+  return false;
+}

package/app/app/api/monitoring/route.ts

@@ -63,7 +63,7 @@ export async function GET() {
   const kbStats = getCachedKbStats(mindRoot);
 
   // Detect MCP status from environment / config
-  const mcpPort = Number(process.env.MCP_PORT) || 3457;
+  const mcpPort = Number(process.env.MINDOS_MCP_PORT) || Number(process.env.MCP_PORT) || 8781;
 
   return NextResponse.json({
     system: {

package/app/app/api/setup/check-port/route.ts

@@ -37,16 +37,20 @@ async function findFreePort(start: number, selfPorts: Set<number>): Promise<numb
 }
 
 /**
- * The port this MindOS web server is actually listening on.
- * Derived from the incoming request URL — always reliable, no network round-trip.
+ * Ports this MindOS instance is known to be using.
  *
- * Note: We intentionally do NOT read settings here. Settings contain *configured*
- * ports (webPort / mcpPort), which may not actually be listening yet (e.g. during
- * first onboard, or if MCP server hasn't started). Treating configured-but-not-
- * listening ports as "self" would mask real conflicts.
+ * myWebPort:  derived from the incoming request URL — always reliable.
+ * myMcpPort:  from MINDOS_MCP_PORT env var set by CLI / Desktop ProcessManager.
+ *
+ * We do NOT read ~/.mindos/config.json here. Config contains *configured* ports
+ * which may not actually be listening yet (e.g. first onboard before MCP starts).
+ * Env vars are only set when a process IS running, so they're safe to trust.
  */
-function getListeningPort(req: NextRequest): number {
-  return parseInt(req.nextUrl.port || '0', 10);
+function getKnownPorts(req: NextRequest): { myWebPort: number; myMcpPort: number } {
+  return {
+    myWebPort: parseInt(req.nextUrl.port || '0', 10),
+    myMcpPort: Number(process.env.MINDOS_MCP_PORT) || 0,
+  };
 }
 
 export async function POST(req: NextRequest) {
@@ -56,10 +60,10 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ error: 'Invalid port' }, { status: 400 });
     }
 
-    const myPort = getListeningPort(req);
+    const { myWebPort, myMcpPort } = getKnownPorts(req);
 
-    // Fast path: if checking the port we're currently listening on, skip network round-trip
-    if (myPort > 0 && port === myPort) {
+    // Fast path: port belongs to this MindOS instance (deterministic, no network)
+    if ((myWebPort > 0 && port === myWebPort) || (myMcpPort > 0 && port === myMcpPort)) {
       return NextResponse.json({ available: true, isSelf: true });
     }
 
@@ -67,13 +71,14 @@ export async function POST(req: NextRequest) {
     if (!inUse) {
       return NextResponse.json({ available: true, isSelf: false });
     }
-    // Port is occupied — check if it's another MindOS instance
+    // Port is occupied by something else — check if it's another MindOS instance
     const self = await isSelfPort(port);
     if (self) {
       return NextResponse.json({ available: true, isSelf: true });
     }
     const skipPorts = new Set<number>();
-    if (myPort > 0) skipPorts.add(myPort);
+    if (myWebPort > 0) skipPorts.add(myWebPort);
+    if (myMcpPort > 0) skipPorts.add(myMcpPort);
     const suggestion = await findFreePort(port + 1, skipPorts);
     return NextResponse.json({ available: false, isSelf: false, suggestion });
   } catch (err) {