agent-relay 2.0.33 → 2.0.35

package/packages/wrapper/dist/wrapper-events.js

@@ -0,0 +1,252 @@
+/**
+ * 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';
+/**
+ * Define a typed event with Zod schema validation
+ */
+export function defineEvent(type, schema) {
+    return { type, schema };
+}
+// =========================================================================
+// Daemon Event Definitions
+// =========================================================================
+export var RelayEvent;
+(function (RelayEvent) {
+    // --- Agent Lifecycle Events ---
+    RelayEvent.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(),
+    }));
+    RelayEvent.AgentDisconnected = defineEvent('daemon.agent.disconnected', z.object({
+        agentName: z.string(),
+        connectionId: z.string(),
+        reason: z.enum(['clean', 'error', 'timeout', 'replaced']).optional(),
+    }));
+    RelayEvent.AgentSpawned = defineEvent('daemon.agent.spawned', z.object({
+        agentName: z.string(),
+        parentAgent: z.string(),
+        cli: z.string(),
+        task: z.string(),
+    }));
+    RelayEvent.AgentReleased = defineEvent('daemon.agent.released', z.object({
+        agentName: z.string(),
+        releasedBy: z.string(),
+    }));
+    // --- Message Events ---
+    RelayEvent.MessageRouted = defineEvent('daemon.message.routed', z.object({
+        messageId: z.string(),
+        from: z.string(),
+        to: z.string(),
+        kind: z.string().optional(),
+        bodyPreview: z.string().optional(),
+    }));
+    RelayEvent.MessageDelivered = defineEvent('daemon.message.delivered', z.object({
+        messageId: z.string(),
+        to: z.string(),
+        deliverySeq: z.number(),
+    }));
+    RelayEvent.MessageFailed = defineEvent('daemon.message.failed', z.object({
+        messageId: z.string(),
+        to: z.string(),
+        error: z.string(),
+    }));
+    // --- Channel Events ---
+    RelayEvent.ChannelJoined = defineEvent('daemon.channel.joined', z.object({
+        channel: z.string(),
+        member: z.string(),
+    }));
+    RelayEvent.ChannelLeft = defineEvent('daemon.channel.left', z.object({
+        channel: z.string(),
+        member: z.string(),
+    }));
+    RelayEvent.ChannelMessage = defineEvent('daemon.channel.message', z.object({
+        channel: z.string(),
+        from: z.string(),
+        bodyPreview: z.string().optional(),
+    }));
+    // --- Processing State Events ---
+    RelayEvent.AgentProcessingStarted = defineEvent('daemon.agent.processing.started', z.object({
+        agentName: z.string(),
+        messageId: z.string(),
+    }));
+    RelayEvent.AgentProcessingEnded = defineEvent('daemon.agent.processing.ended', z.object({
+        agentName: z.string(),
+        durationMs: z.number().optional(),
+    }));
+    // --- Shadow Events ---
+    RelayEvent.ShadowBound = defineEvent('daemon.shadow.bound', z.object({
+        shadowAgent: z.string(),
+        primaryAgent: z.string(),
+        speakOn: z.array(z.string()),
+    }));
+    RelayEvent.ShadowUnbound = defineEvent('daemon.shadow.unbound', z.object({
+        shadowAgent: z.string(),
+        primaryAgent: z.string(),
+    }));
+    // --- System Events ---
+    RelayEvent.DaemonStarted = defineEvent('daemon.system.started', z.object({
+        socketPath: z.string(),
+        version: z.string().optional(),
+    }));
+    RelayEvent.DaemonStopped = defineEvent('daemon.system.stopped', z.object({
+        reason: z.string().optional(),
+    }));
+    RelayEvent.RateLimitExceeded = defineEvent('daemon.system.rate_limit_exceeded', z.object({
+        agentName: z.string(),
+    }));
+    // --- All event definitions for iteration ---
+    RelayEvent.all = [
+        RelayEvent.AgentConnected,
+        RelayEvent.AgentDisconnected,
+        RelayEvent.AgentSpawned,
+        RelayEvent.AgentReleased,
+        RelayEvent.MessageRouted,
+        RelayEvent.MessageDelivered,
+        RelayEvent.MessageFailed,
+        RelayEvent.ChannelJoined,
+        RelayEvent.ChannelLeft,
+        RelayEvent.ChannelMessage,
+        RelayEvent.AgentProcessingStarted,
+        RelayEvent.AgentProcessingEnded,
+        RelayEvent.ShadowBound,
+        RelayEvent.ShadowUnbound,
+        RelayEvent.DaemonStarted,
+        RelayEvent.DaemonStopped,
+        RelayEvent.RateLimitExceeded,
+    ];
+})(RelayEvent || (RelayEvent = {}));
+// =========================================================================
+// Event Bus
+// =========================================================================
+/**
+ * Type-safe event bus for daemon events
+ */
+class RelayEventBus extends EventEmitter {
+    static instance;
+    constructor() {
+        super();
+        this.setMaxListeners(100); // Allow many subscribers
+    }
+    static getInstance() {
+        if (!RelayEventBus.instance) {
+            RelayEventBus.instance = new RelayEventBus();
+        }
+        return RelayEventBus.instance;
+    }
+    /**
+     * Emit a typed event
+     */
+    emitEvent(definition, properties) {
+        const payload = {
+            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(definition, callback) {
+        this.on(definition.type, callback);
+        return () => this.off(definition.type, callback);
+    }
+    /**
+     * Subscribe to all events (wildcard)
+     */
+    onAnyEvent(callback) {
+        this.on('*', callback);
+        return () => this.off('*', callback);
+    }
+    /**
+     * Subscribe to an event once
+     */
+    onceEvent(definition, callback) {
+        this.once(definition.type, callback);
+    }
+}
+// =========================================================================
+// Exports
+// =========================================================================
+/**
+ * Global daemon event bus instance
+ */
+export const relayEventBus = RelayEventBus.getInstance();
+/**
+ * Emit a daemon event
+ */
+export function emitEvent(definition, properties) {
+    relayEventBus.emitEvent(definition, properties);
+}
+/**
+ * Subscribe to a daemon event
+ */
+export function onEvent(definition, callback) {
+    return relayEventBus.onEvent(definition, callback);
+}
+/**
+ * Subscribe to all daemon events
+ */
+export function onAnyEvent(callback) {
+    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() {
+    const schemas = {};
+    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;
+}
+//# sourceMappingURL=wrapper-events.js.map

package/packages/wrapper/dist/wrapper-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper-events.js","sourceRoot":"","sources":["../src/wrapper-events.ts"],"names":[],"mappings":"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"}

package/packages/wrapper/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/wrapper",
-  "version": "2.0.33",
+  "version": "2.0.35",
   "description": "CLI agent wrappers for Agent Relay - tmux, pty integration",
   "type": "module",
   "main": "dist/index.js",
@@ -30,11 +30,12 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@agent-relay/api-types": "2.0.33",
-    "@agent-relay/protocol": "2.0.33",
-    "@agent-relay/config": "2.0.33",
-    "@agent-relay/continuity": "2.0.33",
-    "@agent-relay/resiliency": "2.0.33"
+    "@agent-relay/api-types": "2.0.35",
+    "@agent-relay/protocol": "2.0.35",
+    "@agent-relay/config": "2.0.35",
+    "@agent-relay/continuity": "2.0.35",
+    "@agent-relay/resiliency": "2.0.35",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "typescript": "^5.9.3",

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

@@ -576,11 +576,19 @@ export abstract class BaseWrapper extends EventEmitter {
    * Execute a spawn command
    */
   protected async executeSpawn(name: string, cli: string, task: string): Promise<void> {
-    // TODO: Re-enable daemon socket spawn when client.spawn() is implemented
-    // See: docs/SDK-MIGRATION-PLAN.md for planned implementation
-    // For now, go directly to dashboard API or callback
+    // Try daemon socket spawn first (most reliable)
+    if (this.client.state === 'READY') {
+      try {
+        const result = await this.client.spawn({ name, cli, task });
+        if (result.success) return;
+        // If spawn failed, log and fall through to other methods
+        console.warn(`[base-wrapper] Daemon spawn failed: ${result.error}`);
+      } catch (e) {
+        console.warn(`[base-wrapper] Daemon spawn error: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
 
-    // Try dashboard API
+    // Try dashboard API as fallback
     if (this.config.dashboardPort) {
       try {
         const response = await fetch(
@@ -607,9 +615,17 @@ export abstract class BaseWrapper extends EventEmitter {
    * Execute a release command
    */
   protected async executeRelease(name: string): Promise<void> {
-    // TODO: Re-enable daemon socket release when client.release() is implemented
-    // See: docs/SDK-MIGRATION-PLAN.md for planned implementation
-    // For now, go directly to dashboard API or callback
+    // Try daemon socket release first (most reliable)
+    if (this.client.state === 'READY') {
+      try {
+        const result = await this.client.release(name);
+        if (result.success) return;
+        // If release failed, log and fall through to other methods
+        console.warn(`[base-wrapper] Daemon release failed: ${result.error}`);
+      } catch (e) {
+        console.warn(`[base-wrapper] Daemon release error: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
 
     // Try dashboard API as fallback (backwards compatibility)
     if (this.config.dashboardPort) {

package/packages/wrapper/src/client.test.ts

@@ -256,7 +256,96 @@ describe('RelayClient', () => {
     });
   });
 
-  // TODO: Re-add spawn/release tests when daemon-based spawning is implemented
-  // See: docs/SDK-MIGRATION-PLAN.md for planned implementation
-  // These methods will be added to RelayClient as part of the SDK extraction work
+  describe('spawn', () => {
+    it('should return error when client not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = await client.spawn({ name: 'Worker1', cli: 'claude', task: 'Test task' });
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Client not ready');
+    });
+
+    it('should send SPAWN envelope when ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'READY';
+      (client as any).socket = { write: vi.fn() };
+
+      // Mock requestResponse to return a successful result
+      const mockResult = { replyTo: 'test-id', success: true, name: 'Worker1' };
+      vi.spyOn(client as any, 'requestResponse').mockResolvedValue(mockResult);
+
+      const result = await client.spawn({
+        name: 'Worker1',
+        cli: 'claude',
+        task: 'Test task',
+        model: 'opus',
+        cwd: '/test/path',
+      });
+
+      expect((client as any).requestResponse).toHaveBeenCalledWith(
+        'SPAWN',
+        expect.objectContaining({
+          name: 'Worker1',
+          cli: 'claude',
+          task: 'Test task',
+          model: 'opus',
+          cwd: '/test/path',
+        }),
+        30000
+      );
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle spawn failure', async () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'READY';
+      (client as any).socket = { write: vi.fn() };
+
+      vi.spyOn(client as any, 'requestResponse').mockRejectedValue(new Error('Spawn failed'));
+
+      const result = await client.spawn({ name: 'Worker1', cli: 'claude', task: 'Test task' });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Spawn failed');
+    });
+  });
+
+  describe('release', () => {
+    it('should return error when client not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = await client.release('Worker1');
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Client not ready');
+    });
+
+    it('should send RELEASE envelope when ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'READY';
+      (client as any).socket = { write: vi.fn() };
+
+      const mockResult = { replyTo: 'test-id', success: true, name: 'Worker1' };
+      vi.spyOn(client as any, 'requestResponse').mockResolvedValue(mockResult);
+
+      const result = await client.release('Worker1', 'Task completed');
+
+      expect((client as any).requestResponse).toHaveBeenCalledWith(
+        'RELEASE',
+        { name: 'Worker1', reason: 'Task completed' },
+        10000
+      );
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle release failure', async () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'READY';
+      (client as any).socket = { write: vi.fn() };
+
+      vi.spyOn(client as any, 'requestResponse').mockRejectedValue(new Error('Release failed'));
+
+      const result = await client.release('Worker1');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Release failed');
+    });
+  });
 });

package/packages/wrapper/src/client.ts

@@ -56,8 +56,21 @@ import {
   type SpeakOnTrigger,
   type LogPayload,
   type EntityType,
+  type SpawnPayload,
+  type SpawnResultPayload,
+  type ReleasePayload,
+  type ReleaseResultPayload,
   PROTOCOL_VERSION,
 } from '@agent-relay/protocol/types';
+import {
+  type SpawnResult,
+  type ReleaseResult,
+  toSpawnResult,
+  toReleaseResult,
+} from '@agent-relay/utils/client-helpers';
+
+// Re-export types for consumers
+export type { SpawnResult, ReleaseResult };
 import type {
   ChannelMessagePayload,
   ChannelJoinEnvelope,
@@ -684,6 +697,139 @@ export class RelayClient {
 
     return this.send(envelope);
   }
+
+  // =============================================================================
+  // Spawn/Release Operations
+  // =============================================================================
+
+  /**
+   * Spawn a worker agent via the daemon.
+   * @param options - Spawn configuration
+   * @returns Promise resolving to spawn result
+   */
+  async spawn(options: {
+    name: string;
+    cli: string;
+    task: string;
+    model?: string;
+    cwd?: string;
+  }): Promise<SpawnResult> {
+    if (this._state !== 'READY') {
+      return { success: false, error: 'Client not ready' };
+    }
+
+    try {
+      const payload: SpawnPayload = {
+        name: options.name,
+        cli: options.cli,
+        task: options.task,
+        model: options.model,
+        cwd: options.cwd,
+        spawnerName: this.config.agentName,
+      };
+
+      const result = await this.requestResponse<SpawnResultPayload>(
+        'SPAWN',
+        payload as unknown as Record<string, unknown>,
+        30000 // 30 second timeout for spawn
+      );
+
+      return toSpawnResult(result);
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+
+  /**
+   * Release (terminate) a worker agent via the daemon.
+   * @param name - Name of the agent to release
+   * @param reason - Optional reason for release
+   * @returns Promise resolving to release result
+   */
+  async release(name: string, reason?: string): Promise<ReleaseResult> {
+    if (this._state !== 'READY') {
+      return { success: false, error: 'Client not ready' };
+    }
+
+    try {
+      const payload: ReleasePayload = { name, reason };
+
+      const result = await this.requestResponse<ReleaseResultPayload>(
+        'RELEASE',
+        payload as unknown as Record<string, unknown>,
+        10000 // 10 second timeout for release
+      );
+
+      return toReleaseResult(result);
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+
+  /**
+   * Send an envelope and wait for a matching response.
+   * Used for request/response operations like spawn/release.
+   */
+  private requestResponse<T>(
+    type: string,
+    payload: Record<string, unknown>,
+    timeoutMs: number
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error('Not connected'));
+        return;
+      }
+
+      const requestId = generateId();
+      let timeoutHandle: NodeJS.Timeout;
+      let responseHandler: (envelope: Envelope) => void;
+
+      const cleanup = (): void => {
+        clearTimeout(timeoutHandle);
+        // Remove the handler from pending response handlers
+        this.pendingResponses.delete(requestId);
+      };
+
+      timeoutHandle = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Request timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      responseHandler = (envelope: Envelope): void => {
+        // Match by replyTo or id
+        const replyTo = (envelope.payload as { replyTo?: string })?.replyTo;
+        if (replyTo === requestId || envelope.id === requestId) {
+          cleanup();
+
+          if (envelope.type === 'ERROR') {
+            const errorPayload = envelope.payload as { message?: string; code?: string };
+            reject(new Error(errorPayload.message || errorPayload.code || 'Unknown error'));
+          } else {
+            resolve(envelope.payload as T);
+          }
+        }
+      };
+
+      // Register handler for this request
+      this.pendingResponses.set(requestId, responseHandler);
+
+      // Send the request envelope
+      const envelope: Envelope = {
+        v: PROTOCOL_VERSION,
+        type: type as Envelope['type'],
+        id: requestId,
+        ts: Date.now(),
+        payload,
+      };
+
+      this.send(envelope);
+    });
+  }
+
+  // Map to track pending request/response handlers
+  private pendingResponses: Map<string, (envelope: Envelope) => void> = new Map();
+
   private setState(state: ClientState): void {
     this._state = state;
     if (this.onStateChange) {
@@ -768,6 +914,17 @@ export class RelayClient {
   }
 
   private processFrame(envelope: Envelope): void {
+    // Check for pending request/response handlers first
+    // This handles SPAWN_RESULT, RELEASE_RESULT, and ERROR responses
+    const replyTo = (envelope.payload as { replyTo?: string })?.replyTo;
+    if (replyTo && this.pendingResponses.has(replyTo)) {
+      const handler = this.pendingResponses.get(replyTo);
+      if (handler) {
+        handler(envelope);
+        return;
+      }
+    }
+
     switch (envelope.type) {
       case 'WELCOME':
         this.handleWelcome(envelope as Envelope<WelcomePayload>);
@@ -793,6 +950,12 @@ export class RelayClient {
         this.handleErrorFrame(envelope as Envelope<ErrorPayload>);
         break;
 
+      case 'SPAWN_RESULT':
+      case 'RELEASE_RESULT':
+        // These should be handled by pending response handlers above
+        // If we get here, it's an orphaned response (no handler waiting)
+        break;
+
       case 'BUSY':
         console.warn('[client] Server busy, backing off');
         break;

package/packages/wrapper/src/index.ts

@@ -168,3 +168,32 @@ export {
   RelayPtyOrchestrator,
   type RelayPtyOrchestratorConfig,
 } from './relay-pty-orchestrator.js';
+
+// OpenCode HTTP API integration
+export {
+  OpenCodeApi,
+  openCodeApi,
+  type OpenCodeApiConfig,
+  type OpenCodeSession,
+  type OpenCodeApiResponse,
+} from './opencode-api.js';
+
+// OpenCode wrapper (HTTP API + PTY fallback)
+export {
+  OpenCodeWrapper,
+  type OpenCodeWrapperConfig,
+} from './opencode-wrapper.js';
+
+// Typed event definitions (inspired by opencode's BusEvent pattern)
+export {
+  RelayEvent,
+  defineEvent,
+  relayEventBus,
+  emitEvent,
+  onEvent,
+  onAnyEvent,
+  generateEventSchemas,
+  type EventDefinition,
+  type EventProperties,
+  type EventPayload,
+} from './wrapper-events.js';