npm - edge-book - Versions diffs - 0.1.0 → 0.1.1 - Mend

edge-book 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/edge-book.js ADDED Viewed

@@ -0,0 +1,2965 @@
+#!/usr/bin/env node
+// src/cli.ts
+import fs4 from "fs/promises";
+import { realpathSync } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+// src/dialout.ts
+import crypto2 from "crypto";
+import fs3 from "fs/promises";
+import path3 from "path";
+// src/edge-book.ts
+import crypto from "crypto";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var EdgeBookError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "EdgeBookError";
+    this.code = code;
+  }
+};
+var IDENTITY_FILE = "identity.json";
+var CONTACTS_FILE = "contacts.json";
+var GRANTS_FILE = "grants.json";
+var SEEN_MESSAGES_FILE = "seen-messages.json";
+var CONFIG_FILE = "config.json";
+var RELATIONSHIP_EVENTS_FILE = "relationship-events.jsonl";
+var MESSAGES_FILE = "messages.jsonl";
+var AUDIT_FILE = "audit.jsonl";
+var INBOX_FILE = "inbox.jsonl";
+var CARD_FILE = "openclaw-agent.json";
+var SESSIONS_FILE = "web-sessions.json";
+var POSTS_FILE = "posts.json";
+var FEED_FILE = "feed-items.json";
+var APPROVALS_FILE = "approvals.json";
+var CONTACT_MUTES_FILE = "contact-mutes.json";
+function resolveHome(home) {
+  if (home?.trim()) return path.resolve(home.trim());
+  if (process.env.EDGE_BOOK_HOME?.trim()) return path.resolve(process.env.EDGE_BOOK_HOME.trim());
+  return path.join(os.homedir(), ".openclaw", "edge-book");
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function randomId(prefix) {
+  return `${prefix}_${crypto.randomBytes(16).toString("base64url")}`;
+}
+function stableIdFromPublicKey(publicKeyPem) {
+  const digest = crypto.createHash("sha256").update(publicKeyPem).digest("base64url").slice(0, 32);
+  return `did:openclaw:${digest}`;
+}
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(obj[key])}`).join(",")}}`;
+}
+function withoutSignature(value) {
+  const clone = { ...value };
+  delete clone.signature;
+  return clone;
+}
+function signPayload(payload, privateKeyPem) {
+  return crypto.sign(null, Buffer.from(canonicalize(payload)), privateKeyPem).toString("base64url");
+}
+function verifyPayload(payload, signature, publicKeyPem) {
+  return crypto.verify(null, Buffer.from(canonicalize(payload)), publicKeyPem, Buffer.from(signature, "base64url"));
+}
+async function ensureHome(home) {
+  await fs.mkdir(home, { recursive: true });
+  await chmodBestEffort(home, 448);
+}
+async function readJson(file, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+async function chmodBestEffort(file, mode) {
+  if (process.platform === "win32") return;
+  try {
+    await fs.chmod(file, mode);
+  } catch {
+  }
+}
+async function writeJson(file, value, mode) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  if (mode !== void 0) await chmodBestEffort(file, mode);
+}
+async function appendJsonl(file, value) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.appendFile(file, `${JSON.stringify(value)}
+`, "utf8");
+}
+async function readJsonl(file) {
+  try {
+    const text = await fs.readFile(file, "utf8");
+    return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function relationshipId(a, b) {
+  return `rel_${crypto.createHash("sha256").update([a, b].sort().join("|")).digest("base64url").slice(0, 24)}`;
+}
+var EdgeBookStore = class {
+  home;
+  constructor(options = {}) {
+    this.home = resolveHome(options.home);
+  }
+  file(name) {
+    return path.join(this.home, name);
+  }
+  async init(input = {}) {
+    await ensureHome(this.home);
+    const existing = await readJson(this.file(IDENTITY_FILE), null);
+    if (existing) {
+      await this.updateConfig({ direct_url: input.directUrl, relay_url: input.relayUrl });
+      return existing;
+    }
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+    const public_key_pem = publicKey.export({ type: "spki", format: "pem" }).toString();
+    const private_key_pem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+    const identity = {
+      agent_id: stableIdFromPublicKey(public_key_pem),
+      handle: input.handle || "agent.openclaw.local",
+      display_name: input.displayName || "OpenClaw Agent",
+      owner_label: input.ownerLabel || "",
+      public_key_pem,
+      private_key_pem,
+      created_at: now(),
+      updated_at: now()
+    };
+    await writeJson(this.file(IDENTITY_FILE), identity, 384);
+    await writeJson(this.file(CONTACTS_FILE), {});
+    await writeJson(this.file(GRANTS_FILE), {});
+    await writeJson(this.file(SEEN_MESSAGES_FILE), []);
+    await this.updateConfig({ direct_url: input.directUrl, relay_url: input.relayUrl });
+    await this.audit("identity.init", identity.agent_id, { handle: identity.handle });
+    await this.writeCard(input.cardUrl);
+    return identity;
+  }
+  async identity() {
+    const identity = await readJson(this.file(IDENTITY_FILE), null);
+    if (!identity) throw new EdgeBookError("not_initialized", `Edge Book is not initialized at ${this.home}`);
+    return identity;
+  }
+  async config() {
+    return readJson(this.file(CONFIG_FILE), {});
+  }
+  async updateConfig(input) {
+    const current = await this.config();
+    const next = { ...current };
+    if (input.direct_url !== void 0) next.direct_url = input.direct_url;
+    if (input.relay_url !== void 0) next.relay_url = input.relay_url;
+    await writeJson(this.file(CONFIG_FILE), next);
+    return next;
+  }
+  async buildCard(cardUrl) {
+    const identity = await this.identity();
+    const config = await this.config();
+    const transports = [{ mode: "local", endpoint: this.home }];
+    if (config.direct_url) transports.push({ mode: "direct", endpoint: config.direct_url });
+    if (config.relay_url) transports.push({ mode: "relay", endpoint: config.relay_url });
+    const unsigned = {
+      schema: "openclaw-agent-card/0.1",
+      agent_id: identity.agent_id,
+      handle: identity.handle,
+      display_name: identity.display_name,
+      card_url: cardUrl || `file://${this.file(CARD_FILE)}`,
+      card_version: 1,
+      public_keys: [{ id: `${identity.agent_id}#main`, type: "ed25519", public_key_pem: identity.public_key_pem }],
+      capabilities: ["friend_request", "friend_gated_message", "feed_read_friends"],
+      transports,
+      refresh_after: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString(),
+      expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+    };
+    const card_hash = crypto.createHash("sha256").update(canonicalize(unsigned)).digest("base64url");
+    const withHash = { ...unsigned, card_hash };
+    return { ...withHash, signature: signPayload(withHash, identity.private_key_pem) };
+  }
+  async writeCard(cardUrl) {
+    const card = await this.buildCard(cardUrl);
+    await writeJson(this.file(CARD_FILE), card);
+    return card;
+  }
+  async doctor() {
+    const identity = await readJson(this.file(IDENTITY_FILE), null);
+    const config = await this.config();
+    const checks = {
+      home: this.home,
+      initialized: Boolean(identity),
+      config,
+      files: {}
+    };
+    const requiredFiles = [IDENTITY_FILE, CONTACTS_FILE, GRANTS_FILE, SEEN_MESSAGES_FILE, CARD_FILE];
+    const files = {};
+    for (const name of requiredFiles) {
+      try {
+        const stat = await fs.stat(this.file(name));
+        files[name] = {
+          exists: true,
+          mode: `0${(stat.mode & 511).toString(8)}`
+        };
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          files[name] = { exists: false };
+        } else {
+          throw error;
+        }
+      }
+    }
+    checks.files = files;
+    let cardValid = false;
+    try {
+      const card = await loadCard(this.file(CARD_FILE));
+      cardValid = Boolean(identity && card.agent_id === identity.agent_id);
+    } catch {
+      cardValid = false;
+    }
+    const identityMode = files[IDENTITY_FILE].mode;
+    const privateKeyModeOk = process.platform === "win32" || identityMode === "0600";
+    checks.card_valid = cardValid;
+    checks.private_key_mode_ok = privateKeyModeOk;
+    checks.pass = Boolean(identity) && cardValid && privateKeyModeOk;
+    return checks;
+  }
+  async contacts() {
+    return readJson(this.file(CONTACTS_FILE), {});
+  }
+  async saveContacts(contacts) {
+    await writeJson(this.file(CONTACTS_FILE), contacts);
+  }
+  async grants() {
+    return readJson(this.file(GRANTS_FILE), {});
+  }
+  async saveGrants(grants) {
+    await writeJson(this.file(GRANTS_FILE), grants);
+  }
+  async upsertContactFromCard(card, state) {
+    validateCard(card);
+    const contacts = await this.contacts();
+    const existing = contacts[card.agent_id];
+    if (existing?.relationship_state === "blocked" && state !== "blocked") {
+      throw new EdgeBookError("blocked_peer", "Blocked peer cannot refresh privileged contact state");
+    }
+    const stamp = now();
+    const next = {
+      peer_agent_id: card.agent_id,
+      aliases: Array.from(new Set([...existing?.aliases ?? [], card.handle].filter(Boolean))),
+      display_name: card.display_name,
+      card_url: card.card_url,
+      known_endpoints: card.transports,
+      public_keys: card.public_keys,
+      relationship_state: state ?? existing?.relationship_state ?? "none",
+      capability_grants: existing?.capability_grants ?? [],
+      last_card_hash: card.card_hash,
+      last_card_version: card.card_version,
+      last_card_refresh_at: stamp,
+      last_successful_delivery_at: existing?.last_successful_delivery_at ?? "",
+      audit_refs: existing?.audit_refs ?? [],
+      created_at: existing?.created_at ?? stamp,
+      updated_at: stamp
+    };
+    contacts[card.agent_id] = next;
+    await this.saveContacts(contacts);
+    await this.audit("contact.upsert", card.agent_id, { state: next.relationship_state });
+    return next;
+  }
+  async setRelationship(peerAgentId, nextState, type, reason = "") {
+    const identity = await this.identity();
+    const contacts = await this.contacts();
+    const contact = contacts[peerAgentId];
+    if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    const previous = contact.relationship_state;
+    contact.relationship_state = nextState;
+    contact.updated_at = now();
+    contacts[peerAgentId] = contact;
+    await this.saveContacts(contacts);
+    const unsigned = {
+      event_id: randomId("evt"),
+      type,
+      from_agent_id: identity.agent_id,
+      to_agent_id: peerAgentId,
+      relationship_id: relationshipId(identity.agent_id, peerAgentId),
+      previous_state: previous,
+      next_state: nextState,
+      human_approval_ref: "local-test-harness-or-cli",
+      reason,
+      created_at: now()
+    };
+    const event = { ...unsigned, signature: signPayload(unsigned, identity.private_key_pem) };
+    await appendJsonl(this.file(RELATIONSHIP_EVENTS_FILE), event);
+    await this.audit(`relationship.${type}`, peerAgentId, { previous, next: nextState, reason });
+    return event;
+  }
+  async createFriendRequest(targetCard, note = "") {
+    const identity = await this.identity();
+    validateCard(targetCard);
+    const existing = (await this.contacts())[targetCard.agent_id];
+    if (existing?.relationship_state === "blocked") throw new EdgeBookError("blocked_peer", "Cannot request a blocked peer");
+    await this.upsertContactFromCard(targetCard, "request_sent");
+    await this.setRelationship(targetCard.agent_id, "request_sent", "FriendRequest", note);
+    const card = await this.writeCard();
+    return this.signEnvelope({
+      type: "friend_request",
+      to_agent_id: targetCard.agent_id,
+      relationship_id: relationshipId(identity.agent_id, targetCard.agent_id),
+      capability_id: "",
+      ref: "",
+      transport: "local",
+      body: { card, note }
+    });
+  }
+  async receiveFriendRequest(envelope) {
+    await this.verifyEnvelope(envelope);
+    if (envelope.type !== "friend_request") throw new EdgeBookError("wrong_message_type", "Expected friend_request envelope");
+    const body = envelope.body;
+    validateCard(body.card);
+    if (body.card.agent_id !== envelope.from_agent_id) throw new EdgeBookError("agent_id_mismatch", "Friend request card does not match sender");
+    const contact = await this.upsertContactFromCard(body.card, "request_received");
+    await this.setRelationship(envelope.from_agent_id, "request_received", "FriendRequest", body.note);
+    await appendJsonl(this.file(INBOX_FILE), envelope);
+    return contact;
+  }
+  async acceptFriend(peerAgentId, reason = "accepted") {
+    const identity = await this.identity();
+    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", "Cannot accept a blocked peer");
+    await this.setRelationship(peerAgentId, "friend", "Accept", reason);
+    const grant = await this.issueGrant(peerAgentId, ["message.friend", "feed.read.friends"]);
+    const card = await this.writeCard();
+    return this.signEnvelope({
+      type: "friend_response",
+      to_agent_id: peerAgentId,
+      relationship_id: relationshipId(identity.agent_id, peerAgentId),
+      capability_id: grant.grant_id,
+      ref: "",
+      transport: "local",
+      body: { accepted: true, card, grant, reason }
+    });
+  }
+  async applyFriendResponse(envelope) {
+    await this.verifyEnvelope(envelope);
+    if (envelope.type !== "friend_response") throw new EdgeBookError("wrong_message_type", "Expected friend_response envelope");
+    const body = envelope.body;
+    validateCard(body.card);
+    if (body.card.agent_id !== envelope.from_agent_id) throw new EdgeBookError("agent_id_mismatch", "Friend response card does not match sender");
+    await this.upsertContactFromCard(body.card, body.accepted ? "friend" : "rejected");
+    await this.setRelationship(envelope.from_agent_id, body.accepted ? "friend" : "rejected", body.accepted ? "Accept" : "Reject", body.reason);
+    if (body.grant) await this.storeGrant(body.grant);
+  }
+  async revoke(peerAgentId) {
+    await this.setRelationship(peerAgentId, "revoked", "Revoke", "revoked");
+    const grants = await this.grants();
+    for (const grant of Object.values(grants)) {
+      if (grant.subject_agent_id === peerAgentId || grant.issuer_agent_id === peerAgentId) {
+        grant.status = "revoked";
+        grant.revoked_at = now();
+      }
+    }
+    await this.saveGrants(grants);
+  }
+  async block(peerAgentId) {
+    await this.setRelationship(peerAgentId, "blocked", "Block", "blocked");
+  }
+  async issueGrant(subjectAgentId, scopes, expiresAt = "") {
+    const identity = await this.identity();
+    const unsigned = {
+      grant_id: randomId("grant"),
+      issuer_agent_id: identity.agent_id,
+      subject_agent_id: subjectAgentId,
+      relationship_id: relationshipId(identity.agent_id, subjectAgentId),
+      scopes,
+      status: "active",
+      issued_at: now(),
+      expires_at: expiresAt,
+      revoked_at: "",
+      audit_refs: []
+    };
+    const grant = { ...unsigned, signature: signPayload(unsigned, identity.private_key_pem) };
+    await this.storeGrant(grant);
+    await this.audit("grant.issue", subjectAgentId, { grant_id: grant.grant_id, scopes });
+    return grant;
+  }
+  async storeGrant(grant) {
+    const grants = await this.grants();
+    grants[grant.grant_id] = grant;
+    await this.saveGrants(grants);
+    const contacts = await this.contacts();
+    const peer = grant.issuer_agent_id === (await this.identity()).agent_id ? grant.subject_agent_id : grant.issuer_agent_id;
+    const contact = contacts[peer];
+    if (contact && !contact.capability_grants.includes(grant.grant_id)) {
+      contact.capability_grants.push(grant.grant_id);
+      contact.updated_at = now();
+      contacts[peer] = contact;
+      await this.saveContacts(contacts);
+    }
+  }
+  async sendPrivilegedMessage(peerAgentId, body, scope = "message.friend") {
+    const identity = await this.identity();
+    const contacts = await this.contacts();
+    const contact = contacts[peerAgentId];
+    if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    if (contact.relationship_state !== "friend") {
+      throw new EdgeBookError("not_friend", `Cannot send friend-gated message to relationship_state=${contact.relationship_state}`);
+    }
+    const grant = await this.findUsableGrant(peerAgentId, scope);
+    if (!grant) throw new EdgeBookError("missing_grant", `No active grant for ${scope}`);
+    const envelope = await this.signEnvelope({
+      type: "privileged_message",
+      to_agent_id: peerAgentId,
+      relationship_id: relationshipId(identity.agent_id, peerAgentId),
+      capability_id: grant.grant_id,
+      ref: "",
+      transport: "local",
+      body
+    });
+    await appendJsonl(this.file(MESSAGES_FILE), envelope);
+    await this.audit("message.send", peerAgentId, { message_id: envelope.message_id, scope });
+    return envelope;
+  }
+  async receivePrivilegedMessage(envelope) {
+    await this.verifyEnvelope(envelope);
+    if (envelope.type !== "privileged_message") throw new EdgeBookError("wrong_message_type", "Expected privileged_message envelope");
+    const contacts = await this.contacts();
+    const contact = contacts[envelope.from_agent_id];
+    if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${envelope.from_agent_id}`);
+    if (contact.relationship_state !== "friend") {
+      throw new EdgeBookError("not_friend", `Cannot receive friend-gated message from relationship_state=${contact.relationship_state}`);
+    }
+    const grants = await this.grants();
+    const grant = grants[envelope.capability_id];
+    if (!grant || grant.status !== "active" || grant.subject_agent_id !== envelope.from_agent_id || !grant.scopes.includes("message.friend")) {
+      throw new EdgeBookError("missing_grant", "Message does not carry an active grant issued to sender");
+    }
+    await appendJsonl(this.file(INBOX_FILE), envelope);
+    await this.audit("message.receive", envelope.from_agent_id, { message_id: envelope.message_id });
+  }
+  async findUsableGrant(peerAgentId, scope) {
+    const identity = await this.identity();
+    const grants = await this.grants();
+    return Object.values(grants).find(
+      (grant) => grant.issuer_agent_id === peerAgentId && grant.subject_agent_id === identity.agent_id && grant.status === "active" && grant.scopes.includes(scope) && (!grant.expires_at || Date.parse(grant.expires_at) > Date.now())
+    );
+  }
+  async signEnvelope(input) {
+    const identity = await this.identity();
+    const unsigned = {
+      message_id: randomId("msg"),
+      from_agent_id: identity.agent_id,
+      created_at: now(),
+      expires_at: new Date(Date.now() + 10 * 60 * 1e3).toISOString(),
+      ...input
+    };
+    return { ...unsigned, signature: signPayload(unsigned, identity.private_key_pem) };
+  }
+  async verifyEnvelope(envelope) {
+    const identity = await this.identity();
+    if (envelope.to_agent_id !== identity.agent_id) throw new EdgeBookError("wrong_recipient", "Envelope recipient does not match local identity");
+    if (Date.parse(envelope.expires_at) <= Date.now()) throw new EdgeBookError("expired_message", "Message is expired");
+    const seen = await readJson(this.file(SEEN_MESSAGES_FILE), []);
+    if (seen.includes(envelope.message_id)) throw new EdgeBookError("replay", `Replay detected for ${envelope.message_id}`);
+    const contacts = await this.contacts();
+    let publicKey = contacts[envelope.from_agent_id]?.public_keys?.[0]?.public_key_pem;
+    if (!publicKey && envelope.type === "friend_request") {
+      const card = envelope.body.card;
+      publicKey = card?.public_keys?.[0]?.public_key_pem;
+    }
+    if (!publicKey && envelope.type === "friend_response") {
+      const card = envelope.body.card;
+      publicKey = card?.public_keys?.[0]?.public_key_pem;
+    }
+    if (!publicKey) throw new EdgeBookError("unknown_key", `Unknown sender key for ${envelope.from_agent_id}`);
+    if (!verifyPayload(withoutSignature(envelope), envelope.signature, publicKey)) {
+      throw new EdgeBookError("invalid_signature", "Message signature is invalid");
+    }
+    seen.push(envelope.message_id);
+    await writeJson(this.file(SEEN_MESSAGES_FILE), seen);
+  }
+  async inbox() {
+    return readJsonl(this.file(INBOX_FILE));
+  }
+  async receiveEnvelope(envelope) {
+    if (envelope.type === "friend_request") return this.receiveFriendRequest(envelope);
+    if (envelope.type === "friend_response") return this.applyFriendResponse(envelope);
+    if (envelope.type === "privileged_message") return this.receivePrivilegedMessage(envelope);
+    throw new EdgeBookError("unsupported_envelope", `Unsupported envelope type: ${envelope.type}`);
+  }
+  async audit(action, peerAgentId, details) {
+    const audit_id = randomId("audit");
+    await appendJsonl(this.file(AUDIT_FILE), {
+      audit_id,
+      created_at: now(),
+      action,
+      peer_agent_id: peerAgentId,
+      details
+    });
+    return audit_id;
+  }
+  async auditEvents() {
+    return readJsonl(this.file(AUDIT_FILE));
+  }
+  async sessions() {
+    return readJson(this.file(SESSIONS_FILE), {});
+  }
+  async saveSessions(sessions) {
+    await writeJson(this.file(SESSIONS_FILE), sessions);
+  }
+  async createSession(input = {}) {
+    const identity = await this.identity();
+    const stamp = now();
+    const session = {
+      session_id: randomId("session"),
+      owner_agent_id: identity.agent_id,
+      created_at: stamp,
+      expires_at: new Date(Date.now() + (input.ttlMs ?? 8 * 60 * 60 * 1e3)).toISOString(),
+      last_seen_at: stamp,
+      auth_method: input.authMethod ?? "local-owner-token",
+      csrf_token_hash: randomId("csrf"),
+      revoked_at: ""
+    };
+    const sessions = await this.sessions();
+    sessions[session.session_id] = session;
+    await this.saveSessions(sessions);
+    await this.audit("session.create", identity.agent_id, { session_id: session.session_id, auth_method: session.auth_method });
+    return session;
+  }
+  async requireSession(sessionId) {
+    const sessions = await this.sessions();
+    const session = sessions[sessionId];
+    if (!session) throw new EdgeBookError("unauthorized", "Missing or unknown web session");
+    if (session.revoked_at) throw new EdgeBookError("unauthorized", "Web session was revoked");
+    if (Date.parse(session.expires_at) <= Date.now()) throw new EdgeBookError("unauthorized", "Web session expired");
+    session.last_seen_at = now();
+    sessions[sessionId] = session;
+    await this.saveSessions(sessions);
+    return session;
+  }
+  async revokeSession(sessionId) {
+    const sessions = await this.sessions();
+    const session = sessions[sessionId];
+    if (!session) return;
+    session.revoked_at = now();
+    sessions[sessionId] = session;
+    await this.saveSessions(sessions);
+    await this.audit("session.revoke", session.owner_agent_id, { session_id: sessionId });
+  }
+  async posts() {
+    return readJson(this.file(POSTS_FILE), {});
+  }
+  async savePosts(posts) {
+    await writeJson(this.file(POSTS_FILE), posts);
+  }
+  async feedItems() {
+    return readJson(this.file(FEED_FILE), {});
+  }
+  async saveFeedItems(items) {
+    await writeJson(this.file(FEED_FILE), items);
+  }
+  async approvals() {
+    return readJson(this.file(APPROVALS_FILE), {});
+  }
+  async saveApprovals(approvals) {
+    await writeJson(this.file(APPROVALS_FILE), approvals);
+  }
+  async contactMutes() {
+    return readJson(this.file(CONTACT_MUTES_FILE), {});
+  }
+  async saveContactMutes(mutes) {
+    await writeJson(this.file(CONTACT_MUTES_FILE), mutes);
+  }
+  async createApproval(input) {
+    const identity = await this.identity();
+    const approval = {
+      approval_id: randomId("approval"),
+      type: input.type,
+      requested_by_agent_id: input.requestedByAgentId || identity.agent_id,
+      object_type: input.objectType,
+      object_id: input.objectId,
+      summary: input.summary,
+      risk_level: input.riskLevel || "medium",
+      status: "pending",
+      created_at: now(),
+      resolved_at: "",
+      resolved_by: "",
+      audit_refs: []
+    };
+    const approvals = await this.approvals();
+    approvals[approval.approval_id] = approval;
+    await this.saveApprovals(approvals);
+    approval.audit_refs.push(await this.audit("approval.create", approval.requested_by_agent_id, { approval_id: approval.approval_id, type: approval.type }));
+    approvals[approval.approval_id] = approval;
+    await this.saveApprovals(approvals);
+    return approval;
+  }
+  async resolveApproval(approvalId, approved) {
+    const approvals = await this.approvals();
+    const approval = approvals[approvalId];
+    if (!approval) throw new EdgeBookError("unknown_approval", `Unknown approval: ${approvalId}`);
+    if (approval.status !== "pending") throw new EdgeBookError("approval_resolved", `Approval already ${approval.status}`);
+    approval.status = approved ? "approved" : "rejected";
+    approval.resolved_at = now();
+    approval.resolved_by = "local-owner";
+    approvals[approvalId] = approval;
+    approval.audit_refs.push(await this.audit("approval.resolve", approval.requested_by_agent_id, { approval_id: approvalId, approved }));
+    approvals[approvalId] = approval;
+    await this.saveApprovals(approvals);
+    return approval;
+  }
+  async createPost(input) {
+    const identity = await this.identity();
+    const stamp = now();
+    const sourceBasis = input.sourceBasis || "human-authored";
+    const requestedStatus = input.status || (sourceBasis === "agent-authored" ? "pending_approval" : "draft");
+    const post = {
+      post_id: randomId("post"),
+      author_agent_id: identity.agent_id,
+      human_owner_id: identity.owner_label || identity.agent_id,
+      kind: input.kind || "note",
+      title: input.title,
+      body: input.body,
+      tags: input.tags || [],
+      visibility: input.visibility || "private",
+      source_basis: sourceBasis,
+      status: requestedStatus,
+      created_at: stamp,
+      updated_at: stamp,
+      published_at: requestedStatus === "published" ? stamp : "",
+      expires_at: input.expiresAt || "",
+      approval_ref: "",
+      permissions_used: [],
+      audit_refs: [],
+      reply_or_help_channel: input.replyOrHelpChannel || ""
+    };
+    const posts = await this.posts();
+    posts[post.post_id] = post;
+    await this.savePosts(posts);
+    if (post.status === "pending_approval") {
+      const approval = await this.createApproval({
+        type: "publish_post",
+        objectType: "post",
+        objectId: post.post_id,
+        summary: `Publish ${post.visibility} post: ${post.title}`,
+        riskLevel: post.visibility === "public_if_enabled" ? "high" : "medium"
+      });
+      post.approval_ref = approval.approval_id;
+      posts[post.post_id] = post;
+      await this.savePosts(posts);
+    }
+    post.audit_refs.push(await this.audit("post.create", identity.agent_id, { post_id: post.post_id, status: post.status, visibility: post.visibility }));
+    posts[post.post_id] = post;
+    await this.savePosts(posts);
+    if (post.status === "published") await this.ensureLocalFeedItem(post);
+    return post;
+  }
+  async approvePost(postId) {
+    const posts = await this.posts();
+    const post = posts[postId];
+    if (!post) throw new EdgeBookError("unknown_post", `Unknown post: ${postId}`);
+    if (post.status === "removed") throw new EdgeBookError("removed_post", "Cannot approve a removed post");
+    if (post.status === "expired") throw new EdgeBookError("expired_post", "Cannot approve an expired post");
+    if (post.approval_ref) await this.resolveApproval(post.approval_ref, true);
+    post.status = "published";
+    post.source_basis = post.source_basis === "agent-authored" ? "human-approved" : post.source_basis;
+    post.updated_at = now();
+    post.published_at = post.published_at || post.updated_at;
+    posts[postId] = post;
+    await this.savePosts(posts);
+    await this.ensureLocalFeedItem(post);
+    post.audit_refs.push(await this.audit("post.approve", post.author_agent_id, { post_id: postId, visibility: post.visibility }));
+    posts[postId] = post;
+    await this.savePosts(posts);
+    return post;
+  }
+  async editPost(postId, input) {
+    const posts = await this.posts();
+    const post = posts[postId];
+    if (!post) throw new EdgeBookError("unknown_post", `Unknown post: ${postId}`);
+    if (post.status === "removed") throw new EdgeBookError("removed_post", "Cannot edit a removed post");
+    if (input.title !== void 0) post.title = input.title;
+    if (input.body !== void 0) post.body = input.body;
+    if (input.tags !== void 0) post.tags = input.tags;
+    if (input.visibility !== void 0) post.visibility = input.visibility;
+    post.status = post.status === "published" ? "edited" : post.status;
+    post.updated_at = now();
+    post.audit_refs.push(await this.audit("post.edit", post.author_agent_id, { post_id: postId }));
+    posts[postId] = post;
+    await this.savePosts(posts);
+    return post;
+  }
+  async removePost(postId, reason = "removed by local owner") {
+    const posts = await this.posts();
+    const post = posts[postId];
+    if (!post) throw new EdgeBookError("unknown_post", `Unknown post: ${postId}`);
+    post.status = "removed";
+    post.updated_at = now();
+    post.audit_refs.push(await this.audit("post.remove", post.author_agent_id, { post_id: postId, reason }));
+    posts[postId] = post;
+    await this.savePosts(posts);
+    return post;
+  }
+  async expirePost(postId, reason = "expired") {
+    const posts = await this.posts();
+    const post = posts[postId];
+    if (!post) throw new EdgeBookError("unknown_post", `Unknown post: ${postId}`);
+    post.status = "expired";
+    post.updated_at = now();
+    post.audit_refs.push(await this.audit("post.expire", post.author_agent_id, { post_id: postId, reason }));
+    posts[postId] = post;
+    await this.savePosts(posts);
+    return post;
+  }
+  async ensureLocalFeedItem(post) {
+    const identity = await this.identity();
+    const items = await this.feedItems();
+    const existing = Object.values(items).find((item2) => item2.post_id === post.post_id && item2.origin_agent_id === identity.agent_id);
+    if (existing) return existing;
+    const item = {
+      feed_item_id: randomId("feed"),
+      post_id: post.post_id,
+      origin_agent_id: identity.agent_id,
+      origin_home: "local",
+      relationship_id: "",
+      visibility_checked_at: now(),
+      delivery_route: "local",
+      read_state: "unread",
+      hidden: false,
+      muted_reason: "",
+      received_at: now(),
+      audit_refs: []
+    };
+    item.audit_refs.push(await this.audit("feed.local_add", identity.agent_id, { feed_item_id: item.feed_item_id, post_id: post.post_id }));
+    items[item.feed_item_id] = item;
+    await this.saveFeedItems(items);
+    return item;
+  }
+  async visiblePostsForPeer(peerAgentId) {
+    const identity = await this.identity();
+    const contacts = await this.contacts();
+    const contact = contacts[peerAgentId];
+    if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    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(
+      (candidate) => candidate.issuer_agent_id === identity.agent_id && candidate.subject_agent_id === peerAgentId && candidate.status === "active" && candidate.scopes.includes("feed.read.friends") && (!candidate.expires_at || Date.parse(candidate.expires_at) > Date.now())
+    );
+    if (!grant) throw new EdgeBookError("missing_grant", "No active feed.read.friends grant for peer");
+    const posts = Object.values(await this.posts());
+    return posts.filter((post) => post.visibility === "friends" && ["published", "edited"].includes(post.status)).filter((post) => !post.expires_at || Date.parse(post.expires_at) > Date.now()).sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+  }
+  async importFeedPosts(peerAgentId, posts, route = "local") {
+    const contacts = await this.contacts();
+    const contact = contacts[peerAgentId];
+    if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    if (contact.relationship_state !== "friend") throw new EdgeBookError("not_friend", `Cannot import feed from relationship_state=${contact.relationship_state}`);
+    const items = await this.feedItems();
+    const imported = [];
+    for (const post of posts) {
+      const existing = Object.values(items).find((item2) => item2.post_id === post.post_id && item2.origin_agent_id === peerAgentId);
+      if (existing) {
+        imported.push(existing);
+        continue;
+      }
+      const item = {
+        feed_item_id: randomId("feed"),
+        post_id: post.post_id,
+        origin_agent_id: peerAgentId,
+        origin_home: route === "relay" ? "relay" : "direct",
+        relationship_id: relationshipId((await this.identity()).agent_id, peerAgentId),
+        visibility_checked_at: now(),
+        delivery_route: route,
+        read_state: "unread",
+        hidden: false,
+        muted_reason: "",
+        received_at: now(),
+        audit_refs: []
+      };
+      item.audit_refs.push(await this.audit("feed.import_item", peerAgentId, { feed_item_id: item.feed_item_id, post_id: post.post_id, route }));
+      items[item.feed_item_id] = item;
+      imported.push(item);
+    }
+    await this.saveFeedItems(items);
+    await this.audit("feed.import", peerAgentId, { count: imported.length, route });
+    return imported;
+  }
+  async markFeedItemRead(feedItemId) {
+    const items = await this.feedItems();
+    const item = items[feedItemId];
+    if (!item) throw new EdgeBookError("unknown_feed_item", `Unknown feed item: ${feedItemId}`);
+    item.read_state = "read";
+    item.audit_refs.push(await this.audit("feed.mark_read", item.origin_agent_id, { feed_item_id: feedItemId }));
+    items[feedItemId] = item;
+    await this.saveFeedItems(items);
+    return item;
+  }
+  async hideFeedItem(feedItemId, reason = "") {
+    const items = await this.feedItems();
+    const item = items[feedItemId];
+    if (!item) throw new EdgeBookError("unknown_feed_item", `Unknown feed item: ${feedItemId}`);
+    item.hidden = true;
+    item.muted_reason = reason;
+    item.audit_refs.push(await this.audit("feed.hide", item.origin_agent_id, { feed_item_id: feedItemId, reason }));
+    items[feedItemId] = item;
+    await this.saveFeedItems(items);
+    return item;
+  }
+  async muteContact(peerAgentId, reason = "") {
+    const contacts = await this.contacts();
+    if (!contacts[peerAgentId]) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
+    const mutes = await this.contactMutes();
+    const mute = {
+      peer_agent_id: peerAgentId,
+      muted_at: now(),
+      muted_reason: reason,
+      audit_refs: []
+    };
+    mute.audit_refs.push(await this.audit("contact.mute", peerAgentId, { reason }));
+    mutes[peerAgentId] = mute;
+    await this.saveContactMutes(mutes);
+    return mute;
+  }
+  async unmuteContact(peerAgentId) {
+    const mutes = await this.contactMutes();
+    if (!mutes[peerAgentId]) return;
+    delete mutes[peerAgentId];
+    await this.saveContactMutes(mutes);
+    await this.audit("contact.unmute", peerAgentId, {});
+  }
+  async reviewLocalDataImport(data) {
+    const objectCount = (key) => {
+      const value = data[key];
+      if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
+      return Object.keys(value).length;
+    };
+    const audit = Array.isArray(data.audit) ? data.audit.length : 0;
+    return {
+      review_only: true,
+      activates_remote_endpoints: false,
+      counts: {
+        contacts: objectCount("contacts"),
+        grants: objectCount("grants"),
+        sessions: objectCount("sessions"),
+        posts: objectCount("posts"),
+        feed_items: objectCount("feed_items"),
+        approvals: objectCount("approvals"),
+        contact_mutes: objectCount("contact_mutes"),
+        audit
+      }
+    };
+  }
+  async exportLocalData() {
+    return {
+      identity: await this.identity(),
+      contacts: await this.contacts(),
+      grants: await this.grants(),
+      sessions: await this.sessions(),
+      posts: await this.posts(),
+      feed_items: await this.feedItems(),
+      approvals: await this.approvals(),
+      contact_mutes: await this.contactMutes(),
+      audit: await this.auditEvents()
+    };
+  }
+};
+function validateCard(card) {
+  if (card.schema !== "openclaw-agent-card/0.1") throw new EdgeBookError("invalid_card", "Unsupported Agent Card schema");
+  if (!card.agent_id || !card.public_keys?.[0]?.public_key_pem) throw new EdgeBookError("invalid_card", "Agent Card is missing identity key");
+  const expectedId = stableIdFromPublicKey(card.public_keys[0].public_key_pem);
+  if (card.agent_id !== expectedId) throw new EdgeBookError("invalid_card", "Agent Card agent_id does not match public key");
+  if (!verifyPayload(withoutSignature(card), card.signature, card.public_keys[0].public_key_pem)) {
+    throw new EdgeBookError("invalid_card", "Agent Card signature is invalid");
+  }
+}
+async function loadCard(cardPathOrUrl) {
+  if (/^https?:\/\//.test(cardPathOrUrl)) {
+    const response = await fetch(cardPathOrUrl);
+    if (!response.ok) throw new EdgeBookError("card_fetch_failed", `Failed to fetch card: ${response.status}`);
+    const card2 = await response.json();
+    validateCard(card2);
+    return card2;
+  }
+  const filePath = cardPathOrUrl.startsWith("file://") ? new URL(cardPathOrUrl) : path.resolve(cardPathOrUrl);
+  const card = JSON.parse(await fs.readFile(filePath, "utf8"));
+  validateCard(card);
+  return card;
+}
+async function runTwoAgentHarness(baseDir) {
+  const root = baseDir || await fs.mkdtemp(path.join(os.tmpdir(), "edge-book-"));
+  const alice = new EdgeBookStore({ home: path.join(root, "alice") });
+  const bob = new EdgeBookStore({ home: path.join(root, "bob") });
+  await alice.init({ handle: "alice.openclaw.local", displayName: "Alice Agent", ownerLabel: "Alice" });
+  await bob.init({ handle: "bob.openclaw.local", displayName: "Bob Agent", ownerLabel: "Bob" });
+  const aliceCard = await alice.writeCard();
+  const bobCard = await bob.writeCard();
+  const request = await alice.createFriendRequest(bobCard, "test harness request");
+  let deniedBeforeAccept = false;
+  try {
+    await alice.sendPrivilegedMessage(bobCard.agent_id, { text: "too soon" });
+  } catch (error) {
+    deniedBeforeAccept = error.code === "not_friend";
+  }
+  await bob.receiveFriendRequest(request);
+  const accept = await bob.acceptFriend(aliceCard.agent_id);
+  await alice.applyFriendResponse(accept);
+  const message = await alice.sendPrivilegedMessage(bobCard.agent_id, { text: "hello Bob" });
+  await bob.receivePrivilegedMessage(message);
+  let replayDenied = false;
+  try {
+    await bob.receivePrivilegedMessage(message);
+  } catch (error) {
+    replayDenied = error.code === "replay";
+  }
+  await bob.revoke(aliceCard.agent_id);
+  let revokedDenied = false;
+  try {
+    await bob.receivePrivilegedMessage(await alice.sendPrivilegedMessage(bobCard.agent_id, { text: "after revoke" }));
+  } catch (error) {
+    revokedDenied = ["not_friend", "replay", "missing_grant"].includes(error.code);
+  }
+  await bob.setRelationship(aliceCard.agent_id, "friend", "Accept", "reset for block test");
+  await bob.block(aliceCard.agent_id);
+  let blockedDenied = false;
+  try {
+    await bob.receivePrivilegedMessage(await alice.sendPrivilegedMessage(bobCard.agent_id, { text: "after block" }));
+  } catch (error) {
+    blockedDenied = error.code === "not_friend";
+  }
+  const rotatedBobCard = await bob.writeCard();
+  await alice.upsertContactFromCard(rotatedBobCard);
+  const aliceContacts = await alice.contacts();
+  const bobAudit = await bob.auditEvents();
+  const assertions = {
+    deniedBeforeAccept,
+    replayDenied,
+    revokedDenied,
+    blockedDenied,
+    aliceHasBobContact: Boolean(aliceContacts[bobCard.agent_id]),
+    bobAuditWritten: bobAudit.length > 0
+  };
+  const passed = Object.values(assertions).every(Boolean);
+  if (!passed) throw new EdgeBookError("harness_failed", `Harness failed: ${JSON.stringify(assertions)}`);
+  return { passed, root, assertions };
+}
+// src/http.ts
+import fs2 from "fs/promises";
+import http from "http";
+import path2 from "path";
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  const text = Buffer.concat(chunks).toString("utf8");
+  return JSON.parse(text);
+}
+function headerValue(req, name) {
+  const value = req.headers[name.toLowerCase()];
+  if (Array.isArray(value)) return value[0] || "";
+  return value || "";
+}
+function sendJson(res, status, value) {
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  res.end(`${JSON.stringify(value, null, 2)}
+`);
+}
+function sendHtml(res, value) {
+  res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+  res.end(value);
+}
+function sendError(res, error) {
+  const status = error instanceof EdgeBookError && error.code === "unauthorized" ? 401 : error instanceof EdgeBookError && error.code === "csrf_required" ? 403 : error instanceof EdgeBookError ? 400 : 500;
+  sendJson(res, status, {
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+    code: error instanceof EdgeBookError ? error.code : "internal_error"
+  });
+}
+function compactPem(pem) {
+  return pem.replace(/-----BEGIN [^-]+-----/g, "").replace(/-----END [^-]+-----/g, "").replace(/\s+/g, "");
+}
+function publicIdentity(identity) {
+  return {
+    did: identity.agent_id,
+    handle: identity.handle,
+    name: identity.display_name,
+    display_name: identity.display_name,
+    public_key: compactPem(identity.public_key_pem)
+  };
+}
+function publicApiExport(data) {
+  const identity = data.identity;
+  return {
+    ...data,
+    ...identity ? { identity: publicIdentity(identity) } : {},
+    sessions: void 0
+  };
+}
+async function publicApprovals(store) {
+  try {
+    const approvals = await store.approvals();
+    if (!approvals || typeof approvals !== "object" || Array.isArray(approvals)) return {};
+    return approvals;
+  } catch {
+    return {};
+  }
+}
+function createDefaultApiAdapters(store) {
+  return {
+    store,
+    async requireSession(req) {
+      const sessionId = headerValue(req, "x-openclaw-session");
+      await store.requireSession(sessionId);
+      return sessionId;
+    },
+    async requireCsrf(req, sessionId) {
+      const sessions = await store.sessions();
+      const session = sessions[sessionId];
+      if (!session) throw new EdgeBookError("unauthorized", "Missing or unknown web session");
+      if (headerValue(req, "x-openclaw-csrf") !== session.csrf_token_hash) {
+        throw new EdgeBookError("csrf_required", "Missing or invalid CSRF token");
+      }
+    }
+  };
+}
+function methodMutates(method) {
+  return method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
+}
+async function requireApiAuth(req, adapters) {
+  const sessionId = await adapters.requireSession(req);
+  if (methodMutates(req.method)) await adapters.requireCsrf(req, sessionId);
+  return sessionId;
+}
+async function handleOwnerApi(req, res, url, adapters) {
+  const store = adapters.store;
+  if (req.method === "POST" && url.pathname === "/auth/login") {
+    const body = await readJsonBody(req);
+    const session = await store.createSession({ authMethod: body.auth_method, ttlMs: body.ttl_ms });
+    sendJson(res, 200, { ok: true, session_id: session.session_id, csrf_token: session.csrf_token_hash, expires_at: session.expires_at });
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/auth/logout") {
+    const sessionId = await adapters.requireSession(req);
+    await adapters.requireCsrf(req, sessionId);
+    await store.revokeSession(sessionId);
+    sendJson(res, 200, { ok: true });
+    return true;
+  }
+  if (!url.pathname.startsWith("/api/")) return false;
+  await requireApiAuth(req, adapters);
+  if (req.method === "GET" && url.pathname === "/api/me") {
+    sendJson(res, 200, { identity: publicIdentity(await store.identity()) });
+    return true;
+  }
+  if (req.method === "GET" && url.pathname === "/api/contacts") {
+    sendJson(res, 200, { contacts: await store.contacts(), mutes: await store.contactMutes() });
+    return true;
+  }
+  const contactMuteMatch = /^\/api\/contacts\/([^/]+)\/mute$/.exec(url.pathname);
+  if (req.method === "POST" && contactMuteMatch) {
+    const body = await readJsonBody(req);
+    sendJson(res, 200, { mute: await store.muteContact(decodeURIComponent(contactMuteMatch[1]), body.reason || "") });
+    return true;
+  }
+  const messagesMatch = /^\/api\/messages\/([^/]+)$/.exec(url.pathname);
+  if (req.method === "GET" && messagesMatch) {
+    const peerId = decodeURIComponent(messagesMatch[1]);
+    const inbox = (await store.inbox()).filter((message) => message.from_agent_id === peerId || message.to_agent_id === peerId);
+    sendJson(res, 200, { messages: inbox });
+    return true;
+  }
+  const messageSendMatch = /^\/api\/messages\/([^/]+)\/send$/.exec(url.pathname);
+  if (req.method === "POST" && messageSendMatch) {
+    const body = await readJsonBody(req);
+    const envelope = await store.sendPrivilegedMessage(decodeURIComponent(messageSendMatch[1]), { text: body.text || "" });
+    sendJson(res, 200, { envelope });
+    return true;
+  }
+  if (req.method === "GET" && url.pathname === "/api/posts") {
+    sendJson(res, 200, { posts: await store.posts() });
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/api/posts") {
+    const body = await readJsonBody(req);
+    const post = await store.createPost({
+      title: body.title,
+      body: body.body,
+      kind: body.kind,
+      tags: body.tags,
+      visibility: body.visibility,
+      sourceBasis: body.source_basis,
+      status: body.status
+    });
+    sendJson(res, 200, { post });
+    return true;
+  }
+  const postActionMatch = /^\/api\/posts\/([^/]+)\/(approve|edit|remove)$/.exec(url.pathname);
+  if (req.method === "POST" && postActionMatch) {
+    const postId = decodeURIComponent(postActionMatch[1]);
+    const action = postActionMatch[2];
+    if (action === "approve") sendJson(res, 200, { post: await store.approvePost(postId) });
+    if (action === "edit") {
+      const body = await readJsonBody(req);
+      sendJson(res, 200, { post: await store.editPost(postId, body) });
+    }
+    if (action === "remove") {
+      const body = await readJsonBody(req);
+      sendJson(res, 200, { post: await store.removePost(postId, body.reason || "removed by local owner") });
+    }
+    return true;
+  }
+  if (req.method === "GET" && url.pathname === "/api/feed") {
+    sendJson(res, 200, { feed_items: await store.feedItems() });
+    return true;
+  }
+  const feedActionMatch = /^\/api\/feed\/([^/]+)\/(read|hide)$/.exec(url.pathname);
+  if (req.method === "POST" && feedActionMatch) {
+    const itemId = decodeURIComponent(feedActionMatch[1]);
+    if (feedActionMatch[2] === "read") sendJson(res, 200, { feed_item: await store.markFeedItemRead(itemId) });
+    if (feedActionMatch[2] === "hide") {
+      const body = await readJsonBody(req);
+      sendJson(res, 200, { feed_item: await store.hideFeedItem(itemId, body.reason || "") });
+    }
+    return true;
+  }
+  if (req.method === "GET" && url.pathname === "/api/approvals") {
+    sendJson(res, 200, { approvals: await publicApprovals(store) });
+    return true;
+  }
+  const approvalResolveMatch = /^\/api\/approvals\/([^/]+)\/resolve$/.exec(url.pathname);
+  if (req.method === "POST" && approvalResolveMatch) {
+    const body = await readJsonBody(req);
+    sendJson(res, 200, { approval: await store.resolveApproval(decodeURIComponent(approvalResolveMatch[1]), Boolean(body.approved)) });
+    return true;
+  }
+  const auditMatch = /^\/api\/audit\/([^/]+)\/([^/]+)$/.exec(url.pathname);
+  if (req.method === "GET" && auditMatch) {
+    const objectId = decodeURIComponent(auditMatch[2]);
+    const audit = (await store.auditEvents()).filter((event) => JSON.stringify(event).includes(objectId));
+    sendJson(res, 200, { audit });
+    return true;
+  }
+  if (req.method === "GET" && url.pathname === "/api/audit") {
+    sendJson(res, 200, { audit: await store.auditEvents() });
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/api/export") {
+    sendJson(res, 200, { export: publicApiExport(await store.exportLocalData()) });
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/api/import") {
+    const body = await readJsonBody(req);
+    sendJson(res, 200, { review: await store.reviewLocalDataImport(body) });
+    return true;
+  }
+  sendJson(res, 404, { ok: false, error: "not_found" });
+  return true;
+}
+function dashboardHtml() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Edge Book</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --bg: #eef2f4;
+      --panel: #ffffff;
+      --line: #c7d1d6;
+      --text: #1d2a31;
+      --muted: #5f7079;
+      --accent: #116466;
+      --accent-dark: #0a4244;
+      --accent-soft: #dcefee;
+      --active: #1f7a4f;
+      --active-soft: #e5f5ec;
+      --active-line: #a8d5bd;
+      --note: #345995;
+      --note-soft: #e8eef9;
+      --ink: #12343b;
+      --warn: #9a3412;
+      --warn-soft: #fff7ed;
+      --warn-line: #fed7aa;
+      --danger: #b42318;
+      --danger-soft: #fff7f6;
+      --danger-line: #f0b5ae;
+      --neutral-soft: #f4f7f8;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: var(--bg);
+      color: var(--text);
+      font-family: "Lucida Grande", Tahoma, Verdana, Arial, sans-serif;
+      font-size: 12px;
+      letter-spacing: 0;
+    }
+    .app {
+      min-height: 100vh;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr);
+      grid-template-rows: auto 1fr;
+    }
+    header {
+      position: sticky;
+      top: 0;
+      z-index: 10;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      padding: 0 16px;
+      border-bottom: 1px solid #07383a;
+      background: linear-gradient(#14797b, #0d5557);
+      color: #ffffff;
+      box-shadow: 0 1px 2px rgb(0 0 0 / 18%);
+    }
+    .top-inner {
+      width: min(1220px, 100%);
+      margin: 0 auto;
+      display: grid;
+      grid-template-columns: 220px minmax(240px, 1fr) auto;
+      gap: 12px;
+      align-items: center;
+    }
+    h1 {
+      margin: 0;
+      font-size: 20px;
+      font-weight: 700;
+      letter-spacing: 0;
+      text-shadow: 0 -1px 0 rgb(0 0 0 / 25%);
+    }
+    .product-mark {
+      display: grid;
+      gap: 2px;
+      min-width: 0;
+    }
+    .product-subtitle {
+      color: #d8f1ef;
+      font-size: 11px;
+      overflow-wrap: anywhere;
+    }
+    h2 {
+      margin: 0;
+      font-size: 13px;
+      font-weight: 700;
+    }
+    h3 { font-size: 14px; }
+    .search {
+      width: 100%;
+      height: 25px;
+      border: 1px solid #07383a;
+      border-radius: 2px;
+      padding: 4px 8px;
+      font: inherit;
+      background: #f7fbfb;
+      color: var(--text);
+      box-shadow: inset 0 1px 1px rgb(0 0 0 / 12%);
+    }
+    .status {
+      display: flex;
+      align-items: center;
+      flex-wrap: wrap;
+      gap: 12px;
+      color: #eef8f8;
+      min-width: 0;
+    }
+    .badge {
+      border: 1px solid var(--line);
+      border-radius: 3px;
+      padding: 4px 7px;
+      background: #f9fafb;
+      color: var(--muted);
+      white-space: nowrap;
+    }
+    .badge.owned {
+      border-color: var(--active-line);
+      background: var(--active-soft);
+      color: var(--active);
+    }
+    .badge.attention {
+      border-color: var(--warn-line);
+      background: var(--warn-soft);
+      color: var(--warn);
+    }
+    .badge.risk {
+      border-color: var(--danger-line);
+      background: var(--danger-soft);
+      color: var(--danger);
+    }
+    .badge.neutral {
+      border-color: var(--line);
+      background: var(--neutral-soft);
+      color: var(--muted);
+    }
+    header .badge {
+      border-color: #0a4244;
+      background: rgb(255 255 255 / 14%);
+      color: #ffffff;
+    }
+    .page {
+      width: min(1220px, 100%);
+      margin: 0 auto;
+      display: grid;
+      grid-template-columns: 170px minmax(520px, 1fr) 250px;
+      gap: 12px;
+      padding: 14px 12px 28px;
+    }
+    nav, aside {
+      align-self: start;
+      position: sticky;
+      top: 56px;
+    }
+    nav {
+      padding: 0;
+    }
+    nav button {
+      width: 100%;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 2px;
+      border: 1px solid transparent;
+      border-radius: 2px;
+      background: transparent;
+      color: var(--text);
+      padding: 5px 6px;
+      text-align: left;
+      cursor: pointer;
+      font-weight: 700;
+    }
+    nav button span { color: var(--muted); font-weight: 400; }
+    nav button:hover { background: #e2ebef; }
+    nav button.active {
+      border-color: #b7c5cc;
+      background: #dbe7eb;
+      color: var(--accent-dark);
+    }
+    main {
+      min-width: 0;
+    }
+    aside {
+      background: #f8fafb;
+      border: 1px solid var(--line);
+      padding: 10px;
+      min-width: 0;
+      color: #40535c;
+    }
+    .toolbar {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
+      border: 1px solid var(--line);
+      border-bottom: 0;
+      background: #f7f9fa;
+      padding: 7px 9px;
+    }
+    .summary-grid {
+      display: grid;
+      grid-template-columns: repeat(5, minmax(0, 1fr));
+      gap: 8px;
+      margin-bottom: 10px;
+    }
+    .summary-card {
+      min-height: 62px;
+      border: 1px solid var(--line);
+      border-radius: 4px;
+      background: var(--panel);
+      padding: 8px;
+      display: grid;
+      align-content: space-between;
+      gap: 5px;
+    }
+    .summary-label {
+      color: var(--muted);
+      font-size: 11px;
+      line-height: 1.25;
+      overflow-wrap: anywhere;
+    }
+    .summary-value {
+      font-size: 19px;
+      font-weight: 700;
+      color: var(--ink);
+    }
+    .summary-card.warn { background: var(--warn-soft) !important; }
+    .summary-card.risk { background: var(--danger-soft) !important; }
+    .summary-card.active { background: var(--active-soft); border-color: #b5ddc9; }
+    .list {
+      display: grid;
+      gap: 10px;
+    }
+    .item {
+      border: 1px solid var(--line);
+      border-radius: 3px;
+      background: var(--panel);
+      padding: 10px 12px;
+      box-shadow: 0 1px 1px rgb(0 0 0 / 4%);
+      display: grid;
+      gap: 8px;
+    }
+    .item[tabindex="0"] { cursor: pointer; }
+    .item[tabindex="0"]:hover {
+      border-color: #8fbec0;
+      box-shadow: 0 1px 3px rgb(0 0 0 / 10%);
+    }
+    .item-head {
+      display: flex;
+      justify-content: space-between;
+      gap: 10px;
+      align-items: start;
+    }
+    .item h3 {
+      margin: 0 0 6px;
+      color: var(--accent-dark);
+      font-size: 14px;
+      line-height: 1.25;
+    }
+    .item-title-row {
+      display: flex;
+      align-items: start;
+      gap: 8px;
+      min-width: 0;
+    }
+    .item-body {
+      color: var(--text);
+      line-height: 1.45;
+    }
+    .item-time {
+      color: var(--muted);
+      font-size: 11px;
+      white-space: nowrap;
+    }
+    .inspect-tag {
+      color: var(--accent-dark);
+      border: 1px solid #bfd8d9;
+      background: #f1f8f8;
+      border-radius: 2px;
+      padding: 2px 5px;
+      font-size: 11px;
+      white-space: nowrap;
+    }
+    .meta {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 6px;
+      color: var(--muted);
+      font-size: 11px;
+      margin-top: 8px;
+    }
+    .trust-strip {
+      display: grid;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      gap: 6px;
+      margin-top: 2px;
+    }
+    .trust-pill {
+      border: 1px solid var(--line);
+      border-radius: 3px;
+      background: #fbfcfd;
+      padding: 5px 6px;
+      min-width: 0;
+    }
+    .trust-label {
+      display: block;
+      color: var(--muted);
+      font-size: 9px;
+      font-weight: 400;
+      text-transform: uppercase;
+    }
+    .trust-value {
+      display: block;
+      overflow-wrap: anywhere;
+      font-weight: 700;
+      font-size: 12px;
+      color: var(--ink);
+    }
+    .meta span {
+      border: 1px solid var(--line);
+      border-radius: 2px;
+      padding: 3px 5px;
+      background: #fbfcfd;
+    }
+    .actions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 6px;
+      margin-top: 10px;
+    }
+    .view-copy {
+      color: var(--muted);
+      font-size: 11px;
+    }
+    .detail-panel {
+      border: 1px solid var(--line);
+      border-bottom: 0;
+      background: #f7f9fa;
+      padding: 9px;
+      display: grid;
+      gap: 6px;
+    }
+    .detail-title {
+      font-weight: 700;
+      color: var(--ink);
+      overflow-wrap: anywhere;
+    }
+    .detail-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 6px;
+    }
+    .detail-grid div {
+      border: 1px solid var(--line);
+      background: #fff;
+      padding: 5px;
+      min-width: 0;
+      overflow-wrap: anywhere;
+    }
+    .actions button, .composer button {
+      border: 1px solid var(--line);
+      border-radius: 2px;
+      background: #f3f6f7;
+      color: var(--text);
+      padding: 5px 8px;
+      cursor: pointer;
+      font: inherit;
+      font-weight: 700;
+    }
+    .actions button:hover, .composer button:hover {
+      border-color: #9cc9ca;
+      background: #eef7f7;
+    }
+    .actions button.danger {
+      border-color: var(--danger-line);
+      background: var(--danger-soft);
+      color: var(--danger);
+    }
+    .actions button.primary, .composer button.primary, .empty-actions button.primary {
+      border-color: var(--active-line);
+      background: var(--active-soft);
+      color: var(--active);
+    }
+    .composer {
+      border: 1px solid var(--line);
+      border-radius: 3px;
+      background: var(--panel);
+      padding: 10px;
+      margin-bottom: 10px;
+      display: grid;
+      gap: 8px;
+    }
+    .composer input, .composer textarea, .composer select {
+      width: 100%;
+      border: 1px solid var(--line);
+      border-radius: 2px;
+      padding: 6px;
+      font: inherit;
+      background: #ffffff;
+      color: var(--text);
+    }
+    .composer textarea {
+      min-height: 72px;
+      resize: vertical;
+    }
+    .empty, .loading, .error {
+      border: 1px dashed var(--line);
+      border-radius: 3px;
+      background: var(--panel);
+      color: var(--muted);
+      padding: 16px;
+    }
+    .empty-actions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 12px;
+    }
+    .empty-actions button {
+      border: 1px solid var(--line);
+      border-radius: 2px;
+      background: #f3f6f7;
+      color: var(--text);
+      padding: 5px 8px;
+      cursor: pointer;
+      font: inherit;
+      font-weight: 700;
+    }
+    .skeleton {
+      display: grid;
+      gap: 8px;
+    }
+    .skeleton-line {
+      height: 10px;
+      border-radius: 2px;
+      background: linear-gradient(90deg, #e7eef1, #f7fafb, #e7eef1);
+    }
+    .skeleton-line.short { width: 48%; }
+    .error { border-color: #f3b4ad; color: var(--danger); }
+    .risk {
+      color: var(--danger);
+      border-color: var(--danger-line) !important;
+      background: var(--danger-soft) !important;
+    }
+    .warn {
+      color: var(--warn);
+      border-color: var(--warn-line) !important;
+      background: var(--warn-soft) !important;
+    }
+    pre {
+      margin: 0;
+      white-space: pre-wrap;
+      word-break: break-word;
+      font-size: 11px;
+      line-height: 1.4;
+    }
+    .module {
+      border: 1px solid var(--line);
+      background: var(--panel);
+      margin-bottom: 10px;
+      padding: 9px;
+    }
+    .module h2 { margin-bottom: 7px; }
+    .owner-card {
+      display: grid;
+      grid-template-columns: 36px minmax(0, 1fr);
+      gap: 8px;
+      align-items: center;
+      margin-bottom: 10px;
+      padding: 6px;
+    }
+    .avatar {
+      width: 36px;
+      height: 36px;
+      border-radius: 2px;
+      display: grid;
+      place-items: center;
+      background: var(--accent);
+      color: #ffffff;
+      font-weight: 700;
+      border: 1px solid var(--accent-dark);
+    }
+    .avatar.mini {
+      width: 30px;
+      height: 30px;
+      font-size: 11px;
+      background: var(--note);
+      border-color: #274472;
+      flex: 0 0 auto;
+    }
+    .owner-name {
+      font-weight: 700;
+      overflow-wrap: anywhere;
+    }
+    .owner-id {
+      color: var(--muted);
+      font-size: 11px;
+      overflow-wrap: anywhere;
+    }
+    .queue {
+      display: grid;
+      gap: 6px;
+    }
+    .queue-row {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      border-bottom: 1px solid #e4ebef;
+      padding-bottom: 5px;
+    }
+    .queue-row:last-child { border-bottom: 0; padding-bottom: 0; }
+    .queue-row strong { overflow-wrap: anywhere; }
+    .profile-panel {
+      border: 1px solid var(--line);
+      background: var(--panel);
+      margin-bottom: 10px;
+      padding: 10px;
+      display: grid;
+      gap: 8px;
+    }
+    .profile-head {
+      display: grid;
+      grid-template-columns: 52px minmax(0, 1fr);
+      gap: 10px;
+      align-items: center;
+    }
+    .profile-head .avatar {
+      width: 52px;
+      height: 52px;
+      font-size: 16px;
+    }
+    .profile-name {
+      font-size: 16px;
+      font-weight: 700;
+      color: var(--ink);
+      overflow-wrap: anywhere;
+    }
+    .profile-meta {
+      color: var(--muted);
+      overflow-wrap: anywhere;
+    }
+    .activity-list {
+      display: grid;
+      gap: 6px;
+    }
+    .activity-row {
+      border-bottom: 1px solid #e4ebef;
+      padding-bottom: 6px;
+      display: grid;
+      gap: 2px;
+      cursor: pointer;
+    }
+    .activity-row:last-child { border-bottom: 0; padding-bottom: 0; }
+    .activity-type {
+      color: var(--ink);
+      font-weight: 700;
+      overflow-wrap: anywhere;
+    }
+    .activity-note {
+      color: var(--muted);
+      overflow-wrap: anywhere;
+    }
+    @media (max-width: 920px) {
+      header { position: static; height: auto; min-height: 54px; }
+      .top-inner {
+        grid-template-columns: 1fr;
+        padding: 8px 0 10px;
+      }
+      .status {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 8px;
+      }
+      header .badge {
+        min-width: 0;
+        text-align: center;
+        white-space: normal;
+      }
+      .page {
+        grid-template-columns: 1fr;
+        padding-top: 12px;
+      }
+      nav, aside {
+        position: static;
+      }
+      nav {
+        display: grid;
+        grid-template-columns: 1fr;
+        gap: 6px;
+      }
+      nav button { margin: 0; }
+      .summary-grid {
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+      }
+      .trust-strip,
+      .detail-grid {
+        grid-template-columns: 1fr;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <header>
+      <div class="top-inner">
+      <div class="product-mark">
+        <h1>Edge Book</h1>
+        <div class="product-subtitle">Local-first agent social workspace</div>
+      </div>
+      <input class="search" aria-label="Search local Edge Book data" placeholder="Search local friends, posts, messages">
+      <div class="status">
+        <span id="sessionBadge" class="badge">Local session</span>
+      </div>
+      </div>
+    </header>
+    <div class="page">
+    <nav aria-label="Edge Book views">
+      <div class="owner-card">
+        <div class="avatar">EB</div>
+        <div>
+          <div id="ownerName" class="owner-name">Connecting...</div>
+        <div id="ownerShort" class="owner-id">local owner session</div>
+        </div>
+      </div>
+      <button data-view="profile">Profile <span id="profileCount">Owner</span></button>
+      <button data-view="feed" class="active">Feed <span id="feedCount">Visible 0</span></button>
+      <button data-view="contacts">Friends <span id="contactCount">Friends 0</span></button>
+      <button data-view="messages">Messages <span id="messageCount">Total 0</span></button>
+      <button data-view="posts">Post history <span id="postCount">Drafts 0</span></button>
+      <button data-view="approvals">Approvals <span id="approvalCount">Pending 0</span></button>
+      <button data-view="activity">Activity Log <span id="activityCount">Events 0</span></button>
+      <button data-view="inspector">Inspector <span>Details</span></button>
+    </nav>
+    <main>
+      <section id="summaryGrid" class="summary-grid" aria-label="Edge Book operational summary">
+        <div class="summary-card active"><div class="summary-label">Visible feed</div><div id="summaryFeed" class="summary-value">0</div></div>
+        <div class="summary-card"><div class="summary-label">Friends</div><div id="summaryFriends" class="summary-value">0</div></div>
+        <div class="summary-card"><div class="summary-label">Messages</div><div id="summaryMessages" class="summary-value">0</div></div>
+        <div class="summary-card warn"><div class="summary-label">Pending approvals</div><div id="summaryApprovals" class="summary-value">0</div></div>
+        <div class="summary-card"><div class="summary-label">Drafts and pending posts</div><div id="summaryDrafts" class="summary-value">0</div></div>
+      </section>
+      <div class="toolbar">
+        <div>
+          <h2 id="viewTitle">Feed</h2>
+          <div id="viewCopy" class="view-copy">Relationship-gated updates with delivery and provenance context.</div>
+        </div>
+        <span id="viewState" class="badge">Loading</span>
+      </div>
+      <section id="content" class="list">
+        <div class="loading">Loading local Edge Book data...</div>
+      </section>
+    </main>
+    <aside>
+      <div class="module">
+        <h2>Owner Console</h2>
+        <div id="owner" class="owner-id">Connecting to local owner session...</div>
+      </div>
+      <div class="module">
+        <h2>Attention Queue</h2>
+        <div id="attentionQueue" class="queue">
+          <div class="queue-row"><strong>Loading</strong><span class="badge">Local</span></div>
+        </div>
+      </div>
+      <div class="module">
+        <h2>Recent Activity</h2>
+        <div id="activityRail" class="activity-list">
+          <div class="activity-row"><div class="activity-type">Loading</div><div class="activity-note">Local audit trail</div></div>
+        </div>
+      </div>
+      <div class="toolbar">
+        <h2>Inspector</h2>
+        <span class="badge">Inspect</span>
+      </div>
+      <div id="inspectorSummary" class="detail-panel">
+        <div class="detail-title">No object selected</div>
+        <div class="view-copy">Click a feed item, contact, message, post, or approval to inspect decision context.</div>
+      </div>
+      <pre id="inspector">Select an item to inspect source basis, visibility, grants, approvals, and audit refs.</pre>
+    </aside>
+    </div>
+  </div>
+  <script>
+    const state = {
+      view: "feed",
+      sessionId: "",
+      csrf: "",
+      me: null,
+      contacts: {},
+      mutes: {},
+      posts: {},
+      feedItems: {},
+      approvals: {},
+      messages: [],
+      audit: []
+    };
+    const titleByView = {
+      profile: "Profile",
+      feed: "Feed",
+      contacts: "Friends and contacts",
+      messages: "Messages",
+      posts: "Post history",
+      approvals: "Approvals",
+      activity: "Activity Log",
+      inspector: "Inspector"
+    };
+    const copyByView = {
+      profile: "Owner identity, local session, relationship posture, and working history.",
+      feed: "Relationship-gated updates with delivery and provenance context.",
+      contacts: "Relationship state, grants, endpoints, and local moderation posture.",
+      messages: "Friend-gated envelopes grouped by peer context.",
+      posts: "Drafts, approvals, visibility, source basis, and removal state.",
+      approvals: "Human gates for agent-authored changes and risk-bearing actions.",
+      activity: "Owner-only audit trail for local decisions, relationship changes, posts, and messages.",
+      inspector: "Readable decision summary plus detailed local evidence."
+    };
+    function headers(extra = {}) {
+      return { "content-type": "application/json", "x-openclaw-session": state.sessionId, "x-openclaw-csrf": state.csrf, ...extra };
+    }
+    async function api(path, init = {}) {
+      const response = await fetch(path, { ...init, headers: headers(init.headers || {}) });
+      const body = await response.json();
+      if (!response.ok) throw new Error(body.code || body.error || "request_failed");
+      return body;
+    }
+    function values(obj) { return Object.values(obj || {}); }
+    function setText(id, text) { document.getElementById(id).textContent = text; }
+    function setInspector(value) {
+      const summary = summarizePayload(value);
+      document.getElementById("inspectorSummary").innerHTML = '<div class="detail-title">' + escapeHtml(summary.title) + '</div><div class="detail-grid">' +
+        summary.facts.map((fact) => '<div><span class="trust-label">' + escapeHtml(fact[0]) + '</span><span class="trust-value">' + escapeHtml(fact[1]) + '</span></div>').join("") +
+        '</div>';
+      setText("inspector", JSON.stringify(value, null, 2));
+    }
+    function meta(parts) {
+      return '<div class="meta">' + parts.filter(Boolean).map((part) => '<span>' + escapeHtml(part) + '</span>').join("") + '</div>';
+    }
+    function skeleton(label = "Loading local Edge Book data...") {
+      return '<div class="loading"><div>' + escapeHtml(label) + '</div><div class="skeleton" aria-hidden="true"><div class="skeleton-line"></div><div class="skeleton-line"></div><div class="skeleton-line short"></div></div></div>';
+    }
+    function escapeHtml(value) {
+      return String(value ?? "").replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[char]));
+    }
+    function action(label, name, id, variant = "") {
+      return '<button type="button" class="' + escapeHtml(variant) + '" data-action="' + escapeHtml(name) + '" data-id="' + escapeHtml(id) + '">' + escapeHtml(label) + '</button>';
+    }
+    function trustStrip(entries) {
+      return '<div class="trust-strip">' + entries.map((entry) => '<div class="trust-pill"><span class="trust-label">' + escapeHtml(entry[0]) + '</span><span class="trust-value">' + escapeHtml(entry[1]) + '</span></div>').join("") + '</div>';
+    }
+    function item(title, body, facts, payload, classes = "", actions = "", trust = [], timestamp = "", avatar = "") {
+      const factHtml = facts.filter(Boolean).length ? meta(facts) : "";
+      const timeHtml = timestamp ? '<span class="item-time">' + escapeHtml(timestamp) + '</span>' : "";
+      const avatarHtml = avatar ? '<span class="avatar mini contact-avatar">' + escapeHtml(avatar) + '</span>' : "";
+      return '<article class="item ' + classes + '" tabindex="0" data-payload="' + encodeURIComponent(JSON.stringify(payload)) + '"><div class="item-head"><div class="item-title-row">' + avatarHtml + '<div><h3>' + escapeHtml(title) + '</h3>' + timeHtml + '</div></div><span class="inspect-tag">Inspect</span></div><div class="item-body">' + escapeHtml(body || "") + '</div>' + (trust.length ? trustStrip(trust) : "") + factHtml + (actions ? '<div class="actions">' + actions + '</div>' : '') + '</article>';
+    }
+    function renderEmpty(label) {
+      return '<div class="empty">' + label + '</div>';
+    }
+    function renderFeedEmpty() {
+      return '<div class="empty">Nothing yet.<div class="empty-actions"><button type="button" class="primary" data-view-target="posts">Compose</button><button type="button" data-view-target="contacts">Invite a friend</button></div></div>';
+    }
+    function shortId(value) {
+      const text = String(value || "");
+      return text.length > 18 ? text.slice(0, 18) + "..." : text;
+    }
+    function labelize(value) {
+      return String(value || "n/a").replace(/_/g, " ");
+    }
+    function publicOwnerLabel() {
+      return state.me?.display_name || "Local owner";
+    }
+    function initials(label) {
+      const words = String(label || "EB").replace(/[^a-z0-9 ]/gi, " ").trim().split(/s+/).filter(Boolean);
+      const text = (words[0]?.[0] || "E") + (words[1]?.[0] || words[0]?.[1] || "B");
+      return text.toUpperCase();
+    }
+    function contactFor(agentId) {
+      return state.contacts[agentId] || {};
+    }
+    function agentLabel(agentId) {
+      if (!agentId) return "Local owner";
+      if ((state.me?.did || state.me?.agent_id) === agentId) return publicOwnerLabel();
+      const contact = contactFor(agentId);
+      return contact.display_name || contact.aliases?.[0] || shortId(agentId);
+    }
+    function peerEndpointLabel(contact) {
+      const endpoints = contact.known_endpoints || [];
+      if (!endpoints.length) return "No endpoint published";
+      return endpoints.map((endpoint) => labelize(endpoint.mode)).join(", ");
+    }
+    function timeLabel(value) {
+      if (!value) return "n/a";
+      const date = new Date(value);
+      if (Number.isNaN(date.getTime())) return String(value);
+      return date.toLocaleString([], { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+    }
+    function pendingApprovals() { return values(state.approvals).filter((approval) => approval.status === "pending"); }
+    function visibleFeedItems() { return values(state.feedItems).filter((feed) => !feed.hidden); }
+    function friendContacts() { return values(state.contacts).filter((contact) => contact.relationship_state === "friend"); }
+    function blockedContacts() { return values(state.contacts).filter((contact) => contact.relationship_state === "blocked"); }
+    function draftPosts() { return values(state.posts).filter((post) => post.status === "draft" || post.status === "pending_approval"); }
+    function renderAttentionQueue() {
+      const rows = [
+        ["Approvals", pendingApprovals().length, pendingApprovals().length ? "attention" : "owned"],
+        ["Unread feed", values(state.feedItems).filter((feed) => feed.read_state !== "read" && !feed.hidden).length, "neutral"],
+        ["Blocked peers", blockedContacts().length, blockedContacts().length ? "risk" : "owned"],
+        ["Draft/pending posts", draftPosts().length, draftPosts().length ? "attention" : "neutral"]
+      ];
+      document.getElementById("attentionQueue").innerHTML = rows.map((row) => '<div class="queue-row"><strong>' + escapeHtml(row[0]) + '</strong><span class="badge ' + escapeHtml(row[2]) + '">' + escapeHtml(row[1]) + '</span></div>').join("");
+    }
+    function renderActivityRail() {
+      const recent = [...state.audit].reverse().slice(0, 6);
+      document.getElementById("activityRail").innerHTML = recent.map((event) => '<div class="activity-row" tabindex="0" data-payload="' + encodeURIComponent(JSON.stringify(event)) + '"><div class="activity-type">' + escapeHtml(labelize(event.type || "event")) + '</div><div class="activity-note">' + escapeHtml(agentLabel(event.peer_agent_id) + " | " + timeLabel(event.created_at)) + '</div></div>').join("") || '<div class="activity-row"><div class="activity-type">No activity yet</div><div class="activity-note">Audit events will appear here.</div></div>';
+      document.querySelectorAll("#activityRail [data-payload]").forEach((node) => {
+        node.addEventListener("click", () => setInspector(JSON.parse(decodeURIComponent(node.dataset.payload))));
+        node.addEventListener("keydown", (event) => { if (event.key === "Enter") node.click(); });
+      });
+    }
+    function summarizePayload(value) {
+      const data = value || {};
+      const feed = data.feed || data;
+      const post = data.post || data;
+      const title = post.title || data.summary || data.display_name || labelize(data.type) || agentLabel(data.peer_agent_id) || "Selected object";
+      const facts = [
+        ["relationship", labelize(data.relationship_state || "local owner")],
+        ["visibility", labelize(post.visibility || feed.visibility || "n/a")],
+        ["source", labelize(post.source_basis || data.source_basis || data.transport || data.delivery_route || feed.delivery_route || "local")],
+        ["approval", labelize(data.status || post.status || data.risk_level || "n/a")],
+        ["audit evidence", (data.audit_refs || post.audit_refs || feed.audit_refs || []).length || (data.audit_id ? 1 : 0)]
+      ];
+      return { title, facts };
+    }
+    function render() {
+      document.querySelectorAll("nav button").forEach((button) => button.classList.toggle("active", button.dataset.view === state.view));
+      setText("viewTitle", titleByView[state.view]);
+      setText("viewCopy", copyByView[state.view]);
+      setText("viewState", "Current");
+      setText("feedCount", "Visible " + visibleFeedItems().length);
+      setText("contactCount", "Friends " + friendContacts().length);
+      setText("postCount", "Drafts " + draftPosts().length);
+      setText("approvalCount", "Pending " + pendingApprovals().length);
+      setText("activityCount", "Events " + state.audit.length);
+      setText("messageCount", "Total " + state.messages.length);
+      setText("summaryFeed", visibleFeedItems().length);
+      setText("summaryFriends", friendContacts().length);
+      setText("summaryMessages", state.messages.length);
+      setText("summaryApprovals", pendingApprovals().length);
+      setText("summaryDrafts", draftPosts().length);
+      renderAttentionQueue();
+      renderActivityRail();
+      const content = document.getElementById("content");
+      let html = "";
+      if (state.view === "profile") {
+        html = '<section class="profile-panel"><div class="profile-head"><div class="avatar">EB</div><div><div class="profile-name">' + escapeHtml(publicOwnerLabel()) + '</div><div class="profile-meta">Local owner session</div></div></div>' +
+          trustStrip([
+            ["session", "local active"],
+            ["friends", friendContacts().length],
+            ["pending approvals", pendingApprovals().length],
+            ["activity events", state.audit.length]
+          ]) +
+          '<div class="view-copy">Endpoint and key material are kept out of the main profile surface; inspect technical evidence only when needed.</div></section>' +
+          values(state.posts).slice(0, 6).map((post) => item(post.title, post.body, [
+            "status: " + labelize(post.status),
+            "visibility: " + labelize(post.visibility),
+            "source: " + labelize(post.source_basis),
+            "updated: " + timeLabel(post.updated_at)
+          ], post, post.status === "removed" ? "risk" : "", "", [
+            ["status", labelize(post.status)],
+            ["visibility", labelize(post.visibility)],
+            ["source", labelize(post.source_basis)],
+            ["audit refs", (post.audit_refs || []).length]
+          ])).join("");
+      }
+      if (state.view === "feed") {
+        const posts = state.posts;
+        html = values(state.feedItems).map((feed) => {
+          const post = posts[feed.post_id] || {};
+          const actions = [
+            feed.read_state === "read" ? "" : action("Mark read", "feed-read", feed.feed_item_id),
+            feed.hidden ? "" : action("Hide", "feed-hide", feed.feed_item_id, "danger")
+          ].join("");
+          return item(post.title || "Untitled feed item", post.body || "No post body loaded for this feed item.", [
+            feed.read_state !== "read" ? "unread" : "",
+            feed.hidden ? "hidden" : ""
+          ], { feed, post }, feed.hidden ? "warn" : "", actions, [
+            ["relationship", labelize(contactFor(feed.origin_agent_id).relationship_state || "local")],
+            ["visibility", labelize(post.visibility || "unknown")],
+            ["source", labelize(post.source_basis || feed.origin_home || "unknown")],
+            ["delivery", labelize(feed.delivery_route || "local")]
+          ], "Posted " + timeLabel(post.published_at || post.updated_at || feed.received_at));
+        }).join("") || renderFeedEmpty();
+      }
+      if (state.view === "contacts") {
+        html = values(state.contacts).map((contact) => item(contact.display_name || "Unnamed contact", contact.aliases?.[0] || contact.card_url || peerEndpointLabel(contact), [
+          state.mutes[contact.peer_agent_id] ? "muted" : "active",
+        ], contact, contact.relationship_state === "blocked" ? "risk" : "", state.mutes[contact.peer_agent_id] ? "" : action("Mute", "contact-mute", contact.peer_agent_id), [
+          ["relationship", labelize(contact.relationship_state)],
+          ["grants", (contact.capability_grants || []).length],
+          ["endpoint", (contact.known_endpoints || []).length ? "known" : "missing"],
+          ["local posture", state.mutes[contact.peer_agent_id] ? "muted" : "active"]
+        ], "", initials(contact.display_name || contact.aliases?.[0] || contact.peer_agent_id))).join("") || renderEmpty("No contacts yet.");
+      }
+      if (state.view === "messages") {
+        html = state.messages.map((message) => item(labelize(message.type), message.body?.text || message.body?.note || JSON.stringify(message.body || {}), [
+        ], message, "", "", [
+          ["direction", message.to_agent_id === (state.me?.did || state.me?.agent_id) ? "inbound" : "outbound"],
+          ["transport", labelize(message.transport || "local")],
+          ["sender", agentLabel(message.from_agent_id)],
+          ["recipient", agentLabel(message.to_agent_id)]
+        ], "", initials(agentLabel(message.from_agent_id)))).join("") || renderEmpty("No messages for selected contacts yet.");
+      }
+      if (state.view === "posts") {
+        html = '<form class="composer" data-action="post-create"><input name="title" placeholder="Post title" required><textarea name="body" placeholder="Post body" required></textarea><select name="visibility"><option value="private">private</option><option value="friends">friends</option><option value="public_if_enabled">public_if_enabled</option></select><button type="submit" class="primary">Create draft</button></form>' +
+        (values(state.posts).map((post) => {
+          const actions = [
+            post.status === "pending_approval" ? action("Approve", "post-approve", post.post_id) : "",
+            post.status === "removed" ? "" : action("Edit", "post-edit", post.post_id),
+            post.status === "removed" ? "" : action("Remove", "post-remove", post.post_id, "danger")
+          ].join("");
+          return item(post.title, post.body, [
+          post.approval_ref ? "approval linked" : ""
+        ], post, post.status === "removed" ? "risk" : "", actions, [
+          ["status", labelize(post.status)],
+          ["visibility", labelize(post.visibility)],
+          ["source", labelize(post.source_basis)],
+          ["approval", post.approval_ref ? "linked" : "none"]
+        ], "Updated " + timeLabel(post.updated_at));
+        }).join("") || renderEmpty("No post history yet."));
+      }
+      if (state.view === "approvals") {
+        html = values(state.approvals).map((approval) => {
+          const actions = approval.status === "pending"
+            ? action("Approve", "approval-approve", approval.approval_id) + action("Reject", "approval-reject", approval.approval_id, "danger")
+            : "";
+          return item(approval.summary, approval.object_type + " awaiting local owner decision", [], approval, approval.risk_level === "high" ? "risk" : approval.risk_level === "medium" ? "warn" : "", actions, [
+          ["risk", labelize(approval.risk_level)],
+          ["status", labelize(approval.status)],
+          ["type", labelize(approval.type)],
+          ["object", labelize(approval.object_type || "unknown")]
+        ], "Requested " + timeLabel(approval.created_at));
+        }).join("") || renderEmpty("No approval requests.");
+      }
+      if (state.view === "activity") {
+        html = [...state.audit].reverse().map((event) => item(labelize(event.type || "audit event"), event.peer_agent_id ? agentLabel(event.peer_agent_id) : "Local owner action", [
+          "when: " + timeLabel(event.created_at),
+          "actor/context: " + agentLabel(event.peer_agent_id),
+          "audit evidence available"
+        ], event, "", "", [
+          ["event", labelize(event.type || "unknown")],
+          ["actor/context", agentLabel(event.peer_agent_id)],
+          ["time", timeLabel(event.created_at)],
+          ["audit evidence", event.audit_id ? "available" : "not recorded"]
+        ])).join("") || renderEmpty("No activity log entries yet.");
+      }
+      if (state.view === "inspector") {
+        html = item("Current API snapshot", "Local owner state loaded from /api routes.", [
+          "contacts: " + values(state.contacts).length,
+          "posts: " + values(state.posts).length,
+          "feed: " + values(state.feedItems).length,
+          "approvals: " + values(state.approvals).length,
+          "activity: " + state.audit.length
+        ], state, "", "", [
+          ["owner", state.me?.display_name || "Local owner"],
+          ["contacts", values(state.contacts).length],
+          ["posts", values(state.posts).length],
+          ["approvals", values(state.approvals).length]
+        ]);
+      }
+      content.innerHTML = html;
+      content.querySelectorAll("[data-payload]").forEach((node) => {
+        node.addEventListener("click", () => setInspector(JSON.parse(decodeURIComponent(node.dataset.payload))));
+        node.addEventListener("keydown", (event) => { if (event.key === "Enter") node.click(); });
+      });
+      content.querySelectorAll("button[data-view-target]").forEach((button) => {
+        button.addEventListener("click", (event) => {
+          event.stopPropagation();
+          state.view = button.dataset.viewTarget;
+          render();
+        });
+      });
+      content.querySelectorAll("button[data-action]").forEach((button) => {
+        button.addEventListener("click", (event) => {
+          event.stopPropagation();
+          runAction(button.dataset.action, button.dataset.id);
+        });
+      });
+      const composer = content.querySelector("form[data-action='post-create']");
+      if (composer) composer.addEventListener("submit", createPost);
+    }
+    async function postJson(path, body = {}) {
+      return api(path, { method: "POST", body: JSON.stringify(body) });
+    }
+    async function runAction(name, id) {
+      try {
+        if (name === "feed-read") await postJson("/api/feed/" + encodeURIComponent(id) + "/read");
+        if (name === "feed-hide") await postJson("/api/feed/" + encodeURIComponent(id) + "/hide", { reason: prompt("Reason", "hidden by owner") || "" });
+        if (name === "contact-mute") await postJson("/api/contacts/" + encodeURIComponent(id) + "/mute", { reason: prompt("Reason", "muted by owner") || "" });
+        if (name === "post-approve") await postJson("/api/posts/" + encodeURIComponent(id) + "/approve");
+        if (name === "post-edit") {
+          const current = state.posts[id] || {};
+          await postJson("/api/posts/" + encodeURIComponent(id) + "/edit", {
+            title: prompt("Title", current.title || "") || current.title || "",
+            body: prompt("Body", current.body || "") || current.body || "",
+            visibility: current.visibility || "private"
+          });
+        }
+        if (name === "post-remove") await postJson("/api/posts/" + encodeURIComponent(id) + "/remove", { reason: prompt("Reason", "removed by owner") || "" });
+        if (name === "approval-approve") await postJson("/api/approvals/" + encodeURIComponent(id) + "/resolve", { approved: true });
+        if (name === "approval-reject") await postJson("/api/approvals/" + encodeURIComponent(id) + "/resolve", { approved: false });
+        await refresh();
+      } catch (error) {
+        setInspector({ action: name, id, failure_reason: error.message || String(error) });
+      }
+    }
+    async function createPost(event) {
+      event.preventDefault();
+      const form = event.currentTarget;
+      const data = new FormData(form);
+      try {
+        await postJson("/api/posts", {
+          title: data.get("title"),
+          body: data.get("body"),
+          visibility: data.get("visibility"),
+          status: "draft"
+        });
+        form.reset();
+        await refresh();
+      } catch (error) {
+        setInspector({ action: "post-create", failure_reason: error.message || String(error) });
+      }
+    }
+    async function refresh() {
+      const me = await api("/api/me");
+      state.me = me.identity;
+      setText("owner", publicOwnerLabel() + " | Local session active");
+      setText("ownerName", publicOwnerLabel());
+      setText("ownerShort", "local owner session");
+      const [contacts, posts, feed, approvals, audit] = await Promise.all([
+        api("/api/contacts"),
+        api("/api/posts"),
+        api("/api/feed"),
+        api("/api/approvals"),
+        api("/api/audit")
+      ]);
+      state.contacts = contacts.contacts;
+      state.mutes = contacts.mutes;
+      state.posts = posts.posts;
+      state.feedItems = feed.feed_items;
+      state.approvals = approvals.approvals;
+      state.audit = audit.audit || [];
+      const messageSets = await Promise.all(values(state.contacts).map((contact) => api("/api/messages/" + encodeURIComponent(contact.peer_agent_id)).catch(() => ({ messages: [] }))));
+      state.messages = messageSets.flatMap((set) => set.messages || []);
+      setText("sessionBadge", "Local session active");
+      render();
+    }
+    async function boot() {
+      try {
+        document.getElementById("content").innerHTML = skeleton();
+        setText("viewState", "Loading");
+        const login = await fetch("/auth/login", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ auth_method: "dev-bypass" })
+        }).then((response) => response.json());
+        state.sessionId = login.session_id;
+        state.csrf = login.csrf_token;
+        await refresh();
+      } catch (error) {
+        document.getElementById("content").innerHTML = '<div class="loading">Still connecting to local Edge Book data. Retrying shortly...</div>';
+        setText("viewState", "Connecting");
+        window.setTimeout(boot, 1200);
+      }
+    }
+    document.querySelectorAll("nav button").forEach((button) => button.addEventListener("click", () => {
+      state.view = button.dataset.view;
+      render();
+    }));
+    boot();
+  </script>
+</body>
+</html>`;
+}
+function createEdgeBookHttpServer(store, cardUrl) {
+  const adapters = createDefaultApiAdapters(store);
+  return http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", "http://localhost");
+      if (req.method === "GET" && (url.pathname === "/" || url.pathname === "/app")) {
+        sendHtml(res, dashboardHtml());
+        return;
+      }
+      if (await handleOwnerApi(req, res, url, adapters)) return;
+      if (req.method === "GET" && url.pathname === "/edge-book/card") {
+        sendJson(res, 200, await store.writeCard(cardUrl));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/edge-book/envelopes") {
+        const envelope = await readJsonBody(req);
+        await store.receiveEnvelope(envelope);
+        sendJson(res, 200, { ok: true, type: envelope.type, message_id: envelope.message_id });
+        return;
+      }
+      sendJson(res, 404, { ok: false, error: "not_found" });
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+}
+async function startEdgeBookServer(options) {
+  const store = new EdgeBookStore({ home: options.home });
+  const host = options.host || "127.0.0.1";
+  const port = options.port ?? 0;
+  const server = createEdgeBookHttpServer(store, options.cardUrl);
+  await new Promise((resolve) => server.listen(port, host, resolve));
+  return server;
+}
+function relayFile(store, agentId) {
+  return path2.join(store, `${encodeURIComponent(agentId)}.jsonl`);
+}
+async function appendRelayEnvelope(store, agentId, envelope) {
+  await fs2.mkdir(store, { recursive: true });
+  await fs2.appendFile(relayFile(store, agentId), `${JSON.stringify(envelope)}
+`, "utf8");
+}
+async function drainRelayEnvelopes(store, agentId) {
+  const file = relayFile(store, agentId);
+  try {
+    const text = await fs2.readFile(file, "utf8");
+    await fs2.writeFile(file, "", "utf8");
+    return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function createRelayServer(store) {
+  return http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", "http://localhost");
+      const match = /^\/relay\/([^/]+)$/.exec(url.pathname);
+      if (!match) {
+        sendJson(res, 404, { ok: false, error: "not_found" });
+        return;
+      }
+      const agentId = decodeURIComponent(match[1]);
+      if (req.method === "POST") {
+        const envelope = await readJsonBody(req);
+        await appendRelayEnvelope(store, agentId, envelope);
+        sendJson(res, 200, { ok: true, queued: 1 });
+        return;
+      }
+      if (req.method === "GET") {
+        const envelopes = await drainRelayEnvelopes(store, agentId);
+        sendJson(res, 200, { ok: true, envelopes });
+        return;
+      }
+      sendJson(res, 405, { ok: false, error: "method_not_allowed" });
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+}
+async function startRelayServer(options) {
+  const host = options.host || "127.0.0.1";
+  const port = options.port ?? 0;
+  const server = createRelayServer(options.store);
+  await new Promise((resolve) => server.listen(port, host, resolve));
+  return server;
+}
+async function postEnvelope(endpoint, envelope) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(envelope)
+  });
+  if (!response.ok) throw new EdgeBookError("delivery_failed", `Delivery failed: ${response.status} ${await response.text()}`);
+}
+async function postRelayEnvelope(relayBaseUrl, recipientAgentId, envelope) {
+  await postEnvelope(`${relayBaseUrl.replace(/\/$/, "")}/relay/${encodeURIComponent(recipientAgentId)}`, envelope);
+}
+async function pullRelayEnvelopes(relayBaseUrl, recipientAgentId) {
+  const response = await fetch(`${relayBaseUrl.replace(/\/$/, "")}/relay/${encodeURIComponent(recipientAgentId)}`);
+  if (!response.ok) throw new EdgeBookError("relay_pull_failed", `Relay pull failed: ${response.status}`);
+  const body = await response.json();
+  return body.envelopes || [];
+}
+// src/dialout.ts
+var KEY_FILE = "host-dialout-key.json";
+var DEFAULT_PAIR_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_HEARTBEAT_MS = 25e3;
+var DEFAULT_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 3e4;
+var PAIRING_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function keyId(agentKey) {
+  return `agent_${crypto2.createHash("sha256").update(agentKey).digest("base64url").slice(0, 32)}`;
+}
+async function chmodBestEffort2(file, mode) {
+  if (process.platform === "win32") return;
+  try {
+    await fs3.chmod(file, mode);
+  } catch {
+  }
+}
+async function loadOrCreateDialoutKey(store) {
+  const file = store.file(KEY_FILE);
+  try {
+    const existing = JSON.parse(await fs3.readFile(file, "utf8"));
+    if (existing.agent_key && existing.public_key_pem && existing.private_key_pem && existing.key_id) return existing;
+    if (existing.public_key_pem && existing.private_key_pem && existing.key_id) {
+      const migrated = {
+        ...existing,
+        agent_key: `ed25519:${Buffer.from(existing.public_key_pem, "utf8").toString("base64")}`
+      };
+      migrated.key_id = keyId(migrated.agent_key);
+      await fs3.writeFile(file, `${JSON.stringify(migrated, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+      await chmodBestEffort2(file, 384);
+      return migrated;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const pair = crypto2.generateKeyPairSync("ed25519");
+  const publicKeyPem = pair.publicKey.export({ type: "spki", format: "pem" }).toString();
+  const privateKeyPem = pair.privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+  const publicKeyDer = pair.publicKey.export({ type: "spki", format: "der" });
+  const agentKey = `ed25519:${Buffer.from(publicKeyDer).toString("base64")}`;
+  const key = {
+    schema: "edge-book-host-dialout-key/0.1",
+    key_id: keyId(agentKey),
+    agent_key: agentKey,
+    public_key_pem: publicKeyPem,
+    private_key_pem: privateKeyPem,
+    created_at: now2()
+  };
+  await fs3.mkdir(path3.dirname(file), { recursive: true });
+  await fs3.writeFile(file, `${JSON.stringify(key, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  await chmodBestEffort2(file, 384);
+  return key;
+}
+function generatePairingCode(length = 8) {
+  let code = "";
+  for (let i = 0; i < length; i += 1) {
+    code += PAIRING_ALPHABET[crypto2.randomInt(PAIRING_ALPHABET.length)];
+  }
+  return code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code;
+}
+async function createPairRegistration(store, ttlMs = DEFAULT_PAIR_TTL_MS) {
+  const code = generatePairingCode();
+  return {
+    code,
+    frame: {
+      type: "pair_register",
+      code,
+      ttl_ms: ttlMs,
+      request_id: crypto2.randomUUID()
+    }
+  };
+}
+async function createSessionsRevokeFrame(store) {
+  await loadOrCreateDialoutKey(store);
+  return {
+    type: "sessions_revoke",
+    request_id: crypto2.randomUUID()
+  };
+}
+function socketFactory(url) {
+  const SocketCtor = globalThis.WebSocket;
+  if (!SocketCtor) throw new EdgeBookError("websocket_unavailable", "This Node runtime does not provide global WebSocket");
+  return new SocketCtor(url);
+}
+function addSocketListener(socket, event, handler) {
+  if (socket.addEventListener) {
+    socket.addEventListener(event, handler);
+    return;
+  }
+  const prop = `on${event}`;
+  socket[prop] = handler;
+}
+function serverBaseUrl(server) {
+  const address = server.address();
+  if (!address || typeof address === "string") throw new EdgeBookError("local_api_unavailable", "Local API server did not expose a port");
+  return `http://127.0.0.1:${address.port}`;
+}
+async function closeServer(server) {
+  await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+}
+async function openLocalApi(store) {
+  const server = await startEdgeBookServer({ home: store.home, host: "127.0.0.1", port: 0 });
+  const baseUrl = serverBaseUrl(server);
+  const login = await fetch(`${baseUrl}/auth/login`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ auth_method: "future-remote-auth", ttl_ms: 24 * 60 * 60 * 1e3 })
+  });
+  if (!login.ok) {
+    await closeServer(server);
+    throw new EdgeBookError("local_api_login_failed", `Local API login failed: ${login.status}`);
+  }
+  const body = await login.json();
+  return { server, baseUrl, sessionId: body.session_id, csrf: body.csrf_token };
+}
+function normalizeApiPath(value) {
+  if (!value.startsWith("/api/")) throw new EdgeBookError("invalid_proxy_path", "Dial-out only proxies /api/* JSON requests");
+  return value;
+}
+function apiUrl(baseUrl, frame) {
+  return `${baseUrl}${normalizeApiPath(frame.path)}${frame.query || ""}`;
+}
+function requestBody(frame, method) {
+  if (method === "GET" || method === "HEAD") return void 0;
+  if (typeof frame.body_b64 === "string") return Buffer.from(frame.body_b64, "base64");
+  return Buffer.from(JSON.stringify(frame.body ?? {}), "utf8");
+}
+var EdgeBookDialoutClient = class {
+  options;
+  store;
+  socket;
+  localApi;
+  heartbeat;
+  reconnectTimer;
+  stopped = false;
+  currentBackoff;
+  opened;
+  pendingSessionRevokes = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = {
+      heartbeatMs: options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS,
+      reconnect: options.reconnect ?? true,
+      backoffMs: options.backoffMs ?? DEFAULT_BACKOFF_MS,
+      socketFactory: options.socketFactory ?? socketFactory,
+      openLocalApi: options.openLocalApi ?? true,
+      host: options.host,
+      home: options.home
+    };
+    this.store = new EdgeBookStore({ home: options.home });
+    this.currentBackoff = this.options.backoffMs;
+  }
+  async start() {
+    this.stopped = false;
+    await this.connect();
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    this.socket?.close();
+    if (this.localApi) await closeServer(this.localApi.server);
+    this.localApi = void 0;
+  }
+  async pair(ttlMs = DEFAULT_PAIR_TTL_MS) {
+    const registration = await createPairRegistration(this.store, ttlMs);
+    this.send(registration.frame);
+    return registration;
+  }
+  async revokeSessions() {
+    const frame = await createSessionsRevokeFrame(this.store);
+    this.send(frame);
+    return frame;
+  }
+  async revokeSessionsAndWait(timeoutMs = 5e3) {
+    const frame = await createSessionsRevokeFrame(this.store);
+    const ackPromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingSessionRevokes.delete(frame.request_id);
+        reject(new EdgeBookError("host_revoke_timeout", "Timed out waiting for sessions_revoke_ok"));
+      }, timeoutMs);
+      this.pendingSessionRevokes.set(frame.request_id, { resolve, reject, timer });
+    });
+    this.send(frame);
+    return { frame, ack: await ackPromise };
+  }
+  async connect() {
+    if (this.options.openLocalApi && !this.localApi) this.localApi = await openLocalApi(this.store);
+    const socket = this.options.socketFactory(this.options.host);
+    this.socket = socket;
+    const opened = new Promise((resolve, reject) => {
+      this.opened = { resolve, reject };
+      addSocketListener(socket, "open", async () => {
+        try {
+          this.currentBackoff = this.options.backoffMs;
+          const key = await loadOrCreateDialoutKey(this.store);
+          const identity = await this.store.identity();
+          this.send({
+            type: "hello",
+            agent_key: key.agent_key,
+            agent_did: identity.agent_id,
+            version: "0.1.0",
+            nonce: crypto2.randomUUID()
+          });
+        } catch (error) {
+          this.opened = void 0;
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    });
+    addSocketListener(socket, "message", (event) => {
+      void this.handleMessage(event?.data);
+    });
+    addSocketListener(socket, "close", () => {
+      if (this.heartbeat) clearInterval(this.heartbeat);
+      if (!this.stopped && this.options.reconnect) this.scheduleReconnect();
+    });
+    await opened;
+  }
+  scheduleReconnect() {
+    const delay = this.currentBackoff;
+    this.currentBackoff = Math.min(MAX_BACKOFF_MS, Math.round(this.currentBackoff * 1.7));
+    this.reconnectTimer = setTimeout(() => {
+      void this.connect();
+    }, delay);
+  }
+  send(value) {
+    this.socket?.send(JSON.stringify(value));
+  }
+  async handleMessage(data) {
+    const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
+    const frame = JSON.parse(text);
+    if (frame.type === "hello_ok") {
+      this.opened?.resolve();
+      this.opened = void 0;
+      return;
+    }
+    if (frame.type === "hello_err") {
+      const error = new EdgeBookError("host_hello_failed", frame.error || "Host rejected hello");
+      this.opened?.reject(error);
+      this.opened = void 0;
+      return;
+    }
+    if (frame.type === "ping") {
+      this.send({ type: "pong" });
+      return;
+    }
+    if (frame.type === "pair_register_ok" || frame.type === "pair_register_err") return;
+    if (frame.type === "sessions_revoke_ok") {
+      const ack = frame;
+      const pending = this.pendingSessionRevokes.get(ack.request_id || "");
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingSessionRevokes.delete(ack.request_id || "");
+        pending.resolve(ack);
+      }
+      return;
+    }
+    if (frame.type === "error") return;
+    if (frame.type !== "host.api.request" && frame.type !== "api_request") return;
+    const response = await this.handleApiRequest(frame);
+    this.send(response);
+  }
+  async handleApiRequest(frame) {
+    try {
+      if (!this.localApi) {
+        if (!this.options.openLocalApi) throw new EdgeBookError("local_api_disabled", "This dial-out client does not serve local API requests");
+        this.localApi = await openLocalApi(this.store);
+      }
+      const method = (frame.method || "GET").toUpperCase();
+      const response = await fetch(apiUrl(this.localApi.baseUrl, frame), {
+        method,
+        headers: {
+          "content-type": "application/json",
+          "x-openclaw-session": this.localApi.sessionId,
+          "x-openclaw-csrf": this.localApi.csrf
+        },
+        body: requestBody(frame, method)
+      });
+      const bodyBuffer = Buffer.from(await response.arrayBuffer());
+      return {
+        type: "api_response",
+        id: frame.id || frame.request_id || "",
+        request_id: frame.request_id || frame.id || "",
+        status: response.status,
+        headers: { "content-type": response.headers.get("content-type") || "application/json; charset=utf-8" },
+        body_b64: bodyBuffer.toString("base64")
+      };
+    } catch (error) {
+      const body = {
+        ok: false,
+        code: error instanceof EdgeBookError ? error.code : "internal_error",
+        error: error instanceof Error ? error.message : String(error)
+      };
+      return {
+        type: "api_response",
+        id: frame.id || frame.request_id || "",
+        request_id: frame.request_id || frame.id || "",
+        status: error instanceof EdgeBookError ? 400 : 500,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_b64: Buffer.from(JSON.stringify(body), "utf8").toString("base64"),
+        body
+      };
+    }
+  }
+};
+async function sendPairRegistration(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const registration = await client.pair(options.ttlMs ?? DEFAULT_PAIR_TTL_MS);
+  await client.stop();
+  return registration;
+}
+async function sendSessionsRevoke(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const { frame, ack } = await client.revokeSessionsAndWait();
+  await client.stop();
+  return { ...frame, channel_id: ack.channel_id };
+}
+// src/cli.ts
+function usage() {
+  return `Edge Book
+Usage:
+  edge-book init [--home <dir>] [--handle <handle>] [--name <display>]
+Hosted reader:
+  edge-book dialout --host <ws-url> [--home <dir>]
+  edge-book pair --host <ws-url> [--ttl-ms <ms>] [--home <dir>]
+  edge-book sessions revoke --host <ws-url> [--home <dir>]
+Local agent:
+  edge-book doctor [--home <dir>]
+  edge-book card show [--home <dir>]
+  edge-book card export --path <file> [--home <dir>]
+  edge-book friend request <card-path-or-url> [--deliver] [--home <dir>]
+  edge-book friend receive <envelope-json-path> [--home <dir>]
+  edge-book friend accept <peer-agent-id> [--deliver] [--home <dir>]
+  edge-book friend apply-response <envelope-json-path> [--home <dir>]
+  edge-book friend revoke <peer-agent-id> [--home <dir>]
+  edge-book friend block <peer-agent-id> [--home <dir>]
+  edge-book contacts list [--home <dir>]
+  edge-book contacts refresh <card-path-or-url> [--home <dir>]
+  edge-book message send <peer-agent-id> --body <text> [--deliver] [--home <dir>]
+  edge-book message receive <envelope-json-path> [--home <dir>]
+  edge-book inbox list [--home <dir>]
+  edge-book inbox pull --relay <url> [--home <dir>]
+  edge-book serve --host <host> --port <port> [--home <dir>]
+  edge-book relay serve --host <host> --port <port> --store <dir>
+  edge-book harness two-agent`;
+}
+function takeFlag(args, name) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return void 0;
+  const value = args[idx + 1];
+  args.splice(idx, 2);
+  return value;
+}
+function parseHome(args, ctx) {
+  return takeFlag(args, "--home") || ctx.home;
+}
+function requireArg(value, label) {
+  if (!value) throw new EdgeBookError("missing_arg", `Missing ${label}`);
+  return value;
+}
+function takeBoolFlag(args, name) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return false;
+  args.splice(idx, 1);
+  return true;
+}
+async function readEnvelope(filePath) {
+  return JSON.parse(await fs4.readFile(path4.resolve(filePath), "utf8"));
+}
+async function deliverToEndpoint(envelope, endpoint) {
+  await postEnvelope(endpoint, envelope);
+  return `Delivered ${envelope.type} to ${endpoint}`;
+}
+async function deliverToPeer(store, envelope, peerAgentId) {
+  const contacts = await store.contacts();
+  const contact = contacts[peerAgentId];
+  const direct = contact?.known_endpoints.find((entry) => entry.mode === "direct")?.endpoint;
+  if (direct) return deliverToEndpoint(envelope, direct);
+  const relay = contact?.known_endpoints.find((entry) => entry.mode === "relay")?.endpoint;
+  if (relay) {
+    await postRelayEnvelope(relay, peerAgentId, envelope);
+    return `Queued ${envelope.type} via relay ${relay}`;
+  }
+  throw new EdgeBookError("no_route", `No direct or relay endpoint for ${peerAgentId}`);
+}
+function serverAddress(server) {
+  const address = server.address();
+  if (!address || typeof address === "string") return String(address);
+  return `${address.address}:${address.port}`;
+}
+async function handleCli(inputArgs, ctx = {}) {
+  const args = [...inputArgs];
+  const home = parseHome(args, ctx);
+  const command = args.shift() || "help";
+  const store = new EdgeBookStore({ home });
+  if (command === "help" || command === "--help" || command === "-h") {
+    return { text: usage() };
+  }
+  if (command === "init") {
+    const handle = takeFlag(args, "--handle");
+    const displayName = takeFlag(args, "--name");
+    const directUrl = takeFlag(args, "--direct-url");
+    const relayUrl = takeFlag(args, "--relay-url");
+    const identity = await store.init({ handle, displayName, directUrl, relayUrl });
+    return { text: `Initialized ${identity.agent_id} at ${store.home}`, json: identity };
+  }
+  if (command === "doctor") {
+    const result = await store.doctor();
+    return { text: JSON.stringify(result, null, 2), json: result };
+  }
+  if (command === "card") {
+    const action = args.shift() || "show";
+    if (action === "show") {
+      const card = await store.writeCard();
+      return { text: JSON.stringify(card, null, 2), json: card };
+    }
+    if (action === "export") {
+      const target = requireArg(takeFlag(args, "--path"), "--path");
+      const card = await store.writeCard();
+      await fs4.mkdir(path4.dirname(path4.resolve(target)), { recursive: true });
+      await fs4.writeFile(path4.resolve(target), `${JSON.stringify(card, null, 2)}
+`, "utf8");
+      return { text: `Exported Agent Card to ${path4.resolve(target)}`, json: card };
+    }
+  }
+  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 envelope = await store.createFriendRequest(card);
+      if (deliver) {
+        const direct = card.transports.find((entry) => entry.mode === "direct")?.endpoint;
+        if (direct) return { text: await deliverToEndpoint(envelope, direct), json: envelope };
+        const relay = card.transports.find((entry) => entry.mode === "relay")?.endpoint;
+        if (relay) {
+          await postRelayEnvelope(relay, card.agent_id, envelope);
+          return { text: `Queued friend_request via relay ${relay}`, json: envelope };
+        }
+        throw new EdgeBookError("no_route", `No direct or relay endpoint for ${card.agent_id}`);
+      }
+      return { text: JSON.stringify(envelope, null, 2), json: envelope };
+    }
+    if (action === "receive") {
+      const source = requireArg(args.shift(), "envelope-json-path");
+      const contact = await store.receiveFriendRequest(await readEnvelope(source));
+      return { text: JSON.stringify(contact, null, 2), json: contact };
+    }
+    if (action === "accept") {
+      const deliver = takeBoolFlag(args, "--deliver");
+      const peer = requireArg(args.shift(), "peer-agent-id");
+      const envelope = await store.acceptFriend(peer);
+      if (deliver) return { text: await deliverToPeer(store, envelope, peer), json: envelope };
+      return { text: JSON.stringify(envelope, null, 2), json: envelope };
+    }
+    if (action === "apply-response") {
+      const source = requireArg(args.shift(), "envelope-json-path");
+      await store.applyFriendResponse(await readEnvelope(source));
+      return { text: `Applied friend response from ${path4.resolve(source)}` };
+    }
+    if (action === "revoke") {
+      const peer = requireArg(args.shift(), "peer-agent-id");
+      await store.revoke(peer);
+      return { text: `Revoked ${peer}` };
+    }
+    if (action === "block") {
+      const peer = requireArg(args.shift(), "peer-agent-id");
+      await store.block(peer);
+      return { text: `Blocked ${peer}` };
+    }
+  }
+  if (command === "contacts") {
+    const action = args.shift() || "list";
+    if (action === "list") {
+      const contacts = await store.contacts();
+      return { text: JSON.stringify(Object.values(contacts), null, 2), json: contacts };
+    }
+    if (action === "refresh") {
+      const target = requireArg(args.shift(), "card-path-or-url");
+      const contact = await store.upsertContactFromCard(await loadCard(target));
+      return { text: JSON.stringify(contact, null, 2), json: contact };
+    }
+  }
+  if (command === "message") {
+    const action = args.shift();
+    if (action === "send") {
+      const deliver = takeBoolFlag(args, "--deliver");
+      const peer = requireArg(args.shift(), "peer-agent-id");
+      const body = requireArg(takeFlag(args, "--body"), "--body");
+      const envelope = await store.sendPrivilegedMessage(peer, { text: body });
+      if (deliver) return { text: await deliverToPeer(store, envelope, peer), json: envelope };
+      return { text: JSON.stringify(envelope, null, 2), json: envelope };
+    }
+    if (action === "receive") {
+      const source = requireArg(args.shift(), "envelope-json-path");
+      await store.receivePrivilegedMessage(await readEnvelope(source));
+      return { text: `Received privileged message from ${path4.resolve(source)}` };
+    }
+  }
+  if (command === "inbox") {
+    const action = args.shift() || "list";
+    if (action === "list") {
+      const inbox = await store.inbox();
+      return { text: JSON.stringify(inbox, null, 2), json: inbox };
+    }
+    if (action === "pull") {
+      const relay = requireArg(takeFlag(args, "--relay"), "--relay");
+      const identity = await store.identity();
+      const envelopes = await pullRelayEnvelopes(relay, identity.agent_id);
+      for (const envelope of envelopes) await store.receiveEnvelope(envelope);
+      return { text: `Pulled ${envelopes.length} envelope(s) from ${relay}`, json: envelopes };
+    }
+  }
+  if (command === "serve") {
+    const host = takeFlag(args, "--host") || "127.0.0.1";
+    const port = Number(takeFlag(args, "--port") || "0");
+    const cardUrl = takeFlag(args, "--card-url");
+    const server = await startEdgeBookServer({ home, host, port, cardUrl });
+    console.log(`Edge Book server listening on ${serverAddress(server)}`);
+    await new Promise(() => void 0);
+  }
+  if (command === "dialout") {
+    const hostUrl = requireArg(takeFlag(args, "--host"), "--host");
+    const client = new EdgeBookDialoutClient({ home, host: hostUrl, socketFactory: ctx.socketFactory });
+    await client.start();
+    console.log(`Edge Book dial-out connected to ${hostUrl}`);
+    await new Promise(() => void 0);
+  }
+  if (command === "pair") {
+    const hostUrl = requireArg(takeFlag(args, "--host"), "--host");
+    const ttlMs = Number(takeFlag(args, "--ttl-ms") || `${5 * 60 * 1e3}`);
+    if (!ctx.textOnly) {
+      const client = new EdgeBookDialoutClient({ home, host: hostUrl, socketFactory: ctx.socketFactory, openLocalApi: false });
+      await client.start();
+      const registration2 = await client.pair(ttlMs);
+      console.log(`Pairing code: ${registration2.code}`);
+      console.log(`Expires in: ${ttlMs}ms`);
+      console.log("Edge Book dial-out remains connected; leave this process running during the hosted reader session.");
+      await new Promise(() => void 0);
+    }
+    const registration = await sendPairRegistration({ home, host: hostUrl, ttlMs, socketFactory: ctx.socketFactory });
+    return { text: `Pairing code: ${registration.code}
+Expires in: ${registration.frame.ttl_ms}ms`, json: registration };
+  }
+  if (command === "sessions") {
+    const action = args.shift();
+    if (action === "revoke") {
+      const hostUrl = requireArg(takeFlag(args, "--host"), "--host");
+      const frame = await sendSessionsRevoke({ home, host: hostUrl, socketFactory: ctx.socketFactory });
+      const channel = frame.channel_id || "unknown-channel";
+      return { text: `Received sessions_revoke_ok for request ${frame.request_id} on ${channel}`, json: frame };
+    }
+  }
+  if (command === "relay") {
+    const action = args.shift();
+    if (action === "serve") {
+      const host = takeFlag(args, "--host") || "127.0.0.1";
+      const port = Number(takeFlag(args, "--port") || "0");
+      const relayStore = requireArg(takeFlag(args, "--store"), "--store");
+      const server = await startRelayServer({ host, port, store: relayStore });
+      console.log(`Edge Book relay listening on ${serverAddress(server)}`);
+      await new Promise(() => void 0);
+    }
+  }
+  if (command === "harness") {
+    const action = args.shift();
+    if (action === "two-agent") {
+      const result = await runTwoAgentHarness();
+      return { text: `PASS two-agent harness
+${JSON.stringify(result, null, 2)}`, json: result };
+    }
+  }
+  throw new EdgeBookError("unknown_command", usage());
+}
+async function runCli(args) {
+  const result = await handleCli(args);
+  console.log(result.text);
+}
+function isCliEntrypoint() {
+  if (!process.argv[1]) return false;
+  return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+}
+if (isCliEntrypoint()) {
+  runCli(process.argv.slice(2)).catch((error) => {
+    console.error(error?.message ?? String(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  handleCli,
+  runCli
+};