@decentnetwork/lan 0.1.16 → 0.1.18

package/dist/carrier/peer-manager.js

@@ -159,12 +159,29 @@ export class PeerManager extends EventEmitter {
         if (!this.peer) {
             throw new Error("Peer not created. Call create() first.");
         }
-        return this.peer.friends().map((friend) => ({
-            pubkey: friend.pubkey,
-            name: friend.name,
-            status: friend.status === "online" ? "online" : "offline",
-            lastSeen: friend.acceptedAt,
-        }));
+        return this.peer.friends().map((friend) => {
+            // Preserve the SDK's three-state status ("requested" matters —
+            // collapsing it into "offline" hid the "did my friend-request
+            // make it across?" diagnostic from diag output).
+            const status = friend.status === "online"
+                ? "online"
+                : friend.status === "requested"
+                    ? "requested"
+                    : "offline";
+            // Both pubkey and userid are populated with the base58 userid in
+            // every current SDK code path, but persisted records from
+            // pre-1.7.x clients may only have pubkey. Keep both forms.
+            const carrierId = friend.userid || friend.pubkey;
+            return {
+                pubkey: friend.pubkey,
+                carrierId,
+                name: friend.name,
+                status,
+                address: friend.address,
+                lastSeen: friend.acceptedAt,
+                acceptedAt: friend.acceptedAt,
+            };
+        });
     }
     /**
      * Check if a specific friend is currently online (direct UDP path established).

package/dist/cli/commands.d.ts

@@ -90,13 +90,16 @@ export declare function cmdFriendRequest(args: {
  * (this takes ~45s), then wait for the request to arrive.
  */
 export declare function cmdFriendAccept(args: {
-    pubkey?: string;
+    userid?: string;
     waitForRequest?: boolean;
     waitMs?: number;
     configDir?: string;
 }): Promise<void>;
 /**
- * List friends in the friend store.
+ * List friends in the friend store. Prefers the live daemon over IPC —
+ * opening a second Peer with the same keyfile would stomp on the
+ * daemon's Carrier session, so we only fall back to that path when the
+ * daemon isn't running. Same pattern as `peers list` and `resolve`.
  */
 export declare function cmdFriendsList(args: {
     configDir?: string;

package/dist/cli/commands.js

@@ -460,6 +460,21 @@ export async function cmdFriendRequest(args) {
 export async function cmdFriendAccept(args) {
     const dir = args.configDir || ConfigLoader.defaultConfigDir();
     const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+    // When the daemon is up, route the accept through IPC — no need
+    // to bring the daemon down. This is what 'friends accept' does
+    // and 'friend-accept' is just an alias for that path now.
+    if (daemonPid(config) !== null) {
+        if (!args.userid) {
+            throw new Error("userid is required when the daemon is up. Use 'agentnet friends pending' to see queued requests, then 'agentnet friend-accept <userid>'.");
+        }
+        await cmdFriendsAccept({ userid: args.userid, configDir: args.configDir });
+        return;
+    }
+    // Daemon-down fallback: open a standalone peer. This path stays
+    // because it's the only way to accept a request when the daemon
+    // can't run (e.g. the operator hasn't set up the helper binary
+    // yet). The --wait interactive mode is also useful for one-shot
+    // bootstrapping.
     assertDaemonNotRunning(config, "friend-accept");
     const { Peer } = await import("@decentnetwork/peer");
     const keyFile = resolve(config.carrier.dataDir, "keypair.json");
@@ -487,7 +502,10 @@ export async function cmdFriendAccept(args) {
     if (stored.length === 0) {
         console.warn(`Self-announce got 0 storage nodes — request may still arrive via express relay`);
     }
-    let pubkey = args.pubkey;
+    // The SDK uses `pubkey` as the local-var name historically; semantically
+    // this is the sender's userid (base58). Keep the variable name to
+    // minimize churn but document the mapping.
+    let pubkey = args.userid;
     const wait = args.waitForRequest;
     if (!pubkey || wait) {
         const waitMs = args.waitMs ?? 120000;
@@ -500,7 +518,7 @@ export async function cmdFriendAccept(args) {
         catch (err) {
             if (!pubkey)
                 throw err;
-            console.warn(`No incoming request — will try acceptance with provided pubkey ${pubkey}`);
+            console.warn(`No incoming request — will try acceptance with provided userid ${pubkey}`);
         }
     }
     console.log(`Accepting friend request from ${pubkey}...`);
@@ -511,46 +529,63 @@ export async function cmdFriendAccept(args) {
     console.log(`Friend accepted: ${pubkey}`);
 }
 /**
- * List friends in the friend store.
+ * List friends in the friend store. Prefers the live daemon over IPC —
+ * opening a second Peer with the same keyfile would stomp on the
+ * daemon's Carrier session, so we only fall back to that path when the
+ * daemon isn't running. Same pattern as `peers list` and `resolve`.
  */
 export async function cmdFriendsList(args) {
     const dir = args.configDir || ConfigLoader.defaultConfigDir();
     const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
-    assertDaemonNotRunning(config, "friends list");
-    const { Peer } = await import("@decentnetwork/peer");
-    const keyFile = resolve(config.carrier.dataDir, "keypair.json");
-    if (!existsSync(keyFile)) {
-        console.log("No identity yet. Start the daemon at least once to generate one.");
-        return;
+    let friends;
+    let source;
+    if (daemonPid(config) !== null) {
+        const res = await ipcCall(config, { op: "diag" });
+        if (!res.ok)
+            throw new Error(`Daemon diag failed: ${res.error}`);
+        friends = (res.data.friends ?? []);
+        source = "daemon";
+    }
+    else {
+        const { Peer } = await import("@decentnetwork/peer");
+        const keyFile = resolve(config.carrier.dataDir, "keypair.json");
+        if (!existsSync(keyFile)) {
+            console.log("No identity yet. Start the daemon at least once to generate one.");
+            return;
+        }
+        const peer = await Peer.create({
+            keyFile,
+            compatibilityMode: "legacy",
+            bootstrapNodes: config.carrier.bootstrapNodes,
+            expressNodes: config.carrier.expressNodes,
+        });
+        await peer.start();
+        friends = peer.friends().map((f) => ({
+            pubkey: f.pubkey,
+            carrierId: f.userid || f.pubkey,
+            name: f.name,
+            status: f.status,
+            address: f.address,
+            acceptedAt: f.acceptedAt,
+        }));
+        await peer.stop();
+        source = "disk";
     }
-    // Open peer and start (start() loads friends from disk)
-    const peer = await Peer.create({
-        keyFile,
-        compatibilityMode: "legacy",
-        bootstrapNodes: config.carrier.bootstrapNodes,
-        expressNodes: config.carrier.expressNodes,
-    });
-    await peer.start();
-    const friends = peer.friends();
     if (friends.length === 0) {
         console.log("No friends. Use 'agentnet friend-request --address <addr>' to add one.");
-        await peer.stop();
         return;
     }
-    console.log(`Friends (${friends.length}):`);
+    console.log(`Friends (${friends.length}) ${source === "daemon" ? "[live]" : "[disk]"}:`);
     for (const friend of friends) {
         console.log(``);
         console.log(`  ${friend.name || "(unnamed)"}  status=${friend.status}`);
-        // userid is Carrier's first-class identifier; show that, hide
-        // the raw hex pubkey unless someone explicitly needs it.
-        const userid = friend.userid && friend.userid !== friend.pubkey ? friend.userid : friend.pubkey;
+        const userid = friend.carrierId || friend.pubkey;
         console.log(`    userid:  ${userid}`);
         if (friend.address)
             console.log(`    address: ${friend.address}`);
         if (friend.acceptedAt)
             console.log(`    accepted: ${new Date(friend.acceptedAt).toISOString()}`);
     }
-    await peer.stop();
 }
 /**
  * List queued friend-requests held by the running daemon (the ones

package/dist/cli/index.js

@@ -112,8 +112,8 @@ async function main() {
             configDir: argv["config-dir"],
         });
     })
-        .command("friend-request", "Send a friend request (run while daemon is down)", (y) => y
-        .option("address", { type: "string", demandOption: true, describe: "Recipient Carrier address" })
+        .command("friend-request <address>", "Send a friend request (routes through the running daemon when up; opens a standalone peer when down)", (y) => y
+        .positional("address", { type: "string", demandOption: true, describe: "Recipient Carrier address" })
         .option("hello", { type: "string", describe: "Greeting message" })
         .option("wait-ms", { type: "number", default: 8000, describe: "Wait time for relay delivery" })
         .option("config-dir", { type: "string" }), async (argv) => {
@@ -124,13 +124,27 @@ async function main() {
             configDir: argv["config-dir"],
         });
     })
-        .command("friend-accept", "Accept a friend request (run while daemon is down)", (y) => y
-        .option("pubkey", { type: "string", describe: "Sender pubkey (omit with --wait to receive interactively)" })
-        .option("wait", { type: "boolean", default: false, describe: "Wait for incoming request" })
+        // `friend-accept` is the legacy daemon-down command. With autoAccept
+        // on by default (the standard config), this is rarely used — but we
+        // keep it as an alias for `friends accept` so an operator running
+        // an old recipe doesn't dead-end.
+        //
+        // Positional userid is supported. The flag is named --userid (NOT
+        // --pubkey) because Carrier's identifier model is address + userid;
+        // "pubkey" only exists as a hex-encoded internal representation
+        // operators never need to touch.
+        .command("friend-accept [userid]", "Accept a queued friend-request by userid (alias of 'friends accept')", (y) => y
+        .positional("userid", { type: "string", describe: "Sender's Carrier userid (base58)" })
+        .option("userid", { type: "string", describe: "Sender's Carrier userid (base58)" })
+        // --wait is kept for the daemon-down interactive path
+        // (rarely used now; only matters when autoAccept is off
+        // AND the operator wants to run a one-shot accept without
+        // bringing the daemon up).
+        .option("wait", { type: "boolean", default: false, describe: "Daemon-down mode: wait for an incoming request" })
         .option("wait-ms", { type: "number", default: 120000, describe: "Time to wait for request (ms)" })
         .option("config-dir", { type: "string" }), async (argv) => {
         await cmdFriendAccept({
-            pubkey: argv.pubkey,
+            userid: argv.userid,
             waitForRequest: argv.wait,
             waitMs: argv["wait-ms"],
             configDir: argv["config-dir"],
@@ -149,14 +163,24 @@ async function main() {
         .command("pending", "List queued friend-requests (over IPC; daemon must be up)", (yy) => yy.option("config-dir", { type: "string" }), async (argv) => {
         await cmdFriendsPending({ configDir: argv["config-dir"] });
     })
-        .command("accept", "Accept a queued friend-request by userid (over IPC; daemon stays up)", (yy) => yy
-        .option("userid", { type: "string", demandOption: true, describe: "Sender's Carrier userid (base58)" })
+        // Accept positional userid OR `--userid X`. Operators expect
+        // `agentnet friends accept <userid>` to just work — without
+        // a positional that fails with "Unknown argument: <userid>"
+        // because yargs treats the unflagged value as junk.
+        .command("accept [userid]", "Accept a queued friend-request by userid (over IPC; daemon stays up)", (yy) => yy
+        .positional("userid", { type: "string", describe: "Sender's Carrier userid (base58)" })
+        .option("userid", { type: "string", describe: "Same as positional; either form works" })
         .option("config-dir", { type: "string" }), async (argv) => {
+        if (!argv.userid)
+            throw new Error("userid is required (positional or --userid)");
         await cmdFriendsAccept({ userid: argv.userid, configDir: argv["config-dir"] });
     })
-        .command("reject", "Drop a queued friend-request by userid (over IPC; daemon stays up)", (yy) => yy
-        .option("userid", { type: "string", demandOption: true })
+        .command("reject [userid]", "Drop a queued friend-request by userid (over IPC; daemon stays up)", (yy) => yy
+        .positional("userid", { type: "string", describe: "Sender's Carrier userid (base58)" })
+        .option("userid", { type: "string", describe: "Same as positional; either form works" })
         .option("config-dir", { type: "string" }), async (argv) => {
+        if (!argv.userid)
+            throw new Error("userid is required (positional or --userid)");
         await cmdFriendsReject({ userid: argv.userid, configDir: argv["config-dir"] });
     })
         .demandCommand(1, "Specify a friends subcommand (run 'agentnet friends --help')"), () => {

package/dist/daemon/server.js

@@ -170,6 +170,8 @@ export class DaemonServer {
                             carrierId: f.carrierId,
                             name: f.name,
                             status: f.status,
+                            address: f.address,
+                            acceptedAt: f.acceptedAt,
                         })),
                         ipam: ipamPeers,
                     };

package/dist/types.d.ts

@@ -8,11 +8,21 @@ export interface PeerIdentity {
 }
 export interface RemotePeer {
     pubkey: string;
-    status: "online" | "offline" | "connecting";
+    /**
+     * Mirrors the SDK's FriendRecord.status verbatim:
+     *  - "online":    crypto session established
+     *  - "offline":   was a friend, currently disconnected
+     *  - "requested": we sent a friend-request; peer hasn't accepted
+     * Collapsing "requested" into "offline" loses the operator signal
+     * ("did my friend-request go through?") so keep them distinct.
+     */
+    status: "online" | "offline" | "requested";
     name?: string;
     carrierId?: string;
     virtualIp?: string;
+    address?: string;
     lastSeen?: number;
+    acceptedAt?: number;
 }
 export interface FriendConnectionEvent {
     pubkey: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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",