@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/workflow/service/registry.test.js

@@ -0,0 +1,90 @@
+/**
+ * Registry Tests
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { WorkflowServiceRegistry, registerWorkflowService, getWorkflowService } from "./registry.js";
+import { WorkflowService } from "./workflow-service.js";
+import { MockWorkflowRepository, MockRunRepository, MockWorkflowEngine } from "../storage/mock-repositories.js";
+describe('WorkflowServiceRegistry', () => {
+    let mockEngine;
+    beforeEach(() => {
+        // Reset registry before each test
+        WorkflowServiceRegistry.getInstance().reset();
+        mockEngine = new MockWorkflowEngine();
+    });
+    const createService = () => new WorkflowService(new MockWorkflowRepository(), new MockRunRepository(), (workflow, options) => mockEngine);
+    describe('getInstance', () => {
+        it('should return the same instance on multiple calls', () => {
+            const instance1 = WorkflowServiceRegistry.getInstance();
+            const instance2 = WorkflowServiceRegistry.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('register', () => {
+        it('should register a service', () => {
+            const registry = WorkflowServiceRegistry.getInstance();
+            const service = createService();
+            registry.register(service);
+            expect(registry.isRegistered()).toBe(true);
+        });
+    });
+    describe('get', () => {
+        it('should return the registered service', () => {
+            const registry = WorkflowServiceRegistry.getInstance();
+            const service = createService();
+            registry.register(service);
+            expect(registry.get()).toBe(service);
+        });
+        it('should throw error if no service registered', () => {
+            const registry = WorkflowServiceRegistry.getInstance();
+            expect(() => registry.get()).toThrow('WorkflowService is not registered');
+        });
+    });
+    describe('isRegistered', () => {
+        it('should return false if no service registered', () => {
+            const registry = WorkflowServiceRegistry.getInstance();
+            expect(registry.isRegistered()).toBe(false);
+        });
+        it('should return true after service is registered', () => {
+            const registry = WorkflowServiceRegistry.getInstance();
+            const service = new WorkflowService(new MockWorkflowRepository(), new MockRunRepository(), mockEngine);
+            registry.register(service);
+            expect(registry.isRegistered()).toBe(true);
+        });
+    });
+    describe('reset', () => {
+        it('should reset the registry', () => {
+            const registry = WorkflowServiceRegistry.getInstance();
+            const service = createService();
+            registry.register(service);
+            registry.reset();
+            expect(registry.isRegistered()).toBe(false);
+        });
+    });
+});
+describe('convenience functions', () => {
+    let mockEngine;
+    beforeEach(() => {
+        WorkflowServiceRegistry.getInstance().reset();
+        mockEngine = new MockWorkflowEngine();
+    });
+    const createService = () => new WorkflowService(new MockWorkflowRepository(), new MockRunRepository(), (workflow, options) => mockEngine);
+    describe('registerWorkflowService', () => {
+        it('should register service via convenience function', () => {
+            const service = createService();
+            registerWorkflowService(service);
+            expect(WorkflowServiceRegistry.getInstance().isRegistered()).toBe(true);
+        });
+    });
+    describe('getWorkflowService', () => {
+        it('should get service via convenience function', () => {
+            const service = createService();
+            registerWorkflowService(service);
+            expect(getWorkflowService()).toBe(service);
+        });
+        it('should throw if service not registered', () => {
+            expect(() => getWorkflowService()).toThrow('WorkflowService is not registered');
+        });
+    });
+});
+//# sourceMappingURL=registry.test.js.map

package/dist/core/src/env/workflow/service/workflow-service.d.ts

@@ -0,0 +1,162 @@
+/**
+ * WorkflowService - Session-based Workflow Execution
+ *
+ * After session-based refactoring, workflow runs are managed via SessionComponent.
+ * The workflows table is still used for storing workflow definitions.
+ *
+ * Key concepts:
+ * - Session IS a workflow run (no separate runId concept)
+ * - Session.metadata stores workflow run state (status, input, agentSessions)
+ * - Session.messages stores node execution history with workflow.node.* roles
+ * - Resume is based on session state and messages
+ */
+import type { Workflow, WorkflowDefinition, RunOptions, RunResult, WorkflowMetadata, WorkflowConfig } from '../types';
+export interface WorkflowRepository {
+    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow;
+    getById(id: string): Workflow | null;
+    getByName(name: string): Workflow | null;
+    list(options?: ListOptions): Workflow[];
+    update(id: string, updates: Partial<Workflow>): Workflow | null;
+    delete(id: string): boolean;
+}
+import type { NodeDefinition } from '../types';
+export interface CreateOptions {
+    tags?: string[];
+    metadata?: WorkflowMetadata;
+    taskId?: number;
+    force?: boolean;
+}
+export interface ListOptions {
+    tag?: string;
+    taskId?: number;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface WorkflowUpdates {
+    definition?: WorkflowDefinition;
+    config?: WorkflowConfig;
+    tags?: string[];
+    metadata?: WorkflowMetadata;
+}
+export interface WorkflowEngine {
+    createSession(workflowId: string, options?: {
+        input?: Record<string, any>;
+        workflowName?: string;
+        workflowVersion?: string;
+    }): Promise<string>;
+    run(sessionId: string, options?: RunOptions): Promise<RunResult>;
+    runWorkflow(workflow: Workflow | WorkflowDefinition, options?: RunOptions): Promise<RunResult>;
+    stop(sessionId: string, reason?: string): Promise<void>;
+    addNode(sessionId: string, nodeDefinition: NodeDefinition): Promise<void>;
+    removeNode(sessionId: string, nodeId: string): Promise<void>;
+}
+export type WorkflowEngineFactory = (workflow: Workflow, options?: RunOptions) => Pick<WorkflowEngine, 'run' | 'stop' | 'runWorkflow'>;
+export interface SessionInfo {
+    id: string;
+    title: string;
+    metadata: WorkflowSessionMetadata;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface WorkflowSessionMetadata {
+    type: 'workflow';
+    runId?: string;
+    workflowId?: string;
+    workflowName: string;
+    workflowVersion?: string;
+    status: 'running' | 'paused' | 'completed' | 'failed';
+    input?: any;
+    rootNodeId?: string;
+    agentSessions?: AgentSessionRef[];
+}
+export interface AgentSessionRef {
+    nodeId: string;
+    sessionId: string;
+    status: 'active' | 'paused' | 'completed';
+}
+export declare class WorkflowService {
+    private workflowRepository;
+    private engineFactory;
+    private sessionComponent?;
+    constructor(workflowRepository: WorkflowRepository, engineFactory: WorkflowEngineFactory, sessionComponent?: {
+        create(options: {
+            id?: string;
+            title: string;
+            metadata: any;
+        }): Promise<{
+            id: string;
+        }>;
+        get(id: string): Promise<SessionInfo | null | undefined>;
+        list?(options?: {
+            limit?: number;
+            offset?: number;
+        }): Promise<SessionInfo[]>;
+        update(id: string, updates: {
+            metadata?: any;
+        }): Promise<boolean>;
+        addMessage(sessionId: string, message: any): Promise<string>;
+        getMessages(sessionId: string): Promise<any[]>;
+    });
+    /**
+     * Create a new workflow from definition
+     */
+    createWorkflow(definition: WorkflowDefinition, options?: CreateOptions): Promise<Workflow>;
+    /**
+     * Get workflow by id or name
+     */
+    getWorkflow(idOrName: string): Workflow | null;
+    /**
+     * Get workflow by id
+     */
+    getWorkflowById(id: string): Workflow | null;
+    /**
+     * Get workflow by name
+     */
+    getWorkflowByName(name: string): Workflow | null;
+    /**
+     * List workflows with optional filters
+     */
+    listWorkflows(options?: ListOptions): Workflow[];
+    /**
+     * Update an existing workflow
+     */
+    updateWorkflow(idOrName: string, updates: WorkflowUpdates, options?: {
+        tags?: string[];
+    }): Promise<Workflow>;
+    /**
+     * Delete a workflow by name or id
+     */
+    deleteWorkflow(idOrName: string): Promise<boolean>;
+    /**
+     * Run a workflow by definition or name
+     *
+     * This creates a Session that represents the workflow run.
+     * The Session ID is used as the run identifier for pause/resume.
+     */
+    runWorkflow(idOrNameOrDefinition: string | WorkflowDefinition, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
+    /**
+     * Run workflow by name (convenience method)
+     */
+    runWorkflowByName(name: string, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
+    /**
+     * Stop a running workflow session
+     */
+    stopRun(sessionId: string, reason?: string): Promise<void>;
+    /**
+     * Get workflow session by ID
+     */
+    getSession(sessionId: string): Promise<SessionInfo | null>;
+    /**
+     * List workflow sessions
+     */
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<SessionInfo[]>;
+    /**
+     * Get messages from a workflow session
+     */
+    getSessionMessages(sessionId: string): Promise<any[]>;
+}
+//# sourceMappingURL=workflow-service.d.ts.map

package/dist/core/src/env/workflow/service/workflow-service.js

@@ -0,0 +1,244 @@
+/**
+ * WorkflowService - Session-based Workflow Execution
+ *
+ * After session-based refactoring, workflow runs are managed via SessionComponent.
+ * The workflows table is still used for storing workflow definitions.
+ *
+ * Key concepts:
+ * - Session IS a workflow run (no separate runId concept)
+ * - Session.metadata stores workflow run state (status, input, agentSessions)
+ * - Session.messages stores node execution history with workflow.node.* roles
+ * - Resume is based on session state and messages
+ */
+// ==================== WorkflowService ====================
+export class WorkflowService {
+    workflowRepository;
+    engineFactory;
+    sessionComponent;
+    constructor(workflowRepository, engineFactory, sessionComponent) {
+        this.workflowRepository = workflowRepository;
+        this.engineFactory = engineFactory;
+        this.sessionComponent = sessionComponent;
+    }
+    // ==================== Workflow CRUD ====================
+    /**
+     * Create a new workflow from definition
+     */
+    async createWorkflow(definition, options) {
+        // Check if workflow with same name exists
+        const existing = this.workflowRepository.getByName(definition.name);
+        if (existing) {
+            if (options?.force !== true) {
+                throw new Error(`Workflow already exists: ${definition.name}`);
+            }
+            // Update existing workflow
+            return this.workflowRepository.update(existing.id, {
+                name: definition.name,
+                version: definition.version,
+                description: definition.description || existing.description,
+                definition,
+                config: definition.config || {},
+                metadata: {
+                    ...options.metadata || definition.metadata || existing.metadata || {},
+                    taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId,
+                },
+                tags: options.tags || definition.metadata?.tags || [],
+            });
+        }
+        // Create new workflow
+        const workflow = {
+            name: definition.name,
+            version: definition.version,
+            description: definition.description,
+            definition,
+            config: definition.config || {},
+            metadata: {
+                ...options?.metadata || definition.metadata || {},
+                taskId: options?.taskId || definition.metadata?.taskId,
+            },
+            tags: options?.tags || definition.metadata?.tags || [],
+        };
+        return this.workflowRepository.create(workflow);
+    }
+    /**
+     * Get workflow by id or name
+     */
+    getWorkflow(idOrName) {
+        // Try by id first
+        let workflow = this.workflowRepository.getById(idOrName);
+        if (workflow)
+            return workflow;
+        // Then try by name
+        return this.workflowRepository.getByName(idOrName);
+    }
+    /**
+     * Get workflow by id
+     */
+    getWorkflowById(id) {
+        return this.workflowRepository.getById(id);
+    }
+    /**
+     * Get workflow by name
+     */
+    getWorkflowByName(name) {
+        return this.workflowRepository.getByName(name);
+    }
+    /**
+     * List workflows with optional filters
+     */
+    listWorkflows(options) {
+        return this.workflowRepository.list(options);
+    }
+    /**
+     * Update an existing workflow
+     */
+    async updateWorkflow(idOrName, updates, options) {
+        // Find the workflow
+        let workflow = this.workflowRepository.getByName(idOrName);
+        if (!workflow) {
+            workflow = this.workflowRepository.getById(idOrName);
+        }
+        if (!workflow) {
+            throw new Error(`Workflow not found: ${idOrName}`);
+        }
+        const updateData = {
+            ...updates,
+        };
+        if (options?.tags !== undefined) {
+            updateData.tags = options.tags;
+        }
+        const updated = this.workflowRepository.update(workflow.id, updateData);
+        if (!updated) {
+            throw new Error(`Failed to update workflow: ${idOrName}`);
+        }
+        return updated;
+    }
+    /**
+     * Delete a workflow by name or id
+     */
+    async deleteWorkflow(idOrName) {
+        // Find the workflow
+        let workflow = this.workflowRepository.getByName(idOrName);
+        if (!workflow) {
+            workflow = this.workflowRepository.getById(idOrName);
+        }
+        if (!workflow) {
+            return false;
+        }
+        return this.workflowRepository.delete(workflow.id);
+    }
+    // ==================== Workflow Execution (Session-based) ====================
+    /**
+     * Run a workflow by definition or name
+     *
+     * This creates a Session that represents the workflow run.
+     * The Session ID is used as the run identifier for pause/resume.
+     */
+    async runWorkflow(idOrNameOrDefinition, input, options) {
+        // Resolve workflow
+        let workflow = null;
+        let definition = null;
+        if (typeof idOrNameOrDefinition === 'string') {
+            // Running by name - workflow must exist
+            workflow = this.getWorkflow(idOrNameOrDefinition);
+            if (!workflow) {
+                throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
+            }
+            definition = workflow.definition;
+        }
+        else {
+            // Running by definition - create inline workflow if needed
+            definition = idOrNameOrDefinition;
+            workflow = this.getWorkflowByName(definition.name);
+            // If workflow doesn't exist, create a temporary one for execution
+            if (!workflow) {
+                workflow = {
+                    id: `wf_inline_${definition.name}`,
+                    name: definition.name,
+                    version: definition.version,
+                    description: definition.description,
+                    definition,
+                    config: definition.config || {},
+                    metadata: definition.metadata || {},
+                    tags: definition.metadata?.tags || [],
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                };
+            }
+        }
+        // Create engine and run workflow directly
+        // Note: engine.runWorkflow() handles session creation and state management
+        const engine = this.engineFactory(workflow, {
+            ...options,
+            input,
+        });
+        // Run the workflow (this creates the session internally)
+        const result = await engine.runWorkflow(workflow, {
+            ...options,
+            input,
+        });
+        return {
+            ...result,
+            runId: result.runId || result.sessionId || '',
+            sessionId: result.sessionId || result.runId || '',
+        };
+    }
+    /**
+     * Run workflow by name (convenience method)
+     */
+    async runWorkflowByName(name, input, options) {
+        const workflow = this.getWorkflowByName(name);
+        if (!workflow) {
+            throw new Error(`Workflow not found: ${name}`);
+        }
+        return this.runWorkflow(name, input, options);
+    }
+    /**
+     * Stop a running workflow session
+     */
+    async stopRun(sessionId, reason) {
+        const session = await this.sessionComponent?.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const metadata = session.metadata;
+        if (metadata.type !== 'workflow') {
+            throw new Error(`Session is not a workflow session: ${sessionId}`);
+        }
+        const workflow = this.getWorkflowByName(metadata.workflowName);
+        if (!workflow) {
+            throw new Error(`Workflow not found: ${metadata.workflowName}`);
+        }
+        const engine = this.engineFactory(workflow);
+        await engine.stop(sessionId, reason);
+    }
+    /**
+     * Get workflow session by ID
+     */
+    async getSession(sessionId) {
+        if (!this.sessionComponent) {
+            return null;
+        }
+        const session = await this.sessionComponent.get(sessionId);
+        return session ?? null;
+    }
+    /**
+     * List workflow sessions
+     */
+    async listSessions(options) {
+        if (!this.sessionComponent?.list) {
+            return [];
+        }
+        return this.sessionComponent.list(options);
+    }
+    /**
+     * Get messages from a workflow session
+     */
+    async getSessionMessages(sessionId) {
+        if (!this.sessionComponent) {
+            return [];
+        }
+        return this.sessionComponent.getMessages(sessionId);
+    }
+}
+//# sourceMappingURL=workflow-service.js.map

package/dist/core/src/env/workflow/service/workflow-service.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * WorkflowService Tests - Session-based Design
+ */
+export {};
+//# sourceMappingURL=workflow-service.test.d.ts.map