@tjamescouch/agentchat 0.22.0 → 0.23.0

package/lib/security.js

@@ -1,183 +0,0 @@
-/**
- * Security utilities for AgentChat
- * Prevents running agents in dangerous directories
- */
-
-import path from 'path';
-import os from 'os';
-
-// Directories that are absolutely forbidden (system roots)
-const FORBIDDEN_DIRECTORIES = new Set([
-  '/',
-  '/root',
-  '/home',
-  '/Users',
-  '/var',
-  '/etc',
-  '/usr',
-  '/bin',
-  '/sbin',
-  '/lib',
-  '/opt',
-  '/tmp',
-  '/System',
-  '/Applications',
-  '/Library',
-  '/private',
-  '/private/var',
-  '/private/tmp',
-  'C:\\',
-  'C:\\Windows',
-  'C:\\Program Files',
-  'C:\\Program Files (x86)',
-  'C:\\Users',
-]);
-
-// Minimum depth from root required for a "project" directory
-// e.g., /Users/name/projects/myproject = depth 4 (minimum required)
-const MIN_SAFE_DEPTH = 3;
-
-/**
- * Get the depth of a path from root
- * @param {string} dirPath - Directory path to check
- * @returns {number} - Number of directory levels from root
- */
-function getPathDepth(dirPath) {
-  const normalized = path.normalize(dirPath);
-  const parts = normalized.split(path.sep).filter(p => p && p !== '.');
-  return parts.length;
-}
-
-/**
- * Check if directory is a user's home directory
- * @param {string} dirPath - Directory path to check
- * @returns {boolean}
- */
-function isHomeDirectory(dirPath) {
-  const normalized = path.normalize(dirPath);
-  const homeDir = os.homedir();
-
-  // Check exact match with home directory
-  if (normalized === homeDir || normalized === homeDir + path.sep) {
-    return true;
-  }
-
-  // Check common home directory patterns
-  const homePatterns = [
-    /^\/Users\/[^/]+$/,           // macOS: /Users/username
-    /^\/home\/[^/]+$/,            // Linux: /home/username
-    /^C:\\Users\\[^\\]+$/i,       // Windows: C:\Users\username
-  ];
-
-  return homePatterns.some(pattern => pattern.test(normalized));
-}
-
-/**
- * Check if a directory is safe for running agentchat
- * @param {string} dirPath - Directory path to check (defaults to cwd)
- * @returns {{safe: boolean, error?: string, warning?: string, level: 'error'|'warning'|'ok'}}
- */
-export function checkDirectorySafety(dirPath = process.cwd()) {
-  const normalized = path.normalize(path.resolve(dirPath));
-
-  // Check forbidden directories
-  if (FORBIDDEN_DIRECTORIES.has(normalized)) {
-    return {
-      safe: false,
-      level: 'error',
-      error: `Cannot run agentchat in system directory: ${normalized}\n` +
-             `Please run from a project directory instead.`
-    };
-  }
-
-  // Check if it's a home directory BEFORE depth check
-  // Home directories are allowed but warn (they're at depth 2 which would fail depth check)
-  if (isHomeDirectory(normalized)) {
-    return {
-      safe: true,
-      level: 'warning',
-      warning: `Running agentchat in home directory: ${normalized}\n` +
-               `Consider running from a specific project directory instead.`
-    };
-  }
-
-  // Check path depth (too shallow = too close to root)
-  const depth = getPathDepth(normalized);
-  if (depth < MIN_SAFE_DEPTH) {
-    return {
-      safe: false,
-      level: 'error',
-      error: `Cannot run agentchat in root-level directory: ${normalized}\n` +
-             `This directory is too close to the filesystem root.\n` +
-             `Please run from a project directory (at least ${MIN_SAFE_DEPTH} levels deep).`
-    };
-  }
-
-  // All checks passed
-  return {
-    safe: true,
-    level: 'ok'
-  };
-}
-
-/**
- * Enforce directory safety check - throws if unsafe
- * @param {string} dirPath - Directory path to check (defaults to cwd)
- * @param {object} options - Options
- * @param {boolean} options.allowWarnings - If true, don't throw on warnings (default: true)
- * @param {boolean} options.silent - If true, don't print warnings (default: false)
- * @throws {Error} If directory is not safe
- */
-export function enforceDirectorySafety(dirPath = process.cwd(), options = {}) {
-  const { allowWarnings = true, silent = false } = options;
-
-  const result = checkDirectorySafety(dirPath);
-
-  if (result.level === 'error') {
-    throw new Error(result.error);
-  }
-
-  if (result.level === 'warning') {
-    if (!silent) {
-      console.error(`\n⚠️  WARNING: ${result.warning}\n`);
-    }
-    if (!allowWarnings) {
-      throw new Error(result.warning);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Check if running in a project directory (has common project indicators)
- * @param {string} dirPath - Directory path to check
- * @returns {boolean}
- */
-export function looksLikeProjectDirectory(dirPath = process.cwd()) {
-  const projectIndicators = [
-    'package.json',
-    'Cargo.toml',
-    'go.mod',
-    'pyproject.toml',
-    'setup.py',
-    'requirements.txt',
-    'Gemfile',
-    'pom.xml',
-    'build.gradle',
-    'Makefile',
-    'CMakeLists.txt',
-    '.git',
-    '.gitignore',
-    'README.md',
-    'README',
-  ];
-
-  // This is a heuristic check - doesn't actually verify files exist
-  // Just checks if the path looks reasonable
-  const normalized = path.normalize(path.resolve(dirPath));
-  const depth = getPathDepth(normalized);
-
-  // If it's deep enough and not a system directory, it probably looks like a project
-  return depth >= MIN_SAFE_DEPTH && !FORBIDDEN_DIRECTORIES.has(normalized);
-}

package/lib/server/handlers/identity.js

@@ -1,242 +0,0 @@
-/**
- * Identity Handlers
- * Handles identify, verification request/response
- */
-
-import crypto from 'crypto';
-import {
-  ServerMessageType,
-  ErrorCode,
-  createMessage,
-  createError,
-  generateAgentId,
-  generateVerifyId,
-  pubkeyToAgentId,
-} from '../../protocol.js';
-
-/**
- * Handle IDENTIFY command
- */
-export function handleIdentify(server, ws, msg) {
-  // Check if already identified
-  if (server.agents.has(ws)) {
-    server._send(ws, createError(ErrorCode.INVALID_MSG, 'Already identified'));
-    return;
-  }
-
-  let id;
-
-  // Use pubkey-derived stable ID if pubkey provided
-  if (msg.pubkey) {
-    // Check if this pubkey has connected before
-    const existingId = server.pubkeyToId.get(msg.pubkey);
-    if (existingId) {
-      // Returning agent - use their stable ID
-      id = existingId;
-    } else {
-      // New agent with pubkey - generate stable ID from pubkey
-      id = pubkeyToAgentId(msg.pubkey);
-      server.pubkeyToId.set(msg.pubkey, id);
-    }
-
-    // Check if this ID is currently in use by another connection
-    if (server.agentById.has(id)) {
-      // Kick the old connection instead of rejecting the new one
-      const oldWs = server.agentById.get(id);
-      server._log('identity-takeover', { id, reason: 'New connection with same identity' });
-      server._send(oldWs, createError(ErrorCode.INVALID_MSG, 'Disconnected: Another connection claimed this identity'));
-      server._handleDisconnect(oldWs);
-      oldWs.close(1000, 'Identity claimed by new connection');
-    }
-  } else {
-    // Ephemeral agent - generate random ID
-    id = generateAgentId();
-  }
-
-  const agent = {
-    id,
-    name: msg.name,
-    pubkey: msg.pubkey || null,
-    channels: new Set(),
-    connectedAt: Date.now(),
-    presence: 'online',
-    statusText: null
-  };
-
-  server.agents.set(ws, agent);
-  server.agentById.set(id, ws);
-
-  // Determine if this is a new or returning identity
-  const isReturning = msg.pubkey && server.pubkeyToId.has(msg.pubkey);
-  const isEphemeral = !msg.pubkey;
-
-  server._log('identify', {
-    id,
-    name: msg.name,
-    hasPubkey: !!msg.pubkey,
-    returning: isReturning,
-    ephemeral: isEphemeral,
-    ip: ws._realIp,
-    user_agent: ws._userAgent
-  });
-
-  server._send(ws, createMessage(ServerMessageType.WELCOME, {
-    agent_id: `@${id}`,
-    server: server.serverName
-  }));
-}
-
-/**
- * Handle VERIFY_REQUEST command
- */
-export function handleVerifyRequest(server, ws, msg) {
-  const agent = server.agents.get(ws);
-  if (!agent) {
-    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
-    return;
-  }
-
-  // Find target agent
-  const targetId = msg.target.slice(1);
-  const targetWs = server.agentById.get(targetId);
-
-  if (!targetWs) {
-    server._send(ws, createError(ErrorCode.AGENT_NOT_FOUND, `Agent ${msg.target} not found`));
-    return;
-  }
-
-  const targetAgent = server.agents.get(targetWs);
-
-  // Target must have a pubkey for verification
-  if (!targetAgent.pubkey) {
-    server._send(ws, createError(ErrorCode.NO_PUBKEY, `Agent ${msg.target} has no persistent identity`));
-    return;
-  }
-
-  // Create verification request
-  const requestId = generateVerifyId();
-  const expires = Date.now() + server.verificationTimeoutMs;
-
-  server.pendingVerifications.set(requestId, {
-    from: `@${agent.id}`,
-    fromWs: ws,
-    target: msg.target,
-    targetPubkey: targetAgent.pubkey,
-    nonce: msg.nonce,
-    expires
-  });
-
-  // Set timeout to clean up expired requests
-  setTimeout(() => {
-    const request = server.pendingVerifications.get(requestId);
-    if (request) {
-      server.pendingVerifications.delete(requestId);
-      // Notify requester of timeout
-      if (request.fromWs.readyState === 1) {
-        server._send(request.fromWs, createMessage(ServerMessageType.VERIFY_FAILED, {
-          request_id: requestId,
-          target: request.target,
-          reason: 'Verification timed out'
-        }));
-      }
-    }
-  }, server.verificationTimeoutMs);
-
-  server._log('verify_request', { id: requestId, from: agent.id, target: targetId });
-
-  // Forward to target agent
-  server._send(targetWs, createMessage(ServerMessageType.VERIFY_REQUEST, {
-    request_id: requestId,
-    from: `@${agent.id}`,
-    nonce: msg.nonce
-  }));
-
-  // Acknowledge to requester
-  server._send(ws, createMessage(ServerMessageType.VERIFY_REQUEST, {
-    request_id: requestId,
-    target: msg.target,
-    status: 'pending'
-  }));
-}
-
-/**
- * Handle VERIFY_RESPONSE command
- */
-export function handleVerifyResponse(server, ws, msg) {
-  const agent = server.agents.get(ws);
-  if (!agent) {
-    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
-    return;
-  }
-
-  // Must have identity to respond to verification
-  if (!agent.pubkey) {
-    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Responding to verification requires persistent identity'));
-    return;
-  }
-
-  // Find the pending verification
-  const request = server.pendingVerifications.get(msg.request_id);
-  if (!request) {
-    server._send(ws, createError(ErrorCode.VERIFICATION_EXPIRED, 'Verification request not found or expired'));
-    return;
-  }
-
-  // Verify the responder is the target
-  if (request.target !== `@${agent.id}`) {
-    server._send(ws, createError(ErrorCode.INVALID_MSG, 'You are not the target of this verification'));
-    return;
-  }
-
-  // Verify the nonce matches
-  if (msg.nonce !== request.nonce) {
-    server._send(ws, createError(ErrorCode.INVALID_MSG, 'Nonce mismatch'));
-    return;
-  }
-
-  // Verify the signature
-  let verified = false;
-  try {
-    const keyObj = crypto.createPublicKey(request.targetPubkey);
-    verified = crypto.verify(
-      null,
-      Buffer.from(msg.nonce),
-      keyObj,
-      Buffer.from(msg.sig, 'base64')
-    );
-  } catch (err) {
-    server._log('verify_error', { request_id: msg.request_id, error: err.message });
-  }
-
-  // Clean up the pending request
-  server.pendingVerifications.delete(msg.request_id);
-
-  server._log('verify_response', {
-    request_id: msg.request_id,
-    from: agent.id,
-    verified
-  });
-
-  // Notify the original requester
-  if (request.fromWs.readyState === 1) {
-    if (verified) {
-      server._send(request.fromWs, createMessage(ServerMessageType.VERIFY_SUCCESS, {
-        request_id: msg.request_id,
-        agent: request.target,
-        pubkey: request.targetPubkey
-      }));
-    } else {
-      server._send(request.fromWs, createMessage(ServerMessageType.VERIFY_FAILED, {
-        request_id: msg.request_id,
-        target: request.target,
-        reason: 'Signature verification failed'
-      }));
-    }
-  }
-
-  // Notify the responder
-  server._send(ws, createMessage(verified ? ServerMessageType.VERIFY_SUCCESS : ServerMessageType.VERIFY_FAILED, {
-    request_id: msg.request_id,
-    verified
-  }));
-}

package/lib/server/handlers/index.js

@@ -1,42 +0,0 @@
-/**
- * Server Handlers Index
- * Exports all handler functions
- */
-
-// Message handlers
-export {
-  handleMsg,
-  handleJoin,
-  handleLeave,
-  handleListChannels,
-  handleListAgents,
-  handleCreateChannel,
-  handleInvite,
-} from './message.js';
-
-// Proposal handlers
-export {
-  handleProposal,
-  handleAccept,
-  handleReject,
-  handleComplete,
-  handleDispute,
-} from './proposal.js';
-
-// Identity handlers
-export {
-  handleIdentify,
-  handleVerifyRequest,
-  handleVerifyResponse,
-} from './identity.js';
-
-// Skills handlers
-export {
-  handleRegisterSkills,
-  handleSearchSkills,
-} from './skills.js';
-
-// Presence handlers
-export {
-  handleSetPresence,
-} from './presence.js';