@wacando/agent 2.1.0 → 2.3.0

package/packages/runtime/conversations.mjs

@@ -5,6 +5,7 @@ import {
 } from '#wacando/xmpp';
 import { ApiError } from '../onboarding/network.mjs';
 import { SafeError } from '../onboarding/storage.mjs';
+import { fileApiMessages, fileBodyKind, fileErrors } from './files.mjs';
 import { attachRecovery, recoveryLifecycle, recoveryView } from './recovery.mjs';
 
 // Consent-aware conversations (lbframe/wacando docs/CONVERSATION_CONSENT.md):
@@ -44,6 +45,7 @@ export function apiFailure(error) {
     CONVERSATION_NOT_ACTIVE: 'Conversation is not active. Nothing was sent.',
     NOT_FOUND: consentErrors.notAccepted,
     FORBIDDEN: 'Refused: the other agent is not reachable for new requests, or this agent may not act here. Nothing was sent.',
+    ...fileApiMessages,
   };
   return new SafeError(known[error.code] ?? `Wacando API refused the request (${error.code ?? `HTTP ${error.status}`}).`);
 }
@@ -102,7 +104,7 @@ export function publicConversation(view, extra = {}) {
 
 /** Messaging for ONE connected identity. Created by AgentRuntime.conversations(). */
 export class ConversationClient {
-  constructor({ runtime, agent, session }) {
+  constructor({ runtime, agent, session, files }) {
     this.runtime = runtime;
     this.agent = agent;
     this.session = session;
@@ -127,8 +129,17 @@ export class ConversationClient {
     this.recoveryStates = new Map(); // conversationId → recovery view
     this.recovery = this.attachRecovery(session);
     this.lifecyclesLoaded = this.loadLifecycles();
+    // lbframe/wacando-agent#10: encrypted files under owner approval.
+    this.files = files?.(this) ?? null;
+    // lbframe/wacando-agent#21: clean up ended transfers at every connection.
+    this.filesSwept = this.sweepFiles();
   }
 
+  /** Content-free counts of the local file records removed, or null (never throws). */
+  sweepFiles() { return this.files ? this.files.sweep().catch(() => null) : Promise.resolve(null); }
+
+  failure(error) { return apiFailure(error); }
+
   /**
    * Learn every conversation's state at start-up (and after a reconnection),
    * so recovery is not refused just because no tool call happened yet.
@@ -167,7 +178,7 @@ export class ConversationClient {
     return state ? { recovery: { ...state } } : {};
   }
 
-  /** Own sent text, kept in memory only and bounded (Signal cannot self-decrypt). */
+  /** Own sent text (or a file summary), kept in memory only and bounded (Signal cannot self-decrypt). */
   remember(id, text) {
     this.sent.set(id, text);
     while (this.sent.size > MAX_ENTRIES) this.sent.delete(this.sent.keys().next().value);
@@ -180,6 +191,7 @@ export class ConversationClient {
     this.session = session;
     this.recovery = this.attachRecovery(session);
     this.lifecyclesLoaded = this.loadLifecycles();
+    this.filesSwept = this.sweepFiles();
     this.tracker = new MucOriginTracker(session.client, { trustedRelayJid: this.policyJid });
     this.rooms.clear();
     for (const resolve of this.submissions.values()) resolve({ state: 'refused', reason: 'connection-lost' });
@@ -220,14 +232,25 @@ export class ConversationClient {
       if (transcript.has(id)) return;
       const own = origin.senderBareJid === this.selfJid;
       let text = null;
+      let file;
       if (own) text = this.sent.get(id) ?? null;
       else if (!this.claimed.has(id)) {
         this.claimed.add(id);
         text = await this.session.provider.decryptStanza(stanza, origin).catch(() => null);
       }
+      if (text !== null && typeof text === 'object') { file = text.file; text = null; }
+      else if (fileBodyKind(text)) {
+        // A file descriptor is never shown as text: a valid share -> quarantined,
+        // anything else (invalid share, review descriptor in the room) -> refused.
+        const kind = fileBodyKind(text);
+        file = kind === 'review' ? { state: 'refused', reason: 'review_descriptor' }
+          : this.files && !own ? await this.files.intake(conversationId, id, text).catch(() => ({ state: 'refused', reason: 'storage_unavailable' }))
+            : { state: 'refused', reason: 'file_transfer_unavailable' };
+        text = null;
+      }
       if (this.held.has(id)) this.held.get(id).state = 'delivered';
       const entry = { id, conversationId, sender: own ? 'self' : 'peer', at: stamp ?? new Date().toISOString(), text,
-        ...(text === null && !own ? { undecryptable: true } : {}), source };
+        ...(file ? { file } : {}), ...(text === null && !own && !file ? { undecryptable: true } : {}), source };
       transcript.set(id, entry);
       while (transcript.size > MAX_ENTRIES) transcript.delete(transcript.keys().next().value);
       if (!own) for (const waiter of [...this.waiters]) waiter(entry);
@@ -278,6 +301,7 @@ export class ConversationClient {
    * agent receives nothing before its owner accepts.
    */
   async propose(handle, text) {
+    if (fileBodyKind(text)) throw new SafeError(fileErrors.plainText);
     const peer = await this.resolve(handle);
     let conversation;
     try {
@@ -295,6 +319,7 @@ export class ConversationClient {
 
   /** Send in a conversation, respecting consent and the agent's mode. */
   async send(conversationId, text) {
+    if (fileBodyKind(text)) throw new SafeError(fileErrors.plainText);
     const view = await this.conversation(conversationId);
     if (view.state === 'requested') {
       if (view.role !== 'requester') throw new SafeError(consentErrors.waitingOther);
@@ -302,15 +327,33 @@ export class ConversationClient {
       return { conversation: publicConversation(view), message: await this.submit(view, text, 'first_message') };
     }
     if (view.state !== 'active') throw new SafeError(consentErrors.closed(view.state));
+    return this.deliver(view, text);
+  }
+
+  /** Deliver a body in an ACTIVE conversation: directly as a member, held by the policy when gated. */
+  async deliver(view, text, memo = text) {
     const mode = await this.enter(view);
-    if (mode === 'gated') return { conversation: publicConversation(view, { mode }), message: await this.submit(view, text, 'service_message') };
+    if (mode === 'gated') return { conversation: publicConversation(view, { mode }), message: await this.submit(view, text, 'service_message', memo) };
     const stanza = await this.encrypt(view, text);
     const id = stanza.getAttr('id');
-    this.remember(id, text);
+    this.remember(id, memo);
     await this.session.client.send(stanza);
     return { conversation: publicConversation(view, { mode }), message: { id, state: 'sent' } };
   }
 
+  fileTransfers() {
+    if (!this.files) throw new SafeError('File transfer is not available on this runtime.');
+    return this.files;
+  }
+  /** Encrypt a local file, ask the owner's approval, then deposit and share it (bounded wait). */
+  sendFile(conversationId, path, options) { return this.fileTransfers().send(conversationId, path, options); }
+  /** State of an outgoing (advanced as far as approved) or incoming file. */
+  fileStatus(fileId, options) { return this.fileTransfers().status(fileId, options); }
+  /** Fetch a released incoming file into the private quarantine directory. */
+  receiveFile(fileId, options) { return this.fileTransfers().receive(fileId, options); }
+  /** Local file transfers (no keys). */
+  listFiles(conversationId) { return this.fileTransfers().list(conversationId); }
+
   /**
    * Recipients, discovered fresh before EVERY encryption: owners observe
    * through per-installation device JIDs (lbframe/wacando #35/#108). There is
@@ -335,7 +378,7 @@ export class ConversationClient {
   }
 
   /** Encrypt for the room, then hand the ciphertext to the policy component. */
-  async submit(view, text, kind) {
+  async submit(view, text, kind, memo = text) {
     const stanza = await this.encrypt(view, text);
     const id = stanza.getAttr('id');
     let timer;
@@ -343,7 +386,7 @@ export class ConversationClient {
       this.submissions.set(id, resolve);
       timer = setTimeout(() => reject(new SafeError('The policy component did not answer; the message may not be held. Retry later.')), SUBMISSION_TIMEOUT_MS);
     }).finally(() => { clearTimeout(timer); this.submissions.delete(id); });
-    this.remember(id, text);
+    this.remember(id, memo);
     await this.session.client.send(toPolicySubmission(stanza, this.policyJid));
     const attrs = await status;
     if (attrs.state !== 'held') {