@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/service/workflow-service.ts

@@ -0,0 +1,393 @@
+/**
+ * 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,
+  RunStatus,
+  WorkflowMetadata,
+  WorkflowConfig,
+} from '../types';
+
+// Repository interfaces (abstraction for storage layer)
+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;
+}
+
+// Need NodeDefinition for addNode
+import type { NodeDefinition } from '../types';
+
+// ==================== Options Interfaces ====================
+
+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;
+}
+
+// Engine interface (abstraction for workflow execution)
+// Note: Unified run() handles both fresh start and resume from session
+// Note: pause is triggered internally by interrupts, not a manual operation
+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>;
+}
+
+// Engine factory type for creating new engine instances per run
+export type WorkflowEngineFactory = (
+  workflow: Workflow,
+  options?: RunOptions
+) => Pick<WorkflowEngine, 'run' | 'stop' | 'runWorkflow'>;
+
+// Session types
+export interface SessionInfo {
+  id: string;
+  title: string;
+  metadata: WorkflowSessionMetadata;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface WorkflowSessionMetadata {
+  type: 'workflow';
+  runId?: string;  // Legacy runId for compatibility
+  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';
+}
+
+// ==================== WorkflowService ====================
+
+export class WorkflowService {
+  constructor(
+    private workflowRepository: WorkflowRepository,
+    private engineFactory: WorkflowEngineFactory,
+    private 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[]>;
+    }
+  ) {}
+  
+  // ==================== Workflow CRUD ====================
+  
+  /**
+   * Create a new workflow from definition
+   */
+  async createWorkflow(
+    definition: WorkflowDefinition,
+    options?: CreateOptions
+  ): Promise<Workflow> {
+    // 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: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'> = {
+      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: string): Workflow | null {
+    // 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: string): Workflow | null {
+    return this.workflowRepository.getById(id);
+  }
+  
+  /**
+   * Get workflow by name
+   */
+  getWorkflowByName(name: string): Workflow | null {
+    return this.workflowRepository.getByName(name);
+  }
+  
+  /**
+   * List workflows with optional filters
+   */
+  listWorkflows(options?: ListOptions): Workflow[] {
+    return this.workflowRepository.list(options);
+  }
+  
+  /**
+   * Update an existing workflow
+   */
+  async updateWorkflow(
+    idOrName: string,
+    updates: WorkflowUpdates,
+    options?: { tags?: string[] }
+  ): Promise<Workflow> {
+    // 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: Partial<Workflow> = {
+      ...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: string): Promise<boolean> {
+    // 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: string | WorkflowDefinition,
+    input?: Record<string, any>,
+    options?: RunOptions
+  ): Promise<RunResult> {
+    // Resolve workflow
+    let workflow: Workflow | null = null;
+    let definition: WorkflowDefinition | null = 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: string,
+    input?: Record<string, any>,
+    options?: RunOptions
+  ): Promise<RunResult> {
+    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: string, reason?: string): Promise<void> {
+    const session = await this.sessionComponent?.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    
+    const metadata = session.metadata as WorkflowSessionMetadata;
+    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: string): Promise<SessionInfo | null> {
+    if (!this.sessionComponent) {
+      return null;
+    }
+    const session = await this.sessionComponent.get(sessionId);
+    return session ?? null;
+  }
+  
+  /**
+   * List workflow sessions
+   */
+  async listSessions(options?: { limit?: number; offset?: number }): Promise<SessionInfo[]> {
+    if (!this.sessionComponent?.list) {
+      return [];
+    }
+    return this.sessionComponent.list(options);
+  }
+  
+  /**
+   * Get messages from a workflow session
+   */
+  async getSessionMessages(sessionId: string): Promise<any[]> {
+    if (!this.sessionComponent) {
+      return [];
+    }
+    return this.sessionComponent.getMessages(sessionId);
+  }
+}

package/src/env/workflow/storage/index.ts

@@ -0,0 +1,28 @@
+/**
+ * @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,
+  type BunDatabase,
+} from './sqlite';
+
+// Workflow Repository
+export {
+  WorkflowRepository,
+  rowToWorkflow,
+  type WorkflowRow,
+  type ListWorkflowsOptions,
+  type UpdateWorkflowOptions,
+} from './workflow-repo';