@geminilight/mindos 0.5.68 → 0.5.70

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

@@ -357,21 +357,29 @@ export async function POST(req: NextRequest) {
         contextStrategy,
       ),
 
-      // Write-protection: block writes to protected files
+      // Write-protection: block writes to protected files gracefully
       beforeToolCall: async (context: BeforeToolCallContext): Promise<BeforeToolCallResult | undefined> => {
         const { toolCall, args } = context;
         // toolCall is an object with type "toolCall" and contains the tool name and ID
         const toolName = (toolCall as any).toolName ?? (toolCall as any).name;
         if (toolName && WRITE_TOOLS.has(toolName)) {
-          const filePath = (args as any).path ?? (args as any).from_path;
-          if (filePath) {
+          // Special handling for batch creations where we need to check multiple files
+          const pathsToCheck: string[] = [];
+          if (toolName === 'batch_create_files' && Array.isArray((args as any).files)) {
+            (args as any).files.forEach((f: any) => { if (f.path) pathsToCheck.push(f.path); });
+          } else {
+            const singlePath = (args as any).path ?? (args as any).from_path;
+            if (singlePath) pathsToCheck.push(singlePath);
+          }
+
+          for (const filePath of pathsToCheck) {
             try {
               assertNotProtected(filePath, 'modified by AI agent');
             } catch (e) {
               const errorMsg = e instanceof Error ? e.message : String(e);
               return {
                 block: true,
-                reason: `Write-protection error: ${errorMsg}`,
+                reason: `Write-protection error: ${errorMsg}. You CANNOT modify ${filePath} because it is system-protected. Please tell the user you don't have permission to do this.`,
               };
             }
           }

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

@@ -0,0 +1,197 @@
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+import fs from 'fs';
+import path from 'path';
+import { NextRequest, NextResponse } from 'next/server';
+import { revalidatePath } from 'next/cache';
+import { sanitizeFileName, convertToMarkdown } from '@/lib/core/file-convert';
+import { resolveSafe } from '@/lib/core/security';
+import { scaffoldIfNewSpace } from '@/lib/core/space-scaffold';
+import { organizeAfterImport } from '@/lib/core/organize';
+import { invalidateSearchIndex } from '@/lib/core/search';
+import { effectiveSopRoot } from '@/lib/settings';
+import { invalidateCache } from '@/lib/fs';
+
+const MAX_FILES = 20;
+const MAX_CONTENT_LENGTH = 5 * 1024 * 1024;
+
+type ConflictMode = 'skip' | 'rename' | 'overwrite';
+
+interface ImportRequest {
+  files: Array<{
+    name: string;
+    content: string;
+    encoding?: 'text' | 'base64';
+  }>;
+  targetSpace?: string;
+  organize?: boolean;
+  conflict?: ConflictMode;
+}
+
+function normalizeTargetSpace(raw: unknown): string {
+  if (raw === undefined || raw === null) return '';
+  if (typeof raw !== 'string') return '';
+  return raw.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '').trim();
+}
+
+function decodeFileContent(
+  encoding: 'text' | 'base64' | undefined,
+  content: string,
+  sanitizedName: string,
+): string {
+  if (encoding === 'base64') {
+    const buf = Buffer.from(content, 'base64');
+    if (sanitizedName.toLowerCase().endsWith('.pdf')) {
+      return buf.toString('latin1');
+    }
+    return buf.toString('utf-8');
+  }
+  return content;
+}
+
+function resolveUniquePath(
+  mindRoot: string,
+  relPath: string,
+  conflict: ConflictMode,
+): { relPath: string; resolved: string; skipped?: string } {
+  let rel = relPath.replace(/\\/g, '/');
+  let resolved = resolveSafe(mindRoot, rel);
+  if (!fs.existsSync(resolved)) {
+    return { relPath: rel, resolved };
+  }
+  if (conflict === 'skip') {
+    return { relPath: rel, resolved, skipped: 'file exists' };
+  }
+  if (conflict === 'overwrite') {
+    return { relPath: rel, resolved };
+  }
+  let n = 0;
+  while (fs.existsSync(resolved)) {
+    n += 1;
+    const dir = path.posix.dirname(rel);
+    const base = path.posix.basename(rel);
+    const ext = path.posix.extname(base);
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    const newBase = `${stem}-${n}${ext}`;
+    rel = dir && dir !== '.' ? path.posix.join(dir, newBase) : newBase;
+    resolved = resolveSafe(mindRoot, rel);
+  }
+  return { relPath: rel, resolved };
+}
+
+export async function POST(req: NextRequest) {
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const mindRoot = effectiveSopRoot().trim();
+  if (!mindRoot) {
+    return NextResponse.json({ error: 'MIND_ROOT is not configured' }, { status: 400 });
+  }
+
+  if (!body || typeof body !== 'object') {
+    return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  const reqBody = body as ImportRequest;
+  if (!Array.isArray(reqBody.files)) {
+    return NextResponse.json({ error: 'files must be an array' }, { status: 400 });
+  }
+
+  if (reqBody.files.length > MAX_FILES) {
+    return NextResponse.json({ error: `At most ${MAX_FILES} files per request` }, { status: 400 });
+  }
+
+  const targetSpaceNorm = normalizeTargetSpace(reqBody.targetSpace);
+  const organize = reqBody.organize !== false;
+  const conflict: ConflictMode =
+    reqBody.conflict === 'skip' || reqBody.conflict === 'overwrite' || reqBody.conflict === 'rename'
+      ? reqBody.conflict
+      : 'rename';
+
+  const created: Array<{ original: string; path: string }> = [];
+  const skipped: Array<{ name: string; reason: string }> = [];
+  const errors: Array<{ name: string; error: string }> = [];
+  const createdPaths: string[] = [];
+  const updatedFiles: string[] = [];
+
+  for (const entry of reqBody.files) {
+    const originalName = typeof entry?.name === 'string' ? entry.name : '';
+    try {
+      if (typeof entry?.name !== 'string' || typeof entry?.content !== 'string') {
+        errors.push({ name: originalName || '(unknown)', error: 'name and content must be strings' });
+        continue;
+      }
+      if (!entry.name.trim()) {
+        errors.push({ name: '(empty)', error: 'name must not be empty' });
+        continue;
+      }
+      if (entry.content.length > MAX_CONTENT_LENGTH) {
+        errors.push({ name: entry.name, error: `content exceeds ${MAX_CONTENT_LENGTH} characters` });
+        continue;
+      }
+
+      const sanitized = sanitizeFileName(entry.name);
+      const encoding = entry.encoding === 'base64' ? 'base64' : 'text';
+      const raw = decodeFileContent(encoding, entry.content, sanitized);
+      const convertResult = convertToMarkdown(sanitized, raw);
+
+      let relPath = targetSpaceNorm
+        ? path.posix.join(targetSpaceNorm, convertResult.targetName)
+        : convertResult.targetName;
+
+      const { relPath: finalRel, resolved, skipped: skipReason } = resolveUniquePath(
+        mindRoot,
+        relPath,
+        conflict,
+      );
+
+      if (skipReason) {
+        skipped.push({ name: entry.name, reason: skipReason });
+        continue;
+      }
+
+      fs.mkdirSync(path.dirname(resolved), { recursive: true });
+      fs.writeFileSync(resolved, convertResult.content, 'utf-8');
+      scaffoldIfNewSpace(mindRoot, finalRel);
+
+      created.push({ original: entry.name, path: finalRel });
+      createdPaths.push(finalRel);
+    } catch (e) {
+      errors.push({ name: originalName || '(unknown)', error: (e as Error).message });
+    }
+  }
+
+  if (organize && createdPaths.length > 0) {
+    try {
+      const { readmeUpdated } = organizeAfterImport(mindRoot, createdPaths, targetSpaceNorm);
+      if (readmeUpdated && targetSpaceNorm) {
+        updatedFiles.push(path.posix.join(targetSpaceNorm, 'README.md'));
+      }
+    } catch {
+      /* organize is best-effort */
+    }
+  }
+
+  if (created.length > 0 || updatedFiles.length > 0) {
+    invalidateSearchIndex();
+    invalidateCache();
+  }
+
+  try {
+    revalidatePath('/');
+  } catch {
+    /* noop in test env */
+  }
+
+  return NextResponse.json({
+    created,
+    skipped,
+    errors,
+    updatedFiles,
+  });
+}

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

@@ -11,6 +11,82 @@ function parseJsonc(text: string): Record<string, unknown> {
   return JSON.parse(stripped);
 }
 
+/** Ensure nested object path exists and return the leaf container */
+function ensureNestedPath(obj: Record<string, unknown>, dotPath: string): Record<string, unknown> {
+  const parts = dotPath.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (!current[part] || typeof current[part] !== 'object') {
+      current[part] = {};
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+  return current;
+}
+
+/** Generate a TOML section string for an MCP entry */
+function buildTomlEntry(sectionKey: string, serverName: string, entry: Record<string, unknown>): string {
+  const lines: string[] = [];
+  lines.push(`[${sectionKey}.${serverName}]`);
+  if (entry.type) lines.push(`type = "${entry.type}"`);
+  if (entry.command) lines.push(`command = "${entry.command}"`);
+  if (entry.url) lines.push(`url = "${entry.url}"`);
+  if (Array.isArray(entry.args)) {
+    lines.push(`args = [${entry.args.map(a => `"${a}"`).join(', ')}]`);
+  }
+  if (entry.env && typeof entry.env === 'object') {
+    lines.push('');
+    lines.push(`[${sectionKey}.${serverName}.env]`);
+    for (const [k, v] of Object.entries(entry.env)) {
+      lines.push(`${k} = "${v}"`);
+    }
+  }
+  if (entry.headers && typeof entry.headers === 'object') {
+    lines.push('');
+    lines.push(`[${sectionKey}.${serverName}.headers]`);
+    for (const [k, v] of Object.entries(entry.headers)) {
+      lines.push(`${k} = "${v}"`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/** Replace or append a [section.server] block in a TOML file */
+function mergeTomlEntry(existing: string, sectionKey: string, serverName: string, entry: Record<string, unknown>): string {
+  const sectionHeader = `[${sectionKey}.${serverName}]`;
+  const envHeader = `[${sectionKey}.${serverName}.env]`;
+  const headersHeader = `[${sectionKey}.${serverName}.headers]`;
+  const newBlock = buildTomlEntry(sectionKey, serverName, entry);
+
+  const lines = existing.split('\n');
+  const result: string[] = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === sectionHeader || trimmed === envHeader || trimmed === headersHeader) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith('[')) {
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+
+  // Remove trailing blank lines before appending
+  while (result.length > 0 && result[result.length - 1].trim() === '') {
+    result.pop();
+  }
+  result.push('');
+  result.push(newBlock);
+  result.push('');
+
+  return result.join('\n');
+}
+
 interface AgentInstallItem {
   key: string;
   scope: 'project' | 'global';
@@ -96,20 +172,31 @@ export async function POST(req: NextRequest) {
       const absPath = expandHome(configPath);
 
       try {
-        // Read existing config
-        let config: Record<string, unknown> = {};
-        if (fs.existsSync(absPath)) {
-          config = parseJsonc(fs.readFileSync(absPath, 'utf-8'));
-        }
-
-        // Merge — only touch mcpServers.mindos
-        if (!config[agent.key]) config[agent.key] = {};
-        (config[agent.key] as Record<string, unknown>).mindos = entry;
-
-        // Write
         const dir = path.dirname(absPath);
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+        if (agent.format === 'toml') {
+          // TOML format (e.g. Codex): merge into existing TOML or generate new
+          const existing = fs.existsSync(absPath) ? fs.readFileSync(absPath, 'utf-8') : '';
+          const merged = mergeTomlEntry(existing, agent.key, 'mindos', entry as Record<string, unknown>);
+          fs.writeFileSync(absPath, merged, 'utf-8');
+        } else {
+          // JSON format (default)
+          let config: Record<string, unknown> = {};
+          if (fs.existsSync(absPath)) {
+            config = parseJsonc(fs.readFileSync(absPath, 'utf-8'));
+          }
+
+          // For global scope with nested key (e.g. VS Code: mcp.servers),
+          // write to the nested path instead of the flat key
+          const useNestedKey = isGlobal && agent.globalNestedKey;
+          const container = useNestedKey
+            ? ensureNestedPath(config, agent.globalNestedKey!)
+            : (() => { if (!config[agent.key]) config[agent.key] = {}; return config[agent.key] as Record<string, unknown>; })();
+          container.mindos = entry;
+
+          fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        }
 
         const result: typeof results[number] = { agent: key, status: 'ok', path: configPath, transport: effectiveTransport };
 

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

@@ -50,7 +50,7 @@ export async function GET(req: NextRequest) {
       transport: 'http',
       endpoint,
       port,
-      toolCount: running ? 20 : 0,
+      toolCount: running ? 23 : 0,
       authConfigured,
       // Masked for display; full token only used server-side in snippet generation
       maskedToken: authConfigured ? maskToken(token) : undefined,

package/app/components/ActivityBar.tsx

@@ -2,13 +2,13 @@
 
 import { useRef, useCallback, useState, useEffect } from 'react';
 import Link from 'next/link';
-import { FolderTree, Search, Settings, RefreshCw, Blocks, Bot, Compass, HelpCircle, ChevronLeft, ChevronRight, Radio } from 'lucide-react';
+import { FolderTree, Search, Settings, RefreshCw, Bot, Compass, HelpCircle, ChevronLeft, ChevronRight, Radio } from 'lucide-react';
 import { useLocale } from '@/lib/LocaleContext';
 import { DOT_COLORS, getStatusLevel } from './SyncStatusBar';
 import type { SyncStatus } from './settings/SyncTab';
 import Logo from './Logo';
 
-export type PanelId = 'files' | 'search' | 'echo' | 'plugins' | 'agents' | 'discover';
+export type PanelId = 'files' | 'search' | 'echo' | 'agents' | 'discover';
 
 export const RAIL_WIDTH_COLLAPSED = 48;
 export const RAIL_WIDTH_EXPANDED = 180;
@@ -181,9 +181,8 @@ export default function ActivityBar({
         {/* ── Middle: Core panel toggles ── */}
         <div className={`flex flex-col ${expanded ? 'px-1.5' : 'items-center'} gap-1 py-2`}>
           <RailButton icon={<FolderTree size={18} />} label={t.sidebar.files} active={activePanel === 'files'} expanded={expanded} onClick={() => toggle('files')} walkthroughId="files-panel" />
-          <RailButton icon={<Radio size={18} />} label={t.sidebar.echo} active={activePanel === 'echo'} expanded={expanded} onClick={() => toggle('echo')} />
           <RailButton icon={<Search size={18} />} label={t.sidebar.searchTitle} shortcut="⌘K" active={activePanel === 'search'} expanded={expanded} onClick={() => toggle('search')} walkthroughId="search-button" />
-          <RailButton icon={<Blocks size={18} />} label={t.sidebar.plugins} active={activePanel === 'plugins'} expanded={expanded} onClick={() => toggle('plugins')} />
+          <RailButton icon={<Radio size={18} />} label={t.sidebar.echo} active={activePanel === 'echo'} expanded={expanded} onClick={() => toggle('echo')} />
           <RailButton
             icon={<Bot size={18} />}
             label={t.sidebar.agents}

package/app/components/FileTree.tsx

@@ -6,7 +6,7 @@ import { FileNode } from '@/lib/types';
 import { encodePath } from '@/lib/utils';
 import {
   ChevronDown, FileText, Table, Folder, FolderOpen, Plus, Loader2,
-  Trash2, Pencil, Layers, ScrollText,
+  Trash2, Pencil, Layers, ScrollText, FolderInput,
 } from 'lucide-react';
 import { createFileAction, deleteFileAction, renameFileAction, renameSpaceAction, deleteSpaceAction, convertToSpaceAction, deleteFolderAction } from '@/lib/actions';
 import { useLocale } from '@/lib/LocaleContext';
@@ -23,6 +23,7 @@ interface FileTreeProps {
   onNavigate?: () => void;
   maxOpenDepth?: number | null;
   parentIsSpace?: boolean;
+  onImport?: (space: string) => void;
 }
 
 function getIcon(node: FileNode) {
@@ -96,8 +97,8 @@ const MENU_DIVIDER = "my-1 border-t border-border/50";
 
 // ─── SpaceContextMenu ─────────────────────────────────────────────────────────
 
-function SpaceContextMenu({ x, y, node, onClose, onRename }: {
-  x: number; y: number; node: FileNode; onClose: () => void; onRename: () => void;
+function SpaceContextMenu({ x, y, node, onClose, onRename, onImport }: {
+  x: number; y: number; node: FileNode; onClose: () => void; onRename: () => void; onImport?: (space: string) => void;
 }) {
   const router = useRouter();
   const { t } = useLocale();
@@ -108,6 +109,11 @@ function SpaceContextMenu({ x, y, node, onClose, onRename }: {
       <button className={MENU_ITEM} onClick={() => { router.push(`/view/${encodePath(`${node.path}/INSTRUCTION.md`)}`); onClose(); }}>
         <ScrollText size={14} className="shrink-0" /> {t.fileTree.editRules}
       </button>
+      {onImport && (
+        <button className={MENU_ITEM} onClick={() => { onImport(node.path); onClose(); }}>
+          <FolderInput size={14} className="shrink-0" /> {t.fileTree.importFile}
+        </button>
+      )}
       <button className={MENU_ITEM} onClick={() => { onRename(); onClose(); }}>
         <Pencil size={14} className="shrink-0" /> {t.fileTree.renameSpace}
       </button>
@@ -240,9 +246,9 @@ function NewFileInline({ dirPath, depth, onDone }: { dirPath: string; depth: num
 
 // ─── DirectoryNode ────────────────────────────────────────────────────────────
 
-function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth }: {
+function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth, onImport }: {
   node: FileNode; depth: number; currentPath: string; onNavigate?: () => void;
-  maxOpenDepth?: number | null;
+  maxOpenDepth?: number | null; onImport?: (space: string) => void;
 }) {
   const router = useRouter();
   const isActive = currentPath.startsWith(node.path + '/') || currentPath === node.path;
@@ -255,6 +261,8 @@ function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth }: {
   const renameRef = useRef<HTMLInputElement>(null);
   const clickTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const [contextMenu, setContextMenu] = useState<{ x: number; y: number } | null>(null);
+  const [plusPopover, setPlusPopover] = useState(false);
+  const plusRef = useRef<HTMLButtonElement>(null);
   const { t } = useLocale();
 
   const toggle = useCallback(() => setOpen(v => !v), []);
@@ -391,12 +399,12 @@ function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth }: {
         </button>
         <div className="absolute right-1 top-1/2 -translate-y-1/2 hidden group-hover/dir:flex items-center gap-0.5 z-10">
           <button
+            ref={plusRef}
             type="button"
             onClick={(e) => {
               e.preventDefault();
               e.stopPropagation();
-              setOpen(true);
-              setShowNewFile(true);
+              setPlusPopover(v => !v);
             }}
             className="p-0.5 rounded text-muted-foreground hover:text-foreground hover:bg-muted transition-colors"
             title={t.fileTree.newFileTitle}
@@ -444,6 +452,7 @@ function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth }: {
             onNavigate={onNavigate}
             maxOpenDepth={maxOpenDepth}
             parentIsSpace={isSpace}
+            onImport={onImport}
           />
         )}
         {showNewFile && (
@@ -462,6 +471,7 @@ function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth }: {
           node={node}
           onClose={() => setContextMenu(null)}
           onRename={() => startRename()}
+          onImport={onImport}
         />
       ) : (
         <FolderContextMenu
@@ -472,6 +482,22 @@ function DirectoryNode({ node, depth, currentPath, onNavigate, maxOpenDepth }: {
           onRename={() => startRename()}
         />
       ))}
+
+      {plusPopover && plusRef.current && (() => {
+        const rect = plusRef.current!.getBoundingClientRect();
+        return (
+          <ContextMenuShell x={rect.left} y={rect.bottom + 4} onClose={() => setPlusPopover(false)} menuHeight={80}>
+            <button className={MENU_ITEM} onClick={() => { setPlusPopover(false); setOpen(true); setShowNewFile(true); }}>
+              <FileText size={14} className="shrink-0" /> {t.fileTree.newFile}
+            </button>
+            {onImport && (
+              <button className={MENU_ITEM} onClick={() => { setPlusPopover(false); onImport(node.path); }}>
+                <FolderInput size={14} className="shrink-0" /> {t.fileTree.importFile}
+              </button>
+            )}
+          </ContextMenuShell>
+        );
+      })()}
     </div>
   );
 }
@@ -589,7 +615,7 @@ function FileNodeItem({ node, depth, currentPath, onNavigate }: {
 
 // ─── FileTree (root) ──────────────────────────────────────────────────────────
 
-export default function FileTree({ nodes, depth = 0, onNavigate, maxOpenDepth, parentIsSpace }: FileTreeProps) {
+export default function FileTree({ nodes, depth = 0, onNavigate, maxOpenDepth, parentIsSpace, onImport }: FileTreeProps) {
   const pathname = usePathname();
   const currentPath = getCurrentFilePath(pathname);
 
@@ -609,7 +635,7 @@ export default function FileTree({ nodes, depth = 0, onNavigate, maxOpenDepth, p
     <div className="flex flex-col gap-0.5">
       {visibleNodes.map((node) =>
         node.type === 'directory' ? (
-          <DirectoryNode key={node.path} node={node} depth={depth} currentPath={currentPath} onNavigate={onNavigate} maxOpenDepth={maxOpenDepth} />
+          <DirectoryNode key={node.path} node={node} depth={depth} currentPath={currentPath} onNavigate={onNavigate} maxOpenDepth={maxOpenDepth} onImport={onImport} />
         ) : (
           <FileNodeItem key={node.path} node={node} depth={depth} currentPath={currentPath} onNavigate={onNavigate} />
         )