@tjamescouch/agentchat 0.1.0

package/lib/deploy/config.js

@@ -0,0 +1,128 @@
+/**
+ * AgentChat Deploy Configuration
+ * Parser for deploy.yaml configuration files
+ */
+
+import fs from 'fs/promises';
+import yaml from 'js-yaml';
+
+/**
+ * Default configuration values
+ */
+export const DEFAULT_CONFIG = {
+  provider: 'docker',
+  port: 6667,
+  host: '0.0.0.0',
+  name: 'agentchat',
+  logMessages: false,
+  volumes: false,
+  healthCheck: true,
+  tls: null,
+  network: null
+};
+
+/**
+ * Load and parse deploy.yaml configuration
+ * @param {string} configPath - Path to configuration file
+ * @returns {Promise<object>} Validated configuration object
+ */
+export async function loadConfig(configPath) {
+  const content = await fs.readFile(configPath, 'utf-8');
+  const parsed = yaml.load(content);
+  return validateConfig(parsed);
+}
+
+/**
+ * Validate configuration object
+ * @param {object} config - Raw configuration object
+ * @returns {object} Validated and merged configuration
+ * @throws {Error} If configuration is invalid
+ */
+export function validateConfig(config) {
+  if (!config || typeof config !== 'object') {
+    throw new Error('Configuration must be an object');
+  }
+
+  const result = { ...DEFAULT_CONFIG, ...config };
+
+  // Validate provider
+  if (!['docker', 'akash'].includes(result.provider)) {
+    throw new Error(`Invalid provider: ${result.provider}. Must be 'docker' or 'akash'`);
+  }
+
+  // Validate port
+  const port = parseInt(result.port);
+  if (isNaN(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${result.port}. Must be between 1 and 65535`);
+  }
+  result.port = port;
+
+  // Validate host
+  if (typeof result.host !== 'string' || result.host.length === 0) {
+    throw new Error('Invalid host: must be a non-empty string');
+  }
+
+  // Validate name
+  if (typeof result.name !== 'string' || result.name.length === 0) {
+    throw new Error('Invalid name: must be a non-empty string');
+  }
+  // Docker container name must be alphanumeric with dashes/underscores
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(result.name)) {
+    throw new Error('Invalid name: must start with alphanumeric and contain only alphanumeric, dash, underscore');
+  }
+
+  // Validate TLS config
+  if (result.tls) {
+    if (typeof result.tls !== 'object') {
+      throw new Error('TLS config must be an object with cert and key paths');
+    }
+    if (!result.tls.cert || typeof result.tls.cert !== 'string') {
+      throw new Error('TLS config must include cert path');
+    }
+    if (!result.tls.key || typeof result.tls.key !== 'string') {
+      throw new Error('TLS config must include key path');
+    }
+  }
+
+  // Validate network
+  if (result.network !== null && typeof result.network !== 'string') {
+    throw new Error('Network must be a string or null');
+  }
+
+  // Ensure booleans
+  result.logMessages = Boolean(result.logMessages);
+  result.volumes = Boolean(result.volumes);
+  result.healthCheck = result.healthCheck !== false;
+
+  return result;
+}
+
+/**
+ * Generate example deploy.yaml content
+ * @returns {string} Example YAML configuration
+ */
+export function generateExampleConfig() {
+  return `# AgentChat deployment configuration
+provider: docker
+port: 6667
+host: 0.0.0.0
+name: agentchat
+
+# Enable data persistence volumes
+volumes: false
+
+# Health check (default: true)
+healthCheck: true
+
+# Logging (default: false)
+logMessages: false
+
+# TLS configuration (optional)
+# tls:
+#   cert: ./certs/cert.pem
+#   key: ./certs/key.pem
+
+# Docker network (optional)
+# network: agentchat-net
+`;
+}

package/lib/deploy/index.js

@@ -0,0 +1,149 @@
+/**
+ * AgentChat Deployment Module
+ * Generate deployment files for agentchat servers
+ */
+
+import yaml from 'js-yaml';
+
+// Re-export Akash module
+export {
+  AkashWallet,
+  AkashClient,
+  generateSDL as generateAkashSDL,
+  generateWallet,
+  checkBalance,
+  createDeployment,
+  listDeployments,
+  closeDeployment,
+  queryBids,
+  acceptBid,
+  getDeploymentStatus,
+  NETWORKS as AKASH_NETWORKS,
+  WALLET_PATH as AKASH_WALLET_PATH
+} from './akash.js';
+
+/**
+ * Generate docker-compose.yml for self-hosting
+ * @param {object} options - Configuration options
+ * @returns {string} docker-compose.yml content
+ */
+export async function deployToDocker(options = {}) {
+  const config = {
+    port: options.port || 6667,
+    host: options.host || '0.0.0.0',
+    name: options.name || 'agentchat',
+    logMessages: options.logMessages || false,
+    volumes: options.volumes || false,
+    tls: options.tls || null,
+    network: options.network || null,
+    healthCheck: options.healthCheck !== false
+  };
+
+  // Build compose object
+  const compose = {
+    version: '3.8',
+    services: {
+      agentchat: {
+        image: 'agentchat:latest',
+        build: '.',
+        container_name: config.name,
+        ports: [`${config.port}:6667`],
+        environment: [
+          `PORT=6667`,
+          `HOST=${config.host}`,
+          `SERVER_NAME=${config.name}`,
+          `LOG_MESSAGES=${config.logMessages}`
+        ],
+        restart: 'unless-stopped'
+      }
+    }
+  };
+
+  const service = compose.services.agentchat;
+
+  // Add health check
+  if (config.healthCheck) {
+    service.healthcheck = {
+      test: ['CMD', 'node', '-e',
+        "const ws = new (require('ws'))('ws://localhost:6667'); ws.on('open', () => process.exit(0)); ws.on('error', () => process.exit(1)); setTimeout(() => process.exit(1), 5000);"
+      ],
+      interval: '30s',
+      timeout: '10s',
+      retries: 3,
+      start_period: '10s'
+    };
+  }
+
+  // Add volumes if enabled
+  if (config.volumes) {
+    service.volumes = service.volumes || [];
+    service.volumes.push('agentchat-data:/app/data');
+    compose.volumes = { 'agentchat-data': {} };
+  }
+
+  // Add TLS certificate mounts
+  if (config.tls) {
+    service.volumes = service.volumes || [];
+    service.volumes.push(`${config.tls.cert}:/app/certs/cert.pem:ro`);
+    service.volumes.push(`${config.tls.key}:/app/certs/key.pem:ro`);
+    service.environment.push('TLS_CERT=/app/certs/cert.pem');
+    service.environment.push('TLS_KEY=/app/certs/key.pem');
+  }
+
+  // Add network configuration
+  if (config.network) {
+    service.networks = [config.network];
+    compose.networks = {
+      [config.network]: {
+        driver: 'bridge'
+      }
+    };
+  }
+
+  return yaml.dump(compose, {
+    lineWidth: -1,
+    noRefs: true,
+    quotingType: '"'
+  });
+}
+
+/**
+ * Generate Dockerfile for agentchat server
+ * @param {object} options - Configuration options
+ * @returns {string} Dockerfile content
+ */
+export async function generateDockerfile(options = {}) {
+  const tls = options.tls || false;
+
+  return `FROM node:18-alpine
+
+WORKDIR /app
+
+# Install dependencies first for better layer caching
+COPY package*.json ./
+RUN npm ci --production
+
+# Copy application code
+COPY . .
+
+# Create data directory for persistence
+RUN mkdir -p /app/data
+
+# Default environment variables
+ENV PORT=6667
+ENV HOST=0.0.0.0
+ENV SERVER_NAME=agentchat
+ENV LOG_MESSAGES=false
+${tls ? `ENV TLS_CERT=""
+ENV TLS_KEY=""
+` : ''}
+EXPOSE 6667
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \\
+  CMD node -e "const ws = new (require('ws'))('ws://localhost:' + (process.env.PORT || 6667)); ws.on('open', () => process.exit(0)); ws.on('error', () => process.exit(1)); setTimeout(() => process.exit(1), 5000);"
+
+# Start server
+CMD ["node", "bin/agentchat.js", "serve"]
+`;
+}

package/lib/identity.js

@@ -0,0 +1,166 @@
+/**
+ * AgentChat Identity Module
+ * Ed25519 key generation, storage, and signing
+ */
+
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+// Default identity file location
+export const DEFAULT_IDENTITY_PATH = path.join(os.homedir(), '.agentchat', 'identity.json');
+
+/**
+ * Generate stable agent ID from pubkey
+ * Returns first 8 chars of SHA256 hash (hex)
+ */
+export function pubkeyToAgentId(pubkey) {
+  const hash = crypto.createHash('sha256').update(pubkey).digest('hex');
+  return hash.substring(0, 8);
+}
+
+/**
+ * Validate Ed25519 public key in PEM format
+ */
+export function isValidPubkey(pubkey) {
+  if (!pubkey || typeof pubkey !== 'string') return false;
+
+  try {
+    const keyObj = crypto.createPublicKey(pubkey);
+    return keyObj.asymmetricKeyType === 'ed25519';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * AgentChat Identity
+ * Represents an agent's Ed25519 keypair and associated metadata
+ */
+export class Identity {
+  constructor(data) {
+    this.name = data.name;
+    this.pubkey = data.pubkey;      // PEM format
+    this.privkey = data.privkey;    // PEM format (null if loaded from export)
+    this.created = data.created;
+
+    // Lazy-load crypto key objects
+    this._publicKey = null;
+    this._privateKey = null;
+  }
+
+  /**
+   * Generate new Ed25519 keypair
+   */
+  static generate(name) {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+
+    return new Identity({
+      name,
+      pubkey: publicKey.export({ type: 'spki', format: 'pem' }),
+      privkey: privateKey.export({ type: 'pkcs8', format: 'pem' }),
+      created: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Load identity from JSON file
+   */
+  static async load(filePath = DEFAULT_IDENTITY_PATH) {
+    const data = await fs.readFile(filePath, 'utf-8');
+    const parsed = JSON.parse(data);
+    return new Identity(parsed);
+  }
+
+  /**
+   * Save identity to JSON file
+   */
+  async save(filePath = DEFAULT_IDENTITY_PATH) {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+
+    const data = {
+      name: this.name,
+      pubkey: this.pubkey,
+      privkey: this.privkey,
+      created: this.created
+    };
+
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), {
+      mode: 0o600  // Owner read/write only
+    });
+  }
+
+  /**
+   * Check if identity file exists
+   */
+  static async exists(filePath = DEFAULT_IDENTITY_PATH) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get fingerprint (first 16 chars of SHA256 hash of pubkey)
+   */
+  getFingerprint() {
+    const hash = crypto.createHash('sha256').update(this.pubkey).digest('hex');
+    return hash.substring(0, 16);
+  }
+
+  /**
+   * Get stable agent ID (first 8 chars of fingerprint)
+   */
+  getAgentId() {
+    return pubkeyToAgentId(this.pubkey);
+  }
+
+  /**
+   * Sign data with private key
+   * Returns base64-encoded signature
+   */
+  sign(data) {
+    if (!this.privkey) {
+      throw new Error('Private key not available (identity was loaded from export)');
+    }
+
+    if (!this._privateKey) {
+      this._privateKey = crypto.createPrivateKey(this.privkey);
+    }
+
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const signature = crypto.sign(null, buffer, this._privateKey);
+    return signature.toString('base64');
+  }
+
+  /**
+   * Verify a signature
+   * Static method for verifying any message
+   */
+  static verify(data, signature, pubkey) {
+    try {
+      const keyObj = crypto.createPublicKey(pubkey);
+      const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      const sigBuffer = Buffer.from(signature, 'base64');
+      return crypto.verify(null, buffer, keyObj, sigBuffer);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Export for sharing (pubkey only, no private key)
+   */
+  export() {
+    return {
+      name: this.name,
+      pubkey: this.pubkey,
+      created: this.created
+    };
+  }
+}

package/lib/protocol.js

@@ -0,0 +1,236 @@
+/**
+ * AgentChat Protocol
+ * Message types and validation for agent-to-agent communication
+ */
+
+import crypto from 'crypto';
+
+// Client -> Server message types
+export const ClientMessageType = {
+  IDENTIFY: 'IDENTIFY',
+  JOIN: 'JOIN',
+  LEAVE: 'LEAVE',
+  MSG: 'MSG',
+  LIST_CHANNELS: 'LIST_CHANNELS',
+  LIST_AGENTS: 'LIST_AGENTS',
+  CREATE_CHANNEL: 'CREATE_CHANNEL',
+  INVITE: 'INVITE',
+  PING: 'PING'
+};
+
+// Server -> Client message types
+export const ServerMessageType = {
+  WELCOME: 'WELCOME',
+  MSG: 'MSG',
+  JOINED: 'JOINED',
+  LEFT: 'LEFT',
+  AGENT_JOINED: 'AGENT_JOINED',
+  AGENT_LEFT: 'AGENT_LEFT',
+  CHANNELS: 'CHANNELS',
+  AGENTS: 'AGENTS',
+  ERROR: 'ERROR',
+  PONG: 'PONG'
+};
+
+// Error codes
+export const ErrorCode = {
+  AUTH_REQUIRED: 'AUTH_REQUIRED',
+  CHANNEL_NOT_FOUND: 'CHANNEL_NOT_FOUND',
+  NOT_INVITED: 'NOT_INVITED',
+  INVALID_MSG: 'INVALID_MSG',
+  RATE_LIMITED: 'RATE_LIMITED',
+  AGENT_NOT_FOUND: 'AGENT_NOT_FOUND',
+  CHANNEL_EXISTS: 'CHANNEL_EXISTS',
+  INVALID_NAME: 'INVALID_NAME'
+};
+
+/**
+ * Check if a target is a channel (#name) or agent (@name)
+ */
+export function isChannel(target) {
+  return target && target.startsWith('#');
+}
+
+export function isAgent(target) {
+  return target && target.startsWith('@');
+}
+
+/**
+ * Validate agent name
+ * - 1-32 characters
+ * - alphanumeric, dash, underscore
+ * - no spaces
+ */
+export function isValidName(name) {
+  if (!name || typeof name !== 'string') return false;
+  if (name.length < 1 || name.length > 32) return false;
+  return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+
+/**
+ * Validate channel name
+ * - starts with #
+ * - 2-32 characters total
+ * - alphanumeric, dash, underscore after #
+ */
+export function isValidChannel(channel) {
+  if (!channel || typeof channel !== 'string') return false;
+  if (!channel.startsWith('#')) return false;
+  const name = channel.slice(1);
+  if (name.length < 1 || name.length > 31) return false;
+  return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+
+/**
+ * Validate Ed25519 public key in PEM format
+ */
+export function isValidPubkey(pubkey) {
+  if (!pubkey || typeof pubkey !== 'string') return false;
+
+  try {
+    const keyObj = crypto.createPublicKey(pubkey);
+    return keyObj.asymmetricKeyType === 'ed25519';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Generate stable agent ID from pubkey
+ * Returns first 8 chars of SHA256 hash (hex)
+ */
+export function pubkeyToAgentId(pubkey) {
+  const hash = crypto.createHash('sha256').update(pubkey).digest('hex');
+  return hash.substring(0, 8);
+}
+
+/**
+ * Create a message object with timestamp
+ */
+export function createMessage(type, data = {}) {
+  return {
+    type,
+    ts: Date.now(),
+    ...data
+  };
+}
+
+/**
+ * Create an error message
+ */
+export function createError(code, message) {
+  return createMessage(ServerMessageType.ERROR, { code, message });
+}
+
+/**
+ * Validate incoming client message
+ * Returns { valid: true, msg } or { valid: false, error }
+ */
+export function validateClientMessage(raw) {
+  let msg;
+  
+  // Parse JSON
+  try {
+    msg = typeof raw === 'string' ? JSON.parse(raw) : raw;
+  } catch (e) {
+    return { valid: false, error: 'Invalid JSON' };
+  }
+  
+  // Must have type
+  if (!msg.type) {
+    return { valid: false, error: 'Missing message type' };
+  }
+  
+  // Validate by type
+  switch (msg.type) {
+    case ClientMessageType.IDENTIFY:
+      if (!isValidName(msg.name)) {
+        return { valid: false, error: 'Invalid agent name' };
+      }
+      // Validate pubkey if provided
+      if (msg.pubkey !== undefined && msg.pubkey !== null) {
+        if (!isValidPubkey(msg.pubkey)) {
+          return { valid: false, error: 'Invalid public key format (must be Ed25519 PEM)' };
+        }
+      }
+      break;
+      
+    case ClientMessageType.JOIN:
+    case ClientMessageType.LEAVE:
+    case ClientMessageType.LIST_AGENTS:
+      if (!isValidChannel(msg.channel)) {
+        return { valid: false, error: 'Invalid channel name' };
+      }
+      break;
+      
+    case ClientMessageType.MSG:
+      if (!msg.to) {
+        return { valid: false, error: 'Missing target' };
+      }
+      if (!isChannel(msg.to) && !isAgent(msg.to)) {
+        return { valid: false, error: 'Invalid target (must start with # or @)' };
+      }
+      if (typeof msg.content !== 'string') {
+        return { valid: false, error: 'Missing or invalid content' };
+      }
+      if (msg.content.length > 4096) {
+        return { valid: false, error: 'Content too long (max 4096 chars)' };
+      }
+      // Validate signature format if present
+      if (msg.sig !== undefined && typeof msg.sig !== 'string') {
+        return { valid: false, error: 'Invalid signature format' };
+      }
+      break;
+      
+    case ClientMessageType.CREATE_CHANNEL:
+      if (!isValidChannel(msg.channel)) {
+        return { valid: false, error: 'Invalid channel name' };
+      }
+      break;
+      
+    case ClientMessageType.INVITE:
+      if (!isValidChannel(msg.channel)) {
+        return { valid: false, error: 'Invalid channel name' };
+      }
+      if (!msg.agent || !isAgent(msg.agent)) {
+        return { valid: false, error: 'Invalid agent target' };
+      }
+      break;
+      
+    case ClientMessageType.LIST_CHANNELS:
+    case ClientMessageType.PING:
+      // No additional validation needed
+      break;
+      
+    default:
+      return { valid: false, error: `Unknown message type: ${msg.type}` };
+  }
+  
+  return { valid: true, msg };
+}
+
+/**
+ * Generate a unique agent ID
+ */
+export function generateAgentId() {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let id = '';
+  for (let i = 0; i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+
+/**
+ * Serialize message for sending over WebSocket
+ */
+export function serialize(msg) {
+  return JSON.stringify(msg);
+}
+
+/**
+ * Parse message from WebSocket
+ */
+export function parse(data) {
+  return JSON.parse(data);
+}