edge-book 0.6.0 → 0.7.1

package/dist/edge-book.js

@@ -485,6 +485,7 @@ var EdgeBookStore = class {
     const contacts = await this.contacts();
     const contact = contacts[peerAgentId];
     if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    if (contact.relationship_state === "blocked") throw new EdgeBookError("blocked", `Peer ${peerAgentId} is blocked`);
     if (contact.relationship_state !== "friend") {
       throw new EdgeBookError("not_friend", `Cannot send friend-gated message to relationship_state=${contact.relationship_state}`);
     }
@@ -965,9 +966,13 @@ var EdgeBookStore = class {
     const object = await this.getObject(objectId);
     if (object && object.from_agent === subjectAgentId) return true;
     const grants = await this.grants();
-    return Object.values(grants).some(
+    const candidates = Object.values(grants).filter(
       (grant) => grant.object_id === objectId && grant.subject_agent_id === subjectAgentId && grant.scopes.includes("object.read") && grant.status === "active" && (!grant.expires_at || Date.parse(grant.expires_at) > at)
     );
+    for (const grant of candidates) {
+      if (await this.verifyGrantSignature(grant)) return true;
+    }
+    return false;
   }
   // Audited read. Returns the object iff canReadObject; else fails closed.
   async readObject(objectId, subjectAgentId) {
@@ -1557,6 +1562,7 @@ var EdgeBookStore = class {
     const contacts = await this.contacts();
     const contact = contacts[peerAgentId];
     if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    if (contact.relationship_state === "blocked") throw new EdgeBookError("blocked", `Peer ${peerAgentId} is blocked`);
     if (contact.relationship_state !== "friend") throw new EdgeBookError("not_friend", `Feed denied for relationship_state=${contact.relationship_state}`);
     const grants = await this.grants();
     const grant = Object.values(grants).find(
@@ -3735,6 +3741,138 @@ async function revokeOneSession(options) {
   }
 }
 
+// src/resolver.ts
+function nextAction(result, target) {
+  switch (result.status) {
+    case "resolved":
+      return `friend request ${target} --deliver`;
+    case "approval_required":
+    case "candidates": {
+      const first = result.candidates?.[0];
+      return first ? `candidates list   # then: friend request ${first.candidate_id}` : "candidates list";
+    }
+    default:
+      return "(no match \u2014 check the target)";
+  }
+}
+var localContactProvider = {
+  name: "local",
+  priority: 100,
+  async resolve(store, target) {
+    const contacts = await store.contacts();
+    const match = Object.values(contacts).find(
+      (c) => c.peer_agent_id === target || c.aliases.includes(target) || c.display_name === target
+    );
+    if (!match) return null;
+    return {
+      kind: "card",
+      agent_id: match.peer_agent_id,
+      provenance: {
+        source: "local",
+        confidence: "high",
+        display_name: match.display_name,
+        reason: `known contact (relationship_state=${match.relationship_state})`
+      }
+    };
+  }
+};
+function cardProvider(name, source, match) {
+  return {
+    name,
+    priority: 90,
+    async resolve(_store, target) {
+      if (!match(target)) return null;
+      const card = await loadCard(target);
+      return {
+        kind: "card",
+        card,
+        agent_id: card.agent_id,
+        provenance: { source, confidence: "high", display_name: card.handle, reason: `${source} card verified` }
+      };
+    }
+  };
+}
+var inviteProvider = cardProvider("invite", "invite", (t) => t.startsWith("edgebook:invite:"));
+var cardUrlProvider = cardProvider("card_url", "card_url", (t) => /^https?:\/\//.test(t));
+var cardFileProvider = cardProvider(
+  "card_file",
+  "card_file",
+  (t) => t.startsWith("file://") || t.startsWith("/") || t.startsWith("./") || t.endsWith(".json")
+);
+var CANDIDATES_FILE = "candidates.json";
+function candidateKey(c) {
+  return `${c.source}:${c.card_url ?? c.agent_id ?? ""}`;
+}
+async function readCandidates(store) {
+  return readJson(store.file(CANDIDATES_FILE), {});
+}
+async function listCandidates(store) {
+  return Object.values(await readCandidates(store));
+}
+async function getCandidate(store, id) {
+  return (await readCandidates(store))[id];
+}
+async function writeCandidate(store, input) {
+  const map = await readCandidates(store);
+  const existing = Object.values(map).find((c) => candidateKey(c) === candidateKey(input));
+  if (existing) return existing;
+  const candidate = {
+    candidate_id: randomId("cand"),
+    approved: false,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...input
+  };
+  map[candidate.candidate_id] = candidate;
+  await writeJson(store.file(CANDIDATES_FILE), map);
+  await store.audit("candidate.write", candidate.agent_id ?? "", { candidate_id: candidate.candidate_id, source: candidate.source });
+  return candidate;
+}
+function defaultProviders(registryLookup = async () => null) {
+  return [localContactProvider, inviteProvider, cardUrlProvider, cardFileProvider, makeRegistryProvider(registryLookup)];
+}
+async function resolveTarget(store, target, opts) {
+  const ordered = [...opts.providers].sort((a, b) => b.priority - a.priority);
+  for (const provider of ordered) {
+    const r = await provider.resolve(store, target);
+    if (!r) continue;
+    if (r.kind === "card") {
+      const result2 = { status: "resolved", card: r.card, agent_id: r.agent_id, provenance: r.provenance, next_action: "" };
+      result2.next_action = nextAction(result2, target);
+      return result2;
+    }
+    const candidate = await writeCandidate(store, r.candidate);
+    const result = { status: "approval_required", candidates: [candidate], provenance: r.provenance, next_action: "" };
+    result.next_action = nextAction(result, target);
+    return result;
+  }
+  return { status: "not_found", next_action: "(no match \u2014 check the target)" };
+}
+async function markCandidateApproved(store, candidateId, agentId) {
+  const map = await readJson(store.file(CANDIDATES_FILE), {});
+  if (!map[candidateId]) return;
+  map[candidateId].approved = true;
+  map[candidateId].agent_id = agentId;
+  await writeJson(store.file(CANDIDATES_FILE), map);
+}
+function makeRegistryProvider(lookup) {
+  return {
+    name: "registry",
+    priority: 50,
+    async resolve(_store, target) {
+      if (!target.startsWith("registry:")) return null;
+      const cardTarget = await lookup(target);
+      if (!cardTarget) return null;
+      const card = await loadCard(cardTarget);
+      return {
+        kind: "card",
+        card,
+        agent_id: card.agent_id,
+        provenance: { source: "registry", confidence: "medium", display_name: card.handle, reason: "registry handle lookup" }
+      };
+    }
+  };
+}
+
 // src/cli.ts
 function usage() {
   return `Edge Book
@@ -3921,13 +4059,33 @@ share_owner_label: ${id.share_owner_label ? "true" : "false"} (${shared})`,
       return { text: inviteUrl, json: { invite_url: inviteUrl, agent_id: card.agent_id } };
     }
   }
+  if (command === "resolve") {
+    const target = requireArg(args.shift(), "target");
+    const result = await resolveTarget(store, target, { providers: defaultProviders() });
+    const label = result.agent_id ?? result.candidates?.[0]?.candidate_id ?? "";
+    return { text: `${result.status}  ${label}
+next: ${result.next_action}`, json: result };
+  }
+  if (command === "candidates") {
+    const action = args.shift() || "list";
+    if (action === "list") {
+      const candidates = await listCandidates(store);
+      const text = candidates.length ? candidates.map((c) => `${c.candidate_id}  ${c.source}  ${c.display_name}  ${c.approved ? "[approved]" : ""}`).join("\n") : "No candidates.";
+      return { text, json: { candidates } };
+    }
+  }
   if (command === "friend") {
     const action = args.shift();
     if (action === "request") {
       const deliver = takeBoolFlag(args, "--deliver");
-      const target = requireArg(args.shift(), "card-path-or-url");
-      const card = await loadCard(target);
+      const target = requireArg(args.shift(), "card-path-url-or-candidate");
+      const candidate = await getCandidate(store, target);
+      if (candidate && !candidate.card_url) {
+        throw new EdgeBookError("candidate_not_resolvable", "Candidate has no card_url to verify; cannot request");
+      }
+      const card = candidate ? await loadCard(candidate.card_url) : await loadCard(target);
       const envelope = await store.createFriendRequest(card);
+      if (candidate) await markCandidateApproved(store, candidate.candidate_id, card.agent_id);
       if (deliver) {
         const direct = card.transports.find((entry) => entry.mode === "direct")?.endpoint;
         if (direct) return { text: await deliverToEndpoint(envelope, direct), json: envelope };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-book",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Run your own Edge Book agent and connect it to the hosted reader.",
   "license": "MIT",
   "type": "module",
@@ -12,7 +12,9 @@
     "test": "node --test test/*.test.ts",
     "harness": "node bin/edge-book.js harness two-agent",
     "harness:e2e": "node scripts/convergence-e2e.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "smoke": "node scripts/smoke-2agent.ts",
+    "smoke:host": "node scripts/smoke-2agent.ts --host"
   },
   "openclaw": {
     "extensions": [