@saadnvd1/agent-os 0.3.700 → 0.3.715

package/components/SessionList/useSidebarData.ts

@@ -3,9 +3,11 @@
 import { useCallback, useMemo } from "react";
 import { useSnapshot } from "valtio";
 import type { Session } from "@/lib/db";
+import type { SessionGroup } from "@/lib/sidebar/shelves";
 import {
   buildShelves,
   inWorkspace,
+  orderGroups,
   projectsInWorkspace,
 } from "@/lib/sidebar/shelves";
 import type { TaskState } from "@/lib/tasks/state";
@@ -25,6 +27,7 @@ import type { SessionStatus } from "./SessionList.types";
 
 // One empty list for queries still loading, so memos below hold.
 const NONE: never[] = [];
+const NONE_GROUPS: SessionGroup[] = [];
 
 // Everything the flat list needs: the current workspace's sessions, sorted
 // onto shelves by the remembered filters.
@@ -55,6 +58,7 @@ export function useSidebarData(
     () => sessionsQuery.data?.sessions ?? [],
     [sessionsQuery.data]
   );
+  const allGroups = sessionsQuery.data?.sessionGroups ?? NONE_GROUPS;
   // Keyed by its contents: the hosts query hands back a new object each time.
   const linkedKey = JSON.stringify(useLinkedHostNames());
   const linked = useMemo(
@@ -102,6 +106,10 @@ export function useSidebarData(
       ),
       projectId: project?.id ?? null,
       currentOrchestrators,
+      groups: orderGroups(
+        allGroups.filter((g) => !workspace || g.workspace_id === workspace.id),
+        workspaces.map((w) => w.id)
+      ),
     };
     // The rollups count the whole list; the filter only narrows what shows.
     const all = buildShelves(input);
@@ -120,6 +128,7 @@ export function useSidebarData(
     now,
     linked,
     sessions,
+    allGroups,
     projects,
     workspaces,
     tasks,
@@ -235,6 +244,7 @@ export function useSidebarData(
   return {
     ui,
     shelves,
+    groups: allGroups,
     queued,
     toStart,
     machines,

package/components/ui/notice.tsx

@@ -0,0 +1,46 @@
+import type { ReactNode } from "react";
+import { AlertTriangle, Info } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+const TONES = {
+  info: {
+    box: "bg-muted/60",
+    icon: <Info className="text-muted-foreground mt-0.5 h-4 w-4 shrink-0" />,
+  },
+  warning: {
+    box: "bg-amber-500/10",
+    icon: (
+      <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0 text-amber-600 dark:text-amber-400" />
+    ),
+  },
+} as const;
+
+/** A short message in a tinted box, with an optional action on the right. */
+export function Notice({
+  tone = "info",
+  action,
+  className,
+  children,
+}: {
+  tone?: keyof typeof TONES;
+  action?: ReactNode;
+  className?: string;
+  children: ReactNode;
+}) {
+  return (
+    <div
+      role="status"
+      className={cn(
+        "flex flex-col gap-2 rounded-lg p-3 text-sm sm:flex-row sm:items-center",
+        TONES[tone].box,
+        className
+      )}
+    >
+      <div className="flex min-w-0 flex-1 gap-2">
+        {TONES[tone].icon}
+        <div className="min-w-0 flex-1">{children}</div>
+      </div>
+      {action}
+    </div>
+  );
+}

package/components/ui/status-pill.tsx

@@ -0,0 +1,39 @@
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+const TONES = {
+  amber: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
+  muted: "bg-muted text-muted-foreground",
+} as const;
+
+/** A small coloured pill for a status. A button when it has an onClick. */
+export function StatusPill({
+  tone,
+  className,
+  onClick,
+  ...props
+}: Omit<ComponentProps<"span">, "onClick"> & {
+  tone: keyof typeof TONES;
+  onClick?: () => void;
+}) {
+  const classes = cn(
+    "inline-flex max-w-full min-w-0 items-center gap-1 rounded-md px-1.5 py-0.5 text-[11px] font-semibold",
+    TONES[tone],
+    className
+  );
+  if (!onClick) return <span className={classes} {...props} />;
+  return (
+    <button
+      type="button"
+      onClick={(e) => {
+        e.stopPropagation();
+        onClick();
+      }}
+      className={cn(
+        classes,
+        "relative cursor-pointer before:absolute before:-inset-x-1 before:-inset-y-3 hover:brightness-110"
+      )}
+      {...(props as ComponentProps<"button">)}
+    />
+  );
+}

package/data/claims/index.ts

@@ -0,0 +1,2 @@
+export { claimKeys } from "./keys";
+export { useClaims, useCheckStart } from "./queries";

package/data/claims/keys.ts

@@ -0,0 +1,5 @@
+export const claimKeys = {
+  all: ["claims"] as const,
+  list: (project?: string) =>
+    [...claimKeys.all, "list", project ?? ""] as const,
+};

package/data/claims/queries.ts

@@ -0,0 +1,47 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import type { ClaimsView } from "@/lib/claims/view";
+import type { StartWarning } from "@/lib/claims/startWarning";
+import { usePollWhenOffline } from "../push/connection";
+import { claimKeys } from "./keys";
+
+// Claims here and on linked machines. Pushed when a claim changes; it polls
+// only while the stream is down.
+export function useClaims(opts: { project?: string; enabled?: boolean } = {}) {
+  const { project, enabled = true } = opts;
+  return useQuery({
+    queryKey: claimKeys.list(project),
+    queryFn: async (): Promise<ClaimsView> => {
+      const res = await fetch(
+        `/api/claims${project ? `?project=${encodeURIComponent(project)}` : ""}`
+      );
+      if (!res.ok) throw new Error("Failed to load claims");
+      return res.json();
+    },
+    enabled,
+    staleTime: 5000,
+    refetchInterval: usePollWhenOffline(15000),
+  });
+}
+
+export interface StartCheckInput {
+  projectId: string;
+  name?: string;
+  prompt: string;
+  branch?: string | null;
+}
+
+// Who else is on the work a person is about to start. A failure means no
+// warning: it never stops a start.
+export function useCheckStart() {
+  return useMutation({
+    mutationFn: async (input: StartCheckInput): Promise<StartWarning[]> => {
+      const res = await fetch("/api/claims/check", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input),
+      });
+      if (!res.ok) return [];
+      return ((await res.json()) as { overlaps: StartWarning[] }).overlaps;
+    },
+  });
+}

package/data/peers/keys.ts

@@ -3,4 +3,5 @@ export const peerKeys = {
   account: () => [...peerKeys.all, "account"] as const,
   pending: () => [...peerKeys.all, "pending"] as const,
   link: (id: string) => [...peerKeys.all, "link", id] as const,
+  audit: (hostId: string) => [...peerKeys.all, "audit", hostId] as const,
 };

package/data/peers/queries.ts

@@ -1,4 +1,5 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { AuditRow } from "@/lib/peer/audit";
 import type { AccountMachines } from "@/lib/peer/machines";
 import type { PendingView } from "@/lib/peer/pairing";
 import type { Outgoing } from "@/lib/peer/pairing-out";
@@ -139,3 +140,33 @@ export function useAnswerLink() {
     }),
   };
 }
+
+/** Unlinks a machine linked through Connect, here and (if it answers) there. */
+export function useUnlinkPeer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (hostId: string) =>
+      json<{ name: string; told: boolean; removed: boolean }>(
+        await fetch(`/api/peers/${hostId}`, { method: "DELETE" })
+      ),
+    onSettled: () => {
+      void queryClient.invalidateQueries({ queryKey: hostKeys.all });
+      void queryClient.invalidateQueries({ queryKey: peerKeys.account() });
+    },
+  });
+}
+
+/** Every call to and from a linked machine, newest first. */
+export function usePeerAudit(hostId: string | null) {
+  return useQuery({
+    queryKey: peerKeys.audit(hostId ?? ""),
+    queryFn: async () =>
+      (
+        await json<{ rows: AuditRow[] }>(
+          await fetch(`/api/peers/${hostId}/audit`)
+        )
+      ).rows,
+    enabled: !!hostId,
+    refetchInterval: 15_000,
+  });
+}

package/data/push/topics.ts

@@ -18,6 +18,7 @@ import { archivedKeys } from "../done";
 import { awayKeys } from "../away";
 import { bookmarkKeys } from "../bookmarks/keys";
 import { learningCardsKeys } from "../learning-cards";
+import { claimKeys } from "../claims/keys";
 
 // What each pushed topic (a table that changed, lib/db/changes.ts, or a
 // pushed view) means the browser should refetch. Only queries on screen
@@ -41,6 +42,7 @@ function keysFor(topic: string): QueryKey[] {
     case "projects":
       return [projectKeys.all, sessionKeys.all];
     case "groups":
+    case "session_groups":
       return [sessionKeys.all];
     case "workspaces":
       return [workspaceKeys.all, orchestratorKeys.all];
@@ -76,6 +78,8 @@ function keysFor(topic: string): QueryKey[] {
       return [devServerKeys.all];
     case "learning_cards":
       return [learningCardsKeys.all, orchestratorKeys.all];
+    case "work_claims":
+      return [claimKeys.all, sessionKeys.all];
     case "chat_bookmarks":
       return [bookmarkKeys.all];
     default:

package/data/session-groups/index.ts

@@ -0,0 +1,156 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import type { SessionGroup } from "@/lib/sidebar/shelves";
+import { sessionKeys } from "@/data/sessions/keys";
+import type { SessionsResponse } from "@/data/sessions/queries";
+
+async function send<T>(
+  url: string,
+  method: string,
+  body?: unknown
+): Promise<T> {
+  const res = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error ?? "Could not change the group");
+  return data as T;
+}
+
+// Groups ride along in the sessions response, so every edit patches that
+// one cache entry and lets the change push settle the rest.
+function useGroupCache() {
+  const queryClient = useQueryClient();
+  const key = sessionKeys.list();
+  return {
+    key,
+    refresh: () => queryClient.invalidateQueries({ queryKey: key }),
+    async patch(edit: (old: SessionsResponse) => SessionsResponse) {
+      await queryClient.cancelQueries({ queryKey: key });
+      const previous = queryClient.getQueryData<SessionsResponse>(key);
+      queryClient.setQueryData<SessionsResponse>(
+        key,
+        (old) => old && edit(old)
+      );
+      return { previous };
+    },
+    restore(previous?: SessionsResponse) {
+      if (previous) queryClient.setQueryData(key, previous);
+    },
+  };
+}
+
+export function useCreateGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (v: { name: string; workspaceId: string | null }) =>
+      send<{ sessionGroup: SessionGroup }>("/api/session-groups", "POST", v),
+    onSuccess: ({ sessionGroup }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: [...old.sessionGroups, sessionGroup],
+      })),
+    onError: (e: Error) => toast.error(e.message),
+    onSettled: cache.refresh,
+  });
+}
+
+export function useUpdateGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: ({
+      id,
+      ...patch
+    }: {
+      id: string;
+      name?: string;
+      collapsed?: boolean;
+    }) => send(`/api/session-groups/${id}`, "PATCH", patch),
+    onMutate: ({ id, ...patch }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: old.sessionGroups.map((g) =>
+          g.id === id ? { ...g, ...patch } : g
+        ),
+      })),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}
+
+export function useReorderGroups() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (v: { workspaceId: string | null; ids: string[] }) =>
+      send("/api/session-groups/order", "POST", v),
+    onMutate: ({ ids }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: old.sessionGroups.map((g) =>
+          ids.includes(g.id) ? { ...g, sort_order: ids.indexOf(g.id) } : g
+        ),
+      })),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}
+
+// Deleting is soft: the toast's Undo restores the group and its members.
+export function useDeleteGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (g: { id: string; name: string }) =>
+      send(`/api/session-groups/${g.id}`, "DELETE"),
+    onMutate: (g) =>
+      cache.patch((old) => ({
+        ...old,
+        sessionGroups: old.sessionGroups.filter((x) => x.id !== g.id),
+      })),
+    onSuccess: (_d, g) =>
+      toast(`Deleted group ${g.name}`, {
+        description: "Its sessions went back to the shelves.",
+        duration: 10_000,
+        action: {
+          label: "Undo",
+          onClick: () =>
+            send(`/api/session-groups/${g.id}/restore`, "POST")
+              .catch((e: Error) => toast.error(e.message))
+              .finally(cache.refresh),
+        },
+      }),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}
+
+// One or many sessions into a group, or out of it with groupId null.
+export function useAssignGroup() {
+  const cache = useGroupCache();
+  return useMutation({
+    mutationFn: (v: { ids: string[]; groupId: string | null }) =>
+      send("/api/sessions/group", "POST", v),
+    onMutate: ({ ids, groupId }) =>
+      cache.patch((old) => ({
+        ...old,
+        sessions: old.sessions.map((s) =>
+          ids.includes(s.id) ? { ...s, session_group_id: groupId } : s
+        ),
+      })),
+    onError: (e: Error, _v, ctx) => {
+      cache.restore(ctx?.previous);
+      toast.error(e.message);
+    },
+    onSettled: cache.refresh,
+  });
+}

package/data/sessions/index.ts

@@ -6,7 +6,6 @@ export {
   useRenameSession,
   useForkSession,
   useSummarizeSession,
-  useMoveSessionToGroup,
   useMoveSessionToProject,
   useSessionSetup,
 } from "./queries";

package/data/sessions/pin.ts

@@ -1,11 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Session, Group } from "@/lib/db";
+import type { Session } from "@/lib/db";
 import { sessionKeys } from "./keys";
-
-interface SessionsResponse {
-  sessions: Session[];
-  groups: Group[];
-}
+import type { SessionsResponse } from "./queries";
 
 export function usePinSession() {
   const queryClient = useQueryClient();

package/data/sessions/queries.ts

@@ -1,13 +1,15 @@
+import { toast } from "sonner";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Session, Group } from "@/lib/db";
+import type { Session } from "@/lib/db";
+import type { SessionGroup } from "@/lib/sidebar/shelves";
 import type { AgentType } from "@/lib/providers";
 import type { ChatAccess, ChatFile, ChatImage } from "@/lib/chat/events";
 import { sessionKeys } from "./keys";
 import { usePollWhenOffline, usePushConnected } from "../push/connection";
 
-interface SessionsResponse {
+export interface SessionsResponse {
   sessions: Session[];
-  groups: Group[];
+  sessionGroups: SessionGroup[];
 }
 
 async function fetchSessions(): Promise<SessionsResponse> {
@@ -128,31 +130,6 @@ export function useSummarizeSession() {
   });
 }
 
-export function useMoveSessionToGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      sessionId,
-      groupPath,
-    }: {
-      sessionId: string;
-      groupPath: string;
-    }) => {
-      const res = await fetch(`/api/sessions/${sessionId}`, {
-        method: "PATCH",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ groupPath }),
-      });
-      if (!res.ok) throw new Error("Failed to move session");
-      return res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
-    },
-  });
-}
-
 export function useMoveSessionToProject() {
   const queryClient = useQueryClient();
 
@@ -172,7 +149,11 @@ export function useMoveSessionToProject() {
       if (!res.ok) throw new Error("Failed to move session");
       return res.json();
     },
-    onSuccess: () => {
+    onSuccess: (data: { clearedGroup?: string | null }) => {
+      if (data.clearedGroup)
+        toast(`Removed from ${data.clearedGroup}`, {
+          description: "Groups stay inside one workspace.",
+        });
       queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
     },
   });

package/data/sessions/shelf.ts

@@ -1,12 +1,8 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Session, Group } from "@/lib/db";
+import type { Session } from "@/lib/db";
 import { toSqliteTime } from "@/lib/session-meta";
 import { sessionKeys } from "./keys";
-
-interface SessionsResponse {
-  sessions: Session[];
-  groups: Group[];
-}
+import type { SessionsResponse } from "./queries";
 
 async function post(url: string, body: object) {
   const res = await fetch(url, {

package/data/tasks/index.ts

@@ -47,6 +47,8 @@ export function useCreateTask() {
       priority?: Priority;
       baseBranch?: string;
       hostId?: string;
+      // Queue behind other work: a task, or "claim:<id>".
+      after?: string;
       view?: "chat" | "terminal";
     }) =>
       // Over the workspace's running task limit it's queued instead.

package/hooks/useSessions.ts

@@ -6,20 +6,17 @@ import {
   useRenameSession,
   useForkSession,
   useSummarizeSession,
-  useMoveSessionToGroup,
   useMoveSessionToProject,
 } from "@/data/sessions";
 
 export function useSessions() {
   const { data, refetch } = useSessionsQuery();
   const sessions = data?.sessions ?? [];
-  const groups = data?.groups ?? [];
 
   const deleteMutation = useDeleteSession();
   const renameMutation = useRenameSession();
   const forkMutation = useForkSession();
   const summarizeMutation = useSummarizeSession();
-  const moveToGroupMutation = useMoveSessionToGroup();
   const moveToProjectMutation = useMoveSessionToProject();
 
   const fetchSessions = useCallback(async () => {
@@ -61,13 +58,6 @@ export function useSessions() {
     [summarizeMutation]
   );
 
-  const moveSessionToGroup = useCallback(
-    async (sessionId: string, groupPath: string) => {
-      await moveToGroupMutation.mutateAsync({ sessionId, groupPath });
-    },
-    [moveToGroupMutation]
-  );
-
   const moveSessionToProject = useCallback(
     async (sessionId: string, projectId: string) => {
       await moveToProjectMutation.mutateAsync({ sessionId, projectId });
@@ -77,7 +67,6 @@ export function useSessions() {
 
   return {
     sessions,
-    groups,
     loaded: data !== undefined,
     summarizingSessionId: summarizeMutation.isPending
       ? (summarizeMutation.variables as string)
@@ -88,7 +77,6 @@ export function useSessions() {
     renameSession,
     forkSession,
     summarizeSession,
-    moveSessionToGroup,
     moveSessionToProject,
   };
 }