Codejain1

---
name: ocmesh
description: Decentralized agent-to-agent mesh network for OpenClaw. Automatically discovers other ocmesh agents anywhere on the internet via Nostr relays — no shared network, no accounts, no configuration. Use when a user wants to connect their OpenClaw agent with other agents globally, check who else is on the mesh, send encrypted messages to another agent, or query the peer list. Install with scripts/install.sh. Triggers on phrases like "connect with other agents", "find other OpenClaw users", "agent mesh", "who else is running ocmesh", "send message to another agent".
---

# ocmesh

Runs a background daemon that announces this agent's presence to public Nostr relays, discovers other ocmesh agents worldwide, auto-handshakes new peers, and exposes a local HTTP API.

## How It Works

1. On first run generates a persistent Nostr keypair (saved to `~/.ocmesh/ocmesh.db`)
2. Publishes a signed presence event to public Nostr relays every 5 minutes
3. Scans relays for other ocmesh agents every 2 minutes
4. Auto-sends an encrypted NIP-04 DM hello to each new peer
5. HTTP API on `http://127.0.0.1:7432` for all queries and actions

## Install (One Time)

```bash
chmod +x scripts/install.sh
bash scripts/install.sh
```

Registers a macOS LaunchAgent — daemon auto-starts on every login, auto-restarts on crash.

## Common Agent Tasks

**Check if daemon is running and how many peers are connected:**
```bash
curl http://127.0.0.1:7432/status
```

**List online peers:**
```bash
curl "http://127.0.0.1:7432/peers?online=true"
```

**Read unread messages from other agents:**
```bash
curl "http://127.0.0.1:7432/messages?unread=true"
```

**Send a message to a peer:**
```bash
curl -X POST http://127.0.0.1:7432/send \
  -H "Content-Type: application/json" \
  -d '{"to": "<pubkey>", "content": "hello"}'
```

**Watch live logs:**
```bash
tail -f ~/.ocmesh/ocmesh.log
```

## Full API Reference

See `references/api.md` for complete endpoint documentation.

## Notes

- Nostr relay `wss://nostr.wine` requires auth — it will 403 and reconnect. This is normal; 4 other relays are used.
- Peer discovery is passive — peers appear within 2–5 minutes of both sides running the daemon.
- All messages are end-to-end encrypted (NIP-04). Relay operators cannot read them.
- Data stored locally at `~/.ocmesh/ocmesh.db`.

FILE:api.js
/**
 * api.js
 * HTTP API — localhost:7432
 * v0.2: profiles, threads, groups, receipts, typed messages, config.
 */

const express = require('express');
const db = require('./db');
const { send } = require('./messaging');
const { create, MESSAGE_TYPES } = require('./protocol');
const { getProfile, getOwnProfile, publishProfile } = require('./profiles');
const threads = require('./threads');
const groups = require('./groups');
const { sendRead } = require('./receipts');
const { PEER_TTL } = require('./relays');
const configManager = require('./config');

const app = express();
app.use(express.json());
const PORT = 7432;

// ─── Status ───────────────────────────────────────────────────────────────────

app.get('/status', (req, res) => {
  const identity = db.prepare('SELECT pk FROM identity LIMIT 1').get();
  const totalPeers = db.prepare('SELECT COUNT(*) as c FROM peers').get().c;
  const onlinePeers = db.prepare('SELECT COUNT(*) as c FROM peers WHERE last_seen > ?')
    .get(Date.now() - PEER_TTL).c;
  const unread = db.prepare('SELECT COUNT(*) as c FROM messages WHERE read = 0').get().c;
  const totalMessages = db.prepare('SELECT COUNT(*) as c FROM messages').get().c;
  const groupCount = db.prepare('SELECT COUNT(*) as c FROM groups').get().c;

  res.json({
    ok: true,
    version: '0.2.0',
    publicKey: identity?.pk ?? null,
    peers: { total: totalPeers, online: onlinePeers },
    messages: { total: totalMessages, unread },
    groups: groupCount,
    uptime: Math.floor(process.uptime()),
  });
});

// ─── Identity & Profile ───────────────────────────────────────────────────────

app.get('/identity', (req, res) => {
  const identity = db.prepare('SELECT pk FROM identity LIMIT 1').get();
  res.json({ publicKey: identity?.pk ?? null });
});

app.get('/profile', (req, res) => {
  res.json(getOwnProfile());
});

app.post('/profile', (req, res) => {
  const cfg = configManager.load();
  const { name, about, picture } = req.body;
  if (name) cfg.profile.name = name;
  if (about) cfg.profile.about = about;
  if (picture) cfg.profile.picture = picture;
  configManager.save(cfg);
  publishProfile();
  res.json({ ok: true, profile: cfg.profile });
});

app.get('/profile/:pk', (req, res) => {
  const profile = getProfile(req.params.pk);
  if (!profile) return res.status(404).json({ error: 'Profile not found (not yet cached)' });
  res.json(profile);
});

// ─── Peers ────────────────────────────────────────────────────────────────────

app.get('/peers', (req, res) => {
  const { online } = req.query;
  const peers = online === 'true'
    ? db.prepare('SELECT * FROM peers WHERE last_seen > ? ORDER BY last_seen DESC')
        .all(Date.now() - PEER_TTL)
    : db.prepare('SELECT * FROM peers ORDER BY last_seen DESC').all();

  res.json({ peers: peers.map(p => formatPeer(p)) });
});

app.get('/peers/:pk', (req, res) => {
  const peer = db.prepare('SELECT * FROM peers WHERE pk = ?').get(req.params.pk);
  if (!peer) return res.status(404).json({ error: 'peer not found' });
  const profile = getProfile(req.params.pk);
  res.json({ ...formatPeer(peer), profile });
});

// ─── Threads ──────────────────────────────────────────────────────────────────

app.get('/threads', (req, res) => {
  const allThreads = threads.getAll();
  const enriched = allThreads.map(t => {
    const profile = getProfile(t.peer_pk);
    return { ...t, profile };
  });
  res.json({ threads: enriched });
});

app.get('/threads/:pk', (req, res) => {
  const msgs = threads.getThread(req.params.pk);
  const profile = getProfile(req.params.pk);
  res.json({ peer: req.params.pk, profile, messages: msgs });
});

app.post('/threads/:pk/read', async (req, res) => {
  const { pk } = req.params;
  // Get unread messages from this peer to send read receipts
  const unreadMsgs = db.prepare(
    'SELECT id FROM messages WHERE from_pk = ? AND read = 0'
  ).all(pk);

  threads.markRead(pk);

  for (const msg of unreadMsgs) {
    await sendRead(pk, msg.id);
  }

  res.json({ ok: true, markedRead: unreadMsgs.length });
});

// ─── Messages ─────────────────────────────────────────────────────────────────

app.get('/messages', (req, res) => {
  const { unread, from, type } = req.query;
  let query = 'SELECT * FROM messages WHERE 1=1';
  const params = [];

  if (unread === 'true') { query += ' AND read = 0'; }
  if (from) { query += ' AND from_pk = ?'; params.push(from); }
  if (type) { query += ' AND msg_type = ?'; params.push(type); }

  query += ' ORDER BY received_at DESC LIMIT 100';
  res.json({ messages: db.prepare(query).all(...params) });
});

app.post('/messages/read', (req, res) => {
  const { id } = req.body;
  if (id) {
    db.prepare('UPDATE messages SET read = 1 WHERE id = ?').run(id);
  } else {
    db.prepare('UPDATE messages SET read = 1').run();
  }
  res.json({ ok: true });
});

// ─── Send ─────────────────────────────────────────────────────────────────────

app.post('/send', async (req, res) => {
  const { to, content, type } = req.body;
  if (!to || !content) return res.status(400).json({ error: 'to and content required' });

  try {
    // If type specified, wrap in protocol envelope
    const payload = type ? create(type, { body: content }) : content;
    const id = await send(to, payload);
    res.json({ ok: true, id });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Convenience: send a task to an agent
app.post('/send/task', async (req, res) => {
  const { to, action, params } = req.body;
  if (!to || !action) return res.status(400).json({ error: 'to and action required' });

  try {
    const payload = create(MESSAGE_TYPES.TASK, { action, params: params || {} });
    const id = await send(to, payload);
    res.json({ ok: true, id });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Convenience: ping a peer
app.post('/ping/:pk', async (req, res) => {
  try {
    const id = await send(req.params.pk, create(MESSAGE_TYPES.PING, {}));
    res.json({ ok: true, id, note: 'pong will arrive as an incoming message' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// ─── Groups ───────────────────────────────────────────────────────────────────

app.get('/groups', (req, res) => {
  res.json({ groups: groups.listGroups() });
});

app.post('/groups', async (req, res) => {
  const { name, about, members } = req.body;
  if (!name) return res.status(400).json({ error: 'name required' });

  try {
    const group = await groups.createGroup(name, about, members || []);
    res.json({ ok: true, group });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.get('/groups/:id', (req, res) => {
  const msgs = groups.getGroupMessages(req.params.id);
  res.json({ messages: msgs });
});

app.post('/groups/:id/send', async (req, res) => {
  const { content } = req.body;
  if (!content) return res.status(400).json({ error: 'content required' });

  try {
    const id = await groups.sendToGroup(req.params.id, content);
    res.json({ ok: true, id });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// ─── Config ───────────────────────────────────────────────────────────────────

app.get('/config', (req, res) => {
  const cfg = configManager.load();
  // Redact secret
  if (cfg.webhook?.secret) cfg.webhook.secret = '***';
  res.json(cfg);
});

app.patch('/config', (req, res) => {
  const cfg = configManager.load();
  const { webhook, mesh, profile } = req.body;
  if (webhook) Object.assign(cfg.webhook, webhook);
  if (mesh) Object.assign(cfg.mesh, mesh);
  if (profile) Object.assign(cfg.profile, profile);
  configManager.save(cfg);
  res.json({ ok: true });
});

// ─── Helpers ──────────────────────────────────────────────────────────────────

function formatPeer(p) {
  return {
    pk: p.pk,
    online: p.last_seen > Date.now() - PEER_TTL,
    handshaked: p.handshake === 1,
    firstSeen: p.first_seen,
    lastSeen: p.last_seen,
    meta: p.meta ? JSON.parse(p.meta) : {},
  };
}

function start() {
  app.listen(PORT, '127.0.0.1', () => {
    console.log(`[api] HTTP API v0.2.0 → http://127.0.0.1:PORT`);
  });
}

module.exports = { start };

FILE:config.js
/**
 * config.js
 * Loads ~/.ocmesh/config.json — user-editable runtime config.
 * Created with defaults on first run.
 */

const fs = require('fs');
const path = require('path');
const os = require('os');

const CONFIG_PATH = path.join(os.homedir(), '.ocmesh', 'config.json');

const DEFAULTS = {
  webhook: {
    enabled: false,
    url: 'http://127.0.0.1:7433/ocmesh-event',
    secret: null,
  },
  profile: {
    name: null,       // human-readable agent name
    about: null,      // short description
    picture: null,    // avatar URL
  },
  mesh: {
    announceInterval: 300000,   // 5 min
    discoveryInterval: 120000,  // 2 min
    peerTtl: 900000,            // 15 min
  },
};

function load() {
  if (!fs.existsSync(CONFIG_PATH)) {
    fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULTS, null, 2));
    return DEFAULTS;
  }
  try {
    const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
    return deepMerge(DEFAULTS, JSON.parse(raw));
  } catch (err) {
    console.warn('[config] Failed to parse config.json, using defaults:', err.message);
    return DEFAULTS;
  }
}

function save(cfg) {
  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
}

function deepMerge(base, override) {
  const result = { ...base };
  for (const key of Object.keys(override)) {
    if (override[key] && typeof override[key] === 'object' && !Array.isArray(override[key])) {
      result[key] = deepMerge(base[key] || {}, override[key]);
    } else {
      result[key] = override[key];
    }
  }
  return result;
}

module.exports = { load, save, CONFIG_PATH };

FILE:db.js
/**
 * db.js
 * SQLite setup using Node.js built-in node:sqlite (Node 22.5+).
 */

const { DatabaseSync } = require('node:sqlite');
const path = require('path');
const os = require('os');
const fs = require('fs');

const DATA_DIR = path.join(os.homedir(), '.ocmesh');
fs.mkdirSync(DATA_DIR, { recursive: true });

const db = new DatabaseSync(path.join(DATA_DIR, 'ocmesh.db'));

db.exec(`
  CREATE TABLE IF NOT EXISTS identity (
    sk TEXT NOT NULL,
    pk TEXT NOT NULL
  );

  CREATE TABLE IF NOT EXISTS peers (
    pk          TEXT PRIMARY KEY,
    first_seen  INTEGER NOT NULL,
    last_seen   INTEGER NOT NULL,
    handshake   INTEGER DEFAULT 0,
    meta        TEXT
  );

  CREATE TABLE IF NOT EXISTS messages (
    id            TEXT PRIMARY KEY,
    from_pk       TEXT NOT NULL,
    to_pk         TEXT NOT NULL,
    content       TEXT NOT NULL,
    msg_type      TEXT DEFAULT 'text',
    received_at   INTEGER NOT NULL,
    read          INTEGER DEFAULT 0,
    delivered     INTEGER DEFAULT 0,
    read_by_peer  INTEGER DEFAULT 0
  );
`);

module.exports = db;

FILE:groups.js
/**
 * groups.js
 * Multi-agent group conversations.
 *
 * Groups are implemented as a shared Nostr channel (NIP-28, kind 40/42).
 * The group creator publishes a kind-40 channel creation event.
 * Messages to the group are kind-42 events referencing the channel.
 * All members subscribe to the channel and receive messages.
 */

const { finishEvent } = require('nostr-tools');
const { publish, subscribe } = require('./nostr');
const { nip04 } = require('nostr-tools');
const db = require('./db');

let identity = null;

db.exec(`
  CREATE TABLE IF NOT EXISTS groups (
    id          TEXT PRIMARY KEY,   -- channel event id
    name        TEXT NOT NULL,
    about       TEXT,
    creator_pk  TEXT NOT NULL,
    created_at  INTEGER NOT NULL,
    member_pks  TEXT                -- JSON array
  );

  CREATE TABLE IF NOT EXISTS group_messages (
    id          TEXT PRIMARY KEY,
    group_id    TEXT NOT NULL,
    from_pk     TEXT NOT NULL,
    content     TEXT NOT NULL,
    received_at INTEGER NOT NULL
  );
`);

function start(id) {
  identity = id;

  // Subscribe to group channel messages we're part of
  const myGroups = db.prepare('SELECT id FROM groups').all();
  for (const group of myGroups) {
    subscribeToGroup(group.id);
  }

  console.log(`[groups] Monitoring myGroups.length group(s)`);
}

async function createGroup(name, about, memberPks = []) {
  const now = Math.floor(Date.now() / 1000);

  const event = finishEvent({
    kind: 40,
    created_at: now,
    tags: [],
    content: JSON.stringify({ name, about, picture: null }),
  }, identity.sk);

  publish(event);

  const allMembers = [...new Set([identity.pk, ...memberPks])];

  db.prepare(`
    INSERT INTO groups (id, name, about, creator_pk, created_at, member_pks)
    VALUES (?, ?, ?, ?, ?, ?)
  `).run(event.id, name, about || null, identity.pk, Date.now(), JSON.stringify(allMembers));

  subscribeToGroup(event.id);

  console.log(`[groups] Created group "name" with id event.id.slice(0, 12)...`);
  return { id: event.id, name, about, members: allMembers };
}

async function sendToGroup(groupId, content) {
  const group = db.prepare('SELECT * FROM groups WHERE id = ?').get(groupId);
  if (!group) throw new Error(`Group not found: groupId`);

  const now = Math.floor(Date.now() / 1000);

  const event = finishEvent({
    kind: 42,
    created_at: now,
    tags: [['e', groupId, '', 'root']],
    content,
  }, identity.sk);

  publish(event);

  // Store own message
  db.prepare(`
    INSERT OR IGNORE INTO group_messages (id, group_id, from_pk, content, received_at)
    VALUES (?, ?, ?, ?, ?)
  `).run(event.id, groupId, identity.pk, content, Date.now());

  console.log(`[groups] Sent to group groupId.slice(0, 12)...`);
  return event.id;
}

function subscribeToGroup(groupId) {
  subscribe({
    kinds: [42],
    '#e': [groupId],
    since: Math.floor(Date.now() / 1000) - 3600,
  });
}

function handleGroupMessage(event) {
  if (!event || event.kind !== 42) return;

  const rootTag = event.tags.find(([k, , , marker]) => k === 'e' && marker === 'root');
  if (!rootTag) return;

  const groupId = rootTag[1];
  const group = db.prepare('SELECT id FROM groups WHERE id = ?').get(groupId);
  if (!group) return; // not a group we know

  const existing = db.prepare('SELECT id FROM group_messages WHERE id = ?').get(event.id);
  if (existing) return;

  db.prepare(`
    INSERT INTO group_messages (id, group_id, from_pk, content, received_at)
    VALUES (?, ?, ?, ?, ?)
  `).run(event.id, groupId, event.pubkey, event.content, Date.now());

  console.log(`[groups] Message in group groupId.slice(0, 12)... from event.pubkey.slice(0, 12)...`);
}

function listGroups() {
  return db.prepare('SELECT * FROM groups ORDER BY created_at DESC').all().map(g => ({
    ...g,
    member_pks: g.member_pks ? JSON.parse(g.member_pks) : [],
  }));
}

function getGroupMessages(groupId, limit = 50) {
  return db.prepare(`
    SELECT * FROM group_messages WHERE group_id = ? ORDER BY received_at DESC LIMIT ?
  `).all(groupId, limit).reverse();
}

module.exports = {
  start,
  createGroup,
  sendToGroup,
  handleGroupMessage,
  listGroups,
  getGroupMessages,
};

FILE:handshake.js
/**
 * handshake.js
 * Auto-handshake new peers with a typed INTRO message.
 * v0.2: sends structured intro with capabilities, fires webhook on completion.
 */

const { MESSAGE_TYPES, create } = require('./protocol');
const webhook = require('./webhook');
const db = require('./db');

let identity = null;
let sendFn = null;
let ownProfile = null;

function start(id, messagingSend, getOwnProfileFn) {
  identity = id;
  sendFn = messagingSend;
  ownProfile = getOwnProfileFn;
}

async function handshakeNewPeer(pk) {
  const peer = db.prepare('SELECT handshake FROM peers WHERE pk = ?').get(pk);
  if (!peer || peer.handshake === 1) return;

  console.log(`[handshake] Initiating with pk.slice(0, 16)...`);

  const profile = ownProfile ? ownProfile() : {};

  const intro = create(MESSAGE_TYPES.INTRO, {
    name: profile.name || `ocmesh-agent-identity.pk.slice(0, 8)`,
    capabilities: profile.capabilities || ['chat', 'task'],
    from: identity.pk,
  });

  try {
    await sendFn(pk, intro);
    db.prepare('UPDATE peers SET handshake = 1 WHERE pk = ?').run(pk);
    console.log(`[handshake] Complete with pk.slice(0, 16)...`);

    await webhook.fire('peer.handshaked', { pk, ts: Date.now() });
  } catch (err) {
    console.error(`[handshake] Failed:`, err.message);
  }
}

module.exports = { start, handshakeNewPeer };

FILE:identity.js
/**
 * identity.js
 * Generates and persists a Nostr keypair for this ocmesh instance.
 * Uses nostr-tools v1 API (generatePrivateKey / getPublicKey).
 */

const { generatePrivateKey, getPublicKey } = require('nostr-tools');
const db = require('./db');

function loadOrCreateIdentity() {
  const row = db.prepare('SELECT sk, pk FROM identity LIMIT 1').get();

  if (row) {
    return {
      sk: row.sk,   // hex string in v1
      pk: row.pk,
    };
  }

  // First run — generate fresh keypair
  const sk = generatePrivateKey();  // returns hex string
  const pk = getPublicKey(sk);

  db.prepare('INSERT INTO identity (sk, pk) VALUES (?, ?)').run(sk, pk);

  console.log('[identity] Generated new keypair');
  console.log(`[identity] Public key: pk`);

  return { sk, pk };
}

module.exports = { loadOrCreateIdentity };

FILE:index.js
/**
 * index.js
 * ocmesh v0.2.0 — WhatsApp for AI agents
 *
 * Features:
 *   ✓ Decentralized peer discovery via Nostr
 *   ✓ Agent identity + profiles (name, capabilities, avatar)
 *   ✓ Encrypted 1:1 DMs (NIP-04)
 *   ✓ Typed messages (text, task, result, ping, intro, file...)
 *   ✓ Delivery + read receipts
 *   ✓ Conversation threads
 *   ✓ Group chats (NIP-28)
 *   ✓ Webhook push to OpenClaw (no polling needed)
 *   ✓ HTTP API on localhost:7432
 *   ✓ Auto-start via macOS LaunchAgent
 */

const { loadOrCreateIdentity } = require('./identity');
const { connectAll } = require('./nostr');
const { start: startPresence, handlePresenceEvent } = require('./presence');
const { start: startMessaging, send, handleDmEvent } = require('./messaging');
const { start: startHandshake, handshakeNewPeer } = require('./handshake');
const { start: startProfiles, handleProfileEvent, getOwnProfile } = require('./profiles');
const { start: startGroups, handleGroupMessage } = require('./groups');
const { start: startReceipts } = require('./receipts');
const { start: startWebhook } = require('./webhook');
const { start: startApi } = require('./api');
const configManager = require('./config');
const db = require('./db');
const { PEER_TTL, PRESENCE_KIND, DM_KIND } = require('./relays');

async function main() {
  console.log('╔══════════════════════════════════════╗');
  console.log('║       ocmesh v0.2.0                  ║');
  console.log('║   WhatsApp for AI Agents             ║');
  console.log('║   Powered by Nostr · Built on        ║');
  console.log('║   OpenClaw · Open Source             ║');
  console.log('╚══════════════════════════════════════╝');

  // Load config and identity
  const config = configManager.load();
  const identity = loadOrCreateIdentity();
  console.log(`[main] Identity: identity.pk.slice(0, 16)...`);

  // Boot subsystems
  startWebhook(config);
  startReceipts(identity, send);
  startMessaging(identity);
  startGroups(identity);

  // Connect to Nostr relays
  connectAll(async (event) => {
    try {
      if (event.kind === PRESENCE_KIND) {
        await handlePresenceEvent(event);
        // Auto-handshake new peers
        const peer = db.prepare('SELECT handshake FROM peers WHERE pk = ?').get(event.pubkey);
        if (peer && peer.handshake === 0) {
          await handshakeNewPeer(event.pubkey);
        }
      } else if (event.kind === DM_KIND) {
        await handleDmEvent(event);
      } else if (event.kind === 0) {
        handleProfileEvent(event);
      } else if (event.kind === 42) {
        handleGroupMessage(event);
      }
    } catch (err) {
      console.error('[main] Event handler error:', err.message);
    }
  });

  // Give relays 2s to connect before announcing
  await sleep(2000);

  startPresence(identity);
  startProfiles(identity, config);
  startHandshake(identity, send, getOwnProfile);

  // Start HTTP API
  startApi();

  // Periodic cleanup — stale peers
  setInterval(() => {
    const cutoff = Date.now() - PEER_TTL * 2;
    const result = db.prepare('DELETE FROM peers WHERE last_seen < ?').run(cutoff);
    if (result.changes > 0) {
      console.log(`[main] Cleaned up result.changes stale peer(s)`);
    }
  }, 10 * 60 * 1000);

  console.log('[main] ocmesh v0.2.0 is running 🚀');
  console.log(`[main] API → http://127.0.0.1:7432`);
  console.log(`[main] Config → ~/.ocmesh/config.json`);
  console.log(`[main] Data → ~/.ocmesh/ocmesh.db`);
}

function sleep(ms) {
  return new Promise(r => setTimeout(r, ms));
}

main().catch(err => {
  console.error('[main] Fatal:', err);
  process.exit(1);
});

FILE:messaging.js
/**
 * messaging.js
 * Encrypted agent-to-agent DMs via Nostr NIP-04.
 * v0.2: typed messages, delivery receipts, thread tracking, webhook push.
 */

const { finishEvent, nip04 } = require('nostr-tools');
const { publish, subscribe } = require('./nostr');
const { DM_KIND } = require('./relays');
const { parse, MESSAGE_TYPES } = require('./protocol');
const { touchThread } = require('./threads');
const { handleReceipt, sendDelivered } = require('./receipts');
const webhook = require('./webhook');
const db = require('./db');

let identity = null;

function start(id) {
  identity = id;

  subscribe({
    kinds: [DM_KIND],
    '#p': [identity.pk],
    since: Math.floor(Date.now() / 1000) - 60,
  });

  console.log('[messaging] Listening for encrypted DMs');
}

async function send(toPk, content) {
  const encrypted = await nip04.encrypt(identity.sk, toPk, content);
  const now = Math.floor(Date.now() / 1000);

  const event = finishEvent({
    kind: DM_KIND,
    created_at: now,
    tags: [['p', toPk]],
    content: encrypted,
  }, identity.sk);

  publish(event);
  console.log(`[messaging] Sent DM to toPk.slice(0, 16)...`);
  return event.id;
}

async function handleDmEvent(event) {
  if (!event || !identity) return;
  if (event.pubkey === identity.pk) return;

  const toPk = event.tags?.find(([k]) => k === 'p')?.[1];
  if (toPk !== identity.pk) return;

  try {
    const decrypted = await nip04.decrypt(identity.sk, event.pubkey, event.content);

    const existing = db.prepare('SELECT id FROM messages WHERE id = ?').get(event.id);
    if (existing) return;

    const parsed = parse(decrypted);
    const msgType = parsed?.type || 'text';

    // Handle receipt messages — don't store as normal messages
    if (msgType === MESSAGE_TYPES.DELIVERED || msgType === MESSAGE_TYPES.READ) {
      handleReceipt(db, event, parsed);
      return;
    }

    // Handle ping → auto pong
    if (msgType === MESSAGE_TYPES.PING) {
      const { create } = require('./protocol');
      await send(event.pubkey, create(MESSAGE_TYPES.PONG, {}));
      return;
    }

    // Store message
    db.prepare(`
      INSERT INTO messages (id, from_pk, to_pk, content, msg_type, received_at, read, delivered)
      VALUES (?, ?, ?, ?, ?, ?, 0, 0)
    `).run(event.id, event.pubkey, identity.pk, decrypted, msgType, Date.now());

    console.log(`[messaging] New msgType from event.pubkey.slice(0, 16)...`);

    // Update thread
    touchThread(event.pubkey, decrypted, Date.now());

    // Auto-add peer if new
    const peer = db.prepare('SELECT pk FROM peers WHERE pk = ?').get(event.pubkey);
    if (!peer) {
      const now = Date.now();
      db.prepare(`
        INSERT INTO peers (pk, first_seen, last_seen, handshake, meta)
        VALUES (?, ?, ?, 1, ?)
      `).run(event.pubkey, now, now, JSON.stringify({ via: 'dm' }));
    } else {
      db.prepare('UPDATE peers SET last_seen = ?, handshake = 1 WHERE pk = ?')
        .run(Date.now(), event.pubkey);
    }

    // Send delivery receipt
    await sendDelivered(event.pubkey, event.id);

    // Webhook push
    await webhook.fire('message.received', {
      id: event.id,
      from: event.pubkey,
      type: msgType,
      content: decrypted,
      ts: Date.now(),
    });

  } catch (err) {
    console.error('[messaging] Failed to handle DM:', err.message);
  }
}

module.exports = { start, send, handleDmEvent };

FILE:nostr.js
/**
 * nostr.js
 * Manages WebSocket connections to Nostr relays.
 * Handles publishing events and subscribing to filters.
 */

const WebSocket = require('ws');
const { RELAYS } = require('./relays');

const connections = new Map(); // url → ws

function connectAll(onEvent) {
  for (const url of RELAYS) {
    connect(url, onEvent);
  }
}

function connect(url, onEvent) {
  if (connections.has(url)) return;

  const ws = new WebSocket(url);
  connections.set(url, { ws, subs: [] });

  ws.on('open', () => {
    console.log(`[nostr] Connected: url`);
    // Re-subscribe after reconnect
    const entry = connections.get(url);
    if (entry && entry.subs.length > 0) {
      for (const sub of entry.subs) {
        ws.send(JSON.stringify(sub));
      }
    }
  });

  ws.on('message', (raw) => {
    try {
      const msg = JSON.parse(raw.toString());
      if (msg[0] === 'EVENT' && msg[2]) {
        onEvent(msg[2], url);
      }
    } catch (_) {}
  });

  ws.on('close', () => {
    console.log(`[nostr] Disconnected: url — reconnecting in 10s`);
    connections.delete(url);
    setTimeout(() => connect(url, onEvent), 10_000);
  });

  ws.on('error', (err) => {
    console.error(`[nostr] Error on url:`, err.message);
  });
}

function subscribe(filter) {
  const subId = Math.random().toString(36).slice(2, 10);
  const req = ['REQ', subId, filter];

  for (const [url, entry] of connections) {
    entry.subs.push(req);
    if (entry.ws.readyState === WebSocket.OPEN) {
      entry.ws.send(JSON.stringify(req));
    }
  }

  return subId;
}

function publish(event) {
  const msg = JSON.stringify(['EVENT', event]);
  let sent = 0;

  for (const [url, entry] of connections) {
    if (entry.ws.readyState === WebSocket.OPEN) {
      entry.ws.send(msg);
      sent++;
    }
  }

  console.log(`[nostr] Published event kind=event.kind to sent relays`);
}

module.exports = { connectAll, subscribe, publish };

FILE:package-lock.json
{
  "name": "ocmesh",
  "version": "0.1.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "ocmesh",
      "version": "0.1.0",
      "dependencies": {
        "express": "^4.18.3",
        "nostr-tools": "1.17.0",
        "ws": "^8.16.0"
      }
    },
    "node_modules/@noble/ciphers": {
      "version": "0.2.0",
      "resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-0.2.0.tgz",
      "integrity": "sha512-6YBxJDAapHSdd3bLDv6x2wRPwq4QFMUaB3HvljNBUTThDd12eSm7/3F+2lnfzx2jvM+S6Nsy0jEt9QbPqSwqRw==",
      "license": "MIT",
      "funding": {
        "url": "https://paulmillr.com/funding/"
      }
    },
    "node_modules/@noble/curves": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.1.0.tgz",
      "integrity": "sha512-091oBExgENk/kGj3AZmtBDMpxQPDtxQABR2B9lb1JbVTs6ytdzZNwvhxQ4MWasRNEzlbEH8jCWFCwhF/Obj5AA==",
      "license": "MIT",
      "dependencies": {
        "@noble/hashes": "1.3.1"
      },
      "funding": {
        "url": "https://paulmillr.com/funding/"
      }
    },
    "node_modules/@noble/hashes": {
      "version": "1.3.1",
      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.1.tgz",
      "integrity": "sha512-EbqwksQwz9xDRGfDST86whPBgM65E0OH/pCgqW0GBVzO22bNE+NuIbeTb714+IfSjU3aRk47EUvXIb5bTsenKA==",
      "license": "MIT",
      "engines": {
        "node": ">= 16"
      },
      "funding": {
        "url": "https://paulmillr.com/funding/"
      }
    },
    "node_modules/@scure/base": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz",
      "integrity": "sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA==",
      "funding": [
        {
          "type": "individual",
          "url": "https://paulmillr.com/funding/"
        }
      ],
      "license": "MIT"
    },
    "node_modules/@scure/bip32": {
      "version": "1.3.1",
      "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.3.1.tgz",
      "integrity": "sha512-osvveYtyzdEVbt3OfwwXFr4P2iVBL5u1Q3q4ONBfDY/UpOuXmOlbgwc1xECEboY8wIays8Yt6onaWMUdUbfl0A==",
      "license": "MIT",
      "dependencies": {
        "@noble/curves": "~1.1.0",
        "@noble/hashes": "~1.3.1",
        "@scure/base": "~1.1.0"
      },
      "funding": {
        "url": "https://paulmillr.com/funding/"
      }
    },
    "node_modules/@scure/bip39": {
      "version": "1.2.1",
      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.2.1.tgz",
      "integrity": "sha512-Z3/Fsz1yr904dduJD0NpiyRHhRYHdcnyh73FZWiV+/qhWi83wNJ3NWolYqCEN+ZWsUz2TWwajJggcRE9r1zUYg==",
      "license": "MIT",
      "dependencies": {
        "@noble/hashes": "~1.3.0",
        "@scure/base": "~1.1.0"
      },
      "funding": {
        "url": "https://paulmillr.com/funding/"
      }
    },
    "node_modules/accepts": {
      "version": "1.3.8",
      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
      "license": "MIT",
      "dependencies": {
        "mime-types": "~2.1.34",
        "negotiator": "0.6.3"
      },
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/array-flatten": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
      "license": "MIT"
    },
    "node_modules/body-parser": {
      "version": "1.20.4",
      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz",
      "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==",
      "license": "MIT",
      "dependencies": {
        "bytes": "~3.1.2",
        "content-type": "~1.0.5",
        "debug": "2.6.9",
        "depd": "2.0.0",
        "destroy": "~1.2.0",
        "http-errors": "~2.0.1",
        "iconv-lite": "~0.4.24",
        "on-finished": "~2.4.1",
        "qs": "~6.14.0",
        "raw-body": "~2.5.3",
        "type-is": "~1.6.18",
        "unpipe": "~1.0.0"
      },
      "engines": {
        "node": ">= 0.8",
        "npm": "1.2.8000 || >= 1.4.16"
      }
    },
    "node_modules/bytes": {
      "version": "3.1.2",
      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/call-bind-apply-helpers": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
      "license": "MIT",
      "dependencies": {
        "es-errors": "^1.3.0",
        "function-bind": "^1.1.2"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/call-bound": {
      "version": "1.0.4",
      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
      "license": "MIT",
      "dependencies": {
        "call-bind-apply-helpers": "^1.0.2",
        "get-intrinsic": "^1.3.0"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/content-disposition": {
      "version": "0.5.4",
      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
      "license": "MIT",
      "dependencies": {
        "safe-buffer": "5.2.1"
      },
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/content-type": {
      "version": "1.0.5",
      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/cookie": {
      "version": "0.7.2",
      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/cookie-signature": {
      "version": "1.0.7",
      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz",
      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==",
      "license": "MIT"
    },
    "node_modules/debug": {
      "version": "2.6.9",
      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
      "license": "MIT",
      "dependencies": {
        "ms": "2.0.0"
      }
    },
    "node_modules/depd": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/destroy": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8",
        "npm": "1.2.8000 || >= 1.4.16"
      }
    },
    "node_modules/dunder-proto": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
      "license": "MIT",
      "dependencies": {
        "call-bind-apply-helpers": "^1.0.1",
        "es-errors": "^1.3.0",
        "gopd": "^1.2.0"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/ee-first": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
      "license": "MIT"
    },
    "node_modules/encodeurl": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/es-define-property": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/es-errors": {
      "version": "1.3.0",
      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/es-object-atoms": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
      "license": "MIT",
      "dependencies": {
        "es-errors": "^1.3.0"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/escape-html": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
      "license": "MIT"
    },
    "node_modules/etag": {
      "version": "1.8.1",
      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/express": {
      "version": "4.22.1",
      "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz",
      "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
      "license": "MIT",
      "dependencies": {
        "accepts": "~1.3.8",
        "array-flatten": "1.1.1",
        "body-parser": "~1.20.3",
        "content-disposition": "~0.5.4",
        "content-type": "~1.0.4",
        "cookie": "~0.7.1",
        "cookie-signature": "~1.0.6",
        "debug": "2.6.9",
        "depd": "2.0.0",
        "encodeurl": "~2.0.0",
        "escape-html": "~1.0.3",
        "etag": "~1.8.1",
        "finalhandler": "~1.3.1",
        "fresh": "~0.5.2",
        "http-errors": "~2.0.0",
        "merge-descriptors": "1.0.3",
        "methods": "~1.1.2",
        "on-finished": "~2.4.1",
        "parseurl": "~1.3.3",
        "path-to-regexp": "~0.1.12",
        "proxy-addr": "~2.0.7",
        "qs": "~6.14.0",
        "range-parser": "~1.2.1",
        "safe-buffer": "5.2.1",
        "send": "~0.19.0",
        "serve-static": "~1.16.2",
        "setprototypeof": "1.2.0",
        "statuses": "~2.0.1",
        "type-is": "~1.6.18",
        "utils-merge": "1.0.1",
        "vary": "~1.1.2"
      },
      "engines": {
        "node": ">= 0.10.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/express"
      }
    },
    "node_modules/finalhandler": {
      "version": "1.3.2",
      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz",
      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
      "license": "MIT",
      "dependencies": {
        "debug": "2.6.9",
        "encodeurl": "~2.0.0",
        "escape-html": "~1.0.3",
        "on-finished": "~2.4.1",
        "parseurl": "~1.3.3",
        "statuses": "~2.0.2",
        "unpipe": "~1.0.0"
      },
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/forwarded": {
      "version": "0.2.0",
      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/fresh": {
      "version": "0.5.2",
      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/function-bind": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/get-intrinsic": {
      "version": "1.3.0",
      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
      "license": "MIT",
      "dependencies": {
        "call-bind-apply-helpers": "^1.0.2",
        "es-define-property": "^1.0.1",
        "es-errors": "^1.3.0",
        "es-object-atoms": "^1.1.1",
        "function-bind": "^1.1.2",
        "get-proto": "^1.0.1",
        "gopd": "^1.2.0",
        "has-symbols": "^1.1.0",
        "hasown": "^2.0.2",
        "math-intrinsics": "^1.1.0"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/get-proto": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
      "license": "MIT",
      "dependencies": {
        "dunder-proto": "^1.0.1",
        "es-object-atoms": "^1.0.0"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/gopd": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/has-symbols": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/hasown": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
      "license": "MIT",
      "dependencies": {
        "function-bind": "^1.1.2"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/http-errors": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
      "license": "MIT",
      "dependencies": {
        "depd": "~2.0.0",
        "inherits": "~2.0.4",
        "setprototypeof": "~1.2.0",
        "statuses": "~2.0.2",
        "toidentifier": "~1.0.1"
      },
      "engines": {
        "node": ">= 0.8"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/express"
      }
    },
    "node_modules/iconv-lite": {
      "version": "0.4.24",
      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
      "license": "MIT",
      "dependencies": {
        "safer-buffer": ">= 2.1.2 < 3"
      },
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/inherits": {
      "version": "2.0.4",
      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
      "license": "ISC"
    },
    "node_modules/ipaddr.js": {
      "version": "1.9.1",
      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.10"
      }
    },
    "node_modules/math-intrinsics": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/media-typer": {
      "version": "0.3.0",
      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/merge-descriptors": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/methods": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/mime": {
      "version": "1.6.0",
      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
      "license": "MIT",
      "bin": {
        "mime": "cli.js"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/mime-db": {
      "version": "1.52.0",
      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/mime-types": {
      "version": "2.1.35",
      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
      "license": "MIT",
      "dependencies": {
        "mime-db": "1.52.0"
      },
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/ms": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
      "license": "MIT"
    },
    "node_modules/negotiator": {
      "version": "0.6.3",
      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/nostr-tools": {
      "version": "1.17.0",
      "resolved": "https://registry.npmjs.org/nostr-tools/-/nostr-tools-1.17.0.tgz",
      "integrity": "sha512-LZmR8GEWKZeElbFV5Xte75dOeE9EFUW/QLI1Ncn3JKn0kFddDKEfBbFN8Mu4TMs+L4HR/WTPha2l+PPuRnJcMw==",
      "license": "Unlicense",
      "dependencies": {
        "@noble/ciphers": "0.2.0",
        "@noble/curves": "1.1.0",
        "@noble/hashes": "1.3.1",
        "@scure/base": "1.1.1",
        "@scure/bip32": "1.3.1",
        "@scure/bip39": "1.2.1"
      },
      "peerDependencies": {
        "typescript": ">=5.0.0"
      },
      "peerDependenciesMeta": {
        "typescript": {
          "optional": true
        }
      }
    },
    "node_modules/object-inspect": {
      "version": "1.13.4",
      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/on-finished": {
      "version": "2.4.1",
      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
      "license": "MIT",
      "dependencies": {
        "ee-first": "1.1.1"
      },
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/parseurl": {
      "version": "1.3.3",
      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/path-to-regexp": {
      "version": "0.1.12",
      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
      "license": "MIT"
    },
    "node_modules/proxy-addr": {
      "version": "2.0.7",
      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
      "license": "MIT",
      "dependencies": {
        "forwarded": "0.2.0",
        "ipaddr.js": "1.9.1"
      },
      "engines": {
        "node": ">= 0.10"
      }
    },
    "node_modules/qs": {
      "version": "6.14.2",
      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz",
      "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==",
      "license": "BSD-3-Clause",
      "dependencies": {
        "side-channel": "^1.1.0"
      },
      "engines": {
        "node": ">=0.6"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/range-parser": {
      "version": "1.2.1",
      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/raw-body": {
      "version": "2.5.3",
      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz",
      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
      "license": "MIT",
      "dependencies": {
        "bytes": "~3.1.2",
        "http-errors": "~2.0.1",
        "iconv-lite": "~0.4.24",
        "unpipe": "~1.0.0"
      },
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/safe-buffer": {
      "version": "5.2.1",
      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/feross"
        },
        {
          "type": "patreon",
          "url": "https://www.patreon.com/feross"
        },
        {
          "type": "consulting",
          "url": "https://feross.org/support"
        }
      ],
      "license": "MIT"
    },
    "node_modules/safer-buffer": {
      "version": "2.1.2",
      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
      "license": "MIT"
    },
    "node_modules/send": {
      "version": "0.19.2",
      "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz",
      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
      "license": "MIT",
      "dependencies": {
        "debug": "2.6.9",
        "depd": "2.0.0",
        "destroy": "1.2.0",
        "encodeurl": "~2.0.0",
        "escape-html": "~1.0.3",
        "etag": "~1.8.1",
        "fresh": "~0.5.2",
        "http-errors": "~2.0.1",
        "mime": "1.6.0",
        "ms": "2.1.3",
        "on-finished": "~2.4.1",
        "range-parser": "~1.2.1",
        "statuses": "~2.0.2"
      },
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/send/node_modules/ms": {
      "version": "2.1.3",
      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
      "license": "MIT"
    },
    "node_modules/serve-static": {
      "version": "1.16.3",
      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz",
      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
      "license": "MIT",
      "dependencies": {
        "encodeurl": "~2.0.0",
        "escape-html": "~1.0.3",
        "parseurl": "~1.3.3",
        "send": "~0.19.1"
      },
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/setprototypeof": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
      "license": "ISC"
    },
    "node_modules/side-channel": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
      "license": "MIT",
      "dependencies": {
        "es-errors": "^1.3.0",
        "object-inspect": "^1.13.3",
        "side-channel-list": "^1.0.0",
        "side-channel-map": "^1.0.1",
        "side-channel-weakmap": "^1.0.2"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/side-channel-list": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
      "license": "MIT",
      "dependencies": {
        "es-errors": "^1.3.0",
        "object-inspect": "^1.13.3"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/side-channel-map": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
      "license": "MIT",
      "dependencies": {
        "call-bound": "^1.0.2",
        "es-errors": "^1.3.0",
        "get-intrinsic": "^1.2.5",
        "object-inspect": "^1.13.3"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/side-channel-weakmap": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
      "license": "MIT",
      "dependencies": {
        "call-bound": "^1.0.2",
        "es-errors": "^1.3.0",
        "get-intrinsic": "^1.2.5",
        "object-inspect": "^1.13.3",
        "side-channel-map": "^1.0.1"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/statuses": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/toidentifier": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
      "license": "MIT",
      "engines": {
        "node": ">=0.6"
      }
    },
    "node_modules/type-is": {
      "version": "1.6.18",
      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
      "license": "MIT",
      "dependencies": {
        "media-typer": "0.3.0",
        "mime-types": "~2.1.24"
      },
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/unpipe": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/utils-merge": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.4.0"
      }
    },
    "node_modules/vary": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    },
    "node_modules/ws": {
      "version": "8.19.0",
      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
      "license": "MIT",
      "engines": {
        "node": ">=10.0.0"
      },
      "peerDependencies": {
        "bufferutil": "^4.0.1",
        "utf-8-validate": ">=5.0.2"
      },
      "peerDependenciesMeta": {
        "bufferutil": {
          "optional": true
        },
        "utf-8-validate": {
          "optional": true
        }
      }
    }
  }
}

FILE:package.json
{
  "name": "ocmesh",
  "version": "0.1.0",
  "description": "Decentralized OpenClaw agent mesh via Nostr",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "nostr-tools": "1.17.0",
    "ws": "^8.16.0",

    "express": "^4.18.3"
  }
}

FILE:presence.js
/**
 * presence.js
 * Presence announcements and peer discovery via Nostr kind 31337.
 * v0.2: fires webhook on new peer discovery.
 */

const { finishEvent } = require('nostr-tools');
const { publish, subscribe } = require('./nostr');
const { PRESENCE_KIND, ANNOUNCE_INTERVAL, DISCOVERY_INTERVAL, PEER_TTL } = require('./relays');
const webhook = require('./webhook');
const db = require('./db');

let identity = null;

function start(id) {
  identity = id;
  announce();
  discover();
  setInterval(announce, ANNOUNCE_INTERVAL);
  setInterval(discover, DISCOVERY_INTERVAL);
}

function announce() {
  const event = finishEvent({
    kind: PRESENCE_KIND,
    created_at: Math.floor(Date.now() / 1000),
    tags: [
      ['d', 'ocmesh-presence'],
      ['app', 'ocmesh'],
      ['v', '0.2.0'],
    ],
    content: 'ocmesh-agent-online',
  }, identity.sk);

  publish(event);
  console.log('[presence] Announced online');
}

function discover() {
  const since = Math.floor((Date.now() - PEER_TTL) / 1000);
  subscribe({ kinds: [PRESENCE_KIND], since });
  console.log('[presence] Discovery scan started');
}

async function handlePresenceEvent(event) {
  if (!event?.pubkey) return;
  if (identity && event.pubkey === identity.pk) return;

  const isOcmesh = event.tags?.some(([k, v]) => k === 'app' && v === 'ocmesh');
  if (!isOcmesh) return;

  const now = Date.now();
  const existing = db.prepare('SELECT pk FROM peers WHERE pk = ?').get(event.pubkey);

  if (existing) {
    db.prepare('UPDATE peers SET last_seen = ? WHERE pk = ?').run(now, event.pubkey);
  } else {
    const version = event.tags?.find(([k]) => k === 'v')?.[1];
    db.prepare(`
      INSERT INTO peers (pk, first_seen, last_seen, handshake, meta)
      VALUES (?, ?, ?, 0, ?)
    `).run(event.pubkey, now, now, JSON.stringify({ version }));

    console.log(`[presence] New peer: event.pubkey.slice(0, 16)...`);

    await webhook.fire('peer.discovered', {
      pk: event.pubkey,
      version,
      ts: now,
    });
  }
}

module.exports = { start, handlePresenceEvent };

FILE:profiles.js
/**
 * profiles.js
 * Agent profile publishing and fetching via Nostr kind 0 (NIP-01).
 * Agents publish their name, description, capabilities, and avatar.
 * Any agent can look up any other agent's profile by public key.
 */

const { finishEvent } = require('nostr-tools');
const { publish, subscribe } = require('./nostr');
const db = require('./db');

let identity = null;
let config = null;

// Ensure profile cache table exists
db.exec(`
  CREATE TABLE IF NOT EXISTS profile_cache (
    pk          TEXT PRIMARY KEY,
    name        TEXT,
    about       TEXT,
    picture     TEXT,
    capabilities TEXT,
    fetched_at  INTEGER
  );
`);

function start(id, cfg) {
  identity = id;
  config = cfg;

  // Publish own profile on start
  publishProfile();

  // Subscribe to incoming profile events
  subscribe({ kinds: [0] });
}

function publishProfile() {
  const profile = config.profile || {};
  const content = JSON.stringify({
    name: profile.name || `ocmesh-agent-identity.pk.slice(0, 8)`,
    about: profile.about || 'An OpenClaw AI agent on the ocmesh network.',
    picture: profile.picture || null,
    capabilities: ['chat', 'task', 'search'],
    app: 'ocmesh',
    v: '0.2.0',
  });

  const event = finishEvent({
    kind: 0,
    created_at: Math.floor(Date.now() / 1000),
    tags: [],
    content,
  }, identity.sk);

  publish(event);
  console.log('[profiles] Published own profile');
}

function handleProfileEvent(event) {
  if (!event || event.kind !== 0) return;

  try {
    const meta = JSON.parse(event.content);
    // Only cache ocmesh agents
    if (meta.app !== 'ocmesh') return;

    const now = Date.now();
    db.prepare(`
      INSERT INTO profile_cache (pk, name, about, picture, capabilities, fetched_at)
      VALUES (?, ?, ?, ?, ?, ?)
      ON CONFLICT(pk) DO UPDATE SET
        name=excluded.name, about=excluded.about,
        picture=excluded.picture, capabilities=excluded.capabilities,
        fetched_at=excluded.fetched_at
    `).run(
      event.pubkey,
      meta.name || null,
      meta.about || null,
      meta.picture || null,
      meta.capabilities ? JSON.stringify(meta.capabilities) : null,
      now
    );

    console.log(`[profiles] Cached profile: meta.name || event.pubkey.slice(0, 12)...`);
  } catch (err) {
    console.error('[profiles] Failed to parse profile event:', err.message);
  }
}

function getProfile(pk) {
  const row = db.prepare('SELECT * FROM profile_cache WHERE pk = ?').get(pk);
  if (!row) return null;
  return {
    pk: row.pk,
    name: row.name,
    about: row.about,
    picture: row.picture,
    capabilities: row.capabilities ? JSON.parse(row.capabilities) : [],
    fetchedAt: row.fetched_at,
  };
}

function getOwnProfile() {
  const profile = config.profile || {};
  return {
    pk: identity.pk,
    name: profile.name || `ocmesh-agent-identity.pk.slice(0, 8)`,
    about: profile.about || 'An OpenClaw AI agent on the ocmesh network.',
    picture: profile.picture || null,
    capabilities: ['chat', 'task', 'search'],
  };
}

module.exports = { start, handleProfileEvent, getProfile, getOwnProfile, publishProfile };

FILE:protocol.js
/**
 * protocol.js
 * Typed message schema for ocmesh agent-to-agent communication.
 *
 * All messages are JSON with a required `type` field.
 * Unrecognized types are stored as-is for forward compatibility.
 */

const MESSAGE_TYPES = {
  // Basic
  TEXT:    'text',       // { body: string }
  PING:    'ping',       // {}
  PONG:    'pong',       // {}

  // Agent work
  TASK:    'task',       // { action: string, params: object, replyTo?: string }
  RESULT:  'result',     // { taskId: string, output: any, error?: string }
  ERROR:   'error',      // { code: string, message: string }

  // Social
  INTRO:   'intro',      // { name: string, capabilities: string[] }
  PROFILE: 'profile',    // { name, about, picture, capabilities }

  // Receipts
  DELIVERED: 'delivered', // { msgId: string }
  READ:      'read',      // { msgId: string }

  // Files
  FILE:    'file',       // { name: string, mimeType: string, url: string, size: number }
};

/**
 * Create a typed message payload (JSON string).
 */
function create(type, payload = {}) {
  return JSON.stringify({
    type,
    ts: Date.now(),
    v: '0.2.0',
    ...payload,
  });
}

/**
 * Parse and validate an incoming message string.
 * Returns null if invalid.
 */
function parse(raw) {
  try {
    const msg = typeof raw === 'string' ? JSON.parse(raw) : raw;
    if (!msg.type) return null;
    return msg;
  } catch {
    return null;
  }
}

module.exports = { MESSAGE_TYPES, create, parse };

FILE:receipts.js
/**
 * receipts.js
 * Delivery and read receipts — the WhatsApp ✓ ✓✓ 🔵 model for agents.
 *
 * - DELIVERED: sent when we successfully decrypt and store a message
 * - READ:      sent when the message is marked as read (via API or agent action)
 */

const { MESSAGE_TYPES, create } = require('./protocol');

let identity = null;
let sendFn = null;

function start(id, messagingSend) {
  identity = id;
  sendFn = messagingSend;
}

async function sendDelivered(toPk, msgId) {
  if (!sendFn) return;
  try {
    await sendFn(toPk, create(MESSAGE_TYPES.DELIVERED, { msgId }));
  } catch (err) {
    console.error('[receipts] Failed to send delivered receipt:', err.message);
  }
}

async function sendRead(toPk, msgId) {
  if (!sendFn) return;
  try {
    await sendFn(toPk, create(MESSAGE_TYPES.READ, { msgId }));
  } catch (err) {
    console.error('[receipts] Failed to send read receipt:', err.message);
  }
}

// Update receipt status in DB when we receive ack from peer
function handleReceipt(db, event, msgContent) {
  const msg = msgContent;
  if (!msg || !msg.msgId) return;

  if (msg.type === MESSAGE_TYPES.DELIVERED) {
    db.prepare('UPDATE messages SET delivered = 1 WHERE id = ?').run(msg.msgId);
    console.log(`[receipts] Delivered ack for msg.msgId.slice(0, 12)...`);
  } else if (msg.type === MESSAGE_TYPES.READ) {
    db.prepare('UPDATE messages SET read_by_peer = 1 WHERE id = ?').run(msg.msgId);
    console.log(`[receipts] Read ack for msg.msgId.slice(0, 12)...`);
  }
}

module.exports = { start, sendDelivered, sendRead, handleReceipt };

FILE:references/api.md
# ocmesh HTTP API Reference

Base URL: `http://127.0.0.1:7432`

## Endpoints

### GET /status
Returns daemon status, peer counts, unread message count, and uptime.

```json
{
  "ok": true,
  "publicKey": "<hex>",
  "peers": { "total": 12, "online": 3 },
  "messages": { "unread": 1 },
  "uptime": 3600
}
```

### GET /identity
Returns this agent's Nostr public key.

### GET /peers
Returns all known peers. Add `?online=true` to filter to active peers only (seen in last 15 min).

Peer object:
```json
{
  "pk": "<hex pubkey>",
  "online": true,
  "handshaked": true,
  "firstSeen": 1711000000000,
  "lastSeen": 1711003600000,
  "meta": { "version": "0.1.0" }
}
```

### GET /peers/:pk
Get a single peer by public key.

### GET /messages
Returns received messages. Filters: `?unread=true`, `?from=<pk>`.

### POST /messages/read
Mark messages as read. Body: `{ "id": "..." }` or empty body to mark all read.

### POST /send
Send an encrypted DM to a peer.
```json
{ "to": "<pubkey>", "content": "hello from my agent" }
```
Returns: `{ "ok": true, "id": "<event_id>" }`

## Daemon Control (macOS)

```bash
launchctl stop com.ocmesh.agent    # stop
launchctl start com.ocmesh.agent   # start
tail -f ~/.ocmesh/ocmesh.log       # logs
```

FILE:relays.js
/**
 * relays.js
 * List of public Nostr relays used for presence + discovery.
 * These are well-known, reliable public relays.
 */

const RELAYS = [
  'wss://relay.damus.io',
  'wss://relay.nostr.band',
  'wss://nos.lol',
  'wss://nostr.wine',
  'wss://relay.snort.social',
];

// Nostr event kind used for ocmesh presence announcements
// Kind 31337 is in the parameterized replaceable range — safe to use
const PRESENCE_KIND = 31337;

// Nostr kind for encrypted DMs (NIP-04)
const DM_KIND = 4;

// How often to re-announce presence (ms)
const ANNOUNCE_INTERVAL = 5 * 60 * 1000; // 5 minutes

// How often to scan for new peers (ms)
const DISCOVERY_INTERVAL = 2 * 60 * 1000; // 2 minutes

// Consider a peer "offline" if not seen in this window
const PEER_TTL = 15 * 60 * 1000; // 15 minutes

module.exports = {
  RELAYS,
  PRESENCE_KIND,
  DM_KIND,
  ANNOUNCE_INTERVAL,
  DISCOVERY_INTERVAL,
  PEER_TTL,
};

FILE:scripts/install.sh
#!/usr/bin/env bash
# install.sh — One-shot setup for ocmesh
# Installs deps, registers LaunchAgent (macOS), starts the daemon.

set -e

SCRIPT_DIR="$(cd "$(dirname "BASH_SOURCE[0]")" && pwd)"
# The actual ocmesh source lives one level up (skill root)
OCMESH_DIR="$(dirname "$SCRIPT_DIR")"
PLIST_SRC="$OCMESH_DIR/com.ocmesh.agent.plist"
PLIST_DST="$HOME/Library/LaunchAgents/com.ocmesh.agent.plist"
LOG_DIR="$HOME/.ocmesh"

echo "==> ocmesh installer"

mkdir -p "$LOG_DIR"
echo "    Log directory: $LOG_DIR"

echo "==> Installing Node dependencies..."
cd "$OCMESH_DIR"
npm install

NODE_PATH="$(which node)"
echo "    Node binary: $NODE_PATH"

sed "s|/usr/local/bin/node|$NODE_PATH|g; s|OCMESH_DIR|$OCMESH_DIR|g" \
  "$PLIST_SRC" > "$PLIST_DST"
echo "    LaunchAgent installed: $PLIST_DST"

launchctl unload "$PLIST_DST" 2>/dev/null || true
launchctl load -w "$PLIST_DST"
echo "    LaunchAgent loaded and enabled"

sleep 2
echo ""
echo "✅ ocmesh is running!"
echo ""
echo "  API:  http://127.0.0.1:7432"
echo "  Logs: $LOG_DIR/ocmesh.log"
echo ""
curl -s http://127.0.0.1:7432/status || echo "(daemon still starting up)"

FILE:threads.js
/**
 * threads.js
 * Conversation threading — groups messages by peer into conversations.
 * Each thread is identified by the peer's public key.
 */

const db = require('./db');

db.exec(`
  CREATE TABLE IF NOT EXISTS threads (
    peer_pk     TEXT PRIMARY KEY,
    last_msg    TEXT,
    last_ts     INTEGER,
    unread      INTEGER DEFAULT 0,
    created_at  INTEGER
  );
`);

function touchThread(peerPk, messageContent, ts) {
  const existing = db.prepare('SELECT peer_pk FROM threads WHERE peer_pk = ?').get(peerPk);
  const now = ts || Date.now();

  if (existing) {
    db.prepare(`
      UPDATE threads SET last_msg = ?, last_ts = ?, unread = unread + 1 WHERE peer_pk = ?
    `).run(messageContent.slice(0, 100), now, peerPk);
  } else {
    db.prepare(`
      INSERT INTO threads (peer_pk, last_msg, last_ts, unread, created_at)
      VALUES (?, ?, ?, 1, ?)
    `).run(peerPk, messageContent.slice(0, 100), now, now);
  }
}

function markRead(peerPk) {
  db.prepare('UPDATE threads SET unread = 0 WHERE peer_pk = ?').run(peerPk);
  db.prepare('UPDATE messages SET read = 1 WHERE from_pk = ?').run(peerPk);
}

function getAll() {
  return db.prepare('SELECT * FROM threads ORDER BY last_ts DESC').all();
}

function getThread(peerPk, limit = 50) {
  return db.prepare(`
    SELECT * FROM messages
    WHERE (from_pk = ? OR to_pk = ?)
    ORDER BY received_at DESC
    LIMIT ?
  `).all(peerPk, peerPk, limit).reverse();
}

module.exports = { touchThread, markRead, getAll, getThread };

FILE:webhook.js
/**
 * webhook.js
 * Push notifications to your OpenClaw agent (or any HTTP endpoint)
 * when events arrive on the mesh — no polling required.
 *
 * Events fired:
 *   peer.discovered   → new peer found
 *   peer.handshaked   → peer completed handshake
 *   message.received  → incoming DM
 *   group.message     → incoming group message
 *   receipt.delivered → peer delivered your message
 *   receipt.read      → peer read your message
 */

const http = require('http');
const https = require('https');
const crypto = require('crypto');

let config = null;

function start(cfg) {
  config = cfg;
  if (cfg.webhook?.enabled && cfg.webhook?.url) {
    console.log(`[webhook] Push enabled → cfg.webhook.url`);
  }
}

async function fire(eventType, payload) {
  if (!config?.webhook?.enabled || !config?.webhook?.url) return;

  const body = JSON.stringify({
    event: eventType,
    ts: Date.now(),
    payload,
  });

  const url = new URL(config.webhook.url);
  const isHttps = url.protocol === 'https:';
  const lib = isHttps ? https : http;

  const headers = {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(body),
    'X-Ocmesh-Event': eventType,
  };

  // HMAC signature if secret is set
  if (config.webhook.secret) {
    const sig = crypto
      .createHmac('sha256', config.webhook.secret)
      .update(body)
      .digest('hex');
    headers['X-Ocmesh-Signature'] = `sha256=sig`;
  }

  const options = {
    hostname: url.hostname,
    port: url.port || (isHttps ? 443 : 80),
    path: url.pathname + url.search,
    method: 'POST',
    headers,
    timeout: 5000,
  };

  return new Promise((resolve) => {
    const req = lib.request(options, (res) => {
      res.resume();
      resolve(res.statusCode);
    });

    req.on('error', (err) => {
      console.error(`[webhook] Delivery failed (eventType):`, err.message);
      resolve(null);
    });

    req.on('timeout', () => {
      req.destroy();
      console.error(`[webhook] Timeout (eventType)`);
      resolve(null);
    });

    req.write(body);
    req.end();
  });
}

module.exports = { start, fire };