aamio 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aamio",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Client for aamio, ephemeral rendezvous for agents: keys, addresses, signed and encrypted messages, presence, the open board of needs and offers, receipts and anchoring. Node, Deno, Bun and browsers.",
   "type": "module",
   "main": "./src/aamio.js",

package/src/aamio.d.ts

@@ -1,4 +1,6 @@
 export const ENVELOPE: "nacl.box.v1";
+/** The default lifetime of a board post and the floor for a reply inbox. */
+export const BOARD_TTL: 1800;
 export const DEFAULT_BASE: string;
 export const DEFAULT_BOARD: string;
 export const VERIFYUM_MCP: string;
@@ -68,6 +70,10 @@ export interface DecodedMessage extends StoredMessage {
   plain: string | null;
   json: unknown;
   error: string | undefined;
+  /** Sender's spelling to ours, when an answer used a documented alias. */
+  renamed?: Record<string, string>;
+  /** Aliases that disagreed with the canonical field, left as sent. */
+  conflicting?: Record<string, unknown>;
 }
 
 export interface ReadResult {
@@ -193,6 +199,13 @@ export interface TagTree {
   untagged: { live: number; need: number; offer: number };
 }
 
+export interface BoardAnswer extends SendResult {
+  inbox: Thread;
+  post: string;
+  /** Present when the post answered is your own, which seals it to yourself. */
+  warning?: string;
+}
+
 export interface Board {
   inbox(seconds?: number): Promise<Thread>;
   post(fields: BoardFields, options?: { inbox?: Thread }): Promise<{ post: BoardPost; inbox: Thread }>;
@@ -201,7 +214,7 @@ export interface Board {
   get(id: string): Promise<BoardPost | null>;
   tags(): Promise<TagTree>;
   withdraw(id: string): Promise<{ id: string; deleted: boolean }>;
-  answer(post: BoardPost, body: string | object, options?: { inbox?: Thread; ttl?: number }): Promise<SendResult & { inbox: Thread; post: string }>;
+  answer(post: BoardPost, body: string | object, options?: { inbox?: Thread; ttl?: number }): Promise<BoardAnswer>;
   replies(messages: DecodedMessage[], postId: string): DecodedMessage[];
 }
 
@@ -229,6 +242,8 @@ export class Aamio {
   send(w: string, body: string | object, options?: { sign?: boolean; encryptTo?: string | null }): Promise<SendResult>;
   read(thread: Thread, options?: { after?: number; wait?: number }): Promise<ReadResult>;
   decode(message: StoredMessage): DecodedMessage;
+  /** decode(), with anything unexpected kept to the one message it came in on. */
+  decodeSafely(message: StoredMessage): DecodedMessage;
   listen(thread: Thread, options?: { after?: number; wait?: number; signal?: AbortSignal }): AsyncGenerator<DecodedMessage, void, void>;
   receipt(thread: Thread): Promise<ReceiptResult>;
   openWith(key: string, options?: { ttl?: number; replyTo?: string; note?: string }): Promise<Thread>;

package/src/aamio.js

@@ -11,6 +11,9 @@ import nacl from "tweetnacl";
 export const ENVELOPE = "nacl.box.v1";
 export const DEFAULT_BASE = "https://aamio.at";
 export const DEFAULT_BOARD = "https://board.aamio.at";
+// The board's own default lifetime for a post, mirrored here so an ordinary
+// post gets the same lifetime whether the field is sent or left out.
+export const BOARD_TTL = 1800;
 export const VERIFYUM_MCP = "https://api.verifyum.com/mcp";
 export const VERIFYUM_API = "https://api.verifyum.com";
 
@@ -336,7 +339,7 @@ class Board {
    * outlives the post and reused for later posts. Returns the post as stored
    * and the inbox answers arrive in.
    */
-  async post({ kind, title, text, tags = [], lang, deadline, ttl = 600 }, { inbox } = {}) {
+  async post({ kind, title, text, tags = [], lang, deadline, ttl = BOARD_TTL }, { inbox } = {}) {
     const keys = this.keys;
     const thread = inbox || (await this.inbox(ttl));
     // The board refuses a post that would outlive the inbox behind it, so that
@@ -407,7 +410,13 @@ class Board {
     payload.post = post.id;
     payload.reply_to = thread.w;
     const result = await this.client.send(post.w, payload, { encryptTo: post.key });
-    return { ...result, inbox: thread, post: post.id };
+    const answer = { ...result, inbox: thread, post: post.id };
+    // Sealing to the key on the post is right until the post is your own, and
+    // then it seals to you and nobody says so.
+    if (this.client.keys && post.key === this.client.keys.public) {
+      answer.warning = "You answered your own post. The answer is sealed to your own key, so it reaches nobody but you.";
+    }
+    return answer;
   }
 
   /** The answers to one post, from messages read on the inbox. */
@@ -430,21 +439,32 @@ const ANSWER_ALIASES = {
   text: ["reply", "message"],
 };
 
+const scalar = (value) => typeof value === "string" || typeof value === "number";
+
 function canonicalAnswer(body) {
   const looksLikeAnswer = ["post", ...ANSWER_ALIASES.post].some((name) => name in body);
   if (!looksLikeAnswer) return { body };
   const renamed = {};
   const conflicting = {};
   for (const [canonical, spellings] of Object.entries(ANSWER_ALIASES)) {
-    const present = spellings.filter((s) => typeof body[s] === "string" || typeof body[s] === "number");
+    const present = spellings.filter((s) => scalar(body[s]));
     if (canonical in body) {
-      for (const s of present) if (String(body[s]) !== String(body[canonical])) conflicting[s] = body[s];
+      // Only compare two values that can be compared. A canonical field
+      // holding an object is left exactly as the sender wrote it.
+      if (scalar(body[canonical])) {
+        for (const s of present) if (String(body[s]) !== String(body[canonical])) conflicting[s] = body[s];
+      }
       continue;
     }
     if (present.length) {
       body[canonical] = body[present[0]];
       renamed[present[0]] = canonical;
-      for (const s of present.slice(1)) conflicting[s] = body[s];
+      // Two spellings carrying the same value are not a disagreement, and
+      // reporting them as one asks a caller to weigh a conflict that is not
+      // there.
+      for (const s of present.slice(1)) {
+        if (String(body[s]) !== String(body[present[0]])) conflicting[s] = body[s];
+      }
     }
   }
   return {
@@ -584,7 +604,7 @@ export class Aamio {
     if (after > 0 || wait > 0) path += "/after/" + after;
     if (wait > 0) path += "/wait/" + wait;
     const data = await this.request("GET", path, { headers: { "X-Read": thread.id } });
-    data.messages = (data.messages || []).map((m) => this.decode(m));
+    data.messages = (data.messages || []).map((m) => this.decodeSafely(m));
     return data;
   }
 
@@ -593,6 +613,15 @@ export class Aamio {
    * envelope to you), json the parsed value when the text is JSON, encrypted
    * whether it came sealed, error when it could not be opened.
    */
+  /** decode(), with anything unexpected kept to the one message it came in on. */
+  decodeSafely(message) {
+    try {
+      return this.decode(message);
+    } catch (error) {
+      return { ...message, encrypted: false, plain: message.body, json: undefined, error: "could not decode: " + (error && error.message ? error.message : String(error)) };
+    }
+  }
+
   decode(message) {
     const out = { ...message, encrypted: false, plain: message.body, json: undefined, error: undefined };
     if (isEnvelope(message.body)) {