@geminilight/mindos 0.6.52 → 0.6.54

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

@@ -26,7 +26,8 @@ import { AGENT_SYSTEM_PROMPT, ORGANIZE_SYSTEM_PROMPT, CHAT_SYSTEM_PROMPT } from
 import type { AskModeApi } from '@/lib/types';
 import { toAgentMessages } from '@/lib/agent/to-agent-messages';
 import { logAgentOp } from '@/lib/agent/log';
-import { readSettings } from '@/lib/settings';
+import { readSettings, readBaseUrlCompat, writeBaseUrlCompat } from '@/lib/settings';
+import { en as i18nEn, zh as i18nZh } from '@/lib/i18n';
 import { MindOSError, apiError, ErrorCodes } from '@/lib/errors';
 import { metrics } from '@/lib/metrics';
 import { assertNotProtected } from '@/lib/core';
@@ -400,6 +401,134 @@ function toPiCustomToolDefinitions(tools: AgentTool<any>[]): ToolDefinition<any,
   }));
 }
 
+// ---------------------------------------------------------------------------
+// Non-streaming fallback for proxies that don't support stream + tools
+// ---------------------------------------------------------------------------
+
+/**
+ * Mini agent loop using non-streaming OpenAI-compatible API.
+ * Used when a proxy silently breaks stream+tools by returning plain text.
+ * Emits SSE events identical to the streaming path so the frontend is unaffected.
+ */
+async function runNonStreamingFallback(opts: {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+  systemPrompt: string;
+  historyMessages: { role: string; content: unknown }[];
+  userContent: string;
+  tools: AgentTool<any>[];
+  send: (event: MindOSSSEvent) => void;
+  signal: AbortSignal;
+  maxSteps: number;
+}): Promise<void> {
+  const { baseUrl, apiKey, model, systemPrompt, historyMessages, userContent, tools, send, signal, maxSteps } = opts;
+
+  const openaiTools = tools.map(t => ({
+    type: 'function' as const,
+    function: {
+      name: t.name,
+      description: t.description ?? '',
+      parameters: (t as any).parameters ?? { type: 'object', properties: {} },
+    },
+  }));
+
+  const messages: { role: string; content: unknown; tool_calls?: unknown; tool_call_id?: string }[] = [
+    { role: 'system', content: systemPrompt },
+    ...historyMessages,
+    { role: 'user', content: userContent },
+  ];
+
+  const toolMap = new Map(tools.map(t => [t.name, t]));
+  const endpoint = `${baseUrl.replace(/\/$/, '')}/chat/completions`;
+  let step = 0;
+
+  while (step < maxSteps) {
+    if (signal.aborted) throw new Error('Request aborted');
+    step++;
+
+    const resp = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        tools: openaiTools.length > 0 ? openaiTools : undefined,
+        tool_choice: openaiTools.length > 0 ? 'auto' : undefined,
+        stream: false,
+      }),
+      signal,
+    });
+
+    if (!resp.ok) {
+      const errText = await resp.text().catch(() => '');
+      throw new Error(`Non-streaming API error ${resp.status}: ${errText.slice(0, 200)}`);
+    }
+
+    const data = await resp.json() as any;
+    const choice = data?.choices?.[0];
+    if (!choice) throw new Error('Empty response from API');
+
+    const msg = choice.message;
+    const finishReason: string = choice.finish_reason ?? 'stop';
+
+    // Emit text content in chunks to simulate streaming appearance
+    if (msg.content) {
+      const text: string = typeof msg.content === 'string' ? msg.content : '';
+      if (text) {
+        const chunkSize = 40;
+        for (let i = 0; i < text.length; i += chunkSize) {
+          send({ type: 'text_delta', delta: text.slice(i, i + chunkSize) });
+          await new Promise(r => setTimeout(r, 8));
+        }
+      }
+    }
+
+    // No tool calls or naturally stopped → done
+    if (finishReason === 'stop' || !msg.tool_calls?.length) break;
+
+    // Execute each tool call
+    const toolResultMessages: { role: string; tool_call_id: string; content: string }[] = [];
+    for (const tc of msg.tool_calls) {
+      const toolName = tc.function?.name ?? '';
+      const toolCallId = tc.id ?? `call_${Date.now()}`;
+      let parsedArgs: Record<string, unknown> = {};
+      try { parsedArgs = JSON.parse(tc.function?.arguments ?? '{}'); } catch { /* ignore */ }
+
+      const tool = toolMap.get(toolName);
+      send({ type: 'tool_start', toolCallId, toolName, args: parsedArgs });
+
+      let resultText = '';
+      let isError = false;
+      if (tool) {
+        try {
+          const result = await tool.execute(toolCallId, parsedArgs, signal);
+          resultText = result.content
+            .filter((c: any) => c.type === 'text')
+            .map((c: any) => c.text)
+            .join('\n');
+        } catch (err) {
+          resultText = err instanceof Error ? err.message : String(err);
+          isError = true;
+        }
+      } else {
+        resultText = `Tool "${toolName}" not found`;
+        isError = true;
+      }
+
+      send({ type: 'tool_end', toolCallId, output: resultText, isError });
+      toolResultMessages.push({ role: 'tool', tool_call_id: toolCallId, content: resultText });
+    }
+
+    // Append assistant turn + tool results for next iteration
+    messages.push({ role: 'assistant', content: msg.content ?? null, tool_calls: msg.tool_calls });
+    messages.push(...toolResultMessages);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // POST /api/ask
 // ---------------------------------------------------------------------------
@@ -433,6 +562,10 @@ export async function POST(req: NextRequest) {
   // Read agent config from settings
   const serverSettings = readSettings();
   const agentConfig = serverSettings.agent ?? {};
+
+  // Detect locale from Accept-Language header for i18n status messages
+  const acceptLang = req.headers.get('accept-language') ?? '';
+  const t = acceptLang.startsWith('zh') ? i18nZh.ask : i18nEn.ask;
   const defaultMaxSteps = askMode === 'chat' ? 8 : (agentConfig.maxSteps ?? 20);
   const stepLimit = Number.isFinite(body.maxSteps)
     ? Math.min(30, Math.max(1, Number(body.maxSteps)))
@@ -689,7 +822,7 @@ export async function POST(req: NextRequest) {
     const provOverride = body.providerOverride && isProviderId(body.providerOverride)
       ? body.providerOverride as ProviderId
       : undefined;
-    const { model, modelName, apiKey, provider } = getModelConfig({
+    const { model, modelName, apiKey, provider, baseUrl } = getModelConfig({
       provider: provOverride,
       hasImages: hasImages(messages),
     });
@@ -788,6 +921,7 @@ export async function POST(req: NextRequest) {
 
         let hasContent = false;
         let lastModelError = '';
+        const effectiveBaseUrlKey = baseUrl || 'default';
 
         session.subscribe((event: AgentEvent) => {
           if (isTextDeltaEvent(event)) {
@@ -993,6 +1127,36 @@ export async function POST(req: NextRequest) {
             safeClose();
           } else {
             // Route to MindOS agent (existing logic)
+
+            // ── Proxy compatibility check ──
+            // If this baseUrl is known to reject stream+tools, skip session.prompt() entirely
+            // and go straight to the non-streaming fallback path.
+            const compatCache = readBaseUrlCompat();
+            if (compatCache[effectiveBaseUrlKey] === 'non-streaming' && baseUrl && provider === 'openai') {
+              send({ type: 'status', message: t.proxyCompatMode });
+              try {
+                await runNonStreamingFallback({
+                  baseUrl,
+                  apiKey,
+                  model: modelName,
+                  systemPrompt,
+                  historyMessages: llmHistoryMessages,
+                  userContent: typeof lastUserContent === 'string' ? lastUserContent : JSON.stringify(lastUserContent),
+                  tools: requestTools,
+                  send,
+                  signal: req.signal,
+                  maxSteps: stepLimit,
+                });
+                metrics.recordRequest(Date.now() - requestStartTime);
+                send({ type: 'done' });
+              } catch (fallbackErr) {
+                metrics.recordRequest(Date.now() - requestStartTime);
+                send({ type: 'error', message: t.proxyCompatFailed(fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)) });
+              }
+              safeClose();
+              return;
+            }
+
             // Retry with exponential backoff for transient failures (timeout, rate limit, 5xx).
             // Only retry if no content has been streamed yet — once the user sees partial
             // output, retrying would produce duplicate/garbled content.
@@ -1022,7 +1186,33 @@ export async function POST(req: NextRequest) {
 
             metrics.recordRequest(Date.now() - requestStartTime);
             if (!hasContent && lastModelError) {
-              send({ type: 'error', message: lastModelError });
+              // No content received — check if this looks like a proxy stream+tools incompatibility.
+              // Only attempt fallback for OpenAI-compatible endpoints with a custom baseUrl.
+              if (baseUrl && provider === 'openai') {
+                send({ type: 'status', message: t.proxyCompatDetecting });
+                try {
+                  await runNonStreamingFallback({
+                    baseUrl,
+                    apiKey,
+                    model: modelName,
+                    systemPrompt,
+                    historyMessages: llmHistoryMessages,
+                    userContent: typeof lastUserContent === 'string' ? lastUserContent : JSON.stringify(lastUserContent),
+                    tools: requestTools,
+                    send,
+                    signal: req.signal,
+                    maxSteps: stepLimit,
+                  });
+                  // Success → cache this endpoint as non-streaming so future requests skip the probe
+                  writeBaseUrlCompat(effectiveBaseUrlKey, 'non-streaming');
+                  console.log(`[ask] Proxy compat detected: ${effectiveBaseUrlKey} → non-streaming (cached)`);
+                  send({ type: 'done' });
+                } catch (fallbackErr) {
+                  send({ type: 'error', message: t.proxyCompatAlsoFailed(fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)) });
+                }
+              } else {
+                send({ type: 'error', message: lastModelError });
+              }
             } else {
               send({ type: 'done' });
             }

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

@@ -0,0 +1,121 @@
+export const dynamic = 'force-dynamic';
+import fs from 'fs';
+import { NextRequest, NextResponse } from 'next/server';
+import { resolveSafe } from '@/lib/core/security';
+import { getMindRoot } from '@/lib/fs';
+
+/** MIME types for binary files served from the knowledge base */
+const BINARY_MIME: Record<string, string> = {
+  // Documents
+  '.pdf': 'application/pdf',
+  // Images
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+  // Audio
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.m4a': 'audio/mp4',
+  '.ogg': 'audio/ogg',
+  '.flac': 'audio/flac',
+  '.aac': 'audio/aac',
+  // Video
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mov': 'video/quicktime',
+  '.mkv': 'video/x-matroska',
+};
+
+/** Max file size: 200MB for media, protects against truly absurd files */
+const MAX_RAW_SIZE = 200 * 1024 * 1024;
+
+/**
+ * GET /api/file/raw?path=<relative-path>
+ *
+ * Serve a binary file from the knowledge base with the correct Content-Type.
+ * Supports HTTP Range requests for audio/video seeking (required by <audio>/<video>).
+ *
+ * Security: path is resolved via resolveSafe() which prevents traversal attacks.
+ */
+export async function GET(req: NextRequest) {
+  const filePath = req.nextUrl.searchParams.get('path');
+  if (!filePath) {
+    return NextResponse.json({ error: 'Missing path parameter' }, { status: 400 });
+  }
+
+  const lower = filePath.toLowerCase();
+  const ext = lower.slice(lower.lastIndexOf('.'));
+  const mime = BINARY_MIME[ext];
+  if (!mime) {
+    return NextResponse.json({ error: `Unsupported binary file type: ${ext}` }, { status: 400 });
+  }
+
+  let resolved: string;
+  try {
+    resolved = resolveSafe(getMindRoot(), filePath);
+  } catch {
+    return NextResponse.json({ error: 'Access denied' }, { status: 403 });
+  }
+
+  if (!fs.existsSync(resolved)) {
+    return NextResponse.json({ error: 'File not found' }, { status: 404 });
+  }
+
+  const stat = fs.statSync(resolved);
+  if (stat.size > MAX_RAW_SIZE) {
+    return NextResponse.json(
+      { error: `File too large (${Math.round(stat.size / 1024 / 1024)}MB). Max: ${MAX_RAW_SIZE / 1024 / 1024}MB` },
+      { status: 413 },
+    );
+  }
+
+  const totalSize = stat.size;
+  const rangeHeader = req.headers.get('range');
+
+  // HTTP Range request — required for audio/video seeking
+  if (rangeHeader) {
+    const match = rangeHeader.match(/bytes=(\d+)-(\d*)/);
+    if (match) {
+      const start = Math.min(parseInt(match[1], 10), totalSize - 1);
+      const end = Math.min(match[2] ? parseInt(match[2], 10) : totalSize - 1, totalSize - 1);
+      const chunkSize = end - start + 1;
+
+      const buf = Buffer.alloc(chunkSize);
+      const fd = fs.openSync(resolved, 'r');
+      try {
+        fs.readSync(fd, buf, 0, chunkSize, start);
+      } finally {
+        fs.closeSync(fd);
+      }
+
+      return new NextResponse(buf, {
+        status: 206,
+        headers: {
+          'Content-Type': mime,
+          'Content-Length': String(chunkSize),
+          'Content-Range': `bytes ${start}-${end}/${totalSize}`,
+          'Accept-Ranges': 'bytes',
+          'Cache-Control': 'private, max-age=60',
+        },
+      });
+    }
+  }
+
+  // Full file response
+  const buf = fs.readFileSync(resolved);
+  return new NextResponse(buf, {
+    status: 200,
+    headers: {
+      'Content-Type': mime,
+      'Content-Length': String(totalSize),
+      'Accept-Ranges': 'bytes',
+      'Cache-Control': 'private, max-age=60',
+      'Content-Disposition': 'inline',
+    },
+  });
+}

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

@@ -24,6 +24,7 @@ import {
   appendCsvRow,
   getMindRoot,
   invalidateCache,
+  getFileTree,
   listMindSpaces,
   appendContentChange,
 } from '@/lib/fs';
@@ -34,6 +35,18 @@ function err(msg: string, status = 400) {
   return NextResponse.json({ error: msg }, { status });
 }
 
+/** Recursively collect all directory paths from the file tree. */
+function collectDirectories(nodes: import('@/lib/types').FileNode[]): string[] {
+  const dirs: string[] = [];
+  for (const n of nodes) {
+    if (n.type === 'directory') {
+      dirs.push(n.path);
+      if (n.children) dirs.push(...collectDirectories(n.children));
+    }
+  }
+  return dirs;
+}
+
 /** Returns true if the path targets a root-level system file (INSTRUCTION.md, CONFIG.json, etc.). */
 function isSystemFile(filePath: string): boolean {
   const basename = path.posix.basename(filePath);
@@ -83,6 +96,14 @@ export async function GET(req: NextRequest) {
     }
   }
 
+  if (op === 'list_dirs') {
+    try {
+      return NextResponse.json({ dirs: collectDirectories(getFileTree()) });
+    } catch (e) {
+      return err((e as Error).message, 500);
+    }
+  }
+
   if (op === 'check_conflicts') {
     const names = req.nextUrl.searchParams.get('names');
     const space = req.nextUrl.searchParams.get('space') ?? '';

package/app/app/api/inbox/route.ts

@@ -41,10 +41,10 @@ export async function POST(req: NextRequest) {
     return NextResponse.json({ error: 'Request body must contain a files array' }, { status: 400 });
   }
 
-  const { files } = body as { files: Array<{ name: string; content: string; encoding?: 'text' | 'base64' }> };
+  const { files, source } = body as { files: Array<{ name: string; content: string; encoding?: 'text' | 'base64' }>, source?: string };
 
   try {
-    const result = saveToInbox(mindRoot, files);
+    const result = saveToInbox(mindRoot, files, source);
 
     if (result.saved.length > 0) {
       invalidateCache();
@@ -59,3 +59,39 @@ export async function POST(req: NextRequest) {
     );
   }
 }
+
+export async function DELETE(req: NextRequest) {
+  const mindRoot = effectiveSopRoot().trim();
+  if (!mindRoot) {
+    return NextResponse.json({ error: 'MIND_ROOT is not configured' }, { status: 400 });
+  }
+
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { names } = (body ?? {}) as { names?: string[] };
+  if (!Array.isArray(names) || names.length === 0) {
+    return NextResponse.json({ error: 'Request body must contain a non-empty names array' }, { status: 400 });
+  }
+
+  try {
+    const { archiveFromInbox } = await import('@/lib/core/inbox');
+    const result = archiveFromInbox(mindRoot, names);
+
+    if (result.archived.length > 0) {
+      invalidateCache();
+      try { revalidatePath('/', 'layout'); } catch { /* test env */ }
+    }
+
+    return NextResponse.json(result);
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 },
+    );
+  }
+}

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

@@ -66,6 +66,7 @@ export async function GET(req: NextRequest) {
       maskedToken: authConfigured ? maskToken(token) : undefined,
       authToken: authConfigured ? token : undefined,
       localIP: getLocalIP(),
+      connectionMode: settings.connectionMode ?? { cli: true, mcp: false },
     });
   } catch (err) {
     return NextResponse.json({ error: String(err) }, { status: 500 });

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

@@ -3,31 +3,36 @@ import { NextResponse } from 'next/server';
 import { spawn } from 'node:child_process';
 import { resolve } from 'node:path';
 
+/**
+ * Strip ALL MINDOS_ and MIND_ prefixed env vars so the restart child
+ * process re-derives paths from its own installation root.
+ * Preserves old port values via MINDOS_OLD_ for cleanup.
+ */
+function cleanEnvForRestart(): { env: NodeJS.ProcessEnv; oldWebPort?: string; oldMcpPort?: string } {
+  const cleaned = { ...process.env };
+  const oldWebPort = cleaned.MINDOS_WEB_PORT;
+  const oldMcpPort = cleaned.MINDOS_MCP_PORT;
+  for (const key of Object.keys(cleaned)) {
+    if (key.startsWith('MINDOS_') || key.startsWith('MIND_')) {
+      delete cleaned[key];
+    }
+  }
+  delete cleaned.AUTH_TOKEN;
+  delete cleaned.WEB_PASSWORD;
+  delete cleaned.NODE_OPTIONS;
+  // Pass old ports so restart command can clean up stale listeners
+  if (oldWebPort) cleaned.MINDOS_OLD_WEB_PORT = oldWebPort;
+  if (oldMcpPort) cleaned.MINDOS_OLD_MCP_PORT = oldMcpPort;
+  return { env: cleaned, oldWebPort, oldMcpPort };
+}
+
 export async function POST() {
   try {
+    // Resolve CLI path BEFORE cleaning env (we still need current vars)
     const cliPath = process.env.MINDOS_CLI_PATH || resolve(process.env.MINDOS_PROJECT_ROOT || process.cwd(), '..', 'bin', 'cli.js');
     const nodeBin = process.env.MINDOS_NODE_BIN || process.execPath;
-    // Use 'restart' (stop all → wait for ports free → start) instead of bare
-    // 'start' which would fail assertPortFree because the current process and
-    // its MCP child are still holding the ports.
-    //
-    // IMPORTANT: Strip MINDOS_* env vars so the child's loadConfig() reads
-    // the *updated* config file instead of inheriting stale values from this
-    // process.  Without this, changing ports in the GUI has no effect on the
-    // restarted server — it would start on the old ports.
-    //
-    // Pass the current (old) ports via MINDOS_OLD_* so the restart command
-    // can clean up processes still listening on the previous ports.
-    const childEnv = { ...process.env };
-    const oldWebPort = childEnv.MINDOS_WEB_PORT;
-    const oldMcpPort = childEnv.MINDOS_MCP_PORT;
-    delete childEnv.MINDOS_WEB_PORT;
-    delete childEnv.MINDOS_MCP_PORT;
-    delete childEnv.MIND_ROOT;
-    delete childEnv.AUTH_TOKEN;
-    delete childEnv.WEB_PASSWORD;
-    if (oldWebPort) childEnv.MINDOS_OLD_WEB_PORT = oldWebPort;
-    if (oldMcpPort) childEnv.MINDOS_OLD_MCP_PORT = oldMcpPort;
+
+    const { env: childEnv } = cleanEnvForRestart();
     const child = spawn(nodeBin, [cliPath, 'restart'], {
       detached: true,
       stdio: 'ignore',

package/app/app/api/settings/route.ts

@@ -96,6 +96,18 @@ export async function POST(req: NextRequest) {
       ? (incomingAuthToken === '' ? '' : current.authToken)
       : current.authToken;
 
+    // Handle connectionMode: validate if provided, otherwise keep existing
+    let resolvedConnectionMode = current.connectionMode ?? { cli: true, mcp: false };
+    if (body.connectionMode && typeof body.connectionMode === 'object') {
+      const incomingMode = body.connectionMode as Record<string, unknown>;
+      if (typeof incomingMode.cli === 'boolean' && typeof incomingMode.mcp === 'boolean') {
+        resolvedConnectionMode = {
+          cli: incomingMode.cli,
+          mcp: incomingMode.mcp,
+        };
+      }
+    }
+
     const next: ServerSettings = {
       ai: {
         provider: body.ai?.provider ?? current.ai.provider,
@@ -108,6 +120,7 @@ export async function POST(req: NextRequest) {
       port: typeof body.port === 'number' ? body.port : current.port,
       mcpPort: typeof body.mcpPort === 'number' ? body.mcpPort : current.mcpPort,
       startMode: body.startMode ?? current.startMode,
+      connectionMode: resolvedConnectionMode,
     };
 
     writeSettings(next);

package/app/app/api/setup/route.ts

@@ -53,7 +53,7 @@ export async function GET() {
 export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
-    const { mindRoot, template, port, mcpPort, authToken, webPassword, ai } = body;
+    const { mindRoot, template, port, mcpPort, authToken, webPassword, ai, connectionMode } = body;
 
     // Validate required fields
     if (!mindRoot || typeof mindRoot !== 'string') {
@@ -126,6 +126,15 @@ export async function POST(req: NextRequest) {
     const disabledSkills = body.template === 'zh' ? ['mindos'] : ['mindos-zh'];
     // Determine guide template from setup template
     const guideTemplate = body.template === 'zh' ? 'zh' : body.template === 'empty' ? 'empty' : 'en';
+    
+    // Validate and build connectionMode
+    let resolvedConnectionMode = current.connectionMode ?? { cli: true, mcp: false };
+    if (connectionMode && typeof connectionMode === 'object') {
+      if (typeof connectionMode.cli === 'boolean' && typeof connectionMode.mcp === 'boolean') {
+        resolvedConnectionMode = connectionMode;
+      }
+    }
+
     const config: ServerSettings = {
       ai: mergedAi,
       mindRoot: resolvedRoot,
@@ -145,6 +154,7 @@ export async function POST(req: NextRequest) {
         askedAI: false,
         nextStepIndex: 0,
       },
+      connectionMode: resolvedConnectionMode,
     };
 
     writeSettings(config);