@vdoninja/ninja-p2p 0.1.0 → 0.1.2

package/dist/vdo-bridge.d.ts

@@ -10,7 +10,7 @@
 import { EventEmitter } from "node:events";
 import { MessageBus, type MessageBusOptions } from "./message-bus.js";
 import { PeerRegistry } from "./peer-registry.js";
-import { type AnnouncePayload, type MessageEnvelope, type PeerIdentity } from "./protocol.js";
+import { type AgentProfile, type FileOfferPayload, type AnnouncePayload, type MessageEnvelope, type MessageType, type PeerIdentity } from "./protocol.js";
 export type VDOBridgeOptions = {
     room: string;
     streamId: string;
@@ -23,6 +23,8 @@ export type VDOBridgeOptions = {
     skills?: string[];
     /** Topics to subscribe to. */
     topics?: string[];
+    /** Optional agent profile advertised to peers. */
+    agentProfile?: AgentProfile;
     /** Heartbeat interval in ms. Default: 30000. */
     heartbeatMs?: number;
     /** MessageBus options. */
@@ -40,14 +42,19 @@ export declare class VDOBridge extends EventEmitter {
     private status;
     private statusDetail;
     private version;
+    private agentProfile;
+    private readonly viewedStreamIds;
     constructor(options: VDOBridgeOptions);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
+    private emitBridgeError;
     /** Update skills and broadcast the change. */
     updateSkills(skills: string[]): void;
     /** Update status and broadcast the change. */
     updateStatus(status: string, detail?: string): void;
+    /** Update the advertised agent profile and broadcast the change. */
+    updateAgentProfile(profile: AgentProfile): void;
     /** Get current announce payload. */
     getAnnouncePayload(): AnnouncePayload;
     /** Send a chat message to everyone or a specific peer. */
@@ -58,9 +65,26 @@ export declare class VDOBridge extends EventEmitter {
     command(targetStreamId: string, command: string, args?: unknown): MessageEnvelope;
     /** Publish an event to a topic. */
     publishEvent(topic: string, kind: string, data?: unknown): MessageEnvelope;
+    /** Send a file to a connected peer. */
+    sendFile(targetStreamId: string, filePath: string): FileOfferPayload;
+    /** Send an image to a connected peer. */
+    sendImage(targetStreamId: string, filePath: string): FileOfferPayload;
+    /** Send raw data through the underlying SDK without envelope wrapping. */
+    sendRaw(data: unknown, targetStreamId?: string): boolean;
+    /** Reply to a received message using its sender as the target. */
+    reply(message: MessageEnvelope, type: MessageType, payload: unknown): MessageEnvelope;
+    /** Acknowledge receipt of a received message. */
+    ack(message: MessageEnvelope, payload?: unknown): MessageEnvelope;
+    /** Respond to a command or request-style message. */
+    commandResponse(message: MessageEnvelope, result?: unknown, error?: string): MessageEnvelope;
+    /** Ask a peer to replay recent message history to this bridge. */
+    requestHistory(targetStreamId: string, count?: number): MessageEnvelope;
+    /** Access the underlying VDO.Ninja SDK instance for advanced media workflows. */
+    getSDK(): InstanceType<typeof import("@vdoninja/sdk")> | null;
     private wireSDKEvents;
     private startHeartbeat;
     private stopHeartbeat;
     private respondPong;
     private broadcastSkillUpdate;
+    private maybeViewPeer;
 }

package/dist/vdo-bridge.js

@@ -8,6 +8,7 @@
  * Zero dependencies on stevesbot internals.
  */
 import { EventEmitter } from "node:events";
+import { sendFileFromPath } from "./file-transfer.js";
 import { MessageBus } from "./message-bus.js";
 import { PeerRegistry } from "./peer-registry.js";
 import { createEnvelope, createInstanceId, envelopeToWire, parseEnvelope, } from "./protocol.js";
@@ -23,7 +24,9 @@ export class VDOBridge extends EventEmitter {
     skills;
     status = "idle";
     statusDetail = "";
-    version = "0.1.0";
+    version = "0.1.2";
+    agentProfile;
+    viewedStreamIds = new Set();
     constructor(options) {
         super();
         this.options = options;
@@ -34,6 +37,7 @@ export class VDOBridge extends EventEmitter {
             instanceId: createInstanceId(),
         };
         this.skills = options.skills ?? [];
+        this.agentProfile = options.agentProfile;
         this.peers = new PeerRegistry();
         this.bus = new MessageBus(this.identity, this.peers, options.busOptions);
         // Subscribe to requested topics
@@ -63,7 +67,7 @@ export class VDOBridge extends EventEmitter {
                 this.sdk.sendData(data, target ?? undefined);
             }
             catch (err) {
-                this.emit("error", err);
+                this.emitBridgeError(err);
             }
         });
         await this.sdk.connect();
@@ -100,6 +104,7 @@ export class VDOBridge extends EventEmitter {
         catch { /* best effort */ }
         this.connected = false;
         this.sdk = null;
+        this.viewedStreamIds.clear();
         this.peers.clear();
         console.log("[P2P] Disconnected.");
         this.emit("disconnected");
@@ -107,6 +112,13 @@ export class VDOBridge extends EventEmitter {
     isConnected() {
         return this.connected;
     }
+    emitBridgeError(err) {
+        if (this.listenerCount("error") > 0) {
+            this.emit("error", err);
+            return;
+        }
+        console.error("[P2P] Bridge error:", err);
+    }
     // ── Identity Management ──────────────────────────────────────────────────
     /** Update skills and broadcast the change. */
     updateSkills(skills) {
@@ -119,6 +131,11 @@ export class VDOBridge extends EventEmitter {
         this.statusDetail = detail ?? "";
         this.broadcastSkillUpdate();
     }
+    /** Update the advertised agent profile and broadcast the change. */
+    updateAgentProfile(profile) {
+        this.agentProfile = profile;
+        this.broadcastSkillUpdate();
+    }
     /** Get current announce payload. */
     getAnnouncePayload() {
         return {
@@ -127,6 +144,7 @@ export class VDOBridge extends EventEmitter {
             statusDetail: this.statusDetail,
             version: this.version,
             topics: this.bus.getSubscriptions(),
+            agent: this.agentProfile,
         };
     }
     // ── Convenience Methods ──────────────────────────────────────────────────
@@ -149,6 +167,72 @@ export class VDOBridge extends EventEmitter {
     publishEvent(topic, kind, data) {
         return this.bus.publish(topic, "event", { kind, ...((data && typeof data === "object") ? data : { data }) });
     }
+    /** Send a file to a connected peer. */
+    sendFile(targetStreamId, filePath) {
+        return sendFileFromPath(this, targetStreamId, filePath, "file");
+    }
+    /** Send an image to a connected peer. */
+    sendImage(targetStreamId, filePath) {
+        return sendFileFromPath(this, targetStreamId, filePath, "image");
+    }
+    /** Send raw data through the underlying SDK without envelope wrapping. */
+    sendRaw(data, targetStreamId) {
+        if (!this.sdk)
+            return false;
+        try {
+            if (!targetStreamId) {
+                this.sdk.sendData(data, { allowFallback: true });
+                return true;
+            }
+            const peer = this.peers.getPeer(targetStreamId);
+            if (peer?.uuid) {
+                this.sdk.sendData(data, { UUID: peer.uuid, allowFallback: true });
+            }
+            else {
+                this.sdk.sendData(data, { streamID: targetStreamId, allowFallback: true });
+            }
+            return true;
+        }
+        catch (err) {
+            this.emitBridgeError(err);
+            return false;
+        }
+    }
+    /** Reply to a received message using its sender as the target. */
+    reply(message, type, payload) {
+        return this.bus.send(message.from.streamId, type, payload);
+    }
+    /** Acknowledge receipt of a received message. */
+    ack(message, payload) {
+        const ackPayload = { messageId: message.id };
+        if (payload !== undefined) {
+            ackPayload.data = payload;
+        }
+        return this.bus.send(message.from.streamId, "ack", ackPayload);
+    }
+    /** Respond to a command or request-style message. */
+    commandResponse(message, result, error) {
+        if (error) {
+            return this.bus.send(message.from.streamId, "command_response", {
+                requestId: message.id,
+                ok: false,
+                error,
+            });
+        }
+        return this.bus.send(message.from.streamId, "command_response", {
+            requestId: message.id,
+            ok: true,
+            result: result ?? null,
+        });
+    }
+    /** Ask a peer to replay recent message history to this bridge. */
+    requestHistory(targetStreamId, count = 50) {
+        return this.bus.send(targetStreamId, "history_request", { count });
+    }
+    /** Access the underlying VDO.Ninja SDK instance for advanced media workflows. */
+    getSDK() {
+        return this.sdk;
+    }
     // ── SDK Event Wiring ─────────────────────────────────────────────────────
     wireSDKEvents() {
         if (!this.sdk)
@@ -239,6 +323,7 @@ export class VDOBridge extends EventEmitter {
         this.sdk.addEventListener("peerDisconnected", (event) => {
             const uuid = event.detail?.uuid ?? "unknown";
             const streamId = event.detail?.streamID ?? this.peers.streamIdForUuid(uuid) ?? uuid;
+            this.viewedStreamIds.delete(streamId);
             this.peers.markDisconnected(streamId);
             console.log(`[P2P] Peer disconnected: ${streamId}`);
             this.emit("peer:disconnected", { streamId, uuid });
@@ -257,15 +342,20 @@ export class VDOBridge extends EventEmitter {
             const list = event.detail?.list ?? [];
             for (const entry of list) {
                 if (entry.streamID && entry.streamID !== this.options.streamId) {
-                    // View each existing peer to establish data channels
-                    this.sdk.view(entry.streamID, { audio: false, video: false });
+                    this.maybeViewPeer(entry.streamID);
                 }
             }
         });
+        this.sdk.addEventListener("videoaddedtoroom", (event) => {
+            this.maybeViewPeer(event.detail?.streamID);
+        });
+        this.sdk.addEventListener("streamAdded", (event) => {
+            this.maybeViewPeer(event.detail?.streamID);
+        });
         // Error handling
         this.sdk.addEventListener("error", (event) => {
             console.error("[P2P] SDK error:", event.detail?.error);
-            this.emit("error", event.detail?.error);
+            this.emitBridgeError(event.detail?.error);
         });
     }
     // ── Heartbeat ────────────────────────────────────────────────────────────
@@ -313,6 +403,20 @@ export class VDOBridge extends EventEmitter {
             skills: this.skills,
             status: this.status,
             statusDetail: this.statusDetail,
+            agent: this.agentProfile,
         });
     }
+    maybeViewPeer(streamId) {
+        if (!this.sdk || !streamId || streamId === this.options.streamId || this.viewedStreamIds.has(streamId)) {
+            return;
+        }
+        this.viewedStreamIds.add(streamId);
+        try {
+            this.sdk.view(streamId, { audio: false, video: false });
+        }
+        catch (err) {
+            this.viewedStreamIds.delete(streamId);
+            this.emitBridgeError(err);
+        }
+    }
 }

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@vdoninja/ninja-p2p",
-  "version": "0.1.0",
-  "description": "Reusable P2P agent communication module using VDO.Ninja WebRTC data channels",
+  "version": "0.1.2",
+  "description": "Open source P2P agent messaging and coordination over VDO.Ninja WebRTC data channels",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "ninja-p2p": "./dist/cli.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -22,6 +25,18 @@
       "types": "./dist/peer-registry.d.ts",
       "import": "./dist/peer-registry.js"
     },
+    "./file-transfer": {
+      "types": "./dist/file-transfer.d.ts",
+      "import": "./dist/file-transfer.js"
+    },
+    "./agent-state": {
+      "types": "./dist/agent-state.d.ts",
+      "import": "./dist/agent-state.js"
+    },
+    "./shared-folders": {
+      "types": "./dist/shared-folders.d.ts",
+      "import": "./dist/shared-folders.js"
+    },
     "./protocol": {
       "types": "./dist/protocol.d.ts",
       "import": "./dist/protocol.js"
@@ -33,16 +48,36 @@
     "dist",
     "dashboard.html",
     "README.md",
-    "skills/ninja-p2p"
+    ".codex/skills/ninja-p2p",
+    ".agents/skills/ninja-p2p",
+    ".claude/skills/ninja-p2p"
   ],
   "sideEffects": false,
   "scripts": {
     "test": "tsx --test tests/**/*.test.ts",
     "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc -p tsconfig.json",
+    "validate:live": "node ./scripts/validate-live.mjs",
+    "sync:docs": "node -e \"const fs=require('node:fs'); fs.mkdirSync('docs',{recursive:true}); fs.copyFileSync('dashboard.html','docs/index.html');\"",
     "prepare": "npm run build"
   },
-  "keywords": ["p2p", "webrtc", "vdo.ninja", "agent", "pub-sub", "data-channel", "bot"],
+  "keywords": [
+    "p2p",
+    "webrtc",
+    "vdo.ninja",
+    "agent",
+    "agent-mesh",
+    "cli",
+    "codex",
+    "claude-code",
+    "skill",
+    "pub-sub",
+    "data-channel",
+    "bot",
+    "nat-traversal",
+    "hole-punching",
+    "remote-control"
+  ],
   "author": "Steve Seguin",
   "license": "MIT",
   "publishConfig": {

package/skills/ninja-p2p/SKILL.md

@@ -1,74 +0,0 @@
----
-name: ninja-p2p
-description: Build bot-to-bot communication over VDO.Ninja WebRTC data channels. Use this skill when the user wants agents or services to meet in a room, discover peers, send private messages, broadcast events, or keep lightweight P2P presence without a central relay.
----
-
-# ninja-p2p
-
-Use this skill when a project needs room-based peer discovery and direct messaging between bots over WebRTC.
-
-## What This Repo Provides
-
-- `VDOBridge` for connection lifecycle, room join, announce, heartbeat, and SDK wiring
-- `PeerRegistry` for presence, skills, topics, and status tracking
-- `MessageBus` for broadcast, direct messages, topic-based fanout, history replay, and offline queueing
-- `dashboard.html` for a browser-side room monitor and chat UI
-
-## Install The Library In A Project
-
-Install it from npm:
-
-```bash
-npm install @vdoninja/ninja-p2p @roamhq/wrtc
-```
-
-`@vdoninja/sdk` is installed transitively. `ws` comes from the SDK in Node environments.
-
-## Add This Skill To Codex
-
-Use Codex's built-in `skill-installer` helper and install the `skills/ninja-p2p` path from this repo, then restart Codex.
-
-## Default Integration Pattern
-
-1. Pick a shared `room` for the bots that should discover each other.
-2. Give each bot a unique `streamId`.
-3. Connect with `VDOBridge`.
-4. Use `bridge.chat(text)` for room-wide messages.
-5. Use `bridge.chat(text, targetStreamId)` or `bridge.command(targetStreamId, command, args)` for private messages.
-6. Use `bridge.publishEvent(topic, kind, data)` for topic fanout.
-
-## Example
-
-```ts
-import { VDOBridge } from "@vdoninja/ninja-p2p";
-
-const bridge = new VDOBridge({
-  room: "agents_room",
-  streamId: "planner_bot",
-  identity: {
-    streamId: "planner_bot",
-    role: "agent",
-    name: "Planner",
-  },
-  password: false,
-  skills: ["plan", "chat"],
-  topics: ["events"],
-});
-
-await bridge.connect();
-
-bridge.chat("Planner online");
-bridge.chat("sync now", "worker_bot");
-bridge.publishEvent("events", "status_change", { status: "busy" });
-
-bridge.bus.on("message:chat", (envelope) => {
-  console.log(`${envelope.from.name}: ${envelope.payload.text}`);
-});
-```
-
-## Notes
-
-- `room` and `streamId` should be stable and human-readable, but unique enough to avoid collisions.
-- Private messages target peer `streamId`s.
-- Topic messages are broadcast and filtered on the receiver side.
-- The browser dashboard can sit in the same room as the bots for live inspection.