@decentnetwork/lan 0.1.135 → 0.1.137

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.

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.

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, 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

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;
@@ -90,7 +94,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" | "self-restart";
     address?: string;
     hello?: string;
     userid?: string;
@@ -102,6 +106,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;

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,8 +44,19 @@ 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;
+    private lastTunRebuildMs;
     private statusTimer?;
     private pidFile?;
     private configDir;
@@ -59,6 +70,12 @@ export declare class DaemonServer {
      * del races the kernel (EBUSY) and the respawn leaves the daemon TUN-less.
      */
     private reconfigureTunTo;
+    /** Watch a TUN device for an unexpected `closed` (the helper died — e.g. on
+     *  WSL after "write tun: invalid argument") and rebuild it, so the data plane
+     *  self-heals instead of staying down until a manual restart. Backoff-guarded
+     *  so a helper that keeps dying immediately doesn't tight-loop. */
+    private attachTunRecovery;
+    private rebuildTun;
     start(): Promise<void>;
     stop(): Promise<void>;
     /**
@@ -75,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;

package/dist/daemon/server.js

@@ -39,6 +39,15 @@ function shellQuote(parts) {
  *  whitespace (e.g. macOS's U+202F narrow no-break space before "PM" in
  *  screenshot/recording names) to a plain space, so files don't need shell
  *  escaping. Never empty. */
+/** True for image/video/audio by extension — the kinds the chat UI previews
+ *  inline. Mirrors dkFileMediaKind() in the desktop UI. Used to decide whether
+ *  to keep a local copy of an OUTGOING file so the sender can play it too. */
+function isMediaFileName(name) {
+    const ext = (name.split(".").pop() || "").toLowerCase();
+    return (["png", "jpg", "jpeg", "gif", "webp", "svg", "heic", "bmp"].includes(ext) ||
+        ["mp4", "mov", "webm", "m4v", "mkv", "avi"].includes(ext) ||
+        ["mp3", "m4a", "aac", "wav", "ogg", "flac", "opus"].includes(ext));
+}
 function sanitizeFileName(name) {
     const cleaned = (name || "file")
         .replace(/[/\\]/g, "_")
@@ -80,8 +89,19 @@ export class DaemonServer {
     /** Outgoing file transfers in flight: fileId → the chat message tracking it,
      *  so progress/complete/cancel events can patch its status + sent bytes. */
     activeSends = new Map();
+    /** Directory holding queued (offline) outgoing file bytes: <configDir>/outbox.
+     *  One file per queued message, named by its msgId. Set in start(). */
+    outboxDir = "";
+    /** Peers whose outbox is currently being drained, so overlapping
+     *  friend-connection "connected" events don't double-send. */
+    flushingOutbox = new Set();
+    /** 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. */
+    static OUTBOX_MAX_FILE_BYTES = 5 * 1024 * 1024;
     startedAt = 0;
     isRunning = false;
+    tunRebuildInProgress = false;
+    lastTunRebuildMs = 0;
     statusTimer;
     pidFile;
     configDir;
@@ -130,12 +150,56 @@ export class DaemonServer {
             // Re-attach the packet-router's TUN listener — it was bound to the old
             // TunDevice instance.
             this.packetRouter?.swapTunDevice(this.tunDevice);
+            this.attachTunRecovery(this.tunDevice);
             this.logger.info(`TUN now at ${newIp}`);
         }
         catch (err) {
             this.logger.error(`Failed to reconfigure TUN to ${newIp}: ${err instanceof Error ? err.message : err}`);
         }
     }
+    /** Watch a TUN device for an unexpected `closed` (the helper died — e.g. on
+     *  WSL after "write tun: invalid argument") and rebuild it, so the data plane
+     *  self-heals instead of staying down until a manual restart. Backoff-guarded
+     *  so a helper that keeps dying immediately doesn't tight-loop. */
+    attachTunRecovery(device) {
+        if (this.useMockTun)
+            return;
+        device.once("closed", () => {
+            if (!this.isRunning || this.useMockTun)
+                return;
+            const delay = Date.now() - this.lastTunRebuildMs < 10_000 ? 5_000 : 1_000;
+            this.logger.warn(`TUN closed unexpectedly — rebuilding data plane in ${delay}ms`);
+            setTimeout(() => void this.rebuildTun(), delay);
+        });
+    }
+    async rebuildTun() {
+        const rm = this.routeManager;
+        if (!this.isRunning || this.useMockTun || this.tunRebuildInProgress || !this.tunDevice || !rm)
+            return;
+        this.tunRebuildInProgress = true;
+        this.lastTunRebuildMs = Date.now();
+        try {
+            const ip = this.tunDevice.getConfig().ip;
+            const dev = new TunDevice({
+                config: { name: this.config.network.interface, ip, subnet: this.config.network.subnet },
+                mockMode: false,
+            });
+            await dev.open();
+            await rm.configureTun({ ...dev.getConfig(), name: dev.getInterface() });
+            this.tunDevice = dev;
+            this.packetRouter?.swapTunDevice(dev);
+            this.attachTunRecovery(dev);
+            this.logger.info(`TUN rebuilt at ${ip} (data plane recovered)`);
+        }
+        catch (err) {
+            this.logger.error(`TUN rebuild failed: ${err instanceof Error ? err.message : err} — retrying in 5s`);
+            this.tunRebuildInProgress = false;
+            if (this.isRunning)
+                setTimeout(() => void this.rebuildTun(), 5_000);
+            return;
+        }
+        this.tunRebuildInProgress = false;
+    }
     async start() {
         if (this.isRunning) {
             throw new Error("Daemon already running");
@@ -225,6 +289,8 @@ export class DaemonServer {
             // On-disk chat + friend-metadata stores (survive restarts; back the UI).
             this.messageStore = new MessageStore(resolve(this.configDir, "messages.json"));
             this.friendMeta = new FriendMetaStore(resolve(this.configDir, "friends-meta.json"));
+            this.outboxDir = resolve(this.configDir, "outbox");
+            this.reconcileOutboxOnStart();
             // Start IPC as soon as the peer is up. The CLI uses it to drive
             // operations that need the daemon's Carrier identity (e.g.
             // friend-request) without spawning a competing Peer instance.
@@ -261,8 +327,23 @@ export class DaemonServer {
                 chatSend: async (userid, text) => {
                     if (!text)
                         return;
-                    await this.peerManager.sendText(userid, text);
-                    this.logChat(userid, "out", text);
+                    // If the friend is online, deliver immediately. If they're offline (or
+                    // the live send throws), queue it: store as "queued" and flush on their
+                    // next reconnect — so chat works store-and-forward, not just live.
+                    if (this.peerManager?.isFriendOnline(userid)) {
+                        try {
+                            await this.peerManager.sendText(userid, text);
+                            this.logChat(userid, "out", text);
+                            return;
+                        }
+                        catch (e) {
+                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, queuing: ${e.message}`);
+                        }
+                    }
+                    this.messageStore?.append(userid, "out", text, Date.now(), "queued");
+                    this.friendMeta?.ensure(userid);
+                    this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                    this.logger.info(`Queued text for offline ${userid.slice(0, 8)} (delivers on reconnect)`);
                 },
                 chatHistory: async (peer, before, limit) => {
                     return { chats: this.messageStore?.history(peer, { before, limit }) ?? {} };
@@ -308,6 +389,16 @@ export class DaemonServer {
                 friendSetAlias: async (userid, alias) => {
                     this.friendMeta?.setAlias(userid, alias);
                 },
+                friendsAutoAccept: async (enabled) => {
+                    // Live toggle: flip in-memory (the friend-request handler reads it
+                    // fresh) AND persist to config.yaml so it survives a restart.
+                    this.config.friends = { ...(this.config.friends ?? {}), autoAccept: enabled };
+                    await ConfigLoader.save(this.config, resolve(this.configDir, "config.yaml")).catch((e) => {
+                        this.logger.warn(`Failed to persist friends.autoAccept: ${e.message}`);
+                    });
+                    this.logger.info(`friends.autoAccept set to ${enabled}`);
+                    return { autoAccept: enabled };
+                },
                 setProfile: async ({ name, description }) => {
                     // Re-push to friends over Carrier (live) …
                     this.peerManager?.setUserInfo({ name, description });
@@ -325,6 +416,42 @@ export class DaemonServer {
                     const { basename } = await import("path");
                     const data = await fs.readFile(path);
                     const name = basename(path);
+                    // Keep a local copy of outgoing MEDIA under downloads/ so the sender
+                    // can preview/play it in chat too (the UI uploads to a temp file that's
+                    // deleted right after send; without this the sender has nothing to
+                    // serve back). The receiver already saves every file the same way.
+                    if (isMediaFileName(name)) {
+                        void (async () => {
+                            try {
+                                const dir = resolve(this.configDir, "downloads");
+                                await fs.mkdir(dir, { recursive: true });
+                                await fs.writeFile(resolve(dir, sanitizeFileName(name)), data);
+                            }
+                            catch (e) {
+                                this.logger.warn(`Could not cache sent media for preview: ${e.message}`);
+                            }
+                        })();
+                    }
+                    // Friend offline → queue the file for delivery on reconnect. Bytes are
+                    // copied into <configDir>/outbox/<msgId> (survives restart). Capped at
+                    // OUTBOX_MAX_FILE_BYTES so the queue stays small; bigger files should
+                    // wait until the peer is online (the live transfer handles any size).
+                    if (!this.peerManager?.isFriendOnline(userid)) {
+                        if (data.length > DaemonServer.OUTBOX_MAX_FILE_BYTES) {
+                            throw new Error(`Peer offline — queued files are limited to ${(DaemonServer.OUTBOX_MAX_FILE_BYTES / 1024 / 1024) | 0} MB ` +
+                                `(this is ${(data.length / 1024 / 1024).toFixed(1)} MB). Send it once they're online.`);
+                        }
+                        const safe = sanitizeFileName(name);
+                        const msg = this.messageStore?.appendFile(userid, "out", { name: safe, size: data.length, status: "queued", sent: 0 });
+                        if (!msg)
+                            throw new Error("Could not queue file (no message store)");
+                        await fs.mkdir(this.outboxDir, { recursive: true });
+                        await fs.writeFile(resolve(this.outboxDir, msg.id), data);
+                        this.friendMeta?.ensure(userid);
+                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                        this.logger.info(`Queued file "${name}" (${data.length}B) for offline ${userid.slice(0, 8)} (delivers on reconnect)`);
+                        return { queued: true, name: safe, size: data.length };
+                    }
                     const fileId = this.peerManager?.sendFile(userid, new Uint8Array(data), name);
                     if (!fileId)
                         throw new Error("No free transfer slot (or friend unknown)");
@@ -540,6 +667,7 @@ export class DaemonServer {
             // In real mode: helper creates the TUN, then we configure IP + route on it.
             // In mock mode: just open the mock device.
             await this.tunDevice.open();
+            this.attachTunRecovery(this.tunDevice);
             if (!this.useMockTun) {
                 // Use the actual device name from the helper (e.g. utun12 on macOS,
                 // agentnet0 on Linux) — different from the configured name.
@@ -578,7 +706,6 @@ export class DaemonServer {
             //   agentnet friends accept --userid <userid>
             //   agentnet friends reject --userid <userid>
             // Pending requests survive daemon restarts.
-            const autoAcceptFriends = this.config.friends?.autoAccept ?? true;
             const pendingPath = resolve(this.config.carrier.dataDir, "..", "pending-friends.json");
             this.pendingFriends = new PendingFriendsStore(pendingPath);
             const pubkeyHexToUserid = async (input) => {
@@ -605,6 +732,11 @@ export class DaemonServer {
             // transitions immediately instead of on the next poll tick.
             this.peerManager.on("friend-connection", (evt) => {
                 this.ipcEvents.emit("event", { type: "presence", userid: evt?.pubkey, status: evt?.status });
+                // A friend just came online — drain anything we queued for them while
+                // they were offline (text + small files), in order.
+                if (evt?.status === "connected" && evt.pubkey) {
+                    void this.flushOutbox(evt.pubkey).catch((e) => this.logger.warn(`Outbox flush for ${evt.pubkey.slice(0, 8)} failed: ${e.message}`));
+                }
             });
             // File transfer (toxcore-standard): auto-accept offers from friends and
             // save completed files under <configDir>/downloads/.
@@ -629,7 +761,11 @@ export class DaemonServer {
                 this.logger.warn(`File send to ${p.friendId.slice(0, 8)} aborted (${p.reason ?? "cancelled"})`);
                 const t = p.fileId ? this.activeSends.get(p.fileId) : undefined;
                 if (t) {
-                    this.messageStore?.patchFile(t.peer, t.msgId, { status: "failed" });
+                    // If this was a queued (offline) send and its bytes are still in the
+                    // outbox, revert the chip to "queued" so it retries on the next
+                    // reconnect instead of dying as "failed". Otherwise mark failed.
+                    const requeue = !!this.outboxDir && existsSync(resolve(this.outboxDir, t.msgId));
+                    this.messageStore?.patchFile(t.peer, t.msgId, { status: requeue ? "queued" : "failed", sent: 0 });
                     this.activeSends.delete(p.fileId);
                     this.ipcEvents.emit("event", { type: "chat", userid: t.peer, dir: "out" });
                 }
@@ -646,6 +782,11 @@ export class DaemonServer {
                         if (t) {
                             this.messageStore?.patchFile(t.peer, t.msgId, { status: "sent", sent: p.size });
                             this.activeSends.delete(p.fileId);
+                            // If this was a queued (offline) send, its bytes lived in the
+                            // outbox — now delivered, drop the copy.
+                            if (this.outboxDir) {
+                                void import("fs/promises").then((fs) => fs.unlink(resolve(this.outboxDir, t.msgId)).catch(() => undefined));
+                            }
                             this.ipcEvents.emit("event", { type: "chat", userid: t.peer, dir: "out" });
                         }
                     }
@@ -669,7 +810,9 @@ export class DaemonServer {
                     const who = `${req.name || "(unnamed)"} ${userid}`;
                     const hello = req.hello ? ` hello="${req.hello.slice(0, 60)}"` : "";
                     this.ipcEvents.emit("event", { type: "request", userid });
-                    if (autoAcceptFriends) {
+                    // Read the flag LIVE (not captured at start) so `agentnet friends
+                    // autoaccept off` takes effect immediately, no daemon restart.
+                    if (this.config.friends?.autoAccept ?? true) {
                         this.logger.info(`Friend request from ${who}${hello} — auto-accepting`);
                         this.peerManager?.acceptFriendRequest(req.pubkey).catch((err) => {
                             this.logger.warn(`Auto-accept failed for ${who}: ${err}`);
@@ -901,6 +1044,84 @@ export class DaemonServer {
         this.friendMeta?.ensure(userid);
         this.ipcEvents.emit("event", { type: "chat", userid, dir });
     }
+    /** 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). */
+    reconcileOutboxOnStart() {
+        if (!this.messageStore || !this.outboxDir)
+            return;
+        let requeued = 0;
+        const all = this.messageStore.history();
+        for (const [peer, msgs] of Object.entries(all)) {
+            for (const m of msgs) {
+                if (m.dir === "out" && m.file?.status === "sending" && existsSync(resolve(this.outboxDir, m.id))) {
+                    this.messageStore.patchFile(peer, m.id, { status: "queued", sent: 0 });
+                    requeued++;
+                }
+            }
+        }
+        if (requeued)
+            this.logger.info(`Re-queued ${requeued} interrupted offline file transfer(s)`);
+    }
+    /** 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. */
+    async flushOutbox(userid) {
+        if (this.flushingOutbox.has(userid))
+            return;
+        if (!this.messageStore || !this.peerManager)
+            return;
+        const queued = this.messageStore.queuedOutgoing(userid);
+        if (!queued.length)
+            return;
+        this.flushingOutbox.add(userid);
+        try {
+            const fs = await import("fs/promises");
+            this.logger.info(`Flushing ${queued.length} queued item(s) to ${userid.slice(0, 8)}`);
+            for (const m of queued) {
+                // Bail if the friend dropped mid-flush — keep the rest queued.
+                if (!this.peerManager.isFriendOnline(userid))
+                    break;
+                if (m.file) {
+                    const bytesPath = resolve(this.outboxDir, m.id);
+                    let data;
+                    try {
+                        data = await fs.readFile(bytesPath);
+                    }
+                    catch {
+                        // Bytes vanished (manual cleanup / earlier delivery) — drop the chip.
+                        this.messageStore.patchFile(userid, m.id, { status: "failed" });
+                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                        continue;
+                    }
+                    const fileId = this.peerManager.sendFile(userid, new Uint8Array(data), m.file.name);
+                    if (!fileId)
+                        break; // no free transfer slot — retry on next reconnect
+                    // Hand off to the live progress/complete path: flip to "sending" and
+                    // track by fileId so file-progress/-complete patch this same chip.
+                    this.messageStore.patchFile(userid, m.id, { status: "sending", sent: 0 });
+                    this.activeSends.set(fileId, { peer: userid, msgId: m.id });
+                    this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                }
+                else {
+                    try {
+                        await this.peerManager.sendText(userid, m.text);
+                        this.messageStore.setStatus(userid, m.id, undefined); // delivered
+                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                    }
+                    catch (e) {
+                        this.logger.warn(`Flush sendText to ${userid.slice(0, 8)} failed: ${e.message}`);
+                        break; // transient — leave this and the rest queued
+                    }
+                }
+            }
+        }
+        finally {
+            this.flushingOutbox.delete(userid);
+        }
+    }
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
     reFriendAt = new Map();

package/dist/proxy/multi-exit-router.js

@@ -300,7 +300,136 @@ export function startMultiExitRouter(opts) {
         client.on("error", () => up.destroy());
         up.on("error", () => client.destroy());
     }
-    const server = http.createServer((_req, res) => { res.writeHead(405); res.end("CONNECT only\n"); });
+    // A destination is "local" when it should be dialed straight from this box on
+    // the normal routing table — loopback, RFC1918, the agentnet 10.86/16 vIPs
+    // (which ride the TUN), and *.decent/*.lan names. For these we must NOT bind
+    // the physical-egress source IP (that would break the TUN route to 10.86.x).
+    function isLocalDest(host) {
+        const h = host.toLowerCase();
+        if (h === "localhost" || h.endsWith(".localhost"))
+            return true;
+        if (h.endsWith(".lan") || h.endsWith(".decent") || h.endsWith(".agentnet") || h.endsWith(".local"))
+            return true;
+        if (h === "::1")
+            return true;
+        if (h.startsWith("fc") || h.startsWith("fd") || h.startsWith("fe80"))
+            return true; // IPv6 ULA / link-local
+        if (/^\d{1,3}(\.\d{1,3}){3}$/.test(h)) {
+            const [a, b] = h.split(".").map(Number);
+            if (a === 127 || a === 10)
+                return true; // loopback / 10/8 (incl 10.86 agentnet)
+            if (a === 192 && b === 168)
+                return true; // 192.168/16
+            if (a === 172 && b >= 16 && b <= 31)
+                return true; // 172.16/12
+            if (a === 169 && b === 254)
+                return true; // link-local
+        }
+        return false;
+    }
+    // Plain-HTTP forwarding (the browser's proxy request for an `http://` URL,
+    // which arrives as a normal request with an absolute-form URL — NOT a CONNECT
+    // tunnel). Dial the origin directly from here and pipe the streams both ways.
+    function httpForwardDirect(host, port, path, req, res, headers) {
+        const bindIp = isLocalDest(host) ? undefined : opts.egressBindIp;
+        directTotal++;
+        const up = http.request({ host, port, path, method: req.method, headers, localAddress: bindIp }, (upRes) => {
+            res.writeHead(upRes.statusCode || 502, upRes.headers);
+            upRes.pipe(res);
+        });
+        up.setTimeout(CONNECT_TIMEOUT_MS, () => up.destroy(new Error("upstream timeout")));
+        up.on("error", (e) => { if (!res.headersSent)
+            res.writeHead(502, { "content-type": "text/plain" }); res.end(`direct proxy error: ${e.message}\n`); });
+        req.pipe(up);
+    }
+    // Plain-HTTP through an exit region: open a CONNECT tunnel to host:port via the
+    // exit, then ride the normal http.request over that raw socket. Fails over to
+    // the next exit if CONNECT is refused.
+    function httpForwardViaExit(order, idx, target, host, port, path, req, res, headers) {
+        if (idx >= order.length) {
+            if (!res.headersSent)
+                res.writeHead(502, { "content-type": "text/plain" });
+            res.end("all exits failed\n");
+            return;
+        }
+        const exit = order[idx];
+        const tun = net.connect(exit.port, exit.host);
+        tun.setTimeout(CONNECT_TIMEOUT_MS, () => tun.destroy());
+        tun.once("connect", () => { tun.setTimeout(0); tun.write(`CONNECT ${target} HTTP/1.1\r\nHost: ${target}\r\n\r\n`); });
+        let buf = Buffer.alloc(0);
+        const onHdr = (chunk) => {
+            buf = Buffer.concat([buf, chunk]);
+            const i = buf.indexOf("\r\n\r\n");
+            if (i === -1)
+                return;
+            tun.removeListener("data", onHdr);
+            const statusLine = buf.slice(0, i).toString("utf8").split("\r\n")[0] || "";
+            if (!/ 200/.test(statusLine)) {
+                tun.destroy();
+                httpForwardViaExit(order, idx + 1, target, host, port, path, req, res, headers);
+                return;
+            }
+            exit.lastSuccessMs = Date.now();
+            exit.fails = 0;
+            if (!exit.healthy)
+                exit.healthy = true;
+            const leftover = buf.slice(i + 4);
+            if (leftover.length)
+                tun.unshift(leftover);
+            const up = http.request({ host, port, path, method: req.method, headers, createConnection: () => tun }, (upRes) => {
+                res.writeHead(upRes.statusCode || 502, upRes.headers);
+                upRes.pipe(res);
+            });
+            up.on("error", (e) => { if (!res.headersSent)
+                res.writeHead(502, { "content-type": "text/plain" }); res.end(`exit proxy error: ${e.message}\n`); });
+            req.pipe(up);
+        };
+        tun.on("data", onHdr);
+        tun.on("error", () => { tun.removeListener("data", onHdr); httpForwardViaExit(order, idx + 1, target, host, port, path, req, res, headers); });
+    }
+    const server = http.createServer((req, res) => {
+        // Browsers send proxy HTTP requests in absolute-form: `GET http://h:p/path`.
+        // Anything else is someone hitting the proxy port directly — show a hint.
+        let parsed;
+        try {
+            parsed = new URL(req.url || "");
+        }
+        catch {
+            res.writeHead(200, { "content-type": "text/plain" });
+            res.end(`agentnet multi-exit proxy [${mode}] on ${listenHost}:${listenPort}\nSet this as your browser's HTTP+HTTPS proxy; http:// and https:// both work.\n`);
+            return;
+        }
+        if (parsed.protocol !== "http:") {
+            res.writeHead(400, { "content-type": "text/plain" });
+            res.end("only http:// here; https:// uses CONNECT\n");
+            return;
+        }
+        const host = parsed.hostname.toLowerCase();
+        const port = Number(parsed.port) || 80;
+        const path = (parsed.pathname || "/") + (parsed.search || "");
+        const target = `${host}:${port}`;
+        // Forward the client's headers minus hop-by-hop proxy bits.
+        const headers = { ...req.headers };
+        delete headers["proxy-connection"];
+        let region = routeFor(host);
+        if (region !== "direct" && !regionHasExits(region))
+            region = "direct";
+        if (!seenHosts.has(host)) {
+            seenHosts.add(host);
+            log(`route ${host} → ${region === "direct" ? "DIRECT" : `region [${region}]`} (http)`);
+        }
+        if (region === "direct") {
+            httpForwardDirect(host, port, path, req, res, headers);
+            return;
+        }
+        const order = pickOrder(region);
+        if (order.length === 0) {
+            res.writeHead(503, { "content-type": "text/plain" });
+            res.end("no healthy exit for region\n");
+            return;
+        }
+        httpForwardViaExit(order, 0, target, host, port, path, req, res, headers);
+    });
     server.on("connect", (req, client, head) => {
         const target = req.url || "";
         const host = (target.split(":")[0] || "").toLowerCase();

package/dist/tun/tun-device.js

@@ -97,8 +97,11 @@ export class TunDevice extends EventEmitter {
             });
             return;
         }
-        // Real mode: framed write to helper stdin
-        if (!this.helper || !this.helper.stdin) {
+        // Real mode: framed write to helper stdin. Bail out cleanly if the pipe is
+        // gone or no longer writable — throwing here is caught by the router's
+        // try/catch (→ recordDrop "tun-write-failed"), whereas writing into a dead
+        // pipe would emit an async EPIPE 'error' event that crashes the daemon.
+        if (!this.helper || !this.helper.stdin || this.helper.stdin.destroyed || !this.helper.stdin.writable) {
             throw new Error("Helper process not available");
         }
         const lenBuf = Buffer.alloc(4);
@@ -204,6 +207,24 @@ export class TunDevice extends EventEmitter {
                 this.emit("closed");
             }
         });
+        // Error handlers on the process AND its pipes. Without these, an EPIPE when
+        // the helper dies mid-write (observed on WSL: repeated "write tun: invalid
+        // argument" → helper exits → the next TUN write hits a broken stdin) is
+        // emitted as an UNHANDLED 'error' event on the stdin socket and crashes the
+        // entire daemon — taking the TUN and every session down. Catch them: log,
+        // and mark the device closed so the router stops writing (drops with
+        // "tun-down") and the reopen path can rebuild the TUN instead of crashing.
+        const onStreamError = (where) => (err) => {
+            this.logger.warn(`TUN helper ${where} error: ${err.message}`);
+            if (this.isOpen) {
+                this.isOpen = false;
+                this.emit("closed");
+            }
+        };
+        this.helper.on("error", onStreamError("process"));
+        this.helper.stdin.on("error", onStreamError("stdin"));
+        this.helper.stdout.on("error", onStreamError("stdout"));
+        this.helper.stderr.on("error", onStreamError("stderr"));
         this.isOpen = true;
         this.emit("ready");
     }

package/dist/ui/desktop/app.js

@@ -285,7 +285,7 @@ function useDaemonData() {
           status: m.file.status,
           pct: m.file.status === "sending" && m.file.size ? Math.min(100, Math.floor((m.file.sent || 0) / m.file.size * 100)) : void 0
         } : void 0,
-        status: m.dir === "out" ? "read" : void 0
+        status: m.dir === "out" ? m.status === "queued" ? "queued" : "read" : void 0
       }));
       const withDay = msgs.length ? [{ day: dkDayLabel(arr[0].ts) }].concat(msgs) : [];
       setThreads((t) => Object.assign({}, t, { [peerId]: withDay }));
@@ -1032,38 +1032,39 @@ const inputStyle = {
 };
 function Msg({ m, peer, T }) {
   const mine = m.from === "me";
-  return /* @__PURE__ */ React.createElement("div", { style: { display: "flex", justifyContent: mine ? "flex-end" : "flex-start", alignItems: "flex-end", gap: 8, margin: "3px 0" } }, !mine && /* @__PURE__ */ React.createElement(DkAvatar, { peer, size: 24, radius: 6, dot: false }), /* @__PURE__ */ React.createElement("div", { style: { maxWidth: "64%", display: "flex", flexDirection: "column", alignItems: mine ? "flex-end" : "flex-start" } }, m.file ? !mine && m.file.status !== "sending" && m.file.status !== "failed" && (m.file.media === "image" || m.file.media === "video" || m.file.media === "audio") ? (
-    // Received media → inline preview / player, with name, size, download.
-    /* @__PURE__ */ React.createElement("div", { style: {
-      display: "flex",
-      flexDirection: "column",
-      gap: 6,
-      maxWidth: 300,
-      background: "var(--bub-them)",
-      border: "1px solid var(--line)",
-      borderRadius: 12,
-      padding: 6
-    } }, m.file.media === "image" && /* @__PURE__ */ React.createElement("a", { href: dkFileUrl(m.file.name), target: "_blank", rel: "noreferrer", style: { display: "block", lineHeight: 0 } }, /* @__PURE__ */ React.createElement(
-      "img",
-      {
-        src: dkFileUrl(m.file.name),
-        alt: m.file.name,
-        style: { display: "block", maxWidth: "100%", maxHeight: 280, borderRadius: 8, objectFit: "cover" }
-      }
-    )), m.file.media === "video" && /* @__PURE__ */ React.createElement(
-      "video",
-      {
-        src: dkFileUrl(m.file.name),
-        controls: true,
-        preload: "metadata",
-        style: { maxWidth: "100%", maxHeight: 320, borderRadius: 8, background: "#000" }
-      }
-    ), m.file.media === "audio" && /* @__PURE__ */ React.createElement("audio", { src: dkFileUrl(m.file.name), controls: true, style: { width: "100%" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8, padding: "0 2px" } }, /* @__PURE__ */ React.createElement("span", { style: { flex: 1, minWidth: 0, fontFamily: "var(--mono)", fontSize: 11, color: "var(--faint)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, m.file.name), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, color: "var(--faint)", flexShrink: 0 } }, m.file.size), /* @__PURE__ */ React.createElement("a", { href: dkFileDownloadUrl(m.file.name), download: m.file.name, title: "download", style: { display: "inline-flex", flexShrink: 0 } }, /* @__PURE__ */ React.createElement(Icon, { name: "download", size: 15, stroke: 2, color: "var(--accent)" }))))
-  ) : React.createElement(
-    mine ? "div" : "a",
-    {
-      ...mine ? {} : { href: dkFileDownloadUrl(m.file.name), download: m.file.name, title: "download" },
-      style: {
+  return /* @__PURE__ */ React.createElement("div", { style: { display: "flex", justifyContent: mine ? "flex-end" : "flex-start", alignItems: "flex-end", gap: 8, margin: "3px 0" } }, !mine && /* @__PURE__ */ React.createElement(DkAvatar, { peer, size: 24, radius: 6, dot: false }), /* @__PURE__ */ React.createElement("div", { style: { maxWidth: "64%", display: "flex", flexDirection: "column", alignItems: mine ? "flex-end" : "flex-start" } }, m.file ? (
+    // Inline preview/player. Received media: as soon as it's saved.
+    // Sent media: once it's fully delivered ('sent') — the daemon keeps a
+    // local copy so it plays on the sender's side too.
+    (m.file.media === "image" || m.file.media === "video" || m.file.media === "audio") && (mine ? m.file.status === "sent" : m.file.status !== "sending" && m.file.status !== "failed" && m.file.status !== "queued") ? (
+      // Received media → inline preview / player, with name, size, download.
+      /* @__PURE__ */ React.createElement("div", { style: {
+        display: "flex",
+        flexDirection: "column",
+        gap: 6,
+        maxWidth: 300,
+        background: "var(--bub-them)",
+        border: "1px solid var(--line)",
+        borderRadius: 12,
+        padding: 6
+      } }, m.file.media === "image" && /* @__PURE__ */ React.createElement("a", { href: dkFileUrl(m.file.name), target: "_blank", rel: "noreferrer", style: { display: "block", lineHeight: 0 } }, /* @__PURE__ */ React.createElement(
+        "img",
+        {
+          src: dkFileUrl(m.file.name),
+          alt: m.file.name,
+          style: { display: "block", maxWidth: "100%", maxHeight: 280, borderRadius: 8, objectFit: "cover" }
+        }
+      )), m.file.media === "video" && /* @__PURE__ */ React.createElement(
+        "video",
+        {
+          src: dkFileUrl(m.file.name),
+          controls: true,
+          preload: "metadata",
+          style: { maxWidth: "100%", maxHeight: 320, borderRadius: 8, background: "#000" }
+        }
+      ), m.file.media === "audio" && /* @__PURE__ */ React.createElement("audio", { src: dkFileUrl(m.file.name), controls: true, style: { width: "100%" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8, padding: "0 2px" } }, /* @__PURE__ */ React.createElement("span", { style: { flex: 1, minWidth: 0, fontFamily: "var(--mono)", fontSize: 11, color: "var(--faint)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, m.file.name), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, color: "var(--faint)", flexShrink: 0 } }, m.file.size), /* @__PURE__ */ React.createElement("a", { href: dkFileDownloadUrl(m.file.name), download: m.file.name, title: "download", style: { display: "inline-flex", flexShrink: 0 } }, /* @__PURE__ */ React.createElement(Icon, { name: "download", size: 15, stroke: 2, color: "var(--accent)" }))))
+    ) : (() => {
+      const cardStyle = {
         display: "flex",
         alignItems: "center",
         gap: 10,
@@ -1074,11 +1075,34 @@ function Msg({ m, peer, T }) {
         minWidth: 200,
         textDecoration: "none",
         cursor: mine ? "default" : "pointer"
+      };
+      const icon = /* @__PURE__ */ React.createElement("div", { style: { width: 34, height: 34, borderRadius: 7, flexShrink: 0, background: mine ? "rgba(255,255,255,0.16)" : "var(--chip)", display: "flex", alignItems: "center", justifyContent: "center", color: mine ? "#fff" : "var(--accent)" } }, /* @__PURE__ */ React.createElement(Icon, { name: m.file.media === "image" ? "image" : m.file.media === "video" ? "video" : m.file.media === "audio" ? "play" : "file", size: 18, stroke: 1.9 }));
+      const meta = /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 600, color: mine ? "#fff" : "var(--text)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, m.file.name), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11, color: mine ? "rgba(255,255,255,0.7)" : "var(--faint)", marginTop: 1 } }, m.file.status === "queued" ? `${m.file.size} \xB7 ${T.queued || "queued"}` : m.file.status === "sending" ? `${m.file.size} \xB7 sending ${m.file.pct != null ? m.file.pct + "%" : "\u2026"}` : m.file.status === "failed" ? `${m.file.size} \xB7 failed` : mine ? `${m.file.size} \xB7 sent` : `${m.file.size} \xB7 ${T.open || "open"}`));
+      if (mine) {
+        return /* @__PURE__ */ React.createElement("div", { style: cardStyle }, icon, meta, m.file.status === "queued" ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }) : m.file.status === "sending" ? /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, fontWeight: 700, color: "rgba(255,255,255,0.9)" } }, m.file.pct != null ? m.file.pct + "%" : "\u2026") : m.file.status === "failed" ? /* @__PURE__ */ React.createElement(Icon, { name: "x", size: 16, stroke: 2.4, color: "rgba(255,200,190,0.95)" }) : /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }));
       }
-    },
-    /* @__PURE__ */ React.createElement("div", { style: { width: 34, height: 34, borderRadius: 7, flexShrink: 0, background: mine ? "rgba(255,255,255,0.16)" : "var(--chip)", display: "flex", alignItems: "center", justifyContent: "center", color: mine ? "#fff" : "var(--accent)" } }, /* @__PURE__ */ React.createElement(Icon, { name: m.file.media === "image" ? "image" : m.file.media === "video" ? "video" : m.file.media === "audio" ? "play" : "file", size: 18, stroke: 1.9 })),
-    /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 600, color: mine ? "#fff" : "var(--text)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, m.file.name), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11, color: mine ? "rgba(255,255,255,0.7)" : "var(--faint)", marginTop: 1 } }, m.file.status === "sending" ? `${m.file.size} \xB7 sending ${m.file.pct != null ? m.file.pct + "%" : "\u2026"}` : m.file.status === "failed" ? `${m.file.size} \xB7 failed` : mine ? `${m.file.size} \xB7 sent` : `${m.file.size} \xB7 download`)),
-    mine ? m.file.status === "sending" ? /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, fontWeight: 700, color: "rgba(255,255,255,0.9)" } }, m.file.pct != null ? m.file.pct + "%" : "\u2026") : m.file.status === "failed" ? /* @__PURE__ */ React.createElement(Icon, { name: "x", size: 16, stroke: 2.4, color: "rgba(255,200,190,0.95)" }) : /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }) : /* @__PURE__ */ React.createElement(Icon, { name: "download", size: 16, stroke: 2, color: "var(--accent)" })
+      return /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: cardStyle,
+          title: "open",
+          onClick: () => window.open(dkFileUrl(m.file.name), "_blank", "noopener")
+        },
+        icon,
+        meta,
+        /* @__PURE__ */ React.createElement(
+          "a",
+          {
+            href: dkFileDownloadUrl(m.file.name),
+            download: m.file.name,
+            title: "download",
+            onClick: (e) => e.stopPropagation(),
+            style: { display: "inline-flex", flexShrink: 0 }
+          },
+          /* @__PURE__ */ React.createElement(Icon, { name: "download", size: 16, stroke: 2, color: "var(--accent)" })
+        )
+      );
+    })()
   ) : /* @__PURE__ */ React.createElement("div", { style: {
     padding: "8px 12px",
     borderRadius: 12,
@@ -1092,7 +1116,7 @@ function Msg({ m, peer, T }) {
     lineHeight: 1.4,
     letterSpacing: -0.1,
     wordBreak: "break-word"
-  } }, m.text), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 4, margin: "3px 3px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.time), mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" }))));
+  } }, m.text), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 4, margin: "3px 3px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.time), mine && m.status === "queued" ? /* @__PURE__ */ React.createElement("span", { style: { display: "inline-flex", alignItems: "center", gap: 2 }, title: "waiting for peer \u2014 will send when they're online" }, /* @__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)" } }, 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)" }))));
 }
 function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, onAlias, onRemove, onOpenNet }) {
   const scrollRef = React.useRef(null);
@@ -1362,6 +1386,8 @@ const STR = {
     message: "Message",
     send: "Send",
     pickPeer: "Select a peer to open the conversation",
+    queued: "queued",
+    open: "open",
     myIp: "my ip",
     copyAddr: "copy address",
     peersOnline: "peers online",
@@ -1437,6 +1463,8 @@ const STR = {
     message: "\u6D88\u606F",
     send: "\u53D1\u9001",
     pickPeer: "\u9009\u62E9\u4E00\u4F4D\u597D\u53CB\u5F00\u59CB\u4F1A\u8BDD",
+    queued: "\u5F85\u53D1\u9001",
+    open: "\u6253\u5F00",
     myIp: "\u6211\u7684 IP",
     copyAddr: "\u590D\u5236\u5730\u5740",
     peersOnline: "\u5728\u7EBF\u597D\u53CB",

package/dist/ui/server.js

@@ -319,10 +319,28 @@ export function startFriendUi(opts) {
                     mp3: "audio/mpeg", m4a: "audio/mp4", aac: "audio/aac", wav: "audio/wav",
                     ogg: "audio/ogg", flac: "audio/flac", opus: "audio/opus",
                     pdf: "application/pdf",
+                    // Text / markup / code / config → served as UTF-8 text so a plain
+                    // click opens (previews) them in the browser instead of forcing a
+                    // download. `.md` and friends are the common case here.
+                    md: "text/markdown", markdown: "text/markdown",
+                    txt: "text/plain", text: "text/plain", log: "text/plain",
+                    json: "application/json", csv: "text/csv", tsv: "text/tab-separated-values",
+                    xml: "text/xml", yaml: "text/plain", yml: "text/plain",
+                    ini: "text/plain", conf: "text/plain", cfg: "text/plain", toml: "text/plain",
+                    html: "text/html", htm: "text/html", css: "text/css",
+                    js: "text/plain", ts: "text/plain", jsx: "text/plain", tsx: "text/plain",
+                    py: "text/plain", sh: "text/plain", srt: "text/plain", vtt: "text/vtt",
                 };
                 const ctype = MIME[ext] || "application/octet-stream";
                 const isMedia = ctype.startsWith("image/") || ctype.startsWith("video/") || ctype.startsWith("audio/");
-                const wantDownload = q.get("dl") === "1" || !isMedia;
+                const isText = ctype.startsWith("text/") || ctype === "application/json" || ctype === "application/pdf";
+                // Anything we can render inline (media, text, pdf) opens on a plain GET;
+                // `?dl=1` forces a save. Binary stays attachment-only.
+                const inlineViewable = isMedia || isText;
+                const wantDownload = q.get("dl") === "1" || !inlineViewable;
+                // Text needs an explicit charset so the browser renders UTF-8 (Chinese
+                // markdown etc.) correctly rather than as mojibake.
+                const ctypeHeader = ctype.startsWith("text/") ? `${ctype}; charset=utf-8` : ctype;
                 // Content-Disposition must be ASCII — Node throws ERR_INVALID_CHAR on a
                 // non-ASCII header value (filenames from macOS contain U+202F before
                 // "PM", and others may be Chinese, etc.). Provide an ASCII-only
@@ -343,7 +361,7 @@ export function startFriendUi(opts) {
                         return;
                     }
                     res.writeHead(206, {
-                        "content-type": ctype,
+                        "content-type": ctypeHeader,
                         "content-disposition": disposition,
                         "accept-ranges": "bytes",
                         "content-range": `bytes ${start}-${end}/${size}`,
@@ -353,7 +371,7 @@ export function startFriendUi(opts) {
                     return;
                 }
                 res.writeHead(200, {
-                    "content-type": ctype,
+                    "content-type": ctypeHeader,
                     "content-disposition": disposition,
                     "accept-ranges": "bytes",
                     "content-length": String(size),

package/docs/INSTALL.md

@@ -13,13 +13,27 @@ transparently between any two daemons that are Carrier friends.
 | | minimum |
 |---|---|
 | Node.js | **20+** |
-| OS | Linux (`x86_64`, `aarch64`) or macOS (`aarch64`, `x86_64`) |
+| OS | Linux (`x86_64`, `aarch64`), macOS (`aarch64`, `x86_64`), or **Windows 10 / 11 via WSL2** ([Windows guide](INSTALL-WINDOWS.md)) |
 | Root / sudo | Yes — needed to create the TUN device. The daemon drops back to user-mode for everything else. |
 | Outbound network | TCP and UDP to public Carrier bootstrap nodes (ports 33445 + 443). No inbound port needed; no public IP needed. |
 
-Windows isn't supported yet; WSL2 with Linux mode works (UDP through
-WSL's NAT is unreliable, so the SDK falls back to TCP relay — works,
-just slower).
+### Windows
+
+Windows **is** supported — but the daemon runs inside **WSL2** (Windows
+Subsystem for Linux), a real Linux environment Windows installs for you, not
+on Windows directly. Requirements:
+
+- **Windows 11**, or **Windows 10 version 2004 or later** (build 19041+) —
+  this is what the one-command `wsl --install` needs.
+- **Fast (direct UDP) path needs Windows 11, version 22H2 or later.** There you
+  turn on WSL **mirrored networking mode**, which lets the direct UDP
+  hole-punch succeed (~200 ms — smooth for live video). On **Windows 10**
+  mirrored mode doesn't exist, so WSL's NAT blocks inbound UDP and the SDK
+  falls back to the TCP relay: it still works, just slower (fine for SSH, chat,
+  and most browsing; live sports may stutter).
+
+👉 **Non-technical step-by-step for Windows users: [INSTALL-WINDOWS.md](INSTALL-WINDOWS.md)**
+(install WSL → install Node.js → install decentlan, three steps).
 
 ## Install
 
@@ -52,7 +66,7 @@ Wait ~60–90s, then verify:
 
 ```bash
 agentnet ipam list           # should show 6+ peers
-agentnet diag | grep tun     # your allocated 10.86.1.x
+agentnet diag | grep tun     # your allocated 10.86.x.x
 ```
 
 > ### If `ipam list` shows only yourself after 2 minutes
@@ -63,7 +77,7 @@ agentnet diag | grep tun     # your allocated 10.86.1.x
 >
 > 1. Re-send the friend-request directly through your live daemon:
 >    ```bash
->    agentnet friend-request Jt7w1pKkyLT5GVue9h6ZPkjg1EeuuTbD6JVSLycXLsdm6nvBGSUd
+>    agentnet friend-request NsuN81dZdEoyvwEFgWaHkT8SPJB6UWeRmdYcCGFV5CdbbPXoK2RM
 >    ```
 >    Then wait 60s and re-check `agentnet ipam list`.
 >

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.135",
+  "version": "0.1.137",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",