@decentnetwork/lan 0.1.136 → 0.1.138

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,6 +89,15 @@ 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;
@@ -271,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.
@@ -307,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 }) ?? {} };
@@ -354,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 });
@@ -371,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)");
@@ -426,6 +507,33 @@ export class DaemonServer {
                     }
                     return { applied: true, allowHosts };
                 },
+                proxyAccess: async (userid, allow) => {
+                    // Live block/allow a peer's access to THIS node's exit proxy port.
+                    // Mutates the running ACL (evaluated per-packet, so it's instant) and
+                    // persists policy.yaml. Under the default "allow" policy, a friend can
+                    // use the exit unless we add an explicit DENY — so "block" adds a deny
+                    // rule on the proxy port and "allow" removes the peer's rules.
+                    if (!this.policy)
+                        throw new Error("ACL policy not initialised");
+                    const port = this.config.proxy?.port ?? 8888;
+                    // Accept a userid or a friendly name; store the rule under whatever
+                    // identifier the ACL matches on (both are checked at evaluate time).
+                    const peerKey = userid;
+                    if (allow) {
+                        this.policy.removePeer(peerKey);
+                    }
+                    else {
+                        this.policy.addRule({
+                            peer: peerKey,
+                            direction: "both",
+                            deny: [{ proto: "tcp", port, purpose: "exit-block" }],
+                            audit: true,
+                        });
+                    }
+                    await this.policy.save();
+                    this.logger.info(`Exit access ${allow ? "ALLOWED" : "BLOCKED"} for ${peerKey.slice(0, 12)} (tcp:${port})`);
+                    return { applied: true, userid: peerKey, allowed: allow, port };
+                },
                 selfRestart: async () => {
                     // Detach a child process that waits briefly and then re-execs
                     // the same argv we were started with. Inherits privileges
@@ -505,6 +613,10 @@ export class DaemonServer {
                             session: this.peerManager?.getSessionStatus(f.pubkey) ?? null,
                         })),
                         ipam: ipamPeers,
+                        // Exit-operator view: live per-client usage of THIS node's CONNECT
+                        // proxy (who's tunnelling through me + how much). Null when the
+                        // proxy isn't running.
+                        proxy: this.connectProxy?.getStats() ?? null,
                     };
                 },
             });
@@ -625,7 +737,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) => {
@@ -652,6 +763,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/.
@@ -676,7 +792,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" });
                 }
@@ -693,6 +813,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" });
                         }
                     }
@@ -716,7 +841,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}`);
@@ -948,6 +1075,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/connect-proxy.d.ts

@@ -51,6 +51,17 @@ export interface ConnectProxyOptions {
         bytesTransferred: number;
     }) => void;
 }
+/** Per-client (per source virtual-IP) usage of the exit, so the operator can
+ *  see WHO is using their exit and HOW MUCH — spot heavy/abusive users. */
+export interface ProxyPeerUsage {
+    src: string;
+    srcName?: string;
+    active: number;
+    totalOpened: number;
+    totalRefused: number;
+    bytesTransferred: number;
+    lastSeenMs: number;
+}
 export interface ConnectProxyStats {
     bindIp: string;
     port: number;
@@ -59,13 +70,19 @@ export interface ConnectProxyStats {
     totalOpened: number;
     totalRefused: number;
     bytesTransferred: number;
+    /** Per-client breakdown, heaviest (by bytes) first. */
+    peers: ProxyPeerUsage[];
 }
 export declare class ConnectProxy {
     private opts;
     private server;
     private logger;
     private stats;
+    /** Live per-client usage, keyed by source virtual IP. */
+    private perPeer;
     constructor(opts: ConnectProxyOptions);
+    /** Get-or-create the per-client usage row for a source IP. */
+    private peerRow;
     start(): Promise<void>;
     stop(): Promise<void>;
     getStats(): ConnectProxyStats;

package/dist/proxy/connect-proxy.js

@@ -27,6 +27,8 @@ export class ConnectProxy {
     server = null;
     logger;
     stats;
+    /** Live per-client usage, keyed by source virtual IP. */
+    perPeer = new Map();
     constructor(opts) {
         this.opts = opts;
         this.logger = new Logger({ prefix: "ConnectProxy" });
@@ -38,8 +40,20 @@ export class ConnectProxy {
             totalOpened: 0,
             totalRefused: 0,
             bytesTransferred: 0,
+            peers: [],
         };
     }
+    /** Get-or-create the per-client usage row for a source IP. */
+    peerRow(src, srcName) {
+        let row = this.perPeer.get(src);
+        if (!row) {
+            row = { src, srcName, active: 0, totalOpened: 0, totalRefused: 0, bytesTransferred: 0, lastSeenMs: 0 };
+            this.perPeer.set(src, row);
+        }
+        if (srcName && !row.srcName)
+            row.srcName = srcName;
+        return row;
+    }
     async start() {
         if (this.server) {
             throw new Error("ConnectProxy already started");
@@ -84,7 +98,10 @@ export class ConnectProxy {
         this.logger.info("Stopped");
     }
     getStats() {
-        return { ...this.stats };
+        const peers = [...this.perPeer.values()]
+            .sort((a, b) => b.bytesTransferred - a.bytesTransferred || b.totalOpened - a.totalOpened)
+            .map((p) => ({ ...p }));
+        return { ...this.stats, peers };
     }
     /**
      * Update the host allowlist (and optionally the port allowlist) of a
@@ -139,6 +156,10 @@ export class ConnectProxy {
             clientSocket.destroy();
             this.stats.active = Math.max(0, this.stats.active - 1);
             this.stats.bytesTransferred += bytes;
+            const row = this.peerRow(src, srcName);
+            row.active = Math.max(0, row.active - 1);
+            row.bytesTransferred += bytes;
+            row.lastSeenMs = Date.now();
             this.opts.onTunnelClose?.({
                 src,
                 srcName,
@@ -161,6 +182,10 @@ export class ConnectProxy {
             }
             this.stats.active += 1;
             this.stats.totalOpened += 1;
+            const row = this.peerRow(src, srcName);
+            row.active += 1;
+            row.totalOpened += 1;
+            row.lastSeenMs = Date.now();
             this.opts.onTunnelOpen?.({ src, srcName, target: `${host}:${port}` });
             this.logger.info(`tunnel open  ${src}${srcName ? ` (${srcName})` : ""} -> ${host}:${port}`);
         });
@@ -208,6 +233,9 @@ export class ConnectProxy {
     }
     refuse(clientSocket, src, srcName, target, code, reason) {
         this.stats.totalRefused += 1;
+        const row = this.peerRow(src, srcName);
+        row.totalRefused += 1;
+        row.lastSeenMs = Date.now();
         this.logger.info(`tunnel refused ${src}${srcName ? ` (${srcName})` : ""} -> ${target}: ${reason}`);
         try {
             const statusText = code === 400 ? "Bad Request" : "Forbidden";

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();