a2acalling 0.1.0

package/src/lib/call-monitor.js

@@ -0,0 +1,143 @@
+/**
+ * Call Monitor - Auto-concludes idle conversations
+ * 
+ * Monitors active conversations and triggers summarization when:
+ * - No messages for 60 seconds (configurable)
+ * - Explicit end signal received
+ * - Max duration exceeded
+ */
+
+class CallMonitor {
+  constructor(options = {}) {
+    this.convStore = options.convStore;
+    this.summarizer = options.summarizer;
+    this.notifyOwner = options.notifyOwner || (() => {});
+    this.ownerContext = options.ownerContext || {};
+    
+    // Timing config
+    this.idleTimeoutMs = options.idleTimeoutMs || 60000;      // 60s idle
+    this.maxDurationMs = options.maxDurationMs || 300000;     // 5min max
+    this.checkIntervalMs = options.checkIntervalMs || 10000;  // Check every 10s
+    
+    this.intervalId = null;
+    this.activeConversations = new Map(); // conversationId -> { startTime, lastActivity, callerInfo }
+  }
+
+  /**
+   * Start monitoring
+   */
+  start() {
+    if (this.intervalId) return;
+    
+    this.intervalId = setInterval(() => {
+      this._checkIdleConversations();
+    }, this.checkIntervalMs);
+    
+    console.log('[a2a] Call monitor started');
+  }
+
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      console.log('[a2a] Call monitor stopped');
+    }
+  }
+
+  /**
+   * Track a new or continuing conversation
+   */
+  trackActivity(conversationId, callerInfo = {}) {
+    const now = Date.now();
+    const existing = this.activeConversations.get(conversationId);
+    
+    if (existing) {
+      existing.lastActivity = now;
+    } else {
+      this.activeConversations.set(conversationId, {
+        startTime: now,
+        lastActivity: now,
+        callerInfo
+      });
+    }
+  }
+
+  /**
+   * Explicitly end a conversation
+   */
+  async endConversation(conversationId, reason = 'explicit') {
+    const convData = this.activeConversations.get(conversationId);
+    this.activeConversations.delete(conversationId);
+    
+    if (!this.convStore) return { success: false, error: 'no_store' };
+    
+    try {
+      const result = await this.convStore.concludeConversation(conversationId, {
+        summarizer: this.summarizer,
+        ownerContext: this.ownerContext
+      });
+      
+      if (result.success) {
+        // Notify owner
+        const context = this.convStore.getConversationContext(conversationId);
+        this.notifyOwner({
+          type: 'conversation_concluded',
+          reason,
+          conversation: context,
+          callerInfo: convData?.callerInfo
+        }).catch(err => {
+          console.error('[a2a] Failed to notify owner:', err.message);
+        });
+      }
+      
+      return result;
+    } catch (err) {
+      console.error('[a2a] Failed to conclude conversation:', err.message);
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * Check for idle conversations
+   */
+  async _checkIdleConversations() {
+    const now = Date.now();
+    
+    for (const [convId, data] of this.activeConversations) {
+      const idleTime = now - data.lastActivity;
+      const duration = now - data.startTime;
+      
+      // Check max duration
+      if (duration > this.maxDurationMs) {
+        console.log(`[a2a] Conversation ${convId} exceeded max duration, concluding...`);
+        await this.endConversation(convId, 'max_duration');
+        continue;
+      }
+      
+      // Check idle timeout
+      if (idleTime > this.idleTimeoutMs) {
+        console.log(`[a2a] Conversation ${convId} idle for ${Math.round(idleTime / 1000)}s, concluding...`);
+        await this.endConversation(convId, 'idle_timeout');
+      }
+    }
+  }
+
+  /**
+   * Get active conversation count
+   */
+  getActiveCount() {
+    return this.activeConversations.size;
+  }
+
+  /**
+   * Get all active conversation IDs
+   */
+  getActiveConversations() {
+    return Array.from(this.activeConversations.keys());
+  }
+}
+
+module.exports = { CallMonitor };

package/src/lib/client.js

@@ -0,0 +1,208 @@
+/**
+ * A2A Client - Make calls to remote agents
+ */
+
+const https = require('https');
+const http = require('http');
+
+class A2AClient {
+  constructor(options = {}) {
+    this.timeout = options.timeout || 60000;
+    this.caller = options.caller || {};
+  }
+
+  /**
+   * Parse an a2a:// URL
+   */
+  static parseInvite(inviteUrl) {
+    // Support both a2a:// and legacy oclaw:// schemes
+    const match = inviteUrl.match(/^(?:a2a|oclaw):\/\/([^/]+)\/(.+)$/);
+    if (!match) {
+      throw new Error(`Invalid invite URL: ${inviteUrl}`);
+    }
+    return { host: match[1], token: match[2] };
+  }
+
+  /**
+   * Call a remote agent
+   * 
+   * @param {string} endpoint - a2a:// URL or {host, token}
+   * @param {string} message - Message to send
+   * @param {object} options - Additional options
+   * @returns {Promise<object>} Response from remote agent
+   */
+  async call(endpoint, message, options = {}) {
+    let host, token;
+    
+    if (typeof endpoint === 'string') {
+      ({ host, token } = A2AClient.parseInvite(endpoint));
+    } else {
+      ({ host, token } = endpoint);
+    }
+
+    const { conversationId, context, timeoutSeconds } = options;
+
+    const body = JSON.stringify({
+      message,
+      conversation_id: conversationId,
+      caller: this.caller,
+      context,
+      timeout_seconds: timeoutSeconds || 60
+    });
+
+    const isLocalhost = host === 'localhost' || host.startsWith('localhost:') || host.startsWith('127.');
+    const hasExplicitPort = host.includes(':');
+    const port = hasExplicitPort ? parseInt(host.split(':')[1]) : (isLocalhost ? 80 : 443);
+    // Use HTTP for localhost or explicit non-443 ports, HTTPS otherwise
+    const useHttp = isLocalhost || (hasExplicitPort && port !== 443);
+    const protocol = useHttp ? http : https;
+    const hostname = host.split(':')[0];
+
+    return new Promise((resolve, reject) => {
+      const req = protocol.request({
+        hostname,
+        port,
+        path: '/api/federation/invoke',
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body)
+        },
+        timeout: this.timeout
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new A2AError(json.error || 'request_failed', json.message || data, res.statusCode));
+            } else {
+              resolve(json);
+            }
+          } catch (e) {
+            reject(new A2AError('parse_error', `Failed to parse response: ${data}`, res.statusCode));
+          }
+        });
+      });
+
+      req.on('error', (e) => {
+        reject(new A2AError('network_error', e.message));
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new A2AError('timeout', 'Request timed out'));
+      });
+
+      req.write(body);
+      req.end();
+    });
+  }
+
+  /**
+   * Check if a remote agent is available
+   */
+  async ping(endpoint) {
+    let host;
+    
+    if (typeof endpoint === 'string') {
+      ({ host } = A2AClient.parseInvite(endpoint));
+    } else {
+      ({ host } = endpoint);
+    }
+
+    const isLocalhost = host === 'localhost' || host.startsWith('localhost:') || host.startsWith('127.');
+    const hasExplicitPort = host.includes(':');
+    const port = hasExplicitPort ? parseInt(host.split(':')[1]) : (isLocalhost ? 80 : 443);
+    const useHttp = isLocalhost || (hasExplicitPort && port !== 443);
+    const protocol = useHttp ? http : https;
+    const hostname = host.split(':')[0];
+
+    return new Promise((resolve, reject) => {
+      const req = protocol.request({
+        hostname,
+        port,
+        path: '/api/federation/ping',
+        method: 'GET',
+        timeout: 5000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            resolve({ pong: res.statusCode === 200 });
+          }
+        });
+      });
+
+      req.on('error', () => resolve({ pong: false }));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ pong: false });
+      });
+      req.end();
+    });
+  }
+
+  /**
+   * Get federation status of a remote
+   */
+  async status(endpoint) {
+    let host;
+    
+    if (typeof endpoint === 'string') {
+      ({ host } = A2AClient.parseInvite(endpoint));
+    } else {
+      ({ host } = endpoint);
+    }
+
+    const isLocalhost = host === 'localhost' || host.startsWith('localhost:') || host.startsWith('127.');
+    const hasExplicitPort = host.includes(':');
+    const port = hasExplicitPort ? parseInt(host.split(':')[1]) : (isLocalhost ? 80 : 443);
+    const useHttp = isLocalhost || (hasExplicitPort && port !== 443);
+    const protocol = useHttp ? http : https;
+    const hostname = host.split(':')[0];
+
+    return new Promise((resolve, reject) => {
+      const req = protocol.request({
+        hostname,
+        port,
+        path: '/api/federation/status',
+        method: 'GET',
+        timeout: 5000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            reject(new A2AError('parse_error', 'Invalid status response'));
+          }
+        });
+      });
+
+      req.on('error', (e) => reject(new A2AError('network_error', e.message)));
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new A2AError('timeout', 'Request timed out'));
+      });
+      req.end();
+    });
+  }
+}
+
+class A2AError extends Error {
+  constructor(code, message, statusCode = null) {
+    super(message);
+    this.name = 'A2AError';
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+}
+
+module.exports = { A2AClient, A2AError };

package/src/lib/config.js

@@ -0,0 +1,173 @@
+/**
+ * A2A Configuration Management
+ * 
+ * Stores permission tiers, default settings, and user preferences.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_DIR = process.env.A2A_CONFIG_DIR || 
+  process.env.OPENCLAW_CONFIG_DIR || 
+  path.join(process.env.HOME || '/tmp', '.config', 'openclaw');
+
+const CONFIG_FILE = path.join(CONFIG_DIR, 'a2a-config.json');
+
+const DEFAULT_CONFIG = {
+  // Has the user completed onboarding?
+  onboardingComplete: false,
+  
+  // Permission tiers
+  tiers: {
+    public: {
+      name: 'Public',
+      description: 'Basic networking - safe for anyone',
+      capabilities: [],
+      disclosure: 'minimal',
+      examples: ['calendar availability', 'public social posts', 'general questions']
+    },
+    friends: {
+      name: 'Friends',
+      description: 'Most capabilities, no sensitive financial data',
+      capabilities: [],
+      disclosure: 'public',
+      examples: ['email summaries', 'schedule meetings', 'project discussions']
+    },
+    private: {
+      name: 'Private',
+      description: 'Full access - only for you',
+      capabilities: [],
+      disclosure: 'public',
+      examples: ['financial data', 'personal notes', 'private conversations']
+    },
+    custom: {
+      name: 'Custom',
+      description: 'User-defined permissions',
+      capabilities: [],
+      disclosure: 'minimal',
+      examples: []
+    }
+  },
+  
+  // Default token settings
+  defaults: {
+    expiration: 'never',        // never, 1d, 7d, 30d
+    maxCalls: 100,              // per token
+    rateLimit: {
+      perMinute: 10,
+      perHour: 100,
+      perDay: 1000
+    },
+    maxPendingRequests: 5       // max connection requests per hour
+  },
+  
+  // Agent info
+  agent: {
+    name: '',
+    description: '',
+    hostname: ''
+  },
+  
+  // Timestamps
+  createdAt: null,
+  updatedAt: null
+};
+
+class A2AConfig {
+  constructor() {
+    this._ensureDir();
+    this.config = this._load();
+  }
+
+  _ensureDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+  }
+
+  _load() {
+    if (fs.existsSync(CONFIG_FILE)) {
+      try {
+        const saved = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        return { ...DEFAULT_CONFIG, ...saved };
+      } catch (e) {
+        console.error('[a2a] Config corrupted, using defaults');
+        return { ...DEFAULT_CONFIG };
+      }
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+
+  _save() {
+    this.config.updatedAt = new Date().toISOString();
+    if (!this.config.createdAt) {
+      this.config.createdAt = this.config.updatedAt;
+    }
+    const tmpPath = `${CONFIG_FILE}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(this.config, null, 2));
+    fs.renameSync(tmpPath, CONFIG_FILE);
+  }
+
+  // Check if onboarding is complete
+  isOnboarded() {
+    return this.config.onboardingComplete === true;
+  }
+
+  // Mark onboarding complete
+  completeOnboarding() {
+    this.config.onboardingComplete = true;
+    this._save();
+  }
+
+  // Reset to run onboarding again
+  resetOnboarding() {
+    this.config.onboardingComplete = false;
+    this._save();
+  }
+
+  // Get/set tiers
+  getTiers() {
+    return this.config.tiers;
+  }
+
+  setTier(tierName, tierConfig) {
+    this.config.tiers[tierName] = { ...this.config.tiers[tierName], ...tierConfig };
+    this._save();
+  }
+
+  // Get/set defaults
+  getDefaults() {
+    return this.config.defaults;
+  }
+
+  setDefaults(defaults) {
+    this.config.defaults = { ...this.config.defaults, ...defaults };
+    this._save();
+  }
+
+  // Get/set agent info
+  getAgent() {
+    return this.config.agent;
+  }
+
+  setAgent(agent) {
+    this.config.agent = { ...this.config.agent, ...agent };
+    this._save();
+  }
+
+  // Get full config
+  getAll() {
+    return this.config;
+  }
+
+  // Export for sharing
+  export() {
+    return {
+      tiers: this.config.tiers,
+      defaults: this.config.defaults,
+      agent: this.config.agent
+    };
+  }
+}
+
+module.exports = { A2AConfig, DEFAULT_CONFIG, CONFIG_FILE };