@saadnvd1/agent-os 0.3.561 → 0.3.565

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

@@ -1,9 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
-import {
-  renameDevice,
-  revokeDevice,
-  setDeviceCanApprove,
-} from "@/lib/security/devices";
+import { renameDevice, setDeviceCanApprove } from "@/lib/security/devices";
+import { revokeDeviceAndKeys } from "@/lib/orchestrator/passkey-asks";
 import { requireLocalTrust } from "@/lib/security/route-guard";
 import { DEVICE_HEADER } from "@/lib/security/auth";
 import { demoMode } from "@/lib/security/demo";
@@ -43,7 +40,7 @@ export async function DELETE(request: NextRequest, { params }: Ctx) {
       { error: "Not available in the demo." },
       { status: 403 }
     );
-  if (!revokeDevice(id))
+  if (!revokeDeviceAndKeys(id, "Devices"))
     return NextResponse.json({ error: "Not found" }, { status: 404 });
   return NextResponse.json({ ok: true });
 }

package/app/api/devices/me/route.ts

@@ -1,12 +1,12 @@
 import { NextRequest, NextResponse } from "next/server";
-import { revokeDevice } from "@/lib/security/devices";
+import { revokeDeviceAndKeys } from "@/lib/orchestrator/passkey-asks";
 import { callingDevice, needsDevice } from "@/lib/security/device-me";
 
 // DELETE /api/devices/me - the device signs itself out ("Forget machine")
 export async function DELETE(request: NextRequest) {
   const id = callingDevice(request);
   if (!id) return needsDevice();
-  if (!revokeDevice(id))
+  if (!revokeDeviceAndKeys(id, "the device itself"))
     return NextResponse.json({ error: "Not found" }, { status: 404 });
   return NextResponse.json({ ok: true });
 }

package/app/api/presence/device-key/options/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import {
+  deviceRegistrationOptions,
+  PresenceError,
+} from "@/lib/security/presence";
+import { refusalResponse } from "@/lib/security/presence-http";
+import { passkeysBootstrapped } from "@/lib/security/passkeys";
+
+// A challenge for this paired device's new approval key to sign. The key is
+// the device's own, so only a paired device asks; with passkeys already set
+// up, it needs a code from one of them, like a browser passkey does.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  if (gate.approver.via !== "device" || !gate.approver.deviceId)
+    return NextResponse.json(
+      { error: "Only a paired device has its own key" },
+      { status: 403 }
+    );
+  try {
+    const { enrollCode } = (await request.json().catch(() => ({}))) as {
+      enrollCode?: string;
+    };
+    return NextResponse.json(
+      deviceRegistrationOptions(gate.approver.deviceId, enrollCode)
+    );
+  } catch (error) {
+    if (error instanceof PresenceError && error.code === "enroll")
+      return NextResponse.json({
+        needsCode: true,
+        canBootstrap: !passkeysBootstrapped(),
+      });
+    return refusalResponse(error);
+  }
+}

package/app/api/presence/device-key/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { verifyDeviceRegistration } from "@/lib/security/presence";
+import { placeOf, refusalResponse } from "@/lib/security/presence-http";
+import { raisePasskeyAsks } from "@/lib/orchestrator/passkey-asks";
+import { resolvePasskeyAsks } from "@/lib/orchestrator/asks";
+
+// Stores the paired device's own approval key, and puts it on Saad's asks
+// list to confirm. A key it replaces (a reinstall) is revoked and noted.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  if (gate.approver.via !== "device" || !gate.approver.deviceId)
+    return NextResponse.json(
+      { error: "Only a paired device has its own key" },
+      { status: 403 }
+    );
+  try {
+    const body = (await request.json().catch(() => ({}))) as {
+      publicKey?: string;
+      challenge?: string;
+      signature?: string;
+      name?: string;
+      hardware?: string;
+      enrollCode?: string;
+    };
+    if (!body.publicKey || !body.challenge || !body.signature)
+      return NextResponse.json({ error: "No key" }, { status: 400 });
+    const place = placeOf(gate.approver, request.headers);
+    const { key, replaced } = verifyDeviceRegistration(
+      gate.approver.deviceId,
+      {
+        publicKey: body.publicKey,
+        challenge: body.challenge,
+        signature: body.signature,
+        name: body.name || place,
+        hardware: body.hardware,
+      },
+      {
+        via: gate.approver.via,
+        from: place,
+        userAgent: request.headers.get("user-agent"),
+      },
+      body.enrollCode
+    );
+    for (const old of replaced) {
+      resolvePasskeyAsks(old.id, "replaced");
+      raisePasskeyAsks(old, place, "revoked");
+    }
+    raisePasskeyAsks(key, place);
+    return NextResponse.json({ passkey: { id: key.id, name: key.name } });
+  } catch (error) {
+    return refusalResponse(error);
+  }
+}

package/app/api/presence/enroll/route.ts

@@ -1,12 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
+import { mintEnrollCode } from "@/lib/security/presence";
 import {
-  mintEnrollCode,
-  relyingParty,
-  verifyPresence,
-} from "@/lib/security/presence";
-import { refusalResponse } from "@/lib/security/presence-http";
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 
 // A one-time code (10 minutes) for adding a passkey on another device,
 // minted only on an assertion from an existing passkey.
@@ -14,15 +13,8 @@ export async function POST(request: NextRequest) {
   const gate = requireApprover(request);
   if (!gate.ok) return gate.response;
   try {
-    const { assertion } = (await request.json().catch(() => ({}))) as {
-      assertion?: AuthenticationResponseJSON;
-    };
-    await verifyPresence(
-      relyingParty(request.headers),
-      assertion,
-      "enroll",
-      "enroll"
-    );
+    const body = (await request.json().catch(() => ({}))) as PresenceProof;
+    await requirePresence(request, gate.approver, body, "enroll", "enroll");
     return NextResponse.json({ code: mintEnrollCode() });
   } catch (error) {
     return refusalResponse(error);

package/app/api/presence/options/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { requireApprover } from "@/lib/security/approver";
 import {
   assertionOptions,
+  deviceAssertionOptions,
   relyingParty,
   type PresencePurpose,
 } from "@/lib/security/presence";
@@ -21,8 +22,27 @@ export async function POST(request: NextRequest) {
       askId?: number;
       binding?: string;
       passkeyId?: string;
+      method?: "device";
     };
     const binding = presenceBinding(body);
+    if (body.method === "device") {
+      if (gate.approver.via !== "device" || !gate.approver.deviceId)
+        return NextResponse.json(
+          { error: "Only a paired device has its own key" },
+          { status: 403 }
+        );
+      const device = deviceAssertionOptions(
+        gate.approver.deviceId,
+        body.purpose!,
+        binding
+      );
+      if (!device)
+        return NextResponse.json({
+          needsDeviceKey: true,
+          canBootstrap: !passkeysBootstrapped(),
+        });
+      return NextResponse.json({ device });
+    }
     const rp = relyingParty(request.headers);
     const options = await assertionOptions(rp, body.purpose!, binding);
     if (!options)

package/app/api/presence/passkeys/[id]/route.ts

@@ -1,9 +1,12 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
 import { getPasskey, revokePasskey } from "@/lib/security/passkeys";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { placeOf, refusalResponse } from "@/lib/security/presence-http";
+import {
+  placeOf,
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { raisePasskeyAsks } from "@/lib/orchestrator/passkey-asks";
 import { revokePresence } from "@/lib/orchestrator/presence-binding";
 import { resolvePasskeyAsks } from "@/lib/orchestrator/asks";
@@ -21,12 +24,11 @@ export async function DELETE(request: NextRequest, { params }: Ctx) {
     const key = getPasskey(id);
     if (!key || key.revoked_at)
       return NextResponse.json({ error: "Not found" }, { status: 404 });
-    const { assertion } = (await request.json().catch(() => ({}))) as {
-      assertion?: AuthenticationResponseJSON;
-    };
-    await verifyPresence(
-      relyingParty(request.headers),
-      assertion,
+    const body = (await request.json().catch(() => ({}))) as PresenceProof;
+    await requirePresence(
+      request,
+      gate.approver,
+      body,
       "revoke",
       revokePresence(id)
     );

package/app/api/workspaces/[id]/orchestrator/asks/[askId]/route.ts

@@ -1,8 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { placeOf, refusalResponse } from "@/lib/security/presence-http";
+import {
+  placeOf,
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { getPasskey } from "@/lib/security/passkeys";
 import { raisePasskeyAsks } from "@/lib/orchestrator/passkey-asks";
 import {
@@ -40,10 +43,11 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     : requireApprover(request);
   if (!gate.ok) return gate.response;
   const { id, askId } = await params;
-  const body = (await request.json().catch(() => null)) as {
-    binding?: string;
-    assertion?: AuthenticationResponseJSON;
-  } | null;
+  const body = (await request.json().catch(() => null)) as
+    | ({
+        binding?: string;
+      } & PresenceProof)
+    | null;
   const parsed = parseAnswer(body);
   // A demo keeps no visitor's words where the next visitor would read them.
   const answer =
@@ -73,9 +77,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
           { status: 400 }
         );
       if (!demo && PRESENCE_KINDS.includes(ask.kind))
-        await verifyPresence(
-          relyingParty(request.headers),
-          body.assertion,
+        await requirePresence(
+          request,
+          gate.approver,
+          body,
           "approve",
           askPresence(ask.id, body.binding)
         );

package/app/api/workspaces/[id]/orchestrator/pause/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { getWorkspace } from "@/lib/workspaces";
 import { setPaused } from "@/lib/orchestrator/pause";
 import { requireApprover } from "@/lib/security/approver";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { refusalResponse } from "@/lib/security/presence-http";
+import {
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { resumePresence } from "@/lib/orchestrator/presence-binding";
 
 type RouteParams = { params: Promise<{ id: string }> };
@@ -18,10 +20,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
   const { id } = await params;
   if (!getWorkspace(id))
     return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
-  const { paused, assertion } = (await request.json().catch(() => ({}))) as {
+  const body = (await request.json().catch(() => ({}))) as {
     paused?: unknown;
-    assertion?: AuthenticationResponseJSON;
-  };
+  } & PresenceProof;
+  const { paused } = body;
   if (typeof paused !== "boolean")
     return NextResponse.json(
       { error: "paused must be true or false" },
@@ -29,9 +31,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     );
   try {
     if (!paused)
-      await verifyPresence(
-        relyingParty(request.headers),
-        assertion,
+      await requirePresence(
+        request,
+        gate.approver,
+        body,
         "resume",
         resumePresence(id)
       );

package/app/api/workspaces/[id]/orchestrator/rules/[ruleId]/route.ts

@@ -1,11 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import type { PresenceProof } from "@/lib/security/presence-http";
 import { removeRule, updateRule } from "@/lib/orchestrator/rules";
 import { provenAsSaad } from "../presence";
 
 type RouteParams = { params: Promise<{ id: string; ruleId: string }> };
 
-type Body = { text?: unknown; assertion?: AuthenticationResponseJSON };
+type Body = { text?: unknown } & PresenceProof;
 
 // The rule, its body, and Saad's passkey on it; or the refusal.
 async function target(
@@ -21,7 +21,7 @@ async function target(
       response: NextResponse.json({ error: "Bad rule id" }, { status: 400 }),
     };
   const body = (await request.json().catch(() => ({}))) as Body;
-  const refused = await provenAsSaad(request, id, body.assertion);
+  const refused = await provenAsSaad(request, id, body);
   if (refused) return { response: refused };
   return { workspaceId: id, ruleId: n, body };
 }

package/app/api/workspaces/[id]/orchestrator/rules/presence.ts

@@ -1,8 +1,10 @@
 import type { NextRequest } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import { requireApprover } from "@/lib/security/approver";
-import { relyingParty, verifyPresence } from "@/lib/security/presence";
-import { refusalResponse } from "@/lib/security/presence-http";
+import {
+  refusalResponse,
+  requirePresence,
+  type PresenceProof,
+} from "@/lib/security/presence-http";
 import { rulesPresence } from "@/lib/orchestrator/presence-binding";
 
 // A rule written here is Saad's, shown to the orchestrator as his word and
@@ -11,14 +13,15 @@ import { rulesPresence } from "@/lib/orchestrator/presence-binding";
 export async function provenAsSaad(
   request: NextRequest,
   workspaceId: string,
-  assertion: AuthenticationResponseJSON | undefined
+  proof: PresenceProof | undefined
 ): Promise<Response | null> {
   const gate = requireApprover(request);
   if (!gate.ok) return gate.response;
   try {
-    await verifyPresence(
-      relyingParty(request.headers),
-      assertion,
+    await requirePresence(
+      request,
+      gate.approver,
+      proof,
       "rules",
       rulesPresence(workspaceId)
     );

package/app/api/workspaces/[id]/orchestrator/rules/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import type { PresenceProof } from "@/lib/security/presence-http";
 import { getWorkspace } from "@/lib/workspaces";
 import { addRule, listRules } from "@/lib/orchestrator/rules";
 import { provenAsSaad } from "./presence";
@@ -19,13 +19,13 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
   const { id } = await params;
   if (!getWorkspace(id))
     return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
-  const { text, assertion } = (await request.json().catch(() => ({}))) as {
+  const body = (await request.json().catch(() => ({}))) as {
     text?: unknown;
-    assertion?: AuthenticationResponseJSON;
-  };
+  } & PresenceProof;
+  const { text } = body;
   if (typeof text !== "string")
     return NextResponse.json({ error: "text is required" }, { status: 400 });
-  const refused = await provenAsSaad(request, id, assertion);
+  const refused = await provenAsSaad(request, id, body);
   if (refused) return refused;
   try {
     return NextResponse.json({ rule: addRule(id, text, "saad") });

package/components/Devices/PasskeysSection.tsx

@@ -25,7 +25,8 @@ const when = (s: string) =>
 const fail = (e: Error) => toast.error(e.message);
 
 // Passkeys prove it's you approving an ask or resuming an orchestrator.
-// Each belongs to the host name it was made on.
+// A browser passkey belongs to the host name it was made on; the app keeps its
+// own key in the phone's Secure Enclave.
 export function PasskeysSection({ open }: { open: boolean }) {
   const { data } = usePasskeysQuery(open);
   const add = useAddPasskey();
@@ -64,7 +65,8 @@ export function PasskeysSection({ open }: { open: boolean }) {
           <div className="min-w-0 flex-1">
             <p className="truncate text-sm font-medium">{k.name}</p>
             <p className="text-muted-foreground truncate text-xs">
-              {k.rp_id} · added {when(k.created_at)}
+              {k.type === "device" ? "Device key (Face ID)" : k.rp_id} · added{" "}
+              {when(k.created_at)}
               {k.registered_from ? ` from ${k.registered_from}` : ""} · used{" "}
               {lastSeen(k.last_used_at)}
             </p>

package/lib/db/migrations-legacy-checksums.json

@@ -0,0 +1,90 @@
+{
+  "1": "f6d5756a104c16ec",
+  "2": "3699f5f3cd215455",
+  "3": "dc4efbc29c2976ef",
+  "4": "d3db3af92f123a13",
+  "5": "d5937aba3b590fed",
+  "6": "0c4668cf9a58cecd",
+  "7": "7f535265ae1ad37f",
+  "8": "5c24f600f5f73145",
+  "9": "99496923fc7ff333",
+  "10": "22162670e68726c0",
+  "11": "21cd323c1654f9a9",
+  "12": "d66b982154dc3ee2",
+  "13": "ba1c8c4e2486a74d",
+  "14": "2f9575eed78d3284",
+  "15": "4c2293b3766c0d84",
+  "16": "8e798e52aed97875",
+  "17": "a743501f00312926",
+  "18": "cb84130b195bfa63",
+  "19": "b0ba5d304ca64aba",
+  "20": "ef3e125d28bfa506",
+  "21": "542664a9bef5f215",
+  "22": "195a6a7a87776269",
+  "23": "e4b50e60ac0821fa",
+  "24": "afb9644f31cc7602",
+  "25": "52bb47e1eed4e8d4",
+  "26": "9b5247315a01bdbe",
+  "27": "9c34c46d26c93cc4",
+  "28": "83d816f925aa0aba",
+  "29": "5ce556a828f7510b",
+  "30": "3d1bc245c30dcf49",
+  "31": "250433b280fd8df1",
+  "32": "95ec3c8125969681",
+  "33": "711226e6a027f6cd",
+  "34": "d8c917aa6f3e00b6",
+  "35": "7db35660583c2a50",
+  "36": "7ff8363149a3952c",
+  "37": "b7e72a18d3398da6",
+  "38": "cea02e00d1262601",
+  "39": "61c77d0f357d71d6",
+  "40": "6cedcf70268ddd25",
+  "41": "3d9af0548ae91946",
+  "42": "410ef4562a046ce6",
+  "43": "b0fca4e05ff6499e",
+  "44": "06b7f4dc636c9675",
+  "45": "73948f256c522959",
+  "46": "202f8fd102ef2581",
+  "47": "510435d6afa487cd",
+  "48": "10727869e8c8dea1",
+  "49": "0384a86395f6650a",
+  "50": "cc05c3663ca18b2b",
+  "51": "b381268fe096fb02",
+  "52": "281ad10453d9177a",
+  "53": "a7a53074ed49a566",
+  "54": "2358b106da3e7b68",
+  "55": "478ece72deb01953",
+  "56": "d04bafcaa2eda941",
+  "57": "0f9bc09a7a31f64d",
+  "58": "ccbf7eebccadfa3f",
+  "59": "1859ac87155d546b",
+  "60": "035e204a4b6c457e",
+  "61": "85d9bb65b051409a",
+  "62": "723d9c60994dec97",
+  "63": "77dd17570476ee17",
+  "64": "de5f368a88af93de",
+  "65": "081cc6eaf666581b",
+  "66": "08eedfefd3d3f3f9",
+  "67": "e37ead69c14e2d01",
+  "68": "9ab2551e258f1588",
+  "69": "55edb197ed55afe1",
+  "70": "d8a4faf39318bd1d",
+  "71": "45b9b9ff57d2083d",
+  "72": "51b77e2e1c5c8ae6",
+  "73": "2878b9f0762ab53d",
+  "74": "c94cd8f644a8518f",
+  "75": "e082428a046f9e6b",
+  "76": "17f3160630d658dc",
+  "77": "cd54bfd73fbcd168",
+  "78": "8ad44a982b1eb58d",
+  "79": "0b09d57d6ea8ce0a",
+  "80": "941d85f2ef8bd012",
+  "81": "ecd85de2bdf45ff1",
+  "82": "07f11cdac5f8444a",
+  "83": "eabf72b6a8616eac",
+  "84": "1ed4fb30b7435f28",
+  "85": "a85ac25c0e34f2fb",
+  "86": "50b5725a67286dee",
+  "87": "6024c62bcdbb186e",
+  "88": "bb58ec622ae398e5"
+}