ai2ai 0.1.0

package/lib/crypto.js

@@ -0,0 +1,124 @@
+/**
+ * AI2AI Crypto — Ed25519 signing, verification, and key management
+ * Zero external dependencies — uses only Node.js built-in crypto module.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { KEYS_DIR, ensureDirs } = require('./config');
+
+/**
+ * Generate a new Ed25519 key pair
+ */
+function generateKeyPair() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519', {
+    publicKeyEncoding: { type: 'spki', format: 'pem' },
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+  });
+  return { publicKey, privateKey };
+}
+
+/**
+ * Load keys from ~/.ai2ai/keys/
+ */
+function loadKeys() {
+  const pubPath = path.join(KEYS_DIR, 'agent.pub');
+  const privPath = path.join(KEYS_DIR, 'agent.key');
+
+  if (!fs.existsSync(pubPath) || !fs.existsSync(privPath)) {
+    return null;
+  }
+
+  return {
+    publicKey: fs.readFileSync(pubPath, 'utf-8'),
+    privateKey: fs.readFileSync(privPath, 'utf-8'),
+  };
+}
+
+/**
+ * Save keys to ~/.ai2ai/keys/
+ */
+function saveKeys(keys) {
+  ensureDirs();
+  const pubPath = path.join(KEYS_DIR, 'agent.pub');
+  const privPath = path.join(KEYS_DIR, 'agent.key');
+
+  fs.writeFileSync(pubPath, keys.publicKey, { mode: 0o644 });
+  fs.writeFileSync(privPath, keys.privateKey, { mode: 0o600 });
+}
+
+/**
+ * Load or create keys
+ */
+function loadOrCreateKeys() {
+  let keys = loadKeys();
+  if (!keys) {
+    keys = generateKeyPair();
+    saveKeys(keys);
+  }
+  return keys;
+}
+
+/**
+ * Get a human-readable fingerprint of a public key
+ */
+function getFingerprint(publicKeyPem) {
+  const hash = crypto.createHash('sha256').update(publicKeyPem).digest('hex');
+  return hash.match(/.{1,4}/g).slice(0, 8).join(':');
+}
+
+/**
+ * Sign a message envelope
+ * Signs the canonical fields to produce a deterministic signature.
+ */
+function signMessage(envelope, privateKeyPem) {
+  const payload = JSON.stringify({
+    id: envelope.id,
+    timestamp: envelope.timestamp,
+    from: envelope.from,
+    to: envelope.to,
+    conversation: envelope.conversation,
+    type: envelope.type,
+    intent: envelope.intent,
+    payload: envelope.payload,
+  });
+
+  const privateKey = crypto.createPrivateKey(privateKeyPem);
+  return crypto.sign(null, Buffer.from(payload), privateKey).toString('base64');
+}
+
+/**
+ * Verify a message signature
+ */
+function verifyMessage(envelope, signature, publicKeyPem) {
+  const payload = JSON.stringify({
+    id: envelope.id,
+    timestamp: envelope.timestamp,
+    from: envelope.from,
+    to: envelope.to,
+    conversation: envelope.conversation,
+    type: envelope.type,
+    intent: envelope.intent,
+    payload: envelope.payload,
+  });
+
+  try {
+    const publicKey = crypto.createPublicKey(publicKeyPem);
+    return crypto.verify(null, Buffer.from(payload), publicKey, Buffer.from(signature, 'base64'));
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  generateKeyPair,
+  loadKeys,
+  saveKeys,
+  loadOrCreateKeys,
+  getFingerprint,
+  signMessage,
+  verifyMessage,
+};

package/lib/init.js

@@ -0,0 +1,148 @@
+/**
+ * ai2ai init — Interactive setup wizard
+ * Creates identity, generates keys, saves config to ~/.ai2ai/
+ */
+
+'use strict';
+
+const readline = require('readline');
+const { saveConfig, loadConfig, ensureDirs, AI2AI_DIR } = require('./config');
+const { generateKeyPair, saveKeys, getFingerprint } = require('./crypto');
+
+/**
+ * Prompt the user for input
+ */
+function ask(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : '';
+  return new Promise(resolve => {
+    rl.question(`  ${question}${suffix}: `, answer => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+/**
+ * Prompt for yes/no
+ */
+function askYesNo(rl, question, defaultYes = false) {
+  const hint = defaultYes ? 'Y/n' : 'y/N';
+  return new Promise(resolve => {
+    rl.question(`  ${question} [${hint}]: `, answer => {
+      const a = answer.trim().toLowerCase();
+      if (!a) return resolve(defaultYes);
+      resolve(a === 'y' || a === 'yes');
+    });
+  });
+}
+
+async function run() {
+  const existing = loadConfig();
+
+  console.log(`
+╔══════════════════════════════════════════╗
+║     🦞 AI2AI — Agent Setup Wizard       ║
+╚══════════════════════════════════════════╝
+`);
+
+  if (existing) {
+    console.log(`  ⚠️  Existing config found at ${AI2AI_DIR}`);
+    console.log(`     Agent: ${existing.agentName} (${existing.humanName})\n`);
+  }
+
+  console.log('  Let\'s set up your AI agent identity.\n');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    // 1. Human name
+    const defaultName = existing?.humanName || '';
+    const humanName = await ask(rl, '👤 Your name', defaultName);
+    if (!humanName) {
+      console.log('\n  ❌ Name is required.\n');
+      return;
+    }
+
+    // 2. Agent name
+    const defaultAgent = existing?.agentName || `${humanName.toLowerCase().replace(/\s+/g, '-')}-assistant`;
+    const agentName = await ask(rl, '🤖 Agent name', defaultAgent);
+
+    // 3. Port
+    const defaultPort = existing?.port || 18800;
+    const portStr = await ask(rl, '🌐 Server port', String(defaultPort));
+    const port = parseInt(portStr) || defaultPort;
+
+    // 4. Timezone
+    const defaultTz = existing?.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timezone = await ask(rl, '🕐 Timezone', defaultTz);
+
+    // 5. Telegram integration
+    let telegramToken = existing?.telegramToken || '';
+    const wantTelegram = await askYesNo(rl, '📱 Enable Telegram integration?', !!telegramToken);
+    if (wantTelegram) {
+      telegramToken = await ask(rl, '🔑 Telegram bot token', telegramToken ? '(keep existing)' : '');
+      if (telegramToken === '(keep existing)') telegramToken = existing?.telegramToken || '';
+    } else {
+      telegramToken = '';
+    }
+
+    // 6. Generate keys
+    console.log('\n  🔑 Generating Ed25519 keypair...');
+    let keys;
+    if (existing && await askYesNo(rl, '   Keep existing keys?', true)) {
+      const { loadKeys } = require('./crypto');
+      keys = loadKeys();
+      if (!keys) {
+        console.log('   ⚠️  No existing keys found, generating new ones...');
+        keys = generateKeyPair();
+      }
+    } else {
+      keys = generateKeyPair();
+    }
+
+    rl.close();
+
+    // Save everything
+    ensureDirs();
+    saveKeys(keys);
+
+    const config = {
+      agentName,
+      humanName,
+      port,
+      timezone,
+      telegramToken: telegramToken || undefined,
+      createdAt: existing?.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    saveConfig(config);
+
+    const fingerprint = getFingerprint(keys.publicKey);
+
+    console.log(`
+╔══════════════════════════════════════════╗
+║          ✅ Setup Complete!              ║
+╚══════════════════════════════════════════╝
+
+  👤 Human:        ${humanName}
+  🤖 Agent:        ${agentName}
+  🌐 Port:         ${port}
+  🕐 Timezone:     ${timezone}
+  🔑 Fingerprint:  ${fingerprint}
+  📁 Config:       ${AI2AI_DIR}
+${telegramToken ? '  📱 Telegram:     Enabled\n' : ''}
+  Next steps:
+    ai2ai start                   Start your server
+    ai2ai connect <endpoint>      Connect to a friend
+    ai2ai status                  Check your setup
+`);
+
+  } catch (err) {
+    rl.close();
+    throw err;
+  }
+}
+
+module.exports = { run };

package/lib/pending.js

@@ -0,0 +1,114 @@
+/**
+ * ai2ai pending — Show pending messages awaiting human review
+ * Lists all pending messages with numbered references for easy approve/reject.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { PENDING_DIR, ensureDirs } = require('./config');
+
+/**
+ * Load all pending messages, sorted by date
+ */
+function loadPending() {
+  ensureDirs();
+  if (!fs.existsSync(PENDING_DIR)) return [];
+
+  const files = fs.readdirSync(PENDING_DIR).filter(f => f.endsWith('.json'));
+  const pending = [];
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(PENDING_DIR, file), 'utf-8'));
+      pending.push({
+        file,
+        id: file.replace('.json', ''),
+        ...data,
+      });
+    } catch {
+      // Skip corrupted files
+    }
+  }
+
+  // Sort by creation date (oldest first)
+  pending.sort((a, b) => {
+    const da = new Date(a.createdAt || 0);
+    const db = new Date(b.createdAt || 0);
+    return da - db;
+  });
+
+  return pending;
+}
+
+/**
+ * Get a pending message by its list number (1-indexed)
+ */
+function getPendingByNumber(num) {
+  const pending = loadPending();
+  if (num < 1 || num > pending.length) return null;
+  return pending[num - 1];
+}
+
+/**
+ * Remove a pending message
+ */
+function removePending(id) {
+  const filePath = path.join(PENDING_DIR, `${id}.json`);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+/**
+ * Format a timestamp for display
+ */
+function timeAgo(dateStr) {
+  const now = Date.now();
+  const then = new Date(dateStr).getTime();
+  const diff = now - then;
+
+  if (diff < 60000) return 'just now';
+  if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+  if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+  return `${Math.floor(diff / 86400000)}d ago`;
+}
+
+async function run() {
+  const pending = loadPending();
+
+  if (pending.length === 0) {
+    console.log('\n  📭 No pending messages.\n');
+    return;
+  }
+
+  console.log(`\n  📬 Pending Messages (${pending.length})\n`);
+  console.log('  ─'.repeat(25));
+
+  for (let i = 0; i < pending.length; i++) {
+    const p = pending[i];
+    const from = p.envelope?.from?.human || p.envelope?.from?.agent || 'Unknown';
+    const intent = p.handler || p.envelope?.intent || p.envelope?.type || 'unknown';
+    const time = p.createdAt ? timeAgo(p.createdAt) : '';
+
+    console.log(`\n  ${i + 1}. ${intent} from ${from}  (${time})`);
+
+    if (p.approvalMessage) {
+      // Indent the approval message
+      const lines = p.approvalMessage.split('\n');
+      for (const line of lines) {
+        console.log(`     ${line}`);
+      }
+    }
+
+    console.log(`     ID: ${p.id.slice(0, 8)}...`);
+  }
+
+  console.log('\n  ─'.repeat(25));
+  console.log(`\n  Commands:`);
+  console.log(`    ai2ai approve <number> [reply]   Accept with optional reply`);
+  console.log(`    ai2ai reject <number>            Decline\n`);
+}
+
+module.exports = { run, loadPending, getPendingByNumber, removePending };

package/lib/protocol.js

@@ -0,0 +1,161 @@
+/**
+ * AI2AI Protocol — Message creation and HTTP transport
+ * Handles envelope creation, signing, and sending.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const http = require('http');
+const https = require('https');
+const { requireConfig } = require('./config');
+const { loadOrCreateKeys, signMessage, getFingerprint } = require('./crypto');
+
+/**
+ * Create a new AI2AI message envelope
+ */
+function createEnvelope({ to, type, intent, payload, conversationId }) {
+  const config = requireConfig();
+  const keys = loadOrCreateKeys();
+
+  const envelope = {
+    ai2ai: '0.1',
+    id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    from: {
+      agent: config.agentName,
+      node: `${config.agentName}-node`,
+      human: config.humanName,
+    },
+    to: to || { agent: 'unknown', node: 'unknown', human: 'unknown' },
+    conversation: conversationId || crypto.randomUUID(),
+    type,
+    intent: intent || null,
+    payload: payload || {},
+    requires_human_approval: true,
+  };
+
+  envelope.signature = signMessage(envelope, keys.privateKey);
+  return envelope;
+}
+
+/**
+ * Create a ping envelope for handshaking
+ */
+function createPingEnvelope() {
+  const config = requireConfig();
+  const keys = loadOrCreateKeys();
+
+  return createEnvelope({
+    to: { agent: 'unknown', node: 'unknown', human: 'unknown' },
+    type: 'ping',
+    payload: {
+      capabilities: [
+        'schedule.meeting', 'schedule.call', 'message.relay',
+        'info.request', 'info.share', 'social.introduction',
+      ],
+      languages: ['en'],
+      timezone: config.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+      model_info: 'local',
+      protocol_versions: ['0.1'],
+      public_key: keys.publicKey,
+      fingerprint: getFingerprint(keys.publicKey),
+    },
+  });
+}
+
+/**
+ * Send an HTTP request to an AI2AI endpoint
+ * Returns a promise that resolves with the parsed JSON response.
+ */
+function sendRequest(endpoint, envelope) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint);
+    const transport = url.protocol === 'https:' ? https : http;
+
+    const body = JSON.stringify(envelope);
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        'X-AI2AI-Version': '0.1',
+      },
+      timeout: 30000,
+    };
+
+    const req = transport.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (res.statusCode >= 400) {
+            reject(new Error(parsed.error || parsed.reason || `HTTP ${res.statusCode}`));
+          } else {
+            resolve(parsed);
+          }
+        } catch {
+          reject(new Error(`Invalid response from server (HTTP ${res.statusCode})`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`Connection failed: ${err.message}`));
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Connection timed out (30s)'));
+    });
+
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * Fetch a URL via GET (for health checks etc.)
+ */
+function fetchGet(endpoint) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint);
+    const transport = url.protocol === 'https:' ? https : http;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname,
+      method: 'GET',
+      timeout: 10000,
+    };
+
+    const req = transport.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data: data });
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`Connection failed: ${err.message}`)));
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timed out')); });
+    req.end();
+  });
+}
+
+module.exports = {
+  createEnvelope,
+  createPingEnvelope,
+  sendRequest,
+  fetchGet,
+};

package/lib/send.js

@@ -0,0 +1,135 @@
+/**
+ * ai2ai send — Send a message to another agent
+ * Parses natural language to determine intent automatically.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const { requireConfig, findContact } = require('./config');
+const { createEnvelope, sendRequest } = require('./protocol');
+
+/**
+ * Detect if a message looks like a scheduling request
+ */
+function isSchedulingRequest(message) {
+  const patterns = [
+    /\b(meet|meeting|schedule|calendar|book|arrange)\b/i,
+    /\b(monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/i,
+    /\b(next week|this week|tomorrow|tonight|this evening)\b/i,
+    /\b(lunch|dinner|breakfast|coffee|drinks|call)\b/i,
+    /\b(\d{1,2}:\d{2}|noon|midnight|\d{1,2}\s*(am|pm))\b/i,
+    /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\w*\s+\d/i,
+  ];
+
+  let matches = 0;
+  for (const p of patterns) {
+    if (p.test(message)) matches++;
+  }
+  return matches >= 2; // Need at least 2 scheduling signals
+}
+
+/**
+ * Detect if a message is a question
+ */
+function isQuestion(message) {
+  return /\?$/.test(message.trim()) ||
+    /^(what|where|when|who|why|how|can|could|would|do|does|is|are)\b/i.test(message.trim());
+}
+
+async function run(args) {
+  if (args.length < 2) {
+    console.error('\n  ❌ Usage: ai2ai send <contact> <message>');
+    console.error('  Example: ai2ai send alex "dinner next Thursday?"\n');
+    process.exit(1);
+  }
+
+  const contactQuery = args[0];
+  const message = args.slice(1).join(' ').replace(/^["']|["']$/g, '');
+
+  const config = requireConfig();
+  const contact = findContact(contactQuery);
+
+  if (!contact) {
+    console.error(`\n  ❌ Contact "${contactQuery}" not found.`);
+    console.error('  Run `ai2ai contacts` to see known contacts.\n');
+    process.exit(1);
+  }
+
+  if (!contact.endpoint) {
+    console.error(`\n  ❌ No endpoint for "${contactQuery}".`);
+    console.error('  Run `ai2ai connect <endpoint>` to add one.\n');
+    process.exit(1);
+  }
+
+  // Determine intent based on message content
+  let intent, payload;
+
+  if (isSchedulingRequest(message)) {
+    intent = 'schedule.meeting';
+    payload = {
+      subject: message,
+      proposed_times: [], // The receiving agent will parse this
+      duration_minutes: 60,
+      notes: message,
+      flexibility: 'high',
+    };
+    console.log(`\n  📅 Detected scheduling request`);
+  } else if (isQuestion(message)) {
+    intent = 'info.request';
+    payload = {
+      question: message,
+    };
+    console.log(`\n  ❓ Detected question`);
+  } else {
+    intent = 'message.relay';
+    payload = {
+      message,
+      urgency: 'low',
+      reply_requested: true,
+    };
+    console.log(`\n  💬 Sending message`);
+  }
+
+  console.log(`  📤 To: ${contact.humanName || contact.id} (${contact.id})`);
+  console.log(`  🎯 Intent: ${intent}`);
+
+  try {
+    const envelope = createEnvelope({
+      to: {
+        agent: contact.id,
+        node: `${contact.id}-node`,
+        human: contact.humanName || contact.id,
+      },
+      type: 'request',
+      intent,
+      payload,
+    });
+
+    const response = await sendRequest(contact.endpoint, envelope);
+
+    if (response.status === 'pending_approval') {
+      console.log(`\n  ✅ Message delivered! Awaiting approval from ${contact.humanName || contact.id}.`);
+      console.log(`  💬 Conversation: ${envelope.conversation.slice(0, 8)}...`);
+      console.log('  Run `ai2ai pending` to check for responses.\n');
+    } else if (response.status === 'ok') {
+      console.log(`\n  ✅ Message delivered and processed!`);
+      if (response.payload) {
+        console.log(`  📨 Response: ${JSON.stringify(response.payload)}`);
+      }
+      console.log('');
+    } else if (response.status === 'rejected') {
+      console.error(`\n  ❌ Message rejected: ${response.reason}\n`);
+      process.exit(1);
+    } else {
+      console.log(`\n  📨 Response: ${JSON.stringify(response, null, 2)}\n`);
+    }
+
+  } catch (err) {
+    console.error(`\n  ❌ Failed to send: ${err.message}`);
+    console.error('  Is the recipient\'s server running?\n');
+    process.exit(1);
+  }
+}
+
+module.exports = { run };