@uuaid/pillar 0.2.0-alpha.6 → 0.2.0-alpha.7

package/bin/pillar.mjs

@@ -3,6 +3,7 @@
  * pillar — one-command CLI.
  *
  *   pillar init  [--home ~/.pillar]              first-time setup: mint UUAID + keys
+ *   pillar init --refresh [--directory URL]      re-sync carriers + address book (keychain untouched)
  *   pillar id    [--home ~/.pillar]              print our UUAID + PeerId + addrs
  *   pillar send  <recipient> <kind> <json>       send a signed envelope
  *   pillar recv  [--home ~/.pillar] [--follow]   listen for envelopes and print them
@@ -89,9 +90,77 @@ function writeRuntimeFile(pillar, home) {
   writeFileSync(join(home, "runtime.json"), JSON.stringify(rt, null, 2));
 }
 
+// Carrier list + address book merge from a fetched directory — shared by
+// `init --directory` (first contact) and `init --refresh` (re-sync without
+// touching the keychain).
+function carriersFromDirectory(d) {
+  return [d.carrier, ...(Array.isArray(d.seeds) ? d.seeds.map((s) => s.url) : [])].filter(Boolean);
+}
+
+function mergeDirectoryAgents(home, d) {
+  if (!Array.isArray(d.agents)) return null;
+  const fleetPath = join(home, "fleet.json");
+  const prev = existsSync(fleetPath) ? JSON.parse(readFileSync(fleetPath, "utf-8")).fleet ?? {} : {};
+  const fleet = { ...prev };
+  let added = 0;
+  for (const a of d.agents) {
+    if (!a.uuaid || !a.publicKey) continue;
+    const key = typeof a.role === "string" && a.role ? a.role : a.uuaid;
+    fleet[key] = {
+      uuaid: a.uuaid,
+      publicKey: a.publicKey,
+      ...(prev[key]?.addrs ? { addrs: prev[key].addrs } : {}),
+      ...(prev[key]?.peerId ? { peerId: prev[key].peerId } : {}),
+    };
+    if (!prev[key]) added++;
+  }
+  writeFileSync(fleetPath, JSON.stringify({ fleet }, null, 2));
+  return { count: Object.keys(fleet).length, added };
+}
+
+async function fetchDirectory(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    console.error(`directory fetch failed: ${url} -> ${res.status}`);
+    exit(1);
+  }
+  return res.json();
+}
+
 async function cmdInit(args) {
   const home = homePath(args);
   mkdirSync(home, { recursive: true });
+
+  // --refresh re-syncs carriers + address book from a directory WITHOUT
+  // touching the keychain (init --force would mint a NEW identity and break
+  // every enrolled sender).  Requires an existing identity.
+  if (args.refresh) {
+    const kcPath = join(home, "keychain.json");
+    if (!existsSync(kcPath)) {
+      console.error(`refresh: no keychain at ${kcPath} — run pillar init first (refresh never mints keys)`);
+      exit(1);
+    }
+    if (typeof args.directory !== "string") {
+      console.error("refresh: --directory <url> is required");
+      exit(1);
+    }
+    const d = await fetchDirectory(args.directory);
+    const list = carriersFromDirectory(d);
+    if (!list.length) {
+      console.error(`refresh: directory ${args.directory} lists no carrier and no seeds`);
+      exit(1);
+    }
+    const cfgPath = join(home, "config.json");
+    const cfg = existsSync(cfgPath) ? JSON.parse(readFileSync(cfgPath, "utf-8")) : {};
+    cfg.carriers = list;
+    writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+    console.log(`carriers refreshed from ${args.directory}: ${list.join(", ")}`);
+    const ab = mergeDirectoryAgents(home, d);
+    if (ab) console.log(`address book: ${ab.count} peers in ${join(home, "fleet.json")} (${ab.added} new from directory)`);
+    console.log(`refresh complete at ${home} (keychain untouched)`);
+    return;
+  }
+
   const kcPath = join(home, "keychain.json");
   if (existsSync(kcPath) && !args.force) {
     console.error(`keychain already exists at ${kcPath}. use --force to overwrite.`);
@@ -110,13 +179,8 @@ async function cmdInit(args) {
   // the primary carrier plus every seeds[] entry as carriers (the LimeWire
   // seed model — poll all, replicate to all); --carriers sets them directly.
   if (typeof args.directory === "string") {
-    const res = await fetch(args.directory);
-    if (!res.ok) {
-      console.error(`init: directory fetch failed: ${args.directory} -> ${res.status}`);
-      exit(1);
-    }
-    const d = await res.json();
-    const list = [d.carrier, ...(Array.isArray(d.seeds) ? d.seeds.map(s => s.url) : [])].filter(Boolean);
+    const d = await fetchDirectory(args.directory);
+    const list = carriersFromDirectory(d);
     if (!list.length) {
       console.error(`init: directory ${args.directory} lists no carrier and no seeds`);
       exit(1);
@@ -126,25 +190,8 @@ async function cmdInit(args) {
     // Seed the address book from the directory's agents[] so a fresh agent can
     // `pillar ask`/`pillar send` with zero key plumbing (keys required for E2E).
     // Merge — never clobber a hand-curated fleet.json.
-    if (Array.isArray(d.agents)) {
-      const fleetPath = join(home, "fleet.json");
-      const prev = existsSync(fleetPath) ? JSON.parse(readFileSync(fleetPath, "utf-8")).fleet ?? {} : {};
-      const fleet = { ...prev };
-      let added = 0;
-      for (const a of d.agents) {
-        if (!a.uuaid || !a.publicKey) continue;
-        const key = typeof a.role === "string" && a.role ? a.role : a.uuaid;
-        fleet[key] = {
-          uuaid: a.uuaid,
-          publicKey: a.publicKey,
-          ...(prev[key]?.addrs ? { addrs: prev[key].addrs } : {}),
-          ...(prev[key]?.peerId ? { peerId: prev[key].peerId } : {}),
-        };
-        if (!prev[key]) added++;
-      }
-      writeFileSync(fleetPath, JSON.stringify({ fleet }, null, 2));
-      console.log(`address book: ${Object.keys(fleet).length} peers in ${fleetPath} (${added} new from directory)`);
-    }
+    const ab = mergeDirectoryAgents(home, d);
+    if (ab) console.log(`address book: ${ab.count} peers in ${join(home, "fleet.json")} (${ab.added} new from directory)`);
   } else if (args.carriers) {
     cfg.carriers = args.carriers.split(",").map(s => s.trim()).filter(Boolean);
   }
@@ -238,6 +285,19 @@ async function cmdGroups(args) {
   }
 }
 
+// Extract human-readable text from a zestro command_result. The server-side
+// payload fields are unverified — defensively try the common shapes, cap at
+// 8192 bytes (pillar-responder's MAX_REPLY_BYTES convention).
+function replyTextFromResult(result) {
+  const text = result?.text ?? result?.result ?? result?.output ?? result?.response ?? result?.message;
+  if (typeof text === "string" && text.trim()) return text.slice(0, 8192);
+  if (typeof text !== "string" && text !== undefined && text !== null) {
+    const s = JSON.stringify(text);
+    if (s) return s.slice(0, 8192);
+  }
+  return JSON.stringify(result ?? {}).slice(0, 8192);
+}
+
 async function cmdRecv(args) {
   const p = loadPillar(args);
   await p.start();
@@ -273,14 +333,37 @@ async function cmdRecv(args) {
     const line = { at: new Date().toISOString(), from: env.sender, kind: env.kind, payload: env.payload };
     if (env.payload?._group?.name) line.group = env.payload._group.name;
     console.log(JSON.stringify(line));
-    if (bridge) {
+    if (bridge && env.kind === "request") {
+      // Interaction-convention return leg: ack FIRST — pillar-ask allows 120s
+      // per phase but ZestroBridge times out at 30s, so the ack goes out before
+      // the bridged agent turn starts. Then reply with the turn's result text,
+      // or status:"pending" on bridge timeout (command queued, turn running),
+      // or status:"error" with the bridge failure as reason.
+      const thread = env.payload?.thread ?? env.id;
+      const senderKey = env.transportSignature.publicKey; // open() F1: sender derives from this key
       try {
+        await p.send({ recipient: env.sender, recipientPublicKey: senderKey, kind: "ack", payload: { inReplyTo: env.id } });
         const result = await bridge.sendCommand({ command: JSON.stringify({ kind: env.kind, payload: env.payload, sender: env.sender }) });
-        console.log(`  → zestro result: ${JSON.stringify(result).slice(0, 200)}`);
+        const text = replyTextFromResult(result);
+        await p.send({ recipient: env.sender, recipientPublicKey: senderKey, kind: "reply", payload: { thread, inReplyTo: env.id, status: "ok", text } });
+        console.log(`  → zestro reply sent (${text.length} bytes)`);
       } catch (e) {
         // command_result only arrives when the target agent's TURN completes —
         // a busy agent (long turn) exceeds any sane timeout while the command
         // is already queued in its tab. Timeout = accepted-unconfirmed, not failure.
+        if (/timed out/.test(e.message)) {
+          console.log(`  → zestro: queued (command_result pending — agent busy)`);
+          await p.send({ recipient: env.sender, recipientPublicKey: senderKey, kind: "reply", payload: { thread, inReplyTo: env.id, status: "pending", text: "request forwarded to zestro agent — turn still running" } });
+        } else {
+          console.error(`  → zestro bridge error: ${e.message}`);
+          await p.send({ recipient: env.sender, recipientPublicKey: senderKey, kind: "reply", payload: { thread, inReplyTo: env.id, status: "error", reason: e.message.slice(0, 300), text: `zestro bridge error: ${e.message.slice(0, 300)}` } });
+        }
+      }
+    } else if (bridge) {
+      try {
+        const result = await bridge.sendCommand({ command: JSON.stringify({ kind: env.kind, payload: env.payload, sender: env.sender }) });
+        console.log(`  → zestro result: ${JSON.stringify(result).slice(0, 200)}`);
+      } catch (e) {
         if (/timed out/.test(e.message)) {
           console.log(`  → zestro: queued (command_result pending — agent busy)`);
         } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uuaid/pillar",
-  "version": "0.2.0-alpha.6",
+  "version": "0.2.0-alpha.7",
   "description": "IAASO-3050 reference implementation. Every agent runs its own PDP pillar, discovers peers via a Kademlia DHT, and exchanges cryptographically signed + Noise-encrypted messages over libp2p. One command to install and join the network.",
   "license": "Apache-2.0",
   "type": "module",
@@ -56,4 +56,4 @@
     "uint8arrays": "^5.1.1",
     "ws": "^8.21.3"
   }
-}
+}