v3.8

nix/deepagent-code.nix

@@ -18,6 +18,11 @@ stdenvNoCC.mkDerivation (finalAttrs: {
   inherit (node_modules) version src;
   inherit node_modules;
 
+  patchPhase = ''
+    BUN_VERSION=$(bun --version)
+    sed -i "s/const expectedBunVersionRange.*/const expectedBunVersionRange = \"^$BUN_VERSION\";/" packages/script/src/index.ts
+  '';
+
   nativeBuildInputs = [
     bun
     nodejs # for patchShebangs node_modules

nix/hashes.json

@@ -1,6 +1,6 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-OttgLsPJSYW1b9RGqiYSi7qPdDC3GuD2FE7k5tPe6Iw=",
+    "x86_64-linux": "sha256-vB4imi5LtCxnDuOaJFQh+asK51RUDCnIVCkIzBQN12o=",
     "aarch64-linux": "sha256-VsmW8tTiT3VkTxp5oiYc/maJLSsBMxK6VVUSVshWVT8=",
     "aarch64-darwin": "sha256-/MaQBX2zoJMtLA8jHt8+uKpIFve/eec3RfcKT3FvXC8=",
     "x86_64-darwin": "sha256-3ggap9rgR2TvVbYgnXsgkg6Rj1TqNZu32QgTVRdN0f0="

packages/app/src/app.tsx

@@ -31,6 +31,7 @@ import { CommandProvider } from "@/context/command"
 import { CommentsProvider } from "@/context/comments"
 import { DebugProvider } from "@/context/debug"
 import { FileProvider } from "@/context/file"
+import { GatewayProvider } from "@/context/gateway"
 import { ServerSDKProvider } from "@/context/server-sdk"
 import { ServerSyncProvider } from "@/context/server-sync"
 import { GlobalProvider } from "@/context/global"
@@ -311,39 +312,41 @@ export function AppInterface(props: {
   disableHealthCheck?: boolean
 }) {
   return (
-    <ServerProvider
-      defaultServer={props.defaultServer}
-      canonicalLocalServer={props.canonicalLocalServer}
-      servers={props.servers}
-    >
-      <GlobalProvider>
-        <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
-          <Dynamic
-            component={props.router ?? Router}
-            root={(routerProps) => (
-              <TabsProvider>
-                <ServerKey>
-                  <QueryProvider>
-                    <ServerSDKProvider>
-                      <ServerSyncProvider>
-                        <RouterRoot appChildren={props.children}>{routerProps.children}</RouterRoot>
-                      </ServerSyncProvider>
-                    </ServerSDKProvider>
-                  </QueryProvider>
-                </ServerKey>
-              </TabsProvider>
-            )}
-          >
-            <Route path="/" component={HomeRoute} />
-            <Route path="/:dir" component={DirectoryLayout}>
+    <GatewayProvider>
+      <ServerProvider
+        defaultServer={props.defaultServer}
+        canonicalLocalServer={props.canonicalLocalServer}
+        servers={props.servers}
+      >
+        <GlobalProvider>
+          <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
+            <Dynamic
+              component={props.router ?? Router}
+              root={(routerProps) => (
+                <TabsProvider>
+                  <ServerKey>
+                    <QueryProvider>
+                      <ServerSDKProvider>
+                        <ServerSyncProvider>
+                          <RouterRoot appChildren={props.children}>{routerProps.children}</RouterRoot>
+                        </ServerSyncProvider>
+                      </ServerSDKProvider>
+                    </QueryProvider>
+                  </ServerKey>
+                </TabsProvider>
+              )}
+            >
+              <Route path="/" component={HomeRoute} />
+              <Route path="/:dir" component={DirectoryLayout}>
               <Route path="/" component={() => <Navigate href="session" />} />
               <Route path="/agent" component={AgentSystemRoute} />
               <Route path="/review" component={ReviewRoute} />
               <Route path="/session/:id?" component={SessionRoute} />
-            </Route>
-          </Dynamic>
-        </ConnectionGate>
-      </GlobalProvider>
-    </ServerProvider>
+              </Route>
+            </Dynamic>
+          </ConnectionGate>
+        </GlobalProvider>
+      </ServerProvider>
+    </GatewayProvider>
   )
 }

packages/app/src/components/im/agent-status-chip.tsx

@@ -0,0 +1,49 @@
+import { createMemo } from "solid-js"
+
+interface AgentStatusChipProps {
+  agentID: string
+  status: string
+}
+
+export function AgentStatusChip(props: AgentStatusChipProps) {
+  const getStatusColor = createMemo(() => {
+    switch (props.status) {
+      case "started":
+      case "running":
+        return "bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200"
+      case "success":
+        return "bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200"
+      case "failed":
+        return "bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200"
+      case "timeout":
+        return "bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200"
+      default:
+        return "bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-200"
+    }
+  })
+
+  const getStatusIcon = createMemo(() => {
+    switch (props.status) {
+      case "started":
+      case "running":
+        return "⏳"
+      case "success":
+        return "✓"
+      case "failed":
+        return "✗"
+      case "timeout":
+        return "⏱"
+      default:
+        return "•"
+    }
+  })
+
+  return (
+    <div class={`inline-flex items-center gap-1 px-2 py-1 rounded-full text-xs font-medium ${getStatusColor()}`}>
+      <span>{getStatusIcon()}</span>
+      <span>Agent {props.agentID}</span>
+      <span>•</span>
+      <span>{props.status}</span>
+    </div>
+  )
+}

packages/app/src/components/im/group-chat-panel.tsx

@@ -0,0 +1,126 @@
+import { createSignal, createEffect, onMount, Show } from "solid-js"
+import { MessageList } from "./message-list"
+import { MessageComposer } from "./message-composer"
+import { useIMWebSocket } from "@/hooks/use-im-websocket"
+import type { LocalMessage } from "@/hooks/use-im-websocket"
+import { useIMClient } from "@/utils/im-client"
+import type { AgentDescriptor } from "./types"
+
+interface GroupChatPanelProps {
+  groupID: string
+}
+
+export function GroupChatPanel(props: GroupChatPanelProps) {
+  const client = useIMClient()
+  const [historicalMessages, setHistoricalMessages] = createSignal<LocalMessage[]>([])
+  const [agents, setAgents] = createSignal<AgentDescriptor[]>([])
+  const [loading, setLoading] = createSignal(true)
+
+  const { connected, messages: realtimeMessages, agentStatuses, typingMembers, send } = useIMWebSocket(
+    client,
+    () => props.groupID,
+  )
+
+  // The single desktop user identity, as the server assigns it. Used to exclude
+  // our own echoed typing/read events from the UI.
+  const SELF_MEMBER_ID = "server"
+
+  const othersTyping = () => Array.from(typingMembers()).filter((id) => id !== SELF_MEMBER_ID)
+
+  // Load historical messages
+  createEffect(() => {
+    const groupID = props.groupID
+    setLoading(true)
+    client
+      .listMessages(groupID, 50)
+      .then((data) => {
+        // Server returns messages newest-first (desc). Reverse to ascending so
+        // they render oldest→newest in the list.
+        const historical: LocalMessage[] = (data.messages || []).slice().reverse()
+        setHistoricalMessages(historical)
+        setLoading(false)
+      })
+      .catch((error) => {
+        console.error("Failed to load messages:", error)
+        setLoading(false)
+      })
+  })
+
+  // Load available agents
+  onMount(() => {
+    client
+      .listAgents()
+      .then((data) => {
+        setAgents(data || [])
+      })
+      .catch((error) => {
+        console.error("Failed to load agents:", error)
+      })
+  })
+
+  // Merge historical and realtime messages, de-duplicating by id (a message the
+  // user sent appears both in the historical fetch and the realtime broadcast)
+  // and sorting ascending by creation time.
+  const allMessages = () => {
+    const byId = new Map<string, LocalMessage>()
+    for (const m of historicalMessages()) byId.set(m.id, m)
+    for (const m of realtimeMessages()) byId.set(m.id, m)
+    return Array.from(byId.values()).sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  // Mark the group read whenever new messages land (and on first load). Sends
+  // both the HTTP mark-read (persisted last_read_at) and a realtime receipt.
+  createEffect(() => {
+    const msgs = allMessages()
+    if (loading() || msgs.length === 0) return
+    const readAt = Date.now()
+    client.markRead(props.groupID, readAt).catch((error) => {
+      console.error("Failed to mark read:", error)
+    })
+    send({ type: "read_receipt", data: { groupID: props.groupID, memberID: SELF_MEMBER_ID, readAt } })
+  })
+
+  const handleTyping = (typing: boolean) => {
+    send({ type: "typing", data: { groupID: props.groupID, memberID: SELF_MEMBER_ID, typing } })
+  }
+
+  const handleSendMessage = async (content: string) => {
+    // Send via HTTP API; the created message arrives back over the WebSocket.
+    try {
+      await client.createMessage(props.groupID, { content, type: "text" })
+    } catch (error) {
+      console.error("Failed to send message:", error)
+      alert("Failed to send message")
+    }
+  }
+
+  return (
+    <Show
+      when={!loading()}
+      fallback={
+        <div class="flex-1 flex items-center justify-center">
+          <div class="text-sm text-muted-foreground">Loading messages...</div>
+        </div>
+      }
+    >
+      <div class="flex-1 flex flex-col overflow-hidden">
+        <div class="border-b border-border p-4 bg-muted/50">
+          <h2 class="font-semibold">Group Chat</h2>
+          <div class="text-xs text-muted-foreground">
+            {connected() ? "Connected" : "Disconnected"}
+          </div>
+        </div>
+
+        <MessageList messages={allMessages()} agentStatuses={agentStatuses()} />
+
+        <Show when={othersTyping().length > 0}>
+          <div class="px-4 py-1 text-xs text-muted-foreground italic">
+            {othersTyping().length === 1 ? "Someone is typing…" : "Several people are typing…"}
+          </div>
+        </Show>
+
+        <MessageComposer onSend={handleSendMessage} onTyping={handleTyping} agents={agents()} />
+      </div>
+    </Show>
+  )
+}