@saadnvd1/agent-os 0.3.698 → 0.3.715

package/components/Claims/StartClaimsNotice.tsx

@@ -0,0 +1,70 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { Notice } from "@/components/ui/notice";
+import type { StartWarning } from "@/lib/claims/startWarning";
+
+// Above the composer when a person's task start overlaps claimed work. They
+// choose: start anyway, queue it behind that work, or go back and edit.
+export function StartClaimsNotice({
+  warnings,
+  busy,
+  onStart,
+  onDismiss,
+}: {
+  warnings: StartWarning[];
+  busy: boolean;
+  onStart: (after?: string) => void;
+  onDismiss: () => void;
+}) {
+  const top = warnings[0];
+  if (!top) return null;
+  const files = top.shared.slice(0, 3).join(", ");
+  return (
+    <Notice
+      tone="warning"
+      action={
+        <div className="flex flex-wrap gap-2">
+          <Button
+            size="sm"
+            variant="outline"
+            className="min-h-11 md:min-h-8"
+            disabled={busy}
+            onClick={() => onStart()}
+          >
+            Start anyway
+          </Button>
+          <Button
+            size="sm"
+            className="min-h-11 md:min-h-8"
+            disabled={busy}
+            onClick={() => onStart(`claim:${top.claim.id}`)}
+          >
+            Start after it
+          </Button>
+          <Button
+            size="sm"
+            variant="ghost"
+            className="min-h-11 md:min-h-8"
+            disabled={busy}
+            onClick={onDismiss}
+          >
+            Edit
+          </Button>
+        </div>
+      }
+    >
+      <p className="font-medium">
+        {top.strength === "strong"
+          ? "Someone is already on this"
+          : "This may overlap"}
+        {warnings.length > 1 ? ` (${warnings.length} claims)` : ""}
+      </p>
+      <p className="text-muted-foreground text-xs break-words">
+        “{top.claim.goal}” on {top.claim.machine}
+        {top.claim.branch ? ` (${top.claim.branch})` : ""}
+        {files ? ` touches ${files}` : ""}
+      </p>
+    </Notice>
+  );
+}

package/components/Claims/claims-ui.test.ts

@@ -0,0 +1,161 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { claimKeys } from "@/data/claims/keys";
+import { claimsUi, claimsUiActions } from "@/stores/claimsUi";
+import { ClaimFiles } from "./ClaimFiles";
+import { OverlapPill } from "./OverlapPill";
+import { StartClaimsNotice } from "./StartClaimsNotice";
+import { focusView, groupByRepo, lastHeardText, startedText } from "./format";
+import type { Claim } from "@/lib/claims/types";
+
+const overlap = {
+  strength: "strong" as const,
+  machine: "box",
+  goal: "Rework login",
+  shared: 3,
+  claimId: "r-1",
+  mineId: "s-1",
+};
+
+beforeEach(() => claimsUiActions.setOpen(false));
+
+describe("OverlapPill", () => {
+  it("reads Overlaps: <machine>, amber when strong", () => {
+    const html = renderToStaticMarkup(createElement(OverlapPill, { overlap }));
+    expect(html).toContain("Overlaps: box");
+    expect(html).toContain("text-amber-700");
+    expect(html).toContain('data-overlap="strong"');
+  });
+
+  it("is muted when weak", () => {
+    const html = renderToStaticMarkup(
+      createElement(OverlapPill, { overlap: { ...overlap, strength: "weak" } })
+    );
+    expect(html).toContain("text-muted-foreground");
+    expect(html).not.toContain("text-amber-700");
+  });
+
+  it("opens the claims sheet on that pair when tapped", () => {
+    const el = OverlapPill({ overlap }) as { props: { onClick: () => void } };
+    el.props.onClick();
+    expect(claimsUi.open).toBe(true);
+    expect([...(claimsUi.focus ?? [])]).toEqual(["s-1", "r-1"]);
+    claimsUiActions.showAll();
+    expect(claimsUi.focus).toBeNull();
+  });
+});
+
+describe("StartClaimsNotice", () => {
+  const warnings = [
+    {
+      strength: "strong" as const,
+      kinds: ["files" as const],
+      shared: ["a.ts", "b.ts"],
+      claim: {
+        id: "r-1",
+        goal: "Rework login",
+        machine: "box",
+        branch: "feature/login",
+        sessionName: null,
+      },
+    },
+  ];
+  const html = renderToStaticMarkup(
+    createElement(StartClaimsNotice, {
+      warnings,
+      busy: false,
+      onStart: () => {},
+      onDismiss: () => {},
+    })
+  );
+
+  it("names the work and offers both choices", () => {
+    expect(html).toContain("Rework login");
+    expect(html).toContain("on box");
+    expect(html).toContain("a.ts, b.ts");
+    expect(html).toContain("Start anyway");
+    expect(html).toContain("Start after it");
+  });
+
+  it("renders nothing without a warning", () => {
+    expect(
+      renderToStaticMarkup(
+        createElement(StartClaimsNotice, {
+          warnings: [],
+          busy: false,
+          onStart: () => {},
+          onDismiss: () => {},
+        })
+      )
+    ).toBe("");
+  });
+});
+
+describe("claims keys and helpers", () => {
+  it("keys the list by project", () => {
+    expect(claimKeys.list()).toEqual(["claims", "list", ""]);
+    expect(claimKeys.list("p1")).toEqual(["claims", "list", "p1"]);
+    expect(claimKeys.list("p1").slice(0, 1)).toEqual(claimKeys.all);
+  });
+
+  it("words ages and last heard", () => {
+    expect(startedText({ startedAt: 0 }, 12 * 60_000)).toBe("started 12m ago");
+    expect(startedText({ startedAt: 0 }, 5_000)).toBe("just started");
+    expect(lastHeardText(0, 6 * 60_000)).toBe("last heard 6m ago");
+    expect(lastHeardText(null, 0)).toBe("this machine");
+  });
+
+  const c = (id: string, repo: string, startedAt: number) =>
+    ({ id, repo, startedAt, files: [], filesMore: 0 }) as unknown as Claim;
+
+  it("groups by repo, oldest work first", () => {
+    const groups = groupByRepo([
+      c("a", "r2", 5),
+      c("b", "r1", 9),
+      c("c", "r2", 1),
+    ]);
+    expect(groups.map((g) => [g.repo, g.claims.map((x) => x.id)])).toEqual([
+      ["r2", ["c", "a"]],
+      ["r1", ["b"]],
+    ]);
+  });
+
+  it("narrows to one pair", () => {
+    const view = {
+      claims: [c("a", "r", 1), c("b", "r", 2), c("z", "r", 3)],
+      overlaps: [
+        {
+          a: "a",
+          b: "b",
+          kinds: ["files" as const],
+          shared: [],
+          strength: "weak" as const,
+        },
+        {
+          a: "b",
+          b: "z",
+          kinds: ["files" as const],
+          shared: [],
+          strength: "weak" as const,
+        },
+      ],
+    };
+    const f = focusView(view, ["a", "b"]);
+    expect(f.claims.map((x) => x.id)).toEqual(["a", "b"]);
+    expect(f.overlaps).toHaveLength(1);
+    expect(focusView(view, null)).toBe(view);
+  });
+
+  it("marks shared files in a claim's list", () => {
+    const html = renderToStaticMarkup(
+      createElement(ClaimFiles, {
+        files: ["a.ts", "b.ts"],
+        more: 2,
+        shared: new Set(["a.ts"]),
+      })
+    );
+    expect(html).toContain("and 2 more");
+    expect(html.match(/text-amber-700/g)).toHaveLength(1);
+  });
+});

package/components/Claims/format.ts

@@ -0,0 +1,57 @@
+import type { Claim } from "@/lib/claims/types";
+import type { ClaimsView } from "@/lib/claims/view";
+
+const span = (ms: number) => {
+  const mins = Math.floor(Math.max(0, ms) / 60_000);
+  if (mins < 1) return "under a minute";
+  if (mins < 60) return `${mins}m`;
+  if (mins < 24 * 60) return `${Math.floor(mins / 60)}h`;
+  return `${Math.floor(mins / (24 * 60))}d`;
+};
+
+/** "started 12m ago". */
+export const startedText = (c: Pick<Claim, "startedAt">, now: number) => {
+  const s = span(now - c.startedAt);
+  return s === "under a minute" ? "just started" : `started ${s} ago`;
+};
+
+/** "last heard 6m ago". */
+export const lastHeardText = (at: number | null, now: number) => {
+  if (at === null) return "this machine";
+  const s = span(now - at);
+  return s === "under a minute" ? "heard just now" : `last heard ${s} ago`;
+};
+
+/** A machine not heard from for this long is shown as quiet. */
+export const QUIET_MS = 3 * 60_000;
+
+export interface RepoGroup {
+  repo: string;
+  claims: Claim[];
+}
+
+/** Claims by repository, the repository with the oldest work first. */
+export function groupByRepo(claims: Claim[]): RepoGroup[] {
+  const byRepo = new Map<string, Claim[]>();
+  for (const c of claims)
+    byRepo.set(c.repo, [...(byRepo.get(c.repo) ?? []), c]);
+  return [...byRepo]
+    .map(([repo, list]) => ({
+      repo,
+      claims: [...list].sort((a, b) => a.startedAt - b.startedAt),
+    }))
+    .sort((a, b) => a.claims[0].startedAt - b.claims[0].startedAt);
+}
+
+/** The claims and overlaps of one pair, or everything when no pair is set. */
+export function focusView(
+  view: Pick<ClaimsView, "claims" | "overlaps">,
+  focus: string[] | null
+) {
+  if (!focus) return view;
+  const ids = new Set(focus);
+  return {
+    claims: view.claims.filter((c) => ids.has(c.id)),
+    overlaps: view.overlaps.filter((o) => ids.has(o.a) && ids.has(o.b)),
+  };
+}

package/components/Claims/index.ts

@@ -0,0 +1,3 @@
+export { ClaimsSheet } from "./ClaimsSheet";
+export { OverlapPill } from "./OverlapPill";
+export { StartClaimsNotice } from "./StartClaimsNotice";

package/components/Draft/DraftPanel.tsx

@@ -15,6 +15,9 @@ import { useGitCheck } from "@/data/git/queries";
 import { useSelectedWorkspace } from "@/hooks/useSelectedWorkspace";
 import { useLaunchSession } from "@/data/sessions";
 import { useCreateTask } from "@/data/tasks";
+import { useCheckStart } from "@/data/claims";
+import { StartClaimsNotice } from "@/components/Claims";
+import type { StartWarning } from "@/lib/claims/startWarning";
 import { usePanes } from "@/contexts/PaneContext";
 import { setPendingPrompt } from "@/stores/initialPrompt";
 import { draftsActions, draftsStore, newDraft } from "@/stores/drafts";
@@ -53,8 +56,15 @@ export function DraftPanel({
   const launch = useLaunchSession();
   const { workspace } = useSelectedWorkspace();
   const createTask = useCreateTask();
+  const checkStart = useCheckStart();
   const [prefill, setPrefill] = useState<{ text: string; at: number }>();
-  const pending = launch.isPending || createTask.isPending;
+  // A task start that overlaps claimed work waits here for the person's choice.
+  const [held, setHeld] = useState<{
+    text: string;
+    warnings: StartWarning[];
+  } | null>(null);
+  const pending =
+    launch.isPending || createTask.isPending || checkStart.isPending;
 
   if (!hydrated) return null;
   if (!draft)
@@ -67,15 +77,32 @@ export function DraftPanel({
       </div>
     );
 
-  const send = async (text: string, images: ChatImage[], files: ChatFile[]) => {
+  const send = async (
+    text: string,
+    images: ChatImage[],
+    files: ChatFile[],
+    claim?: { after?: string }
+  ) => {
     try {
       if (draft.openPr) {
         if (!project) throw new Error("Pick a project for a task");
         if (images.length || files.length)
           throw new Error("A task takes text only");
+        if (!claim && draft.hostId === project.host_id) {
+          const warnings = await checkStart.mutateAsync({
+            projectId: project.id,
+            prompt: text,
+          });
+          if (warnings.length) {
+            setHeld({ text, warnings });
+            return;
+          }
+        }
+        setHeld(null);
         const { session, queued } = await createTask.mutateAsync({
           projectId: project.id,
           prompt: text,
+          after: claim?.after,
           model: draft.taskModel ?? undefined,
           priority: draft.taskPriority,
           baseBranch: draft.baseBranch ?? undefined,
@@ -145,6 +172,17 @@ export function DraftPanel({
           git={git}
           onChange={(patch) => draftsActions.update(draft.id, patch)}
         />
+        {held && (
+          <StartClaimsNotice
+            warnings={held.warnings}
+            busy={pending}
+            onStart={(after) => void send(held.text, [], [], { after })}
+            onDismiss={() => {
+              setPrefill({ text: held.text, at: Date.now() });
+              setHeld(null);
+            }}
+          />
+        )}
         <Composer
           draftKey={draftComposerKey(draft.id)}
           attachScope="draft"

package/components/Hosts/AccountMachines.tsx

@@ -0,0 +1,194 @@
+"use client";
+
+import { useState } from "react";
+import { ExternalLink, Link2, Loader2, RefreshCw } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Notice } from "@/components/ui/notice";
+import { LinkForm } from "@/components/Welcome/ConnectBlock";
+import {
+  useAccountMachines,
+  useRefreshAccount,
+  useStartLink,
+} from "@/data/peers";
+import { UPGRADE_URL } from "@/lib/peer/reasons";
+import type { AccountMachine } from "@/lib/peer/machines";
+import { cn } from "@/lib/utils";
+import { WaitingLinks } from "./IncomingLinkSheet";
+import { LinkCodeSheet } from "./LinkCodeSheet";
+
+function MachineRow({
+  machine,
+  canLink,
+  onLink,
+  starting,
+}: {
+  machine: AccountMachine;
+  canLink: boolean;
+  onLink: () => void;
+  starting: boolean;
+}) {
+  const linked = machine.linkState === "active";
+  return (
+    <div
+      className={cn(
+        "bg-muted/40 flex items-center gap-3 rounded-lg px-3 py-2.5",
+        !canLink && !linked && "opacity-60"
+      )}
+    >
+      <span
+        className={cn(
+          "h-2 w-2 shrink-0 rounded-full",
+          machine.online ? "bg-emerald-500" : "bg-muted-foreground/40"
+        )}
+        aria-label={machine.online ? "Online" : "Offline"}
+      />
+      <div className="min-w-0 flex-1">
+        <p className="truncate text-sm font-medium">{machine.name}</p>
+        <p className="text-muted-foreground truncate text-xs">
+          {[
+            machine.online ? "Online" : "Offline",
+            machine.version && `AgentOS ${machine.version}`,
+          ]
+            .filter(Boolean)
+            .join(" · ")}
+        </p>
+      </div>
+      {linked ? (
+        <span className="text-xs font-medium text-emerald-600 dark:text-emerald-400">
+          Linked
+        </span>
+      ) : machine.linkState === "suspended" ? (
+        <span
+          className="text-xs text-amber-700 dark:text-amber-400"
+          title={machine.suspendedReason ?? undefined}
+        >
+          Suspended
+        </span>
+      ) : (
+        <Button
+          variant="outline"
+          size="sm"
+          className="min-h-11 sm:min-h-8"
+          disabled={!canLink || starting}
+          onClick={onLink}
+        >
+          {starting ? (
+            <Loader2 className="h-4 w-4 animate-spin" />
+          ) : (
+            <Link2 className="h-4 w-4" />
+          )}
+          Link
+        </Button>
+      )}
+    </div>
+  );
+}
+
+/** Machines → "On your AgentOS account": link them through Connect. */
+export function AccountMachines() {
+  const { data, isPending, error } = useAccountMachines(true);
+  const refresh = useRefreshAccount();
+  const start = useStartLink();
+  const [linkId, setLinkId] = useState<string | null>(null);
+  const [target, setTarget] = useState<string | null>(null);
+
+  const link = (machineId: string) => {
+    setTarget(machineId);
+    start.mutate(machineId, { onSuccess: (l) => setLinkId(l.id) });
+  };
+
+  if (isPending)
+    return <div className="bg-muted/40 h-14 animate-pulse rounded-lg" />;
+  if (error) return <p className="text-destructive text-xs">{error.message}</p>;
+  if (!data.enrolled)
+    return (
+      <div className="space-y-2 rounded-lg border p-3">
+        <p className="text-sm font-medium">
+          Connect this machine to link it with your others
+        </p>
+        <LinkForm />
+      </div>
+    );
+
+  const entitled = data.entitlements?.linkMachines === true;
+  return (
+    <section className="space-y-2" aria-label="On your AgentOS account">
+      <div className="flex items-center justify-between gap-2">
+        <p className="text-sm font-medium">On your AgentOS account</p>
+        <Button
+          variant="ghost"
+          size="icon-sm"
+          className="h-11 w-11 sm:h-8 sm:w-8"
+          aria-label="Check your account again"
+          disabled={refresh.isPending}
+          onClick={() => refresh.mutate()}
+        >
+          <RefreshCw
+            className={cn("h-4 w-4", refresh.isPending && "animate-spin")}
+          />
+        </Button>
+      </div>
+      {data.uncheckedSince && (
+        <Notice tone="warning">
+          Couldn&apos;t check your account since{" "}
+          {new Date(data.uncheckedSince).toLocaleString([], {
+            dateStyle: "medium",
+            timeStyle: "short",
+          })}
+          . Machines already linked keep working; new links wait until it&apos;s
+          back.
+        </Notice>
+      )}
+      {data.entitlements && !entitled && (
+        <Notice
+          action={
+            <Button asChild variant="outline" className="min-h-11 sm:min-h-9">
+              <a href={UPGRADE_URL} target="_blank" rel="noopener noreferrer">
+                Upgrade
+                <ExternalLink className="h-3.5 w-3.5" />
+              </a>
+            </Button>
+          }
+        >
+          Link your machines with Pro: tasks move between them over any network,
+          end-to-end encrypted.
+        </Notice>
+      )}
+      {entitled && <WaitingLinks />}
+      {data.error && (
+        <p className="text-muted-foreground text-xs">{data.error}</p>
+      )}
+      {data.machines.length === 0 ? (
+        <p className="text-muted-foreground text-xs">
+          No other machines on your account yet. Run{" "}
+          <code className="font-mono">agent-os connect</code> on another
+          machine, then link it here.
+        </p>
+      ) : (
+        data.machines.map((m) => (
+          <MachineRow
+            key={m.id}
+            machine={m}
+            canLink={entitled}
+            starting={start.isPending && target === m.id}
+            onLink={() => link(m.id)}
+          />
+        ))
+      )}
+      {start.error && (
+        <p className="text-destructive text-xs">{start.error.message}</p>
+      )}
+      <LinkCodeSheet
+        linkId={linkId}
+        onClose={() => {
+          setLinkId(null);
+          start.reset();
+        }}
+        onRetry={() => {
+          setLinkId(null);
+          if (target) link(target);
+        }}
+      />
+    </section>
+  );
+}