@saadnvd1/agent-os 0.3.700 → 0.3.723

package/app/api/claims/outside.test.ts

@@ -0,0 +1,90 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { NextRequest } from "next/server";
+import { db } from "@/lib/db";
+import { machineId } from "@/lib/claims/machine";
+import { putSetting } from "@/lib/settings-store";
+import { upsertLocal } from "@/lib/claims/store";
+import { POST } from "./route";
+import { DELETE } from "./[id]/route";
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM work_claims`).run();
+  putSetting("claims.share", null);
+});
+
+const post = (body: unknown) =>
+  POST(
+    new NextRequest("http://localhost/api/claims", {
+      method: "POST",
+      body: JSON.stringify(body),
+    })
+  );
+const del = (id: string) =>
+  DELETE(new Request("http://localhost"), { params: Promise.resolve({ id }) });
+
+const ok = {
+  remote: "https://github.com/acme/widgets.git",
+  branch: "feature/search",
+  goal: "Rework search",
+  files: ["src/search.ts"],
+};
+
+describe("POST /api/claims", () => {
+  it("registers, then reports an overlap with a task's claim", async () => {
+    upsertLocal(
+      { id: machineId(), name: "here" },
+      {
+        sessionId: "t1",
+        sessionName: "Task",
+        repo: "github.com/acme/widgets",
+        branch: "task/search",
+        base: "main",
+        goal: "Search work",
+        files: ["src/search.ts"],
+        filesMore: 0,
+        prUrl: null,
+      }
+    );
+    const res = await post(ok);
+    const data = await res.json();
+    expect(res.status).toBe(200);
+    expect(data.id).toMatch(/^o-/);
+    expect(data.overlaps[0].strength).toBe("strong");
+  });
+
+  it("rejects a bad body, a non-remote and a custom id", async () => {
+    expect((await post({ remote: 5 })).status).toBe(400);
+    expect((await post({ ...ok, id: "s-abc" })).status).toBe(400);
+    expect((await post({ ...ok, remote: "/srv/x" })).status).toBe(422);
+  });
+
+  it("is off when claims are", async () => {
+    putSetting("claims.share", "off");
+    expect((await post(ok)).status).toBe(409);
+  });
+});
+
+describe("DELETE /api/claims/:id", () => {
+  it("ends an outside claim but not a task's", async () => {
+    upsertLocal(
+      { id: machineId(), name: "here" },
+      {
+        sessionId: "t1",
+        sessionName: "Task",
+        repo: "github.com/acme/widgets",
+        branch: "x",
+        base: "main",
+        goal: "Task",
+        files: [],
+        filesMore: 0,
+        prUrl: null,
+      }
+    );
+    expect((await del("s-t1")).status).toBe(403);
+    const { id } = await (await post(ok)).json();
+    expect((await del(id)).status).toBe(200);
+    expect((await del("o-00000000-0000-0000-0000-000000000000")).status).toBe(
+      200
+    );
+  });
+});

package/app/api/claims/route.test.ts

@@ -0,0 +1,193 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { NextRequest } from "next/server";
+import { db } from "@/lib/db";
+import { machineId } from "@/lib/claims/machine";
+import { createConnectHost } from "@/lib/hosts";
+import { putSetting } from "@/lib/settings-store";
+import { savePin, suspendPin } from "@/lib/peer/links";
+import { upsertLocal } from "@/lib/claims/store";
+import { GET } from "./route";
+import { POST } from "./exchange/route";
+
+const post = (body: unknown) =>
+  POST(
+    new NextRequest("http://localhost/api/claims/exchange", {
+      method: "POST",
+      body: typeof body === "string" ? body : JSON.stringify(body),
+    })
+  );
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM work_claims`).run();
+});
+
+const claim = {
+  id: "r1",
+  origin: "peer-1",
+  origin_name: "box",
+  goal: "Add oauth",
+  repo: "github.com/acme/widgets",
+  branch: "feature/oauth",
+  files: ["a.ts"],
+  ttl_s: 300,
+  age_s: 5,
+};
+
+describe("POST /api/claims/exchange", () => {
+  it("stores a peer's claims and answers with ours", async () => {
+    upsertLocal(
+      { id: machineId(), name: "here" },
+      {
+        sessionId: "s",
+        sessionName: "Mine",
+        repo: "github.com/acme/widgets",
+        branch: "feature/mine",
+        base: "main",
+        goal: "Mine",
+        files: [],
+        filesMore: 0,
+        prUrl: null,
+      }
+    );
+    const res = await post({
+      machine: { id: "peer-1", name: "box" },
+      claims: [claim],
+    });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.machine.id).toBe(machineId());
+    expect(body.claims.map((c: { id: string }) => c.id)).toEqual(["s-s"]);
+    const list = await (
+      await GET(new NextRequest("http://localhost/api/claims"))
+    ).json();
+    expect(list.claims.map((c: { id: string }) => c.id).sort()).toEqual([
+      "r1",
+      "s-s",
+    ]);
+  });
+
+  it("refuses bodies that are not claims", async () => {
+    expect((await post("{nope")).status).toBe(400);
+    expect(
+      (await post({ machine: { id: "p", name: "n" }, claims: [{ id: "x" }] }))
+        .status
+    ).toBe(400);
+    expect(
+      (
+        await post({
+          machine: { id: "p", name: "n" },
+          claims: [{ ...claim, ttl_s: -5 }],
+        })
+      ).status
+    ).toBe(400);
+  });
+});
+
+describe("POST /api/claims/exchange as a Connect peer", () => {
+  const asPeer = (hostId: string | null) =>
+    POST(
+      new NextRequest("http://localhost/api/claims/exchange", {
+        method: "POST",
+        headers: {
+          "x-agentos-trust": "peer",
+          ...(hostId && { "x-agentos-peer": hostId }),
+        },
+        body: JSON.stringify({
+          machine: { id: "peer-1", name: "box" },
+          claims: [claim],
+        }),
+      })
+    );
+
+  it("refuses a host with no active pin and stores nothing", async () => {
+    expect((await asPeer("no-such-host")).status).toBe(403);
+    expect((await asPeer(null)).status).toBe(403);
+    expect(db.prepare(`SELECT 1 FROM work_claims`).all()).toEqual([]);
+  });
+
+  it("refuses a suspended pin, and an active one keeps its via_host", async () => {
+    const host = createConnectHost(`Spark-${Date.now()}`).id;
+    savePin({
+      hostId: host,
+      machineId: "b2b2b2b2",
+      hostname: "m-0123456789abcdef.runagentos.com",
+      signPub: "s",
+      boxPub: "b",
+    });
+    expect((await asPeer(host)).status).toBe(200);
+    const via = () =>
+      (
+        db.prepare(`SELECT via_host FROM work_claims WHERE id='r1'`).get() as {
+          via_host: string | null;
+        }
+      ).via_host;
+    expect(via()).toBe(host);
+    // A token caller re-sending it, with more life, must not clear the pin.
+    await post({
+      machine: { id: "peer-1", name: "box" },
+      claims: [{ ...claim, ttl_s: 600 }],
+    });
+    expect(via()).toBe(host);
+    suspendPin(host, "revoked");
+    db.prepare(`DELETE FROM work_claims`).run();
+    expect((await asPeer(host)).status).toBe(403);
+    expect(db.prepare(`SELECT 1 FROM work_claims`).all()).toEqual([]);
+  });
+
+  it("writes nothing when sharing is off", async () => {
+    const host = createConnectHost(`Studio-${Date.now()}`).id;
+    savePin({
+      hostId: host,
+      machineId: "c3c3c3c3",
+      hostname: "m-fedcba9876543210.runagentos.com",
+      signPub: "s",
+      boxPub: "b",
+    });
+    db.prepare(`DELETE FROM claim_peers`).run();
+    putSetting("claims.share", "off");
+    try {
+      expect((await asPeer(host)).status).toBe(200);
+    } finally {
+      putSetting("claims.share", "on");
+    }
+    expect(db.prepare(`SELECT 1 FROM claim_peers`).all()).toEqual([]);
+  });
+});
+
+describe("GET /api/claims", () => {
+  it("rejects a bad query and an unknown session", async () => {
+    const bad = await GET(
+      new NextRequest(`http://localhost/api/claims?repo=${"x".repeat(400)}`)
+    );
+    expect(bad.status).toBe(400);
+    const none = await GET(
+      new NextRequest("http://localhost/api/claims?session=missing")
+    );
+    expect(none.status).toBe(404);
+  });
+
+  it("narrows to a repo and lists overlaps", async () => {
+    await post({
+      machine: { id: "peer-1", name: "box" },
+      claims: [
+        claim,
+        {
+          ...claim,
+          id: "r2",
+          origin: "peer-2",
+          origin_name: "pc",
+          repo: "github.com/acme/other",
+        },
+      ],
+    });
+    const body = await (
+      await GET(
+        new NextRequest(
+          "http://localhost/api/claims?repo=github.com/acme/widgets"
+        )
+      )
+    ).json();
+    expect(body.claims.map((c: { id: string }) => c.id)).toEqual(["r1"]);
+    expect(body.overlaps).toEqual([]);
+  });
+});

package/app/api/claims/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  claimsShared,
+  claimsView,
+  liveClaims,
+  registerOutside,
+} from "@/lib/claims";
+import { outsideBody } from "@/lib/claims/types";
+import { repoKey } from "@/lib/git-remote";
+import { getDb, queries, type Session } from "@/lib/db";
+import { getProject } from "@/lib/projects";
+import { expandHome } from "@/lib/tasks/session";
+
+export const dynamic = "force-dynamic";
+
+const query = z.object({
+  session: z.string().max(100).optional(),
+  project: z.string().max(100).optional(),
+  repo: z.string().max(300).optional(),
+});
+
+// GET /api/claims - what live sessions, here and on linked machines, are
+// working on, with the pairs that overlap and when each machine was last
+// heard from. `session` or `project` narrows it to that repository.
+export async function GET(request: NextRequest) {
+  const q = query.safeParse(Object.fromEntries(request.nextUrl.searchParams));
+  if (!q.success)
+    return NextResponse.json({ error: "Bad query" }, { status: 400 });
+  let repo = q.data.repo?.toLowerCase();
+  if (q.data.session) {
+    const s = queries.getSession(getDb()).get(q.data.session) as
+      Session | undefined;
+    if (!s)
+      return NextResponse.json({ error: "No such session" }, { status: 404 });
+    repo =
+      (await repoKey(expandHome(s.worktree_path || s.working_directory))) ??
+      undefined;
+    if (!repo) return NextResponse.json(shape([]));
+  }
+  if (q.data.project) {
+    const p = getProject(q.data.project);
+    if (!p)
+      return NextResponse.json({ error: "No such project" }, { status: 404 });
+    repo = (await repoKey(expandHome(p.working_directory))) ?? undefined;
+    if (!repo) return NextResponse.json(shape([]));
+  }
+  return NextResponse.json(shape(liveClaims({ repo })));
+}
+
+// POST /api/claims - a session AgentOS didn't start registers or renews its
+// claim (`aos claim start|touch`). The CLI read git in its own folder and
+// sends the remote URL, branch and paths; nothing is run here.
+export async function POST(request: NextRequest) {
+  const body = outsideBody.safeParse(await request.json().catch(() => null));
+  if (!body.success)
+    return NextResponse.json({ error: "Bad claim" }, { status: 400 });
+  if (!claimsShared())
+    return NextResponse.json({ error: "Claims are off" }, { status: 409 });
+  const result = registerOutside(body.data);
+  if (!result)
+    return NextResponse.json(
+      { error: "No repository remote, or that id belongs to another claim" },
+      { status: 422 }
+    );
+  const claims = liveClaims({ repo: result.claim.repo });
+  const overlaps = shape(claims).overlaps.filter(
+    (o) => o.a === result.claim.id || o.b === result.claim.id
+  );
+  return NextResponse.json({ ...shape(claims), id: result.claim.id, overlaps });
+}
+
+const shape = (claims: ReturnType<typeof liveClaims>) => claimsView(claims);

package/app/api/hosts/[id]/route.ts

@@ -1,12 +1,20 @@
 import { NextRequest, NextResponse } from "next/server";
 import { deleteHost } from "@/lib/hosts";
+import { pinForHost } from "@/lib/peer/links";
 
 export async function DELETE(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
   try {
-    deleteHost((await params).id);
+    const id = (await params).id;
+    // Removing it here would leave the other machine linked to this one.
+    if (pinForHost(id))
+      return NextResponse.json(
+        { error: "It's linked through Connect: unlink it first." },
+        { status: 409 }
+      );
+    deleteHost(id);
     return NextResponse.json({ success: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/models/availability/route.ts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from "next/server";
+import { modelAvailability } from "@/lib/models/availability-refs";
+
+// GET /api/models/availability?refresh=1 - whether each local model's
+// server answers now (ref to state). Cloud models aren't probed.
+export async function GET(request: NextRequest) {
+  const refresh = request.nextUrl.searchParams.has("refresh");
+  return NextResponse.json(await modelAvailability(refresh));
+}

package/app/api/models/choices/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+import { modelCatalog } from "@/lib/models/catalog";
+
+// GET /api/models/choices - every model a picker offers, from the server:
+// the enabled providers' models and the ones Pi reaches, each with its
+// locality (local or cloud) and the last availability check.
+export async function GET() {
+  return NextResponse.json({ choices: modelCatalog() });
+}

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

@@ -0,0 +1,17 @@
+import { NextRequest, NextResponse } from "next/server";
+import { PEER_HEADER, TRUST_HEADER } from "@/lib/security/auth";
+import { getHost } from "@/lib/hosts";
+import { unlinkedByPeer } from "@/lib/peer/links";
+
+export const dynamic = "force-dynamic";
+
+// POST /api/peer/unlink - a linked machine unlinked this one. Reached only
+// through its signed envelope (lib/peer/rpc-server.ts), which the gate turns
+// into `peer` trust naming the host it's pinned to; nothing else may call it.
+export function POST(request: NextRequest) {
+  const hostId = request.headers.get(PEER_HEADER);
+  if (request.headers.get(TRUST_HEADER) !== "peer" || !hostId)
+    return NextResponse.json({ error: "forbidden" }, { status: 403 });
+  const name = getHost(hostId)?.name ?? "the other machine";
+  return NextResponse.json({ unlinked: unlinkedByPeer(hostId, name) });
+}

package/app/api/peers/[hostId]/audit/route.ts

@@ -0,0 +1,14 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { peerAudit } from "@/lib/peer/audit";
+
+// GET /api/peers/:hostId/audit - every call to and from that linked machine,
+// newest first: Machines → Activity.
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ hostId: string }> }
+) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  return NextResponse.json({ rows: peerAudit((await params).hostId) });
+}

package/app/api/peers/[hostId]/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { unlinkPeer } from "@/lib/peer/unlink";
+
+// DELETE /api/peers/:hostId - unlink a machine linked through Connect: its
+// pin goes here at once, and it's told to drop its side. Takes the same
+// trust as linking.
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ hostId: string }> }
+) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  try {
+    return NextResponse.json(await unlinkPeer((await params).hostId));
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    return NextResponse.json({ error }, { status: 404 });
+  }
+}

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

@@ -9,6 +9,9 @@ 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 unlink = await import("./[hostId]/route");
+const audit = await import("./[hostId]/audit/route");
+const hostDelete = await import("../hosts/[id]/route");
 
 const plain = mintDevice("phone").device.id;
 const approver = mintDevice("tablet", null, true).device.id;
@@ -24,7 +27,10 @@ const req = (
       ...(o.device && { "x-agentos-device": o.device }),
       "content-type": "application/json",
     },
-    body: o.body ?? JSON.stringify({ code: "123456" }),
+    body:
+      o.method === "GET"
+        ? undefined
+        : (o.body ?? JSON.stringify({ code: "123456" })),
   });
 const params = { params: Promise.resolve({ id: "nope" }) };
 
@@ -105,7 +111,64 @@ describe("linking routes", () => {
       "/api/peers/account",
       "/api/peers/link",
       "/api/peers/link/x/confirm",
+      "/api/peers/h1",
+      "/api/peers/h1/audit",
+      "/api/peer/unlink",
     ])
       expect(isPublicPath(p)).toBe(false);
   });
+
+  it("unlink and Activity take the same trust as linking", async () => {
+    const hostParams = { params: Promise.resolve({ hostId: "nope" }) };
+    for (const who of [
+      {},
+      { trust: "device", device: plain },
+      { trust: "peer" },
+      { trust: "open" },
+    ]) {
+      const del = req("/api/peers/nope", {
+        ...who,
+        method: "DELETE",
+        body: "",
+      });
+      expect((await unlink.DELETE(del, hostParams)).status).toBe(403);
+      const get = req("/api/peers/nope/audit", { ...who, method: "GET" });
+      expect((await audit.GET(get, hostParams)).status).toBe(403);
+    }
+    const asApprover = { trust: "device", device: approver };
+    expect(
+      (
+        await unlink.DELETE(
+          req("/x", { ...asApprover, method: "DELETE", body: "" }),
+          hostParams
+        )
+      ).status
+    ).toBe(404);
+    const rows = await audit.GET(
+      req("/x", { ...asApprover, method: "GET" }),
+      hostParams
+    );
+    expect(await rows.json()).toEqual({ rows: [] });
+  });
+
+  it("won't remove a Connect-linked machine without unlinking it", async () => {
+    const { createConnectHost } = await import("@/lib/hosts");
+    const { savePin, pinForHost } = await import("@/lib/peer/links");
+    const id = createConnectHost("Linked").id;
+    savePin({
+      hostId: id,
+      machineId: "f0f0f0f0",
+      hostname: "m-0000000000000000.runagentos.com",
+      signPub: "x",
+      boxPub: "y",
+    });
+    const res = await hostDelete.DELETE(
+      req("/x", { method: "DELETE", body: "" }),
+      {
+        params: Promise.resolve({ id }),
+      }
+    );
+    expect(res.status).toBe(409);
+    expect(pinForHost(id)).not.toBeNull();
+  });
 });

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

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+import { NextRequest } from "next/server";
+import { mintDevice } from "@/lib/security/devices";
+
+const seen: unknown[] = [];
+vi.mock("@/lib/peer/pairing", () => ({
+  pendingRequests: (_now: number, o: unknown) => {
+    seen.push(o);
+    return [];
+  },
+}));
+const { GET } = await import("./route");
+
+const get = (headers: Record<string, string>) =>
+  GET(new NextRequest("http://localhost/api/peers/pending", { headers }));
+
+describe("GET /api/peers/pending", () => {
+  it("hands out the second code only to a caller that could accept", async () => {
+    const plain = mintDevice("phone").device.id;
+    const approver = mintDevice("tablet", null, true).device.id;
+    for (const h of [
+      {} as Record<string, string>,
+      { "x-agentos-trust": "device", "x-agentos-device": plain },
+      { "x-agentos-trust": "peer" },
+    ])
+      expect((await get(h)).status).toBe(200);
+    await get({ "x-agentos-trust": "loopback" });
+    await get({ "x-agentos-trust": "device", "x-agentos-device": approver });
+    expect(seen).toEqual([
+      { withCodes: false },
+      { withCodes: false },
+      { withCodes: false },
+      { withCodes: true },
+      { withCodes: true },
+    ]);
+  });
+});

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

@@ -1,7 +1,14 @@
-import { NextResponse } from "next/server";
+import { NextRequest, NextResponse } from "next/server";
+import { approverOf } from "@/lib/security/approver";
 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() });
+// GET /api/peers/pending - machines asking to link here, waiting for the
+// code, and accepted ones whose second code is still to be typed there. That
+// code goes only to a caller that could have accepted.
+export function GET(request: NextRequest) {
+  return NextResponse.json({
+    requests: pendingRequests(Date.now(), {
+      withCodes: approverOf(request.headers) !== null,
+    }),
+  });
 }

package/app/api/session-groups/[id]/restore/route.ts

@@ -0,0 +1,11 @@
+import { restoreGroup } from "@/lib/session-groups";
+import { run } from "@/lib/session-groups/route";
+
+// POST /api/session-groups/:id/restore - undo a delete.
+export async function POST(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  return run(() => ({ sessionGroup: restoreGroup(id) }));
+}

package/app/api/session-groups/[id]/route.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { deleteGroup, updateGroup } from "@/lib/session-groups";
+import { groupRoute, run } from "@/lib/session-groups/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+const patch = z.object({
+  name: z.string().optional(),
+  collapsed: z.boolean().optional(),
+});
+
+// PATCH /api/session-groups/:id { name?, collapsed? } - rename or fold.
+export async function PATCH(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return groupRoute(request, patch, (b) => ({
+    sessionGroup: updateGroup(id, b),
+  }));
+}
+
+// DELETE /api/session-groups/:id - soft delete; its sessions fall back to the
+// status shelves and restore brings them back.
+export async function DELETE(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return run(() => ({ sessionGroup: deleteGroup(id) }));
+}

package/app/api/session-groups/order/route.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { reorderGroups } from "@/lib/session-groups";
+import { groupRoute } from "@/lib/session-groups/route";
+
+const order = z.object({
+  workspaceId: z.string().nullable(),
+  ids: z.array(z.string()),
+});
+
+// POST /api/session-groups/order { workspaceId, ids } - a workspace's order.
+export async function POST(request: Request) {
+  return groupRoute(request, order, (b) => ({
+    sessionGroups: reorderGroups(b.workspaceId, b.ids),
+  }));
+}

package/app/api/session-groups/route.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { createGroup, listGroups } from "@/lib/session-groups";
+import { groupRoute, run } from "@/lib/session-groups/route";
+
+const create = z.object({
+  name: z.string({ error: "A group needs a name" }),
+  workspaceId: z.string().nullable(),
+});
+
+// GET /api/session-groups - every live group.
+export async function GET() {
+  return run(() => ({ sessionGroups: listGroups() }));
+}
+
+// POST /api/session-groups { name, workspaceId } - create one at the bottom
+// of its workspace's order.
+export async function POST(request: Request) {
+  return groupRoute(request, create, (b) => ({
+    sessionGroup: createGroup(b.workspaceId, b.name),
+  }));
+}