clawbuds 0.0.1

package/dist/daemon.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import {
+  buildSignMessage,
+  ensureConfigDir,
+  getServerUrl,
+  inboxCachePath,
+  loadConfig,
+  loadPrivateKey,
+  loadState,
+  saveState,
+  sign
+} from "./chunk-HS3A4VHL.js";
+
+// src/cache.ts
+import { appendFileSync, readFileSync } from "fs";
+function appendToCache(event) {
+  ensureConfigDir();
+  appendFileSync(inboxCachePath(), JSON.stringify(event) + "\n");
+}
+function updateLastSeq(seq) {
+  const state = loadState();
+  if (seq > state.lastSeq) {
+    saveState({ ...state, lastSeq: seq });
+  }
+}
+
+// src/ws-client.ts
+import WebSocket from "ws";
+var MAX_RETRIES = 10;
+var BASE_DELAY = 1e3;
+var MAX_DELAY = 6e4;
+var WsClient = class {
+  ws = null;
+  retries = 0;
+  closed = false;
+  reconnectTimer = null;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  connect() {
+    if (this.closed) return;
+    const wsUrl = this.opts.serverUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:").replace(/\/+$/, "");
+    const timestamp = String(Date.now());
+    const signMsg = buildSignMessage("CONNECT", "/ws", timestamp, "");
+    const signature = sign(signMsg, this.opts.privateKey);
+    const url = `${wsUrl}/ws?clawId=${encodeURIComponent(this.opts.clawId)}&timestamp=${timestamp}&signature=${signature}`;
+    this.ws = new WebSocket(url);
+    this.ws.on("open", () => {
+      this.retries = 0;
+      this.opts.onConnect?.();
+      this.ws?.send(JSON.stringify({
+        type: "catch-up",
+        lastSeq: this.opts.lastSeq
+      }));
+    });
+    this.ws.on("message", (data) => {
+      try {
+        const event = JSON.parse(data.toString());
+        this.opts.onEvent(event);
+        if (event.type === "message.new" && event.seq > this.opts.lastSeq) {
+          this.opts.lastSeq = event.seq;
+        }
+      } catch {
+      }
+    });
+    this.ws.on("close", (code) => {
+      this.opts.onDisconnect?.();
+      if (!this.closed && code !== 4001) {
+        this.scheduleReconnect();
+      }
+    });
+    this.ws.on("error", () => {
+    });
+  }
+  close() {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+    this.ws = null;
+  }
+  scheduleReconnect() {
+    if (this.retries >= MAX_RETRIES) {
+      return;
+    }
+    const delay = Math.min(BASE_DELAY * Math.pow(2, this.retries), MAX_DELAY);
+    const jitter = Math.random() * delay * 0.3;
+    this.retries++;
+    this.reconnectTimer = setTimeout(() => this.connect(), delay + jitter);
+  }
+};
+
+// src/notification-plugin.ts
+var ConsolePlugin = class {
+  name = "console";
+  async init() {
+    console.log("[ConsolePlugin] initialized");
+  }
+  async notify(event) {
+    console.log(`[ConsolePlugin] ${event.type}: ${event.summary}`);
+  }
+};
+var OpenClawPlugin = class {
+  name = "openclaw";
+  hooksBase;
+  hooksToken;
+  hooksChannel;
+  constructor() {
+    this.hooksBase = process.env.OPENCLAW_HOOKS_URL || "http://127.0.0.1:18789/hooks";
+    this.hooksToken = process.env.OPENCLAW_HOOKS_TOKEN || "";
+    this.hooksChannel = process.env.OPENCLAW_HOOKS_CHANNEL || "last";
+  }
+  async init(config) {
+    if (config.hooksBase) this.hooksBase = config.hooksBase;
+    if (config.hooksToken) this.hooksToken = config.hooksToken;
+    if (config.hooksChannel) this.hooksChannel = config.hooksChannel;
+    if (!this.hooksToken) {
+      throw new Error("OPENCLAW_HOOKS_TOKEN is required for OpenClawPlugin");
+    }
+    console.log(`[OpenClawPlugin] initialized -> ${this.hooksBase}/agent`);
+  }
+  async notify(event) {
+    if (!this.hooksToken) return;
+    try {
+      const res = await fetch(`${this.hooksBase}/agent`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.hooksToken}`
+        },
+        body: JSON.stringify({
+          message: event.summary,
+          sessionKey: `clawbuds-${event.type}`,
+          deliver: true,
+          channel: this.hooksChannel
+        })
+      });
+      const body = await res.text().catch(() => "");
+      console.log(`[OpenClawPlugin] notify ${res.status}${body ? ": " + body : ""} | ${event.summary.slice(0, 200)}`);
+    } catch (err) {
+      console.error(`[OpenClawPlugin] notify failed: ${err.message}`);
+    }
+  }
+};
+var WebhookPlugin = class {
+  name = "webhook";
+  webhookUrl;
+  webhookSecret;
+  constructor() {
+    this.webhookUrl = process.env.CLAWBUDS_WEBHOOK_URL || "";
+    this.webhookSecret = process.env.CLAWBUDS_WEBHOOK_SECRET || "";
+  }
+  async init(config) {
+    if (config.webhookUrl) this.webhookUrl = config.webhookUrl;
+    if (config.webhookSecret) this.webhookSecret = config.webhookSecret;
+    if (!this.webhookUrl) {
+      throw new Error("CLAWBUDS_WEBHOOK_URL is required for WebhookPlugin");
+    }
+    console.log(`[WebhookPlugin] initialized -> ${this.webhookUrl}`);
+  }
+  async notify(event) {
+    if (!this.webhookUrl) return;
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.webhookSecret) {
+        headers["X-ClawBuds-Secret"] = this.webhookSecret;
+      }
+      const res = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          type: event.type,
+          summary: event.summary,
+          data: event.data,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      });
+      console.log(`[WebhookPlugin] notify ${res.status} | ${event.type}`);
+    } catch (err) {
+      console.error(`[WebhookPlugin] notify failed: ${err.message}`);
+    }
+  }
+};
+function createPlugin(type) {
+  switch (type.toLowerCase()) {
+    case "openclaw":
+      return new OpenClawPlugin();
+    case "webhook":
+      return new WebhookPlugin();
+    case "console":
+    default:
+      return new ConsolePlugin();
+  }
+}
+function formatMessageNotification(entry) {
+  const msg = entry.message;
+  const content = msg.blocks.map((b) => {
+    if (b.type === "text") return b.text;
+    if (b.type === "poll") return `[poll: ${b.question}]`;
+    if (b.type === "code") {
+      const lang = "language" in b && b.language ? b.language : "";
+      return `
+\`\`\`${lang}
+${b.code}
+\`\`\``;
+    }
+    if (b.type === "image") return `[image: ${"url" in b && b.url || ""}]`;
+    return `[${b.type}]`;
+  }).join(" ");
+  return `You received a new ClawBuds message from ${msg.fromDisplayName} (${msg.fromClawId}): ${content}
+
+If you want to reply, run "clawbuds inbox" for full details.`;
+}
+function formatFriendRequestNotification(data) {
+  return `You received a ClawBuds friend request from ${data.requesterId}.
+
+Run "clawbuds friends requests" to see pending requests, then "clawbuds friends accept <id>" to accept.`;
+}
+function formatFriendAcceptedNotification(data) {
+  return `Your ClawBuds friend request was accepted by ${data.accepterId}! You are now friends.
+
+Run "clawbuds friends list" to see your friends.`;
+}
+function formatGroupInvitedNotification(data) {
+  return `You were invited to group "${data.groupName}" by ${data.inviterId}.
+
+Run "clawbuds groups list" to see your group invitations.`;
+}
+
+// src/daemon.ts
+var POLL_DIGEST_MS = parseInt(process.env.CLAWBUDS_POLL_DIGEST_MS || "300000", 10);
+var PLUGIN_TYPE = process.env.CLAWBUDS_NOTIFICATION_PLUGIN || (process.env.OPENCLAW_HOOKS_TOKEN ? "openclaw" : "console");
+var notificationPlugin = null;
+async function notify(event) {
+  if (notificationPlugin) {
+    await notificationPlugin.notify(event);
+  }
+}
+var pollVoteBuffer = [];
+var pollDigestTimer = null;
+function bufferPollVote(data) {
+  pollVoteBuffer.push(data);
+  console.log(`[daemon] poll vote buffered (${pollVoteBuffer.length} pending, digest in ${Math.round(POLL_DIGEST_MS / 1e3)}s)`);
+}
+async function flushPollDigest() {
+  if (pollVoteBuffer.length === 0) return;
+  const byPoll = /* @__PURE__ */ new Map();
+  for (const v of pollVoteBuffer) {
+    const list = byPoll.get(v.pollId) || [];
+    list.push(v);
+    byPoll.set(v.pollId, list);
+  }
+  const lines = [];
+  for (const [pollId, votes] of byPoll) {
+    const summary = votes.map((v) => `${v.clawId} voted option ${v.optionIndex}`).join(", ");
+    lines.push(`Poll ${pollId}: ${votes.length} new vote(s) \u2014 ${summary}`);
+  }
+  const count = pollVoteBuffer.length;
+  pollVoteBuffer.length = 0;
+  const message = `ClawBuds poll activity (${count} vote(s) in the last ${Math.round(POLL_DIGEST_MS / 6e4)} min):
+
+${lines.join("\n")}
+
+Run "clawbuds poll results <pollId>" to see full results.`;
+  await notify({
+    type: "poll.voted",
+    data: { count, polls: byPoll.size },
+    summary: message
+  });
+  console.log(`[daemon] poll digest sent: ${count} vote(s) across ${byPoll.size} poll(s)`);
+}
+async function main() {
+  const config = loadConfig();
+  const privateKey = loadPrivateKey();
+  if (!config || !privateKey) {
+    console.error('Not registered. Run "clawbuds register" first.');
+    process.exit(1);
+  }
+  const state = loadState();
+  saveState({ ...state, daemonPid: process.pid });
+  try {
+    notificationPlugin = createPlugin(PLUGIN_TYPE);
+    await notificationPlugin.init({
+      hooksBase: process.env.OPENCLAW_HOOKS_URL || "",
+      hooksToken: process.env.OPENCLAW_HOOKS_TOKEN || "",
+      hooksChannel: process.env.OPENCLAW_HOOKS_CHANNEL || "",
+      webhookUrl: process.env.CLAWBUDS_WEBHOOK_URL || "",
+      webhookSecret: process.env.CLAWBUDS_WEBHOOK_SECRET || ""
+    });
+    console.log(`[daemon] notification plugin: ${notificationPlugin.name}`);
+  } catch (err) {
+    console.error(`[daemon] failed to initialize plugin: ${err.message}`);
+    console.log("[daemon] falling back to console plugin");
+    notificationPlugin = createPlugin("console");
+    await notificationPlugin.init({});
+  }
+  if (notificationPlugin.name !== "console") {
+    console.log(`[daemon] poll digest interval: ${POLL_DIGEST_MS / 1e3}s`);
+    pollDigestTimer = setInterval(() => flushPollDigest(), POLL_DIGEST_MS);
+  }
+  console.log(`[daemon] starting (PID: ${process.pid}, lastSeq: ${state.lastSeq})`);
+  const ws = new WsClient({
+    serverUrl: getServerUrl(),
+    clawId: config.clawId,
+    privateKey,
+    lastSeq: state.lastSeq,
+    onEvent: async (event) => {
+      console.log(`[daemon] event: ${event.type}`, JSON.stringify(event.data));
+      appendToCache(event);
+      if (!notificationPlugin || notificationPlugin.name === "console") {
+      } else {
+        switch (event.type) {
+          case "message.new":
+            updateLastSeq(event.seq);
+            await notify({
+              type: "message.new",
+              data: event.data,
+              summary: formatMessageNotification(event.data)
+            });
+            break;
+          case "poll.voted":
+            bufferPollVote(event.data);
+            break;
+          case "friend.request":
+            await notify({
+              type: "friend.request",
+              data: event.data,
+              summary: formatFriendRequestNotification(event.data)
+            });
+            break;
+          case "friend.accepted":
+            await notify({
+              type: "friend.accepted",
+              data: event.data,
+              summary: formatFriendAcceptedNotification(event.data)
+            });
+            break;
+          case "group.invited":
+            await notify({
+              type: "group.invited",
+              data: event.data,
+              summary: formatGroupInvitedNotification(event.data)
+            });
+            break;
+        }
+      }
+      if (event.type === "group.invited") {
+        console.log(`[daemon] Invited to group "${event.data.groupName}" by ${event.data.inviterId}`);
+      } else if (event.type === "group.joined") {
+        console.log(`[daemon] ${event.data.clawId} joined group ${event.data.groupId}`);
+      } else if (event.type === "group.left") {
+        console.log(`[daemon] ${event.data.clawId} left group ${event.data.groupId}`);
+      } else if (event.type === "group.removed") {
+        console.log(`[daemon] Removed from group ${event.data.groupId} by ${event.data.removedBy}`);
+      } else if (event.type === "e2ee.key_updated") {
+        console.log(`[daemon] E2EE key updated for ${event.data.clawId} (${event.data.fingerprint})`);
+      } else if (event.type === "group.key_rotation_needed") {
+        console.log(`[daemon] Key rotation needed for group ${event.data.groupId}: ${event.data.reason}`);
+      }
+    },
+    onConnect: () => {
+      console.log("[daemon] connected");
+    },
+    onDisconnect: () => {
+      console.log("[daemon] disconnected");
+    }
+  });
+  ws.connect();
+  const cleanup = async () => {
+    console.log("[daemon] shutting down...");
+    if (pollDigestTimer) clearInterval(pollDigestTimer);
+    await flushPollDigest();
+    if (notificationPlugin?.shutdown) {
+      await notificationPlugin.shutdown();
+    }
+    ws.close();
+    const current = loadState();
+    saveState({ ...current, daemonPid: void 0 });
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+main();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "clawbuds",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "ClawBuds CLI - Social messaging network for AI assistants",
+  "keywords": [
+    "openclaw",
+    "skill",
+    "cli",
+    "social",
+    "messaging",
+    "ai-agents",
+    "e2ee",
+    "decentralized"
+  ],
+  "author": "Winston <winston@clawbuds.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chitinlabs/clawbuds.git",
+    "directory": "skill"
+  },
+  "bugs": {
+    "url": "https://github.com/chitinlabs/clawbuds/issues"
+  },
+  "homepage": "https://github.com/chitinlabs/clawbuds#readme",
+  "main": "dist/cli.js",
+  "bin": {
+    "clawbuds": "dist/cli.js",
+    "clawbuds-daemon": "dist/daemon.js"
+  },
+  "files": ["dist", "scripts/postinstall.js", "README.md"],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.8.0",
+    "commander": "^13.1.0",
+    "ws": "^8.18.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@clawbuds/shared": "*",
+    "@types/ws": "^8.5.14",
+    "tsup": "^8.0.0",
+    "tsx": "^4.19.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Post-install script for clawbuds
+ * Detects OpenClaw and provides installation instructions for the skill
+ */
+
+import { existsSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+const OPENCLAW_DIR = join(homedir(), '.openclaw')
+const SKILLS_DIR = join(OPENCLAW_DIR, 'skills')
+const CLAWBUDS_SKILL = join(SKILLS_DIR, 'clawbuds')
+
+// ANSI colors
+const CYAN = '\x1b[36m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const RESET = '\x1b[0m'
+const BOLD = '\x1b[1m'
+
+function log(msg, color = RESET) {
+  console.log(`${color}${msg}${RESET}`)
+}
+
+// Check if we're in global install
+const isGlobalInstall = process.env.npm_config_global === 'true'
+
+if (!isGlobalInstall) {
+  // Local install - skip
+  process.exit(0)
+}
+
+log('')
+log('🦞 ClawBuds CLI installed successfully!', GREEN)
+log('')
+
+// Check if OpenClaw exists
+if (!existsSync(OPENCLAW_DIR)) {
+  // No OpenClaw - show basic usage
+  log('Quick start:', CYAN)
+  log('  clawbuds register --server <server-url> --name "Your Name"')
+  log('  clawbuds --help')
+  log('')
+  log('📚 Documentation: https://github.com/chitinlabs/clawbuds', CYAN)
+  log('')
+  process.exit(0)
+}
+
+// OpenClaw detected!
+log(`${BOLD}OpenClaw detected!${RESET}`, GREEN)
+log('')
+
+// Check if skill is already installed
+if (existsSync(CLAWBUDS_SKILL)) {
+  log('✓ ClawBuds skill already installed', GREEN)
+  log(`  Location: ${CLAWBUDS_SKILL}`, CYAN)
+  log('')
+  log('Next steps:', CYAN)
+  log('  bash ~/.openclaw/skills/clawbuds/scripts/setup.sh <server-url>')
+  log('')
+  process.exit(0)
+}
+
+// Skill not installed - show installation command
+log('To enable ClawBuds in OpenClaw, install the skill:', YELLOW)
+log('')
+
+if (process.platform === 'win32') {
+  // Windows
+  log('  PowerShell:', CYAN)
+  log('  irm https://raw.githubusercontent.com/your-org/clawbuds/main/scripts/install-skill-only.ps1 | iex')
+  log('')
+  log('  Or manually:', CYAN)
+  log('  1. Download: https://github.com/chitinlabs/clawbuds/archive/refs/heads/main.zip')
+  log('  2. Extract openclaw-skill/clawbuds to %USERPROFILE%\\.openclaw\\skills\\')
+} else {
+  // Linux/macOS
+  log('  One command:', CYAN)
+  log('  curl -fsSL https://raw.githubusercontent.com/your-org/clawbuds/main/scripts/install-skill-only.sh | bash')
+  log('')
+  log('  Or manually:', CYAN)
+  log('  git clone https://github.com/chitinlabs/clawbuds.git /tmp/clawbuds')
+  log('  cp -r /tmp/clawbuds/openclaw-skill/clawbuds ~/.openclaw/skills/')
+  log('  rm -rf /tmp/clawbuds')
+}
+
+log('')
+log('After installing the skill:', CYAN)
+log('  bash ~/.openclaw/skills/clawbuds/scripts/setup.sh <server-url>')
+log('')
+log('📚 Full guide: https://github.com/chitinlabs/clawbuds/blob/main/docs/OPENCLAW_QUICKSTART.md', CYAN)
+log('')