@wacando/agent 2.0.2 → 2.2.0

package/packages/runtime/runtime.mjs

@@ -1,7 +1,9 @@
 import { OnboardingService } from '../onboarding/service.mjs';
-import { CredentialStore, SafeError } from '../onboarding/storage.mjs';
+import { join } from 'node:path';
+import { CredentialStore, digest, SafeError } from '../onboarding/storage.mjs';
 import { configuredOrigin, get, post } from '../onboarding/network.mjs';
 import { ConversationClient } from './conversations.mjs';
+import { FileTransfers, FileVault, uploadPin } from './files.mjs';
 import { claim, pairingErrors, redeem } from './pairing.mjs';
 
 const BUFFER_LIMIT = 200;
@@ -27,10 +29,16 @@ export function publicIdentity(agent, state) {
  * and stop on revocation.
  */
 export class AgentRuntime {
-  constructor({ host = 'cli', origin, store = new CredentialStore(), report, request, connect, onStanza } = {}) {
+  /**
+   * `files`: `{ uploadOrigin, quarantineDir }` (defaults: WACANDO_UPLOAD_ORIGIN
+   * or the API origin; WACANDO_QUARANTINE_DIR or a directory inside the
+   * protected runtime state) plus test hooks (`now`, `sleep`, `pollMs`, `fetch`).
+   */
+  constructor({ host = 'cli', origin, store = new CredentialStore(), report, request, connect, onStanza, files = {} } = {}) {
     if (!/^[a-z0-9][a-z0-9_-]{0,31}$/.test(host)) throw new SafeError('Invalid runtime host name.');
     this.host = host;
     this.originSetting = origin;
+    this.fileOptions = files;
     this.store = store;
     this.listeners = new Set();
     this.clients = new Map();
@@ -120,7 +128,8 @@ export class AgentRuntime {
     let client = this.clients.get(agent.agentId);
     if (client && client.session !== session) this.rebind(agent.agentId, session);
     if (!client) {
-      client = new ConversationClient({ runtime: this, agent, session });
+      const files = await this.fileTransfersFor(agent);
+      client = new ConversationClient({ runtime: this, agent, session, files });
       this.clients.set(agent.agentId, client);
       for (const stanza of this.buffered.get(agent.agentId) ?? []) client.handle(stanza);
       this.buffered.delete(agent.agentId);
@@ -191,6 +200,15 @@ export class AgentRuntime {
     return { paired: true, ...publicIdentity(agent) };
   }
 
+  /** File transfer state of one identity: private directories, pinned upload origin. */
+  async fileTransfersFor(agent) {
+    const { uploadOrigin, quarantineDir = process.env.WACANDO_QUARANTINE_DIR, ...hooks } = this.fileOptions;
+    const pin = uploadPin(agent.origin, uploadOrigin ?? process.env.WACANDO_UPLOAD_ORIGIN);
+    const base = join(await this.store.directory(agent.origin, this.host), `files-${digest(agent.agentId)}`);
+    const vault = new FileVault(base, quarantineDir ? join(quarantineDir, digest(`${agent.origin}\n${agent.agentId}`).slice(0, 32)) : undefined);
+    return client => new FileTransfers(client, { vault, pin, ...hooks });
+  }
+
   /** Subscribe to every stanza of every connected identity. Returns an unsubscribe function. */
   onStanza(listener) {
     this.listeners.add(listener);

package/packages/runtime/session.mjs

@@ -1,5 +1,5 @@
 import { client } from '@xmpp/client';
-import { announceAvailable, refuseSubscriptionRequests, xml } from '@wacando/xmpp';
+import { announceAvailable, refuseSubscriptionRequests, xml } from '#wacando/xmpp';
 import { SafeError } from '../onboarding/storage.mjs';
 import { loadDevice } from './device.mjs';
 

package/packages/wacando/chunks/chunk-53E7SSTF.mjs

@@ -0,0 +1,423 @@
+// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+import {
+  XMPP_DOMAIN
+} from "./chunk-PZDQXGA6.mjs";
+
+// packages/xmpp/src/muc.ts
+import xml from "@xmpp/xml";
+
+// packages/xmpp/src/jid.ts
+var COMPONENT_JID = `policy.${XMPP_DOMAIN}`;
+function occupantJid(room, nick) {
+  if (nick.length === 0) {
+    throw new Error("occupant nick must not be empty");
+  }
+  return `${room}/${nick}`;
+}
+
+// packages/xmpp/src/timeouts.ts
+var BASE_TIMEOUT_MS = 1e4;
+var scale = 1;
+function scaledTimeoutMs(ms) {
+  return Math.round(ms * scale);
+}
+function defaultTimeoutMs() {
+  return scaledTimeoutMs(BASE_TIMEOUT_MS);
+}
+
+// packages/xmpp/src/stanza.ts
+var StanzaWaitError = class extends Error {
+  constructor(reason, message, stanza) {
+    super(message);
+    this.reason = reason;
+    this.stanza = stanza;
+    this.name = "StanzaWaitError";
+  }
+  reason;
+  stanza;
+};
+function waitForElement(entity, event, predicate, timeoutMs = defaultTimeoutMs()) {
+  return new Promise((resolve, reject) => {
+    const seen = [];
+    const timer = setTimeout(() => {
+      cleanup();
+      const trail = seen.length ? `; last seen: ${seen.join(", ")}` : "; nothing arrived";
+      const status = entity.status;
+      const state = typeof status === "string" ? `; entity status: ${status}` : "";
+      reject(
+        new StanzaWaitError(
+          "timeout",
+          `no matching ${event} within ${timeoutMs}ms${trail}${state}`
+        )
+      );
+    }, timeoutMs);
+    const onElement = (el) => {
+      seen.push(describeElement(el));
+      if (seen.length > 8) seen.shift();
+      try {
+        if (predicate(el)) {
+          cleanup();
+          resolve(el);
+        }
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      entity.off(event, onElement);
+    };
+    entity.on(event, onElement);
+  });
+}
+function waitForStanza(entity, predicate, timeoutMs = defaultTimeoutMs()) {
+  return waitForElement(entity, "stanza", predicate, timeoutMs);
+}
+function describeElement(el) {
+  const type = el.getAttr("type");
+  const from = el.getAttr("from");
+  const error = type === "error" ? ` error=${stanzaErrorCondition(el)}` : "";
+  return `<${el.name}${type ? ` type=${type}` : ""}${from ? ` from=${from}` : ""}${error}>`;
+}
+function stanzaErrorCondition(stanza) {
+  const error = stanza.getChild("error");
+  const condition = error?.children.find((c) => typeof c !== "string");
+  return condition?.getName() ?? "unknown";
+}
+
+// packages/xmpp/src/muc.ts
+var NS_MUC = "http://jabber.org/protocol/muc";
+var NS_MUC_USER = `${NS_MUC}#user`;
+var NS_MUC_ADMIN = `${NS_MUC}#admin`;
+var NS_MUC_OWNER = `${NS_MUC}#owner`;
+var NS_DATA_FORMS = "jabber:x:data";
+var MucError = class extends Error {
+  constructor(message, condition = "unknown", stanza) {
+    super(message);
+    this.condition = condition;
+    this.stanza = stanza;
+    this.name = "MucError";
+  }
+  condition;
+  stanza;
+};
+var MucJoinError = class extends MucError {
+  constructor(condition, stanza, room, nick) {
+    super(`join denied for ${occupantJid(room, nick)}: ${condition}`, condition, stanza);
+    this.room = room;
+    this.nick = nick;
+    this.name = "MucJoinError";
+  }
+  room;
+  nick;
+};
+function joinPresenceEl(room, nick) {
+  return xml("presence", { to: occupantJid(room, nick) }, xml("x", { xmlns: NS_MUC }));
+}
+async function joinRoom(entity, room, nick, timeoutMs = defaultTimeoutMs()) {
+  const self = occupantJid(room, nick);
+  const wait = waitForStanza(
+    entity,
+    (s) => s.is("presence") && s.getAttr("from") === self,
+    timeoutMs
+  );
+  try {
+    await entity.send(joinPresenceEl(room, nick));
+  } catch (err) {
+    void wait.catch(() => {
+    });
+    throw err;
+  }
+  const presence = await wait;
+  if (presence.getAttr("type") === "error") {
+    throw new MucJoinError(stanzaErrorCondition(presence), presence, room, nick);
+  }
+  return presence;
+}
+
+// packages/xmpp/src/origin.ts
+import { jid } from "@xmpp/jid";
+var NS_MUC_USER2 = "http://jabber.org/protocol/muc#user";
+var NS_FORWARD = "urn:xmpp:forward:0";
+var NS_WACANDO_POLICY = "urn:wacando:policy:0";
+var origins = /* @__PURE__ */ new WeakMap();
+function authenticatedMessageOrigin(stanza) {
+  return origins.get(stanza);
+}
+function itemJid(stanza) {
+  const xs = stanza.getChildren("x", NS_MUC_USER2);
+  if (xs.length !== 1) return;
+  const items = xs[0]?.getChildren("item");
+  if (items?.length !== 1) return;
+  const value = items[0]?.getAttr("jid");
+  return typeof value === "string" ? value : void 0;
+}
+function userBareJid(value) {
+  if (value === void 0) return;
+  try {
+    const parsed = jid(value);
+    return parsed.getLocal() ? parsed.bare().toString() : void 0;
+  } catch {
+    return;
+  }
+}
+function isTrustedRelay(value, trustedRelayJid) {
+  if (value === void 0 || trustedRelayJid === void 0) return false;
+  try {
+    const parsed = jid(value);
+    return !parsed.getLocal() && parsed.getDomain() === trustedRelayJid;
+  } catch {
+    return false;
+  }
+}
+function relaySender(stanza) {
+  const relays = stanza.getChildren("relay", NS_WACANDO_POLICY);
+  if (relays.length !== 1) return;
+  return userBareJid(relays[0]?.getAttr("jid"));
+}
+function recordMamOrigin(stanza, room, trustedRelayJid) {
+  if (!stanza.is("message") || stanza.getAttr("type") !== "groupchat" || !stanza.getAttr("from")?.startsWith(`${room}/`))
+    return;
+  const item = itemJid(stanza);
+  const senderBareJid = isTrustedRelay(item, trustedRelayJid) ? relaySender(stanza) : userBareJid(item);
+  if (senderBareJid) origins.set(stanza, { roomJid: room, senderBareJid });
+}
+function unwrapPolicyDelivery(stanza, policyJid) {
+  if (!stanza.is("message") || stanza.getAttr("type") === "error") return;
+  const from = stanza.getAttr("from");
+  if (typeof from !== "string" || !isTrustedRelay(from, policyJid)) return;
+  const deliveries = stanza.getChildren("delivery", NS_WACANDO_POLICY);
+  if (deliveries.length !== 1) return;
+  const delivery = deliveries[0];
+  const room = delivery?.getAttr("room");
+  const senderBareJid = userBareJid(delivery?.getAttr("sender"));
+  const inner = delivery?.getChild("forwarded", NS_FORWARD)?.getChild("message");
+  if (typeof room !== "string" || !senderBareJid || !inner) return;
+  if (inner.getAttr("type") !== "groupchat" || !inner.getAttr("from")?.startsWith(`${room}/`))
+    return;
+  origins.set(inner, { roomJid: room, senderBareJid });
+  return inner;
+}
+var MucOriginTracker = class {
+  /**
+   * `trustedRelayJid`: the policy component domain. When set, groupchat from
+   * an occupant whose real JID is exactly that domain is attributed to its
+   * `<relay jid>` (#39). Without it, relays carry no origin (fail closed).
+   */
+  constructor(entity, options = {}) {
+    this.entity = entity;
+    this.options = options;
+    entity.on("stanza", this.onStanza);
+    entity.on("offline", this.reset);
+    entity.on("disconnect", this.reset);
+  }
+  entity;
+  options;
+  rooms = /* @__PURE__ */ new Set();
+  occupants = /* @__PURE__ */ new Map();
+  /** Occupant full JIDs whose authenticated real JID is the policy component. */
+  relays = /* @__PURE__ */ new Set();
+  trackRoom(room) {
+    this.rooms.add(room);
+  }
+  reset = () => {
+    this.occupants.clear();
+    this.relays.clear();
+  };
+  onStanza = (stanza) => {
+    const from = stanza.getAttr("from");
+    if (typeof from !== "string") return;
+    const slash = from.indexOf("/");
+    if (slash < 1 || !this.rooms.has(from.slice(0, slash))) return;
+    if (stanza.is("presence")) {
+      const type = stanza.getAttr("type");
+      if (type === "unavailable" || type === "error") {
+        this.occupants.delete(from);
+        this.relays.delete(from);
+        if (stanza.getChild("x", NS_MUC_USER2)?.getChildren("status").some((s) => s.getAttr("code") === "110")) {
+          const prefix = `${from.slice(0, slash)}/`;
+          for (const occupant of this.occupants.keys()) {
+            if (occupant.startsWith(prefix)) this.occupants.delete(occupant);
+          }
+          for (const relay of [...this.relays]) {
+            if (relay.startsWith(prefix)) this.relays.delete(relay);
+          }
+        }
+      } else if (!type) {
+        const item = itemJid(stanza);
+        const sender = userBareJid(item);
+        if (sender) this.occupants.set(from, sender);
+        else this.occupants.delete(from);
+        if (isTrustedRelay(item, this.options.trustedRelayJid)) this.relays.add(from);
+        else this.relays.delete(from);
+      }
+    } else if (stanza.is("message") && stanza.getAttr("type") === "groupchat" && !stanza.getChild("delay", "urn:xmpp:delay")) {
+      const senderBareJid = this.relays.has(from) ? relaySender(stanza) : this.occupants.get(from);
+      if (senderBareJid) origins.set(stanza, { roomJid: from.slice(0, slash), senderBareJid });
+    }
+  };
+  close() {
+    this.entity.off("stanza", this.onStanza);
+    this.entity.off("offline", this.reset);
+    this.entity.off("disconnect", this.reset);
+    this.reset();
+  }
+};
+
+// packages/xmpp/src/mam.ts
+import xml2 from "@xmpp/xml";
+var NS_MAM = "urn:xmpp:mam:2";
+var NS_FORWARD2 = "urn:xmpp:forward:0";
+var NS_RSM = "http://jabber.org/protocol/rsm";
+var queryCounter = 0;
+function filterField(varName, value) {
+  return xml2("field", { var: varName }, xml2("value", {}, value));
+}
+function mamQueryEl(options) {
+  const fields = [xml2("field", { var: "FORM_TYPE", type: "hidden" }, xml2("value", {}, NS_MAM))];
+  if (options.withJid !== void 0) fields.push(filterField("with", options.withJid));
+  if (options.start !== void 0) fields.push(filterField("start", options.start));
+  if (options.end !== void 0) fields.push(filterField("end", options.end));
+  const children = [xml2("x", { xmlns: NS_DATA_FORMS, type: "submit" }, ...fields)];
+  if (options.max !== void 0) {
+    children.push(xml2("set", { xmlns: NS_RSM }, xml2("max", {}, String(options.max))));
+  }
+  return xml2("query", { xmlns: NS_MAM, queryid: options.queryId }, ...children);
+}
+async function queryMam(entity, options, timeoutMs = defaultTimeoutMs()) {
+  const queryId = options.queryId ?? `mam${++queryCounter}`;
+  const forwarded = [];
+  const onStanza = (stanza) => {
+    if (!stanza.is("message") || stanza.getAttr("from") !== options.to) return;
+    const result = stanza.getChild("result", NS_MAM);
+    if (!result || result.getAttr("queryid") !== queryId) return;
+    const fwd = result.getChild("forwarded", NS_FORWARD2);
+    if (fwd) {
+      const inner = forwardedStanza(fwd);
+      if (inner) recordMamOrigin(inner, options.to, options.trustedRelayJid);
+      forwarded.push(fwd);
+    }
+  };
+  entity.on("stanza", onStanza);
+  try {
+    const response = await entity.iqCaller.set(
+      mamQueryEl({ ...options, queryId }),
+      options.to,
+      timeoutMs
+    );
+    const fin = response?.getChild("fin", NS_MAM);
+    const rsmLast = fin?.getChild("set", NS_RSM)?.getChildText("last");
+    return {
+      queryId,
+      complete: fin?.getAttr("complete") === "true",
+      lastId: typeof rsmLast === "string" ? rsmLast : void 0,
+      messages: forwarded
+    };
+  } finally {
+    entity.off("stanza", onStanza);
+  }
+}
+function forwardedStanza(forwarded) {
+  return forwarded.children.find(
+    (c) => typeof c !== "string" && c.getName() !== "delay"
+  );
+}
+
+// packages/xmpp/src/roster.ts
+import { jid as parseJid } from "@xmpp/jid";
+import xml3 from "@xmpp/xml";
+function subscriptionRefusal(stanza) {
+  if (!stanza.is("presence") || stanza.getAttr("type") !== "subscribe") return null;
+  const from = stanza.getAttr("from");
+  if (typeof from !== "string" || from === "") return null;
+  let bare;
+  try {
+    bare = parseJid(from).bare().toString();
+  } catch {
+    return null;
+  }
+  return xml3("presence", { to: bare, type: "unsubscribed" });
+}
+function refuseSubscriptionRequests(entity) {
+  const onStanza = (stanza) => {
+    const refusal = subscriptionRefusal(stanza);
+    if (refusal) void entity.send(refusal).catch(() => {
+    });
+  };
+  entity.on("stanza", onStanza);
+  return () => entity.off("stanza", onStanza);
+}
+
+// packages/xmpp/src/presence.ts
+var UNKNOWN_PRESENCE = Object.freeze({
+  connection: "unknown",
+  availability: null
+});
+
+// packages/xmpp/src/pubsub.ts
+import xml4 from "@xmpp/xml";
+var NS_PUBSUB = "http://jabber.org/protocol/pubsub";
+var NS_PUBSUB_PUBLISH_OPTIONS = "http://jabber.org/protocol/pubsub#publish-options";
+function pepPublishEl(node, itemId, payload, accessModel = "open") {
+  return xml4(
+    "pubsub",
+    { xmlns: NS_PUBSUB },
+    xml4("publish", { node }, xml4("item", { id: itemId }, payload)),
+    xml4(
+      "publish-options",
+      {},
+      xml4(
+        "x",
+        { xmlns: NS_DATA_FORMS, type: "submit" },
+        xml4(
+          "field",
+          { var: "FORM_TYPE", type: "hidden" },
+          xml4("value", {}, NS_PUBSUB_PUBLISH_OPTIONS)
+        ),
+        xml4("field", { var: "pubsub#access_model" }, xml4("value", {}, accessModel))
+      )
+    )
+  );
+}
+function pubsubItemsEl(node, maxItems) {
+  const attrs = { node };
+  if (maxItems !== void 0) attrs.max_items = String(maxItems);
+  return xml4("pubsub", { xmlns: NS_PUBSUB }, xml4("items", attrs));
+}
+async function pepPublish(entity, to, node, itemId, payload, timeoutMs = defaultTimeoutMs()) {
+  await entity.iqCaller.set(pepPublishEl(node, itemId, payload), to, timeoutMs);
+}
+async function pepFetchItems(entity, to, node, timeoutMs = defaultTimeoutMs()) {
+  try {
+    const result = await entity.iqCaller.get(pubsubItemsEl(node), to, timeoutMs);
+    const pubsub = result?.getName() === "pubsub" ? result : result?.getChild("pubsub", NS_PUBSUB);
+    const items = pubsub?.getChild("items");
+    if (!items) return [];
+    return items.getChildren("item").map((item) => item.children.find((c) => typeof c !== "string")).filter((el) => el !== void 0);
+  } catch (err) {
+    if (isItemNotFound(err)) return [];
+    throw err;
+  }
+}
+function isItemNotFound(err) {
+  const cond = err?.condition;
+  if (cond === "item-not-found") return true;
+  const stanza = err?.stanza;
+  return stanza?.getChild("error")?.getChild("item-not-found") !== void 0;
+}
+
+export {
+  defaultTimeoutMs,
+  waitForStanza,
+  MucJoinError,
+  joinRoom,
+  authenticatedMessageOrigin,
+  unwrapPolicyDelivery,
+  MucOriginTracker,
+  queryMam,
+  forwardedStanza,
+  pepPublish,
+  pepFetchItems,
+  refuseSubscriptionRequests
+};