@decentnetwork/beagle 0.1.80 → 0.1.82

package/dist/carrier-node.d.ts

@@ -90,7 +90,9 @@ export declare class CarrierNode extends EventEmitter {
     isFriendOnline(userid: string): boolean;
     sessionStatus(pubkey: string): unknown;
     dhtHealth(): unknown;
-    sendText(userid: string, text: string): Promise<void>;
+    sendText(userid: string, text: string): Promise<{
+        delivery: "acked" | "accepted" | "offline";
+    } | void>;
     sendFriendRequest(address: string, hello?: string, opts?: {
         force?: boolean;
     }): Promise<void>;

package/dist/cli.js

@@ -12,6 +12,7 @@ import { startBeagleServer } from "./server.js";
 import { openPeerHost, defaultConfigDir, decentlanCarrierDir, makeDaemonHost } from "./peer-host.js";
 import { SwitchablePeerHost } from "./lan-handoff.js";
 import { loadNodeConfig, saveAutoAccept } from "./node-config.js";
+import { setUiPortHint } from "./identity-lock.js";
 function parseArgs(argv) {
     const get = (flag) => {
         const i = argv.indexOf(flag);
@@ -134,6 +135,11 @@ async function main() {
         onAutoAcceptChange: (enabled) => saveAutoAccept(args.configDir, enabled),
         force: "embedded",
     })).host;
+    // Publish the port before anything takes the identity lock, so the lock file
+    // and the way to reach us are written together. `agentnet restart` reads it:
+    // on a machine where beagle holds the identity there is no daemon for it to
+    // talk to, and without this the documented upgrade one-liner just failed.
+    setUiPortHint(args.port, decentlanCarrierDir(args.configDir));
     const lanHost = new SwitchablePeerHost(peerHost, {
         dataDir: decentlanCarrierDir(args.configDir),
         makeEmbedded: openEmbedded,

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.79";
+window.__DK_UI_VERSION="0.1.81";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -1576,7 +1576,7 @@ window.__DK_UI_VERSION="0.1.79";
         },
         /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }),
         /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.status === "sending" ? T.sendingMsg || "sending" : T.queued || "queued")
-      ) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
+      ) : mine && m.status === "sent" && m.confirmed === false ? /* @__PURE__ */ React.createElement(Icon, { name: "check", size: 12, stroke: 2.2, color: "var(--faint)", title: T.sentUnconfirmed || "sent \u2014 not confirmed by the peer" }) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
     );
   }
   function Conversation({ T, peer, lang, peers, onOpenChat, thread: threadProp, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread }) {

package/dist/embedded-host.js

@@ -326,8 +326,8 @@ export class EmbeddedHost {
             // "queued" a terminal state for text: the clock icon never resolved.
             if (!msg.file) {
                 try {
-                    await this.#node.sendText(pubkey, msg.text);
-                    this.#messages.setStatus(pubkey, msg.id, "sent");
+                    const r = await this.#node.sendText(pubkey, msg.text);
+                    this.#messages.setStatus(pubkey, msg.id, "sent", !r || r.delivery === "acked");
                     this.#events.emit("event", { type: "chat", userid: pubkey, dir: "out" });
                 }
                 catch (e) {
@@ -583,8 +583,11 @@ export class EmbeddedHost {
                 const job = prev.then(async () => {
                     await this.#flushOutbox(uid).catch(() => { });
                     try {
-                        await this.#node.sendText(uid, text);
-                        this.#messages.setStatus(uid, msg.id, "sent");
+                        // "acked" is a confirmation from the far side; anything else is
+                        // the transport taking the bytes. Still "sent" — resending on an
+                        // unconfirmed message is how a phone ends up with two copies.
+                        const r = await this.#node.sendText(uid, text);
+                        this.#messages.setStatus(uid, msg.id, "sent", !r || r.delivery === "acked");
                     }
                     catch (e) {
                         // Offline peer or failed delivery: same recovery either way —

package/dist/identity-lock.d.ts

@@ -15,4 +15,8 @@ export declare class IdentityLockedError extends Error {
  * A stale file (holder gone) is taken over silently: that is a crash we already
  * survived, not a conflict.
  */
+/** Where a holder publishes the port its local HTTP API is on. */
+export declare function uiPortHintPath(dataDir: string): string;
+/** Called by the server once it knows which port it actually bound. */
+export declare function setUiPortHint(port: number, dataDir?: string): void;
 export declare function acquireIdentityLock(dataDir: string): () => void;

package/dist/identity-lock.js

@@ -13,7 +13,7 @@
 // exclusion protocol whose other participant we cannot modify (decentlan is
 // sealed) and must not fork.
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, join } from "node:path";
 /** Same path decentlan uses: `<carrier dataDir>/daemon.pid`. */
 export function identityLockPath(dataDir) {
     return resolve(dataDir, "daemon.pid");
@@ -55,6 +55,27 @@ export class IdentityLockedError extends Error {
  * A stale file (holder gone) is taken over silently: that is a crash we already
  * survived, not a conflict.
  */
+/** Where a holder publishes the port its local HTTP API is on. */
+export function uiPortHintPath(dataDir) {
+    return join(dataDir, "holder.http-port");
+}
+let uiPortForHint;
+/** Called by the server once it knows which port it actually bound. */
+export function setUiPortHint(port, dataDir) {
+    uiPortForHint = port;
+    if (dataDir)
+        writeUiPortHint(dataDir);
+}
+function writeUiPortHint(dataDir) {
+    if (!uiPortForHint)
+        return;
+    try {
+        writeFileSync(uiPortHintPath(dataDir), String(uiPortForHint), "utf-8");
+    }
+    catch {
+        /* best effort — the lock itself is what matters */
+    }
+}
 export function acquireIdentityLock(dataDir) {
     const holder = identityLockHolder(dataDir);
     if (holder !== null && holder !== process.pid)
@@ -65,11 +86,22 @@ export function acquireIdentityLock(dataDir) {
     mkdirSync(dataDir, { recursive: true });
     const file = identityLockPath(dataDir);
     writeFileSync(file, String(process.pid), "utf-8");
+    // Also leave a way to REACH us. The documented upgrade is
+    // `npm i -g @decentnetwork/lan@latest && agentnet restart`, and on a machine
+    // where beagle holds the identity there is no daemon for that second half to
+    // talk to — it failed, and the person was left holding a new package and a
+    // process still running the old one. `agentnet restart` can drive our own
+    // /api/update-restart instead, but only if it can find the port.
+    writeUiPortHint(dataDir);
     let released = false;
     return () => {
         if (released)
             return;
         released = true;
+        try {
+            unlinkSync(uiPortHintPath(dataDir));
+        }
+        catch { /* may not exist */ }
         // Only remove it if it is still OURS. A daemon may have taken over after we
         // released the peer during the LAN handoff, and deleting its lock would
         // silently re-open the door this whole module exists to keep shut.

package/dist/message-store.d.ts

@@ -20,6 +20,9 @@ export interface ChatMessage {
      *  daemon will deliver it (in order) the moment the friend reconnects.
      *  Cleared once actually sent. */
     status?: "sending" | "queued" | "sent" | "failed";
+    /** True when the far side confirmed receipt; false when "sent" is a guess.
+     *  Absent on old records and on inbound messages. */
+    confirmed?: boolean;
     /** How this message traversed the network, for the UI to distinguish at a
      *  glance (different colors). "online" = live net_crypto session (direct/relay);
      *  "offline" = express store-and-forward (the friend or we were offline). Lets
@@ -58,7 +61,15 @@ export declare class MessageStore {
     /** Set (or, with undefined, clear) the delivery status on a text message.
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */
-    setStatus(peer: string, id: string, status?: "sending" | "queued" | "sent" | "failed"): boolean;
+    /**
+     * `confirmed` distinguishes a tick that is EVIDENCE from a tick that is a
+     * guess. sendText reports "acked" only when the far side answered — an
+     * app-level ACK from a JS peer, toxcore's own ACK from a phone. Anything
+     * else went to a live session and was never confirmed. The status stays
+     * "sent" either way, because the message is not queued and must not be
+     * resent; the flag is what the UI reads to stop over-claiming.
+     */
+    setStatus(peer: string, id: string, status?: "sending" | "queued" | "sent" | "failed", confirmed?: boolean): boolean;
     /** Has this peer ever sent us anything? Used as proof-of-friendship for
      *  records that predate the SDK's acceptedAt bookkeeping — a message can
      *  only arrive over an established session. */

package/dist/message-store.js

@@ -62,11 +62,23 @@ export class MessageStore {
     /** Set (or, with undefined, clear) the delivery status on a text message.
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */
-    setStatus(peer, id, status) {
+    /**
+     * `confirmed` distinguishes a tick that is EVIDENCE from a tick that is a
+     * guess. sendText reports "acked" only when the far side answered — an
+     * app-level ACK from a JS peer, toxcore's own ACK from a phone. Anything
+     * else went to a live session and was never confirmed. The status stays
+     * "sent" either way, because the message is not queued and must not be
+     * resent; the flag is what the UI reads to stop over-claiming.
+     */
+    setStatus(peer, id, status, confirmed) {
         const arr = this.byPeer.get(peer);
         const msg = arr?.find((m) => m.id === id);
         if (!msg || msg.file)
             return false;
+        if (confirmed === undefined)
+            delete msg.confirmed;
+        else
+            msg.confirmed = confirmed;
         if (status)
             msg.status = status;
         else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "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",
@@ -27,14 +27,14 @@
   "dependencies": {
     "@decentnetwork/chat-components": "^0.1.3",
     "@decentnetwork/lan": "^0.1.283",
-    "@decentnetwork/peer": "^0.1.162",
+    "@decentnetwork/peer": "^0.1.163",
     "@decentnetwork/peer-webrtc": "^0.2.16",
     "js-yaml": "^4.1.0",
     "ws": "^8.21.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@decentnetwork/beagle-ui": "^0.2.3",
+    "@decentnetwork/beagle-ui": "^0.2.4",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.0",
     "@types/yargs": "^17.0.32",