@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/hooks/useAskSession.ts

@@ -0,0 +1,310 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import type { AgentIdentity, Message, ChatSession } from '@/lib/types';
+import { apiFetch } from '@/lib/api';
+import { bindSessionAgent } from '@/lib/ask-agent';
+
+const MAX_SESSIONS = 30;
+
+function createSession(currentFile?: string): ChatSession {
+  const ts = Date.now();
+  return {
+    id: `${ts}-${Math.random().toString(36).slice(2, 8)}`,
+    currentFile,
+    createdAt: ts,
+    updatedAt: ts,
+    messages: [],
+  };
+}
+
+export function sessionTitle(s: ChatSession): string {
+  if (s.title) return s.title;
+  const firstUser = s.messages.find((m) => m.role === 'user');
+  if (!firstUser) return '(empty session)';
+  const line = firstUser.content.replace(/\s+/g, ' ').trim();
+  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[]> {
+  try {
+    const res = await fetch('/api/ask-sessions', { cache: 'no-store' });
+    if (!res.ok) return [];
+    const data = (await res.json()) as ChatSession[];
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, MAX_SESSIONS);
+  } catch {
+    return [];
+  }
+}
+
+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: stripped }),
+    });
+  } catch {
+    // ignore persistence errors
+  }
+}
+
+async function removeSession(id: string): Promise<void> {
+  try {
+    await fetch('/api/ask-sessions', {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id }),
+    });
+  } catch {
+    // ignore persistence errors
+  }
+}
+
+async function removeSessions(ids: string[]): Promise<void> {
+  try {
+    await fetch('/api/ask-sessions', {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ ids }),
+    });
+  } catch {
+    // ignore persistence errors
+  }
+}
+
+export function useAskSession(currentFile?: string) {
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [sessions, setSessions] = useState<ChatSession[]>([]);
+  const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
+  const persistTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  /** Load sessions from server, pick the matching one or create fresh. Prunes stale empty sessions. */
+  const initSessions = useCallback(async () => {
+    const all = (await fetchSessions())
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, MAX_SESSIONS);
+
+    // Prune any empty sessions that leaked to server (from older versions)
+    const emptyIds = all.filter((s) => s.messages.length === 0).map((s) => s.id);
+    const sorted = emptyIds.length > 0 ? all.filter((s) => !emptyIds.includes(s.id)) : all;
+    if (emptyIds.length > 0) void removeSessions(emptyIds);
+
+    // Always prepend a fresh empty session in memory (never persisted until first message)
+    const fresh = createSession(currentFile);
+    const matched = currentFile
+      ? sorted.find((sess) => sess.currentFile === currentFile)
+      : sorted[0];
+
+    if (matched) {
+      setActiveSessionId(matched.id);
+      setMessages(matched.messages);
+      setSessions([...sorted]);
+    } else {
+      setActiveSessionId(fresh.id);
+      setMessages([]);
+      // Empty session lives only in memory — no upsertSession call
+      setSessions([fresh, ...sorted].slice(0, MAX_SESSIONS));
+    }
+  }, [currentFile]);
+
+  /** Persist current session (debounced). Only persists if session has messages. */
+  const persistSession = useCallback(
+    (msgs: Message[], sessionId: string | null) => {
+      if (!sessionId || msgs.length === 0) return;
+      let sessionToPersist: ChatSession | null = null;
+      setSessions((prev) => {
+        const now = Date.now();
+        const existing = prev.find((s) => s.id === sessionId);
+        sessionToPersist = existing
+          ? { ...existing, currentFile, updatedAt: now, messages: msgs }
+          : { id: sessionId, currentFile, createdAt: now, updatedAt: now, messages: msgs };
+
+        const rest = prev.filter((s) => s.id !== sessionId);
+        return [sessionToPersist!, ...rest]
+          .sort((a, b) => b.updatedAt - a.updatedAt)
+          .slice(0, MAX_SESSIONS);
+      });
+
+      if (persistTimerRef.current) clearTimeout(persistTimerRef.current);
+      persistTimerRef.current = setTimeout(() => {
+        if (sessionToPersist) void upsertSession(sessionToPersist);
+      }, 600);
+    },
+    [currentFile],
+  );
+
+  const clearPersistTimer = useCallback(() => {
+    if (persistTimerRef.current) {
+      clearTimeout(persistTimerRef.current);
+      persistTimerRef.current = null;
+    }
+  }, []);
+
+  /** Create a brand-new session (memory only). If current session is already empty, reuse it. */
+  const resetSession = useCallback(() => {
+    setSessions((prev) => {
+      const active = prev.find((s) => s.id === activeSessionId);
+      // Already on an empty session — just clear input, don't create another
+      if (active && active.messages.length === 0) return prev;
+
+      const fresh = createSession(currentFile);
+      setActiveSessionId(fresh.id);
+      setMessages([]);
+      // Memory only — no upsertSession call. Will be persisted on first message.
+      return [fresh, ...prev]
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, MAX_SESSIONS);
+    });
+  }, [currentFile, activeSessionId]);
+
+  /** Switch to an existing session. Auto-drops abandoned empty sessions from memory. */
+  const loadSession = useCallback(
+    (id: string) => {
+      const target = sessions.find((s) => s.id === id);
+      if (!target) return;
+
+      // Drop the session we're leaving if it's empty (it was never persisted, just remove from memory)
+      const leaving = activeSessionId ? sessions.find((s) => s.id === activeSessionId) : null;
+      if (leaving && leaving.messages.length === 0 && leaving.id !== id) {
+        setSessions((prev) => prev.filter((s) => s.id !== leaving.id));
+      }
+
+      setActiveSessionId(target.id);
+      setMessages(target.messages);
+    },
+    [sessions, activeSessionId],
+  );
+
+  /** Delete a session. If it's the active one, create fresh (memory only). */
+  const deleteSession = useCallback(
+    (id: string) => {
+      const target = sessions.find((s) => s.id === id);
+      // Only call removeSession if the session has messages (i.e. was persisted)
+      if (target && target.messages.length > 0) void removeSession(id);
+
+      const remaining = sessions.filter((s) => s.id !== id);
+      setSessions(remaining);
+
+      if (activeSessionId === id) {
+        const fresh = createSession(currentFile);
+        setActiveSessionId(fresh.id);
+        setMessages([]);
+        setSessions([fresh, ...remaining].slice(0, MAX_SESSIONS));
+        // No upsertSession — memory only
+      }
+    },
+    [activeSessionId, currentFile, sessions],
+  );
+
+  const renameSession = useCallback((id: string, newTitle: string) => {
+    const trimmed = newTitle.trim();
+    setSessions((prev) => {
+      const idx = prev.findIndex((s) => s.id === id);
+      if (idx < 0) return prev;
+      const updated = { ...prev[idx], title: trimmed || undefined };
+      const next = [...prev];
+      next[idx] = updated;
+      void upsertSession(updated);
+      return next;
+    });
+  }, []);
+
+  /** Toggle pin/unpin a session. Pinned sessions sort to top. */
+  const togglePinSession = useCallback((id: string) => {
+    setSessions((prev) => {
+      const idx = prev.findIndex((s) => s.id === id);
+      if (idx < 0) return prev;
+      const updated = { ...prev[idx], pinned: !prev[idx].pinned };
+      const next = [...prev];
+      next[idx] = updated;
+      // Only persist if session has messages
+      if (updated.messages.length > 0) void upsertSession(updated);
+      return next;
+    });
+  }, []);
+
+  /** Update the session-level ACP agent binding for the currently active session. */
+  const setSessionDefaultAcpAgent = useCallback((agent: AgentIdentity | null) => {
+    if (!activeSessionId) return;
+
+    const currentSession = sessions.find((session) => session.id === activeSessionId);
+    if (!currentSession) return;
+
+    const updatedSession = bindSessionAgent({
+      ...currentSession,
+      currentFile: currentSession.currentFile ?? currentFile,
+      updatedAt: Date.now(),
+    }, agent);
+
+    setSessions((prev) => {
+      const rest = prev.filter((session) => session.id !== activeSessionId);
+      return [updatedSession, ...rest]
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, MAX_SESSIONS);
+    });
+
+    if (persistTimerRef.current) clearTimeout(persistTimerRef.current);
+    if (updatedSession.messages.length > 0) {
+      persistTimerRef.current = setTimeout(() => {
+        void upsertSession(updatedSession);
+      }, 600);
+    }
+  }, [activeSessionId, currentFile, sessions]);
+
+  const clearAllSessions = useCallback(() => {
+    // Only delete sessions that have messages (were persisted)
+    const persistedIds = sessions.filter(s => s.messages.length > 0).map(s => s.id);
+    if (persistedIds.length > 0) void removeSessions(persistedIds);
+
+    const fresh = createSession(currentFile);
+    setActiveSessionId(fresh.id);
+    setMessages([]);
+    setSessions([fresh]);
+    // No upsertSession — memory only
+  }, [currentFile, sessions]);
+
+  /** Sessions sorted: pinned first, then by updatedAt desc */
+  const sortedSessions = [...sessions].sort((a, b) => {
+    if (a.pinned && !b.pinned) return -1;
+    if (!a.pinned && b.pinned) return 1;
+    return b.updatedAt - a.updatedAt;
+  });
+  const activeSession = sessions.find((session) => session.id === activeSessionId) ?? null;
+
+  return {
+    messages,
+    setMessages,
+    sessions: sortedSessions,
+    activeSession,
+    activeSessionId,
+    initSessions,
+    persistSession,
+    clearPersistTimer,
+    resetSession,
+    loadSession,
+    deleteSession,
+    renameSession,
+    togglePinSession,
+    setSessionDefaultAcpAgent,
+    clearAllSessions,
+  };
+}

package/_standalone/hooks/useComposerVerticalResize.ts

@@ -0,0 +1,74 @@
+'use client';
+
+import { useCallback, type PointerEvent as ReactPointerEvent } from 'react';
+
+export interface UseComposerVerticalResizeOptions {
+  minHeight: number;
+  maxHeightAbs: number;
+  maxHeightViewportRatio: number;
+  getHeight: () => number;
+  setHeight: (h: number) => void;
+  persist: (h: number) => void;
+}
+
+/**
+ * Drag the top edge of a composer upward to grow height (panel input UX).
+ * Uses pointer capture so drag ends reliably (window exit, touch, pointercancel).
+ */
+export function useComposerVerticalResize({
+  minHeight,
+  maxHeightAbs,
+  maxHeightViewportRatio,
+  getHeight,
+  setHeight,
+  persist,
+}: UseComposerVerticalResizeOptions) {
+  const onPointerDown = useCallback(
+    (e: ReactPointerEvent<HTMLElement>) => {
+      if (e.pointerType === 'mouse' && e.button !== 0) return;
+      e.preventDefault();
+      const el = e.currentTarget;
+      el.setPointerCapture(e.pointerId);
+
+      const pointerId = e.pointerId;
+      const startY = e.clientY;
+      const startH = getHeight();
+      let currentH = startH;
+
+      const maxH = () => Math.min(maxHeightAbs, Math.floor(window.innerHeight * maxHeightViewportRatio));
+
+      document.body.classList.add('select-none');
+      document.body.style.cursor = 'ns-resize';
+
+      const onMove = (ev: PointerEvent) => {
+        if (ev.pointerId !== pointerId) return;
+        const dy = startY - ev.clientY;
+        const next = Math.round(Math.max(minHeight, Math.min(maxH(), startH + dy)));
+        currentH = next;
+        setHeight(next);
+      };
+
+      const onUpOrCancel = (ev: PointerEvent) => {
+        if (ev.pointerId !== pointerId) return;
+        document.body.classList.remove('select-none');
+        document.body.style.cursor = '';
+        el.removeEventListener('pointermove', onMove);
+        el.removeEventListener('pointerup', onUpOrCancel);
+        el.removeEventListener('pointercancel', onUpOrCancel);
+        try {
+          el.releasePointerCapture(pointerId);
+        } catch {
+          /* already released */
+        }
+        persist(currentH);
+      };
+
+      el.addEventListener('pointermove', onMove);
+      el.addEventListener('pointerup', onUpOrCancel);
+      el.addEventListener('pointercancel', onUpOrCancel);
+    },
+    [minHeight, maxHeightAbs, maxHeightViewportRatio, getHeight, setHeight, persist],
+  );
+
+  return onPointerDown;
+}

package/_standalone/hooks/useDelegationHistory.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type { DelegationRecord } from '@/lib/a2a/types';
+
+interface DelegationHistory {
+  delegations: DelegationRecord[];
+  loading: boolean;
+  refresh: () => void;
+}
+
+const POLL_INTERVAL_MS = 5_000;
+
+export function useDelegationHistory(active: boolean): DelegationHistory {
+  const [delegations, setDelegations] = useState<DelegationRecord[]>([]);
+  const [loading, setLoading] = useState(false);
+  const mountedRef = useRef(true);
+
+  const fetchHistory = useCallback(async () => {
+    setLoading(true);
+    try {
+      const res = await fetch('/api/a2a/delegations');
+      if (!res.ok) return;
+      const data = await res.json();
+      if (mountedRef.current) {
+        setDelegations(data.delegations ?? []);
+      }
+    } catch {
+      // silently ignore fetch errors
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => { mountedRef.current = false; };
+  }, []);
+
+  // Fetch on mount and poll while active
+  useEffect(() => {
+    if (!active) return;
+    fetchHistory();
+    const id = setInterval(fetchHistory, POLL_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, [active, fetchHistory]);
+
+  return { delegations, loading, refresh: fetchHistory };
+}

package/_standalone/hooks/useEditorImageUpload.ts

@@ -0,0 +1,113 @@
+/**
+ * Hook for uploading images to the .media/ directory in the editor.
+ *
+ * Unlike useImageUpload (for chat image attachments), this hook uploads
+ * images to the knowledge base's .media/ directory and returns file paths
+ * suitable for use in markdown `![alt](path)` syntax.
+ *
+ * Usage:
+ *   const { uploadToMedia, isUploading } = useEditorImageUpload();
+ *   const paths = await uploadToMedia([file1, file2]);
+ *   // paths = ['/.media/2026-04-07_abc123.png', ...]
+ */
+
+import { useState, useCallback } from 'react';
+
+const MAX_IMAGE_SIZE = 10 * 1024 * 1024; // 10 MB per image
+const ALLOWED_IMAGE_TYPES = new Set([
+  'image/png',
+  'image/jpeg',
+  'image/gif',
+  'image/webp',
+  'image/svg+xml',
+  'image/bmp',
+  'image/x-icon',
+  'image/vnd.microsoft.icon',
+]);
+
+/**
+ * Generates a unique filename: YYYY-MM-DD_randomhash.ext
+ */
+function generateImageFileName(originalName: string): string {
+  const ext = originalName.split('.').pop()?.toLowerCase() || 'png';
+  const timestamp = new Date().toISOString().split('T')[0];
+  const randomHash = Math.random().toString(36).slice(2, 10);
+  return `${timestamp}_${randomHash}.${ext}`;
+}
+
+/** Converts a File to base64 string (without data URL prefix). */
+async function fileToBase64(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result as string;
+      resolve(result.split(',')[1]); // Strip "data:image/...;base64," prefix
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+
+export function useEditorImageUpload() {
+  const [isUploading, setIsUploading] = useState(false);
+
+  const uploadToMedia = useCallback(async (files: File[]): Promise<string[]> => {
+    setIsUploading(true);
+
+    try {
+      // Filter valid images
+      const validFiles: Array<{ base64: string; newName: string }> = [];
+      const skippedReasons: string[] = [];
+
+      for (const file of files) {
+        if (!ALLOWED_IMAGE_TYPES.has(file.type)) {
+          skippedReasons.push(`${file.name}: unsupported format`);
+          continue;
+        }
+        if (file.size > MAX_IMAGE_SIZE) {
+          skippedReasons.push(`${file.name}: exceeds 10MB limit`);
+          continue;
+        }
+
+        const base64 = await fileToBase64(file);
+        const newName = generateImageFileName(file.name);
+        validFiles.push({ base64, newName });
+      }
+
+      if (validFiles.length === 0) {
+        throw new Error(skippedReasons.length > 0
+          ? skippedReasons.join('; ')
+          : 'No valid images to upload');
+      }
+
+      const response = await fetch('/api/file/import', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          files: validFiles.map((img) => ({
+            name: img.newName,
+            content: img.base64,
+            encoding: 'base64',
+          })),
+          targetSpace: '.media',
+          organize: false,  // Don't trigger AI organize for media files
+          conflict: 'rename',
+        }),
+      });
+
+      if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || `Upload failed: ${response.statusText}`);
+      }
+
+      const result = await response.json();
+      return (result.created ?? []).map(
+        (item: { path: string }) => `/${item.path}`,
+      );
+    } finally {
+      setIsUploading(false);
+    }
+  }, []);
+
+  return { uploadToMedia, isUploading };
+}