@decentnetwork/beagle 0.1.50 → 0.1.52

package/dist/carrier-node.d.ts

@@ -98,7 +98,14 @@ export declare class CarrierNode extends EventEmitter {
     sendFile(userid: string, data: Uint8Array, name: string): string | null;
     cancelSend(userid: string, fileId: string): boolean;
     acceptFile(userid: string, fileNumber: number): void;
-    sendInlineFile(userid: string, data: Uint8Array, name: string): Promise<void>;
+    /** Returns the SDK's delivery verdict — "acked" is the only outcome that
+     *  earns a "sent" checkmark. Older SDKs resolve void: report "accepted"
+     *  (bytes out, delivery unproven) rather than inventing a confirmation. */
+    sendInlineFile(userid: string, data: Uint8Array, name: string): Promise<"acked" | "accepted" | "offline">;
+    /** True when the friend is a NATIVE Carrier client (iOS/Android/C): it can
+     *  only receive files as the inline envelope — a toxcore sendFile offer is
+     *  invisible to it and would hang at "sending" until the 60s give-up. */
+    isNativeFriend(userid: string): boolean;
     /** Send on an application packet id. Used for the components channel (165);
      *  unavailable on an SDK build without custom packets, which simply means
      *  this peer can't offer forms — never that chat breaks. */

package/dist/carrier-node.js

@@ -204,11 +204,26 @@ export class CarrierNode extends EventEmitter {
     acceptFile(userid, fileNumber) {
         this.#require().acceptFile(userid, fileNumber);
     }
+    /** Returns the SDK's delivery verdict — "acked" is the only outcome that
+     *  earns a "sent" checkmark. Older SDKs resolve void: report "accepted"
+     *  (bytes out, delivery unproven) rather than inventing a confirmation. */
     async sendInlineFile(userid, data, name) {
         const peer = this.#require();
         if (!peer.sendInlineFile)
             throw new Error("This peer SDK build has no inline-file support");
-        await peer.sendInlineFile(userid, { name, data });
+        const r = await peer.sendInlineFile(userid, { name, data });
+        return (r && typeof r === "object" ? r.delivery : undefined) ?? "accepted";
+    }
+    /** True when the friend is a NATIVE Carrier client (iOS/Android/C): it can
+     *  only receive files as the inline envelope — a toxcore sendFile offer is
+     *  invisible to it and would hang at "sending" until the 60s give-up. */
+    isNativeFriend(userid) {
+        try {
+            return this.#require().isNativeFriend?.(userid) ?? false;
+        }
+        catch {
+            return false;
+        }
     }
     /** Send on an application packet id. Used for the components channel (165);
      *  unavailable on an SDK build without custom packets, which simply means

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.50";
+window.__DK_UI_VERSION="0.1.52";
 const ICON_PATHS = {
   // ---- tab bar (the four must feel like one set) ----
   users: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',

package/dist/embedded-host.js

@@ -592,24 +592,49 @@ export class EmbeddedHost {
             this.#events.emit("event", { type: "chat", userid, dir: "out" });
             return { queued: true, name: safe, size: data.length };
         }
+        // A NATIVE friend (iOS/Android/C Carrier) cannot see the toxcore transfer
+        // protocol AT ALL — offering it one just hangs the chip at "sending" until
+        // the 60s give-up. Its only file path is the inline envelope, so reject an
+        // oversized file BEFORE any bytes move, with the reason (ticket req. 2).
+        const native = this.#node.isNativeFriend(userid);
+        if (native && data.length > INLINE_MAX_BYTES) {
+            throw new Error(`This friend is a native (iOS/Android) client — files are sent inline and limited to ` +
+                `${(INLINE_MAX_BYTES / 1024 / 1024).toFixed(1)} MB (this is ${(data.length / 1024 / 1024).toFixed(1)} MB).`);
+        }
         const msg = this.#messages.appendFile(userid, "out", { name: safe, size: data.length, status: "sending", sent: 0 });
         if (!msg)
             throw new Error("Could not create file message");
         await mkdir(this.outboxDir, { recursive: true });
         await writeFile(resolve(this.outboxDir, msg.id), data);
-        const fileId = this.#node.sendFile(userid, new Uint8Array(data), safe);
+        const fileId = native ? null : this.#node.sendFile(userid, new Uint8Array(data), safe);
         if (!fileId) {
-            // No transfer slot — try the inline envelope, which is also the only
-            // path a native iOS/Android friend can receive at all.
+            // Native friend, or no transfer slot — the inline envelope path.
             if (data.length > INLINE_MAX_BYTES) {
                 this.#messages.patchFile(userid, msg.id, { status: "failed" });
                 throw new Error(`Could not start the transfer, and the file is too large (${(data.length / 1024 / 1024).toFixed(1)} MB) ` +
                     `for the inline fallback (limit ${(INLINE_MAX_BYTES / 1024 / 1024).toFixed(1)} MB).`);
             }
-            await this.#node.sendInlineFile(userid, new Uint8Array(data), safe);
-            this.#messages.patchFile(userid, msg.id, { status: "sent", sent: data.length });
+            // "sent" means the PEER CONFIRMED receipt — nothing less. Stamping it
+            // when sendInlineFile resolved was the fake-sent of INBOX 2026-08-21:
+            // bytes left the machine, the phone had nothing, the UI showed a
+            // checkmark. The SDK's verdict now decides the chip.
+            let delivery;
+            try {
+                delivery = await this.#node.sendInlineFile(userid, new Uint8Array(data), safe);
+            }
+            catch (e) {
+                this.#messages.patchFile(userid, msg.id, { status: "failed" });
+                this.#events.emit("event", { type: "chat", userid, dir: "out" });
+                throw e;
+            }
+            const status = delivery === "acked" ? "sent" : delivery === "offline" ? "queued" : "failed";
+            this.#messages.patchFile(userid, msg.id, { status, sent: delivery === "acked" ? data.length : 0 });
             this.#events.emit("event", { type: "chat", userid, dir: "out" });
-            return { inline: true, name: safe, size: data.length };
+            if (delivery === "accepted") {
+                throw new Error(`The peer never confirmed receiving "${safe}" — it likely did not arrive. ` +
+                    `Check that their app is open and try again.`);
+            }
+            return { inline: true, name: safe, size: data.length, delivery };
         }
         this.#activeSends.set(fileId, { peer: userid, msgId: msg.id });
         this.#meta.ensure(userid);

package/dist/server.js

@@ -355,6 +355,21 @@ async function pickWritableSaveDir(downloadsDir) {
         return alt;
     }
 }
+/**
+ * Turn a bare permission error into the one command that fixes it.
+ *
+ * The daemon runs as root and the files it leaves under ~/.agentnet are
+ * root-owned, so this unprivileged process cannot write them — and "EACCES:
+ * permission denied, open '/Users/x/.agentnet/downloads/a.jpg'" tells the user
+ * nothing about what to do. Daemons from lan 0.1.278 repair this themselves at
+ * startup; older ones need the sweep run once by hand.
+ */
+function permissionHint(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/EACCES|EPERM|permission denied/i.test(msg))
+        return msg;
+    return `${msg}\n\nThis is the root-owned ~/.agentnet problem. Fix it once with:\n  sudo agentnet fix-perms`;
+}
 /** Resolve a saved file by name across downloads/ and sent/, with a
  *  path-traversal guard. Returns null when absent from both. */
 function findSavedFile(downloadsDir, name) {
@@ -1071,7 +1086,7 @@ export function startBeagleServer(opts) {
                     sendJson(res, 200, { ok: true, ...(r.data ?? {}) });
                 }
                 catch (e) {
-                    sendJson(res, 500, { ok: false, error: e instanceof Error ? e.message : String(e) });
+                    sendJson(res, 500, { ok: false, error: permissionHint(e) });
                 }
                 finally {
                     if (!keep)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Beagle — P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@decentnetwork/chat-components": "^0.1.3",
-    "@decentnetwork/lan": "^0.1.277",
-    "@decentnetwork/peer": "^0.1.139",
+    "@decentnetwork/lan": "^0.1.279",
+    "@decentnetwork/peer": "^0.1.140",
     "@decentnetwork/peer-webrtc": "^0.2.16",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"