@geminilight/mindos 0.6.29 → 0.6.31

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

@@ -15,7 +15,7 @@ import { NextRequest, NextResponse } from 'next/server';
 import fs from 'fs';
 import path from 'path';
 import { getFileContent, getMindRoot } from '@/lib/fs';
-import { getModelConfig } from '@/lib/agent/model';
+import { getModelConfig, hasImages } from '@/lib/agent/model';
 import { getRequestScopedTools, getOrganizeTools, WRITE_TOOLS, truncate } from '@/lib/agent/tools';
 import { AGENT_SYSTEM_PROMPT, ORGANIZE_SYSTEM_PROMPT } from '@/lib/agent/prompt';
 import { toAgentMessages } from '@/lib/agent/to-agent-messages';
@@ -25,8 +25,16 @@ import { MindOSError, apiError, ErrorCodes } from '@/lib/errors';
 import { metrics } from '@/lib/metrics';
 import { assertNotProtected } from '@/lib/core';
 import { scanExtensionPaths } from '@/lib/pi-integration/extensions';
+import { createSession, promptStream, closeSession } from '@/lib/acp/session';
+import type { AcpSessionUpdate } from '@/lib/acp/types';
 import type { Message as FrontendMessage } from '@/lib/types';
 
+/** Safe JSON parse — returns {} on invalid input */
+function safeParseJson(raw: string | undefined): Record<string, unknown> {
+  if (!raw) return {};
+  try { return JSON.parse(raw); } catch { return {}; }
+}
+
 // ---------------------------------------------------------------------------
 // MindOS SSE format — 6 event types (front-back contract)
 // ---------------------------------------------------------------------------
@@ -254,6 +262,8 @@ export async function POST(req: NextRequest) {
     maxSteps?: number;
     /** 'organize' = lean prompt for file import organize; default = full prompt */
     mode?: 'organize' | 'default';
+    /** ACP agent selection: if present, route to ACP instead of MindOS */
+    selectedAcpAgent?: { id: string; name: string } | null;
   };
   try {
     body = await req.json();
@@ -261,7 +271,7 @@ export async function POST(req: NextRequest) {
     return apiError(ErrorCodes.INVALID_REQUEST, 'Invalid JSON body', 400);
   }
 
-  const { messages, currentFile, attachedFiles, uploadedFiles } = body;
+  const { messages, currentFile, attachedFiles, uploadedFiles, selectedAcpAgent } = body;
   const isOrganizeMode = body.mode === 'organize';
 
   // Read agent config from settings
@@ -433,15 +443,18 @@ export async function POST(req: NextRequest) {
   }
 
   try {
-    const { model, modelName, apiKey, provider } = getModelConfig();
+    const { model, modelName, apiKey, provider } = getModelConfig({ hasImages: hasImages(messages) });
 
     // Convert frontend messages to AgentMessage[]
     const agentMessages = toAgentMessages(messages);
 
     // Extract the last user message for agent.prompt()
-    const lastUserContent = messages.length > 0 && messages[messages.length - 1].role === 'user'
-      ? messages[messages.length - 1].content
-      : '';
+    const lastMsg = messages.length > 0 ? messages[messages.length - 1] : null;
+    const lastUserContent = lastMsg?.role === 'user' ? lastMsg.content : '';
+    // Extract images for prompt options (pi-ai ImageContent format, skip stripped)
+    const lastUserImages = lastMsg?.role === 'user' && lastMsg.images?.length
+      ? lastMsg.images.filter((img: any) => img.data).map((img: any) => ({ type: 'image' as const, data: img.data, mimeType: img.mimeType }))
+      : undefined;
 
     // History = all messages except the last user message (agent.prompt adds it)
     const historyMessages = agentMessages.slice(0, -1);
@@ -507,15 +520,20 @@ export async function POST(req: NextRequest) {
     const requestStartTime = Date.now();
     const stream = new ReadableStream({
       start(controller) {
+        let streamClosed = false;
         function send(event: MindOSSSEvent) {
+          if (streamClosed) return;
           try {
             controller.enqueue(encoder.encode(`data:${JSON.stringify(event)}\n\n`));
-          } catch (err) {
-            if (err instanceof TypeError) {
-              console.error('[ask] SSE send failed (serialization):', (err as Error).message, 'event type:', (event as { type?: string }).type);
-            }
+          } catch {
+            streamClosed = true;
           }
         }
+        function safeClose() {
+          if (streamClosed) return;
+          streamClosed = true;
+          try { controller.close(); } catch { /* already closed */ }
+        }
 
         let hasContent = false;
         let lastModelError = '';
@@ -603,19 +621,109 @@ export async function POST(req: NextRequest) {
           }
         });
 
-        session.prompt(lastUserContent).then(() => {
-          metrics.recordRequest(Date.now() - requestStartTime);
-          if (!hasContent && lastModelError) {
-            send({ type: 'error', message: lastModelError });
+        // ── Route to ACP agent if selected, otherwise use MindOS agent ──
+        const runAgent = async () => {
+          if (selectedAcpAgent) {
+            // Route to ACP agent with real-time streaming
+            let acpSessionId: string | undefined;
+            try {
+              const acpSession = await createSession(selectedAcpAgent.id, {
+                cwd: getMindRoot(),
+              });
+              acpSessionId = acpSession.id;
+
+              await promptStream(acpSessionId, lastUserContent, (update: AcpSessionUpdate) => {
+                switch (update.type) {
+                  // Text chunks → standard text_delta
+                  case 'agent_message_chunk':
+                  case 'text':
+                    if (update.text) {
+                      hasContent = true;
+                      send({ type: 'text_delta', delta: update.text });
+                    }
+                    break;
+
+                  // Agent thinking → thinking_delta (reuses existing Anthropic thinking UI)
+                  case 'agent_thought_chunk':
+                    if (update.text) {
+                      hasContent = true;
+                      send({ type: 'thinking_delta', delta: update.text });
+                    }
+                    break;
+
+                  // Tool calls → tool_start (reuses existing tool call UI)
+                  case 'tool_call':
+                    if (update.toolCall) {
+                      hasContent = true;
+                      send({
+                        type: 'tool_start',
+                        toolCallId: update.toolCall.toolCallId,
+                        toolName: update.toolCall.title ?? update.toolCall.kind ?? 'tool',
+                        args: safeParseJson(update.toolCall.rawInput),
+                      });
+                    }
+                    break;
+
+                  // Tool call updates → tool_end when completed/failed
+                  case 'tool_call_update':
+                    if (update.toolCall && (update.toolCall.status === 'completed' || update.toolCall.status === 'failed')) {
+                      send({
+                        type: 'tool_end',
+                        toolCallId: update.toolCall.toolCallId,
+                        output: update.toolCall.rawOutput ?? '',
+                        isError: update.toolCall.status === 'failed',
+                      });
+                    }
+                    break;
+
+                  // Plan → emit as text with structured format
+                  case 'plan':
+                    if (update.plan?.entries) {
+                      const planText = update.plan.entries
+                        .map(e => {
+                          const icon = e.status === 'completed' ? '\u2705' : e.status === 'in_progress' ? '\u26a1' : '\u23f3';
+                          return `${icon} ${e.content}`;
+                        })
+                        .join('\n');
+                      send({ type: 'text_delta', delta: `\n\n${planText}\n\n` });
+                    }
+                    break;
+
+                  // Error → stream error
+                  case 'error':
+                    send({ type: 'error', message: update.error ?? 'ACP agent error' });
+                    break;
+                }
+              });
+
+              send({ type: 'done' });
+            } catch (acpErr) {
+              const errMsg = acpErr instanceof Error ? acpErr.message : String(acpErr);
+              send({ type: 'error', message: `ACP Agent Error: ${errMsg}` });
+            } finally {
+              if (acpSessionId) {
+                await closeSession(acpSessionId).catch(() => {});
+              }
+            }
+            safeClose();
           } else {
-            send({ type: 'done' });
+            // Route to MindOS agent (existing logic)
+            await session.prompt(lastUserContent, lastUserImages ? { images: lastUserImages } : undefined);
+            metrics.recordRequest(Date.now() - requestStartTime);
+            if (!hasContent && lastModelError) {
+              send({ type: 'error', message: lastModelError });
+            } else {
+              send({ type: 'done' });
+            }
+            safeClose();
           }
-          controller.close();
-        }).catch((err) => {
+        };
+
+        runAgent().catch((err) => {
           metrics.recordRequest(Date.now() - requestStartTime);
           metrics.recordError();
           send({ type: 'error', message: err instanceof Error ? err.message : String(err) });
-          controller.close();
+          safeClose();
         });
       },
     });

package/app/app/api/export/route.ts

@@ -0,0 +1,105 @@
+import { NextRequest, NextResponse } from 'next/server';
+import path from 'path';
+import archiver from 'archiver';
+import { Readable, PassThrough } from 'stream';
+import { getMindRoot } from '@/lib/fs';
+import { readFile } from '@/lib/core/fs-ops';
+import { markdownToHTML, collectExportFiles } from '@/lib/core/export';
+
+export async function GET(req: NextRequest) {
+  const { searchParams } = req.nextUrl;
+  const filePath = searchParams.get('path');
+  const format = searchParams.get('format') ?? 'md';
+
+  if (!filePath) {
+    return NextResponse.json({ error: 'Missing path parameter' }, { status: 400 });
+  }
+
+  // Path traversal defense-in-depth
+  if (filePath.includes('..') || filePath.startsWith('/')) {
+    return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+  }
+
+  const mindRoot = getMindRoot();
+
+  try {
+    // ── Single file export ──
+    if (format === 'md') {
+      const content = readFile(mindRoot, filePath);
+      const fileName = path.basename(filePath);
+      return new NextResponse(content, {
+        headers: {
+          'Content-Type': 'text/markdown; charset=utf-8',
+          'Content-Disposition': `attachment; filename="${encodeURIComponent(fileName)}"`,
+        },
+      });
+    }
+
+    if (format === 'html') {
+      const content = readFile(mindRoot, filePath);
+      const title = path.basename(filePath, '.md');
+      const html = await markdownToHTML(content, title, filePath);
+      const fileName = path.basename(filePath, '.md') + '.html';
+      return new NextResponse(html, {
+        headers: {
+          'Content-Type': 'text/html; charset=utf-8',
+          'Content-Disposition': `attachment; filename="${encodeURIComponent(fileName)}"`,
+        },
+      });
+    }
+
+    // ── Directory/Space ZIP export ──
+    if (format === 'zip' || format === 'zip-html') {
+      const files = collectExportFiles(mindRoot, filePath);
+      if (files.length === 0) {
+        return NextResponse.json({ error: 'No exportable files found' }, { status: 404 });
+      }
+
+      const spaceName = path.basename(filePath);
+      const date = new Date().toISOString().slice(0, 10);
+      const zipName = `${spaceName}-${date}.zip`;
+
+      // Create archive
+      const archive = archiver('zip', { zlib: { level: 6 } });
+      const passThrough = new PassThrough();
+      archive.pipe(passThrough);
+
+      if (format === 'zip-html') {
+        // Convert each MD file to HTML
+        for (const file of files) {
+          if (file.relativePath.endsWith('.md')) {
+            const title = path.basename(file.relativePath, '.md');
+            const html = await markdownToHTML(file.content, title, file.relativePath);
+            const htmlPath = file.relativePath.replace(/\.md$/, '.html');
+            archive.append(html, { name: htmlPath });
+          } else {
+            archive.append(file.content, { name: file.relativePath });
+          }
+        }
+      } else {
+        for (const file of files) {
+          archive.append(file.content, { name: file.relativePath });
+        }
+      }
+
+      // Pipe archive errors to the passthrough stream
+      archive.on('error', (err) => passThrough.destroy(err));
+      void archive.finalize();
+
+      // Convert Node stream to Web ReadableStream
+      const readable = Readable.toWeb(passThrough) as ReadableStream;
+
+      return new NextResponse(readable, {
+        headers: {
+          'Content-Type': 'application/zip',
+          'Content-Disposition': `attachment; filename="${encodeURIComponent(zipName)}"`,
+        },
+      });
+    }
+
+    return NextResponse.json({ error: `Unsupported format: ${format}` }, { status: 400 });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Export failed';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/app/app/api/workflows/route.ts

@@ -0,0 +1,156 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import YAML from 'js-yaml';
+import { getMindRoot } from '@/lib/fs';
+
+const WORKFLOWS_DIR = '.mindos/workflows';
+
+function getWorkflowsDir(): string {
+  return path.join(getMindRoot(), WORKFLOWS_DIR);
+}
+
+interface WorkflowListItem {
+  path: string;
+  fileName: string;
+  title: string;
+  description?: string;
+  stepCount: number;
+  mtime: number;
+  error?: string;
+}
+
+function listWorkflows(): WorkflowListItem[] {
+  const dir = getWorkflowsDir();
+  if (!fs.existsSync(dir)) return [];
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const items: WorkflowListItem[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!/\.flow\.(yaml|yml)$/i.test(entry.name)) continue;
+
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.join(WORKFLOWS_DIR, entry.name);
+    const stat = fs.statSync(fullPath);
+
+    try {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      const parsed = YAML.load(content, { schema: YAML.JSON_SCHEMA }) as Record<string, unknown> | null;
+
+      if (!parsed || typeof parsed !== 'object') {
+        items.push({
+          path: relativePath,
+          fileName: entry.name,
+          title: entry.name.replace(/\.flow\.(yaml|yml)$/i, ''),
+          stepCount: 0,
+          mtime: stat.mtimeMs,
+          error: 'Invalid YAML',
+        });
+        continue;
+      }
+
+      const steps = Array.isArray(parsed.steps) ? parsed.steps : [];
+      items.push({
+        path: relativePath,
+        fileName: entry.name,
+        title: typeof parsed.title === 'string' ? parsed.title : entry.name.replace(/\.flow\.(yaml|yml)$/i, ''),
+        description: typeof parsed.description === 'string' ? parsed.description : undefined,
+        stepCount: steps.length,
+        mtime: stat.mtimeMs,
+      });
+    } catch (err) {
+      items.push({
+        path: relativePath,
+        fileName: entry.name,
+        title: entry.name.replace(/\.flow\.(yaml|yml)$/i, ''),
+        stepCount: 0,
+        mtime: stat.mtimeMs,
+        error: err instanceof Error ? err.message : 'Parse error',
+      });
+    }
+  }
+
+  // Sort by mtime descending (most recent first)
+  items.sort((a, b) => b.mtime - a.mtime);
+  return items;
+}
+
+const BLANK_TEMPLATE = `title: {TITLE}
+description: ""
+
+steps:
+  - id: step-1
+    name: Step 1
+    prompt: |
+      Describe what this step should do.
+`;
+
+export async function GET() {
+  try {
+    const workflows = listWorkflows();
+    return NextResponse.json({ workflows });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to list workflows' },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const name = typeof body.name === 'string' ? body.name.trim() : '';
+    if (!name) {
+      return NextResponse.json({ error: 'name is required' }, { status: 400 });
+    }
+
+    // Sanitize filename
+    const safeName = name.replace(/[/\\:*?"<>|]/g, '-');
+    const fileName = `${safeName}.flow.yaml`;
+    const dir = getWorkflowsDir();
+
+    // Create Workflows dir if needed
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const fullPath = path.join(dir, fileName);
+    if (fs.existsSync(fullPath)) {
+      return NextResponse.json({ error: 'Workflow already exists' }, { status: 409 });
+    }
+
+    // Generate content from template or blank
+    const template = typeof body.template === 'string' ? body.template : 'blank';
+    let content: string;
+
+    if (template !== 'blank') {
+      // Try to read template from templates dir
+      const templateDir = path.join(getMindRoot(), WORKFLOWS_DIR);
+      const templateFile = fs.readdirSync(templateDir).find(f =>
+        f.toLowerCase().includes(template.toLowerCase()) && /\.workflow\.(yaml|yml)$/i.test(f)
+      );
+      if (templateFile) {
+        content = fs.readFileSync(path.join(templateDir, templateFile), 'utf-8');
+        // Replace title with user's name
+        content = content.replace(/^title:.*$/m, `title: ${name}`);
+      } else {
+        content = BLANK_TEMPLATE.replace('{TITLE}', name);
+      }
+    } else {
+      content = BLANK_TEMPLATE.replace('{TITLE}', name);
+    }
+
+    fs.writeFileSync(fullPath, content, 'utf-8');
+
+    const relativePath = path.join(WORKFLOWS_DIR, fileName);
+    return NextResponse.json({ path: relativePath });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to create workflow' },
+      { status: 500 },
+    );
+  }
+}

package/app/app/globals.css

@@ -166,10 +166,10 @@ body {
   font-family: var(--prose-font-override, 'Lora', Georgia, serif);
   color: var(--prose-body);
   line-height: 1.85;
-  font-size: 0.95rem;
+  font-size: var(--prose-font-size-override, 0.95rem);
 }
 @media (min-width: 640px) {
-  .prose { font-size: 1rem; }
+  .prose { font-size: var(--prose-font-size-override, 1rem); }
 }
 .prose h1, .prose h2, .prose h3, .prose h4 {
   font-family: 'IBM Plex Sans', sans-serif;

package/app/app/page.tsx

@@ -1,6 +1,8 @@
 import { redirect } from 'next/navigation';
+import fs from 'fs';
+import path from 'path';
 import { readSettings } from '@/lib/settings';
-import { getRecentlyModified, getFileContent, getFileTree } from '@/lib/fs';
+import { getRecentlyModified, getFileContent, getFileTree, getMindRoot } from '@/lib/fs';
 import { getAllRenderers } from '@/lib/renderers/registry';
 import HomeContent from '@/components/HomeContent';
 import type { FileNode } from '@/lib/core/types';
@@ -52,8 +54,11 @@ function getTopLevelDirs(): SpaceInfo[] {
 }
 
 function getExistingFiles(paths: string[]): string[] {
+  const root = getMindRoot();
   return paths.filter(p => {
-    try { getFileContent(p); return true; } catch { return false; }
+    try {
+      return fs.existsSync(path.join(root, p));
+    } catch { return false; }
   });
 }
 

package/app/app/trash/page.tsx

@@ -0,0 +1,7 @@
+import { listTrashAction } from '@/lib/actions';
+import TrashPageClient from '@/components/TrashPageClient';
+
+export default async function TrashPage() {
+  const items = await listTrashAction();
+  return <TrashPageClient initialItems={items} />;
+}