@ours.network/cli 1.0.1 → 2.0.1

package/dist/{server-TDJBEWTU.js → server-2RIEOKDA.js}

@@ -11,11 +11,11 @@ import {
   appendNotifyLog,
   bindSession,
   bootWrapper,
-  buildMessagesPayload,
   capabilityReconcileSweep,
   clearNotifyHook,
   closeTemporaryIdentity,
   clusterSweep,
+  consumeOutboundHistoryFailure,
   contactRestoreSweep,
   decodeWireBin,
   delegateRole,
@@ -27,13 +27,18 @@ import {
   establishRoot,
   exportAdBlob,
   findIdentityFile,
+  getFileHistoryItem,
+  getMessageHistoryItem,
   hashLeaseToken,
   identities,
   isSelectableWireId,
   leaseByToken,
   leases,
+  listFileHistory,
+  listIncomingFiles,
+  listIncomingMessages,
+  listMessageHistory,
   log,
-  mimeFromExt,
   mutatingTx,
   outboundRemovalInFlight,
   persistBindings,
@@ -41,16 +46,13 @@ import {
   provisionIdentity,
   publishToBook,
   readBook,
-  readE2eWireIds,
   readonlyTx,
   refreshUnread,
   registrar,
   renderContactRoots,
   renderContacts,
   renderDegraded,
-  renderFileMetadata,
   renderImportRenames,
-  renderInbox,
   renderPending,
   requireAuth,
   reservedNames,
@@ -62,16 +64,21 @@ import {
   sessionHeaders,
   setNotifyHook,
   startupProgress,
+  structuredVoiceOutcome,
+  sttStatus,
   sweepStaleTempIdentities,
+  takeUnreadFiles,
+  takeUnreadMessages,
   tombstones,
+  transcribeVoice,
   unpublishFromBook,
   unreadSummary,
   validateName,
+  voiceDeliveryLine,
   withScope,
   withScopeAsync,
-  writeIncomingFiles,
   writeTempMetaFile
-} from "./chunk-MHVYJY3H.js";
+} from "./chunk-LJ35FDQH.js";
 import {
   buildIdentityFile,
   writeIdentityFile
@@ -96,13 +103,6 @@ function startGcTimer() {
     void (async () => {
       try {
         for (const id of identities.values()) {
-          try {
-            await withScopeAsync(async (lt) => {
-              await mutatingTx(id, "::actor::gc", {}, lt);
-            });
-          } catch (e) {
-            log(`gc(${id.name}) failed:`, String(e));
-          }
           await contactRestoreSweep(id);
           await capabilityReconcileSweep(id);
           await e2eRecoverySweep(id);
@@ -113,7 +113,7 @@ function startGcTimer() {
     })();
   }, GC_INTERVAL_MS);
   gcTimer.unref?.();
-  log(`message GC timer armed (every ${GC_INTERVAL_MS}ms)`);
+  log(`protocol maintenance timer armed (every ${GC_INTERVAL_MS}ms)`);
 }
 function stopGcTimer() {
   if (gcTimer) {
@@ -989,7 +989,37 @@ async function respondToIntroduction(ctx, a) {
 
 // ../../src/api/messaging.ts
 import { readFile } from "node:fs/promises";
-import { basename as basename2 } from "node:path";
+import { basename as basename3 } from "node:path";
+
+// ../../src/files.ts
+import { basename as basename2, extname } from "node:path";
+var FILE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".html": "text/html",
+  ".xml": "application/xml",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime"
+};
+function mimeFromExt(p) {
+  return FILE_MIME[extname(p).toLowerCase()] ?? "application/octet-stream";
+}
 
 // ../../src/messaging/send.ts
 function findSibling(id, contact) {
@@ -1001,15 +1031,19 @@ function findSibling(id, contact) {
 }
 async function sendViaSibling(id, target, text) {
   const targetAd = exportAdBlob(target);
-  await withScopeAsync(async (lt) => {
-    await mutatingTx(id, "::actor::connect_sibling", {
+  const wireId = await withScopeAsync(async (lt) => {
+    const result = await mutatingTx(id, "::actor::connect_sibling", {
       name: target.name,
       target_ad: id.pw.packet.NewBinaryFromBuffer(targetAd).Attach(lt),
       text
     }, lt);
+    return result.Reduce("wire_id").Visualize();
   });
   scheduleCapabilityReconcile(id);
-  return `"${target.name}" was not a contact yet \u2014 connected as an intra-root sibling (delegation-cert auto-accept) and delivered the message.`;
+  return {
+    text: `"${target.name}" was not a contact yet \u2014 connected as an intra-root sibling (delegation-cert auto-accept) and delivered the message.`,
+    wireId
+  };
 }
 async function sendViaLocalBook(id, contact, text) {
   if (!registrar) {
@@ -1028,22 +1062,26 @@ async function sendViaLocalBook(id, contact, text) {
   const targetAd = Buffer.from(entry.address_document, "base64url");
   const entrySig = Buffer.from(entry.registrar_sig, "base64url");
   const joinerAd = exportAdBlob(id);
-  await withScopeAsync(async (lt) => {
+  const wireId = await withScopeAsync(async (lt) => {
     const minted = await mutatingTx(registrar, "::actor::mint_introduction", {
       joiner_ad: registrar.pw.packet.NewBinaryFromBuffer(joinerAd).Attach(lt),
       target_ad: registrar.pw.packet.NewBinaryFromBuffer(targetAd).Attach(lt)
     }, lt);
     const introBlob = Buffer.from(minted.Reduce("intro").GetBinary());
-    await mutatingTx(id, "::actor::connect_local", {
+    const result = await mutatingTx(id, "::actor::connect_local", {
       name: entry.name,
       target_ad: id.pw.packet.NewBinaryFromBuffer(targetAd).Attach(lt),
       intro: id.pw.packet.NewBinaryFromBuffer(introBlob).Attach(lt),
       entry_sig: id.pw.packet.NewBinaryFromBuffer(entrySig).Attach(lt),
       text
     }, lt);
+    return result.Reduce("wire_id").Visualize();
   });
   scheduleCapabilityReconcile(id);
-  return `"${entry.name}" was not a contact yet \u2014 connected via the local contact book and sent the message with the introduction. If "${entry.name}" requires approval for local introductions, delivery completes once they approve.`;
+  return {
+    text: `"${entry.name}" was not a contact yet \u2014 connected via the local contact book and sent the message with the introduction. If "${entry.name}" requires approval for local introductions, delivery completes once they approve.`,
+    wireId
+  };
 }
 var parseSendVerdict = (sent) => {
   const has = (f) => !sent.Reduce(f).IsNil();
@@ -1090,6 +1128,14 @@ async function sendMessage(ctx, a) {
       default:
         break;
     }
+    if (v.kind === "sent" || v.kind === "e2e") {
+      return {
+        ...v,
+        sent: true,
+        wire_id: v.wireId,
+        history_stored: !consumeOutboundHistoryFailure(id, v.wireId)
+      };
+    }
     return v;
   } catch (e) {
     if (!/Unknown contact/.test(String(e))) {
@@ -1098,7 +1144,14 @@ async function sendMessage(ctx, a) {
     try {
       const sibling = findSibling(id, contact);
       const sent = sibling ? await sendViaSibling(id, sibling, text) : await sendViaLocalBook(id, contact, text);
-      return { kind: "introduced", text: sent };
+      return {
+        kind: "introduced",
+        text: sent.text,
+        wireId: sent.wireId,
+        wire_id: sent.wireId,
+        sent: true,
+        history_stored: !consumeOutboundHistoryFailure(id, sent.wireId)
+      };
     } catch (e2) {
       throw errTool("send_message", String(e2), "FALLBACK_FAILED");
     }
@@ -1116,7 +1169,7 @@ async function sendFile(ctx, a) {
   try {
     if (path) {
       buf = await readFile(path);
-      fname = filename ?? basename2(path);
+      fname = filename ?? basename3(path);
     } else if (upload_id) {
       const got = consumeStagedUpload(id, upload_id);
       if (!got) throw errUploadNotFound(upload_id);
@@ -1195,53 +1248,68 @@ async function sendFile(ctx, a) {
       default:
         break;
     }
+    if (v.kind === "sent" || v.kind === "e2e") {
+      return {
+        ...v,
+        filename: fname,
+        bytes: buf.length,
+        mime: mt,
+        sent: true,
+        wire_id: v.wireId,
+        history_stored: !consumeOutboundHistoryFailure(id, v.wireId)
+      };
+    }
     return { ...v, filename: fname, bytes: buf.length, mime: mt };
   } catch (e) {
     throw errTool("send_file", String(e));
   }
 }
-async function listIncomingMessages(ctx) {
+async function listIncomingMessages2(ctx) {
   const id = requireBound(ctx);
   try {
-    return withScope((lt) => renderInbox(readonlyTx(id, "::actor::list_incoming_messages", lt)));
+    return listIncomingMessages(id);
   } catch (e) {
     throw errTool("list_incoming_messages", String(e));
   }
 }
-async function getMessages(ctx) {
+async function getMessages(ctx, input = {}) {
   const id = requireBound(ctx);
   try {
-    const fresh = await withScopeAsync(async (lt) => {
-      const data = await mutatingTx(id, "::actor::get_messages", {}, lt);
-      return renderInbox(data.Reduce("messages"));
-    });
+    const fresh = takeUnreadMessages(id, input);
     refreshUnread(id);
-    const e2eWireIds = readE2eWireIds(id);
-    return buildMessagesPayload(fresh, e2eWireIds);
+    const bySender = /* @__PURE__ */ new Map();
+    for (const message of fresh.messages) {
+      let wireIds = bySender.get(message.from.id);
+      if (!wireIds) {
+        wireIds = [];
+        bySender.set(message.from.id, wireIds);
+      }
+      wireIds.push(message.wire_id);
+    }
+    for (const [senderId, wireIds] of bySender) {
+      try {
+        await withScopeAsync(async (lt) => {
+          await mutatingTx(id, "::actor::send_read_receipts", {
+            sender_id: senderId,
+            wire_ids: wireIds
+          }, lt);
+        });
+      } catch (error) {
+        log(`[${id.name}] read-receipt attempt failed sender_id=${senderId} count=${wireIds.length}:`, String(error));
+      }
+    }
+    return fresh;
   } catch (e) {
     throw errTool("get_messages", String(e));
   }
 }
-async function deferMessages(ctx, a) {
-  const id = requireBound(ctx);
-  const { msg_ids } = a;
-  try {
-    const n = await withScopeAsync(async (lt) => {
-      const data = await mutatingTx(id, "::actor::defer_messages", { msg_ids }, lt);
-      return data.Reduce("deferred").Visualize();
-    });
-    refreshUnread(id);
-    return { deferred: n };
-  } catch (e) {
-    throw errTool("defer_messages", String(e));
-  }
-}
 
 // ../../src/api/files.ts
-async function listIncomingFiles(ctx) {
+import { readFile as readFile2 } from "node:fs/promises";
+async function listIncomingFiles2(ctx) {
   const id = requireBound(ctx);
   try {
-    return withScope((lt) => renderFileMetadata(readonlyTx(id, "::actor::list_incoming_files", lt)));
+    return listIncomingFiles(id);
   } catch (e) {
     throw errTool("list_incoming_files", String(e));
   }
@@ -1257,18 +1325,66 @@ async function getFiles(ctx, a = {}) {
     if (new Set(wire_ids).size !== wire_ids.length) throw errDuplicateId();
   }
   try {
-    const out = await withScopeAsync(async (lt) => {
-      const data = await mutatingTx(id, "::actor::get_files", wire_ids === void 0 ? {} : { wire_ids }, lt);
-      return await writeIncomingFiles(id, data.Reduce("files"));
-    });
+    const selected = takeUnreadFiles(id, { wire_ids, limit: a.limit });
+    const files = [];
+    const lines = [];
+    for (const file of selected.files) {
+      const base = {
+        file_id: file.file_id,
+        wire_id: file.wire_id,
+        from: file.from,
+        filename: file.filename,
+        path: file.blob_path,
+        mime: file.mime,
+        size: file.byte_length,
+        sha256: file.sha256,
+        status: "processed",
+        date: file.date,
+        kind: file.kind,
+        sender: file.from.name
+      };
+      if (file.kind === "voice_message") {
+        const st = sttStatus(CONFIG.stt);
+        let outcome;
+        if (!st.ready) outcome = { kind: "unconfigured", reason: st.reason };
+        else {
+          try {
+            const result = await transcribeVoice(
+              await readFile2(file.blob_path),
+              file.filename,
+              file.mime,
+              CONFIG.stt
+            );
+            outcome = result.ok ? { kind: "transcript", text: result.text } : { kind: "failed", error: result.error };
+          } catch (error) {
+            outcome = { kind: "failed", error: error instanceof Error ? error.message : String(error) };
+          }
+        }
+        base.transcription = structuredVoiceOutcome(st, outcome, {
+          audioPath: file.blob_path,
+          wireId: file.wire_id
+        });
+        lines.push(voiceDeliveryLine({
+          sender: file.from.name,
+          wire: file.wire_id,
+          savedPath: file.blob_path,
+          sizeBytes: file.byte_length
+        }, outcome));
+      } else {
+        lines.push(
+          `  \u2022 ${file.filename} (${file.mime}, ${file.byte_length} B, sha256 ${file.sha256}) from ${file.from.name} \u2192 ${file.blob_path} {${file.wire_id}}`
+        );
+      }
+      files.push(base);
+    }
     refreshUnread(id);
     return {
-      files: out.files,
-      // The finished summary travels; ours-mcp cannot re-derive it. See GetFilesResult.
-      text: out.text,
+      files,
+      text: lines.length === 0 ? "No new files." : `${lines.length} new file(s) available from immutable identity blob storage (bytes stay on disk, never in this result):
+${lines.join("\n")}`,
       mode: wire_ids === void 0 ? "all_unread" : "selected",
-      // null — NOT [] — for the bulk form. See GetFilesResult.
-      requested: wire_ids ?? null
+      requested: wire_ids ?? null,
+      remaining: selected.remaining
     };
   } catch (e) {
     const message = String(e);
@@ -1282,20 +1398,6 @@ function saveFileFallbackNotice(ctx, a) {
   const id = requireBound(ctx);
   return { existsOnDisk: findIdentityFile(id, a.wire_id) !== null };
 }
-async function deferFiles(ctx, a) {
-  const id = requireBound(ctx);
-  const { file_ids } = a;
-  try {
-    const n = await withScopeAsync(async (lt) => {
-      const data = await mutatingTx(id, "::actor::defer_files", { file_ids }, lt);
-      return data.Reduce("deferred").Visualize();
-    });
-    refreshUnread(id);
-    return { deferred: n };
-  } catch (e) {
-    throw errTool("defer_files", String(e));
-  }
-}
 
 // ../../src/api/profile.ts
 async function setBio2(ctx, a) {
@@ -1363,82 +1465,37 @@ async function readvertiseOnUpgrade(ctx) {
   }
 }
 
-// ../../src/api/conversations.ts
-function renderConversation(av) {
-  const out = [];
-  const msgs = av.Reduce("messages");
-  if (msgs.IsNil()) return out;
-  for (let i = 0; ; i++) {
-    const m = msgs.Reduce(i);
-    if (m.IsNil()) break;
-    const wire = m.Reduce("wire_id");
-    const receipt = m.Reduce("receipt");
-    out.push({
-      dir: m.Reduce("dir").Visualize() === "out" ? "out" : "in",
-      text: m.Reduce("text").Visualize(),
-      date: m.Reduce("date").Visualize(),
-      // GetBoolean, never Visualize: a MUFL boolean visualizes as '%%TRUE',
-      // never 'TRUE' — the G4 trap from wire-handlers, one layer up.
-      read: m.Reduce("read").GetBoolean(),
-      wire_id: wire.IsNil() ? "" : wire.Visualize(),
-      receipt: receipt.IsNil() ? null : receipt.Visualize()
-    });
-  }
-  return out;
-}
-async function getConversation(ctx, a) {
+// ../../src/api/history.ts
+function listHistory(ctx, query = {}) {
   const id = requireBound(ctx);
   try {
-    const messages = withScope(
-      (lt) => renderConversation(readonlyTx(id, "::actor::get_conversation", lt, { contact: a.contact }))
-    );
-    return { contact: a.contact, messages };
-  } catch (e) {
-    throw errTool("get_conversation", String(e));
+    return listMessageHistory(id, query);
+  } catch (error) {
+    throw errTool("list_history", String(error));
   }
 }
-async function getReceipts(ctx, a) {
+function getHistoryItem(ctx, input) {
   const id = requireBound(ctx);
   try {
-    const receipts = withScope((lt) => {
-      const av = readonlyTx(id, "::actor::get_receipts", lt, { contact: a.contact }).Reduce("receipts");
-      const out = {};
-      if (av.IsNil()) return out;
-      for (const key of av.GetKeys()) {
-        const wid = key.Visualize();
-        out[wid] = av.Reduce(wid).Visualize();
-      }
-      return out;
-    });
-    return { contact: a.contact, receipts };
-  } catch (e) {
-    throw errTool("get_receipts", String(e));
+    return getMessageHistoryItem(id, input.wire_id);
+  } catch (error) {
+    throw errTool("get_history_item", String(error));
   }
 }
-async function markRead(ctx, a) {
+function listFiles(ctx, query = {}) {
   const id = requireBound(ctx);
   try {
-    const marked = await withScopeAsync(async (lt) => {
-      const data = await mutatingTx(id, "::actor::mark_read", { contact: a.contact }, lt);
-      return Number(data.Reduce("marked").Visualize());
-    });
-    return { contact: a.contact, marked };
-  } catch (e) {
-    throw errTool("mark_read", String(e));
+    return listFileHistory(id, query);
+  } catch (error) {
+    throw errTool("list_files", String(error));
   }
 }
-async function setConversationPolicy(ctx, a) {
+function getFileInfo(ctx, input) {
   const id = requireBound(ctx);
   try {
-    return await withScopeAsync(async (lt) => {
-      const data = await mutatingTx(id, "::actor::set_local_policy", { keep_history: a.keep_history }, lt);
-      return {
-        keepHistory: data.Reduce("keep_history").GetBoolean(),
-        autoAccept: data.Reduce("auto_accept").GetBoolean()
-      };
-    });
-  } catch (e) {
-    throw errTool("set_local_policy", String(e));
+    return getFileHistoryItem(id, input.wire_id);
+  } catch (error) {
+    throw errTool("get_file_info", String(error));
   }
 }
 
@@ -1478,18 +1535,14 @@ var API_OPERATIONS = {
   // ----- messaging (Task 12) -------------------------------------------------
   sendMessage: op(sendMessage),
   sendFile: op(sendFile),
-  listIncomingMessages: op0(listIncomingMessages),
-  getMessages: op0(getMessages),
-  deferMessages: op(deferMessages),
-  deferFiles: op(deferFiles),
-  // The messenger conversation surface. getConversation and getReceipts read
-  // without consuming or emitting; markRead is the human read event.
-  getConversation: op(getConversation),
-  getReceipts: op(getReceipts),
-  markRead: op(markRead),
-  setConversationPolicy: op(setConversationPolicy),
+  listIncomingMessages: op0(listIncomingMessages2),
+  getMessages: op(getMessages),
+  listHistory: op(listHistory),
+  getHistoryItem: op(getHistoryItem),
+  listFiles: op(listFiles),
+  getFileInfo: op(getFileInfo),
   // ----- files (Task 12) -----------------------------------------------------
-  listIncomingFiles: op0(listIncomingFiles),
+  listIncomingFiles: op0(listIncomingFiles2),
   getFiles: op(getFiles),
   saveFileFallbackNotice: op(saveFileFallbackNotice)
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/cli",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "Transport-neutral operator CLI for the ours shared daemon",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -25,6 +25,7 @@
   "dependencies": {
     "@adapt-toolkit/sdk": "0.10.12",
     "@adapt-toolkit/sdk-native": "0.10.12",
-    "@ours.network/sdk": "^2.0.0"
+    "@ours.network/sdk": "^3.0.0",
+    "better-sqlite3": "^11.10.0"
   }
 }