registerSession method

void registerSession(SessionLifecycle lifecycle)

Register session lifecycle callbacks.

Implementation

void registerSession(SessionLifecycle lifecycle) {
  if (lifecycle.onSessionStart != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:session:start',
        type: HookType.onSessionStart,
        priority: HookPriority.normal,
        name: 'Session Start Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = SessionStartedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            workingDirectory: context.metadata['workingDirectory'] as String?,
            profile: context.metadata['profile'] as String?,
            isResume: context.metadata['isResume'] as bool? ?? false,
          );
          await lifecycle.onSessionStart!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onSessionEnd != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:session:end',
        type: HookType.onSessionEnd,
        priority: HookPriority.normal,
        name: 'Session End Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = SessionEndedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            reason: context.metadata['reason'] as String? ?? 'unknown',
            duration:
                context.metadata['duration'] as Duration? ?? Duration.zero,
            totalTokens: context.metadata['totalTokens'] as int? ?? 0,
            estimatedCost:
                context.metadata['estimatedCost'] as double? ?? 0.0,
          );
          await lifecycle.onSessionEnd!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onSessionPause != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:session:pause',
        type: HookType.onSessionEnd, // Reuse session-end with metadata flag
        priority: HookPriority.normal,
        name: 'Session Pause Lifecycle',
        source: 'lifecycle',
        matcher: (context) => context.metadata['isPause'] == true,
        asyncHandler: (context) async {
          final event = SessionPausedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            reason: context.metadata['reason'] as String?,
          );
          await lifecycle.onSessionPause!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onSessionResume != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:session:resume',
        type: HookType.onSessionStart, // Reuse with metadata flag
        priority: HookPriority.normal,
        name: 'Session Resume Lifecycle',
        source: 'lifecycle',
        matcher: (context) => context.metadata['isResume'] == true,
        asyncHandler: (context) async {
          final event = SessionResumedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            pauseDuration:
                context.metadata['pauseDuration'] as Duration? ??
                Duration.zero,
          );
          await lifecycle.onSessionResume!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }
}