@tjamescouch/agentchat 0.4.0 → 0.7.0

package/lib/daemon.js

@@ -1,6 +1,7 @@
 /**
  * AgentChat Daemon
  * Persistent connection with file-based inbox/outbox
+ * Supports multiple instances with different identities
  */
 
 import fs from 'fs';
@@ -9,24 +10,43 @@ import path from 'path';
 import os from 'os';
 import { AgentChatClient } from './client.js';
 import { Identity, DEFAULT_IDENTITY_PATH } from './identity.js';
+import { appendReceipt, shouldStoreReceipt, DEFAULT_RECEIPTS_PATH } from './receipts.js';
 
-// Default paths
+// Base directory
 const AGENTCHAT_DIR = path.join(os.homedir(), '.agentchat');
-const INBOX_PATH = path.join(AGENTCHAT_DIR, 'inbox.jsonl');
-const OUTBOX_PATH = path.join(AGENTCHAT_DIR, 'outbox.jsonl');
-const LOG_PATH = path.join(AGENTCHAT_DIR, 'daemon.log');
-const PID_PATH = path.join(AGENTCHAT_DIR, 'daemon.pid');
+const DAEMONS_DIR = path.join(AGENTCHAT_DIR, 'daemons');
 
-const DEFAULT_CHANNELS = ['#general', '#agents', '#skills'];
+// Default instance name
+const DEFAULT_INSTANCE = 'default';
+
+const DEFAULT_CHANNELS = ['#general', '#agents'];
 const MAX_INBOX_LINES = 1000;
 const RECONNECT_DELAY = 5000; // 5 seconds
 const OUTBOX_POLL_INTERVAL = 500; // 500ms
 
+/**
+ * Get paths for a daemon instance
+ */
+export function getDaemonPaths(instanceName = DEFAULT_INSTANCE) {
+  const instanceDir = path.join(DAEMONS_DIR, instanceName);
+  return {
+    dir: instanceDir,
+    inbox: path.join(instanceDir, 'inbox.jsonl'),
+    outbox: path.join(instanceDir, 'outbox.jsonl'),
+    log: path.join(instanceDir, 'daemon.log'),
+    pid: path.join(instanceDir, 'daemon.pid')
+  };
+}
+
 export class AgentChatDaemon {
   constructor(options = {}) {
     this.server = options.server;
     this.identityPath = options.identity || DEFAULT_IDENTITY_PATH;
     this.channels = options.channels || DEFAULT_CHANNELS;
+    this.instanceName = options.name || DEFAULT_INSTANCE;
+
+    // Get instance-specific paths
+    this.paths = getDaemonPaths(this.instanceName);
 
     this.client = null;
     this.running = false;
@@ -34,13 +54,10 @@ export class AgentChatDaemon {
     this.outboxWatcher = null;
     this.outboxPollInterval = null;
     this.lastOutboxSize = 0;
-
-    // Ensure directory exists
-    this._ensureDir();
   }
 
   async _ensureDir() {
-    await fsp.mkdir(AGENTCHAT_DIR, { recursive: true });
+    await fsp.mkdir(this.paths.dir, { recursive: true });
   }
 
   _log(level, message) {
@@ -48,7 +65,11 @@ export class AgentChatDaemon {
     const line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
 
     // Append to log file
-    fs.appendFileSync(LOG_PATH, line);
+    try {
+      fs.appendFileSync(this.paths.log, line);
+    } catch {
+      // Directory might not exist yet
+    }
 
     // Also output to console if not background
     if (level === 'error') {
@@ -62,7 +83,7 @@ export class AgentChatDaemon {
     const line = JSON.stringify(msg) + '\n';
 
     // Append to inbox
-    await fsp.appendFile(INBOX_PATH, line);
+    await fsp.appendFile(this.paths.inbox, line);
 
     // Check if we need to truncate (ring buffer)
     await this._truncateInbox();
@@ -70,13 +91,13 @@ export class AgentChatDaemon {
 
   async _truncateInbox() {
     try {
-      const content = await fsp.readFile(INBOX_PATH, 'utf-8');
+      const content = await fsp.readFile(this.paths.inbox, 'utf-8');
       const lines = content.trim().split('\n');
 
       if (lines.length > MAX_INBOX_LINES) {
         // Keep only the last MAX_INBOX_LINES
         const newLines = lines.slice(-MAX_INBOX_LINES);
-        await fsp.writeFile(INBOX_PATH, newLines.join('\n') + '\n');
+        await fsp.writeFile(this.paths.inbox, newLines.join('\n') + '\n');
         this._log('info', `Truncated inbox to ${MAX_INBOX_LINES} lines`);
       }
     } catch (err) {
@@ -86,16 +107,34 @@ export class AgentChatDaemon {
     }
   }
 
+  async _saveReceiptIfParty(completeMsg) {
+    try {
+      // Get our agent ID
+      const ourAgentId = this.client?.agentId;
+      if (!ourAgentId) {
+        return;
+      }
+
+      // Check if we should store this receipt
+      if (shouldStoreReceipt(completeMsg, ourAgentId)) {
+        await appendReceipt(completeMsg, DEFAULT_RECEIPTS_PATH);
+        this._log('info', `Saved receipt for proposal ${completeMsg.proposal_id}`);
+      }
+    } catch (err) {
+      this._log('error', `Failed to save receipt: ${err.message}`);
+    }
+  }
+
   async _processOutbox() {
     try {
       // Check if outbox exists
       try {
-        await fsp.access(OUTBOX_PATH);
+        await fsp.access(this.paths.outbox);
       } catch {
         return; // No outbox file
       }
 
-      const content = await fsp.readFile(OUTBOX_PATH, 'utf-8');
+      const content = await fsp.readFile(this.paths.outbox, 'utf-8');
       if (!content.trim()) return;
 
       const lines = content.trim().split('\n');
@@ -124,7 +163,7 @@ export class AgentChatDaemon {
       }
 
       // Truncate outbox after processing
-      await fsp.writeFile(OUTBOX_PATH, '');
+      await fsp.writeFile(this.paths.outbox, '');
 
     } catch (err) {
       if (err.code !== 'ENOENT') {
@@ -144,11 +183,11 @@ export class AgentChatDaemon {
     // Also try fs.watch for immediate response (may not work on all platforms)
     try {
       // Ensure outbox file exists
-      if (!fs.existsSync(OUTBOX_PATH)) {
-        fs.writeFileSync(OUTBOX_PATH, '');
+      if (!fs.existsSync(this.paths.outbox)) {
+        fs.writeFileSync(this.paths.outbox, '');
       }
 
-      this.outboxWatcher = fs.watch(OUTBOX_PATH, (eventType) => {
+      this.outboxWatcher = fs.watch(this.paths.outbox, (eventType) => {
         if (eventType === 'change' && this.client && this.client.connected) {
           this._processOutbox();
         }
@@ -204,6 +243,8 @@ export class AgentChatDaemon {
 
     this.client.on('complete', async (msg) => {
       await this._appendToInbox(msg);
+      // Save receipt if we're a party to this completion
+      await this._saveReceiptIfParty(msg);
     });
 
     this.client.on('dispute', async (msg) => {
@@ -262,15 +303,18 @@ export class AgentChatDaemon {
   async start() {
     this.running = true;
 
+    // Ensure instance directory exists
+    await this._ensureDir();
+
     // Write PID file
-    await fsp.writeFile(PID_PATH, process.pid.toString());
-    this._log('info', `Daemon starting (PID: ${process.pid})`);
+    await fsp.writeFile(this.paths.pid, process.pid.toString());
+    this._log('info', `Daemon starting (PID: ${process.pid}, instance: ${this.instanceName})`);
 
     // Initialize inbox if it doesn't exist
     try {
-      await fsp.access(INBOX_PATH);
+      await fsp.access(this.paths.inbox);
     } catch {
-      await fsp.writeFile(INBOX_PATH, '');
+      await fsp.writeFile(this.paths.inbox, '');
     }
 
     // Connect to server
@@ -287,9 +331,9 @@ export class AgentChatDaemon {
     process.on('SIGTERM', () => this.stop());
 
     this._log('info', 'Daemon started');
-    this._log('info', `Inbox: ${INBOX_PATH}`);
-    this._log('info', `Outbox: ${OUTBOX_PATH}`);
-    this._log('info', `Log: ${LOG_PATH}`);
+    this._log('info', `Inbox: ${this.paths.inbox}`);
+    this._log('info', `Outbox: ${this.paths.outbox}`);
+    this._log('info', `Log: ${this.paths.log}`);
   }
 
   async stop() {
@@ -304,7 +348,7 @@ export class AgentChatDaemon {
 
     // Remove PID file
     try {
-      await fsp.unlink(PID_PATH);
+      await fsp.unlink(this.paths.pid);
     } catch {
       // Ignore if already gone
     }
@@ -315,36 +359,40 @@ export class AgentChatDaemon {
 }
 
 /**
- * Check if daemon is running
+ * Check if daemon instance is running
  */
-export async function isDaemonRunning() {
+export async function isDaemonRunning(instanceName = DEFAULT_INSTANCE) {
+  const paths = getDaemonPaths(instanceName);
+
   try {
-    const pid = await fsp.readFile(PID_PATH, 'utf-8');
+    const pid = await fsp.readFile(paths.pid, 'utf-8');
     const pidNum = parseInt(pid.trim());
 
     // Check if process is running
     try {
       process.kill(pidNum, 0);
-      return { running: true, pid: pidNum };
+      return { running: true, pid: pidNum, instance: instanceName };
     } catch {
       // Process not running, clean up stale PID file
-      await fsp.unlink(PID_PATH);
-      return { running: false };
+      await fsp.unlink(paths.pid);
+      return { running: false, instance: instanceName };
     }
   } catch {
-    return { running: false };
+    return { running: false, instance: instanceName };
   }
 }
 
 /**
- * Stop the daemon
+ * Stop a daemon instance
  */
-export async function stopDaemon() {
-  const status = await isDaemonRunning();
+export async function stopDaemon(instanceName = DEFAULT_INSTANCE) {
+  const status = await isDaemonRunning(instanceName);
   if (!status.running) {
-    return { stopped: false, reason: 'Daemon not running' };
+    return { stopped: false, reason: 'Daemon not running', instance: instanceName };
   }
 
+  const paths = getDaemonPaths(instanceName);
+
   try {
     process.kill(status.pid, 'SIGTERM');
 
@@ -362,26 +410,28 @@ export async function stopDaemon() {
 
     // Clean up PID file
     try {
-      await fsp.unlink(PID_PATH);
+      await fsp.unlink(paths.pid);
     } catch {
       // Ignore
     }
 
-    return { stopped: true, pid: status.pid };
+    return { stopped: true, pid: status.pid, instance: instanceName };
   } catch (err) {
-    return { stopped: false, reason: err.message };
+    return { stopped: false, reason: err.message, instance: instanceName };
   }
 }
 
 /**
- * Get daemon status
+ * Get daemon instance status
  */
-export async function getDaemonStatus() {
-  const status = await isDaemonRunning();
+export async function getDaemonStatus(instanceName = DEFAULT_INSTANCE) {
+  const status = await isDaemonRunning(instanceName);
+  const paths = getDaemonPaths(instanceName);
 
   if (!status.running) {
     return {
-      running: false
+      running: false,
+      instance: instanceName
     };
   }
 
@@ -390,7 +440,7 @@ export async function getDaemonStatus() {
   let lastMessage = null;
 
   try {
-    const content = await fsp.readFile(INBOX_PATH, 'utf-8');
+    const content = await fsp.readFile(paths.inbox, 'utf-8');
     const lines = content.trim().split('\n').filter(l => l);
     inboxLines = lines.length;
 
@@ -407,14 +457,62 @@ export async function getDaemonStatus() {
 
   return {
     running: true,
+    instance: instanceName,
     pid: status.pid,
-    inboxPath: INBOX_PATH,
-    outboxPath: OUTBOX_PATH,
-    logPath: LOG_PATH,
+    inboxPath: paths.inbox,
+    outboxPath: paths.outbox,
+    logPath: paths.log,
     inboxLines,
     lastMessage
   };
 }
 
-// Export paths for CLI
-export { INBOX_PATH, OUTBOX_PATH, LOG_PATH, PID_PATH, DEFAULT_CHANNELS };
+/**
+ * List all daemon instances
+ */
+export async function listDaemons() {
+  const instances = [];
+
+  try {
+    const entries = await fsp.readdir(DAEMONS_DIR, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const status = await isDaemonRunning(entry.name);
+        instances.push({
+          name: entry.name,
+          running: status.running,
+          pid: status.pid || null
+        });
+      }
+    }
+  } catch {
+    // No daemons directory
+  }
+
+  return instances;
+}
+
+/**
+ * Stop all running daemons
+ */
+export async function stopAllDaemons() {
+  const instances = await listDaemons();
+  const results = [];
+
+  for (const instance of instances) {
+    if (instance.running) {
+      const result = await stopDaemon(instance.name);
+      results.push(result);
+    }
+  }
+
+  return results;
+}
+
+// Export for CLI (backwards compatibility with default paths)
+export const INBOX_PATH = getDaemonPaths(DEFAULT_INSTANCE).inbox;
+export const OUTBOX_PATH = getDaemonPaths(DEFAULT_INSTANCE).outbox;
+export const LOG_PATH = getDaemonPaths(DEFAULT_INSTANCE).log;
+export const PID_PATH = getDaemonPaths(DEFAULT_INSTANCE).pid;
+export { DEFAULT_CHANNELS, DEFAULT_INSTANCE };

package/lib/receipts.js

@@ -0,0 +1,294 @@
+/**
+ * AgentChat Receipts Module
+ * Stores and manages COMPLETE receipts for portable reputation
+ *
+ * Receipts are proof of completed work between agents.
+ * They can be exported for reputation aggregation.
+ */
+
+import fs from 'fs';
+import fsp from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { getDefaultStore } from './reputation.js';
+
+// Default receipts file location
+const AGENTCHAT_DIR = path.join(os.homedir(), '.agentchat');
+export const DEFAULT_RECEIPTS_PATH = path.join(AGENTCHAT_DIR, 'receipts.jsonl');
+
+/**
+ * Append a receipt to the receipts file
+ * @param {object} receipt - The COMPLETE message/receipt to store
+ * @param {string} receiptsPath - Path to receipts file
+ * @param {object} options - Options
+ * @param {boolean} options.updateRatings - Whether to update ELO ratings (default: true)
+ */
+export async function appendReceipt(receipt, receiptsPath = DEFAULT_RECEIPTS_PATH, options = {}) {
+  const { updateRatings = true } = options;
+
+  // Ensure directory exists
+  await fsp.mkdir(path.dirname(receiptsPath), { recursive: true });
+
+  // Add storage timestamp
+  const storedReceipt = {
+    ...receipt,
+    stored_at: Date.now()
+  };
+
+  const line = JSON.stringify(storedReceipt) + '\n';
+  await fsp.appendFile(receiptsPath, line);
+
+  // Update ELO ratings if enabled
+  if (updateRatings) {
+    try {
+      const store = getDefaultStore();
+      const ratingChanges = await store.updateRatings(storedReceipt);
+      if (ratingChanges) {
+        storedReceipt._ratingChanges = ratingChanges;
+      }
+    } catch (err) {
+      // Log but don't fail receipt storage if rating update fails
+      console.error(`Warning: Failed to update ratings: ${err.message}`);
+    }
+  }
+
+  return storedReceipt;
+}
+
+/**
+ * Read all receipts from the receipts file
+ * @param {string} receiptsPath - Path to receipts file
+ * @returns {Array} Array of receipt objects
+ */
+export async function readReceipts(receiptsPath = DEFAULT_RECEIPTS_PATH) {
+  try {
+    const content = await fsp.readFile(receiptsPath, 'utf-8');
+    const lines = content.trim().split('\n').filter(l => l.trim());
+
+    return lines.map(line => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return []; // No receipts file yet
+    }
+    throw err;
+  }
+}
+
+/**
+ * Filter receipts by agent ID (where agent is a party)
+ * @param {Array} receipts - Array of receipts
+ * @param {string} agentId - Agent ID to filter by
+ * @returns {Array} Filtered receipts
+ */
+export function filterByAgent(receipts, agentId) {
+  const normalizedId = agentId.startsWith('@') ? agentId : `@${agentId}`;
+  return receipts.filter(r =>
+    r.from === normalizedId ||
+    r.to === normalizedId ||
+    r.completed_by === normalizedId ||
+    // Also check proposal parties if available
+    r.proposal?.from === normalizedId ||
+    r.proposal?.to === normalizedId
+  );
+}
+
+/**
+ * Get unique counterparties from receipts
+ * @param {Array} receipts - Array of receipts
+ * @param {string} agentId - Our agent ID
+ * @returns {Array} Array of unique counterparty IDs
+ */
+export function getCounterparties(receipts, agentId) {
+  const normalizedId = agentId.startsWith('@') ? agentId : `@${agentId}`;
+  const counterparties = new Set();
+
+  for (const r of receipts) {
+    // Check from/to fields
+    if (r.from && r.from !== normalizedId) counterparties.add(r.from);
+    if (r.to && r.to !== normalizedId) counterparties.add(r.to);
+
+    // Check proposal parties
+    if (r.proposal?.from && r.proposal.from !== normalizedId) {
+      counterparties.add(r.proposal.from);
+    }
+    if (r.proposal?.to && r.proposal.to !== normalizedId) {
+      counterparties.add(r.proposal.to);
+    }
+  }
+
+  return Array.from(counterparties);
+}
+
+/**
+ * Get receipt statistics
+ * @param {Array} receipts - Array of receipts
+ * @param {string} agentId - Optional agent ID for filtering
+ * @returns {object} Statistics object
+ */
+export function getStats(receipts, agentId = null) {
+  let filtered = receipts;
+  if (agentId) {
+    filtered = filterByAgent(receipts, agentId);
+  }
+
+  if (filtered.length === 0) {
+    return {
+      count: 0,
+      counterparties: [],
+      dateRange: null,
+      currencies: {}
+    };
+  }
+
+  // Get date range
+  const timestamps = filtered
+    .map(r => r.completed_at || r.ts || r.stored_at)
+    .filter(Boolean)
+    .sort((a, b) => a - b);
+
+  // Count currencies/amounts
+  const currencies = {};
+  for (const r of filtered) {
+    const currency = r.proposal?.currency || r.currency || 'unknown';
+    const amount = r.proposal?.amount || r.amount || 0;
+
+    if (!currencies[currency]) {
+      currencies[currency] = { count: 0, totalAmount: 0 };
+    }
+    currencies[currency].count++;
+    currencies[currency].totalAmount += amount;
+  }
+
+  return {
+    count: filtered.length,
+    counterparties: agentId ? getCounterparties(filtered, agentId) : [],
+    dateRange: timestamps.length > 0 ? {
+      oldest: new Date(timestamps[0]).toISOString(),
+      newest: new Date(timestamps[timestamps.length - 1]).toISOString()
+    } : null,
+    currencies
+  };
+}
+
+/**
+ * Export receipts in specified format
+ * @param {Array} receipts - Array of receipts
+ * @param {string} format - 'json' or 'yaml'
+ * @returns {string} Formatted output
+ */
+export function exportReceipts(receipts, format = 'json') {
+  if (format === 'yaml') {
+    // Simple YAML-like output
+    let output = 'receipts:\n';
+    for (const r of receipts) {
+      output += `  - proposal_id: ${r.proposal_id || 'unknown'}\n`;
+      output += `    completed_at: ${r.completed_at ? new Date(r.completed_at).toISOString() : 'unknown'}\n`;
+      output += `    completed_by: ${r.completed_by || 'unknown'}\n`;
+      if (r.proof) output += `    proof: ${r.proof}\n`;
+      if (r.proposal) {
+        output += `    proposal:\n`;
+        output += `      from: ${r.proposal.from}\n`;
+        output += `      to: ${r.proposal.to}\n`;
+        output += `      task: ${r.proposal.task}\n`;
+        if (r.proposal.amount) output += `      amount: ${r.proposal.amount}\n`;
+        if (r.proposal.currency) output += `      currency: ${r.proposal.currency}\n`;
+      }
+      output += '\n';
+    }
+    return output;
+  }
+
+  // Default: JSON
+  return JSON.stringify(receipts, null, 2);
+}
+
+/**
+ * Check if a receipt should be stored (we are a party to it)
+ * @param {object} completeMsg - The COMPLETE message
+ * @param {string} ourAgentId - Our agent ID
+ * @returns {boolean}
+ */
+export function shouldStoreReceipt(completeMsg, ourAgentId) {
+  const normalizedId = ourAgentId.startsWith('@') ? ourAgentId : `@${ourAgentId}`;
+
+  // Check if we're a party to this completion
+  return (
+    completeMsg.from === normalizedId ||
+    completeMsg.to === normalizedId ||
+    completeMsg.completed_by === normalizedId ||
+    completeMsg.proposal?.from === normalizedId ||
+    completeMsg.proposal?.to === normalizedId
+  );
+}
+
+/**
+ * ReceiptStore class for managing receipts
+ */
+export class ReceiptStore {
+  constructor(receiptsPath = DEFAULT_RECEIPTS_PATH) {
+    this.receiptsPath = receiptsPath;
+    this._receipts = null; // Lazy load
+  }
+
+  /**
+   * Load receipts from file
+   */
+  async load() {
+    this._receipts = await readReceipts(this.receiptsPath);
+    return this._receipts;
+  }
+
+  /**
+   * Get all receipts (loads if needed)
+   */
+  async getAll() {
+    if (this._receipts === null) {
+      await this.load();
+    }
+    return this._receipts;
+  }
+
+  /**
+   * Add a receipt
+   */
+  async add(receipt) {
+    const stored = await appendReceipt(receipt, this.receiptsPath);
+    if (this._receipts !== null) {
+      this._receipts.push(stored);
+    }
+    return stored;
+  }
+
+  /**
+   * Get receipts for an agent
+   */
+  async getForAgent(agentId) {
+    const all = await this.getAll();
+    return filterByAgent(all, agentId);
+  }
+
+  /**
+   * Get statistics
+   */
+  async getStats(agentId = null) {
+    const all = await this.getAll();
+    return getStats(all, agentId);
+  }
+
+  /**
+   * Export receipts
+   */
+  async export(format = 'json', agentId = null) {
+    let receipts = await this.getAll();
+    if (agentId) {
+      receipts = filterByAgent(receipts, agentId);
+    }
+    return exportReceipts(receipts, format);
+  }
+}