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

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

@@ -0,0 +1,228 @@
+/**
+ * WorkflowService Tests - Session-based Design
+ */
+import { describe, it, expect, beforeEach, vi } from 'bun:test';
+import { WorkflowService } from "./workflow-service.js";
+import { MockWorkflowRepository, MockWorkflowEngine } from "../storage/mock-repositories.js";
+describe('WorkflowService', () => {
+    let workflowRepo;
+    let mockEngine;
+    let service;
+    const sampleDefinition = {
+        name: 'test-workflow',
+        version: '1.0',
+        description: 'A test workflow',
+        nodes: [
+            {
+                id: 'node1',
+                type: 'tool',
+                config: { tool: 'test-tool' },
+            },
+            {
+                id: 'node2',
+                type: 'tool',
+                config: { tool: 'test-tool-2' },
+                depends_on: ['node1'],
+            },
+        ],
+    };
+    beforeEach(() => {
+        workflowRepo = new MockWorkflowRepository();
+        mockEngine = new MockWorkflowEngine();
+        // Create engine factory that returns the mock engine
+        const engineFactory = (workflow) => {
+            mockEngine.setWorkflowName(workflow.name);
+            return mockEngine;
+        };
+        service = new WorkflowService(workflowRepo, engineFactory);
+    });
+    // ==================== Workflow CRUD Tests ====================
+    describe('createWorkflow', () => {
+        it('should create a workflow from definition', async () => {
+            const workflow = await service.createWorkflow(sampleDefinition);
+            expect(workflow).toBeDefined();
+            expect(workflow.name).toBe('test-workflow');
+            expect(workflow.version).toBe('1.0');
+            expect(workflow.definition).toEqual(sampleDefinition);
+            expect(workflow.id).toBeDefined();
+        });
+        it('should create workflow with tags from options', async () => {
+            const workflow = await service.createWorkflow(sampleDefinition, {
+                tags: ['test', 'example'],
+            });
+            expect(workflow.tags).toEqual(['test', 'example']);
+        });
+        it('should create workflow with metadata from options', async () => {
+            const workflow = await service.createWorkflow(sampleDefinition, {
+                metadata: { author: 'tester' },
+            });
+            expect(workflow.metadata.author).toBe('tester');
+        });
+        it('should throw error if workflow with same name exists', async () => {
+            await service.createWorkflow(sampleDefinition);
+            await expect(service.createWorkflow(sampleDefinition)).rejects.toThrow('Workflow already exists');
+        });
+        it('should allow creating workflow with force option to overwrite', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const updatedDef = { ...sampleDefinition, description: 'Updated' };
+            const workflow = await service.createWorkflow(updatedDef, { force: true });
+            expect(workflow.description).toBe('Updated');
+        });
+    });
+    describe('getWorkflow', () => {
+        it('should get workflow by id', async () => {
+            const created = await service.createWorkflow(sampleDefinition);
+            const workflow = service.getWorkflow(created.id);
+            expect(workflow).toBeDefined();
+            expect(workflow?.name).toBe('test-workflow');
+        });
+        it('should get workflow by name', () => {
+            service.createWorkflow(sampleDefinition);
+            const workflow = service.getWorkflow('test-workflow');
+            expect(workflow).toBeDefined();
+            expect(workflow?.id).toBeDefined();
+        });
+        it('should return null if workflow not found', () => {
+            const workflow = service.getWorkflow('nonexistent');
+            expect(workflow).toBeNull();
+        });
+    });
+    describe('listWorkflows', () => {
+        it('should list all workflows', async () => {
+            await service.createWorkflow(sampleDefinition);
+            await service.createWorkflow({
+                ...sampleDefinition,
+                name: 'workflow2',
+            });
+            const workflows = service.listWorkflows();
+            expect(workflows.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should filter workflows by tag', async () => {
+            await service.createWorkflow(sampleDefinition, { tags: ['test'] });
+            await service.createWorkflow({
+                ...sampleDefinition,
+                name: 'workflow2',
+            }, { tags: ['other'] });
+            const workflows = service.listWorkflows({ tag: 'test' });
+            expect(workflows.length).toBeGreaterThanOrEqual(1);
+            expect(workflows.every(w => w.tags.includes('test'))).toBe(true);
+        });
+        it('should support pagination with limit and offset', async () => {
+            for (let i = 0; i < 5; i++) {
+                await service.createWorkflow({
+                    ...sampleDefinition,
+                    name: `workflow${i}`,
+                });
+            }
+            const workflows = service.listWorkflows({ limit: 2, offset: 0 });
+            expect(workflows.length).toBeLessThanOrEqual(2);
+        });
+    });
+    describe('updateWorkflow', () => {
+        it('should update workflow definition', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const updatedDef = {
+                ...sampleDefinition,
+                nodes: [
+                    ...sampleDefinition.nodes,
+                    { id: 'new-node', type: 'tool', config: { tool: 'new-tool' } },
+                ],
+            };
+            const workflow = await service.updateWorkflow('test-workflow', {
+                definition: updatedDef,
+            });
+            expect(workflow.definition.nodes.length).toBe(3);
+        });
+        it('should update workflow tags', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const workflow = await service.updateWorkflow('test-workflow', {}, {
+                tags: ['updated', 'tags'],
+            });
+            expect(workflow.tags).toEqual(['updated', 'tags']);
+        });
+        it('should throw error if workflow not found', async () => {
+            await expect(service.updateWorkflow('nonexistent', { definition: sampleDefinition })).rejects.toThrow('Workflow not found');
+        });
+    });
+    describe('deleteWorkflow', () => {
+        it('should delete workflow by name', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const result = await service.deleteWorkflow('test-workflow');
+            expect(result).toBe(true);
+            expect(service.getWorkflow('test-workflow')).toBeNull();
+        });
+        it('should return false if workflow not found', async () => {
+            const result = await service.deleteWorkflow('nonexistent');
+            expect(result).toBe(false);
+        });
+    });
+    // ==================== Workflow Execution Tests (Session-based) ====================
+    describe('runWorkflow', () => {
+        it('should run workflow by definition', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const result = await service.runWorkflow(sampleDefinition);
+            expect(result).toBeDefined();
+            expect(result.sessionId || result.runId).toBeDefined();
+            expect(mockEngine.getCallsByMethod('runWorkflow')).toHaveLength(1);
+        });
+        it('should pass input to workflow run', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const result = await service.runWorkflow(sampleDefinition, {
+                key: 'value',
+            });
+            expect(result).toBeDefined();
+            const runCall = mockEngine.getCallsByMethod('runWorkflow')[0];
+            expect(runCall.args[1]).toBeDefined();
+        });
+        it('should run workflow by name', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const result = await service.runWorkflow('test-workflow');
+            expect(result).toBeDefined();
+            expect(result.sessionId || result.runId).toBeDefined();
+        });
+    });
+    describe('runWorkflowByName', () => {
+        it('should run workflow by name and return result', async () => {
+            await service.createWorkflow(sampleDefinition);
+            const result = await service.runWorkflowByName('test-workflow', { test: 'input' });
+            expect(result).toBeDefined();
+            expect(result.sessionId || result.runId).toBeDefined();
+            expect(mockEngine.getLastCall()?.method).toBe('runWorkflow');
+        });
+        it('should throw error if workflow not found', async () => {
+            await expect(service.runWorkflowByName('nonexistent')).rejects.toThrow('Workflow not found');
+        });
+    });
+    // ==================== Session-based Lifecycle Tests ====================
+    describe('Session-based Resume', () => {
+        it('should have engine factory that creates new engine for each resume', async () => {
+            await service.createWorkflow(sampleDefinition);
+            // Create a mock session component
+            const mockSessionComponent = {
+                create: vi.fn().mockResolvedValue({ id: 'workflow_test_123' }),
+                get: vi.fn().mockResolvedValue({
+                    id: 'workflow_test_123',
+                    metadata: {
+                        type: 'workflow',
+                        workflowName: 'test-workflow',
+                        status: 'paused',
+                    },
+                }),
+                update: vi.fn().mockResolvedValue(true),
+                addMessage: vi.fn().mockResolvedValue('msg_id'),
+                getMessages: vi.fn().mockResolvedValue([]),
+            };
+            // Create service with session component
+            const engineFactory = (workflow) => {
+                mockEngine.setWorkflowName(workflow.name);
+                return mockEngine;
+            };
+            const serviceWithSession = new WorkflowService(workflowRepo, engineFactory, mockSessionComponent);
+            // Run workflow first
+            const result = await serviceWithSession.runWorkflow('test-workflow');
+            // Verify engine was created
+            expect(mockEngine.getCallsByMethod('runWorkflow')).toHaveLength(1);
+        });
+    });
+});
+//# sourceMappingURL=workflow-service.test.js.map

package/dist/core/src/env/workflow/storage/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Workflow Storage Module
+ *
+ * Re-exports all storage components for the workflow component.
+ *
+ * Note: After session-based refactoring, workflow runs are now managed via SessionComponent.
+ * The workflows table is still used for storing workflow definitions.
+ */
+export { getDatabase, closeDatabase, initializeTables, getDatabasePath, resetDatabase, initDatabase, type BunDatabase, } from './sqlite';
+export { WorkflowRepository, rowToWorkflow, type WorkflowRow, type ListWorkflowsOptions, type UpdateWorkflowOptions, } from './workflow-repo';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/workflow/storage/index.js

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Workflow Storage Module
+ *
+ * Re-exports all storage components for the workflow component.
+ *
+ * Note: After session-based refactoring, workflow runs are now managed via SessionComponent.
+ * The workflows table is still used for storing workflow definitions.
+ */
+// SQLite database utilities
+export { getDatabase, closeDatabase, initializeTables, getDatabasePath, resetDatabase, initDatabase, } from "./sqlite.js";
+// Workflow Repository
+export { WorkflowRepository, rowToWorkflow, } from "./workflow-repo.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/workflow/storage/mock-repositories.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Mock Repositories for Testing
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * These mock repositories only handle workflow definitions.
+ */
+import type { Workflow, WorkflowRun, RunStatus } from '../types';
+export interface MockRunRepositoryOptions {
+    workflowId?: string;
+    workflowName?: string;
+}
+export declare class MockRunRepository {
+    private runs;
+    private options;
+    constructor(options?: MockRunRepositoryOptions);
+    setWorkflowInfo(workflowId: string, workflowName: string): void;
+    createWorkflowRun(run: Omit<WorkflowRun, 'id'>): WorkflowRun;
+    getWorkflowRun(id: string): WorkflowRun | null;
+    listWorkflowRuns(workflowId?: string, options?: {
+        status?: RunStatus;
+    }): WorkflowRun[];
+    updateWorkflowRun(id: string, updates: Partial<WorkflowRun>): WorkflowRun | null;
+    clear(): void;
+    count(): number;
+    setWorkflowName(name: string): void;
+}
+export declare class MockWorkflowRepository {
+    private workflows;
+    private nameIndex;
+    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow;
+    getById(id: string): Workflow | null;
+    getByName(name: string): Workflow | null;
+    list(options?: {
+        tag?: string;
+        limit?: number;
+        offset?: number;
+    }): Workflow[];
+    update(id: string, updates: Partial<Workflow>): Workflow | null;
+    delete(id: string): boolean;
+    exists(name: string): boolean;
+    clear(): void;
+    count(): number;
+}
+export interface MockEngineCall {
+    method: string;
+    args: any[];
+    result?: any;
+    timestamp: number;
+}
+export type MockEngineFactory = () => MockWorkflowEngine;
+export declare class MockWorkflowEngine {
+    calls: MockEngineCall[];
+    private sessionResults;
+    private workflowName;
+    constructor();
+    setWorkflowName(name: string): void;
+    getWorkflowName(): string;
+    createSession(workflowId: string, options?: {
+        input?: Record<string, any>;
+        workflowName?: string;
+        workflowVersion?: string;
+    }): Promise<string>;
+    createRun(workflowNameOrDefinition: string | any, options?: {
+        input?: Record<string, any>;
+        debug?: boolean;
+    }): Promise<string>;
+    run(runId: string, options?: any): Promise<any>;
+    runWorkflow(workflow: any, options?: any): Promise<any>;
+    pause(sessionId: string): Promise<void>;
+    resume(sessionId: string, options?: {
+        userResponse?: string;
+        pendingNodeId?: string;
+        agentSessionId?: string;
+    }): Promise<any>;
+    stop(sessionId: string, reason?: string): Promise<void>;
+    addNode(sessionId: string, nodeDefinition: any): Promise<void>;
+    removeNode(sessionId: string, nodeId: string): Promise<void>;
+    clearCalls(): void;
+    getLastCall(): MockEngineCall | undefined;
+    getCallsByMethod(method: string): MockEngineCall[];
+}
+export declare class MockNodeRegistry {
+    private nodes;
+    register(type: string, factory: any): void;
+    get(type: string): any;
+    has(type: string): boolean;
+    list(): string[];
+}
+//# sourceMappingURL=mock-repositories.d.ts.map

package/dist/core/src/env/workflow/storage/mock-repositories.js

@@ -0,0 +1,286 @@
+/**
+ * Mock Repositories for Testing
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * These mock repositories only handle workflow definitions.
+ */
+export class MockRunRepository {
+    runs = new Map();
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    setWorkflowInfo(workflowId, workflowName) {
+        this.options.workflowId = workflowId;
+        this.options.workflowName = workflowName;
+    }
+    createWorkflowRun(run) {
+        const id = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const created = {
+            ...run,
+            id,
+        };
+        this.runs.set(id, created);
+        return created;
+    }
+    getWorkflowRun(id) {
+        return this.runs.get(id) || null;
+    }
+    listWorkflowRuns(workflowId, options) {
+        let runs = Array.from(this.runs.values());
+        if (workflowId) {
+            runs = runs.filter(r => r.workflowId === workflowId);
+        }
+        if (options?.status) {
+            runs = runs.filter(r => r.status === options.status);
+        }
+        // Sort by startedAt descending
+        runs.sort((a, b) => {
+            const aTime = a.startedAt?.getTime() || 0;
+            const bTime = b.startedAt?.getTime() || 0;
+            return bTime - aTime;
+        });
+        return runs;
+    }
+    updateWorkflowRun(id, updates) {
+        const existing = this.runs.get(id);
+        if (!existing)
+            return null;
+        const updated = {
+            ...existing,
+            ...updates,
+        };
+        this.runs.set(id, updated);
+        return updated;
+    }
+    // Helper for testing
+    clear() {
+        this.runs.clear();
+    }
+    count() {
+        return this.runs.size;
+    }
+    // Helper for MockWorkflowEngine
+    setWorkflowName(name) {
+        this.options.workflowName = name;
+    }
+}
+// ==================== Mock WorkflowRepository ====================
+export class MockWorkflowRepository {
+    workflows = new Map();
+    nameIndex = new Map(); // name -> id
+    create(workflow) {
+        const id = `wf_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const now = new Date();
+        const created = {
+            ...workflow,
+            id,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.workflows.set(id, created);
+        this.nameIndex.set(created.name, id);
+        return created;
+    }
+    getById(id) {
+        return this.workflows.get(id) || null;
+    }
+    getByName(name) {
+        const id = this.nameIndex.get(name);
+        return id ? this.workflows.get(id) || null : null;
+    }
+    list(options) {
+        let workflows = Array.from(this.workflows.values());
+        if (options?.tag) {
+            workflows = workflows.filter(w => w.tags.includes(options.tag));
+        }
+        // Sort by updatedAt descending
+        workflows.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+        if (options?.offset) {
+            workflows = workflows.slice(options.offset);
+        }
+        if (options?.limit) {
+            workflows = workflows.slice(0, options.limit);
+        }
+        return workflows;
+    }
+    update(id, updates) {
+        const existing = this.workflows.get(id);
+        if (!existing)
+            return null;
+        const updated = {
+            ...existing,
+            ...updates,
+            id, // Ensure ID doesn't change
+            updatedAt: new Date(),
+        };
+        // Update name index if name changed
+        if (updates.name && updates.name !== existing.name) {
+            this.nameIndex.delete(existing.name);
+            this.nameIndex.set(updated.name, id);
+        }
+        this.workflows.set(id, updated);
+        return updated;
+    }
+    delete(id) {
+        const workflow = this.workflows.get(id);
+        if (!workflow)
+            return false;
+        this.workflows.delete(id);
+        this.nameIndex.delete(workflow.name);
+        return true;
+    }
+    exists(name) {
+        return this.nameIndex.has(name);
+    }
+    // Helper for testing
+    clear() {
+        this.workflows.clear();
+        this.nameIndex.clear();
+    }
+    // Helper to get count
+    count() {
+        return this.workflows.size;
+    }
+}
+export class MockWorkflowEngine {
+    calls = [];
+    sessionResults = new Map();
+    workflowName = '';
+    constructor() {
+        // No longer takes runRepository parameter
+    }
+    setWorkflowName(name) {
+        this.workflowName = name;
+    }
+    getWorkflowName() {
+        return this.workflowName;
+    }
+    async createSession(workflowId, options) {
+        this.calls.push({
+            method: 'createSession',
+            args: [workflowId, options],
+            timestamp: Date.now(),
+        });
+        const sessionId = `workflow_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        this.sessionResults.set(sessionId, {
+            status: 'running',
+            output: null,
+        });
+        return sessionId;
+    }
+    async createRun(workflowNameOrDefinition, options) {
+        this.calls.push({
+            method: 'createRun',
+            args: [workflowNameOrDefinition, options],
+            timestamp: Date.now(),
+        });
+        const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        this.sessionResults.set(runId, {
+            status: 'idle',
+            output: null,
+        });
+        return runId;
+    }
+    async run(runId, options) {
+        this.calls.push({
+            method: 'run',
+            args: [runId, options],
+            timestamp: Date.now(),
+        });
+        const isSync = options?.sync ?? true;
+        this.sessionResults.set(runId, {
+            status: isSync ? 'completed' : 'running',
+            output: { result: 'mocked' },
+        });
+        return {
+            runId,
+            status: isSync ? 'completed' : 'running',
+            output: { result: 'mocked' },
+        };
+    }
+    async runWorkflow(workflow, options) {
+        this.calls.push({
+            method: 'runWorkflow',
+            args: [workflow, options],
+            timestamp: Date.now(),
+        });
+        const isSync = options?.sync ?? true;
+        const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        return {
+            runId,
+            sessionId: runId,
+            status: isSync ? 'completed' : 'running',
+            output: { result: 'mocked' },
+        };
+    }
+    async pause(sessionId) {
+        this.calls.push({
+            method: 'pause',
+            args: [sessionId],
+            timestamp: Date.now(),
+        });
+        this.sessionResults.set(sessionId, { status: 'paused' });
+    }
+    async resume(sessionId, options) {
+        this.calls.push({
+            method: 'resume',
+            args: [sessionId, options],
+            timestamp: Date.now(),
+        });
+        this.sessionResults.set(sessionId, { status: 'running' });
+        return {
+            sessionId,
+            status: 'running',
+        };
+    }
+    async stop(sessionId, reason) {
+        this.calls.push({
+            method: 'stop',
+            args: [sessionId, reason],
+            timestamp: Date.now(),
+        });
+        this.sessionResults.set(sessionId, { status: 'stopped' });
+    }
+    async addNode(sessionId, nodeDefinition) {
+        this.calls.push({
+            method: 'addNode',
+            args: [sessionId, nodeDefinition],
+            timestamp: Date.now(),
+        });
+    }
+    async removeNode(sessionId, nodeId) {
+        this.calls.push({
+            method: 'removeNode',
+            args: [sessionId, nodeId],
+            timestamp: Date.now(),
+        });
+    }
+    // Helper for testing
+    clearCalls() {
+        this.calls = [];
+    }
+    getLastCall() {
+        return this.calls[this.calls.length - 1];
+    }
+    getCallsByMethod(method) {
+        return this.calls.filter(c => c.method === method);
+    }
+}
+// ==================== Mock NodeRegistry ====================
+export class MockNodeRegistry {
+    nodes = new Map();
+    register(type, factory) {
+        this.nodes.set(type, factory);
+    }
+    get(type) {
+        return this.nodes.get(type);
+    }
+    has(type) {
+        return this.nodes.has(type);
+    }
+    list() {
+        return Array.from(this.nodes.keys());
+    }
+}
+//# sourceMappingURL=mock-repositories.js.map

package/dist/core/src/env/workflow/storage/sqlite.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview SQLite Storage for Workflow Component
+ *
+ * Uses Bun's built-in bun:sqlite module for persistence.
+ *
+ * 存储路径：~/.local/share/roy-agent/workflows.db
+ *
+ * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
+ * Only the workflows table is used here for storing workflow definitions.
+ */
+/**
+ * Get the database file path
+ * Default: ~/.local/share/roy-agent/workflows.db
+ */
+export declare function getDatabasePath(): string;
+/**
+ * Get the singleton database instance
+ * @param path - Optional custom database path. If not provided, uses default path.
+ *               Use ':memory:' for in-memory database (testing)
+ */
+export declare function getDatabase(path?: string): any;
+/**
+ * Close the database connection
+ */
+export declare function closeDatabase(): void;
+export type BunDatabase = {
+    exec(sql: string): void;
+    query<T>(sql: string): {
+        all(): T[];
+        get(...params: any[]): T | null;
+    };
+    run(sql: string, ...params: any[]): {
+        lastInsertRowid: number;
+        changes: number;
+    };
+    close(): void;
+    pragma?: (sql: string) => void;
+};
+/**
+ * Initialize all required tables
+ *
+ * Note: Only workflows table is created. Workflow runs are managed via SessionComponent
+ * using the session/message storage, following the session-based design.
+ */
+export declare function initializeTables(): void;
+/**
+ * Reset the database instance (for testing purposes)
+ * This is useful for tests that need a fresh database
+ */
+export declare function resetDatabase(): void;
+/**
+ * Initialize tables and return a ready database
+ * This is a convenience function that combines getDatabase and initializeTables
+ */
+export declare function initDatabase(path?: string): any;
+//# sourceMappingURL=sqlite.d.ts.map