@pellux/goodvibes-tui 0.18.4

package/src/runtime/bootstrap-core.ts

@@ -0,0 +1,375 @@
+import { ConversationManager } from '../core/conversation.ts';
+import { SelectionManager } from '../input/selection.ts';
+import { ConfigManager, getConfiguredSystemPrompt } from '../config/index.ts';
+import { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import { registerAllTools } from '../tools/index.ts';
+import { PermissionManager, createPermissionConfigReader } from '../permissions/manager.ts';
+import { Notifier } from '../integrations/notifier.ts';
+import { WebhookNotifier } from '../integrations/webhooks.ts';
+import { Compositor } from '../renderer/compositor.ts';
+import type { PermissionRequestHandler } from '../permissions/prompt.ts';
+import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import type { ConversationFollowUpItem } from '@pellux/goodvibes-sdk/platform/core/conversation-follow-ups';
+import type { ControlPlaneRecentEvent } from '../control-plane/gateway.ts';
+import type { BootstrapOptions, MutableRuntimeState } from './context.ts';
+import { createFeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/index';
+import { RuntimeEventBus } from './events/index.ts';
+import { createRuntimeStore, createDomainDispatch, type RuntimeStore } from './store/index.ts';
+import { ForensicsCollector, ForensicsRegistry } from './forensics/index.ts';
+import {
+  generateUserSessionId,
+} from './session-persistence.ts';
+import { loadBootstrapSystemPrompt, syncConfiguredServices } from './bootstrap-helpers.ts';
+import { registerBootstrapHookBridge } from './bootstrap-hook-bridge.ts';
+import { registerBootstrapRuntimeEvents } from './bootstrap-runtime-events.ts';
+import { createRuntimeServices, type RuntimeServices } from './services.ts';
+import { createUiRuntimeServices, type UiRuntimeServices } from './ui-services.ts';
+
+export interface BootstrapCoreState {
+  readonly userSessionId: string;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly store: RuntimeStore;
+  readonly services: RuntimeServices;
+  readonly uiServices: UiRuntimeServices;
+  readonly conversation: ConversationManager;
+  readonly compositor: Compositor;
+  readonly selection: SelectionManager;
+  readonly toolRegistry: ToolRegistry;
+  readonly fileCache: ReturnType<typeof registerAllTools>['fileCache'];
+  readonly projectIndex: ReturnType<typeof registerAllTools>['projectIndex'];
+  readonly permissionManager: PermissionManager;
+  readonly forensicsCollector: ForensicsCollector;
+  readonly forensicsRegistry: ForensicsRegistry;
+  readonly runtime: MutableRuntimeState;
+  readonly bootstrapUnsubs: Array<() => void>;
+  readonly runtimeUnsubs: Array<() => void>;
+  readonly agentStatusIntervalRef: { value: ReturnType<typeof setInterval> | null };
+  readonly permissionPromptRef: { requestPermission: PermissionRequestHandler };
+  readonly systemMessageRouterRef: { value: SystemMessageRouter | null };
+  readonly conversationFollowUpRef: { value: ((item: ConversationFollowUpItem) => void) | null };
+  readonly requestRender: () => void;
+  readonly setRenderRequest: (fn: () => void) => void;
+  readonly runtimeSessionIdRef: { value: string };
+}
+
+export async function initializeBootstrapCore(
+  stdout: NodeJS.WriteStream,
+  options: BootstrapOptions,
+  getControlPlaneRecentEvents: (limit: number) => readonly ControlPlaneRecentEvent[],
+): Promise<BootstrapCoreState> {
+  const workingDir = options.workingDir;
+  const homeDirectory = options.homeDirectory;
+  const configManager = options.configManager;
+
+  const featureFlags = createFeatureFlagManager();
+  featureFlags.loadFromConfig({
+    flags: (configManager.getCategory('featureFlags') as Record<string, import('@pellux/goodvibes-sdk/platform/runtime/feature-flags/types').FlagState>) ?? {},
+  });
+
+  const userSessionId = `user-${generateUserSessionId()}`;
+  const runtimeBus = new RuntimeEventBus();
+  const store = createRuntimeStore();
+  const domainDispatch = createDomainDispatch(store);
+  let getConversationTitle = (): string | undefined => undefined;
+  const services = createRuntimeServices({
+    configManager,
+    featureFlags,
+    runtimeBus,
+    runtimeStore: store,
+    getConversationTitle: () => getConversationTitle(),
+    workingDir,
+    homeDirectory,
+  });
+  const providerRegistry = services.providerRegistry;
+  providerRegistry.initModelLimits();
+  services.benchmarkStore.initBenchmarks();
+  providerRegistry.initCatalog();
+  services.keybindingsManager.loadFromDisk();
+  domainDispatch.syncControlPlaneState({
+    enabled: Boolean(configManager.get('controlPlane.enabled')),
+    host: String(configManager.get('controlPlane.host') ?? '127.0.0.1'),
+    port: Number(configManager.get('controlPlane.port') ?? 3421),
+    connectionState: configManager.get('controlPlane.enabled') ? 'connected' : 'disabled',
+    isRunning: Boolean(configManager.get('controlPlane.enabled')),
+  }, 'bootstrap.control-plane');
+  domainDispatch.syncControlPlaneClient({
+    id: 'client:tui',
+    kind: 'tui',
+    label: 'Terminal UI',
+    transport: 'local',
+    connected: true,
+    sessionId: userSessionId,
+    authenticatedAt: Date.now(),
+    lastSeenAt: Date.now(),
+    capabilities: ['session', 'panels', 'commands', 'automation'],
+    metadata: {},
+  }, 'bootstrap.control-plane');
+
+  const {
+    approvalBroker,
+    automationManager,
+    deliveryManager,
+    hookDispatcher,
+    hookWorkbench,
+    memoryStore,
+    panelManager,
+    routeBindings,
+    sessionBroker: sharedSessionBroker,
+    surfaceRegistry,
+    watcherRegistry,
+  } = services;
+
+  routeBindings.attachRuntime({ runtimeBus, runtimeStore: store });
+  surfaceRegistry.attachRuntime(store);
+  surfaceRegistry.syncConfiguredSurfaces();
+  watcherRegistry.attachRuntime({ runtimeBus, runtimeStore: store });
+  if (configManager.get('watchers.enabled')) {
+    watcherRegistry.registerPollingWatcher({
+      id: 'runtime-heartbeat',
+      label: 'Runtime heartbeat',
+      source: {
+        id: 'source:runtime-heartbeat',
+        kind: 'watcher',
+        label: 'Runtime heartbeat',
+        enabled: true,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        metadata: {},
+      },
+      intervalMs: Number(configManager.get('watchers.heartbeatIntervalMs') ?? 30_000),
+      run: () => new Date().toISOString(),
+    });
+    watcherRegistry.startWatcher('runtime-heartbeat');
+  }
+  automationManager.attachRuntime({ runtimeBus, runtimeStore: store, deliveryManager });
+
+  const forensicsRegistry = new ForensicsRegistry();
+  const forensicsCollector = new ForensicsCollector(runtimeBus, forensicsRegistry);
+  const policyRuntimeState = services.policyRuntimeState;
+  const uiServices = createUiRuntimeServices(services, {
+    forensicsRegistry,
+    getControlPlaneRecentEvents,
+  });
+
+  const conversation = new ConversationManager(() => {
+    const width = stdout.columns || 80;
+    if (panelManager.isVisible() && panelManager.getAllOpen().length > 0) {
+      return Math.max(1, panelManager.getLeftWidth(width) - 1);
+    }
+    return width;
+  });
+  conversation.setConfigManager(configManager);
+  getConversationTitle = () => conversation.title;
+
+  const compositor = new Compositor(stdout);
+  const selection = new SelectionManager();
+
+  const toolRegistry = new ToolRegistry();
+  const { fileCache, projectIndex } = registerAllTools(toolRegistry, {
+    fileUndoManager: services.fileUndoManager,
+    modeManager: services.modeManager,
+    processManager: services.processManager,
+    agentManager: services.agentManager,
+    agentMessageBus: services.agentMessageBus,
+    archetypeLoader: services.archetypeLoader,
+    wrfcController: services.wrfcController,
+    webSearchService: services.webSearchService,
+    channelRegistry: services.channelPlugins,
+    remoteRunnerRegistry: services.remoteRunnerRegistry,
+    workflowServices: services.workflow,
+    mcpRegistry: services.mcpRegistry,
+    sessionOrchestration: services.sessionOrchestration,
+    sandboxSessionRegistry: services.sandboxSessionRegistry,
+    workingDirectory: services.workingDirectory,
+    configManager,
+    providerRegistry: services.providerRegistry,
+    toolLLM: services.toolLLM,
+    featureFlags: services.featureFlags,
+    serviceRegistry: services.serviceRegistry,
+    overflowHandler: services.overflowHandler,
+    changeTracker: services.sessionChangeTracker,
+  });
+  services.agentOrchestrator.setDependencies({
+    fileCache,
+    projectIndex,
+    workingDirectory: services.workingDirectory,
+    fileUndoManager: services.fileUndoManager,
+    modeManager: services.modeManager,
+    processManager: services.processManager,
+    agentMessageBus: services.agentMessageBus,
+    webSearchService: services.webSearchService,
+    channelRegistry: services.channelPlugins,
+    remoteRunnerRegistry: services.remoteRunnerRegistry,
+    knowledgeService: services.knowledgeService,
+    archetypeLoader: services.archetypeLoader,
+    configManager,
+    providerRegistry: services.providerRegistry,
+    providerOptimizer: services.providerOptimizer,
+    toolLLM: services.toolLLM,
+    serviceRegistry: services.serviceRegistry,
+    sessionOrchestration: services.sessionOrchestration,
+    featureFlags: services.featureFlags,
+    overflowHandler: services.overflowHandler,
+    memoryRegistry: services.memoryRegistry,
+    sandboxSessionRegistry: services.sandboxSessionRegistry,
+    workflowServices: services.workflow,
+  });
+
+  const bootstrapUnsubs: Array<() => void> = [];
+  await memoryStore.init();
+  bootstrapUnsubs.push(() => {
+    void memoryStore.save();
+    memoryStore.close();
+  });
+
+  const renderRequestRef = { value: (): void => {} };
+  const requestRender = (): void => {
+    renderRequestRef.value();
+  };
+  const permissionPromptRef = {
+    requestPermission: (async () => ({ approved: false, remember: false })) as PermissionRequestHandler,
+  };
+  void approvalBroker.start();
+  void sharedSessionBroker.start();
+  const runtimeSessionIdRef = { value: userSessionId };
+  const systemMessageRouterRef: { value: SystemMessageRouter | null } = { value: null };
+  const conversationFollowUpRef: { value: ((item: ConversationFollowUpItem) => void) | null } = { value: null };
+  const { unsubs: runtimeUnsubs, agentStatusIntervalRef } = registerBootstrapRuntimeEvents({
+    runtimeBus,
+    domainDispatch,
+    getSystemMessageRouter: () => systemMessageRouterRef.value,
+    queueConversationFollowUp: (item) => conversationFollowUpRef.value?.(item),
+    requestRender,
+    configManager,
+    agentManager: services.agentManager,
+    wrfcController: services.wrfcController,
+  });
+
+  providerRegistry.startWatching(runtimeBus);
+
+  const webhookUrls = (configManager.getCategory('notifications') as { webhookUrls?: string[] }).webhookUrls ?? [];
+  if (webhookUrls.length > 0) {
+    const webhookNotifier = WebhookNotifier.fromConfig(webhookUrls);
+    webhookNotifier.attachToRuntimeBus(runtimeBus);
+    domainDispatch.syncIntegration({
+      id: 'webhooks',
+      displayName: 'Webhooks',
+      category: 'communication',
+      status: 'healthy',
+      enabled: true,
+      successCount: 0,
+      errorCount: 0,
+      meta: { urlCount: webhookUrls.length },
+    }, 'bootstrap.webhooks');
+  }
+
+  const notifier = await Notifier.fromConfig(services.serviceRegistry);
+  const queueStatuses = notifier.getQueueStatus();
+  if (queueStatuses.length > 0) {
+    notifier.attachToRuntimeBus(runtimeBus);
+    for (const queueStatus of queueStatuses) {
+      domainDispatch.syncIntegration({
+        id: queueStatus.channel,
+        displayName: queueStatus.channel[0]!.toUpperCase() + queueStatus.channel.slice(1),
+        category: 'communication',
+        status: queueStatus.metrics.deadLettered > 0 ? 'degraded' : 'healthy',
+        enabled: true,
+        successCount: queueStatus.metrics.delivered,
+        errorCount: queueStatus.metrics.deadLettered,
+        ...(queueStatus.dlqEntries[0]?.deadAt ? { lastErrorAt: queueStatus.dlqEntries[0].deadAt } : {}),
+        ...(queueStatus.dlqEntries[0]?.finalError ? { lastError: queueStatus.dlqEntries[0].finalError } : {}),
+        meta: {
+          attempts: queueStatus.metrics.totalAttempts,
+          retrying: queueStatus.metrics.retrying,
+          deadLetters: queueStatus.metrics.deadLettered,
+          dlqSize: queueStatus.metrics.dlqSize,
+          sloEnforced: queueStatus.sloEnforced,
+        },
+      }, 'bootstrap.notifier');
+    }
+  }
+
+  await syncConfiguredServices(domainDispatch.syncIntegration, services.serviceRegistry);
+
+  const permissionManager = new PermissionManager(
+    (request) => approvalBroker.requestApproval({
+      request,
+      sessionId: runtimeSessionIdRef.value,
+      localPrompt: permissionPromptRef.requestPermission,
+    }),
+    createPermissionConfigReader(configManager),
+    policyRuntimeState,
+    services.hookDispatcher,
+  );
+  await hookWorkbench.loadAndApplyManagedHooks();
+
+  const runtime: MutableRuntimeState = {
+    model: configManager.get('provider.model') as string,
+    provider: configManager.get('provider.provider') as string,
+    debugMode: false,
+    systemPrompt: loadBootstrapSystemPrompt(configManager) || getConfiguredSystemPrompt(configManager) || '',
+    reasoningEffort: (configManager.get('provider.reasoningEffort') as string | undefined) ?? '',
+    sessionId: userSessionId,
+  };
+  runtimeSessionIdRef.value = runtime.sessionId;
+  void sharedSessionBroker.createSession({
+    id: runtime.sessionId,
+    title: 'Terminal UI session',
+    metadata: { source: 'tui' },
+    participant: {
+      surfaceKind: 'tui',
+      surfaceId: 'surface:tui',
+      displayName: 'Terminal UI',
+      lastSeenAt: Date.now(),
+    },
+  }).catch(() => {});
+
+  domainDispatch.syncSessionState({
+    id: userSessionId,
+    projectRoot: workingDir,
+    status: 'active',
+    startedAt: Date.now(),
+    recoveryState: 'ready',
+    isResumed: false,
+    wasRepaired: false,
+    lineageId: userSessionId,
+    lineage: [{ sessionId: userSessionId, createdAt: Date.now() }],
+  }, 'bootstrap.session');
+
+  runtimeUnsubs.push(
+    ...registerBootstrapHookBridge({
+      runtimeBus,
+      hookDispatcher,
+      runtime,
+    }),
+  );
+
+  return {
+    userSessionId,
+    runtimeBus,
+    store,
+    services,
+    uiServices,
+    conversation,
+    compositor,
+    selection,
+    toolRegistry,
+    fileCache,
+    projectIndex,
+    permissionManager,
+    forensicsCollector,
+    forensicsRegistry,
+    runtime,
+    bootstrapUnsubs,
+    runtimeUnsubs,
+    agentStatusIntervalRef,
+    permissionPromptRef,
+    systemMessageRouterRef,
+    conversationFollowUpRef,
+    requestRender,
+    setRenderRequest: (fn) => {
+      renderRequestRef.value = fn;
+    },
+    runtimeSessionIdRef,
+  };
+}

package/src/runtime/bootstrap-helpers.ts

@@ -0,0 +1,88 @@
+import type { ConfigManager } from '../config/manager.ts';
+import type { ServiceRegistry } from '../config/service-registry.ts';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import type { MutableRuntimeState } from './context.ts';
+import type { IntegrationRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/integrations';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { loadSystemPrompt as _loadSystemPrompt } from '@pellux/goodvibes-sdk/platform/utils/prompt-loader';
+import { isAbsolute, resolve } from 'node:path';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+function requireOwnedPromptRoot(path: string | null, name: 'workingDirectory' | 'homeDirectory'): string {
+  const trimmed = path?.trim();
+  if (!trimmed) {
+    throw new Error(`loadBootstrapSystemPrompt requires ConfigManager with explicit ${name}.`);
+  }
+  return trimmed;
+}
+
+export function loadBootstrapSystemPrompt(configManager: ConfigManager): string {
+  const workingDirectory = requireOwnedPromptRoot(configManager.getWorkingDirectory(), 'workingDirectory');
+  const homeDirectory = requireOwnedPromptRoot(configManager.getHomeDirectory(), 'homeDirectory');
+  return _loadSystemPrompt(
+    {
+      workingDirectory,
+      homeDirectory,
+      getConfigPath: () => {
+        const configuredPath = configManager.get('provider.systemPromptFile') as string | undefined;
+        if (typeof configuredPath !== 'string' || !configuredPath.trim()) return undefined;
+        return isAbsolute(configuredPath)
+          ? resolve(configuredPath)
+          : resolve(workingDirectory, configuredPath);
+      },
+      argv: process.argv,
+    },
+  );
+}
+
+export async function syncConfiguredServices(
+  syncIntegration: (record: IntegrationRecord, source?: string) => void,
+  serviceRegistry: ServiceRegistry,
+): Promise<void> {
+  const services = serviceRegistry.getAll();
+  await Promise.all(
+    Object.entries(services).map(async ([id, config]) => {
+      const inspection = await serviceRegistry.inspect(id);
+      if (!inspection) return;
+      syncIntegration({
+        id,
+        displayName: config.name || id,
+        category: 'custom',
+        status: inspection.hasPrimaryCredential ? 'healthy' : 'unconfigured',
+        enabled: true,
+        successCount: 0,
+        errorCount: 0,
+        meta: {
+          authType: config.authType,
+          baseUrl: config.baseUrl ?? null,
+          hasPrimaryCredential: inspection.hasPrimaryCredential,
+          hasWebhookUrl: inspection.hasWebhookUrl,
+          hasSigningSecret: inspection.hasSigningSecret,
+          hasPublicKey: inspection.hasPublicKey,
+        },
+      }, 'bootstrap.services');
+    }),
+  );
+}
+
+export function restoreSavedModel(
+  providerRegistry: ProviderRegistry,
+  savedModel: string,
+  savedProvider: string,
+  runtime: MutableRuntimeState,
+): void {
+  const registry = providerRegistry.listModels();
+  const modelDef = savedModel.includes(':')
+    ? (registry.find((m) => m.registryKey === savedModel) ?? registry.find((m) => m.id === savedModel))
+    : registry.find((m) => m.id === savedModel && (!savedProvider || m.provider === savedProvider))
+      ?? registry.find((m) => m.id === savedModel);
+  if (!modelDef) return;
+  try {
+    const key = modelDef.registryKey ?? `${modelDef.provider}:${modelDef.id}`;
+    providerRegistry.setCurrentModel(key);
+    runtime.model = key;
+    runtime.provider = modelDef.provider;
+  } catch (err) {
+    logger.debug('Model restore failed (non-fatal)', { error: summarizeError(err) });
+  }
+}