agent-relay 1.6.0 → 2.0.0

package/packages/api-types/dist/schemas/task.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Task Schemas
+ *
+ * Zod schemas for task-related types used across the dashboard and API.
+ */
+import { z } from 'zod';
+/**
+ * Task status enum
+ */
+export declare const TaskStatusSchema: z.ZodEnum<["open", "in_progress", "completed", "blocked"]>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+/**
+ * Task priority enum
+ */
+export declare const TaskPrioritySchema: z.ZodEnum<["P1", "P2", "P3", "P4"]>;
+export type TaskPriority = z.infer<typeof TaskPrioritySchema>;
+/**
+ * Task type enum
+ */
+export declare const TaskTypeSchema: z.ZodEnum<["task", "bug", "feature", "epic"]>;
+export type TaskType = z.infer<typeof TaskTypeSchema>;
+/**
+ * Task schema (Beads Integration)
+ */
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["open", "in_progress", "completed", "blocked"]>;
+    priority: z.ZodEnum<["P1", "P2", "P3", "P4"]>;
+    type: z.ZodEnum<["task", "bug", "feature", "epic"]>;
+    assignee: z.ZodOptional<z.ZodString>;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    blocking: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    created: z.ZodString;
+    updated: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "task" | "bug" | "feature" | "epic";
+    status: "open" | "in_progress" | "completed" | "blocked";
+    title: string;
+    id: string;
+    priority: "P1" | "P2" | "P3" | "P4";
+    created: string;
+    updated: string;
+    description?: string | undefined;
+    assignee?: string | undefined;
+    blockedBy?: string[] | undefined;
+    blocking?: string[] | undefined;
+}, {
+    type: "task" | "bug" | "feature" | "epic";
+    status: "open" | "in_progress" | "completed" | "blocked";
+    title: string;
+    id: string;
+    priority: "P1" | "P2" | "P3" | "P4";
+    created: string;
+    updated: string;
+    description?: string | undefined;
+    assignee?: string | undefined;
+    blockedBy?: string[] | undefined;
+    blocking?: string[] | undefined;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+/**
+ * Task assignment status enum (for API)
+ */
+export declare const TaskAssignmentStatusSchema: z.ZodEnum<["pending", "assigned", "in_progress", "completed", "failed"]>;
+export type TaskAssignmentStatus = z.infer<typeof TaskAssignmentStatusSchema>;
+/**
+ * Task assignment priority enum (for API)
+ */
+export declare const TaskAssignmentPrioritySchema: z.ZodEnum<["low", "medium", "high", "critical"]>;
+export type TaskAssignmentPriority = z.infer<typeof TaskAssignmentPrioritySchema>;
+/**
+ * Task assignment schema (for /api/tasks endpoints)
+ */
+export declare const TaskAssignmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentName: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    status: z.ZodEnum<["pending", "assigned", "in_progress", "completed", "failed"]>;
+    createdAt: z.ZodString;
+    assignedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "in_progress" | "completed" | "pending" | "assigned";
+    title: string;
+    description: string;
+    agentName: string;
+    id: string;
+    priority: "low" | "medium" | "high" | "critical";
+    createdAt: string;
+    assignedAt?: string | undefined;
+    completedAt?: string | undefined;
+    result?: string | undefined;
+}, {
+    status: "failed" | "in_progress" | "completed" | "pending" | "assigned";
+    title: string;
+    description: string;
+    agentName: string;
+    id: string;
+    priority: "low" | "medium" | "high" | "critical";
+    createdAt: string;
+    assignedAt?: string | undefined;
+    completedAt?: string | undefined;
+    result?: string | undefined;
+}>;
+export type TaskAssignment = z.infer<typeof TaskAssignmentSchema>;
+//# sourceMappingURL=task.d.ts.map

package/packages/api-types/dist/schemas/task.js

@@ -0,0 +1,64 @@
+/**
+ * Task Schemas
+ *
+ * Zod schemas for task-related types used across the dashboard and API.
+ */
+import { z } from 'zod';
+/**
+ * Task status enum
+ */
+export const TaskStatusSchema = z.enum(['open', 'in_progress', 'completed', 'blocked']);
+/**
+ * Task priority enum
+ */
+export const TaskPrioritySchema = z.enum(['P1', 'P2', 'P3', 'P4']);
+/**
+ * Task type enum
+ */
+export const TaskTypeSchema = z.enum(['task', 'bug', 'feature', 'epic']);
+/**
+ * Task schema (Beads Integration)
+ */
+export const TaskSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    status: TaskStatusSchema,
+    priority: TaskPrioritySchema,
+    type: TaskTypeSchema,
+    assignee: z.string().optional(),
+    blockedBy: z.array(z.string()).optional(),
+    blocking: z.array(z.string()).optional(),
+    created: z.string(),
+    updated: z.string(),
+});
+/**
+ * Task assignment status enum (for API)
+ */
+export const TaskAssignmentStatusSchema = z.enum([
+    'pending',
+    'assigned',
+    'in_progress',
+    'completed',
+    'failed',
+]);
+/**
+ * Task assignment priority enum (for API)
+ */
+export const TaskAssignmentPrioritySchema = z.enum(['low', 'medium', 'high', 'critical']);
+/**
+ * Task assignment schema (for /api/tasks endpoints)
+ */
+export const TaskAssignmentSchema = z.object({
+    id: z.string(),
+    agentName: z.string(),
+    title: z.string(),
+    description: z.string(),
+    priority: TaskAssignmentPrioritySchema,
+    status: TaskAssignmentStatusSchema,
+    createdAt: z.string(),
+    assignedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    result: z.string().optional(),
+});
+//# sourceMappingURL=task.js.map

package/packages/api-types/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@agent-relay/api-types",
+  "version": "2.0.0",
+  "description": "Shared API types and Zod schemas for Agent Relay",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/index.d.ts",
+      "import": "./dist/schemas/index.js",
+      "default": "./dist/schemas/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "generate:openapi": "tsx scripts/generate-openapi.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "agent-relay",
+    "api",
+    "types",
+    "zod",
+    "openapi"
+  ],
+  "author": "Khaliq Gant",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgentWorkforce/relay.git",
+    "directory": "packages/api-types"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@asteasolutions/zod-to-openapi": "^7.2.0",
+    "@types/node": "^22.19.3",
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  }
+}

package/packages/api-types/scripts/generate-openapi.ts

@@ -0,0 +1,106 @@
+/**
+ * OpenAPI Generation Script
+ *
+ * Generates OpenAPI 3.1 specification from Zod schemas.
+ * Run with: npm run generate:openapi
+ */
+
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import {
+  extendZodWithOpenApi,
+  OpenAPIRegistry,
+  OpenApiGeneratorV31,
+} from '@asteasolutions/zod-to-openapi';
+
+// Extend Zod with OpenAPI support
+extendZodWithOpenApi(z);
+
+// Import all schemas
+import {
+  AgentSchema,
+  AgentSummarySchema,
+  MessageSchema,
+  SessionSchema,
+  FleetDataSchema,
+  FleetServerSchema,
+  FleetStatsSchema,
+  TaskAssignmentSchema,
+  ApiDecisionSchema,
+  DecisionSchema,
+  TrajectorySchema,
+  SendMessageRequestSchema,
+  SpawnAgentRequestSchema,
+  SpawnAgentResponseSchema,
+  CreateTaskRequestSchema,
+  CreateBeadRequestSchema,
+  ActivityEventSchema,
+  HistorySessionSchema,
+  HistoryMessageSchema,
+  ConversationSchema,
+  HistoryStatsSchema,
+  FileSearchResponseSchema,
+} from '../src/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Create registry
+const registry = new OpenAPIRegistry();
+
+// Register schemas with OpenAPI metadata
+// Note: Schemas with z.lazy() (recursive types) are skipped as they require special handling
+registry.register('Agent', AgentSchema.openapi('Agent'));
+registry.register('AgentSummary', AgentSummarySchema.openapi('AgentSummary'));
+registry.register('Message', MessageSchema.openapi('Message'));
+registry.register('Session', SessionSchema.openapi('Session'));
+// FleetDataSchema contains AgentSchema which is already registered
+registry.register('FleetServer', FleetServerSchema.openapi('FleetServer'));
+registry.register('FleetStats', FleetStatsSchema.openapi('FleetStats'));
+registry.register('TaskAssignment', TaskAssignmentSchema.openapi('TaskAssignment'));
+registry.register('ApiDecision', ApiDecisionSchema.openapi('ApiDecision'));
+registry.register('Decision', DecisionSchema.openapi('Decision'));
+// TrajectorySchema uses z.lazy() for recursive children - skipped for now
+// registry.register('Trajectory', TrajectorySchema.openapi('Trajectory'));
+registry.register('SendMessageRequest', SendMessageRequestSchema.openapi('SendMessageRequest'));
+registry.register('SpawnAgentRequest', SpawnAgentRequestSchema.openapi('SpawnAgentRequest'));
+registry.register('SpawnAgentResponse', SpawnAgentResponseSchema.openapi('SpawnAgentResponse'));
+registry.register('CreateTaskRequest', CreateTaskRequestSchema.openapi('CreateTaskRequest'));
+registry.register('CreateBeadRequest', CreateBeadRequestSchema.openapi('CreateBeadRequest'));
+registry.register('ActivityEvent', ActivityEventSchema.openapi('ActivityEvent'));
+registry.register('HistorySession', HistorySessionSchema.openapi('HistorySession'));
+registry.register('HistoryMessage', HistoryMessageSchema.openapi('HistoryMessage'));
+registry.register('Conversation', ConversationSchema.openapi('Conversation'));
+registry.register('HistoryStats', HistoryStatsSchema.openapi('HistoryStats'));
+registry.register('FileSearchResponse', FileSearchResponseSchema.openapi('FileSearchResponse'));
+
+// Generate OpenAPI spec
+const generator = new OpenApiGeneratorV31(registry.definitions);
+const spec = generator.generateDocument({
+  openapi: '3.1.0',
+  info: {
+    title: 'Agent Relay API',
+    version: '1.0.0',
+    description: 'API types and schemas for Agent Relay communication system',
+  },
+  servers: [
+    {
+      url: 'http://localhost:3888',
+      description: 'Local development server',
+    },
+  ],
+});
+
+// Output path
+const outputDir = join(__dirname, '..', 'dist');
+const outputPath = join(outputDir, 'openapi.json');
+
+// Ensure dist directory exists
+mkdirSync(outputDir, { recursive: true });
+
+// Write spec
+writeFileSync(outputPath, JSON.stringify(spec, null, 2));
+console.log(`OpenAPI spec generated at: ${outputPath}`);
+console.log(`Registered ${Object.keys(spec.components?.schemas ?? {}).length} schemas`);

package/packages/bridge/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { ProjectConfig } from '@agent-relay/config/bridge-config';
+export * from './types.js';
+export * from './multi-project-client.js';
+export * from './utils.js';
+export { escapeForShell, escapeForTmux } from './utils.js';
+export { selectShadowCli, type ShadowCli, type ShadowMode, type ShadowCliSelection, } from './shadow-cli.js';
+export { AgentSpawner, readWorkersMetadata, getWorkerLogsDir, type AgentSpawnerOptions, type CloudPersistenceHandler, type OnAgentDeathCallback, } from './spawner.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/bridge/dist/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './multi-project-client.js';
+export * from './utils.js';
+export { escapeForShell, escapeForTmux } from './utils.js';
+// Shadow CLI selection
+export { selectShadowCli, } from './shadow-cli.js';
+// Agent spawner
+export { AgentSpawner, readWorkersMetadata, getWorkerLogsDir, } from './spawner.js';
+//# sourceMappingURL=index.js.map

package/packages/bridge/dist/multi-project-client.d.ts

@@ -0,0 +1,99 @@
+/**
+ * MultiProjectClient
+ * Connects to multiple project daemons simultaneously for cross-project orchestration.
+ */
+import { type SendPayload } from '@agent-relay/protocol/types';
+import type { ProjectConfig } from './types.js';
+interface MultiProjectClientOptions {
+    /** Agent name to register as (default: '__BridgeClient'). Must be unique per daemon. */
+    agentName?: string;
+    /** Enable automatic reconnection on disconnect (default: true) */
+    reconnect?: boolean;
+    /** Initial reconnection delay in ms (default: 1000) */
+    reconnectDelay?: number;
+    /** Maximum reconnection delay in ms (default: 30000) */
+    maxReconnectDelay?: number;
+    /** Maximum reconnection attempts before giving up (default: Infinity) */
+    maxReconnectAttempts?: number;
+}
+export declare class MultiProjectClient {
+    private projects;
+    private connections;
+    private leads;
+    private options;
+    private shuttingDown;
+    /** Handler for incoming messages */
+    onMessage?: (projectId: string, from: string, payload: SendPayload, messageId: string) => void;
+    /** Handler for connection state changes */
+    onProjectStateChange?: (projectId: string, connected: boolean) => void;
+    constructor(projects: ProjectConfig[], options?: MultiProjectClientOptions);
+    /**
+     * Connect to all project daemons
+     */
+    connect(): Promise<void>;
+    /**
+     * Connect to a single project daemon
+     */
+    private connectToProject;
+    /**
+     * Send HELLO to a project daemon
+     */
+    private sendHello;
+    /**
+     * Handle incoming data from a project connection
+     */
+    private handleData;
+    /**
+     * Process a frame from a project daemon
+     */
+    private processFrame;
+    /**
+     * Handle delivered message from a project
+     */
+    private handleDeliver;
+    /**
+     * Send envelope to a project daemon
+     */
+    private send;
+    /**
+     * Send message to a project
+     * @param projectId - Target project ID
+     * @param to - Agent name within the project (or '*' for broadcast, 'lead' for project lead)
+     * @param body - Message body
+     */
+    sendToProject(projectId: string, to: string, body: string): boolean;
+    /**
+     * Broadcast to all leads
+     */
+    broadcastToLeads(body: string): void;
+    /**
+     * Broadcast to all agents in all projects
+     */
+    broadcastAll(body: string): void;
+    /**
+     * Register a lead for a project
+     */
+    registerLead(projectId: string, leadName: string): void;
+    /**
+     * Get all connected projects
+     */
+    getConnectedProjects(): string[];
+    /**
+     * Get project connection info
+     */
+    getProject(projectId: string): ProjectConfig | undefined;
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     */
+    private scheduleReconnect;
+    /**
+     * Attempt to reconnect to a project daemon
+     */
+    private attemptReconnect;
+    /**
+     * Disconnect from all projects
+     */
+    disconnect(): void;
+}
+export {};
+//# sourceMappingURL=multi-project-client.d.ts.map