@geminilight/mindos 0.5.69 → 0.5.70

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/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} />
         )