@tjamescouch/agentchat 0.22.1 → 0.23.1

package/lib/server/handlers/skills.js

@@ -1,141 +0,0 @@
-/**
- * Skills Handlers
- * Handles skill registration and search
- */
-
-import {
-  ServerMessageType,
-  ErrorCode,
-  createMessage,
-  createError,
-} from '../../protocol.js';
-
-/**
- * Handle REGISTER_SKILLS command
- */
-export function handleRegisterSkills(server, ws, msg) {
-  const agent = server.agents.get(ws);
-  if (!agent) {
-    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
-    return;
-  }
-
-  if (!agent.pubkey) {
-    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Skill registration requires persistent identity'));
-    return;
-  }
-
-  // Store skills for this agent
-  const registration = {
-    agent_id: `@${agent.id}`,
-    skills: msg.skills,
-    registered_at: Date.now(),
-    sig: msg.sig
-  };
-
-  server.skillsRegistry.set(agent.id, registration);
-
-  server._log('skills_registered', { agent: agent.id, count: msg.skills.length });
-
-  // Notify the registering agent
-  server._send(ws, createMessage(ServerMessageType.SKILLS_REGISTERED, {
-    agent_id: `@${agent.id}`,
-    skills_count: msg.skills.length,
-    registered_at: registration.registered_at
-  }));
-
-  // Optionally broadcast to #discovery channel if it exists
-  if (server.channels.has('#discovery')) {
-    server._broadcast('#discovery', createMessage(ServerMessageType.MSG, {
-      from: '@server',
-      to: '#discovery',
-      content: `Agent @${agent.id} registered ${msg.skills.length} skill(s): ${msg.skills.map(s => s.capability).join(', ')}`
-    }));
-  }
-}
-
-/**
- * Handle SEARCH_SKILLS command
- */
-export async function handleSearchSkills(server, ws, msg) {
-  const agent = server.agents.get(ws);
-  if (!agent) {
-    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
-    return;
-  }
-
-  const query = msg.query || {};
-  const results = [];
-
-  // Search through all registered skills
-  for (const [agentId, registration] of server.skillsRegistry) {
-    for (const skill of registration.skills) {
-      let matches = true;
-
-      // Filter by capability (substring match, case-insensitive)
-      if (query.capability) {
-        const cap = skill.capability.toLowerCase();
-        const search = query.capability.toLowerCase();
-        if (!cap.includes(search)) {
-          matches = false;
-        }
-      }
-
-      // Filter by max_rate
-      if (query.max_rate !== undefined && skill.rate !== undefined) {
-        if (skill.rate > query.max_rate) {
-          matches = false;
-        }
-      }
-
-      // Filter by currency
-      if (query.currency && skill.currency) {
-        if (skill.currency.toLowerCase() !== query.currency.toLowerCase()) {
-          matches = false;
-        }
-      }
-
-      if (matches) {
-        results.push({
-          agent_id: registration.agent_id,
-          ...skill,
-          registered_at: registration.registered_at
-        });
-      }
-    }
-  }
-
-  // Enrich results with reputation data
-  const uniqueAgentIds = [...new Set(results.map(r => r.agent_id))];
-  const ratingCache = new Map();
-  for (const agentId of uniqueAgentIds) {
-    const ratingInfo = await server.reputationStore.getRating(agentId);
-    ratingCache.set(agentId, ratingInfo);
-  }
-
-  // Add rating info to each result
-  for (const result of results) {
-    const ratingInfo = ratingCache.get(result.agent_id);
-    result.rating = ratingInfo.rating;
-    result.transactions = ratingInfo.transactions;
-  }
-
-  // Sort by rating (highest first), then by registration time
-  results.sort((a, b) => {
-    if (b.rating !== a.rating) return b.rating - a.rating;
-    return b.registered_at - a.registered_at;
-  });
-
-  // Limit results
-  const limit = query.limit || 50;
-  const limitedResults = results.slice(0, limit);
-
-  server._log('skills_search', { agent: agent.id, query, results_count: limitedResults.length });
-
-  server._send(ws, createMessage(ServerMessageType.SEARCH_RESULTS, {
-    query_id: msg.query_id || null,
-    query,
-    results: limitedResults,
-    total: results.length
-  }));
-}

package/lib/server-directory.js

@@ -1,190 +0,0 @@
-/**
- * Server Directory
- * Registry of known AgentChat servers for discovery
- */
-
-import http from 'http';
-import https from 'https';
-import fs from 'fs/promises';
-import path from 'path';
-
-// Default public servers (can be extended)
-export const DEFAULT_SERVERS = process.env.AGENTCHAT_PUBLIC === 'true'
-  ? [
-      {
-        name: 'AgentChat Public',
-        url: 'wss://agentchat-server.fly.dev',
-        description: 'Official public AgentChat server',
-        region: 'global'
-      }
-    ]
-  : [
-      {
-        name: 'AgentChat Local',
-        url: 'ws://localhost:6667',
-        description: 'Local AgentChat server',
-        region: 'local'
-      }
-    ];
-
-// Default directory file path
-export const DEFAULT_DIRECTORY_PATH = path.join(
-  process.env.HOME || process.env.USERPROFILE || '.',
-  '.agentchat',
-  'servers.json'
-);
-
-/**
- * Server Directory for discovering AgentChat servers
- */
-export class ServerDirectory {
-  constructor(options = {}) {
-    this.directoryPath = options.directoryPath || DEFAULT_DIRECTORY_PATH;
-    this.servers = [...DEFAULT_SERVERS];
-    this.timeout = options.timeout || 5000;
-  }
-
-  /**
-   * Load servers from directory file
-   */
-  async load() {
-    try {
-      const data = await fs.readFile(this.directoryPath, 'utf8');
-      const loaded = JSON.parse(data);
-      if (Array.isArray(loaded.servers)) {
-        // Merge with defaults, avoiding duplicates by URL
-        const urls = new Set(this.servers.map(s => s.url));
-        for (const server of loaded.servers) {
-          if (!urls.has(server.url)) {
-            this.servers.push(server);
-            urls.add(server.url);
-          }
-        }
-      }
-    } catch (err) {
-      // File doesn't exist or is invalid, use defaults
-    }
-    return this;
-  }
-
-  /**
-   * Save servers to directory file
-   */
-  async save() {
-    const dir = path.dirname(this.directoryPath);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(this.directoryPath, JSON.stringify({
-      version: 1,
-      updated_at: new Date().toISOString(),
-      servers: this.servers
-    }, null, 2));
-  }
-
-  /**
-   * Add a server to the directory
-   */
-  async addServer(server) {
-    const existing = this.servers.find(s => s.url === server.url);
-    if (existing) {
-      Object.assign(existing, server);
-    } else {
-      this.servers.push(server);
-    }
-    await this.save();
-  }
-
-  /**
-   * Remove a server from the directory
-   */
-  async removeServer(url) {
-    this.servers = this.servers.filter(s => s.url !== url);
-    await this.save();
-  }
-
-  /**
-   * Check health of a single server
-   * @param {Object} server - Server object with url
-   * @returns {Object} Server with health status
-   */
-  async checkHealth(server) {
-    const wsUrl = server.url;
-    // Convert ws:// or wss:// to http:// or https://
-    const httpUrl = wsUrl
-      .replace('wss://', 'https://')
-      .replace('ws://', 'http://');
-
-    try {
-      const health = await this._fetchHealth(httpUrl + '/health');
-      return {
-        ...server,
-        status: 'online',
-        health,
-        checked_at: new Date().toISOString()
-      };
-    } catch (err) {
-      return {
-        ...server,
-        status: 'offline',
-        error: err.message || err.code || 'Unknown error',
-        checked_at: new Date().toISOString()
-      };
-    }
-  }
-
-  /**
-   * Fetch health endpoint
-   */
-  _fetchHealth(url) {
-    return new Promise((resolve, reject) => {
-      const protocol = url.startsWith('https') ? https : http;
-      const req = protocol.get(url, { timeout: this.timeout }, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-          if (res.statusCode === 200) {
-            try {
-              resolve(JSON.parse(data));
-            } catch {
-              reject(new Error('Invalid health response'));
-            }
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}`));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Timeout'));
-      });
-    });
-  }
-
-  /**
-   * Discover available servers (check health of all known servers)
-   * @param {Object} options
-   * @param {boolean} options.onlineOnly - Only return online servers
-   * @returns {Array} List of servers with status
-   */
-  async discover(options = {}) {
-    const results = await Promise.all(
-      this.servers.map(server => this.checkHealth(server))
-    );
-
-    if (options.onlineOnly) {
-      return results.filter(s => s.status === 'online');
-    }
-
-    return results;
-  }
-
-  /**
-   * Get list of known servers without health check
-   */
-  list() {
-    return [...this.servers];
-  }
-}
-
-export default ServerDirectory;

package/lib/server-directory.ts

@@ -1,232 +0,0 @@
-/**
- * Server Directory
- * Registry of known AgentChat servers for discovery
- */
-
-import http from 'http';
-import https from 'https';
-import fs from 'fs/promises';
-import path from 'path';
-
-export interface ServerEntry {
-  name: string;
-  url: string;
-  description?: string;
-  region?: string;
-}
-
-export interface HealthData {
-  agents?: {
-    connected?: number;
-  };
-  uptime_seconds?: number;
-  [key: string]: unknown;
-}
-
-export interface ServerWithStatus extends ServerEntry {
-  status: 'online' | 'offline' | 'unknown';
-  health?: HealthData;
-  error?: string;
-  checked_at?: string;
-}
-
-export interface ServerDirectoryFile {
-  version: number;
-  updated_at: string;
-  servers: ServerEntry[];
-}
-
-export interface ServerDirectoryOptions {
-  directoryPath?: string;
-  timeout?: number;
-}
-
-export interface DiscoverOptions {
-  onlineOnly?: boolean;
-}
-
-// Default public servers (can be extended)
-export const DEFAULT_SERVERS: ServerEntry[] = process.env.AGENTCHAT_PUBLIC === 'true'
-  ? [
-      {
-        name: 'AgentChat Public',
-        url: 'wss://agentchat-server.fly.dev',
-        description: 'Official public AgentChat server',
-        region: 'global'
-      }
-    ]
-  : [
-      {
-        name: 'AgentChat Local',
-        url: 'ws://localhost:6667',
-        description: 'Local AgentChat server',
-        region: 'local'
-      }
-    ];
-
-// Default directory file path
-export const DEFAULT_DIRECTORY_PATH: string = path.join(
-  process.env.HOME || process.env.USERPROFILE || '.',
-  '.agentchat',
-  'servers.json'
-);
-
-/**
- * Server Directory for discovering AgentChat servers
- */
-export class ServerDirectory {
-  private directoryPath: string;
-  private servers: ServerEntry[];
-  private timeout: number;
-
-  constructor(options: ServerDirectoryOptions = {}) {
-    this.directoryPath = options.directoryPath || DEFAULT_DIRECTORY_PATH;
-    this.servers = [...DEFAULT_SERVERS];
-    this.timeout = options.timeout || 5000;
-  }
-
-  /**
-   * Load servers from directory file
-   */
-  async load(): Promise<this> {
-    try {
-      const data = await fs.readFile(this.directoryPath, 'utf8');
-      const loaded = JSON.parse(data) as ServerDirectoryFile;
-      if (Array.isArray(loaded.servers)) {
-        // Merge with defaults, avoiding duplicates by URL
-        const urls = new Set(this.servers.map(s => s.url));
-        for (const server of loaded.servers) {
-          if (!urls.has(server.url)) {
-            this.servers.push(server);
-            urls.add(server.url);
-          }
-        }
-      }
-    } catch {
-      // File doesn't exist or is invalid, use defaults
-    }
-    return this;
-  }
-
-  /**
-   * Save servers to directory file
-   */
-  async save(): Promise<void> {
-    const dir = path.dirname(this.directoryPath);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(this.directoryPath, JSON.stringify({
-      version: 1,
-      updated_at: new Date().toISOString(),
-      servers: this.servers
-    } as ServerDirectoryFile, null, 2));
-  }
-
-  /**
-   * Add a server to the directory
-   */
-  async addServer(server: ServerEntry): Promise<void> {
-    const existing = this.servers.find(s => s.url === server.url);
-    if (existing) {
-      Object.assign(existing, server);
-    } else {
-      this.servers.push(server);
-    }
-    await this.save();
-  }
-
-  /**
-   * Remove a server from the directory
-   */
-  async removeServer(url: string): Promise<void> {
-    this.servers = this.servers.filter(s => s.url !== url);
-    await this.save();
-  }
-
-  /**
-   * Check health of a single server
-   * @param server - Server object with url
-   * @returns Server with health status
-   */
-  async checkHealth(server: ServerEntry): Promise<ServerWithStatus> {
-    const wsUrl = server.url;
-    // Convert ws:// or wss:// to http:// or https://
-    const httpUrl = wsUrl
-      .replace('wss://', 'https://')
-      .replace('ws://', 'http://');
-
-    try {
-      const health = await this._fetchHealth(httpUrl + '/health');
-      return {
-        ...server,
-        status: 'online',
-        health,
-        checked_at: new Date().toISOString()
-      };
-    } catch (err) {
-      const error = err as Error & { code?: string };
-      return {
-        ...server,
-        status: 'offline',
-        error: error.message || error.code || 'Unknown error',
-        checked_at: new Date().toISOString()
-      };
-    }
-  }
-
-  /**
-   * Fetch health endpoint
-   */
-  private _fetchHealth(url: string): Promise<HealthData> {
-    return new Promise((resolve, reject) => {
-      const protocol = url.startsWith('https') ? https : http;
-      const req = protocol.get(url, { timeout: this.timeout }, (res) => {
-        let data = '';
-        res.on('data', (chunk: Buffer) => data += chunk);
-        res.on('end', () => {
-          if (res.statusCode === 200) {
-            try {
-              resolve(JSON.parse(data) as HealthData);
-            } catch {
-              reject(new Error('Invalid health response'));
-            }
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}`));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Timeout'));
-      });
-    });
-  }
-
-  /**
-   * Discover available servers (check health of all known servers)
-   * @param options
-   * @param options.onlineOnly - Only return online servers
-   * @returns List of servers with status
-   */
-  async discover(options: DiscoverOptions = {}): Promise<ServerWithStatus[]> {
-    const results = await Promise.all(
-      this.servers.map(server => this.checkHealth(server))
-    );
-
-    if (options.onlineOnly) {
-      return results.filter(s => s.status === 'online');
-    }
-
-    return results;
-  }
-
-  /**
-   * Get list of known servers without health check
-   */
-  list(): ServerEntry[] {
-    return [...this.servers];
-  }
-}
-
-export default ServerDirectory;