pairai 0.1.2 → 0.2.1

package/bin.js

@@ -9,7 +9,7 @@ const require = createRequire(import.meta.url);
 
 // Resolve tsx from this package's node_modules as a file:// URL
 const tsxPath = pathToFileURL(require.resolve("tsx")).href;
-const script = join(__dirname, "pairai-channel.ts");
+const script = join(__dirname, "pairai.ts");
 
 const result = spawnSync(process.execPath, ["--import", tsxPath, script, ...process.argv.slice(2)], {
   stdio: "inherit",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pairai",
-  "version": "0.1.2",
-  "description": "Connect AI agents to collaborate via the pairai hub — channel server for Claude Code",
+  "version": "0.2.1",
+  "description": "pairai CLI — connect AI agents to collaborate via the pairai hub",
   "type": "module",
   "license": "MIT",
   "homepage": "https://pairai.pro",
@@ -23,7 +23,7 @@
   },
   "files": [
     "bin.js",
-    "pairai-channel.ts",
+    "pairai.ts",
     "README.md"
   ],
   "dependencies": {

package/{pairai-channel.ts → pairai.ts}

@@ -1,14 +1,15 @@
 #!/usr/bin/env npx tsx
 /**
- * pairai — connect AI agents via the pairai hub
+ * pairai CLI — connect AI agents via the pairai hub
  *
- * Setup:
- *   npx pairai setup "My Agent Name"
- *   npx pairai setup "My Agent Name" --hub https://myhub.example.com
+ * Commands:
+ *   npx pairai setup "Agent Name" [--hub URL] [--provider claude|gemini] [--global]
+ *   npx pairai serve [--provider claude|gemini]
+ *   npx pairai upgrade     — update to latest version (preserves keys and config)
+ *   npx pairai version     — show current version
  *
- * Runtime (spawned by Claude Code, not called manually):
- *   npx pairai serve
- *   Env: PAIRAI_URL, PAIRAI_API_KEY, PAIRAI_POLL_MS, PAIRAI_PRIVATE_KEY_PATH
+ * Env: PAIRAI_HUB_URL, PAIRAI_AGENT_CRED, PAIRAI_KEY_FILE, PAIRAI_POLL_MS
+ * Legacy: PAIRAI_URL, PAIRAI_API_KEY, PAIRAI_PRIVATE_KEY_PATH
  */
 import { execSync } from "node:child_process";
 import {
@@ -16,23 +17,89 @@ import {
   publicEncrypt, privateDecrypt, sign, verify,
   randomBytes, createCipheriv, createDecipheriv, constants,
 } from "node:crypto";
-import { writeFileSync, mkdirSync, readFileSync } from "node:fs";
+import { writeFileSync, mkdirSync, readFileSync, statSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf-8"));
+const VERSION: string = PKG.version;
 
 const args = process.argv.slice(2);
 const command = args[0];
 
-// ── Setup: register + configure Claude Code ──────────────────────────────────
+// ── Version ─────────────────────────────────────────────────────────────────
+
+if (command === "version" || args.includes("--version") || args.includes("-v")) {
+  console.log(`pairai v${VERSION}`);
+  process.exit(0);
+}
+
+// ── Upgrade ─────────────────────────────────────────────────────────────────
+
+if (command === "upgrade") {
+  console.log(`\n  Current version: v${VERSION}`);
+  console.log(`  Checking for updates...\n`);
+  try {
+    const latest = execSync("npm view pairai version", { encoding: "utf-8" }).trim();
+    if (latest === VERSION) {
+      console.log(`  Already on latest version (v${VERSION}).\n`);
+    } else {
+      console.log(`  New version available: v${latest}`);
+      console.log(`  Upgrading...\n`);
+      execSync("npm install -g pairai@latest", { stdio: "inherit" });
+      console.log(`\n  Upgraded to v${latest}.`);
+      console.log(`  Keys and config are unchanged.\n`);
+
+      // Update pinned version in config files
+      const configPaths = [
+        join(process.cwd(), ".mcp.json"),
+        join(process.cwd(), ".gemini", "settings.json"),
+        join(homedir(), ".gemini", "settings.json"),
+      ];
+      for (const p of configPaths) {
+        try {
+          if (!existsSync(p)) continue;
+          const content = readFileSync(p, "utf-8");
+          const updated = content.replace(
+            new RegExp(`pairai@${VERSION.replace(/\./g, "\\.")}`, "g"),
+            `pairai@${latest}`,
+          );
+          if (updated !== content) {
+            writeFileSync(p, updated);
+            console.log(`  Updated version in ${p}`);
+          }
+        } catch {}
+      }
+    }
+  } catch (err) {
+    console.error(`  Upgrade failed: ${(err as Error).message}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+function detectProvider(): "claude" | "gemini" {
+  if (process.env.GEMINI_CLI) return "gemini";
+  try { if (statSync(".gemini").isDirectory()) return "gemini"; } catch {}
+  return "claude";
+}
+
+// ── Setup: register + configure ──────────────────────────────────────────────
 
 if (command === "setup") {
   const rest = args.slice(1);
   const hubIdx = rest.indexOf("--hub");
   const hubUrl = hubIdx !== -1 ? rest.splice(hubIdx, 2)[1] : "https://pairai.pro";
+  const providerIdx = rest.indexOf("--provider");
+  const provider = providerIdx !== -1 ? rest.splice(providerIdx, 2)[1] as "claude" | "gemini" : detectProvider();
+  const globalIdx = rest.indexOf("--global");
+  const useGlobal = globalIdx !== -1 ? (rest.splice(globalIdx, 1), true) : false;
   const agentName = rest.find((a) => !a.startsWith("--"));
 
   if (!agentName) {
-    console.error('Usage: npx pairai setup "Agent Name" [--hub URL]');
+    console.error('Usage: npx pairai setup "Agent Name" [--hub URL] [--provider claude|gemini] [--global]');
     process.exit(1);
   }
 
@@ -65,35 +132,91 @@ if (command === "setup") {
   mkdirSync(keyDir, { recursive: true });
   const keyPath = join(keyDir, `${id}.pem`);
   writeFileSync(keyPath, privateKey, { mode: 0o600 });
-  console.log(`  Private key: ${keyPath}\n`);
-
-  // Write .mcp.json directly (claude mcp add --env puts env vars in args, which breaks)
-  const mcpConfig = {
-    mcpServers: {
-      "pairai-channel": {
-        command: "npx",
-        args: ["pairai", "serve"],
-        env: { PAIRAI_API_KEY: apiKey, PAIRAI_URL: hubUrl, PAIRAI_PRIVATE_KEY_PATH: keyPath },
+  console.log(`  Private key: ${keyPath}`);
+  console.log();
+  console.log(`  ┌──────────────────────────────────────────────────────────┐`);
+  console.log(`  │  BACK UP YOUR PRIVATE KEY                               │`);
+  console.log(`  │                                                          │`);
+  console.log(`  │  ${keyPath.padEnd(56)}│`);
+  console.log(`  │                                                          │`);
+  console.log(`  │  This key is stored only on your machine.                │`);
+  console.log(`  │  The hub never sees it. If lost, you must re-register    │`);
+  console.log(`  │  and re-pair — all encrypted history becomes unreadable. │`);
+  console.log(`  │                                                          │`);
+  console.log(`  │  Copy it to a password manager or secure backup now.     │`);
+  console.log(`  └──────────────────────────────────────────────────────────┘`);
+  console.log();
+
+  if (provider === "gemini") {
+    // Write .gemini/settings.json (project or global)
+    const geminiDir = useGlobal
+      ? join(homedir(), ".gemini")
+      : join(process.cwd(), ".gemini");
+    mkdirSync(geminiDir, { recursive: true });
+    const settingsPath = join(geminiDir, "settings.json");
+
+    // Merge with existing settings
+    let existing: any = {};
+    try {
+      if (existsSync(settingsPath)) {
+        existing = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      }
+    } catch {}
+
+    if (!existing.mcpServers) existing.mcpServers = {};
+    existing.mcpServers.pairai = {
+      command: "npx",
+      args: [`pairai@${VERSION}`, "serve"],
+      env: {
+        PAIRAI_HUB_URL: hubUrl,
+        PAIRAI_AGENT_CRED: apiKey,
+        PAIRAI_KEY_FILE: keyPath,
       },
-    },
-  };
+    };
+
+    writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    console.log(`  Config: ${settingsPath}`);
+    console.log();
+    console.log(`  Next steps:`);
+    console.log(`    1. Restart Gemini CLI to activate the pairai MCP server`);
+    console.log(`    2. Ask Gemini: "Generate a pairing code"`);
+    console.log(`    3. Share the code with another agent to connect`);
+  } else {
+    // Write .mcp.json for Claude Code
+    const mcpConfig = {
+      mcpServers: {
+        "pairai-channel": {
+          command: "npx",
+          args: [`pairai@${VERSION}`, "serve"],
+          env: { PAIRAI_AGENT_CRED: apiKey, PAIRAI_HUB_URL: hubUrl, PAIRAI_KEY_FILE: keyPath },
+        },
+      },
+    };
 
-  const cwd = process.cwd();
-  const mcpJsonPath = join(cwd, ".mcp.json");
-  writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n");
-  console.log(`  MCP config: ${mcpJsonPath}\n`);
-  console.log(`  Done! Start Claude Code with:\n`);
-  console.log(`    claude --dangerously-load-development-channels server:pairai-channel\n`);
+    const cwd = process.cwd();
+    const mcpJsonPath = join(cwd, ".mcp.json");
+    writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+    console.log(`  Config: ${mcpJsonPath}`);
+    console.log();
+    console.log(`  Next steps:`);
+    console.log(`    1. Start Claude Code in this directory`);
+    console.log(`    2. Ask Claude: "Generate a pairing code"`);
+    console.log(`    3. Share the code with another agent to connect`);
+  }
 
+  console.log();
   process.exit(0);
 }
 
 // ── Serve: stdio MCP channel server ──────────────────────────────────────────
 
 if (command !== "serve") {
+  console.error(`pairai v${VERSION}\n`);
   console.error("Usage:");
-  console.error('  npx pairai setup "Agent Name"   — register and configure');
-  console.error("  npx pairai serve                — run channel server (used by Claude Code)");
+  console.error('  npx pairai setup "Agent Name" [--hub URL] [--provider claude|gemini] [--global]');
+  console.error("  npx pairai serve [--provider claude|gemini]");
+  console.error("  npx pairai upgrade        — update to latest version");
+  console.error("  npx pairai version        — show current version");
   process.exit(1);
 }
 
@@ -101,14 +224,18 @@ const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
 const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
 const { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
 
-const HUB_URL = process.env.PAIRAI_URL ?? "https://pairai.pro";
-const API_KEY = process.env.PAIRAI_API_KEY;
+const serveArgs = args.slice(1);
+const serveProviderIdx = serveArgs.indexOf("--provider");
+const serveProvider = serveProviderIdx !== -1 ? serveArgs[serveProviderIdx + 1] : "claude";
+
+const HUB_URL = process.env.PAIRAI_HUB_URL ?? process.env.PAIRAI_URL ?? "https://pairai.pro";
+const API_KEY = process.env.PAIRAI_AGENT_CRED ?? process.env.PAIRAI_API_KEY;
 const POLL_MS = Number(process.env.PAIRAI_POLL_MS ?? "5000");
-const PRIVATE_KEY_PATH = process.env.PAIRAI_PRIVATE_KEY_PATH;
+const PRIVATE_KEY_PATH = process.env.PAIRAI_KEY_FILE ?? process.env.PAIRAI_PRIVATE_KEY_PATH;
 const PRIVATE_KEY = PRIVATE_KEY_PATH ? readFileSync(PRIVATE_KEY_PATH, "utf-8") : null;
 
 if (!API_KEY) {
-  console.error('PAIRAI_API_KEY not set. Run "npx pairai setup" first.');
+  console.error('PAIRAI_AGENT_CRED not set. Run "npx pairai setup" first.');
   process.exit(1);
 }
 
@@ -220,28 +347,30 @@ function localDecrypt(
 
 // ── MCP Server ───────────────────────────────────────────────────────────────
 
+const instructions = [
+  "You are connected to the pairai agent hub. Messages from other AI agents arrive as notifications.",
+  "The channel server polls for updates automatically — you don't need to poll manually.",
+  "",
+  "Notification attributes:",
+  "  task_id     — the task this message belongs to",
+  "  task_title  — short description of the task",
+  "  from_agent  — name of the agent who sent it",
+  "  event_type  — 'new_task' or 'new_message'",
+  "",
+  "When you receive a notification:",
+  "  - To respond, use the reply tool with the task_id and your message.",
+  "  - To accept a task, use the update_status tool with status 'working'.",
+  "  - To finish a task, use the update_status tool with status 'completed'.",
+  "  - To ask for more info, use update_status with 'input-required' and send a message.",
+].join("\n");
+
+const capabilities = serveProvider === "claude"
+  ? { experimental: { "claude/channel": {} }, tools: {} }
+  : { tools: {} };
+
 const mcp = new Server(
   { name: "pairai", version: "1.0.0" },
-  {
-    capabilities: {
-      experimental: { "claude/channel": {} },
-      tools: {},
-    },
-    instructions: [
-      'You are connected to the pairai agent hub. Messages from other AI agents arrive as <channel source="pairai" ...> notifications.',
-      "",
-      "Notification attributes:",
-      "  task_id     — the task this message belongs to",
-      "  task_title  — short description of the task",
-      "  from_agent  — name of the agent who sent it",
-      "  event_type  — 'new_task' or 'new_message'",
-      "",
-      "To respond, use the pairai_reply tool with the task_id and your message.",
-      "To accept a task, use pairai_update_status with status 'working'.",
-      "To finish a task, use pairai_update_status with status 'completed'.",
-      "To ask for more info, use pairai_update_status with 'input-required' and send a message.",
-    ].join("\n"),
-  }
+  { capabilities, instructions }
 );
 
 // ── Tools ────────────────────────────────────────────────────────────────────
@@ -334,6 +463,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     const taskData = (await hubGet(`/tasks/${task_id}`)) as any;
     if (taskData.encrypted) {
       // STRICT: never fall back to plaintext for encrypted tasks
+      await loadPublicKeys(); // refresh in case keys were added since last poll
       const otherId =
         taskData.initiatorAgentId === myAgentId ? taskData.targetAgentId : taskData.initiatorAgentId;
       const otherPub = pubKeyCache.get(otherId);
@@ -372,10 +502,38 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   }
 
   if (name === "pairai_create_task") {
+    const { target_agent_id, title, description } = args as {
+      target_agent_id: string; title: string; description?: string;
+    };
+
+    // Auto-encrypt when both agents have keys and we have a private key
+    await loadPublicKeys();
+    const otherPub = pubKeyCache.get(target_agent_id);
+    if (PRIVATE_KEY && otherPub && myPublicKey) {
+      const { nanoid } = await import("nanoid");
+      const taskId = nanoid();
+      const payload = JSON.stringify({ title, description: description ?? "" });
+      const { ciphertext, signature, encryptedKeys } = localEncrypt(payload, taskId, {
+        [myAgentId]: myPublicKey,
+        [target_agent_id]: otherPub,
+      });
+      await hubPost("/tasks", {
+        id: taskId,
+        targetAgentId: target_agent_id,
+        title: "Encrypted Task",
+        description: ciphertext,
+        encrypted: true,
+        descriptionKeys: encryptedKeys,
+        senderSignature: signature,
+      });
+      return { content: [{ type: "text" as const, text: `Task created (encrypted). ID: ${taskId}` }] };
+    }
+
+    // Fallback: plaintext (no keys available)
     const data = await hubPost("/tasks", {
-      targetAgentId: args.target_agent_id,
-      title: args.title,
-      description: args.description,
+      targetAgentId: target_agent_id,
+      title,
+      description,
     });
     return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
   }
@@ -400,6 +558,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       title: string;
       description?: string;
     };
+    // Refresh keys in case a new connection was established
+    await loadPublicKeys();
     const otherPub = pubKeyCache.get(target_agent_id);
     if (!otherPub || !myPublicKey)
       return {