@decentnetwork/lan 0.1.0

package/dist/tun/tun-device.js

@@ -0,0 +1,265 @@
+/**
+ * TUN device abstraction for reading/writing IP packets
+ *
+ * Two modes:
+ *  - mockMode (default): in-memory packet queue, used for tests
+ *  - real mode: spawns a Go helper subprocess (bin/tun-helper-{platform})
+ *    that owns the TUN device and pipes packets via stdin/stdout with
+ *    4-byte big-endian length-prefix framing.
+ */
+import { EventEmitter } from "events";
+import { spawn } from "child_process";
+import { resolve, dirname } from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { Logger } from "../utils/logger.js";
+export class TunDevice extends EventEmitter {
+    config;
+    logger;
+    mockMode;
+    helperPath;
+    isOpen = false;
+    packetQueue = [];
+    readLoopActive = false;
+    // Real-mode state
+    helper;
+    stdinBuffer = Buffer.alloc(0);
+    actualDeviceName;
+    constructor(opts) {
+        super();
+        this.config = opts.config;
+        this.mockMode = opts.mockMode ?? true;
+        this.helperPath = opts.helperPath;
+        this.logger = new Logger({ prefix: `TunDevice[${opts.config.name}]` });
+    }
+    async open() {
+        if (this.isOpen) {
+            throw new Error("TUN device already open");
+        }
+        this.logger.info("Opening TUN device");
+        if (this.mockMode) {
+            this.logger.info("Using mock TUN mode (no real /dev/net/tun)");
+            this.isOpen = true;
+            this.emit("ready");
+            return;
+        }
+        await this.openReal();
+    }
+    async close() {
+        if (!this.isOpen) {
+            return;
+        }
+        this.logger.info("Closing TUN device");
+        this.readLoopActive = false;
+        this.isOpen = false;
+        this.packetQueue = [];
+        if (this.helper) {
+            this.helper.kill("SIGTERM");
+            this.helper = undefined;
+        }
+        this.emit("closed");
+    }
+    async write(packet) {
+        if (!this.isOpen) {
+            throw new Error("TUN device not open");
+        }
+        if (this.mockMode) {
+            // Mock mode: emit packet event after write (for test routing)
+            setImmediate(() => {
+                this.emit("packet", packet);
+            });
+            return;
+        }
+        // Real mode: framed write to helper stdin
+        if (!this.helper || !this.helper.stdin) {
+            throw new Error("Helper process not available");
+        }
+        const lenBuf = Buffer.alloc(4);
+        lenBuf.writeUInt32BE(packet.length, 0);
+        const ok = this.helper.stdin.write(lenBuf) &&
+            this.helper.stdin.write(Buffer.from(packet));
+        if (!ok) {
+            // Wait for drain to avoid backpressure issues
+            await new Promise((resolveCb) => {
+                this.helper.stdin.once("drain", resolveCb);
+            });
+        }
+    }
+    async read(timeoutMs) {
+        if (!this.isOpen) {
+            throw new Error("TUN device not open");
+        }
+        return new Promise((resolveCb, rejectCb) => {
+            let timeoutHandle = null;
+            if (this.packetQueue.length > 0) {
+                const packet = this.packetQueue.shift();
+                resolveCb(packet);
+                return;
+            }
+            const onPacket = (packet) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.removeListener("packet", onPacket);
+                resolveCb(packet);
+            };
+            this.once("packet", onPacket);
+            if (timeoutMs) {
+                timeoutHandle = setTimeout(() => {
+                    this.removeListener("packet", onPacket);
+                    rejectCb(new Error(`TUN read timeout after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }
+        });
+    }
+    queuePacket(packet) {
+        this.packetQueue.push(packet);
+        this.emit("packet", packet);
+    }
+    async startReadLoop() {
+        if (this.readLoopActive)
+            return;
+        this.readLoopActive = true;
+        this.logger.info("Starting packet read loop");
+        // Real-mode read loop is event-driven via helper stdout (handled in openReal)
+        // Mock-mode packets come from queuePacket() / write()
+    }
+    async stopReadLoop() {
+        this.readLoopActive = false;
+        this.logger.info("Stopped packet read loop");
+    }
+    getConfig() {
+        return this.config;
+    }
+    isActive() {
+        return this.isOpen;
+    }
+    getInterface() {
+        return this.actualDeviceName || this.config.name;
+    }
+    getVirtualIp() {
+        return this.config.ip;
+    }
+    getSubnet() {
+        return this.config.subnet;
+    }
+    // ============================================================
+    // Real-mode internals
+    // ============================================================
+    async openReal() {
+        const helperPath = this.helperPath || this.findHelperBinary();
+        if (!helperPath || !existsSync(helperPath)) {
+            throw new Error(`TUN helper binary not found: ${helperPath || "(none)"}\n` +
+                `Build it with: cd helper/tun-helper && go build -o bin/tun-helper-linux-amd64 .`);
+        }
+        this.logger.info(`Spawning TUN helper: ${helperPath}`);
+        this.helper = spawn(helperPath, ["--name", this.config.name], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Wait for "READY <devname>" line on stderr
+        const ready = await this.waitForReady();
+        this.actualDeviceName = ready;
+        this.logger.info(`TUN helper ready: ${ready}`);
+        // Set up packet read loop on stdout
+        this.helper.stdout.on("data", (chunk) => {
+            this.handleStdoutData(chunk);
+        });
+        this.helper.stderr.on("data", (chunk) => {
+            const text = chunk.toString().trim();
+            if (text && !text.startsWith("READY ")) {
+                this.logger.warn(`helper stderr: ${text}`);
+            }
+        });
+        this.helper.on("exit", (code, signal) => {
+            this.logger.warn(`TUN helper exited code=${code} signal=${signal}`);
+            this.helper = undefined;
+            if (this.isOpen) {
+                this.isOpen = false;
+                this.emit("closed");
+            }
+        });
+        this.isOpen = true;
+        this.emit("ready");
+    }
+    async waitForReady() {
+        return new Promise((resolveCb, rejectCb) => {
+            let buf = "";
+            const timeout = setTimeout(() => {
+                rejectCb(new Error("TUN helper did not report READY within 5s"));
+            }, 5000);
+            const onStderr = (chunk) => {
+                buf += chunk.toString();
+                const lines = buf.split("\n");
+                for (const line of lines) {
+                    const match = line.match(/^READY (\S+)/);
+                    if (match) {
+                        clearTimeout(timeout);
+                        this.helper.stderr.removeListener("data", onStderr);
+                        resolveCb(match[1]);
+                        return;
+                    }
+                }
+            };
+            this.helper.stderr.on("data", onStderr);
+            this.helper.on("exit", (code) => {
+                clearTimeout(timeout);
+                rejectCb(new Error(`TUN helper exited before ready (code=${code})`));
+            });
+        });
+    }
+    handleStdoutData(chunk) {
+        this.stdinBuffer = Buffer.concat([this.stdinBuffer, chunk]);
+        while (this.stdinBuffer.length >= 4) {
+            const length = this.stdinBuffer.readUInt32BE(0);
+            if (length === 0 || length > 65536) {
+                this.logger.error(`Invalid packet length from helper: ${length}`);
+                this.stdinBuffer = Buffer.alloc(0);
+                return;
+            }
+            if (this.stdinBuffer.length < 4 + length) {
+                // Wait for more data
+                return;
+            }
+            const packet = this.stdinBuffer.subarray(4, 4 + length);
+            this.stdinBuffer = this.stdinBuffer.subarray(4 + length);
+            // Emit as fresh Uint8Array (avoid tying to internal buffer)
+            this.emit("packet", new Uint8Array(packet));
+        }
+    }
+    findHelperBinary() {
+        // Resolve relative to the running script
+        const scriptPath = fileURLToPath(import.meta.url);
+        const moduleDir = dirname(scriptPath);
+        // Walk up to find project root, then bin/
+        const candidates = [
+            resolve(moduleDir, "../../bin"),
+            resolve(moduleDir, "../../../bin"),
+            resolve(process.cwd(), "bin"),
+        ];
+        const platform = process.platform;
+        const arch = process.arch;
+        let suffix;
+        if (platform === "linux" && arch === "x64") {
+            suffix = "linux-amd64";
+        }
+        else if (platform === "darwin" && arch === "arm64") {
+            suffix = "darwin-arm64";
+        }
+        else if (platform === "darwin" && arch === "x64") {
+            suffix = "darwin-amd64";
+        }
+        else if (platform === "linux" && arch === "arm64") {
+            suffix = "linux-arm64";
+        }
+        else {
+            this.logger.warn(`Unsupported platform: ${platform}/${arch}`);
+            return null;
+        }
+        for (const dir of candidates) {
+            const path = resolve(dir, `tun-helper-${suffix}`);
+            if (existsSync(path)) {
+                return path;
+            }
+        }
+        return null;
+    }
+}

package/dist/tun/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * TUN interface types
+ */
+export interface TunDeviceConfig {
+    name: string;
+    ip: string;
+    subnet: string;
+    mtu?: number;
+}
+export interface RouteConfig {
+    interface: string;
+    subnet: string;
+    ip: string;
+}
+export interface IpHeader {
+    version: number;
+    headerLength: number;
+    dscp: number;
+    totalLength: number;
+    identification: number;
+    flags: number;
+    fragmentOffset: number;
+    ttl: number;
+    protocol: number;
+    checksum: number;
+    srcIp: string;
+    dstIp: string;
+}

package/dist/tun/types.js

@@ -0,0 +1,4 @@
+/**
+ * TUN interface types
+ */
+export {};

package/dist/types.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Shared type definitions for Decent AgentNet
+ */
+export interface PeerIdentity {
+    pubkey: string;
+    address: string;
+    userid: string;
+}
+export interface RemotePeer {
+    pubkey: string;
+    status: "online" | "offline" | "connecting";
+    name?: string;
+    carrierId?: string;
+    virtualIp?: string;
+    lastSeen?: number;
+}
+export interface FriendConnectionEvent {
+    pubkey: string;
+    status: "connected" | "disconnected";
+    timestamp?: number;
+}
+export interface Service {
+    name: string;
+    proto: "tcp" | "udp";
+    port: number;
+}
+export interface IpamRecord {
+    name: string;
+    carrierId: string;
+    virtualIp: string;
+    services: Service[];
+    expiresAt?: number;
+}
+export interface IpamConfig {
+    namespace: string;
+    peers: IpamRecord[];
+}
+export interface TunConfig {
+    name: string;
+    ip: string;
+    subnet: string;
+}
+export interface RouteConfig {
+    interface: string;
+    subnet: string;
+    ip: string;
+}
+export type ProtocolType = "tcp" | "udp" | "any";
+export interface AclRule {
+    peer: string;
+    direction?: "inbound" | "outbound" | "both";
+    allow?: AclPermission[];
+    deny?: AclPermission[];
+    expiresAt?: number;
+    audit?: boolean;
+}
+export interface AclPermission {
+    host?: string;
+    proto: ProtocolType;
+    port?: number;
+    purpose?: string;
+}
+export interface PolicyConfig {
+    defaultAction: "allow" | "deny";
+    rules: AclRule[];
+}
+export interface AuditEntry {
+    timestamp: number;
+    type: "access" | "grant" | "revoke" | "connect" | "disconnect" | "proxy_open" | "proxy_close";
+    srcPubkey?: string;
+    srcName?: string;
+    dstIp?: string;
+    dstPort?: number;
+    proto?: ProtocolType;
+    allowed?: boolean;
+    reason?: string;
+    proxyTarget?: string;
+    bytesTransferred?: number;
+}
+export interface PacketFrame {
+    sessionId: number;
+    opcode: number;
+    payload: Uint8Array;
+}
+export interface FrameEncodingOptions {
+    sessionId: number;
+    opcode?: number;
+    magic?: number;
+}
+export interface NodeConfig {
+    name: string;
+    namespace: string;
+}
+export interface BootstrapNode {
+    host: string;
+    port: number;
+    pk: string;
+    isTcp?: boolean;
+}
+export interface CarrierConfig {
+    dataDir: string;
+    bootstrapNodes: BootstrapNode[];
+    expressNodes?: BootstrapNode[];
+}
+export interface NetworkConfig {
+    interface: string;
+    ip: string;
+    subnet: string;
+    dnsDomain: string;
+    dnsPort: number;
+}
+export interface PathsConfig {
+    ipamFile: string;
+    policyFile: string;
+    auditLog: string;
+}
+export interface ProxyConfig {
+    enabled: boolean;
+    port: number;
+    allowHosts?: string[];
+    allowConnectPorts?: number[];
+}
+export interface FriendsConfig {
+    /** When true (default), the running daemon auto-accepts incoming
+     *  friend requests so adding a new peer never requires stopping the
+     *  daemon. Operators who want manual control set this to false; the
+     *  daemon will log incoming requests and a future `agentnet friend
+     *  accept` CLI will let them act on the running daemon. */
+    autoAccept?: boolean;
+}
+/**
+ * Optional integration with a dora (DHCP-style) registry node. When
+ * enabled, the daemon registers its own (userid, name, ip) on startup
+ * and queries the full roster — replacing the manual ipam.yaml dance.
+ * The dora node is just a Carrier peer; the operator friends it once
+ * out-of-band and puts its userid here.
+ */
+export interface DoraConfig {
+    enabled?: boolean;
+    /** Carrier userids of dora servers to try, in order. First responder
+     *  wins. Empty / unset = manual ipam.yaml mode. */
+    userids?: string[];
+    /** How often to re-fetch the full roster from dora. Default 60_000ms. */
+    refreshIntervalMs?: number;
+}
+export interface DecentAgentNetConfig {
+    node: NodeConfig;
+    carrier: CarrierConfig;
+    network: NetworkConfig;
+    paths: PathsConfig;
+    proxy?: ProxyConfig;
+    friends?: FriendsConfig;
+    dora?: DoraConfig;
+}
+export interface PacketSessionInfo {
+    peerId: string;
+    sessionId: number;
+    createdAt: number;
+    lastActivity: number;
+    isActive: boolean;
+}
+export interface DaemonStatus {
+    isRunning: boolean;
+    uptime: number;
+    version: string;
+    identity?: PeerIdentity;
+    tunInterface?: TunConfig;
+    peers: RemotePeer[];
+    activeSessions: number;
+}
+export interface CliContext {
+    configFile: string;
+    config?: DecentAgentNetConfig;
+    verbose?: boolean;
+    debug?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared type definitions for Decent AgentNet
+ */
+export {};

package/dist/utils/logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Simple logging utility for Decent AgentNet
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+}
+export declare class Logger {
+    private levelStr;
+    private level;
+    private prefix;
+    constructor(options?: LoggerOptions);
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    child(prefix: string): Logger;
+}
+export declare const globalLogger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,43 @@
+/**
+ * Simple logging utility for Decent AgentNet
+ */
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+export class Logger {
+    levelStr;
+    level;
+    prefix;
+    constructor(options) {
+        this.levelStr = (options?.level || process.env.AGENTNET_LOG_LEVEL || "info");
+        this.level = LOG_LEVELS[this.levelStr] ?? LOG_LEVELS.info;
+        this.prefix = options?.prefix ? `[${options.prefix}] ` : "";
+    }
+    debug(message, ...args) {
+        if (this.level <= LOG_LEVELS.debug) {
+            console.debug(`${this.prefix}DEBUG: ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.level <= LOG_LEVELS.info) {
+            console.log(`${this.prefix}INFO: ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.level <= LOG_LEVELS.warn) {
+            console.warn(`${this.prefix}WARN: ${message}`, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.level <= LOG_LEVELS.error) {
+            console.error(`${this.prefix}ERROR: ${message}`, ...args);
+        }
+    }
+    child(prefix) {
+        return new Logger({ level: this.levelStr, prefix });
+    }
+}
+export const globalLogger = new Logger();