@saadnvd1/agent-os 0.3.698 → 0.3.715

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/index.ts

@@ -0,0 +1,2 @@
+export * from "./keys";
+export * from "./queries";

package/data/peers/keys.ts

@@ -0,0 +1,7 @@
+export const peerKeys = {
+  all: ["peers"] as const,
+  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

@@ -0,0 +1,172 @@
+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";
+import { hostKeys } from "../hosts/keys";
+import { peerKeys } from "./keys";
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw Object.assign(new Error(data.error || "Request failed"), {
+      attemptsLeft: data.attemptsLeft as number | undefined,
+    });
+  return data;
+}
+
+const post = (url: string, body?: object) =>
+  fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+/** The other machines on this Connect account, and the plan. */
+export function useAccountMachines(enabled: boolean) {
+  return useQuery({
+    queryKey: peerKeys.account(),
+    queryFn: async () =>
+      json<AccountMachines>(await fetch("/api/peers/account")),
+    enabled,
+    staleTime: 30_000,
+  });
+}
+
+export function useRefreshAccount() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async () =>
+      json<AccountMachines>(await fetch("/api/peers/account?refresh=1")),
+    onSuccess: (data) => queryClient.setQueryData(peerKeys.account(), data),
+  });
+}
+
+/** Machines asking to link here: shown on every page until answered. */
+export function usePendingLinks() {
+  return useQuery({
+    queryKey: peerKeys.pending(),
+    queryFn: async () =>
+      (
+        await json<{ requests: PendingView[] }>(
+          await fetch("/api/peers/pending")
+        )
+      ).requests,
+    refetchInterval: 10_000,
+  });
+}
+
+export function useStartLink() {
+  return useMutation({
+    mutationFn: async (machineId: string) =>
+      (
+        await json<{ link: Outgoing }>(
+          await post("/api/peers/link", { machineId })
+        )
+      ).link,
+  });
+}
+
+/** A link this machine started, followed until it ends. */
+export function useOutgoingLink(id: string | null) {
+  const queryClient = useQueryClient();
+  return useQuery({
+    queryKey: peerKeys.link(id ?? ""),
+    queryFn: async () => {
+      const { link } = await json<{ link: Outgoing }>(
+        await fetch(`/api/peers/link/${id}`)
+      );
+      if (link.state === "accepted") {
+        void queryClient.invalidateQueries({ queryKey: hostKeys.all });
+        void queryClient.invalidateQueries({ queryKey: peerKeys.account() });
+      }
+      return link;
+    },
+    enabled: !!id,
+    refetchInterval: (q) =>
+      !q.state.data || q.state.data.state === "pending" ? 1500 : false,
+  });
+}
+
+/** The code the other machine shows once it took ours: only it pins it. */
+export function useConfirmLink() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (o: { id: string; code: string }) =>
+      (
+        await json<{ link: Outgoing }>(
+          await post(`/api/peers/link/${o.id}/confirm`, { code: o.code })
+        )
+      ).link,
+    onSuccess: (link) => {
+      queryClient.setQueryData(peerKeys.link(link.id), link);
+      void queryClient.invalidateQueries({ queryKey: hostKeys.all });
+      void queryClient.invalidateQueries({ queryKey: peerKeys.account() });
+    },
+    // Three wrong codes end it: show that.
+    onError: (_e, o) =>
+      void queryClient.invalidateQueries({ queryKey: peerKeys.link(o.id) }),
+  });
+}
+
+export function useCancelLink() {
+  return useMutation({
+    mutationFn: async (id: string) =>
+      json(await fetch(`/api/peers/link/${id}`, { method: "DELETE" })),
+  });
+}
+
+export function useAnswerLink() {
+  const queryClient = useQueryClient();
+  const done = () => {
+    void queryClient.invalidateQueries({ queryKey: peerKeys.all });
+    void queryClient.invalidateQueries({ queryKey: hostKeys.all });
+  };
+  return {
+    accept: useMutation({
+      mutationFn: async (o: { id: string; code: string }) =>
+        json<{ hostId: string; name: string; confirmCode: string }>(
+          await post(`/api/peers/pending/${o.id}/accept`, { code: o.code })
+        ),
+      onSuccess: done,
+      // A wrong code changes how many tries are left.
+      onError: () =>
+        void queryClient.invalidateQueries({ queryKey: peerKeys.pending() }),
+    }),
+    decline: useMutation({
+      mutationFn: async (id: string) =>
+        json(await post(`/api/peers/pending/${id}/decline`)),
+      onSuccess: done,
+    }),
+  };
+}
+
+/** 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,
   };
 }