pairai 0.5.1 → 0.6.0

package/lib.ts

@@ -8,6 +8,7 @@ import { homedir } from "node:os";
 import {
   publicEncrypt, privateDecrypt, sign, verify,
   randomBytes, createCipheriv, createDecipheriv,
+  createHash,
   constants as cryptoConstants,
 } from "node:crypto";
 
@@ -302,6 +303,42 @@ export function localEncrypt(
 /**
  * Verify signature, unwrap AES key with own private key, decrypt AES-256-GCM.
  */
+/**
+ * Solve a PoW challenge by finding a nonce such that
+ * SHA-256(challenge + nonce) has at least `difficulty` leading zero bits.
+ */
+export function solveChallenge(challenge: string, difficulty: number): string {
+  let nonce = 0;
+  while (true) {
+    const solution = nonce.toString(16).padStart(8, "0");
+    const hash = createHash("sha256").update(challenge + solution).digest();
+    let zeroBits = 0;
+    for (const byte of hash) {
+      if (byte === 0) { zeroBits += 8; continue; }
+      zeroBits += Math.clz32(byte) - 24;
+      break;
+    }
+    if (zeroBits >= difficulty) return solution;
+    nonce++;
+  }
+}
+
+/**
+ * Fetch a PoW challenge from the hub and solve it.
+ * Returns { challenge, solution } or null if the hub doesn't support PoW.
+ */
+export async function solveHubChallenge(hubUrl: string): Promise<{ challenge: string; solution: string } | null> {
+  try {
+    const res = await fetch(`${hubUrl}/agents/challenge`);
+    if (!res.ok) return null;
+    const data = await res.json() as { challenge: string; difficulty: number };
+    const solution = solveChallenge(data.challenge, data.difficulty);
+    return { challenge: data.challenge, solution };
+  } catch {
+    return null;
+  }
+}
+
 export function localDecrypt(
   ciphertext: string,
   sig: string,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pairai",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "pairai CLI — connect AI agents to collaborate via the pairai hub",
   "type": "module",
   "license": "MIT",

package/pairai.ts

@@ -14,6 +14,7 @@
  *      PAIRAI_KEY_FILE     — path to RSA private key .pem
  *      PAIRAI_POLL_MS      — poll interval in ms (default: 5000)
  *      PAIRAI_LOCK_DIR     — lock file directory (default: ~/.pairai/locks)
+ *      PAIRAI_CHANNEL_NOTIFICATIONS — "1" = poll loop acks server cursor (for Claude with --channel)
  *      PAIRAI_DEBUG        — verbose log: "1" for ~/.pairai/debug.log, or a file path
  * Legacy: PAIRAI_URL, PAIRAI_API_KEY, PAIRAI_PRIVATE_KEY_PATH
  */
@@ -23,7 +24,7 @@ import { writeFileSync, mkdirSync, readFileSync, existsSync, appendFileSync, ope
 import { homedir } from "node:os";
 import { join, dirname, resolve as pathResolve, sep as pathSep, basename, extname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { validateProvider, detectProvider, checkExistingConfig, formatKeyBackupBox, acquireLock, releaseLock, getProviderConfig, localEncrypt as _localEncrypt, localDecrypt as _localDecrypt } from "./lib.js";
+import { validateProvider, detectProvider, checkExistingConfig, formatKeyBackupBox, acquireLock, releaseLock, getProviderConfig, localEncrypt as _localEncrypt, localDecrypt as _localDecrypt, solveHubChallenge } from "./lib.js";
 import type { Provider } from "./lib.js";
 import select from "@inquirer/select";
 import input from "@inquirer/input";
@@ -96,6 +97,7 @@ if (command === "help" || args.includes("--help") || args.includes("-h")) {
   console.log("  PAIRAI_AGENT_CRED   Agent API key");
   console.log("  PAIRAI_KEY_FILE     Path to RSA private key .pem");
   console.log("  PAIRAI_POLL_MS      Poll interval in ms (default: 5000)");
+  console.log("  PAIRAI_CHANNEL_NOTIFICATIONS=1  Poll acks cursor (Claude --channel)");
   console.log("  PAIRAI_DEBUG=1      Verbose log to ~/.pairai/debug.log");
   console.log("\nExamples:");
   console.log('  npx pairai setup "My Assistant"');
@@ -415,10 +417,27 @@ if (command === "setup") {
     privateKeyEncoding: { type: "pkcs8", format: "pem" },
   });
 
+  // Solve PoW challenge (falls back gracefully if hub doesn't support PoW)
+  process.stdout.write("  Solving registration challenge...");
+  const startTime = Date.now();
+  const powResult = await solveHubChallenge(hubUrl);
+  if (powResult) {
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(` done (${elapsed}s)`);
+  } else {
+    console.log(" (skipped — hub may not require PoW)");
+  }
+
+  const registrationBody: Record<string, unknown> = { name: agentName, publicKey };
+  if (powResult) {
+    registrationBody.challenge = powResult.challenge;
+    registrationBody.solution = powResult.solution;
+  }
+
   const res = await fetch(`${hubUrl}/agents`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ name: agentName, publicKey }),
+    body: JSON.stringify(registrationBody),
   });
 
   if (!res.ok) {
@@ -515,6 +534,7 @@ if (command !== "serve") {
   console.error("  PAIRAI_KEY_FILE     Path to RSA private key .pem file");
   console.error("  PAIRAI_POLL_MS      Poll interval in ms (default: 5000)");
   console.error("  PAIRAI_LOCK_DIR     Lock file directory (default: ~/.pairai/locks)");
+  console.error("  PAIRAI_CHANNEL_NOTIFICATIONS=1  Poll acks cursor (Claude --channel)");
   console.error("  PAIRAI_DEBUG=1      Verbose log to ~/.pairai/debug.log");
   console.error("  PAIRAI_DEBUG=<path> Verbose log to custom file");
   process.exit(1);
@@ -1057,6 +1077,14 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["agent_id"],
       },
     },
+    {
+      name: "pairai_export_my_data",
+      description: "Export all your data — profile, connections, tasks, messages, files, blocks, and events. Rate limited to one export per 10 minutes.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+      },
+    },
   ],
 }));
 
@@ -1128,9 +1156,14 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       parts.push(`**Unread messages:**\n${enriched.join("\n")}`);
     }
 
-    // Ack (idempotent — poll loop also acks after delivery).
+    // Ack server-side cursor. For channel-capable clients the poll loop also acks,
+    // but for non-channel clients this is the only place the server cursor advances.
     if (updates.cursor > 0) {
       await hubPost("/events/ack", { cursor: updates.cursor });
+      // Sync local poll cursor so we don't re-notify for these events
+      if (!channelCapable && updates.cursor > lastNotifiedEventId) {
+        lastNotifiedEventId = updates.cursor;
+      }
     }
 
     return { content: [{ type: "text" as const, text: parts.join("\n\n") }] };
@@ -1356,7 +1389,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     if (data.encrypted) {
       try {
         data.description = decryptTaskDescription(data, data.id);
-      } catch {
+      } catch (err) {
+        console.error(`[pairai] [crypto] task description decryption failed for ${data.id}: ${(err as Error).message}`);
         data.description = "[decryption failed]";
       }
     }
@@ -1369,7 +1403,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         try {
           const d = decryptMessage(m, data.id);
           return { ...m, content: d.content, contentType: d.contentType };
-        } catch {
+        } catch (err) {
+          console.error(`[pairai] [crypto] message decryption failed for task ${data.id}: ${(err as Error).message}`);
           return { ...m, content: "[decryption failed]", contentType: "text" };
         }
       }
@@ -1715,6 +1750,15 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     }
   }
 
+  if (name === "pairai_export_my_data") {
+    try {
+      const data = await hubGet("/agents/me/export");
+      return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text" as const, text: `Error: ${(err as Error).message}` }], isError: true };
+    }
+  }
+
   throw new Error(`Unknown tool: ${name}`);
 });
 
@@ -1821,7 +1865,8 @@ async function deliverEventNotification(event: {
       try {
         const d = decryptMessage(m, event.taskId!);
         return d.content;
-      } catch {
+      } catch (err) {
+        console.error(`[pairai] [crypto] message decryption failed for task ${event.taskId}: ${(err as Error).message}`);
         return "[decryption failed]";
       }
     });
@@ -1868,7 +1913,8 @@ async function deliverEventNotification(event: {
     } else {
       try {
         decrypted = decryptMessage(msg, event.taskId);
-      } catch {
+      } catch (err) {
+        console.error(`[pairai] [crypto] message decryption failed for task ${event.taskId}: ${(err as Error).message}`);
         decrypted = { content: "[decryption failed]", contentType: "text" };
       }
     }
@@ -1896,12 +1942,81 @@ async function deliverEventNotification(event: {
   }
 }
 
+// Detect whether the MCP client reliably surfaces channel notifications.
+// Walk the process tree to find Claude Code with --dangerously-load-development-channels server:pairai-channel.
+// Falls back to PAIRAI_CHANNEL_NOTIFICATIONS=1 env var (non-Linux or custom setups).
+const CHANNEL_FLAG = "--dangerously-load-development-channels";
+const CHANNEL_VALUE = "server:pairai-channel";
+
+function detectChannelCapable(): boolean {
+  if (process.env.PAIRAI_CHANNEL_NOTIFICATIONS === "1") {
+    debugLog("detect-channel: PAIRAI_CHANNEL_NOTIFICATIONS=1 (env override)");
+    return true;
+  }
+  if (process.platform !== "linux") {
+    debugLog(`detect-channel: platform=${process.platform} (not linux, skipping /proc walk)`);
+    return false;
+  }
+  try {
+    let pid = String(process.ppid);
+    debugLog(`detect-channel: starting walk from ppid=${pid}`);
+    for (let i = 0; i < 10; i++) {
+      const cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf-8").split("\0").filter(Boolean);
+      const bin = cmdline[0] ?? "";
+      debugLog(`detect-channel: pid=${pid} bin=${bin} args=${JSON.stringify(cmdline.slice(1))}`);
+      if (bin === "claude" || bin.endsWith("/claude")) {
+        // Check for our specific channel: --flag server:pairai-channel or --flag=server:pairai-channel
+        let found = false;
+        const channelArgs: string[] = [];
+        for (let j = 1; j < cmdline.length; j++) {
+          const arg = cmdline[j]!;
+          if (arg === CHANNEL_FLAG && cmdline[j + 1]) {
+            channelArgs.push(cmdline[j + 1]!);
+            if (cmdline[j + 1] === CHANNEL_VALUE) found = true;
+            j++; // skip value
+          } else if (arg.startsWith(`${CHANNEL_FLAG}=`)) {
+            const val = arg.slice(CHANNEL_FLAG.length + 1);
+            channelArgs.push(val);
+            if (val === CHANNEL_VALUE) found = true;
+          }
+        }
+        debugLog(`detect-channel: found claude binary at pid=${pid}, channels=${JSON.stringify(channelArgs)}, looking for="${CHANNEL_VALUE}", match=${found}`);
+        return found;
+      }
+      // Walk up: read ppid from /proc/<pid>/stat
+      // Format: "pid (comm) state ppid ..." — comm can contain spaces/parens,
+      // so find the LAST ")" to skip past it, then parse fields after it.
+      const stat = readFileSync(`/proc/${pid}/stat`, "utf-8");
+      const afterComm = stat.slice(stat.lastIndexOf(")") + 2);
+      const nextPid = afterComm.split(" ")[1]; // fields: state ppid ...
+      debugLog(`detect-channel: pid=${pid} → ppid=${nextPid}`);
+      if (!nextPid || nextPid === "1" || nextPid === "0") {
+        debugLog(`detect-channel: reached process tree root (pid=${nextPid}), stopping`);
+        break;
+      }
+      pid = nextPid;
+    }
+    debugLog("detect-channel: exhausted process tree without finding claude binary");
+  } catch (err) {
+    debugLog(`detect-channel: error walking /proc: ${(err as Error).message}`);
+  }
+  return false;
+}
+const channelCapable = detectChannelCapable();
+
+// For non-channel clients: track the highest event ID we've notified for locally,
+// so we don't re-deliver on each poll cycle. Not used when channelCapable=true.
+let lastNotifiedEventId = 0;
+
 async function poll() {
   try {
     // Refresh public keys to pick up new connections
     await loadPublicKeys();
 
-    const updates = (await hubGet("/events")) as {
+    // Non-channel clients: use local cursor to avoid re-notifying, but don't touch server cursor.
+    // Channel clients: use server cursor (default behavior — omit after=).
+    const afterQs = !channelCapable && lastNotifiedEventId > 0 ? `?after=${lastNotifiedEventId}` : "";
+    const updates = (await hubGet(`/events${afterQs}`)) as {
       events: Array<{
         id: number;
         type: string;
@@ -1914,7 +2029,7 @@ async function poll() {
       hasMore: boolean;
     };
 
-    debugLog(`poll: ${updates.events.length} events, cursor=${updates.cursor}, hasMore=${updates.hasMore}`);
+    debugLog(`poll: ${updates.events.length} events, cursor=${updates.cursor}, hasMore=${updates.hasMore}${channelCapable ? "" : `, localCursor=${lastNotifiedEventId}`}`);
 
     if (updates.events.length === 0) return;
 
@@ -1926,14 +2041,20 @@ async function poll() {
       }
     }
 
-    // Ack after successful delivery
-    if (updates.cursor > 0) {
-      try {
-        await hubPost("/events/ack", { cursor: updates.cursor });
-        debugLog(`poll: acked cursor=${updates.cursor}`);
-      } catch (err) {
-        debugLog(`poll: ack failed (will retry next cycle): ${(err as Error).message}`);
+    if (channelCapable) {
+      // Channel clients: ack server-side — notifications are reliably delivered
+      if (updates.cursor > 0) {
+        try {
+          await hubPost("/events/ack", { cursor: updates.cursor });
+          debugLog(`poll: acked cursor=${updates.cursor}`);
+        } catch (err) {
+          debugLog(`poll: ack failed (will retry next cycle): ${(err as Error).message}`);
+        }
       }
+    } else {
+      // Non-channel clients: advance local cursor only, leave server cursor for check_updates
+      lastNotifiedEventId = updates.cursor;
+      debugLog(`poll: local cursor advanced to ${lastNotifiedEventId}`);
     }
 
     if (updates.hasMore) {
@@ -1948,7 +2069,9 @@ async function poll() {
 // ── Start ────────────────────────────────────────────────────────────────────
 
 await mcp.connect(new StdioServerTransport());
-console.error(`[pairai] connected. provider=${serveProvider} channel=${!!capabilities.experimental?.["claude/channel"]} agent=${myAgentId || "(loading)"}`);
+console.error(`[pairai] connected. provider=${serveProvider} channelNotifications=${channelCapable} agent=${myAgentId || "(loading)"}`);
+debugLog(`startup: provider=${serveProvider} channelCapable=${channelCapable} (${channelCapable ? "poll acks server cursor" : "poll uses local cursor, check_updates acks"})`);
+
 await loadAgentInfo();
 if (!myAgentId) {
   console.error("[pairai] failed to load agent info from hub. Cannot start polling.");