@weaveprotocol/cli 0.1.0 → 0.1.1

package/dist/weave.mjs

@@ -6583,6 +6583,19 @@ function createEmitter() {
 
 // ../src/network/signaling.ts
 var SIGNAL_KINDS = /* @__PURE__ */ new Set(["offer", "answer", "candidate"]);
+function iceFrom(payload) {
+  const { servers, expiresAt } = payload ?? {};
+  if (!Array.isArray(servers) || typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) return null;
+  const kept = [];
+  for (const server of servers.slice(0, 4)) {
+    const urls = (Array.isArray(server?.urls) ? server.urls : [server?.urls]).filter(
+      (url) => typeof url === "string" && url.length < 256 && /^turns?:/.test(url)
+    );
+    if (urls.length === 0 || typeof server.username !== "string" || typeof server.credential !== "string") continue;
+    kept.push({ urls, username: server.username, credential: server.credential });
+  }
+  return kept.length > 0 ? { servers: kept, expiresAt } : null;
+}
 function createSignalingClient(url, did) {
   let ws = null;
   let connected = false;
@@ -6619,7 +6632,10 @@ function createSignalingClient(url, did) {
         try {
           const msg = JSON.parse(event.data);
           if (SIGNAL_KINDS.has(msg.type)) emit("signal", msg);
-          else if (typeof msg.room !== "string") return;
+          else if (msg.type === "ice") {
+            const offered2 = iceFrom(msg.payload);
+            if (offered2) emit("ice", offered2.servers, offered2.expiresAt);
+          } else if (typeof msg.room !== "string") return;
           else if (msg.type === "join") emit("peer-joined", msg.from, msg.room);
           else if (msg.type === "leave") emit("peer-left", msg.from, msg.room);
         } catch (err2) {
@@ -6675,6 +6691,7 @@ function createSignalingClient(url, did) {
       if (rooms.delete(room)) sendMessage({ type: "leave", room });
     },
     signal: (kind, targetDid, payload) => sendMessage({ type: kind, to: targetDid, payload }),
+    requestIce: () => sendMessage({ type: "ice" }),
     on,
     off,
     isConnected: () => connected
@@ -6690,6 +6707,7 @@ function createMultiSignalingClient(urls, did) {
   const { on, off, emit } = createEmitter();
   const routes = /* @__PURE__ */ new Map();
   const presence = /* @__PURE__ */ new Map();
+  const turn = /* @__PURE__ */ new Map();
   const connectedCount = () => clients.filter((client) => client.isConnected()).length;
   const remember = (peer, client) => {
     (routes.get(peer) ?? routes.set(peer, /* @__PURE__ */ new Set()).get(peer)).add(client);
@@ -6718,6 +6736,11 @@ function createMultiSignalingClient(urls, did) {
       remember(message.from, client);
       emit("signal", message);
     });
+    client.on("ice", (servers, expiresAt) => {
+      turn.set(client, { servers, expiresAt });
+      const offers = [...turn.values()];
+      emit("ice", offers.flatMap((offer) => offer.servers), Math.min(...offers.map((offer) => offer.expiresAt)));
+    });
     client.on("connected", () => {
       if (connectedCount() === 1) emit("connected");
     });
@@ -6740,6 +6763,7 @@ function createMultiSignalingClient(urls, did) {
       for (const client of clients) client.disconnect();
       routes.clear();
       presence.clear();
+      turn.clear();
     },
     join: (room) => {
       for (const client of clients) client.join(room);
@@ -6751,6 +6775,9 @@ function createMultiSignalingClient(urls, did) {
     signal: (kind, target, payload) => {
       for (const client of routesFor(target)) client.signal(kind, target, payload);
     },
+    requestIce: () => {
+      for (const client of clients) if (client.isConnected()) client.requestIce();
+    },
     on,
     off,
     isConnected: () => connectedCount() > 0
@@ -6806,7 +6833,8 @@ var DEFAULT_ICE_SERVERS = [
   { urls: "stun:stun1.l.google.com:19302" }
 ];
 function createRTCTransport(config) {
-  const iceServers = config?.iceServers ?? DEFAULT_ICE_SERVERS;
+  const configured = config?.iceServers ?? DEFAULT_ICE_SERVERS;
+  const iceServers = () => typeof configured === "function" ? configured() : configured;
   const connections = /* @__PURE__ */ new Map();
   const { on, off, emit } = createEmitter();
   const setupDataChannel = (peerId, channel) => {
@@ -6834,7 +6862,7 @@ function createRTCTransport(config) {
     if (connections.has(peerId)) {
       close(peerId);
     }
-    const connection = new RTCPeerConnection({ iceServers: [...iceServers] });
+    const connection = new RTCPeerConnection({ iceServers: [...iceServers()] });
     connections.set(peerId, { connection, channel: null });
     connection.onicecandidate = (event) => {
       if (event.candidate) onCandidate(event.candidate.toJSON());
@@ -7137,10 +7165,20 @@ function createWebSocketTransport(config) {
 }
 
 // ../src/network/mesh.ts
+var ICE_REFRESH_MS = 10 * 6e4;
+var ICE_WAIT_MS = 1500;
 function createMesh(config) {
   const { did } = config;
-  const transport = config.createTransport?.() ?? createRTCTransport({ iceServers: config.iceServers });
   const signaling = createMultiSignalingClient(config.relays, did);
+  const configuredIce = config.iceServers ?? DEFAULT_ICE_SERVERS;
+  let relayIce = null;
+  let iceAskedAt = 0;
+  signaling.on("ice", (servers, expiresAt) => {
+    relayIce = { servers, expiresAt };
+    iceAskedAt = 0;
+  });
+  const currentIce = () => relayIce && relayIce.expiresAt > Date.now() ? [...configuredIce, ...relayIce.servers] : configuredIce;
+  const transport = config.createTransport?.() ?? createRTCTransport({ iceServers: currentIce });
   const introduce = config.introductions !== false;
   const authTimeoutMs = config.authTimeoutMs ?? 1e4;
   const rooms = /* @__PURE__ */ new Map();
@@ -7341,6 +7379,23 @@ function createMesh(config) {
     return started;
   };
   return {
+    async iceServers() {
+      const stale = !relayIce || relayIce.expiresAt - Date.now() < ICE_REFRESH_MS;
+      if (signaling.isConnected() && stale && Date.now() - iceAskedAt > ICE_REFRESH_MS) {
+        iceAskedAt = Date.now();
+        await new Promise((resolve) => {
+          const done = () => {
+            clearTimeout(timer);
+            signaling.off("ice", done);
+            resolve();
+          };
+          const timer = setTimeout(done, ICE_WAIT_MS);
+          signaling.on("ice", done);
+          signaling.requestIce();
+        });
+      }
+      return currentIce();
+    },
     join(name, auth = null) {
       const room = { auth, peers: /* @__PURE__ */ new Map(), handshakes: /* @__PURE__ */ new Map(), events: createEmitter() };
       const send = (peer, message) => {
@@ -8156,6 +8211,13 @@ var writeCapability = (spaceId) => ({
   can: "expression/write"
 });
 var noteCid = (encoded) => cidFromBytes(utf8Encode(encoded));
+var NO_ACCOUNT = Object.freeze({ account: null, agent: false });
+var WHO_MESSAGE = "who";
+var LIVE_MESSAGE = "live";
+var MAX_LIVE_BYTES = 64 * 1024;
+var MAX_NOTE_LENGTH = 16 * 1024;
+var LIVE_BURST = 60;
+var LIVE_PER_SECOND = 20;
 var STANDS = { ok: true };
 function looksEncrypted(body) {
   const envelope = body;
@@ -8657,11 +8719,45 @@ async function openSpaceRuntime(deps) {
     }
   }
   const connectedPeers = () => [...new Set(networks.flatMap((network) => network.getPeers().map((peer) => peer.did)))];
+  const peerAccounts = /* @__PURE__ */ new Map();
+  const knownAccounts = /* @__PURE__ */ new Map();
+  const liveAllowance = /* @__PURE__ */ new Map();
+  async function accountOf(peer, note) {
+    if (typeof note !== "string" || note.length > MAX_NOTE_LENGTH) return NO_ACCOUNT;
+    const chain = await resolveDelegationRoot(note, () => null, provider).catch(() => null);
+    if (!chain?.valid || chain.audience !== peer || !chain.rootDid) return NO_ACCOUNT;
+    return { account: chain.rootDid, agent: isAgentNote(note) };
+  }
+  function withinAllowance(peer) {
+    const now = Date.now();
+    const held = liveAllowance.get(peer) ?? { tokens: LIVE_BURST, at: now };
+    const tokens = Math.min(LIVE_BURST, held.tokens + (now - held.at) / 1e3 * LIVE_PER_SECOND);
+    liveAllowance.set(peer, { tokens: Math.max(0, tokens - 1), at: now });
+    return tokens >= 1;
+  }
+  async function onLive(peer, payload) {
+    if (!withinAllowance(peer)) return;
+    if ((JSON.stringify(payload ?? null)?.length ?? 0) > MAX_LIVE_BYTES) return;
+    const { account, agent } = await peerAccounts.get(peer) ?? NO_ACCOUNT;
+    if (!routes.has(peer)) return;
+    emit({ type: "message", space: space2.id, from: account, peer, agent, message: payload });
+  }
   for (const network of networks) {
     network.on("message", (message) => {
       if (message.type === "sync") void sync.handleMessage(message.from, message.payload);
+      else if (message.type === WHO_MESSAGE) {
+        const note = message.payload?.note;
+        const checked = accountOf(message.from, note);
+        peerAccounts.set(message.from, checked);
+        void checked.then((known) => {
+          if (peerAccounts.get(message.from) !== checked) return;
+          knownAccounts.set(message.from, known);
+          emit({ type: "status", space: space2.id });
+        });
+      } else if (message.type === LIVE_MESSAGE) void onLive(message.from, message.payload);
     });
     network.on("peer-connected", (info) => {
+      network.send(info.did, { type: WHO_MESSAGE, from: session.did, payload: { note: session.proof() } });
       routes.set(info.did, network);
       sync.addPeer(info.did);
       sync.notifyPeers([info.did]);
@@ -8671,6 +8767,9 @@ async function openSpaceRuntime(deps) {
       if (routes.get(info.did) === network) {
         routes.delete(info.did);
         sync.removePeer(info.did);
+        peerAccounts.delete(info.did);
+        knownAccounts.delete(info.did);
+        liveAllowance.delete(info.did);
       }
       emit({ type: "status", space: space2.id });
     });
@@ -8681,10 +8780,16 @@ async function openSpaceRuntime(deps) {
   }
   if (networks.length > 0) {
     connection = "connecting";
-    void Promise.allSettled(networks.map((network) => network.connect())).then((results) => {
-      connection = results.some((result) => result.status === "fulfilled") ? "connected" : "error";
-      emit({ type: "status", space: space2.id });
-    });
+    void Promise.any(networks.map((network) => network.connect())).then(
+      () => {
+        connection = "connected";
+        emit({ type: "status", space: space2.id });
+      },
+      () => {
+        connection = "error";
+        emit({ type: "status", space: space2.id });
+      }
+    );
     sync.start();
   }
   let watchTimer = null;
@@ -9031,10 +9136,19 @@ async function openSpaceRuntime(deps) {
         space: space2.id,
         connection,
         peers: connectedPeers(),
+        accounts: Object.fromEntries([...knownAccounts].flatMap(([peer, known]) => known.account && routes.has(peer) ? [[peer, known.account]] : [])),
         root: await storage.getRootCid(),
         rejected
       };
     },
+    async send(message, to) {
+      const encoded = JSON.stringify(message ?? null);
+      if (encoded.length > MAX_LIVE_BYTES) throw new Error("A live message can be at most 64 KB");
+      for (const peer of connectedPeers()) {
+        if (to && to !== peer && (await peerAccounts.get(peer))?.account !== to) continue;
+        routes.get(peer)?.send(peer, { type: LIVE_MESSAGE, from: session.did, payload: message ?? null });
+      }
+    },
     async close() {
       if (watchTimer) clearInterval(watchTimer);
       if (announceTimer) clearTimeout(announceTimer);
@@ -9114,6 +9228,7 @@ async function createNode(config) {
   const registryStore = await config.stores("registry", { seal: true });
   const registry = createSpaceManager(registryStore, provider);
   const runtimes = /* @__PURE__ */ new Map();
+  const holds2 = /* @__PURE__ */ new Map();
   const account = config.accountKey ? await deriveAccountRegistry(config.accountKey, config.signer.did, provider) : null;
   const accountSpaceId = account?.space.id ?? null;
   async function findRecord(spaceId) {
@@ -9224,6 +9339,7 @@ async function createNode(config) {
     }
   }
   async function closeRuntime(spaceId) {
+    holds2.delete(spaceId);
     const open2 = runtimes.get(spaceId);
     if (!open2) return;
     runtimes.delete(spaceId);
@@ -9406,10 +9522,28 @@ async function createNode(config) {
       await registry.remove(spaceId);
       emit({ type: "spaces" });
     },
-    async open(spaceId) {
-      await runtime(spaceId);
+    async hold(spaceId) {
+      const held = holds2.get(spaceId) ?? holds2.set(spaceId, { count: 0 }).get(spaceId);
+      held.count += 1;
+      let released = false;
+      const release = async () => {
+        if (released) return;
+        released = true;
+        if (holds2.get(spaceId) !== held) return;
+        held.count -= 1;
+        if (held.count === 0) await closeRuntime(spaceId);
+      };
+      try {
+        await runtime(spaceId);
+      } catch (error) {
+        await release();
+        throw error;
+      }
+      return release;
+    },
+    async send(spaceId, message, to) {
+      await (await runtime(spaceId)).send(message, to);
     },
-    close: closeRuntime,
     async status(spaceId) {
       const status = await (await runtime(spaceId)).status();
       if (!accountSpaceId) return { ...status, own: [], carriers: [] };
@@ -9618,9 +9752,11 @@ async function createNode(config) {
       closeInvite: person("close invites"),
       revoke: person("revoke notes"),
       access: async (spaceId) => (inside(spaceId), spaces.access(spaceId)),
-      open: async (spaceId) => (inside(spaceId), spaces.open(spaceId)),
+      hold: async (spaceId) => (inside(spaceId), spaces.hold(spaceId)),
       status: async (spaceId) => (inside(spaceId), spaces.status(spaceId)),
       profiles: async (spaceId) => (inside(spaceId), spaces.profiles(spaceId)),
+      // It would arrive as the person: a live message carries no note of its own to say "via agent".
+      send: person("send live messages"),
       authenticator: async () => null
     });
     const agentRecords = Object.freeze({
@@ -9670,6 +9806,7 @@ async function createNode(config) {
       account: Object.freeze({ profile: accountApi.profile, setName: person("rename the account"), revoke: person("revoke notes") }),
       carriers: Object.freeze({ list: carriers.list, add: person("add a carrier"), remove: person("remove a carrier") }),
       delegation: () => note,
+      iceServers: node.iceServers,
       delegate: person("pass its access on"),
       asAgent: person("start another agent"),
       subscribe: (listener) => node.subscribe((event) => {
@@ -9690,6 +9827,7 @@ async function createNode(config) {
     carriers,
     asAgent,
     delegation: () => current,
+    iceServers: async () => mesh ? mesh.iceServers() : config.network?.iceServers ?? DEFAULT_ICE_SERVERS,
     async delegate(params) {
       const token = await delegateCapabilities(
         {
@@ -10700,6 +10838,7 @@ async function serve(options) {
     res.writeHead(426, { "content-type": "text/plain" });
     res.end("This endpoint speaks WebSocket only.\n");
   });
+  const served = /* @__PURE__ */ new Set();
   const onPeer = async (socket, url) => {
     const spaceId = url.searchParams.get("space");
     if (!spaceId) {
@@ -10721,7 +10860,10 @@ async function serve(options) {
           socket.close(4003, "not a reader of this space");
           return;
         }
-        await node.spaces.open(spaceId);
+        if (!served.has(spaceId)) {
+          await node.spaces.hold(spaceId);
+          served.add(spaceId);
+        }
         const sig = await authenticator.welcome(node.sessionDid, hello.nonce);
         socket.send(JSON.stringify({ type: "welcome", did: node.sessionDid, sig }));
         inbound.accept(spaceId, socket, hello.did);
@@ -10771,18 +10913,17 @@ async function startDaemon(options) {
       ...options.nodes?.length ? { nodes: options.nodes } : {}
     }
   });
-  const open2 = /* @__PURE__ */ new Set();
+  const open2 = /* @__PURE__ */ new Map();
   const rescan = async () => {
     const held = new Set((await node.spaces.list()).map((space2) => space2.id));
     for (const id of held) {
       if (open2.has(id)) continue;
-      await node.spaces.open(id);
-      open2.add(id);
+      open2.set(id, await node.spaces.hold(id));
       log(`serving space ${id}`);
     }
-    for (const id of [...open2]) {
+    for (const [id, release] of [...open2]) {
       if (held.has(id)) continue;
-      await node.spaces.close(id);
+      await release();
       open2.delete(id);
       log(`stopped serving space ${id}`);
     }
@@ -11145,7 +11286,7 @@ async function startAgentNode(home, options = {}) {
   for (const space2 of grant.spaces) if (!held.has(space2.id)) await base.spaces.join(space2.invite).catch(() => {
   });
   const node = await base.asAgent({ keys: key2.keys, note: grant.token });
-  for (const space2 of await node.spaces.list()) void node.spaces.open(space2.id).catch(() => {
+  for (const space2 of await node.spaces.list()) void node.spaces.hold(space2.id).catch(() => {
   });
   return {
     node,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weaveprotocol/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The Weave protocol from a terminal: manage spaces, run an always-on node, serve MCP to agents",
   "type": "module",
   "bin": {