@pellux/goodvibes-tui 0.18.4

package/src/runtime/bootstrap-services.ts

@@ -0,0 +1,197 @@
+import type { HookDispatcher } from '../hooks/dispatcher.ts';
+import type { RuntimeEventBus } from './events/index.ts';
+import type { RuntimeServices } from './services.ts';
+import { DaemonServer } from '../daemon/server.ts';
+import { HttpListener } from '../daemon/http-listener.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import net from 'node:net';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+interface DaemonService {
+  enable(config: { daemon: boolean }, token?: string): boolean;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.ts').ControlPlaneRecentEvent[];
+}
+
+interface HttpListenerService {
+  enable(config: { httpListener: boolean }, token?: string): boolean;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+
+interface ServiceFactories {
+  createDaemonServer?: (
+    runtimeBus: RuntimeEventBus,
+    userAuth: RuntimeServices['localUserAuthManager'],
+    runtimeServices: RuntimeServices,
+  ) => DaemonService;
+  createHttpListener?: (
+    hookDispatcher: HookDispatcher,
+    userAuth: RuntimeServices['localUserAuthManager'],
+    configManager: RuntimeServices['configManager'],
+  ) => HttpListenerService;
+  startupTimeoutMs?: number;
+  probeDaemonPortInUse?: (host: string, port: number) => Promise<boolean>;
+  probeHttpListenerPortInUse?: (host: string, port: number) => Promise<boolean>;
+}
+
+export interface ExternalServicesHandle {
+  readonly daemonServer: DaemonService | null;
+  readonly httpListener: HttpListenerService | null;
+  listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.ts').ControlPlaneRecentEvent[];
+  stop(): Promise<void>;
+}
+
+export interface ExternalServicesConfig {
+  get(
+    key:
+      | 'danger.daemon'
+      | 'danger.httpListener'
+      | 'controlPlane.host'
+      | 'controlPlane.port'
+      | 'httpListener.host'
+      | 'httpListener.port',
+  ): boolean | string | number;
+}
+const DEFAULT_SERVICE_START_TIMEOUT_MS = 1500;
+
+async function isTcpPortInUse(host: string, port: number, timeoutMs = 250): Promise<boolean> {
+  return await new Promise<boolean>((resolve) => {
+    const socket = new net.Socket();
+    let settled = false;
+    const finish = (result: boolean): void => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+    socket.connect(port, host);
+  });
+}
+
+async function startWithTimeout(
+  label: string,
+  start: () => Promise<void>,
+  timeoutMs: number,
+  cleanup?: () => Promise<void>,
+): Promise<'started' | 'timed_out'> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const startPromise = start().then(() => 'started' as const);
+  try {
+    const result = await Promise.race([
+      startPromise,
+      new Promise<'timed_out'>((resolve) => {
+        timer = setTimeout(() => resolve('timed_out'), timeoutMs);
+      }),
+    ]);
+    if (result === 'timed_out') {
+      logger.warn(`${label} startup timed out; continuing without it in this TUI instance`, { timeoutMs });
+      if (cleanup) {
+        void cleanup().catch((error) => {
+          logger.warn(`${label} cleanup after startup timeout failed`, { error: summarizeError(error) });
+        });
+        void startPromise.then(() => cleanup()).catch(() => {});
+      }
+    }
+    return result;
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+  }
+}
+
+export async function startExternalServices(
+  config: ExternalServicesConfig,
+  runtimeBus: RuntimeEventBus,
+  hookDispatcher: HookDispatcher,
+  factories: ServiceFactories = {},
+  runtimeServices: RuntimeServices,
+): Promise<ExternalServicesHandle> {
+  const sharedUserAuth = runtimeServices.localUserAuthManager;
+  const createDaemonServer = factories.createDaemonServer ?? ((bus, userAuth, services): DaemonService =>
+    new DaemonServer({ runtimeBus: bus, userAuth, runtimeServices: services }));
+  const createHttpListener = factories.createHttpListener ?? ((dispatcher, userAuth, configManager): HttpListenerService =>
+    new HttpListener({ hookDispatcher: dispatcher, userAuth, configManager }));
+  const startupTimeoutMs = factories.startupTimeoutMs ?? DEFAULT_SERVICE_START_TIMEOUT_MS;
+  const daemonHost = String(config.get('controlPlane.host') ?? '127.0.0.1');
+  const daemonPort = Number(config.get('controlPlane.port') ?? 3421);
+  const httpListenerHost = String(config.get('httpListener.host') ?? '127.0.0.1');
+  const httpListenerPort = Number(config.get('httpListener.port') ?? 3422);
+  const probeDaemonPortInUse = factories.probeDaemonPortInUse ?? ((host: string, port: number) => isTcpPortInUse(host, port));
+  const probeHttpListenerPortInUse = factories.probeHttpListenerPortInUse ?? ((host: string, port: number) => isTcpPortInUse(host, port));
+
+  let daemonServer: DaemonService | null = null;
+  let httpListener: HttpListenerService | null = null;
+
+  if (config.get('danger.daemon') as boolean) {
+    if (await probeDaemonPortInUse(daemonHost, daemonPort)) {
+      logger.warn('Daemon server port already in use; continuing without local daemon in this TUI instance', {
+        host: daemonHost,
+        port: daemonPort,
+      });
+    } else {
+      daemonServer = createDaemonServer(runtimeBus, sharedUserAuth, runtimeServices);
+      daemonServer.enable({ daemon: true });
+      try {
+        const service = daemonServer;
+        const result = await startWithTimeout('Daemon server', () => service.start(), startupTimeoutMs, () => service.stop());
+        if (result === 'timed_out') {
+          daemonServer = null;
+        }
+      } catch (error) {
+        const message = summarizeError(error);
+        if (message.includes('EADDRINUSE') || message.includes('Address already in use')) {
+          logger.warn('Daemon server port already in use; continuing without local daemon in this TUI instance', { error: message });
+          daemonServer = null;
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+
+  if (config.get('danger.httpListener') as boolean) {
+    if (await probeHttpListenerPortInUse(httpListenerHost, httpListenerPort)) {
+      logger.warn('HTTP listener port already in use; continuing without local listener in this TUI instance', {
+        host: httpListenerHost,
+        port: httpListenerPort,
+      });
+    } else {
+      httpListener = createHttpListener(hookDispatcher, sharedUserAuth, runtimeServices.configManager);
+      httpListener.enable({ httpListener: true });
+      try {
+        const service = httpListener;
+        const result = await startWithTimeout('HTTP listener', () => service.start(), startupTimeoutMs, () => service.stop());
+        if (result === 'timed_out') {
+          httpListener = null;
+        }
+      } catch (error) {
+        const message = summarizeError(error);
+        if (message.includes('EADDRINUSE') || message.includes('Address already in use')) {
+          logger.warn('HTTP listener port already in use; continuing without local listener in this TUI instance', { error: message });
+          httpListener = null;
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+
+  return {
+    daemonServer,
+    httpListener,
+    listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.ts').ControlPlaneRecentEvent[] {
+      return daemonServer?.listRecentControlPlaneEvents(limit) ?? [];
+    },
+    async stop(): Promise<void> {
+      await Promise.allSettled([
+        daemonServer?.stop(),
+        httpListener?.stop(),
+      ]);
+    },
+  };
+}

package/src/runtime/bootstrap-shell.ts

@@ -0,0 +1,262 @@
+import type { ConversationManager } from '../core/conversation.ts';
+import type { Orchestrator } from '../core/orchestrator.ts';
+import type { ConfigManager } from '../config/manager.ts';
+import type { RuntimeEventBus } from './events/index.ts';
+import type { RuntimeStore } from './store/index.ts';
+import type { RuntimeServices } from './services.ts';
+import type { MutableRuntimeState } from './context.ts';
+import type { CommandContext } from '../input/command-registry.ts';
+import type { OpsControlPlane } from './ops/control-plane.ts';
+import { CommandRegistry } from '../input/command-registry.ts';
+import { registerBuiltinCommands } from '../input/commands.ts';
+import { InputHistory } from '../input/input-history.ts';
+import { GitStatusProvider } from '../renderer/git-status.ts';
+import type { GitHeaderInfo } from '../renderer/git-status.ts';
+import type { PermissionRequestHandler } from '../permissions/prompt.ts';
+import { registerBuiltinPanels } from '../panels/builtin-panels.ts';
+import { SystemMessagesPanel } from '../panels/system-messages-panel.ts';
+import { createSystemMessageRouter, type SystemMessageRouter } from '../core/system-message-router.ts';
+import { getConfigSnapshot } from '../config/index.ts';
+import { createBootstrapCommandContext } from './bootstrap-command-context.ts';
+import { createResumeSessionHandler } from './bootstrap-hook-bridge.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { loadBootstrapSystemPrompt } from './bootstrap-helpers.ts';
+import { createShellPlanRuntime, createShellRemoteCommandService } from './shell-command-services.ts';
+import { createRuntimeFoundationClients } from './foundation-clients.ts';
+import type { ControlPlaneRecentEvent } from '../control-plane/gateway.ts';
+import type { BuiltinPanelDeps } from '../panels/builtin/shared.ts';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import type { ForensicsRegistry } from './forensics/index.ts';
+import type { PolicyRuntimeState } from './permissions/policy-runtime.ts';
+import type { TaskManager } from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
+import type { UiRuntimeServices } from './ui-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+export interface BootstrapShellState {
+  readonly commandRegistry: CommandRegistry;
+  readonly commandContext: CommandContext;
+  readonly gitStatusProvider: GitStatusProvider;
+  readonly lastGitInfoRef: { value: GitHeaderInfo | undefined };
+  readonly inputHistory: InputHistory;
+  readonly systemMessageRouter: SystemMessageRouter;
+}
+
+export interface BootstrapShellOptions {
+  readonly configManager: ConfigManager;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly runtimeStore: RuntimeStore;
+  readonly services: RuntimeServices;
+  readonly conversation: ConversationManager;
+  readonly runtime: MutableRuntimeState;
+  readonly orchestrator: Orchestrator;
+  readonly requestRender: () => void;
+  readonly permissionPromptRef: { requestPermission: PermissionRequestHandler };
+  readonly onSessionIdChanged: (sessionId: string) => void;
+  readonly writeLastSessionPointer: (sessionId: string) => void;
+  readonly getControlPlaneRecentEvents: (limit: number) => readonly ControlPlaneRecentEvent[];
+  readonly toolRegistry: ToolRegistry;
+  readonly forensicsRegistry: ForensicsRegistry;
+  readonly policyRuntimeState: PolicyRuntimeState;
+  readonly uiServices: UiRuntimeServices;
+  readonly taskManager: TaskManager;
+  readonly opsControlPlane?: OpsControlPlane;
+  readonly completeModelSelectionSideEffect?: () => void;
+}
+
+export function createBootstrapShell(options: BootstrapShellOptions): BootstrapShellState {
+  const {
+    configManager,
+    runtimeBus,
+    runtimeStore,
+    services,
+    conversation,
+    runtime,
+    orchestrator,
+    requestRender,
+    permissionPromptRef,
+    onSessionIdChanged,
+    writeLastSessionPointer,
+    getControlPlaneRecentEvents,
+    toolRegistry,
+    forensicsRegistry,
+    policyRuntimeState,
+    uiServices,
+    taskManager,
+    opsControlPlane,
+    completeModelSelectionSideEffect,
+  } = options;
+
+  const systemMessagesPanel = new SystemMessagesPanel(configManager, services.panelHealthMonitor);
+  const resumeSession = createResumeSessionHandler({
+    runtimeBus,
+    runtime,
+    conversation,
+    requestRender,
+    onSessionIdChanged,
+    sharedSessionBroker: services.sessionBroker,
+    writeLastSessionPointer,
+    hookDispatcher: services.hookDispatcher,
+    sessionManager: services.sessionManager,
+    panelManager: services.panelManager,
+    configManager,
+    providerRegistry: services.providerRegistry,
+  });
+
+  registerBuiltinPanels(services.panelManager, {
+    configManager,
+    getOrchestratorUsage: () => orchestrator.usage as { input: number; output: number; cacheRead: number; cacheWrite: number; model?: string },
+    toolRegistry,
+    providerRegistry: services.providerRegistry,
+    contextWindow: services.providerRegistry.getContextWindowForModel(services.providerRegistry.getCurrentModel()),
+    orchestrator,
+    getCtxWindow: () => services.providerRegistry.getContextWindowForModel(services.providerRegistry.getCurrentModel()),
+    resumeSession,
+    requestRender,
+    forensicsRegistry,
+    policyRuntimeState,
+    approvalBroker: services.approvalBroker,
+    sessionBroker: services.sessionBroker,
+    automationManager: services.automationManager,
+    getControlPlaneRecentEvents,
+    tokenAuditor: services.tokenAuditor,
+    panelHealthMonitor: services.panelHealthMonitor,
+    worktreeRegistry: services.worktreeRegistry,
+    sandboxSessionRegistry: services.sandboxSessionRegistry,
+    systemMessagesPanel,
+    memoryRegistry: services.memoryRegistry,
+    uiServices,
+    pluginManager: services.pluginManager,
+    hookDispatcher: services.hookDispatcher,
+    hookActivityTracker: services.hookActivityTracker,
+    hookWorkbench: services.hookWorkbench,
+    mcpRegistry: services.mcpRegistry,
+  });
+  services.panelManager.prewarmRegistered();
+
+  const systemMessageRouter = createSystemMessageRouter(
+    conversation,
+    systemMessagesPanel,
+    (kind) => {
+      const ui = getConfigSnapshot(configManager).ui;
+      if (kind === 'wrfc') return ui.wrfcMessages;
+      if (kind === 'operational') return ui.operationalMessages;
+      return ui.systemMessages;
+    },
+  );
+  orchestrator.setSystemMessageRouter(systemMessageRouter);
+
+  const commandRegistry = new CommandRegistry();
+  registerBuiltinCommands(commandRegistry);
+  const foundationClients = createRuntimeFoundationClients({
+    runtimeServices: services,
+    tasksReadModel: uiServices.readModels.tasks,
+    taskManager,
+    opsControlPlane,
+  });
+  const {
+    directTransport,
+    hookApi,
+    knowledgeApi,
+    mcpApi,
+    opsApi,
+    providerApi,
+  } = foundationClients;
+  const remoteRuntime = createShellRemoteCommandService({
+    readModels: uiServices.readModels,
+    remoteRunnerRegistry: services.remoteRunnerRegistry,
+    runtimeStore,
+  });
+  const planRuntime = createShellPlanRuntime({
+    adaptivePlanner: services.adaptivePlanner,
+    runtimeBus,
+  });
+
+  const commandContext: CommandContext = createBootstrapCommandContext({
+    configManager,
+    providerRegistry: services.providerRegistry,
+    conversation,
+    runtime,
+    requestRender,
+    keybindingsManager: services.keybindingsManager,
+    requestPermission: (request) => permissionPromptRef.requestPermission(request),
+    toolRegistry,
+    mcpRegistry: services.mcpRegistry,
+    forensicsRegistry,
+    policyRuntimeState,
+    readModels: uiServices.readModels,
+    shellPaths: services.shellPaths,
+    remoteRuntime,
+    planRuntime,
+    fileUndoManager: services.fileUndoManager,
+    memoryRegistry: services.memoryRegistry,
+    integrationHelpers: services.integrationHelpers,
+    automationManager: services.automationManager,
+    knowledgeService: services.knowledgeService,
+    providerOptimizer: services.providerOptimizer,
+    pluginManager: services.pluginManager,
+    hookWorkbench: services.hookWorkbench,
+    agentManager: services.agentManager,
+    modeManager: services.modeManager,
+    sessionManager: services.sessionManager,
+    profileManager: services.profileManager,
+    bookmarkManager: services.bookmarkManager,
+    favoritesStore: services.favoritesStore,
+    benchmarkStore: services.benchmarkStore,
+    providerApi,
+    subscriptionManager: services.subscriptionManager,
+    secretsManager: services.secretsManager,
+    serviceRegistry: services.serviceRegistry,
+    localUserAuthManager: services.localUserAuthManager,
+    tokenAuditor: services.tokenAuditor,
+    replayEngine: services.replayEngine,
+    webhookNotifier: services.webhookNotifier,
+    sessionMemoryStore: services.sessionMemoryStore,
+    sessionLineageTracker: services.sessionLineageTracker,
+    changeTracker: services.sessionChangeTracker,
+    planManager: services.planManager,
+    adaptivePlanner: services.adaptivePlanner,
+    sessionOrchestration: services.sessionOrchestration,
+    operatorClient: directTransport.operator,
+    peerClient: directTransport.peer,
+    knowledgeApi,
+    hookApi,
+    mcpApi,
+    opsApi,
+    directTransport,
+    panelManager: services.panelManager,
+    panelHealthMonitor: services.panelHealthMonitor,
+    worktreeRegistry: services.worktreeRegistry,
+    sandboxSessionRegistry: services.sandboxSessionRegistry,
+    loadSystemPrompt: () => loadBootstrapSystemPrompt(configManager),
+    activatePlan: (_planId, task) => {
+      setTimeout(() => {
+        orchestrator.handleUserInput(task).catch((err) => {
+          logger.debug('activatePlan handler failed', { error: summarizeError(err) });
+        });
+      }, 50);
+    },
+    completeModelSelectionSideEffect,
+  });
+
+  const gitStatusProvider = new GitStatusProvider(services.workingDirectory);
+  const lastGitInfoRef = { value: undefined as GitHeaderInfo | undefined };
+  gitStatusProvider.getStatus().then((info) => {
+    lastGitInfoRef.value = info;
+    requestRender();
+  }).catch(() => { /* non-fatal */ });
+
+  const saveHistory = configManager.get('behavior.saveHistory') as boolean;
+  const inputHistory = new InputHistory({
+    historyPath: services.shellPaths.resolveUserPath('tui', 'input-history.json'),
+    persist: saveHistory,
+  });
+
+  return {
+    commandRegistry,
+    commandContext,
+    gitStatusProvider,
+    lastGitInfoRef,
+    inputHistory,
+    systemMessageRouter,
+  };
+}