@saadnvd1/agent-os 0.3.697 → 0.3.700

package/app/api/bus/send/route.ts

@@ -1,16 +1,26 @@
 import { NextRequest, NextResponse } from "next/server";
 import { sendMessage } from "@/lib/bus";
+import { parseTimeout } from "@/lib/bus/waits/register";
 
 // from: the sending session's id, or null when the user sends from the UI.
 // The message is stored either way; delivery says whether it reached the
 // recipient ("delivered", "queued" behind a busy turn, or "failed" + why).
 export async function POST(request: NextRequest) {
   try {
-    const { from = null, to, body } = await request.json();
+    const {
+      from = null,
+      to,
+      body,
+      await: waits = false,
+      timeout,
+      replyTo,
+    } = await request.json();
     const sent = await sendMessage({
       fromId: from,
       to: String(to ?? ""),
       body: String(body ?? ""),
+      replyTo: replyTo == null ? undefined : Number(replyTo),
+      awaitMs: waits ? parseTimeout(timeout) : undefined,
     });
     return NextResponse.json(sent, { status: 201 });
   } catch (error) {

package/app/api/bus/wait/route.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+import { registerWait } from "@/lib/bus/waits/register";
+
+// `aos wait <session> --until idle|merged|reply`: records the wait and
+// returns; the sweep wakes the sender when it holds (lib/bus/waits/tick).
+export async function POST(request: NextRequest) {
+  try {
+    const { from, to, until, timeout } = await request.json();
+    if (typeof from !== "string" || !from)
+      throw new Error("aos wait runs from inside an AgentOS session");
+    const result = await registerWait({
+      fromId: from,
+      to: String(to ?? ""),
+      until: String(until ?? ""),
+      timeout: timeout == null ? null : String(timeout),
+    });
+    return NextResponse.json(result, { status: 201 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/peer/hello/reveal/route.ts

@@ -0,0 +1,6 @@
+import { helloRoute } from "@/lib/peer/hello-route";
+import { receiveReveal } from "@/lib/peer/pairing";
+
+// POST /api/peer/hello/reveal - public: the asking machine reveals the nonce
+// its hello committed to.
+export const POST = helloRoute((body) => receiveReveal(body));

package/app/api/peer/hello/route.ts

@@ -0,0 +1,9 @@
+import { helloRoute } from "@/lib/peer/hello-route";
+import { receiveHello } from "@/lib/peer/pairing";
+import { SOURCE_HEADER } from "@/lib/security/auth";
+
+// POST /api/peer/hello - public: another machine on this Connect account
+// asks to link (lib/peer/pairing.ts).
+export const POST = helloRoute((body, request) =>
+  receiveHello(body, undefined, request.headers.get(SOURCE_HEADER) ?? "unknown")
+);

package/app/api/peer/hello/status/route.ts

@@ -0,0 +1,6 @@
+import { helloRoute } from "@/lib/peer/hello-route";
+import { receiveStatus } from "@/lib/peer/pairing";
+
+// POST /api/peer/hello/status - public: the asking machine learns, signed,
+// whether the code was typed here.
+export const POST = helloRoute((body) => receiveStatus(body));

package/app/api/peer/ping/route.ts

@@ -0,0 +1,10 @@
+import { NextResponse } from "next/server";
+import { appVersion } from "@/lib/connect/heartbeat";
+
+export const dynamic = "force-dynamic";
+
+// What a linked machine asks first: which version answers, and which peer
+// features it speaks. Nothing about this machine's sessions or paths.
+export function GET() {
+  return NextResponse.json({ version: appVersion(), capabilities: ["rpc-v1"] });
+}

package/app/api/peers/account/route.ts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from "next/server";
+import { accountMachines } from "@/lib/peer/machines";
+
+// GET /api/peers/account[?refresh=1] - the other machines on this Connect
+// account, whether each is linked here, and whether the plan allows linking.
+export async function GET(request: NextRequest) {
+  const refresh = request.nextUrl.searchParams.get("refresh") === "1";
+  return NextResponse.json(await accountMachines(refresh));
+}

package/app/api/peers/gate.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+import { NextRequest } from "next/server";
+import { mintDevice } from "@/lib/security/devices";
+import { isPublicPath } from "@/lib/security/auth";
+
+const accept = await import("./pending/[id]/accept/route");
+const decline = await import("./pending/[id]/decline/route");
+const link = await import("./link/route");
+const cancel = await import("./link/[id]/route");
+const confirm = await import("./link/[id]/confirm/route");
+const hello = await import("../peer/hello/route");
+
+const plain = mintDevice("phone").device.id;
+const approver = mintDevice("tablet", null, true).device.id;
+
+const req = (
+  path: string,
+  o: { trust?: string; device?: string; body?: string; method?: string } = {}
+) =>
+  new NextRequest(`http://localhost${path}`, {
+    method: o.method ?? "POST",
+    headers: {
+      ...(o.trust && { "x-agentos-trust": o.trust }),
+      ...(o.device && { "x-agentos-device": o.device }),
+      "content-type": "application/json",
+    },
+    body: o.body ?? JSON.stringify({ code: "123456" }),
+  });
+const params = { params: Promise.resolve({ id: "nope" }) };
+
+describe("linking routes", () => {
+  it("take a code only from this machine, the tailnet or a Can approve device", async () => {
+    for (const who of [
+      {},
+      { trust: "device", device: plain },
+      { trust: "device", device: "unknown" },
+      { trust: "peer" },
+      { trust: "open" },
+    ]) {
+      const r = await accept.POST(
+        req("/api/peers/pending/nope/accept", who),
+        params
+      );
+      expect(r.status).toBe(403);
+      expect((await decline.POST(req("/x", who), params)).status).toBe(403);
+      expect((await confirm.POST(req("/x", who), params)).status).toBe(403);
+      expect((await link.POST(req("/x", { ...who, body: "{}" }))).status).toBe(
+        403
+      );
+      expect(
+        (
+          await cancel.DELETE(
+            req("/x", { ...who, method: "DELETE", body: "" }),
+            params
+          )
+        ).status
+      ).toBe(403);
+    }
+    // Past the gate: there is no such request.
+    for (const who of [
+      { trust: "loopback" },
+      { trust: "tailnet" },
+      { trust: "device", device: approver },
+    ])
+      expect(
+        (await accept.POST(req("/api/peers/pending/nope/accept", who), params))
+          .status
+      ).toBe(404);
+    expect(
+      (await confirm.POST(req("/x", { trust: "loopback" }), params)).status
+    ).toBe(404);
+    expect(
+      (await link.POST(req("/x", { trust: "loopback", body: "{}" }))).status
+    ).toBe(400);
+    for (const body of ['{"code":482913}', "{", "{}"])
+      for (const route of [accept, confirm])
+        expect(
+          (await route.POST(req("/x", { trust: "loopback", body }), params))
+            .status
+        ).toBe(400);
+  });
+
+  it("caps a hello at 4 KiB and refuses junk", async () => {
+    const big = await hello.POST(
+      req("/api/peer/hello", { body: "x".repeat(5000) })
+    );
+    expect(big.status).toBe(413);
+    expect(
+      (await hello.POST(req("/api/peer/hello", { body: "{" }))).status
+    ).toBe(400);
+    expect(big.headers.get("cache-control")).toBe("no-store");
+  });
+
+  it("are public only for the three hello paths", () => {
+    for (const p of [
+      "/api/peer/hello",
+      "/api/peer/hello/reveal",
+      "/api/peer/hello/status",
+    ])
+      expect(isPublicPath(p)).toBe(true);
+    for (const p of [
+      "/api/peer/hello/x",
+      "/api/peer/hello/../../pair/start",
+      "/api/peers/pending",
+      "/api/peers/account",
+      "/api/peers/link",
+      "/api/peers/link/x/confirm",
+    ])
+      expect(isPublicPath(p)).toBe(false);
+  });
+});

package/app/api/peers/link/[id]/confirm/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { requireApprover } from "@/lib/security/approver";
+import { confirmLink } from "@/lib/peer/pairing-out";
+
+const bodySchema = z.object({ code: z.string().max(32) });
+
+// POST /api/peers/link/:id/confirm {code} - the code the other machine shows
+// once it took ours, typed here: only then is it pinned. Same gate as
+// starting the link.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  const body = bodySchema.safeParse(await request.json().catch(() => null));
+  if (!body.success)
+    return NextResponse.json({ error: "code required" }, { status: 400 });
+  const result = confirmLink((await params).id, body.data.code);
+  if (!result.ok)
+    return NextResponse.json(
+      { error: result.error, attemptsLeft: result.attemptsLeft },
+      { status: result.status }
+    );
+  return NextResponse.json({ link: result.link });
+}

package/app/api/peers/link/[id]/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { cancelLink, outgoingLink } from "@/lib/peer/pairing-out";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// GET /api/peers/link/:id - a link this machine started: its code and state.
+export async function GET(_request: NextRequest, { params }: Ctx) {
+  const link = outgoingLink((await params).id);
+  if (!link)
+    return NextResponse.json({ error: "No such request" }, { status: 404 });
+  return NextResponse.json({ link });
+}
+
+// DELETE /api/peers/link/:id - stop waiting for it.
+export async function DELETE(request: NextRequest, { params }: Ctx) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  return NextResponse.json({ cancelled: cancelLink((await params).id) });
+}

package/app/api/peers/link/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { requireApprover } from "@/lib/security/approver";
+import { LinkError, startLink } from "@/lib/peer/pairing-out";
+
+const bodySchema = z.object({ machineId: z.string().min(1).max(64) });
+
+// POST /api/peers/link {machineId} - ask an account machine to link. Once
+// linked it can run code here too, so only a trusted place may start it.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  const body = bodySchema.safeParse(await request.json().catch(() => null));
+  if (!body.success)
+    return NextResponse.json({ error: "machineId required" }, { status: 400 });
+  try {
+    return NextResponse.json({ link: await startLink(body.data.machineId) });
+  } catch (error) {
+    const status = error instanceof LinkError ? error.status : 500;
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status });
+  }
+}

package/app/api/peers/pending/[id]/accept/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { requireApprover } from "@/lib/security/approver";
+import { acceptRequest } from "@/lib/peer/pairing";
+
+const bodySchema = z.object({ code: z.string().max(32) });
+
+// POST /api/peers/pending/:id/accept {code} - the code the other machine
+// shows, typed here. Linking lets that machine run code here, so it takes
+// this machine, the tailnet or a device with Can approve.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  const body = bodySchema.safeParse(await request.json().catch(() => null));
+  if (!body.success)
+    return NextResponse.json({ error: "code required" }, { status: 400 });
+  const result = await acceptRequest((await params).id, body.data.code);
+  if (!result.ok)
+    return NextResponse.json(
+      { error: result.error, attemptsLeft: result.attemptsLeft },
+      { status: result.status }
+    );
+  return NextResponse.json({
+    hostId: result.hostId,
+    name: result.name,
+    confirmCode: result.confirmCode,
+  });
+}

package/app/api/peers/pending/[id]/decline/route.ts

@@ -0,0 +1,13 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { declineRequest } from "@/lib/peer/pairing";
+
+// POST /api/peers/pending/:id/decline
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  return NextResponse.json({ declined: declineRequest((await params).id) });
+}

package/app/api/peers/pending/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from "next/server";
+import { pendingRequests } from "@/lib/peer/pairing";
+
+// GET /api/peers/pending - machines asking to link here, waiting for the code.
+export function GET() {
+  return NextResponse.json({ requests: pendingRequests() });
+}

package/app/api/sessions/route.ts

@@ -4,6 +4,7 @@ import { isValidAgentType } from "@/lib/providers";
 import { clientSend } from "@/lib/chat/client-send";
 import { CHAT_ACCESS } from "@/lib/chat/events";
 import { launchSession } from "@/lib/sessions/launch";
+import { namesLine, waitBadges } from "@/lib/bus/waits/store";
 import { isProjectRef } from "@/lib/tasks/project-ref";
 
 // GET /api/sessions - List all sessions and groups
@@ -13,7 +14,23 @@ export async function GET() {
     // Merged tasks are listed (the sidebar files them under Done). Dropped
     // tasks live in the Tasks panel, a moved one on the machine it moved to,
     // and archived sessions in the Archived view: none is in the sidebar.
-    const sessions = queries.getSidebarSessions(db).all() as Session[];
+    const badges = waitBadges();
+    const sessions = (queries.getSidebarSessions(db).all() as Session[]).map(
+      (s) => {
+        const b = badges.get(s.id);
+        return b
+          ? {
+              ...s,
+              waiting_on: b.on.length
+                ? namesLine(b.on.map((w) => w.name))
+                : null,
+              waited_by: b.by.length
+                ? namesLine(b.by.map((w) => w.name))
+                : null,
+            }
+          : s;
+      }
+    );
     const groups = queries.getAllGroups(db).all() as Group[];
 
     // Convert expanded from 0/1 to boolean

package/app/page.tsx

@@ -34,6 +34,7 @@ if (typeof window !== "undefined") {
 import { PaneProvider, usePanes } from "@/contexts/PaneContext";
 import { Pane } from "@/components/Pane";
 import { AwayReport } from "@/components/Away/AwayReport";
+import { IncomingLinks } from "@/components/Hosts/IncomingLinkSheet";
 import type { BrowserNotifications } from "@/components/Settings/NotificationsSection";
 import { useNotifications } from "@/hooks/useNotifications";
 import { useViewport } from "@/hooks/useViewport";
@@ -161,6 +162,7 @@ const AppDialogs = memo(function AppDialogs({
       <MoveDialog />
       <ShareDialog />
       <AwayReport />
+      <IncomingLinks />
       <CommandPalette />
     </>
   );

package/components/Hosts/AccountMachines.tsx

@@ -0,0 +1,180 @@
+"use client";
+
+import { useState } from "react";
+import { ExternalLink, Link2, Loader2, RefreshCw } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { LinkForm } from "@/components/Welcome/ConnectBlock";
+import {
+  useAccountMachines,
+  useRefreshAccount,
+  useStartLink,
+} from "@/data/peers";
+import { CONNECT_SITE } from "@/lib/connect/view";
+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-muted-foreground text-xs">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.entitlements && !entitled && (
+        <div className="flex flex-col gap-2 rounded-lg border p-3 sm:flex-row sm:items-center">
+          <p className="flex-1 text-sm">
+            Link your machines with Pro: tasks move between them over any
+            network, end-to-end encrypted.
+          </p>
+          <Button asChild variant="outline" className="min-h-11 sm:min-h-9">
+            <a
+              href={`${CONNECT_SITE}/settings/billing`}
+              target="_blank"
+              rel="noopener noreferrer"
+            >
+              Upgrade
+              <ExternalLink className="h-3.5 w-3.5" />
+            </a>
+          </Button>
+        </div>
+      )}
+      {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>
+  );
+}