@jlongo78/agent-spaces 0.7.7 → 0.8.0

package/.next/standalone/src/hooks/use-sessions.ts

@@ -0,0 +1,437 @@
+'use client';
+
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import type { SessionWithMeta, Project, SearchResult, AnalyticsOverview, ParsedMessage, Tag, Workspace } from '@/types/claude';
+import { api } from '@/lib/api';
+
+// ─── Sessions ───────────────────────────────────────────────
+
+interface SessionsParams {
+  projectId?: string;
+  starred?: boolean;
+  search?: string;
+  agentType?: string;
+  sortBy?: string;
+  sortDir?: string;
+  offset?: number;
+  limit?: number;
+  nodeFilter?: 'local' | 'all' | string;
+}
+
+interface SessionsResponse {
+  sessions: SessionWithMeta[];
+  total: number;
+  errors?: { nodeId: string; nodeName: string; error: string }[];
+}
+
+export function useSessions(params: SessionsParams = {}) {
+  return useQuery({
+    queryKey: ['sessions', params],
+    queryFn: async (): Promise<SessionsResponse> => {
+      const sp = new URLSearchParams();
+      if (params.projectId) sp.set('projectId', params.projectId);
+      if (params.starred !== undefined) sp.set('starred', String(params.starred));
+      if (params.search) sp.set('search', params.search);
+      if (params.agentType) sp.set('agentType', params.agentType);
+      if (params.sortBy) sp.set('sortBy', params.sortBy);
+      if (params.sortDir) sp.set('sortDir', params.sortDir);
+      if (params.offset !== undefined) sp.set('offset', String(params.offset));
+      if (params.limit !== undefined) sp.set('limit', String(params.limit));
+      if (params.nodeFilter === 'all') sp.set('nodes', 'all');
+
+      const res = await fetch(api(`/api/sessions?${sp}`));
+      return res.json();
+    },
+  });
+}
+
+export function useSession(id: string | null) {
+  return useQuery({
+    queryKey: ['session', id],
+    queryFn: async (): Promise<SessionWithMeta & { tagObjects?: Tag[]; workspaces?: Workspace[] }> => {
+      const res = await fetch(api(`/api/sessions/${id}`));
+      if (!res.ok) throw new Error('Session not found');
+      return res.json();
+    },
+    enabled: !!id,
+  });
+}
+
+export function useMessages(sessionId: string | null, offset = 0, limit = 50, nodeId?: string) {
+  return useQuery({
+    queryKey: ['messages', sessionId, offset, limit, nodeId],
+    queryFn: async (): Promise<{ messages: ParsedMessage[]; total: number; hasMore: boolean }> => {
+      const url = nodeId
+        ? api(`/api/network/proxy/${nodeId}/sessions/${sessionId}/messages?offset=${offset}&limit=${limit}`)
+        : api(`/api/sessions/${sessionId}/messages?offset=${offset}&limit=${limit}`);
+      const res = await fetch(url);
+      return res.json();
+    },
+    enabled: !!sessionId,
+  });
+}
+
+// ─── Session Actions ────────────────────────────────────────
+
+export function useToggleStar() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (sessionId: string) => {
+      const res = await fetch(api(`/api/sessions/${sessionId}`), {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'star' }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+export function useUpdateNotes() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ sessionId, notes }: { sessionId: string; notes: string }) => {
+      const res = await fetch(api(`/api/sessions/${sessionId}`), {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'notes', notes }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+export function useAddTag() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ sessionId, tagName }: { sessionId: string; tagName: string }) => {
+      const res = await fetch(api(`/api/sessions/${sessionId}`), {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'tag', tagName }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+      qc.invalidateQueries({ queryKey: ['tags'] });
+    },
+  });
+}
+
+export function useRemoveTag() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ sessionId, tagName }: { sessionId: string; tagName: string }) => {
+      const res = await fetch(api(`/api/sessions/${sessionId}`), {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'removeTag', tagName }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+      qc.invalidateQueries({ queryKey: ['tags'] });
+    },
+  });
+}
+
+export function useRenameSession() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ sessionId, name }: { sessionId: string; name: string }) => {
+      const res = await fetch(api(`/api/sessions/${sessionId}`), {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'rename', name }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+// ─── Tags ───────────────────────────────────────────────────
+
+export function useTags() {
+  return useQuery({
+    queryKey: ['tags'],
+    queryFn: async (): Promise<Tag[]> => {
+      const res = await fetch(api('/api/tags'));
+      return res.json();
+    },
+  });
+}
+
+export function useCreateTag() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ name, color }: { name: string; color?: string }) => {
+      const res = await fetch(api('/api/tags'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'create', name, color }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['tags'] });
+    },
+  });
+}
+
+export function useDeleteTag() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (tagId: number) => {
+      const res = await fetch(api('/api/tags'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'delete', tagId }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['tags'] });
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+export function useUpdateTagColor() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ tagId, color }: { tagId: number; color: string }) => {
+      const res = await fetch(api('/api/tags'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'updateColor', tagId, color }),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['tags'] });
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+// ─── Workspaces ─────────────────────────────────────────────
+
+export function useWorkspaces() {
+  return useQuery({
+    queryKey: ['workspaces'],
+    queryFn: async (): Promise<Workspace[]> => {
+      const res = await fetch(api('/api/workspaces'));
+      return res.json();
+    },
+  });
+}
+
+export function useRemoteWorkspaces() {
+  return useQuery({
+    queryKey: ['workspaces', 'remote'],
+    queryFn: async (): Promise<{
+      local: Workspace[];
+      remote: { nodeId: string; nodeName: string; workspaces: Workspace[] }[];
+      errors: { nodeId: string; nodeName: string; error: string }[];
+    }> => {
+      const res = await fetch(api('/api/workspaces?nodes=all'));
+      return res.json();
+    },
+  });
+}
+
+export function useCreateWorkspace() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (data: { name: string; description?: string; color?: string }) => {
+      const res = await fetch(api('/api/workspaces'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['workspaces'] });
+    },
+  });
+}
+
+export function useUpdateWorkspace() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ id, ...data }: { id: number; name?: string; description?: string; color?: string }) => {
+      const res = await fetch(api(`/api/workspaces/${id}`), {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['workspaces'] });
+    },
+  });
+}
+
+export function useDeleteWorkspace() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (id: number) => {
+      const res = await fetch(api(`/api/workspaces/${id}`), { method: 'DELETE' });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['workspaces'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+export function useWorkspaceSessions(workspaceId: number | null) {
+  return useQuery({
+    queryKey: ['workspace-sessions', workspaceId],
+    queryFn: async (): Promise<SessionWithMeta[]> => {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}`));
+      return res.json();
+    },
+    enabled: workspaceId !== null,
+  });
+}
+
+export function useAddSessionToWorkspace() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ workspaceId, sessionId, nodeId, title, cwd, agentType }: {
+      workspaceId: number; sessionId: string; nodeId?: string; title?: string; cwd?: string; agentType?: string;
+    }) => {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}/sessions`), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId, nodeId, title, cwd, agentType }),
+      });
+      if (!res.ok) throw new Error('Failed to add session to workspace');
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['workspaces'] });
+      qc.invalidateQueries({ queryKey: ['workspace-sessions'] });
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+export function useRemoveSessionFromWorkspace() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ workspaceId, sessionId }: { workspaceId: number; sessionId: string }) => {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}/sessions`), {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId }),
+      });
+      if (!res.ok) throw new Error('Failed to remove session from workspace');
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['workspaces'] });
+      qc.invalidateQueries({ queryKey: ['workspace-sessions'] });
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['session'] });
+    },
+  });
+}
+
+// ─── Bulk Operations ────────────────────────────────────────
+
+export function useBulkAction() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (data: { sessionIds: string[]; action: string; tagName?: string; workspaceId?: number }) => {
+      const res = await fetch(api('/api/bulk'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['sessions'] });
+      qc.invalidateQueries({ queryKey: ['workspaces'] });
+      qc.invalidateQueries({ queryKey: ['tags'] });
+    },
+  });
+}
+
+// ─── Projects ───────────────────────────────────────────────
+
+export function useProjects() {
+  return useQuery({
+    queryKey: ['projects'],
+    queryFn: async (): Promise<Project[]> => {
+      const res = await fetch(api('/api/projects'));
+      return res.json();
+    },
+  });
+}
+
+// ─── Search ─────────────────────────────────────────────────
+
+export function useSearch(query: string, projectId?: string, nodes?: 'all' | 'local') {
+  return useQuery({
+    queryKey: ['search', query, projectId, nodes],
+    queryFn: async (): Promise<{ results: SearchResult[]; query: string; errors?: any[] }> => {
+      const sp = new URLSearchParams({ q: query });
+      if (projectId) sp.set('projectId', projectId);
+      if (nodes === 'all') sp.set('nodes', 'all');
+      const res = await fetch(api(`/api/search?${sp}`));
+      return res.json();
+    },
+    enabled: query.length >= 2,
+  });
+}
+
+// ─── Analytics ──────────────────────────────────────────────
+
+export function useAnalytics() {
+  return useQuery({
+    queryKey: ['analytics'],
+    queryFn: async (): Promise<AnalyticsOverview> => {
+      const res = await fetch(api('/api/analytics/overview'));
+      return res.json();
+    },
+  });
+}
+
+// ─── Sync ───────────────────────────────────────────────────
+
+export function useSync() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      const res = await fetch(api('/api/sync'), { method: 'POST' });
+      return res.json();
+    },
+    onSuccess: () => {
+      qc.invalidateQueries();
+    },
+  });
+}

package/.next/standalone/src/hooks/use-speech-recognition.ts

@@ -0,0 +1,113 @@
+'use client';
+
+import { useState, useEffect, useRef, useCallback } from 'react';
+
+interface UseSpeechRecognitionReturn {
+  isListening: boolean;
+  isSupported: boolean;
+  transcript: string;
+  interimTranscript: string;
+  startListening: () => void;
+  stopListening: () => void;
+  resetTranscript: () => void;
+}
+
+export function useSpeechRecognition(): UseSpeechRecognitionReturn {
+  const [isListening, setIsListening] = useState(false);
+  const [isSupported, setIsSupported] = useState(false);
+  const [transcript, setTranscript] = useState('');
+  const [interimTranscript, setInterimTranscript] = useState('');
+  const recognitionRef = useRef<any>(null);
+
+  useEffect(() => {
+    let SpeechRecognition: any;
+    try {
+      SpeechRecognition =
+        (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition;
+    } catch {
+      // Not available
+    }
+    setIsSupported(!!SpeechRecognition);
+
+    if (!SpeechRecognition) return;
+
+    let recognition: any;
+    try {
+      recognition = new SpeechRecognition();
+      recognition.continuous = false;
+      recognition.interimResults = true;
+      recognition.lang = 'en-US';
+    } catch {
+      setIsSupported(false);
+      return;
+    }
+
+    recognition.onresult = (event: any) => {
+      let interim = '';
+      let final = '';
+
+      for (let i = event.resultIndex; i < event.results.length; i++) {
+        const result = event.results[i];
+        if (result.isFinal) {
+          final += result[0].transcript;
+        } else {
+          interim += result[0].transcript;
+        }
+      }
+
+      if (final) {
+        setTranscript(final);
+        setInterimTranscript('');
+      } else {
+        setInterimTranscript(interim);
+      }
+    };
+
+    recognition.onerror = () => {
+      setIsListening(false);
+    };
+
+    recognition.onend = () => {
+      setIsListening(false);
+    };
+
+    recognitionRef.current = recognition;
+  }, []);
+
+  const startListening = useCallback(() => {
+    if (!recognitionRef.current || isListening) return;
+    setTranscript('');
+    setInterimTranscript('');
+    try {
+      recognitionRef.current.start();
+      setIsListening(true);
+    } catch {
+      // Already started
+    }
+  }, [isListening]);
+
+  const stopListening = useCallback(() => {
+    if (!recognitionRef.current) return;
+    try {
+      recognitionRef.current.stop();
+    } catch {
+      // Already stopped
+    }
+    setIsListening(false);
+  }, []);
+
+  const resetTranscript = useCallback(() => {
+    setTranscript('');
+    setInterimTranscript('');
+  }, []);
+
+  return {
+    isListening,
+    isSupported,
+    transcript,
+    interimTranscript,
+    startListening,
+    stopListening,
+    resetTranscript,
+  };
+}

package/.next/standalone/src/hooks/use-sse.ts

@@ -0,0 +1,35 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { api } from '@/lib/api';
+import { useTier } from '@/hooks/use-tier';
+
+export function useSSEBusEvents() {
+  const qc = useQueryClient();
+  const { hasCollaboration } = useTier();
+
+  useEffect(() => {
+    if (!hasCollaboration) return;
+
+    const es = new EventSource(api('/api/events'));
+
+    const handleMessage = () => {
+      qc.invalidateQueries({ queryKey: ['workspace-messages'] });
+    };
+    const handleContext = () => {
+      qc.invalidateQueries({ queryKey: ['workspace-context'] });
+    };
+
+    es.addEventListener('workspace:message', handleMessage);
+    es.addEventListener('workspace:request', handleMessage);
+    es.addEventListener('workspace:context_updated', handleContext);
+
+    return () => {
+      es.removeEventListener('workspace:message', handleMessage);
+      es.removeEventListener('workspace:request', handleMessage);
+      es.removeEventListener('workspace:context_updated', handleContext);
+      es.close();
+    };
+  }, [qc, hasCollaboration]);
+}

package/.next/standalone/src/hooks/use-tier.ts

@@ -0,0 +1,39 @@
+'use client';
+
+import { createContext, useContext } from 'react';
+
+export interface TierFlags {
+  tier: string;
+  version: string;
+  hasAuth: boolean;
+  hasAdmin: boolean;
+  hasCollaboration: boolean;
+  hasNetwork: boolean;
+  hasMultiuser: boolean;
+  hasCortex: boolean;
+  cortexTierEnabled: boolean;
+  isDesktop: boolean;
+  basePath: string;
+  loading: boolean;
+}
+
+const defaults: TierFlags = {
+  tier: 'community',
+  version: '',
+  hasAuth: false,
+  hasAdmin: false,
+  hasCollaboration: false,
+  hasNetwork: false,
+  hasMultiuser: false,
+  hasCortex: false,
+  cortexTierEnabled: false,
+  isDesktop: true,
+  basePath: '',
+  loading: false,
+};
+
+export const TierContext = createContext<TierFlags>(defaults);
+
+export function useTier(): TierFlags {
+  return useContext(TierContext);
+}

package/.next/standalone/src/lib/agents.ts

@@ -0,0 +1,70 @@
+// Supported agent systems for Spaces panes
+
+export interface AgentType {
+  id: string;
+  name: string;
+  command: string;
+  resumeFlag: string;        // CLI flag for resuming sessions (e.g., '--resume')
+  supportsResume: boolean;
+  color: string;
+  description: string;
+}
+
+export const AGENT_TYPES: Record<string, AgentType> = {
+  claude: {
+    id: 'claude',
+    name: 'Claude Code',
+    command: 'claude',
+    resumeFlag: '--resume',
+    supportsResume: true,
+    color: '#d97706',
+    description: 'Anthropic Claude Code CLI',
+  },
+  codex: {
+    id: 'codex',
+    name: 'Codex CLI',
+    command: 'codex',
+    resumeFlag: 'resume',
+    supportsResume: true,
+    color: '#10b981',
+    description: 'OpenAI Codex CLI',
+  },
+  gemini: {
+    id: 'gemini',
+    name: 'Gemini CLI',
+    command: 'gemini',
+    resumeFlag: '--resume',
+    supportsResume: true,
+    color: '#3b82f6',
+    description: 'Google Gemini CLI',
+  },
+  aider: {
+    id: 'aider',
+    name: 'Aider',
+    command: 'aider',
+    resumeFlag: '',
+    supportsResume: false,
+    color: '#8b5cf6',
+    description: 'AI pair programming in your terminal',
+  },
+  shell: {
+    id: 'shell',
+    name: 'Shell',
+    command: '',
+    resumeFlag: '',
+    supportsResume: false,
+    color: '#71717a',
+    description: 'Plain terminal shell',
+  },
+  custom: {
+    id: 'custom',
+    name: 'Custom',
+    command: '',
+    resumeFlag: '',
+    supportsResume: false,
+    color: '#ec4899',
+    description: 'Custom command',
+  },
+};
+
+export const AGENT_LIST = Object.values(AGENT_TYPES);