@geminilight/mindos 0.6.29 → 0.6.31

package/app/hooks/useAcpConfig.ts

@@ -0,0 +1,96 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import type { AcpAgentOverride } from '@/lib/acp/agent-descriptors';
+
+interface AcpConfigState {
+  configs: Record<string, AcpAgentOverride>;
+  loading: boolean;
+  saving: boolean;
+  error: string | null;
+  /** Save a per-agent override. */
+  save: (agentId: string, config: AcpAgentOverride) => Promise<boolean>;
+  /** Reset a single agent to defaults. */
+  reset: (agentId: string) => Promise<boolean>;
+  /** Refresh from server. */
+  refresh: () => void;
+}
+
+export function useAcpConfig(): AcpConfigState {
+  const [configs, setConfigs] = useState<Record<string, AcpAgentOverride>>({});
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [trigger, setTrigger] = useState(0);
+
+  const refresh = useCallback(() => setTrigger((n) => n + 1), []);
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+
+    fetch('/api/acp/config')
+      .then((res) => {
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return res.json();
+      })
+      .then((data) => {
+        if (cancelled) return;
+        setConfigs(data.agents ?? {});
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        setError((err as Error).message);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => { cancelled = true; };
+  }, [trigger]);
+
+  const save = useCallback(async (agentId: string, config: AcpAgentOverride): Promise<boolean> => {
+    setSaving(true);
+    setError(null);
+    try {
+      const res = await fetch('/api/acp/config', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ agentId, config }),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      setConfigs(data.agents ?? {});
+      return true;
+    } catch (err) {
+      setError((err as Error).message);
+      return false;
+    } finally {
+      setSaving(false);
+    }
+  }, []);
+
+  const reset = useCallback(async (agentId: string): Promise<boolean> => {
+    setSaving(true);
+    setError(null);
+    try {
+      const res = await fetch('/api/acp/config', {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ agentId }),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      setConfigs(data.agents ?? {});
+      return true;
+    } catch (err) {
+      setError((err as Error).message);
+      return false;
+    } finally {
+      setSaving(false);
+    }
+  }, []);
+
+  return { configs, loading, saving, error, save, reset, refresh };
+}

package/app/hooks/useAcpDetection.ts

@@ -1,17 +1,23 @@
 'use client';
 
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 
 export interface DetectedAgent {
   id: string;
   name: string;
   binaryPath: string;
+  resolvedCommand?: {
+    cmd: string;
+    args: string[];
+    source: 'user-override' | 'descriptor' | 'registry';
+  };
 }
 
 export interface NotInstalledAgent {
   id: string;
   name: string;
   installCmd: string;
+  packageName?: string;
 }
 
 interface AcpDetectionState {
@@ -22,44 +28,93 @@ interface AcpDetectionState {
   refresh: () => void;
 }
 
+const STORAGE_KEY = 'mindos:acp-detection';
+const STALE_TTL_MS = 30 * 60 * 1000;
+const REVALIDATE_TTL_MS = 5 * 60 * 1000;
+
+interface DetectionCache {
+  installed: DetectedAgent[];
+  notInstalled: NotInstalledAgent[];
+  ts: number;
+}
+
+function readStorage(): DetectionCache | null {
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.ts !== 'number' || Date.now() - parsed.ts > STALE_TTL_MS) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeStorage(installed: DetectedAgent[], notInstalled: NotInstalledAgent[]) {
+  try {
+    sessionStorage.setItem(STORAGE_KEY, JSON.stringify({ installed, notInstalled, ts: Date.now() }));
+  } catch { /* quota exceeded */ }
+}
+
 export function useAcpDetection(): AcpDetectionState {
-  const [installedAgents, setInstalledAgents] = useState<DetectedAgent[]>([]);
-  const [notInstalledAgents, setNotInstalledAgents] = useState<NotInstalledAgent[]>([]);
-  const [loading, setLoading] = useState(true);
+  const cached = useRef(readStorage());
+  const [installedAgents, setInstalledAgents] = useState<DetectedAgent[]>(cached.current?.installed ?? []);
+  const [notInstalledAgents, setNotInstalledAgents] = useState<NotInstalledAgent[]>(cached.current?.notInstalled ?? []);
+  const [loading, setLoading] = useState(!cached.current);
   const [error, setError] = useState<string | null>(null);
   const [trigger, setTrigger] = useState(0);
+  const inflight = useRef(false);
+
+  const forceRef = useRef(false);
 
   const refresh = useCallback(() => {
+    try { sessionStorage.removeItem(STORAGE_KEY); } catch { /* ignore */ }
+    cached.current = null;
+    forceRef.current = true;
     setTrigger((n) => n + 1);
   }, []);
 
   useEffect(() => {
-    let cancelled = false;
-    setLoading(true);
+    const isForce = forceRef.current;
+    forceRef.current = false;
+
+    const fresh = cached.current && Date.now() - cached.current.ts < REVALIDATE_TTL_MS;
+    if (fresh && trigger === 0) return;
+
+    if (inflight.current) return;
+    inflight.current = true;
+
+    const hasCachedData = installedAgents.length > 0 || notInstalledAgents.length > 0;
+    if (!hasCachedData) setLoading(true);
     setError(null);
 
-    fetch('/api/acp/detect')
+    let cancelled = false;
+
+    fetch(`/api/acp/detect${isForce ? '?force=1' : ''}`)
       .then((res) => {
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         return res.json();
       })
       .then((data) => {
         if (cancelled) return;
-        setInstalledAgents(data.installed ?? []);
-        setNotInstalledAgents(data.notInstalled ?? []);
+        const inst: DetectedAgent[] = data.installed ?? [];
+        const notInst: NotInstalledAgent[] = data.notInstalled ?? [];
+        writeStorage(inst, notInst);
+        cached.current = { installed: inst, notInstalled: notInst, ts: Date.now() };
+        setInstalledAgents(inst);
+        setNotInstalledAgents(notInst);
       })
       .catch((err) => {
         if (cancelled) return;
-        setError((err as Error).message);
+        if (!hasCachedData) setError((err as Error).message);
       })
       .finally(() => {
+        inflight.current = false;
         if (!cancelled) setLoading(false);
       });
 
-    return () => {
-      cancelled = true;
-    };
-  }, [trigger]);
+    return () => { cancelled = true; };
+  }, [trigger]); // eslint-disable-line react-hooks/exhaustive-deps
 
   return { installedAgents, notInstalledAgents, loading, error, refresh };
 }

package/app/hooks/useAcpRegistry.ts

@@ -1,6 +1,6 @@
 'use client';
 
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import type { AcpRegistryEntry } from '@/lib/acp/types';
 
 interface AcpRegistryState {
@@ -10,21 +10,54 @@ interface AcpRegistryState {
   retry: () => void;
 }
 
+const STORAGE_KEY = 'mindos:acp-registry';
+const STALE_TTL_MS = 30 * 60 * 1000; // 30 min — show stale data instantly
+const REVALIDATE_TTL_MS = 10 * 60 * 1000; // 10 min — background refresh interval
+
+function readStorage(): { agents: AcpRegistryEntry[]; ts: number } | null {
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.agents) || typeof parsed.ts !== 'number') return null;
+    if (Date.now() - parsed.ts > STALE_TTL_MS) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeStorage(agents: AcpRegistryEntry[]) {
+  try {
+    sessionStorage.setItem(STORAGE_KEY, JSON.stringify({ agents, ts: Date.now() }));
+  } catch { /* quota exceeded — ignore */ }
+}
+
 export function useAcpRegistry(): AcpRegistryState {
-  const [agents, setAgents] = useState<AcpRegistryEntry[]>([]);
-  const [loading, setLoading] = useState(true);
+  const cached = useRef(readStorage());
+  const [agents, setAgents] = useState<AcpRegistryEntry[]>(cached.current?.agents ?? []);
+  const [loading, setLoading] = useState(!cached.current);
   const [error, setError] = useState<string | null>(null);
   const [trigger, setTrigger] = useState(0);
+  const inflight = useRef(false);
 
   const retry = useCallback(() => {
     setTrigger((n) => n + 1);
   }, []);
 
   useEffect(() => {
-    let cancelled = false;
-    setLoading(true);
+    const fresh = cached.current && Date.now() - cached.current.ts < REVALIDATE_TTL_MS;
+    if (fresh && trigger === 0) return;
+
+    if (inflight.current) return;
+    inflight.current = true;
+
+    const hasCachedData = agents.length > 0;
+    if (!hasCachedData) setLoading(true);
     setError(null);
 
+    let cancelled = false;
+
     fetch('/api/acp/registry')
       .then((res) => {
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -32,20 +65,22 @@ export function useAcpRegistry(): AcpRegistryState {
       })
       .then((data) => {
         if (cancelled) return;
-        setAgents(data.registry?.agents ?? []);
+        const list: AcpRegistryEntry[] = data.registry?.agents ?? [];
+        writeStorage(list);
+        cached.current = { agents: list, ts: Date.now() };
+        setAgents(list);
       })
       .catch((err) => {
         if (cancelled) return;
-        setError((err as Error).message);
+        if (!hasCachedData) setError((err as Error).message);
       })
       .finally(() => {
+        inflight.current = false;
         if (!cancelled) setLoading(false);
       });
 
-    return () => {
-      cancelled = true;
-    };
-  }, [trigger]);
+    return () => { cancelled = true; };
+  }, [trigger]); // eslint-disable-line react-hooks/exhaustive-deps
 
   return { agents, loading, error, retry };
 }

package/app/hooks/useAskModal.ts

@@ -8,13 +8,19 @@ import { useSyncExternalStore, useCallback } from 'react';
  * No external dependencies (no zustand needed).
  */
 
+export interface AcpAgentSelection {
+  id: string;
+  name: string;
+}
+
 interface AskModalState {
   open: boolean;
   initialMessage: string;
   source: 'user' | 'guide' | 'guide-next';  // who triggered the open
+  acpAgent: AcpAgentSelection | null;
 }
 
-let state: AskModalState = { open: false, initialMessage: '', source: 'user' };
+let state: AskModalState = { open: false, initialMessage: '', source: 'user', acpAgent: null };
 const listeners = new Set<() => void>();
 
 function emit() { listeners.forEach(l => l()); }
@@ -24,13 +30,13 @@ function subscribe(listener: () => void) {
 }
 function getSnapshot() { return state; }
 
-export function openAskModal(message = '', source: AskModalState['source'] = 'user') {
-  state = { open: true, initialMessage: message, source };
+export function openAskModal(message = '', source: AskModalState['source'] = 'user', acpAgent: AcpAgentSelection | null = null) {
+  state = { open: true, initialMessage: message, source, acpAgent };
   emit();
 }
 
 export function closeAskModal() {
-  state = { open: false, initialMessage: '', source: 'user' };
+  state = { open: false, initialMessage: '', source: 'user', acpAgent: null };
   emit();
 }
 
@@ -40,7 +46,8 @@ export function useAskModal() {
     open: snap.open,
     initialMessage: snap.initialMessage,
     source: snap.source,
-    openWith: useCallback((message: string, source: AskModalState['source'] = 'user') => openAskModal(message, source), []),
+    acpAgent: snap.acpAgent,
+    openWith: useCallback((message: string, source: AskModalState['source'] = 'user', acpAgent: AcpAgentSelection | null = null) => openAskModal(message, source, acpAgent), []),
     close: useCallback(() => closeAskModal(), []),
   };
 }

package/app/hooks/useAskPanel.ts

@@ -2,7 +2,7 @@
 
 import { useState, useEffect, useCallback } from 'react';
 import { RIGHT_ASK_DEFAULT_WIDTH, RIGHT_ASK_MIN_WIDTH, RIGHT_ASK_MAX_WIDTH } from '@/components/RightAskPanel';
-import { useAskModal } from './useAskModal';
+import { useAskModal, type AcpAgentSelection } from './useAskModal';
 
 export interface AskPanelState {
   askPanelOpen: boolean;
@@ -12,6 +12,7 @@ export interface AskPanelState {
   desktopAskPopupOpen: boolean;
   askInitialMessage: string;
   askOpenSource: 'user' | 'guide' | 'guide-next';
+  askAcpAgent: AcpAgentSelection | null;
   toggleAskPanel: () => void;
   closeAskPanel: () => void;
   closeDesktopAskPopup: () => void;
@@ -33,6 +34,7 @@ export function useAskPanel(): AskPanelState {
   const [askInitialMessage, setAskInitialMessage] = useState('');
   const [askMaximized, setAskMaximized] = useState(false);
   const [askOpenSource, setAskOpenSource] = useState<'user' | 'guide' | 'guide-next'>('user');
+  const [askAcpAgent, setAskAcpAgent] = useState<AcpAgentSelection | null>(null);
 
   const askModal = useAskModal();
 
@@ -62,6 +64,7 @@ export function useAskPanel(): AskPanelState {
     if (askModal.open) {
       setAskInitialMessage(askModal.initialMessage);
       setAskOpenSource(askModal.source);
+      setAskAcpAgent(askModal.acpAgent);
       if (askMode === 'popup') {
         setDesktopAskPopupOpen(true);
       } else {
@@ -69,17 +72,17 @@ export function useAskPanel(): AskPanelState {
       }
       askModal.close();
     }
-  }, [askModal.open, askModal.initialMessage, askModal.source, askModal.close, askMode]);
+  }, [askModal.open, askModal.initialMessage, askModal.source, askModal.acpAgent, askModal.close, askMode]);
 
   const toggleAskPanel = useCallback(() => {
     if (askMode === 'popup') {
       setDesktopAskPopupOpen(v => {
-        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); }
+        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); setAskAcpAgent(null); }
         return !v;
       });
     } else {
       setAskPanelOpen(v => {
-        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); }
+        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); setAskAcpAgent(null); }
         return !v;
       });
     }
@@ -114,7 +117,7 @@ export function useAskPanel(): AskPanelState {
 
   return {
     askPanelOpen, askPanelWidth, askMaximized, askMode, desktopAskPopupOpen,
-    askInitialMessage, askOpenSource,
+    askInitialMessage, askOpenSource, askAcpAgent,
     toggleAskPanel, closeAskPanel, closeDesktopAskPopup,
     handleAskWidthChange, handleAskWidthCommit, handleAskModeSwitch, toggleAskMaximized,
   };

package/app/hooks/useAskSession.ts

@@ -21,7 +21,10 @@ export function sessionTitle(s: ChatSession): string {
   const firstUser = s.messages.find((m) => m.role === 'user');
   if (!firstUser) return '(empty session)';
   const line = firstUser.content.replace(/\s+/g, ' ').trim();
-  return line.length > 42 ? `${line.slice(0, 42)}...` : line;
+  if (!line && firstUser.images && firstUser.images.length > 0) {
+    return `[${firstUser.images.length} image${firstUser.images.length > 1 ? 's' : ''}]`;
+  }
+  return line.length > 42 ? `${line.slice(0, 42)}...` : line || '(empty session)';
 }
 
 async function fetchSessions(): Promise<ChatSession[]> {
@@ -38,10 +41,24 @@ async function fetchSessions(): Promise<ChatSession[]> {
 
 async function upsertSession(session: ChatSession): Promise<void> {
   try {
+    // Strip base64 image data before persisting (images are session-only, not stored)
+    const stripped: ChatSession = {
+      ...session,
+      messages: session.messages.map(m => {
+        if (!m.images || m.images.length === 0) return m;
+        return {
+          ...m,
+          images: m.images.map(img => ({
+            ...img,
+            data: '', // Strip base64 data — images are ephemeral
+          })),
+        };
+      }),
+    };
     await fetch('/api/ask-sessions', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ session }),
+      body: JSON.stringify({ session: stripped }),
     });
   } catch {
     // ignore persistence errors

package/app/hooks/useImageUpload.ts

@@ -0,0 +1,152 @@
+'use client';
+
+import { useState, useCallback } from 'react';
+import type { ImagePart, ImageMimeType } from '@/lib/types';
+
+const ALLOWED_IMAGE_TYPES: Set<string> = new Set([
+  'image/png', 'image/jpeg', 'image/gif', 'image/webp',
+]);
+
+const MAX_IMAGE_SIZE = 5 * 1024 * 1024; // 5MB per image
+const MAX_IMAGES = 4;
+const MAX_DIMENSION = 1920; // Compress to this max width/height
+
+function isImageMimeType(type: string): type is ImageMimeType {
+  return ALLOWED_IMAGE_TYPES.has(type);
+}
+
+/** Compress image to JPEG if over size/dimension limits */
+async function compressImage(file: File): Promise<{ data: string; mimeType: ImageMimeType }> {
+  const mimeType = file.type as ImageMimeType;
+
+  // If small enough, use as-is (skip canvas compression to preserve GIF animation)
+  if (file.size <= MAX_IMAGE_SIZE) {
+    const buffer = await file.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return { data: btoa(binary), mimeType };
+  }
+
+  // Compress via canvas
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      let { width, height } = img;
+      if (width > MAX_DIMENSION || height > MAX_DIMENSION) {
+        const ratio = Math.min(MAX_DIMENSION / width, MAX_DIMENSION / height);
+        width = Math.round(width * ratio);
+        height = Math.round(height * ratio);
+      }
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext('2d');
+      if (!ctx) { reject(new Error('Canvas not supported')); return; }
+      ctx.drawImage(img, 0, 0, width, height);
+      const dataUrl = canvas.toDataURL('image/jpeg', 0.85);
+      const base64 = dataUrl.split(',')[1];
+      resolve({ data: base64, mimeType: 'image/jpeg' });
+      URL.revokeObjectURL(img.src);
+    };
+    img.onerror = () => { reject(new Error('Failed to load image')); URL.revokeObjectURL(img.src); };
+    img.src = URL.createObjectURL(file);
+  });
+}
+
+/** Convert clipboard/DataTransfer items to File[] */
+function extractImageFiles(items: DataTransferItemList | DataTransferItem[]): File[] {
+  const files: File[] = [];
+  const list = Array.from(items);
+  for (const item of list) {
+    if (item.kind === 'file' && ALLOWED_IMAGE_TYPES.has(item.type)) {
+      const file = item.getAsFile();
+      if (file) files.push(file);
+    }
+  }
+  return files;
+}
+
+export function useImageUpload() {
+  const [images, setImages] = useState<ImagePart[]>([]);
+  const [imageError, setImageError] = useState('');
+
+  const addImages = useCallback(async (files: File[]) => {
+    setImageError('');
+    const toProcess = files.slice(0, MAX_IMAGES);
+
+    const results: ImagePart[] = [];
+    for (const file of toProcess) {
+      if (!isImageMimeType(file.type)) {
+        setImageError(`Unsupported image type: ${file.type}`);
+        continue;
+      }
+      try {
+        const { data, mimeType } = await compressImage(file);
+        results.push({ type: 'image', data, mimeType });
+      } catch {
+        setImageError(`Failed to process image: ${file.name}`);
+      }
+    }
+
+    setImages(prev => {
+      const merged = [...prev, ...results];
+      if (merged.length > MAX_IMAGES) {
+        setImageError(`Maximum ${MAX_IMAGES} images allowed`);
+        return merged.slice(0, MAX_IMAGES);
+      }
+      return merged;
+    });
+  }, []);
+
+  /** Handle paste event — returns true if images were found */
+  const handlePaste = useCallback(async (e: ClipboardEvent | React.ClipboardEvent): Promise<boolean> => {
+    const items = e.clipboardData?.items;
+    if (!items) return false;
+    const files = extractImageFiles(items);
+    if (files.length === 0) return false;
+    await addImages(files);
+    return true;
+  }, [addImages]);
+
+  /** Handle drop event */
+  const handleDrop = useCallback(async (e: DragEvent | React.DragEvent) => {
+    const items = e.dataTransfer?.items;
+    if (!items) return;
+    const files = extractImageFiles(items);
+    if (files.length > 0) {
+      e.preventDefault();
+      await addImages(files);
+    }
+  }, [addImages]);
+
+  /** Handle file input change */
+  const handleFileSelect = useCallback(async (files: FileList | null) => {
+    if (!files) return;
+    const imageFiles = Array.from(files).filter(f => isImageMimeType(f.type));
+    await addImages(imageFiles);
+  }, [addImages]);
+
+  const removeImage = useCallback((idx: number) => {
+    setImages(prev => prev.filter((_, i) => i !== idx));
+  }, []);
+
+  const clearImages = useCallback(() => {
+    setImages([]);
+    setImageError('');
+  }, []);
+
+  return {
+    images,
+    imageError,
+    addImages,
+    handlePaste,
+    handleDrop,
+    handleFileSelect,
+    removeImage,
+    clearImages,
+  };
+}

package/app/lib/acp/acp-tools.ts

@@ -7,6 +7,7 @@ import { Type, type Static } from '@sinclair/typebox';
 import type { AgentTool } from '@mariozechner/pi-agent-core';
 import { getAcpAgents, findAcpAgent } from './registry';
 import { createSessionFromEntry, prompt, closeSession } from './session';
+import { getMindRoot } from '../fs';
 
 function textResult(text: string) {
   return { content: [{ type: 'text' as const, text }], details: {} };
@@ -75,7 +76,8 @@ export const acpTools: AgentTool<any>[] = [
           return textResult(`ACP agent not found: ${params.agent_id}. Use list_acp_agents to see available agents.`);
         }
 
-        const session = await createSessionFromEntry(entry);
+        const cwd = getMindRoot();
+        const session = await createSessionFromEntry(entry, { cwd });
 
         try {
           const response = await prompt(session.id, params.message);