agent-relay 2.0.32 → 2.0.34

package/packages/wrapper/src/relay-pty-orchestrator.ts

@@ -57,6 +57,13 @@ import {
 
 const MAX_SOCKET_PATH_LENGTH = 107;
 
+/**
+ * Maximum size for output buffers (rawBuffer, outputBuffer) in bytes.
+ * Prevents RangeError: Invalid string length when agents produce lots of output.
+ * Set to 10MB - enough to capture context but won't exhaust memory.
+ */
+const MAX_OUTPUT_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
+
 function hashWorkspaceId(workspaceId: string): string {
   return createHash('sha256').update(workspaceId).digest('hex').slice(0, 12);
 }
@@ -956,6 +963,19 @@ export class RelayPtyOrchestrator extends BaseWrapper {
     this.outputBuffer += data;
     this.hasReceivedOutput = true;
 
+    // Trim buffers if they exceed max size to prevent RangeError: Invalid string length
+    // Keep the most recent output (tail) as it's more relevant for pattern matching
+    if (this.rawBuffer.length > MAX_OUTPUT_BUFFER_SIZE) {
+      const trimAmount = this.rawBuffer.length - MAX_OUTPUT_BUFFER_SIZE;
+      this.rawBuffer = this.rawBuffer.slice(-MAX_OUTPUT_BUFFER_SIZE);
+      // Adjust lastParsedLength to stay in sync with the trimmed buffer
+      // This ensures parseRelayCommands() doesn't skip content or re-parse old content
+      this.lastParsedLength = Math.max(0, this.lastParsedLength - trimAmount);
+    }
+    if (this.outputBuffer.length > MAX_OUTPUT_BUFFER_SIZE) {
+      this.outputBuffer = this.outputBuffer.slice(-MAX_OUTPUT_BUFFER_SIZE);
+    }
+
     // Feed to idle detector
     this.feedIdleDetectorOutput(data);
 

package/packages/wrapper/src/wrapper-events.ts

@@ -0,0 +1,395 @@
+/**
+ * Typed Event Definitions for Agent Relay Wrapper
+ *
+ * Inspired by opencode's BusEvent pattern, this provides type-safe event
+ * definitions with Zod schema validation. Events can be used for:
+ * - Wrapper internal notifications
+ * - SDK client subscriptions
+ * - OpenAPI spec generation
+ *
+ * @example
+ * ```typescript
+ * import { RelayEvent, emitEvent, onEvent } from './wrapper-events.js';
+ *
+ * // Subscribe to events
+ * onEvent(RelayEvent.AgentConnected, (event) => {
+ *   console.log(`Agent ${event.properties.agentName} connected`);
+ * });
+ *
+ * // Emit events
+ * emitEvent(RelayEvent.AgentConnected, {
+ *   agentName: 'MyAgent',
+ *   connectionId: 'abc123',
+ * });
+ * ```
+ */
+
+import { z } from 'zod';
+import { EventEmitter } from 'node:events';
+
+// =========================================================================
+// Event Definition Factory
+// =========================================================================
+
+/**
+ * Event definition with type and schema
+ */
+export interface EventDefinition<
+  Type extends string = string,
+  Schema extends z.ZodType = z.ZodType
+> {
+  type: Type;
+  schema: Schema;
+}
+
+/**
+ * Define a typed event with Zod schema validation
+ */
+export function defineEvent<Type extends string, Schema extends z.ZodType>(
+  type: Type,
+  schema: Schema
+): EventDefinition<Type, Schema> {
+  return { type, schema };
+}
+
+/**
+ * Infer the properties type from an event definition
+ */
+export type EventProperties<E extends EventDefinition> = z.infer<E['schema']>;
+
+/**
+ * Event payload with type and properties
+ */
+export interface EventPayload<E extends EventDefinition = EventDefinition> {
+  type: E['type'];
+  properties: EventProperties<E>;
+  timestamp: number;
+}
+
+// =========================================================================
+// Daemon Event Definitions
+// =========================================================================
+
+export namespace RelayEvent {
+  // --- Agent Lifecycle Events ---
+
+  export const AgentConnected = defineEvent(
+    'daemon.agent.connected',
+    z.object({
+      agentName: z.string(),
+      connectionId: z.string(),
+      cli: z.string().optional(),
+      task: z.string().optional(),
+      workingDirectory: z.string().optional(),
+    })
+  );
+
+  export const AgentDisconnected = defineEvent(
+    'daemon.agent.disconnected',
+    z.object({
+      agentName: z.string(),
+      connectionId: z.string(),
+      reason: z.enum(['clean', 'error', 'timeout', 'replaced']).optional(),
+    })
+  );
+
+  export const AgentSpawned = defineEvent(
+    'daemon.agent.spawned',
+    z.object({
+      agentName: z.string(),
+      parentAgent: z.string(),
+      cli: z.string(),
+      task: z.string(),
+    })
+  );
+
+  export const AgentReleased = defineEvent(
+    'daemon.agent.released',
+    z.object({
+      agentName: z.string(),
+      releasedBy: z.string(),
+    })
+  );
+
+  // --- Message Events ---
+
+  export const MessageRouted = defineEvent(
+    'daemon.message.routed',
+    z.object({
+      messageId: z.string(),
+      from: z.string(),
+      to: z.string(),
+      kind: z.string().optional(),
+      bodyPreview: z.string().optional(),
+    })
+  );
+
+  export const MessageDelivered = defineEvent(
+    'daemon.message.delivered',
+    z.object({
+      messageId: z.string(),
+      to: z.string(),
+      deliverySeq: z.number(),
+    })
+  );
+
+  export const MessageFailed = defineEvent(
+    'daemon.message.failed',
+    z.object({
+      messageId: z.string(),
+      to: z.string(),
+      error: z.string(),
+    })
+  );
+
+  // --- Channel Events ---
+
+  export const ChannelJoined = defineEvent(
+    'daemon.channel.joined',
+    z.object({
+      channel: z.string(),
+      member: z.string(),
+    })
+  );
+
+  export const ChannelLeft = defineEvent(
+    'daemon.channel.left',
+    z.object({
+      channel: z.string(),
+      member: z.string(),
+    })
+  );
+
+  export const ChannelMessage = defineEvent(
+    'daemon.channel.message',
+    z.object({
+      channel: z.string(),
+      from: z.string(),
+      bodyPreview: z.string().optional(),
+    })
+  );
+
+  // --- Processing State Events ---
+
+  export const AgentProcessingStarted = defineEvent(
+    'daemon.agent.processing.started',
+    z.object({
+      agentName: z.string(),
+      messageId: z.string(),
+    })
+  );
+
+  export const AgentProcessingEnded = defineEvent(
+    'daemon.agent.processing.ended',
+    z.object({
+      agentName: z.string(),
+      durationMs: z.number().optional(),
+    })
+  );
+
+  // --- Shadow Events ---
+
+  export const ShadowBound = defineEvent(
+    'daemon.shadow.bound',
+    z.object({
+      shadowAgent: z.string(),
+      primaryAgent: z.string(),
+      speakOn: z.array(z.string()),
+    })
+  );
+
+  export const ShadowUnbound = defineEvent(
+    'daemon.shadow.unbound',
+    z.object({
+      shadowAgent: z.string(),
+      primaryAgent: z.string(),
+    })
+  );
+
+  // --- System Events ---
+
+  export const DaemonStarted = defineEvent(
+    'daemon.system.started',
+    z.object({
+      socketPath: z.string(),
+      version: z.string().optional(),
+    })
+  );
+
+  export const DaemonStopped = defineEvent(
+    'daemon.system.stopped',
+    z.object({
+      reason: z.string().optional(),
+    })
+  );
+
+  export const RateLimitExceeded = defineEvent(
+    'daemon.system.rate_limit_exceeded',
+    z.object({
+      agentName: z.string(),
+    })
+  );
+
+  // --- All event definitions for iteration ---
+
+  export const all = [
+    AgentConnected,
+    AgentDisconnected,
+    AgentSpawned,
+    AgentReleased,
+    MessageRouted,
+    MessageDelivered,
+    MessageFailed,
+    ChannelJoined,
+    ChannelLeft,
+    ChannelMessage,
+    AgentProcessingStarted,
+    AgentProcessingEnded,
+    ShadowBound,
+    ShadowUnbound,
+    DaemonStarted,
+    DaemonStopped,
+    RateLimitExceeded,
+  ] as const;
+}
+
+// =========================================================================
+// Event Bus
+// =========================================================================
+
+/**
+ * Type-safe event bus for daemon events
+ */
+class RelayEventBus extends EventEmitter {
+  private static instance: RelayEventBus;
+
+  private constructor() {
+    super();
+    this.setMaxListeners(100); // Allow many subscribers
+  }
+
+  static getInstance(): RelayEventBus {
+    if (!RelayEventBus.instance) {
+      RelayEventBus.instance = new RelayEventBus();
+    }
+    return RelayEventBus.instance;
+  }
+
+  /**
+   * Emit a typed event
+   */
+  emitEvent<E extends EventDefinition>(
+    definition: E,
+    properties: EventProperties<E>
+  ): void {
+    const payload: EventPayload<E> = {
+      type: definition.type,
+      properties,
+      timestamp: Date.now(),
+    };
+
+    // Validate properties against schema
+    const result = definition.schema.safeParse(properties);
+    if (!result.success) {
+      console.error(`[RelayEventBus] Invalid event properties for ${definition.type}:`, result.error);
+      return;
+    }
+
+    // Emit to specific subscribers and wildcard subscribers
+    this.emit(definition.type, payload);
+    this.emit('*', payload);
+  }
+
+  /**
+   * Subscribe to a typed event
+   */
+  onEvent<E extends EventDefinition>(
+    definition: E,
+    callback: (event: EventPayload<E>) => void
+  ): () => void {
+    this.on(definition.type, callback);
+    return () => this.off(definition.type, callback);
+  }
+
+  /**
+   * Subscribe to all events (wildcard)
+   */
+  onAnyEvent(callback: (event: EventPayload) => void): () => void {
+    this.on('*', callback);
+    return () => this.off('*', callback);
+  }
+
+  /**
+   * Subscribe to an event once
+   */
+  onceEvent<E extends EventDefinition>(
+    definition: E,
+    callback: (event: EventPayload<E>) => void
+  ): void {
+    this.once(definition.type, callback);
+  }
+}
+
+// =========================================================================
+// Exports
+// =========================================================================
+
+/**
+ * Global daemon event bus instance
+ */
+export const relayEventBus = RelayEventBus.getInstance();
+
+/**
+ * Emit a daemon event
+ */
+export function emitEvent<E extends EventDefinition>(
+  definition: E,
+  properties: EventProperties<E>
+): void {
+  relayEventBus.emitEvent(definition, properties);
+}
+
+/**
+ * Subscribe to a daemon event
+ */
+export function onEvent<E extends EventDefinition>(
+  definition: E,
+  callback: (event: EventPayload<E>) => void
+): () => void {
+  return relayEventBus.onEvent(definition, callback);
+}
+
+/**
+ * Subscribe to all daemon events
+ */
+export function onAnyEvent(callback: (event: EventPayload) => void): () => void {
+  return relayEventBus.onAnyEvent(callback);
+}
+
+// =========================================================================
+// OpenAPI Schema Generation
+// =========================================================================
+
+/**
+ * Generate OpenAPI-compatible schema for all daemon events
+ * This can be used to auto-generate SDK types
+ */
+export function generateEventSchemas(): Record<string, unknown> {
+  const schemas: Record<string, unknown> = {};
+
+  for (const definition of RelayEvent.all) {
+    // Extract JSON Schema from Zod schema
+    // Note: This is a simplified version - production use should use zod-to-json-schema
+    schemas[definition.type] = {
+      type: 'object',
+      properties: {
+        type: { type: 'string', const: definition.type },
+        properties: definition.schema._def, // Simplified - use zod-to-json-schema for production
+        timestamp: { type: 'number' },
+      },
+      required: ['type', 'properties', 'timestamp'],
+    };
+  }
+
+  return schemas;
+}

package/scripts/postinstall.js

@@ -279,6 +279,132 @@ function hasSystemTmux() {
   }
 }
 
+/**
+ * Setup workspace package symlinks for global/bundled installs.
+ *
+ * When agent-relay is installed globally (npm install -g), the workspace packages
+ * are included in the tarball at packages/* but Node.js module resolution expects
+ * them at node_modules/@agent-relay/*. This function creates symlinks to bridge
+ * the gap.
+ *
+ * This is needed because npm's bundledDependencies doesn't properly handle
+ * workspace packages (which are symlinks during development).
+ */
+function setupWorkspacePackageLinks() {
+  const pkgRoot = getPackageRoot();
+  const packagesDir = path.join(pkgRoot, 'packages');
+  const nodeModulesDir = path.join(pkgRoot, 'node_modules');
+  const scopeDir = path.join(nodeModulesDir, '@agent-relay');
+
+  // Check if packages/ exists (we're in a bundled/global install)
+  if (!fs.existsSync(packagesDir)) {
+    // Not a bundled install, workspace packages should be in node_modules already
+    return { needed: false };
+  }
+
+  // Check if node_modules/@agent-relay/daemon exists
+  const testPackage = path.join(scopeDir, 'daemon');
+  if (fs.existsSync(testPackage)) {
+    // Already set up (either normal npm install or previously linked)
+    info('Workspace packages already available in node_modules');
+    return { needed: false, alreadySetup: true };
+  }
+
+  // We need to create symlinks
+  info('Setting up workspace package links for global install...');
+
+  // Create node_modules/@agent-relay/ directory
+  try {
+    fs.mkdirSync(scopeDir, { recursive: true });
+  } catch (err) {
+    warn(`Failed to create @agent-relay scope directory: ${err.message}`);
+    return { needed: true, success: false, error: err.message };
+  }
+
+  // Map from package directory name to npm package name
+  const packageDirs = fs.readdirSync(packagesDir).filter(dir => {
+    const pkgJsonPath = path.join(packagesDir, dir, 'package.json');
+    return fs.existsSync(pkgJsonPath);
+  });
+
+  let linked = 0;
+  let failed = 0;
+  const errors = [];
+
+  for (const dir of packageDirs) {
+    const sourcePath = path.join(packagesDir, dir);
+    const targetPath = path.join(scopeDir, dir);
+
+    // Skip if already exists
+    if (fs.existsSync(targetPath)) {
+      continue;
+    }
+
+    try {
+      // Use relative symlink for portability
+      const relativeSource = path.relative(scopeDir, sourcePath);
+      fs.symlinkSync(relativeSource, targetPath, 'dir');
+      linked++;
+    } catch (err) {
+      // If symlink fails (e.g., on Windows without admin), try copying
+      try {
+        // Copy the package directory
+        copyDirSync(sourcePath, targetPath);
+        linked++;
+      } catch (copyErr) {
+        failed++;
+        errors.push(`${dir}: ${copyErr.message}`);
+      }
+    }
+  }
+
+  if (linked > 0) {
+    success(`Linked ${linked} workspace packages to node_modules/@agent-relay/`);
+  }
+
+  if (failed > 0) {
+    warn(`Failed to link ${failed} packages: ${errors.join(', ')}`);
+    return { needed: true, success: false, linked, failed, errors };
+  }
+
+  return { needed: true, success: true, linked };
+}
+
+/**
+ * Recursively copy a directory
+ */
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    // Skip node_modules in package copies
+    if (entry.name === 'node_modules') {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else if (entry.isSymbolicLink()) {
+      // Resolve symlink and copy the target
+      const linkTarget = fs.readlinkSync(srcPath);
+      const resolvedTarget = path.resolve(path.dirname(srcPath), linkTarget);
+      if (fs.existsSync(resolvedTarget)) {
+        if (fs.statSync(resolvedTarget).isDirectory()) {
+          copyDirSync(resolvedTarget, destPath);
+        } else {
+          fs.copyFileSync(resolvedTarget, destPath);
+        }
+      }
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 /**
  * Install dashboard dependencies
  */
@@ -362,7 +488,16 @@ function patchAgentTrajectories() {
   success('Patched agent-trajectories to record agent on trail start');
 }
 
-function logPostinstallDiagnostics(hasRelayPty, sqliteStatus) {
+function logPostinstallDiagnostics(hasRelayPty, sqliteStatus, linkResult) {
+  // Workspace packages status (for global installs)
+  if (linkResult && linkResult.needed) {
+    if (linkResult.success) {
+      console.log(`✓ Workspace packages linked (${linkResult.linked} packages)`);
+    } else {
+      console.log('⚠ Workspace package linking failed - CLI may not work');
+    }
+  }
+
   if (hasRelayPty) {
     console.log('✓ relay-pty binary installed');
   } else {
@@ -388,6 +523,16 @@ function logPostinstallDiagnostics(hasRelayPty, sqliteStatus) {
  * Main postinstall routine
  */
 async function main() {
+  // Setup workspace package links for global installs
+  // This MUST run first so that other postinstall steps can find the packages
+  const linkResult = setupWorkspacePackageLinks();
+  if (linkResult.needed && !linkResult.success) {
+    warn('Workspace package linking failed - CLI may not work correctly');
+    if (linkResult.errors) {
+      linkResult.errors.forEach(e => warn(`  ${e}`));
+    }
+  }
+
   // Install relay-pty binary for current platform (primary mode)
   const hasRelayPty = installRelayPtyBinary();
 
@@ -401,7 +546,7 @@ async function main() {
   installDashboardDeps();
 
   // Always print diagnostics (even in CI)
-  logPostinstallDiagnostics(hasRelayPty, sqliteStatus);
+  logPostinstallDiagnostics(hasRelayPty, sqliteStatus, linkResult);
 
   // Skip tmux check in CI environments
   if (process.env.CI === 'true') {