@kiberon-labs/behave-graph-flow 1.0.0 → 2.0.0

package/src/plugin/graphrunner/runner.ts

@@ -0,0 +1,358 @@
+import type { System } from '../../system/system';
+import type { StoreApi } from 'zustand';
+import type { GraphRunnerClientStore } from './store';
+import { GraphRunnerClient } from './client';
+import { buildUIGraphJSON } from '../../transformers/Uigraph';
+import { setupClientEventListeners } from './actions';
+
+declare module '@/system/system' {
+  interface System {
+    runner: GraphRunner;
+  }
+}
+
+export class GraphRunner {
+  private system: System;
+  public readonly store: StoreApi<GraphRunnerClientStore>;
+
+  constructor(system: System, store: StoreApi<GraphRunnerClientStore>) {
+    this.system = system;
+    this.store = store;
+  }
+
+  /**
+   * Connect to the graph runner server
+   */
+  async connect(): Promise<void> {
+    const {
+      client,
+      connectionConfig,
+      setClient,
+      setConnectionState,
+      setConnectionInfo,
+      setError,
+      clearServerMetadata,
+      addMessageActivity
+    } = this.store.getState();
+
+    try {
+      setError(null);
+      setConnectionState('connecting');
+
+      const theClient =
+        client ??
+        new GraphRunnerClient({
+          url: connectionConfig.url,
+          auth: connectionConfig.auth,
+          autoReconnect: connectionConfig.autoReconnect,
+          onMessageActivity: (direction, message) => {
+            addMessageActivity(direction, message);
+          }
+        });
+
+      setClient(theClient);
+
+      await theClient.connect();
+
+      // Setup persistent event listeners for trace, logs, and run completion
+      setupClientEventListeners(theClient, this.system, this.store);
+
+      setConnectionState('connected');
+      setConnectionInfo({
+        serverId: theClient.getServerId(),
+        userId: theClient.getUserId(),
+        sessionId: null,
+        authenticated: theClient.isAuthenticated(),
+        capabilities: null
+      });
+
+      // Create session
+      const sessionId = await theClient.createSession();
+      setConnectionInfo({ sessionId });
+
+      // Get capabilities
+      const capabilities = await theClient.getCapabilities();
+      setConnectionInfo({ capabilities });
+
+      // Fetch metadata if supported
+      if (capabilities.runtimeMetadata) {
+        await this.refreshMetadata();
+      }
+
+      // Notify successful connection
+      this.system.notifications.success(
+        `Connected to ${theClient.getServerId() || 'graph runner server'}`
+      );
+    } catch (error) {
+      setConnectionState('disconnected');
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      setError(errorMessage);
+      setClient(null);
+      clearServerMetadata();
+
+      // Notify connection error
+      this.system.notifications.error(`Failed to connect: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Disconnect from the graph runner server
+   */
+  async disconnect(): Promise<void> {
+    const {
+      client,
+      setClient,
+      setConnectionState,
+      setConnectionInfo,
+      clearServerMetadata
+    } = this.store.getState();
+
+    console.log('Disconnecting from graph runner server...');
+    if (client) {
+      try {
+        await client.closeSession();
+        client.disconnect();
+      } catch (error) {
+        console.error('Error disconnecting:', error);
+      }
+    }
+
+    setClient(null);
+    setConnectionState('disconnected');
+    setConnectionInfo({
+      serverId: null,
+      userId: null,
+      sessionId: null,
+      authenticated: false,
+      capabilities: null
+    });
+    clearServerMetadata();
+  }
+
+  /**
+   * Refresh server metadata (variables, events, node types)
+   */
+  async refreshMetadata(): Promise<void> {
+    const {
+      client,
+      setServerVariables,
+      setServerEvents,
+      setNodeTypes,
+      setError
+    } = this.store.getState();
+    if (!client) {
+      return;
+    }
+
+    try {
+      const capabilities = client.getCachedCapabilities();
+      if (!capabilities?.runtimeMetadata) {
+        return;
+      }
+
+      const [variables, events, nodeTypes] = await Promise.all([
+        client.getServerVariables(),
+        client.getServerEvents(),
+        client.getNodeTypes()
+      ]);
+
+      setServerVariables(variables);
+      setServerEvents(events);
+      setNodeTypes(nodeTypes);
+
+      setError(null);
+    } catch (error) {
+      setError(error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  /**
+   * Run a graph remotely
+   */
+  async runRemotely(
+    graphId: string,
+    options?: { graph?: unknown; inputs?: unknown }
+  ): Promise<void> {
+    const {
+      client,
+      setCurrentRunId,
+      setCurrentGraphId,
+      setIsExecuting,
+      setIsPaused,
+      isExecuting,
+      enableTracing
+    } = this.store.getState();
+
+    if (!client) {
+      this.system.notifications.error('No graph runner connection');
+      throw new Error('No graph runner connection');
+    }
+    //already running
+    if (isExecuting) {
+      return;
+    }
+
+    try {
+      const runId = await client.runGraph(graphId, {
+        ...options,
+        trace: enableTracing
+      });
+
+      setCurrentRunId(runId);
+      setCurrentGraphId(graphId);
+      setIsExecuting(true);
+      setIsPaused(false);
+
+      this.system.notifications.info(`Graph execution started: ${graphId}`);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      setIsPaused(false);
+      this.system.notifications.error(`Failed to run graph: ${errorMessage}`);
+      setIsExecuting(false);
+      setCurrentRunId(null);
+      setCurrentGraphId(null);
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the current graph execution
+   */
+  async stop(): Promise<void> {
+    const {
+      client,
+      currentRunId,
+      setIsExecuting,
+      setCurrentRunId,
+      setCurrentGraphId,
+      setIsPaused
+    } = this.store.getState();
+
+    if (!client || !currentRunId) {
+      return;
+    }
+
+    try {
+      await client.stopGraph(currentRunId);
+      this.system.notifications.info('Stopping graph execution');
+      setIsExecuting(false);
+      setCurrentRunId(null);
+      setCurrentGraphId(null);
+      setIsPaused(false);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.system.notifications.error(`Failed to stop graph: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Play the current graph
+   */
+  async play(): Promise<void> {
+    const { clearLogsOnRun, clearTracesOnRun } = this.store.getState();
+
+    // Clear logs if enabled
+    if (clearLogsOnRun) {
+      this.system.logsStore.getState().clear();
+    }
+
+    // Clear traces if enabled
+    if (clearTracesOnRun) {
+      this.system.traceStore.getState().clear();
+    }
+
+    const graphId = 'current';
+    const uiGraphData = buildUIGraphJSON(this.system);
+    const graphData = uiGraphData.flow;
+
+    try {
+      await this.runRemotely(graphId, { graph: graphData });
+    } catch {
+      // Error already handled in runRemotely
+    }
+  }
+
+  /**
+   * Pause the current graph execution
+   */
+  async pause(): Promise<void> {
+    const { client, currentRunId, setIsPaused } = this.store.getState();
+
+    if (!client || !currentRunId) {
+      return;
+    }
+
+    try {
+      // Check if the client's transport is LocalTransport with pause support
+      const transport = (client as any).transport;
+      if (transport && typeof transport.pauseExecution === 'function') {
+        transport.pauseExecution(currentRunId);
+        setIsPaused(true);
+        this.system.notifications.info('Execution paused');
+      } else {
+        // Fallback to stop for remote transports
+        await this.stop();
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.system.notifications.error(`Failed to pause graph: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Resume paused execution
+   */
+  async resume(): Promise<void> {
+    const { client, currentRunId, setIsPaused } = this.store.getState();
+
+    if (!client || !currentRunId) {
+      return;
+    }
+
+    try {
+      const transport = (client as any).transport;
+      if (transport && typeof transport.resumeExecution === 'function') {
+        setIsPaused(false);
+        this.system.notifications.info('Resuming execution');
+        await transport.resumeExecution(currentRunId);
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.system.notifications.error(
+        `Failed to resume graph: ${errorMessage}`
+      );
+    }
+  }
+
+  /**
+   * Execute one step forward
+   */
+  async step(): Promise<void> {
+    const { client, currentRunId, setIsPaused } = this.store.getState();
+
+    if (!client || !currentRunId) {
+      return;
+    }
+
+    try {
+      const transport = (client as any).transport;
+      if (transport && typeof transport.stepExecution === 'function') {
+        setIsPaused(true); // Ensure we stay paused after stepping
+        await transport.stepExecution(currentRunId);
+      } else {
+        this.system.notifications.info(
+          'Step execution not supported for this transport'
+        );
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.system.notifications.error(`Failed to step graph: ${errorMessage}`);
+    }
+  }
+}

package/src/plugin/graphrunner/session.ts

@@ -0,0 +1,243 @@
+/**
+ * Session management for local graph runner
+ * Allows customization of execution context and configuration per session
+ */
+
+import type { IRegistry } from '@kiberon-labs/behave-graph';
+import type {
+  GraphRunnerCapabilities,
+  EventFilter
+} from '../graphrunner/types.js';
+
+/**
+ * Session configuration for graph execution
+ */
+export interface SessionConfig {
+  /** Custom metadata attached to the session */
+  metadata?: Record<string, unknown>;
+  /** Default execution options for all runs in this session */
+  defaultExecutionOptions?: {
+    autoEnd?: boolean;
+    trace?: boolean;
+    eventFilter?: EventFilter;
+    maxExecutionTimeMs?: number;
+  };
+  /** Session-level execution settings */
+  executionSettings?: {
+    /** Delay between execution steps in milliseconds */
+    stepDelay?: number;
+    /** Execution speed multiplier (0.1 to 2.0) */
+    executionSpeed?: number;
+    /** Interval between tick events in milliseconds */
+    tickInterval?: number;
+    /** Maximum number of concurrent runs allowed */
+    maxConcurrentRuns?: number;
+  };
+  /** Custom hook for handling tick timing/delays */
+  tickStrategy?: () => Promise<void>;
+  /** Custom registry overrides for this session */
+  registryOverrides?: Partial<IRegistry>;
+  /** Session lifecycle hooks */
+  hooks?: SessionHooks;
+  /** Session-specific capabilities override */
+  capabilities?: Partial<GraphRunnerCapabilities>;
+}
+
+/**
+ * Lifecycle hooks for session events
+ */
+export interface SessionHooks {
+  /** Called when the session is created */
+  onSessionCreated?: (session: Session) => void | Promise<void>;
+  /** Called when a run starts in this session */
+  onRunStarted?: (
+    session: Session,
+    runId: string,
+    graphId: string
+  ) => void | Promise<void>;
+  /** Called when a run completes in this session */
+  onRunCompleted?: (
+    session: Session,
+    runId: string,
+    graphId: string,
+    result: unknown
+  ) => void | Promise<void>;
+  /** Called when a run fails in this session */
+  onRunError?: (
+    session: Session,
+    runId: string,
+    graphId: string,
+    error: Error
+  ) => void | Promise<void>;
+  /** Called when the session is closed */
+  onSessionClosed?: (session: Session) => void | Promise<void>;
+}
+
+/**
+ * Session state
+ */
+export interface Session {
+  /** Unique session identifier */
+  readonly sessionId: string;
+  /** Session expiration timestamp */
+  readonly expiresAt: number;
+  /** Session creation timestamp */
+  readonly createdAt: number;
+  /** Session configuration */
+  readonly config: SessionConfig;
+  /** Active run IDs in this session */
+  readonly activeRuns: Set<string>;
+  /** Custom session state (user-definable) */
+  state: Record<string, unknown>;
+  /** Session metadata */
+  metadata: Record<string, unknown>;
+}
+
+/**
+ * Factory for creating sessions with custom configuration
+ */
+export interface SessionFactory {
+  /**
+   * Create a new session with optional configuration
+   */
+  createSession(sessionId: string, config?: SessionConfig): Session;
+}
+
+/**
+ * Default session factory implementation
+ */
+export class DefaultSessionFactory implements SessionFactory {
+  private defaultConfig?: SessionConfig;
+
+  constructor(defaultConfig?: SessionConfig) {
+    this.defaultConfig = defaultConfig;
+  }
+
+  createSession(sessionId: string, config?: SessionConfig): Session {
+    const mergedConfig: SessionConfig = {
+      ...this.defaultConfig,
+      ...config,
+      metadata: {
+        ...this.defaultConfig?.metadata,
+        ...config?.metadata
+      },
+      defaultExecutionOptions: {
+        ...this.defaultConfig?.defaultExecutionOptions,
+        ...config?.defaultExecutionOptions
+      },
+      executionSettings: {
+        ...this.defaultConfig?.executionSettings,
+        ...config?.executionSettings
+      },
+      hooks: {
+        ...this.defaultConfig?.hooks,
+        ...config?.hooks
+      }
+    };
+
+    const session: Session = {
+      sessionId,
+      expiresAt: Date.now() + 24 * 60 * 60 * 1000, // 24 hours default
+      createdAt: Date.now(),
+      config: mergedConfig,
+      activeRuns: new Set(),
+      state: {},
+      metadata: mergedConfig.metadata ?? {}
+    };
+
+    // Call creation hook
+    if (mergedConfig.hooks?.onSessionCreated) {
+      void mergedConfig.hooks.onSessionCreated(session);
+    }
+
+    return session;
+  }
+}
+
+/**
+ * Session manager to track and manage multiple sessions
+ */
+export class SessionManager {
+  private sessions = new Map<string, Session>();
+  private sessionFactory: SessionFactory;
+
+  constructor(sessionFactory?: SessionFactory) {
+    this.sessionFactory = sessionFactory ?? new DefaultSessionFactory();
+  }
+
+  /**
+   * Create a new session
+   */
+  createSession(sessionId: string, config?: SessionConfig): Session {
+    const session = this.sessionFactory.createSession(sessionId, config);
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+
+  /**
+   * Get an existing session
+   */
+  getSession(sessionId: string): Session | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Check if a session exists
+   */
+  hasSession(sessionId: string): boolean {
+    return this.sessions.has(sessionId);
+  }
+
+  /**
+   * Close and remove a session
+   */
+  async closeSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      // Call close hook
+      if (session.config.hooks?.onSessionClosed) {
+        await session.config.hooks.onSessionClosed(session);
+      }
+      this.sessions.delete(sessionId);
+    }
+  }
+
+  /**
+   * Add a run to a session
+   */
+  addRunToSession(sessionId: string, runId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.activeRuns.add(runId);
+    }
+  }
+
+  /**
+   * Remove a run from a session
+   */
+  removeRunFromSession(sessionId: string, runId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.activeRuns.delete(runId);
+    }
+  }
+
+  /**
+   * Get all active sessions
+   */
+  getActiveSessions(): Session[] {
+    return Array.from(this.sessions.values());
+  }
+
+  /**
+   * Clean up expired sessions
+   */
+  cleanupExpiredSessions(): void {
+    const now = Date.now();
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (session.expiresAt < now) {
+        void this.closeSession(sessionId);
+      }
+    }
+  }
+}