@decentnetwork/lan 0.1.136 → 0.1.138

package/config/default-doras.yaml

@@ -17,10 +17,6 @@
 #   name     — label only (logs / comments)
 #   segment  — informational: the IP band this registry allocates from
 doras:
-  - name: dora-mac
-    userid: 98rsHv17h8G6AP9RagyrBiT1kmw4cn8MFPEembS6ZVjv
-    address: Jt7w1pKkyLT5GVue9h6ZPkjg1EeuuTbD6JVSLycXLsdm6nvBGSUd
-    segment: 10.86.1.10-10.86.63.254
   - name: dora-beagle
     userid: AxKFEZFLDi23EmnJFNP6gjUM4CaNMPfWUvbFR9ixtMBN
     address: NsuN81dZdEoyvwEFgWaHkT8SPJB6UWeRmdYcCGFV5CdbbPXoK2RM

package/config/default-exits.yaml

@@ -47,9 +47,3 @@ exits:
     userid: 2wErj1XreXt1UchE3FGhuvkZ4GoBpo8JGMn8X49nm2ec
     virtual_ip: 10.86.166.16
     region: us
-  # snoopy has NO public IP (LAN 10.0.0.115) — proves a NAT'd node can serve
-  # as an exit purely over the Carrier tunnel.
-  - name: snoopy
-    userid: BeMbuKf1poh3U4rjw3eeUAKZsbN2qBSjVZdPSvehmHsw
-    virtual_ip: 10.86.156.164
-    region: us

package/dist/cli/commands.d.ts

@@ -149,6 +149,17 @@ export declare function cmdFriendsAccept(args: {
     userid: string;
     configDir?: string;
 }): Promise<void>;
+/**
+ * Show or set friends.autoAccept. With no `mode`, prints the current value.
+ * With on|off: if the daemon is up, toggles it live over IPC (no restart) and
+ * persists; if it's down, edits config.yaml so the next start picks it up.
+ * When OFF, incoming friend-requests queue for manual approval via
+ * `agentnet friends pending` (or the UI's Requests panel).
+ */
+export declare function cmdFriendsAutoAccept(args: {
+    mode?: string;
+    configDir?: string;
+}): Promise<void>;
 /**
  * Drop a queued friend-request without accepting. Sender doesn't
  * get a notification — they just see no acceptance.
@@ -207,6 +218,27 @@ export declare function cmdProxyRevokeHost(args: {
 export declare function cmdProxyListHosts(args: {
     configDir?: string;
 }): Promise<void>;
+/**
+ * `agentnet proxy who` — show who is using THIS node's exit right now:
+ * per-client active tunnels, total tunnels opened, bytes moved, and refusals.
+ * Reads live stats from the running daemon (diag → proxy). Lets an exit
+ * operator spot a heavy user before deciding to `agentnet revoke` them.
+ */
+export declare function cmdProxyWho(args: {
+    configDir?: string;
+}): Promise<void>;
+/**
+ * `agentnet proxy block|allow <peer>` — live per-peer exit access control.
+ * Under the default "allow" policy, every friend can tunnel through this exit;
+ * `block` adds a deny rule on the proxy port (applied to the running daemon
+ * instantly, no restart), `allow` removes it. Accepts a userid or a friendly
+ * name (resolved via the live roster).
+ */
+export declare function cmdProxyAccess(args: {
+    peer: string;
+    allow: boolean;
+    configDir?: string;
+}): Promise<void>;
 /**
  * Print the env-var line for a peer to use this node's proxy.
  */

package/dist/cli/commands.js

@@ -811,6 +811,49 @@ export async function cmdFriendsAccept(args) {
         throw new Error(`Daemon refused: ${res.error}`);
     console.log(`Accepted ${args.userid}.`);
 }
+/**
+ * Show or set friends.autoAccept. With no `mode`, prints the current value.
+ * With on|off: if the daemon is up, toggles it live over IPC (no restart) and
+ * persists; if it's down, edits config.yaml so the next start picks it up.
+ * When OFF, incoming friend-requests queue for manual approval via
+ * `agentnet friends pending` (or the UI's Requests panel).
+ */
+export async function cmdFriendsAutoAccept(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const configPath = resolve(dir, "config.yaml");
+    const config = await ConfigLoader.load(configPath);
+    if (!args.mode) {
+        const cur = config.friends?.autoAccept ?? true;
+        console.log(`friends.autoAccept: ${cur ? "on" : "off"}`);
+        console.log(cur
+            ? "  Incoming friend-requests are accepted automatically."
+            : "  Incoming friend-requests QUEUE for manual approval — 'agentnet friends pending' or the UI.");
+        return;
+    }
+    const enabled = args.mode === "on";
+    let live = false;
+    if (daemonPid(config) !== null) {
+        // Try the live toggle (no session drop). An older daemon (started before
+        // this op existed) rejects it — fall back to persisting config so a restart
+        // applies it, rather than erroring out.
+        const res = await ipcCall(config, { op: "friends-autoaccept", enabled });
+        if (res.ok)
+            live = true;
+    }
+    if (!live) {
+        config.friends = { ...(config.friends ?? {}), autoAccept: enabled };
+        await ConfigLoader.save(config, configPath);
+    }
+    console.log(`friends.autoAccept set to ${enabled ? "on" : "off"}${live ? " (live)" : ""}.`);
+    if (!live) {
+        console.log("Saved to config.yaml — restart the daemon to apply (the running daemon predates the live toggle).");
+    }
+    if (!enabled) {
+        console.log("Incoming friend-requests will then queue — approve with:");
+        console.log("  agentnet friends pending             # see who's waiting");
+        console.log("  agentnet friends accept <userid>     # or use the UI Requests panel");
+    }
+}
 /**
  * Drop a queued friend-request without accepting. Sender doesn't
  * get a notification — they just see no acceptance.
@@ -997,6 +1040,102 @@ export async function cmdProxyListHosts(args) {
     for (const h of allowHosts)
         console.log(`  ${h}`);
 }
+/**
+ * `agentnet proxy who` — show who is using THIS node's exit right now:
+ * per-client active tunnels, total tunnels opened, bytes moved, and refusals.
+ * Reads live stats from the running daemon (diag → proxy). Lets an exit
+ * operator spot a heavy user before deciding to `agentnet revoke` them.
+ */
+export async function cmdProxyWho(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+    const pid = daemonPid(config);
+    if (pid === null) {
+        console.error("No running daemon found for this config — start it with 'agentnet up'.");
+        process.exit(1);
+    }
+    const res = await ipcCall(config, { op: "diag" });
+    if (!res.ok)
+        throw new Error(`Daemon diag failed: ${res.error}`);
+    const proxy = res.data?.proxy;
+    if (!proxy) {
+        console.log("The CONNECT proxy isn't running on this node (nobody can use it as an exit).");
+        console.log("Enable it with:  agentnet proxy enable");
+        return;
+    }
+    const fmtBytes = (n) => {
+        if (n >= 1024 ** 3)
+            return `${(n / 1024 ** 3).toFixed(2)} GB`;
+        if (n >= 1024 ** 2)
+            return `${(n / 1024 ** 2).toFixed(1)} MB`;
+        if (n >= 1024)
+            return `${(n / 1024).toFixed(0)} KB`;
+        return `${n} B`;
+    };
+    const ago = (ms) => {
+        if (!ms)
+            return "—";
+        const s = Math.max(0, Math.floor((Date.now() - ms) / 1000));
+        if (s < 60)
+            return `${s}s ago`;
+        if (s < 3600)
+            return `${Math.floor(s / 60)}m ago`;
+        return `${Math.floor(s / 3600)}h ago`;
+    };
+    console.log(`Exit proxy: ${proxy.active} active tunnel(s), ${proxy.totalOpened} opened total, ` +
+        `${fmtBytes(proxy.bytesTransferred)} moved, ${proxy.totalRefused} refused.`);
+    if (!proxy.peers.length) {
+        console.log("No clients have used this exit yet.");
+        return;
+    }
+    console.log("");
+    console.log("  CLIENT                 ACTIVE  OPENED   BYTES        REFUSED  LAST");
+    for (const p of proxy.peers) {
+        const who = (p.srcName ? `${p.srcName} (${p.src})` : p.src).padEnd(22).slice(0, 22);
+        console.log(`  ${who} ${String(p.active).padStart(6)}  ${String(p.totalOpened).padStart(6)}  ` +
+            `${fmtBytes(p.bytesTransferred).padEnd(11)}  ${String(p.totalRefused).padStart(7)}  ${ago(p.lastSeenMs)}`);
+    }
+    console.log("");
+    console.log("Cut off a heavy user:  agentnet proxy block <userid-or-name>");
+}
+/**
+ * `agentnet proxy block|allow <peer>` — live per-peer exit access control.
+ * Under the default "allow" policy, every friend can tunnel through this exit;
+ * `block` adds a deny rule on the proxy port (applied to the running daemon
+ * instantly, no restart), `allow` removes it. Accepts a userid or a friendly
+ * name (resolved via the live roster).
+ */
+export async function cmdProxyAccess(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+    const pid = daemonPid(config);
+    if (pid === null) {
+        console.error("No running daemon found for this config — start it with 'agentnet up'.");
+        process.exit(1);
+    }
+    // Resolve a friendly name to its userid so the deny rule keys on the stable id.
+    let userid = args.peer;
+    try {
+        const { peers } = await fetchLiveIpam(config);
+        const stripDomain = (s) => s.replace(/\.[A-Za-z][A-Za-z0-9-]*$/, "");
+        const hit = peers.find((p) => p.carrierId === args.peer || p.name === args.peer || p.name === stripDomain(args.peer));
+        if (hit?.carrierId)
+            userid = hit.carrierId;
+    }
+    catch {
+        // fall back to the raw arg — the daemon matches on userid OR name
+    }
+    const res = await ipcCall(config, { op: "proxy-access", userid, enabled: args.allow });
+    if (!res.ok)
+        throw new Error(`Daemon refused: ${res.error}`);
+    if (args.allow) {
+        console.log(`✓ ${args.peer} may use this exit again (block removed, live).`);
+    }
+    else {
+        console.log(`✓ ${args.peer} is now BLOCKED from this exit (live — existing tunnels drop on next reconnect).`);
+        console.log("  Re-allow with:  agentnet proxy allow " + args.peer);
+    }
+}
 /**
  * Print the env-var line for a peer to use this node's proxy.
  */

package/dist/cli/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // Belt-and-braces — also raise it here in case the CLI is run directly
 // (e.g. `node dist/cli/index.js` rather than via dist/index.js).
 EventEmitter.defaultMaxListeners = 100;
-import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyUse, cmdProxyRouter, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, cmdConsole, cmdFileSend, cmdChatSend, cmdChatHistory, cmdFriendRemove, cmdFriendAlias, } from "./commands.js";
+import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsAutoAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyWho, cmdProxyAccess, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyUse, cmdProxyRouter, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, cmdConsole, cmdFileSend, cmdChatSend, cmdChatHistory, cmdFriendRemove, cmdFriendAlias, } from "./commands.js";
 async function main() {
     await yargs(hideBin(process.argv))
         .scriptName("agentnet")
@@ -270,6 +270,11 @@ async function main() {
         .positional("alias", { type: "string", demandOption: true, describe: "Local display name" })
         .option("config-dir", { type: "string" }), async (argv) => {
         await cmdFriendAlias({ userid: argv.userid, alias: argv.alias, configDir: argv["config-dir"] });
+    })
+        .command("autoaccept [mode]", "Auto-accept incoming friend-requests on|off (off = queue for manual approve). No arg shows current.", (yy) => yy
+        .positional("mode", { type: "string", choices: ["on", "off"], describe: "on = auto-accept; off = queue for manual approval" })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        await cmdFriendsAutoAccept({ mode: argv.mode, configDir: argv["config-dir"] });
     })
         .demandCommand(1, "Specify a friends subcommand (run 'agentnet friends --help')"), () => {
         // parent handler — never invoked because demandCommand above
@@ -312,6 +317,19 @@ async function main() {
     })
         .command("list-hosts", "List the CONNECT host allowlist", (yy) => yy.option("config-dir", { type: "string" }), async (argv) => {
         await cmdProxyListHosts({ configDir: argv["config-dir"] });
+    })
+        .command("who", "Show who is using THIS node's exit (per-peer tunnels + bytes)", (yy) => yy.option("config-dir", { type: "string" }), async (argv) => {
+        await cmdProxyWho({ configDir: argv["config-dir"] });
+    })
+        .command("block <peer>", "Block a peer from using THIS node's exit (live, no restart)", (yy) => yy
+        .positional("peer", { type: "string", demandOption: true })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        await cmdProxyAccess({ peer: argv.peer, allow: false, configDir: argv["config-dir"] });
+    })
+        .command("allow <peer>", "Re-allow a previously-blocked peer to use THIS node's exit (live)", (yy) => yy
+        .positional("peer", { type: "string", demandOption: true })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        await cmdProxyAccess({ peer: argv.peer, allow: true, configDir: argv["config-dir"] });
     })
         .command("use", "Print env vars to route HTTPS via a peer's proxy node", (yy) => yy
         .option("peer", { type: "string", demandOption: true, describe: "Peer name or carrier ID" })

package/dist/config/loader.js

@@ -47,7 +47,6 @@ const DEFAULT_EXPRESS_NODES = [
     { host: "tokyo.fi.chat", port: 8443, pk: "EzpBtoUkjeMQfuLGWwTUbvzCn9rK4J648Ziy21EKxefo" },
 ];
 const DEFAULT_DORAS_FALLBACK = [
-    { name: "dora-mac", userid: "98rsHv17h8G6AP9RagyrBiT1kmw4cn8MFPEembS6ZVjv", address: "Jt7w1pKkyLT5GVue9h6ZPkjg1EeuuTbD6JVSLycXLsdm6nvBGSUd" }, // 10.86.1.10–63.254
     { name: "dora-beagle", userid: "AxKFEZFLDi23EmnJFNP6gjUM4CaNMPfWUvbFR9ixtMBN", address: "NsuN81dZdEoyvwEFgWaHkT8SPJB6UWeRmdYcCGFV5CdbbPXoK2RM" }, // 10.86.64.10–127.254
     { name: "dora-sh", userid: "GMEMLmCWLMBK6BJiMkbLPNkEjF4S2xRf1SqR9hM8fWV3", address: "ajg1ZMBw86UyujmEJzqKSCbi3wwEtg6tdGFTdESakyqujyxmqJZK" }, // 10.86.128.10–191.254
     { name: "dora-tokyo", userid: "AB6BZfbrTFWw9eUoVpHdJqhhRnY8bTttp4CHTZ2Xfzxi", address: "MAW2eBqBuQ6SmaXTrnZRRayQjAj3aLatwPy4xmBp7spnJeV569op" }, // 10.86.192.10–254.254

package/dist/console/console.js

@@ -692,8 +692,6 @@ var DEFAULT_EXPRESS_NODES = [
   { host: "tokyo.fi.chat", port: 8443, pk: "EzpBtoUkjeMQfuLGWwTUbvzCn9rK4J648Ziy21EKxefo" }
 ];
 var DEFAULT_DORAS_FALLBACK = [
-  { name: "dora-mac", userid: "98rsHv17h8G6AP9RagyrBiT1kmw4cn8MFPEembS6ZVjv", address: "Jt7w1pKkyLT5GVue9h6ZPkjg1EeuuTbD6JVSLycXLsdm6nvBGSUd" },
-  // 10.86.1.10–63.254
   { name: "dora-beagle", userid: "AxKFEZFLDi23EmnJFNP6gjUM4CaNMPfWUvbFR9ixtMBN", address: "NsuN81dZdEoyvwEFgWaHkT8SPJB6UWeRmdYcCGFV5CdbbPXoK2RM" },
   // 10.86.64.10–127.254
   { name: "dora-sh", userid: "GMEMLmCWLMBK6BJiMkbLPNkEjF4S2xRf1SqR9hM8fWV3", address: "ajg1ZMBw86UyujmEJzqKSCbi3wwEtg6tdGFTdESakyqujyxmqJZK" },

package/dist/daemon/ipc.d.ts

@@ -51,6 +51,10 @@ export interface IpcHandlers {
     friendRemove: (userid: string) => Promise<void>;
     /** Set/clear a local display alias for a friend. */
     friendSetAlias: (userid: string, alias?: string) => Promise<void>;
+    /** Toggle whether incoming friend-requests are auto-accepted. Applies live
+     *  (no restart) and persists to config.yaml. When off, requests queue to
+     *  friends-pending for manual accept via `agentnet friends pending` / the UI. */
+    friendsAutoAccept: (enabled: boolean) => Promise<Record<string, unknown>>;
     /** Update our own profile (display name + description); persists + re-pushes. */
     setProfile: (info: {
         name?: string;
@@ -80,6 +84,12 @@ export interface IpcHandlers {
      *  restart (which drops every Carrier session). Returns the applied
      *  allowlist for the CLI to echo. */
     proxyReload: () => Promise<Record<string, unknown>>;
+    /** Block or allow a specific peer's access to THIS node's exit proxy port,
+     *  LIVE (mutates the running ACL + persists policy.yaml). `allow=true`
+     *  removes the block; `allow=false` adds a deny rule so the peer can no
+     *  longer tunnel through this exit. Lets an operator cut off a heavy user
+     *  without restarting the daemon. */
+    proxyAccess: (userid: string, allow: boolean) => Promise<Record<string, unknown>>;
     /** Re-exec the running daemon with its original argv. The new
      *  process inherits the current process's privileges (so a
      *  root-owned daemon re-execs as root with no sudo prompt),
@@ -90,7 +100,7 @@ export interface IpcHandlers {
     selfRestart: () => Promise<Record<string, unknown>>;
 }
 export interface IpcRequest {
-    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "set-profile" | "file-send" | "chat-mark-read" | "subscribe" | "sign" | "proxy-reload" | "self-restart";
+    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "friends-autoaccept" | "set-profile" | "file-send" | "chat-mark-read" | "subscribe" | "sign" | "proxy-reload" | "proxy-access" | "self-restart";
     address?: string;
     hello?: string;
     userid?: string;
@@ -102,6 +112,7 @@ export interface IpcRequest {
     before?: number;
     limit?: number;
     ts?: number;
+    enabled?: boolean;
 }
 export interface IpcResponseOk {
     ok: true;

package/dist/daemon/ipc.js

@@ -204,6 +204,11 @@ export class IpcServer {
                 await this.handlers.friendSetAlias(req.userid, req.alias);
                 return;
             }
+            case "friends-autoaccept": {
+                if (typeof req.enabled !== "boolean")
+                    throw new Error("enabled (boolean) is required");
+                return await this.handlers.friendsAutoAccept(req.enabled);
+            }
             case "set-profile": {
                 await this.handlers.setProfile({ name: req.name, description: req.description });
                 return;
@@ -228,6 +233,10 @@ export class IpcServer {
             }
             case "proxy-reload":
                 return await this.handlers.proxyReload();
+            case "proxy-access":
+                if (!req.userid)
+                    throw new Error("proxy-access requires a userid");
+                return await this.handlers.proxyAccess(req.userid, req.enabled !== false);
             case "self-restart":
                 return await this.handlers.selfRestart();
             default:

package/dist/daemon/message-store.d.ts

@@ -14,15 +14,21 @@ export interface ChatMessage {
     ts: number;
     /** Stable per-message id (ts + per-process sequence) for UI keys / dedup. */
     id: string;
+    /** Outgoing-text delivery state. "queued" means the peer was offline when the
+     *  user hit send, so the daemon stored it and will deliver it (in order) the
+     *  moment the friend reconnects. Cleared once actually sent. */
+    status?: "queued" | "sent" | "failed";
     /** Present when this entry is a file transfer rather than a text message.
      *  `name`/`size` describe the file; received files (dir:"in") are saved to
      *  <configDir>/downloads/<name> and downloadable via the UI. For outgoing
      *  files, `status` tracks delivery and `sent` is the acked byte count (live
-     *  progress) — the receiver confirms every byte before status becomes "sent". */
+     *  progress) — the receiver confirms every byte before status becomes "sent".
+     *  "queued" mirrors text: the peer was offline, so the bytes live in
+     *  <configDir>/outbox/<id> until the friend reconnects. */
     file?: {
         name: string;
         size: number;
-        status?: "sending" | "sent" | "failed";
+        status?: "queued" | "sending" | "sent" | "failed";
         sent?: number;
     };
 }
@@ -35,19 +41,29 @@ export declare class MessageStore {
     private seq;
     constructor(path: string);
     private load;
-    /** Append a message and schedule a flush. Returns the stored message. */
-    append(peer: string, dir: "in" | "out", text: string, ts?: number): ChatMessage;
+    /** Append a message and schedule a flush. Returns the stored message.
+     *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
+     *  receive — the daemon flushes it on reconnect. */
+    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed"): ChatMessage;
+    /** 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?: "queued" | "sent" | "failed"): boolean;
+    /** Outgoing messages still awaiting delivery (peer was offline), oldest
+     *  first — both queued text and queued file chips. The daemon drains this
+     *  on a friend's reconnect. */
+    queuedOutgoing(peer: string): ChatMessage[];
     /** Append a file-transfer entry (shown as a file chip in the UI). */
     appendFile(peer: string, dir: "in" | "out", file: {
         name: string;
         size: number;
-        status?: "sending" | "sent" | "failed";
+        status?: "queued" | "sending" | "sent" | "failed";
         sent?: number;
     }, ts?: number): ChatMessage;
     /** Patch an existing file message's transfer fields (status / sent bytes).
      *  No-op if the id isn't found. Returns true if it patched. */
     patchFile(peer: string, id: string, patch: {
-        status?: "sending" | "sent" | "failed";
+        status?: "queued" | "sending" | "sent" | "failed";
         sent?: number;
     }): boolean;
     private push;

package/dist/daemon/message-store.js

@@ -43,9 +43,36 @@ export class MessageStore {
             this.logger.warn(`Could not load ${this.path}: ${err}`);
         }
     }
-    /** Append a message and schedule a flush. Returns the stored message. */
-    append(peer, dir, text, ts = Date.now()) {
-        return this.push(peer, { dir, text, ts, id: `${ts}-${this.seq++}` });
+    /** Append a message and schedule a flush. Returns the stored message.
+     *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
+     *  receive — the daemon flushes it on reconnect. */
+    append(peer, dir, text, ts = Date.now(), status) {
+        const msg = { dir, text, ts, id: `${ts}-${this.seq++}` };
+        if (status)
+            msg.status = status;
+        return this.push(peer, msg);
+    }
+    /** 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) {
+        const arr = this.byPeer.get(peer);
+        const msg = arr?.find((m) => m.id === id);
+        if (!msg || msg.file)
+            return false;
+        if (status)
+            msg.status = status;
+        else
+            delete msg.status;
+        this.scheduleSave();
+        return true;
+    }
+    /** Outgoing messages still awaiting delivery (peer was offline), oldest
+     *  first — both queued text and queued file chips. The daemon drains this
+     *  on a friend's reconnect. */
+    queuedOutgoing(peer) {
+        const arr = this.byPeer.get(peer) ?? [];
+        return arr.filter((m) => m.dir === "out" && (m.status === "queued" || m.file?.status === "queued"));
     }
     /** Append a file-transfer entry (shown as a file chip in the UI). */
     appendFile(peer, dir, file, ts = Date.now()) {

package/dist/daemon/server.d.ts

@@ -44,6 +44,15 @@ export declare class DaemonServer {
     /** Outgoing file transfers in flight: fileId → the chat message tracking it,
      *  so progress/complete/cancel events can patch its status + sent bytes. */
     private readonly activeSends;
+    /** Directory holding queued (offline) outgoing file bytes: <configDir>/outbox.
+     *  One file per queued message, named by its msgId. Set in start(). */
+    private outboxDir;
+    /** Peers whose outbox is currently being drained, so overlapping
+     *  friend-connection "connected" events don't double-send. */
+    private readonly flushingOutbox;
+    /** Largest file we'll hold in the offline outbox. Live transfers handle any
+     *  size; the queue is meant for small things the peer can grab on reconnect. */
+    private static readonly OUTBOX_MAX_FILE_BYTES;
     private startedAt;
     private isRunning;
     private tunRebuildInProgress;
@@ -83,6 +92,16 @@ export declare class DaemonServer {
      *  restarts). Also ensures a friend-meta entry exists so the friend shows up
      *  in the UI list even before it's been renamed. */
     private logChat;
+    /** On startup, re-queue any offline file transfer that was mid-flight when the
+     *  daemon last stopped: an out chip stuck at "sending" whose bytes still sit in
+     *  the outbox. Flips it back to "queued" so the next reconnect redelivers it
+     *  (and the bytes aren't orphaned). */
+    private reconcileOutboxOnStart;
+    /** Deliver everything queued for `userid` while they were offline — queued
+     *  text and queued files, oldest first. Called when a friend reconnects.
+     *  Stops early if the link drops again, leaving the remainder queued for the
+     *  next reconnect (true store-and-forward). Re-entrancy-guarded per peer. */
+    private flushOutbox;
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
     private reFriendAt;