@mndrk/agx 2.3.3 → 2.4.2

package/cloud-runtime/standalone/apps/local/hooks/useProcessPolling.ts

@@ -2,7 +2,7 @@
 
 import { useState, useEffect, useRef, useCallback } from "react";
 import type { AgentProcessEntry } from "@/lib/agent-process-registry";
-import type { GroupMessage } from "@/lib/types";
+import type { GroupMessage, ChatEvent } from "@/lib/types";
 import type { ChatRunInfo, StreamingEntry } from "./useGroupChat";
 
 /** Active process states that should show a typing indicator. */
@@ -55,7 +55,10 @@ function normalizeChatRuns(value: unknown): ChatRunInfo[] {
 
 /**
  * Polls `/api/processes` and `/api/history?since=` to drive both the
- * "who's working" indicator and message delivery (replacing SSE).
+ * "who's working" indicator and message delivery.
+ *
+ * When a chat run is active (queued/running), also opens an SSE
+ * connection to `/api/chat-runs/[id]/events` for token-by-token streaming.
  */
 export function useProcessPolling(
   scope: { workspaceId?: string | null; threadId?: string | null } | null,
@@ -80,6 +83,10 @@ export function useProcessPolling(
   setMessagesRef.current = options?.setMessages;
   // Track the latest timestamp we've seen so far for delta fetching
   const lastTimestampRef = useRef<number>(0);
+  // Track active SSE connections by chatRunId
+  const eventSourcesRef = useRef<Map<string, EventSource>>(new Map());
+  // Track per-agent streaming content by chatRunId
+  const streamContentRef = useRef<Map<string, Map<string, { text: string; thoughts: string[] }>>>(new Map());
 
   // Reset lastTimestamp when messages change externally (e.g. full reload)
   useEffect(() => {
@@ -92,6 +99,16 @@ export function useProcessPolling(
     }
   }, [options?.messages]);
 
+  // Clean up SSE connections on unmount
+  useEffect(() => {
+    return () => {
+      for (const es of eventSourcesRef.current.values()) {
+        es.close();
+      }
+      eventSourcesRef.current.clear();
+    };
+  }, []);
+
   const poll = useCallback(async () => {
     const s = scopeRef.current;
     if (!s) {
@@ -147,15 +164,7 @@ export function useProcessPolling(
         );
         setActiveAgents(activeIds);
 
-        // Build streaming indicators from active processes
-        const newStreaming: Record<string, StreamingEntry> = {};
-        for (const proc of entries) {
-          if (!ACTIVE_STATES.has(proc.state)) continue;
-          const triggerMsg = messagesRef.current.find((m) => m.id === proc.sinceMessageId);
-          const rootId = triggerMsg?.rootMessageId ?? proc.sinceMessageId;
-          newStreaming[proc.agentId] = { content: "", rootMessageId: rootId };
-        }
-        setStreaming(newStreaming);
+        // Streaming state is owned by SSE event handlers — don't reset it here.
       }
 
       if (chatRunsRes?.ok) {
@@ -189,6 +198,140 @@ export function useProcessPolling(
     }
   }, []);
 
+  // Subscribe to SSE for active chat runs
+  useEffect(() => {
+    const activeRuns = chatRuns.filter(
+      (run) => run.status === "queued" || run.status === "running"
+    );
+    const activeRunIds = new Set(activeRuns.map((r) => r.chatRunId));
+
+    // Close EventSources for completed/absent runs
+    for (const [chatRunId, es] of eventSourcesRef.current.entries()) {
+      if (!activeRunIds.has(chatRunId)) {
+        es.close();
+        eventSourcesRef.current.delete(chatRunId);
+        streamContentRef.current.delete(chatRunId);
+      }
+    }
+
+    // Open EventSources for new active runs
+    for (const run of activeRuns) {
+      if (eventSourcesRef.current.has(run.chatRunId)) continue;
+
+      const es = new EventSource(`/api/chat-runs/${encodeURIComponent(run.chatRunId)}/events`);
+      eventSourcesRef.current.set(run.chatRunId, es);
+      const agentContent = new Map<string, { text: string; thoughts: string[] }>();
+      streamContentRef.current.set(run.chatRunId, agentContent);
+
+      // Track which agents are actively streaming in this run
+      const activeStreamAgents = new Set<string>();
+
+      es.addEventListener("chat", (e) => {
+        let event: ChatEvent;
+        try {
+          event = JSON.parse(e.data);
+        } catch {
+          return;
+        }
+
+        switch (event.type) {
+          case "participant-start":
+          case "participant-thinking":
+            activeStreamAgents.add(event.participantId);
+            if (!agentContent.has(event.participantId)) {
+              agentContent.set(event.participantId, { text: "", thoughts: [] });
+            }
+            setStreaming((prev) => {
+              if (prev[event.participantId]) return prev;
+              return {
+                ...prev,
+                [event.participantId]: {
+                  content: "",
+                  rootMessageId: run.rootMessageId ?? null,
+                },
+              };
+            });
+            break;
+
+          case "text-delta": {
+            if (!agentContent.has(event.participantId)) {
+              agentContent.set(event.participantId, { text: "", thoughts: [] });
+            }
+            const entry = agentContent.get(event.participantId);
+            if (entry) {
+              entry.text += event.delta;
+              // Update streaming state with the partial content
+              setStreaming((prev) => {
+                const updated = { ...prev };
+                // Find rootMessageId for this participant
+                const rootMessageId = run.rootMessageId ?? null;
+                updated[event.participantId] = {
+                  content: entry.text,
+                  rootMessageId,
+                };
+                return updated;
+              });
+            }
+            break;
+          }
+
+          case "participant-thought": {
+            const entry = agentContent.get(event.participantId);
+            if (entry) {
+              entry.thoughts.push(event.content);
+              setStreaming((prev) => {
+                const existing = prev[event.participantId];
+                if (!existing) return prev;
+                return {
+                  ...prev,
+                  [event.participantId]: {
+                    ...existing,
+                    thoughts: [...entry.thoughts],
+                  },
+                };
+              });
+            }
+            break;
+          }
+
+          case "participant-end":
+            activeStreamAgents.delete(event.participantId);
+            poll().then(() => {
+              setStreaming((prev) => {
+                const updated = { ...prev };
+                delete updated[event.participantId];
+                return updated;
+              });
+            });
+            break;
+
+          case "participant-error":
+            activeStreamAgents.delete(event.participantId);
+            poll().then(() => {
+              setStreaming((prev) => {
+                const updated = { ...prev };
+                delete updated[event.participantId];
+                return updated;
+              });
+            });
+            break;
+
+          case "done":
+            es.close();
+            eventSourcesRef.current.delete(run.chatRunId);
+            streamContentRef.current.delete(run.chatRunId);
+            break;
+        }
+      });
+
+      es.onerror = () => {
+        es.close();
+        eventSourcesRef.current.delete(run.chatRunId);
+        streamContentRef.current.delete(run.chatRunId);
+      };
+    }
+  }, [chatRuns]);
+
   const key = scope?.threadId || scope?.workspaceId || null;
   const hasActiveChatRuns = chatRuns.some((run) => run.status === "queued" || run.status === "running");
   const hasActiveProcesses = processes.some((process) => ACTIVE_STATES.has(process.state));
@@ -209,4 +352,4 @@ export function useProcessPolling(
   }, [key, pollIntervalMs, poll]);
 
   return { activeAgents, processes, streaming, chatRuns, poll };
-}
+}

package/cloud-runtime/standalone/apps/local/hooks/useSidebarStage.ts

@@ -1,7 +1,17 @@
+"use client";
+
+import { useMemo } from "react";
 import type { ProjectWithAgents } from "@/hooks/useProjects";
+import { useTrackerConnections } from "./useTrackerConnections";
 
 export type SidebarStage = "stage1" | "stage2" | "stage3" | "stage4";
 
+export interface TrackerConnectionEntry {
+  type: string;
+  connected: boolean;
+  connectedAt: string;
+}
+
 export interface SidebarStageResult {
   stage: SidebarStage;
   loading: boolean;
@@ -11,33 +21,59 @@ export interface SidebarStageResult {
     terminal: boolean;
     objectives: boolean;
     objectivesIsNew: boolean;
-    linear: boolean;
+    tracking: boolean;
     teams: boolean;
     folders: boolean;
     scheduledTasks: boolean;
     envVars: boolean;
   };
+  /** Connected tracker types for sidebar sub-entries */
+  trackerConnections: TrackerConnectionEntry[];
 }
 
-const ALL_VISIBLE: SidebarStageResult = {
-  stage: "stage4",
-  loading: false,
-  show: {
-    home: true,
-    threads: true,
-    terminal: true,
-    objectives: true,
-    objectivesIsNew: false,
-    linear: true,
-    teams: true,
-    folders: true,
-    scheduledTasks: true,
-    envVars: true,
-  },
+const ALL_VISIBLE_BASE = {
+  home: true,
+  threads: true,
+  terminal: true,
+  objectives: true,
+  objectivesIsNew: false,
+  tracking: true, // Always true — section is always visible
+  teams: true,
+  folders: true,
+  scheduledTasks: true,
+  envVars: true,
 };
 
+/**
+ * Determine which sidebar sections to show.
+ * Task Tracking is always visible — shows "+ Connect" when no trackers connected.
+ */
 export function useSidebarStage(
-  _project: ProjectWithAgents | null,
+  project: ProjectWithAgents | null,
 ): SidebarStageResult {
-  return ALL_VISIBLE;
+  const { connections, loading } = useTrackerConnections(project?.id ?? null);
+
+  return useMemo(() => {
+    const trackerConnections = connections.map((c) => ({
+      type: c.type,
+      connected: c.connected,
+      connectedAt: c.connectedAt,
+    }));
+
+    if (loading) {
+      return {
+        stage: "stage1",
+        loading: true,
+        show: { ...ALL_VISIBLE_BASE },
+        trackerConnections: [],
+      };
+    }
+
+    return {
+      stage: "stage4",
+      loading: false,
+      show: { ...ALL_VISIBLE_BASE },
+      trackerConnections,
+    };
+  }, [loading, connections]);
 }

package/cloud-runtime/standalone/apps/local/hooks/useTaskGroups.ts

@@ -0,0 +1,133 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+export interface TaskGroup {
+  id: string;
+  project_id: string;
+  name: string;
+  position: number;
+  collapsed: number;
+  task_ids: string[];
+  created_at: string;
+  updated_at: string;
+}
+
+export function useTaskGroups(projectId: string | null | undefined) {
+  const [groups, setGroups] = useState<TaskGroup[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const fetchGroups = useCallback(async () => {
+    if (!projectId) return;
+    setIsLoading(true);
+    try {
+      const res = await fetch(`/api/task-groups?project_id=${encodeURIComponent(projectId)}`);
+      if (!res.ok) throw new Error("Failed to fetch groups");
+      const data = await res.json();
+      setGroups(data.groups ?? []);
+    } catch (err) {
+      console.error("useTaskGroups fetch error:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [projectId]);
+
+  useEffect(() => {
+    fetchGroups();
+  }, [fetchGroups]);
+
+  const createGroup = useCallback(
+    async (name: string, taskIds: string[]): Promise<TaskGroup | null> => {
+      if (!projectId) return null;
+      try {
+        const res = await fetch("/api/task-groups", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ project_id: projectId, name, task_ids: taskIds }),
+        });
+        if (!res.ok) throw new Error("Failed to create group");
+        const data = await res.json();
+        await fetchGroups();
+        return data.group;
+      } catch (err) {
+        console.error("createGroup error:", err);
+        return null;
+      }
+    },
+    [projectId, fetchGroups],
+  );
+
+  const updateGroup = useCallback(
+    async (groupId: string, updates: { name?: string; position?: number; collapsed?: boolean }) => {
+      try {
+        const res = await fetch(`/api/task-groups/${groupId}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(updates),
+        });
+        if (!res.ok) throw new Error("Failed to update group");
+        await fetchGroups();
+      } catch (err) {
+        console.error("updateGroup error:", err);
+      }
+    },
+    [fetchGroups],
+  );
+
+  const deleteGroup = useCallback(
+    async (groupId: string) => {
+      try {
+        const res = await fetch(`/api/task-groups/${groupId}`, { method: "DELETE" });
+        if (!res.ok) throw new Error("Failed to delete group");
+        await fetchGroups();
+      } catch (err) {
+        console.error("deleteGroup error:", err);
+      }
+    },
+    [fetchGroups],
+  );
+
+  const addTasksToGroup = useCallback(
+    async (groupId: string, taskIds: string[]) => {
+      try {
+        const res = await fetch(`/api/task-groups/${groupId}/tasks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ task_ids: taskIds }),
+        });
+        if (!res.ok) throw new Error("Failed to assign tasks");
+        await fetchGroups();
+      } catch (err) {
+        console.error("addTasksToGroup error:", err);
+      }
+    },
+    [fetchGroups],
+  );
+
+  const removeTaskFromGroup = useCallback(
+    async (groupId: string, taskId: string) => {
+      try {
+        const res = await fetch(
+          `/api/task-groups/${groupId}/tasks?task_id=${encodeURIComponent(taskId)}`,
+          { method: "DELETE" },
+        );
+        if (!res.ok) throw new Error("Failed to remove task");
+        await fetchGroups();
+      } catch (err) {
+        console.error("removeTaskFromGroup error:", err);
+      }
+    },
+    [fetchGroups],
+  );
+
+  return {
+    groups,
+    isLoading,
+    refetch: fetchGroups,
+    createGroup,
+    updateGroup,
+    deleteGroup,
+    addTasksToGroup,
+    removeTaskFromGroup,
+  };
+}

package/cloud-runtime/standalone/apps/local/hooks/{useLinearActiveAgents.ts → useTrackerActiveAgents.ts}

@@ -2,10 +2,15 @@
 
 import { useEffect, useState } from "react";
 
-export function useLinearActiveAgents(projectId?: string): {
+export function useTrackerActiveAgents(
+  trackerType: string,
+  projectId?: string,
+): {
   issueActiveAgents: Map<string, Array<{ agentId: string; agentName: string }>>;
 } {
-  const [issueActiveAgents, setIssueActiveAgents] = useState<Map<string, Array<{ agentId: string; agentName: string }>>>(new Map());
+  const [issueActiveAgents, setIssueActiveAgents] = useState<
+    Map<string, Array<{ agentId: string; agentName: string }>>
+  >(new Map());
 
   useEffect(() => {
     let cancelled = false;
@@ -14,10 +19,15 @@ export function useLinearActiveAgents(projectId?: string): {
       try {
         const params = new URLSearchParams();
         if (projectId) params.set("projectId", projectId);
-        const res = await fetch(`/api/linear/issues/active-agents?${params}`);
+        const res = await fetch(
+          `/api/trackers/${trackerType}/active-agents?${params}`,
+        );
         if (!res.ok || cancelled) return;
         const data = await res.json();
-        const map = new Map<string, Array<{ agentId: string; agentName: string }>>();
+        const map = new Map<
+          string,
+          Array<{ agentId: string; agentName: string }>
+        >();
         for (const entry of data.agents ?? []) {
           const list = map.get(entry.issueId) ?? [];
           list.push({ agentId: entry.agentId, agentName: entry.agentName });
@@ -31,8 +41,11 @@ export function useLinearActiveAgents(projectId?: string): {
 
     void fetchActiveAgents();
     const interval = setInterval(() => void fetchActiveAgents(), 5000);
-    return () => { cancelled = true; clearInterval(interval); };
-  }, [projectId]);
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+    };
+  }, [trackerType, projectId]);
 
   return { issueActiveAgents };
 }