@pellux/goodvibes-tui 0.18.4

package/src/runtime/auth/inspection.ts

@@ -0,0 +1,125 @@
+import { SecretsManager } from '../../config/secrets.ts';
+import { ServiceRegistry } from '../../config/service-registry.ts';
+import { SubscriptionManager, type ProviderSubscription } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
+import { getSubscriptionProviderConfig } from '../../config/subscription-providers.ts';
+
+export type AuthInspectionFreshness = 'healthy' | 'expiring' | 'expired' | 'pending' | 'available' | 'unconfigured';
+
+export interface ProviderAuthInspection {
+  readonly provider: string;
+  readonly configured: boolean;
+  readonly source?: 'service' | 'builtin';
+  readonly freshness: AuthInspectionFreshness;
+  readonly redirectUri?: string;
+  readonly callbackMode: 'local' | 'manual';
+  readonly localCallback?: string;
+  readonly activeSubscription: boolean;
+  readonly pendingLogin: boolean;
+  readonly overrideAmbientApiKeys: boolean;
+  readonly tokenType?: string;
+  readonly expiresAt?: number;
+  readonly issues: readonly string[];
+  readonly nextActions: readonly string[];
+}
+
+export interface AuthInspectionSnapshot {
+  readonly generatedAt: number;
+  readonly secretKeyCount: number;
+  readonly activeSubscriptions: number;
+  readonly pendingSubscriptions: number;
+  readonly providers: readonly ProviderAuthInspection[];
+}
+
+export interface AuthInspectionDeps {
+  readonly serviceRegistry: Pick<ServiceRegistry, 'get' | 'getAll'>;
+  readonly subscriptionManager: Pick<SubscriptionManager, 'get' | 'getPending' | 'list' | 'listPending'>;
+  readonly secretsManager: Pick<SecretsManager, 'list'>;
+}
+
+function determineFreshness(subscription: ProviderSubscription | null, pending: boolean, configured: boolean): AuthInspectionFreshness {
+  if (pending) return 'pending';
+  if (!subscription) return configured ? 'available' : 'unconfigured';
+  if (typeof subscription.expiresAt !== 'number' || !Number.isFinite(subscription.expiresAt)) return 'healthy';
+  if (subscription.expiresAt <= Date.now()) return 'expired';
+  if (subscription.expiresAt <= Date.now() + 24 * 60 * 60 * 1000) return 'expiring';
+  return 'healthy';
+}
+
+export async function inspectProviderAuth(
+  provider: string,
+  deps: AuthInspectionDeps,
+): Promise<ProviderAuthInspection> {
+  const service = deps.serviceRegistry.get(provider);
+  const resolved = getSubscriptionProviderConfig(provider, service);
+  const subscription = deps.subscriptionManager.get(provider);
+  const pending = deps.subscriptionManager.getPending(provider);
+  const configured = resolved != null;
+  const freshness = determineFreshness(subscription, pending != null, configured);
+  const issues: string[] = [];
+  const nextActions: string[] = [];
+
+  if (!configured) {
+    issues.push('No provider OAuth configuration is available.');
+    nextActions.push(`Add provider OAuth config or a built-in adapter before using /subscription login ${provider} start.`);
+  }
+  if (freshness === 'expired') {
+    issues.push('Stored provider session is expired.');
+    nextActions.push(`Refresh or replace the stored ${provider} session.`);
+  } else if (freshness === 'expiring') {
+    issues.push('Stored provider session expires within 24 hours.');
+    nextActions.push(`Verify or renew the stored ${provider} session soon.`);
+  } else if (freshness === 'pending') {
+    issues.push('OAuth login has started but has not been completed.');
+    nextActions.push(`Finish /subscription login ${provider} finish <code-or-url>.`);
+  } else if (freshness === 'available') {
+    nextActions.push(`Start /subscription login ${provider} start to create a stored session.`);
+  }
+
+  const callbackMode = resolved?.oauth.localCallback ? 'local' : 'manual';
+  const localCallback = resolved?.oauth.localCallback
+    ? `${resolved.oauth.localCallback.host ?? 'localhost'}:${resolved.oauth.localCallback.port ?? 80}${resolved.oauth.localCallback.path ?? '/'}`
+    : undefined;
+
+  return Object.freeze({
+    provider,
+    configured,
+    ...(resolved ? { source: resolved.source } : {}),
+    freshness,
+    ...(resolved ? { redirectUri: resolved.oauth.redirectUri } : {}),
+    callbackMode,
+    ...(localCallback ? { localCallback } : {}),
+    activeSubscription: subscription != null,
+    pendingLogin: pending != null,
+    overrideAmbientApiKeys: subscription?.overrideAmbientApiKeys ?? false,
+    ...(subscription?.tokenType ? { tokenType: subscription.tokenType } : {}),
+    ...(subscription?.expiresAt ? { expiresAt: subscription.expiresAt } : {}),
+    issues,
+    nextActions,
+  });
+}
+
+export async function buildAuthInspectionSnapshot(
+  deps: AuthInspectionDeps,
+): Promise<AuthInspectionSnapshot> {
+  const secrets = await deps.secretsManager.list();
+  const services = deps.serviceRegistry.getAll();
+  const providerIds = new Set<string>([
+    ...Object.values(services)
+      .filter((service) => service.authType === 'oauth' && service.oauth)
+      .map((service) => service.providerId ?? service.name),
+    ...deps.subscriptionManager.list().map((entry) => entry.provider),
+    ...deps.subscriptionManager.listPending().map((entry) => entry.provider),
+  ]);
+  const providers = await Promise.all(
+    [...providerIds]
+      .sort((a, b) => a.localeCompare(b))
+      .map((provider) => inspectProviderAuth(provider, deps)),
+  );
+  return Object.freeze({
+    generatedAt: Date.now(),
+    secretKeyCount: secrets.length,
+    activeSubscriptions: deps.subscriptionManager.list().length,
+    pendingSubscriptions: deps.subscriptionManager.listPending().length,
+    providers,
+  });
+}

package/src/runtime/bootstrap-background.ts

@@ -0,0 +1,147 @@
+import type { ConfigManager } from '../config/manager.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import { autoRegisterProviders } from '../providers/auto-register.ts';
+import { scan, loadPersistedProviders, persistProviders, removePersistedProviders, scanMcpServers } from '@pellux/goodvibes-sdk/platform/discovery/index';
+import type { MutableRuntimeState } from './context.ts';
+import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import type { McpRegistry } from '../mcp/registry.ts';
+import type { ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+type BackgroundProviderRegistrationOptions = {
+  configManager: ConfigManager;
+  providerRegistry: ProviderRegistry;
+  runtime: MutableRuntimeState;
+  requestRender: () => void;
+  restoreSavedModel: (providerRegistry: ProviderRegistry, savedModel: string, savedProvider: string, runtime: MutableRuntimeState) => void;
+  systemMessageRouter: SystemMessageRouter;
+  shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>;
+};
+
+export function startBackgroundProviderRegistration(
+  options: BackgroundProviderRegistrationOptions,
+): void {
+  const { configManager, providerRegistry, runtime, requestRender, restoreSavedModel, systemMessageRouter, shellPaths } = options;
+
+  autoRegisterProviders(providerRegistry);
+
+  const persisted = loadPersistedProviders(shellPaths);
+  if (persisted.length > 0) {
+    try {
+      providerRegistry.registerDiscoveredProviders(persisted);
+      restoreSavedModel(
+        providerRegistry,
+        configManager.get('provider.model') as string,
+        configManager.get('provider.provider') as string,
+        runtime,
+      );
+      for (const server of persisted) {
+        systemMessageRouter.low(
+          `[Local] ${server.name} at ${server.host}:${server.port} (${server.models.length} model${server.models.length !== 1 ? 's' : ''}) — from last session`,
+        );
+      }
+      requestRender();
+    } catch (err) {
+      logger.debug('[bootstrap] Non-fatal error during persisted provider registration', {
+        error: summarizeError(err),
+      });
+    }
+  }
+
+  scan().then((result) => {
+    const currentModel = configManager.get('provider.model') as string;
+    const foundKeys = new Set(result.servers.map((server) => `${server.host}:${server.port}`));
+    const persistedKeys = new Set(persisted.map((server) => `${server.host}:${server.port}`));
+    const newServers = result.servers.filter((server) => !persistedKeys.has(`${server.host}:${server.port}`));
+    const removedServers = persisted.filter((server) => !foundKeys.has(`${server.host}:${server.port}`));
+
+    if (result.servers.length > 0) {
+      try {
+        providerRegistry.registerDiscoveredProviders(result.servers);
+        restoreSavedModel(
+          providerRegistry,
+          configManager.get('provider.model') as string,
+          configManager.get('provider.provider') as string,
+          runtime,
+        );
+      } catch (err) {
+        logger.debug('[bootstrap] Non-fatal error during scan provider registration', {
+          error: summarizeError(err),
+        });
+      }
+    }
+
+    for (const server of newServers) {
+      systemMessageRouter.low(
+        `[Scan] Found ${server.name} at ${server.host}:${server.port} (${server.models.length} model${server.models.length !== 1 ? 's' : ''})`,
+      );
+    }
+
+    if (result.servers.length > 0 && removedServers.length > 0) {
+      removePersistedProviders(shellPaths, removedServers);
+      for (const server of removedServers) {
+        systemMessageRouter.low(
+          `[Scan] ${server.name} at ${server.host}:${server.port} is no longer reachable — removed`,
+        );
+        const wasActive = server.models.includes(currentModel);
+        if (wasActive) {
+          configManager.set('provider.model', 'openrouter/free');
+          configManager.set('provider.provider', 'openrouter');
+          try {
+            providerRegistry.setCurrentModel('openrouter/free');
+            runtime.model = 'openrouter/free';
+            runtime.provider = 'openrouter';
+          } catch (err) {
+            logger.debug('[bootstrap] Non-fatal error switching model after server removal', {
+              error: summarizeError(err),
+            });
+          }
+          systemMessageRouter.high(
+            `[Scan] Active model was on ${server.name} — switched to openrouter/free`,
+          );
+        }
+      }
+    }
+
+    if (result.servers.length > 0) {
+      persistProviders(shellPaths, result.servers);
+    }
+
+    if (newServers.length > 0 || removedServers.length > 0) {
+      requestRender();
+    }
+  }).catch(() => {
+    // Non-fatal: scan failure expected when no local LLMs are running
+  });
+}
+
+type McpAutodiscoveryOptions = {
+  mcpRegistry: McpRegistry;
+  systemMessageRouter: SystemMessageRouter;
+  requestRender: () => void;
+  shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>;
+};
+
+export function scheduleMcpAutodiscovery(options: McpAutodiscoveryOptions): void {
+  const { mcpRegistry, systemMessageRouter, requestRender, shellPaths } = options;
+
+  mcpRegistry.connectAll(shellPaths).catch((err) => {
+    logger.debug('MCP auto-connect failed (non-fatal)', { error: summarizeError(err) });
+  });
+
+  setTimeout(() => {
+    const registeredNames = new Set(mcpRegistry.serverNames);
+    scanMcpServers(shellPaths, registeredNames).then((result) => {
+      if (result.suggestions.length === 0) return;
+      for (const suggestion of result.suggestions) {
+        systemMessageRouter.low(
+          `[MCP] Discovered server '${suggestion.name}' (${suggestion.command} ${(suggestion.args ?? []).join(' ')}). Add it to .goodvibes/mcp.json or ~/.config/mcp/mcp.json to enable it.`,
+        );
+      }
+      requestRender();
+    }).catch((err) => {
+      logger.debug('MCP auto-discovery scan failed (non-fatal)', { error: summarizeError(err) });
+    });
+  }, 2000);
+}

package/src/runtime/bootstrap-command-context.ts

@@ -0,0 +1,265 @@
+import type { ConfigManager } from '../config/manager.ts';
+import type { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+import type { ConversationManager } from '../core/conversation.ts';
+import type { KnowledgeApi } from '../knowledge/knowledge-api.ts';
+import type { HookApi } from '../hooks/hook-api.ts';
+import type { McpApi } from '../mcp/mcp-api.ts';
+import type { PanelManager } from '../panels/panel-manager.ts';
+import type { ProviderApi } from '../providers/provider-api.ts';
+import type { OpsApi } from './ops-api.ts';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import type { MutableRuntimeState } from './context.ts';
+import type { CommandContext } from '../input/command-registry.ts';
+import type { KeybindingsManager } from '../input/keybindings.ts';
+import type { PermissionRequestHandler } from '../permissions/prompt.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 { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state/file-undo';
+import type { McpRegistry } from '../mcp/registry.ts';
+import type { MemoryRegistry } from '../state/memory-store.ts';
+import type { IntegrationHelperService } from './integration/helpers.ts';
+import type { KnowledgeService } from '../knowledge/index.ts';
+import type { PluginManager } from '../plugins/manager.ts';
+import type { HookWorkbench } from '../hooks/workbench.ts';
+import type { PanelHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-health-monitor';
+import type { WorktreeRegistry } from './worktree/registry.ts';
+import type { SandboxSessionRegistry } from './sandbox/session-registry.ts';
+import type { UiReadModels } from './ui-read-models.ts';
+import type { ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
+import type {
+  ShellAgentManagerService,
+  ShellAutomationManagerRuntimeService,
+  ShellModeManagerService,
+  ShellPlanManagerService,
+  ShellSessionOrchestrationService,
+} from './shell-command-ops.ts';
+import { createBootstrapCommandShellServices, type PlanRuntimeService, type RemoteCommandService } from './shell-command-services.ts';
+import type { OperatorClient } from './operator-client.ts';
+import type { PeerClient } from './peer-client.ts';
+import type { DirectTransport } from './transports/direct.ts';
+import {
+  createBootstrapCommandActions,
+  createBootstrapCommandClientsSection,
+  createBootstrapCommandExtensionsSection,
+  createBootstrapCommandOpsSection,
+  createBootstrapCommandPlatformSection,
+  createBootstrapCommandProviderSection,
+  createBootstrapCommandSessionSection,
+  createBootstrapCommandWorkspaceSection,
+} from './bootstrap-command-parts.ts';
+
+export type CreateBootstrapCommandContextOptions = {
+  configManager: ConfigManager;
+  providerRegistry: ProviderRegistry;
+  conversation: ConversationManager;
+  runtime: MutableRuntimeState;
+  requestRender: () => void;
+  keybindingsManager?: KeybindingsManager;
+  requestPermission: PermissionRequestHandler;
+  toolRegistry: ToolRegistry;
+  mcpRegistry: McpRegistry;
+  forensicsRegistry: ForensicsRegistry;
+  policyRuntimeState: PolicyRuntimeState;
+  readModels: UiReadModels;
+  shellPaths: ShellPathService;
+  remoteRuntime?: RemoteCommandService;
+  planRuntime?: PlanRuntimeService;
+  fileUndoManager: FileUndoManager;
+  memoryRegistry?: MemoryRegistry;
+  integrationHelpers?: IntegrationHelperService;
+  automationManager?: ShellAutomationManagerRuntimeService;
+  knowledgeService?: KnowledgeService;
+  providerOptimizer?: import('../providers/optimizer.ts').ProviderOptimizer;
+  pluginManager?: PluginManager;
+  hookWorkbench?: HookWorkbench;
+  agentManager?: ShellAgentManagerService;
+  modeManager?: ShellModeManagerService;
+  sessionManager?: import('../sessions/manager.ts').SessionManager;
+  profileManager?: import('@pellux/goodvibes-sdk/platform/profiles/manager').ProfileManager;
+  bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks/manager').BookmarkManager;
+  favoritesStore?: import('@pellux/goodvibes-sdk/platform/providers/favorites').FavoritesStore;
+  benchmarkStore?: import('@pellux/goodvibes-sdk/platform/providers/model-benchmarks').BenchmarkStore;
+  providerApi?: ProviderApi;
+  subscriptionManager?: import('@pellux/goodvibes-sdk/platform/config/subscriptions').SubscriptionManager;
+  secretsManager?: import('../config/secrets.ts').SecretsManager;
+  serviceRegistry?: import('../config/service-registry.ts').ServiceRegistry;
+  localUserAuthManager?: import('@pellux/goodvibes-sdk/platform/security/user-auth').UserAuthManager;
+  tokenAuditor?: import('@pellux/goodvibes-sdk/platform/security/token-audit').ApiTokenAuditor;
+  replayEngine?: import('@pellux/goodvibes-sdk/platform/core/deterministic-replay').DeterministicReplayEngine;
+  webhookNotifier?: import('../integrations/webhooks.ts').WebhookNotifier;
+  sessionMemoryStore?: import('@pellux/goodvibes-sdk/platform/core/session-memory').SessionMemoryStore;
+  changeTracker?: import('@pellux/goodvibes-sdk/platform/sessions/change-tracker').SessionChangeTracker;
+  planManager?: ShellPlanManagerService;
+  adaptivePlanner?: AdaptivePlanner;
+  sessionOrchestration?: ShellSessionOrchestrationService;
+  operatorClient?: OperatorClient;
+  peerClient?: PeerClient;
+  knowledgeApi?: KnowledgeApi;
+  hookApi?: HookApi;
+  mcpApi?: McpApi;
+  opsApi?: OpsApi;
+  directTransport?: DirectTransport;
+  panelManager: PanelManager;
+  panelHealthMonitor: PanelHealthMonitor;
+  worktreeRegistry: WorktreeRegistry;
+  sandboxSessionRegistry: SandboxSessionRegistry;
+  loadSystemPrompt: () => string;
+  activatePlan: (planId: string, task: string) => void;
+  completeModelSelectionSideEffect?: () => void;
+  sessionLineageTracker?: import('@pellux/goodvibes-sdk/platform/core/session-lineage').SessionLineageTracker;
+};
+
+export function createBootstrapCommandContext(
+  options: CreateBootstrapCommandContextOptions,
+): CommandContext {
+  const {
+    providerRegistry,
+    configManager,
+    conversation,
+    runtime,
+    requestRender,
+    keybindingsManager,
+    requestPermission,
+    toolRegistry,
+    mcpRegistry,
+    forensicsRegistry,
+    policyRuntimeState,
+    readModels,
+    shellPaths,
+    remoteRuntime,
+    planRuntime,
+    fileUndoManager,
+    memoryRegistry,
+    integrationHelpers,
+    automationManager,
+    knowledgeService,
+    providerOptimizer,
+    pluginManager,
+    hookWorkbench,
+    agentManager,
+    modeManager,
+    sessionManager,
+    profileManager,
+    bookmarkManager,
+    favoritesStore,
+    benchmarkStore,
+    providerApi,
+    subscriptionManager,
+    secretsManager,
+    serviceRegistry,
+    localUserAuthManager,
+    tokenAuditor,
+    replayEngine,
+    webhookNotifier,
+    sessionMemoryStore,
+    sessionLineageTracker,
+    changeTracker,
+    planManager,
+    adaptivePlanner,
+    sessionOrchestration,
+    operatorClient,
+    peerClient,
+    knowledgeApi,
+    hookApi,
+    mcpApi,
+    opsApi,
+    directTransport,
+    panelManager,
+    panelHealthMonitor,
+    worktreeRegistry,
+    sandboxSessionRegistry,
+    loadSystemPrompt,
+    activatePlan,
+    completeModelSelectionSideEffect,
+  } = options;
+
+  const shellServices = createBootstrapCommandShellServices({
+    agentManager,
+    automationManager,
+    modeManager,
+    planManager,
+    adaptivePlanner,
+    sessionOrchestration,
+    shellPaths,
+    panelHealthMonitor,
+    worktreeRegistry,
+    sandboxSessionRegistry,
+    readModels,
+    serviceRegistry,
+    subscriptionManager,
+    secretsManager,
+    localUserAuthManager,
+    tokenAuditor,
+    replayEngine,
+    webhookNotifier,
+    remoteRuntime,
+    planRuntime,
+    forensicsRegistry,
+    policyRuntimeState,
+    memoryRegistry,
+    integrationHelpers,
+    knowledgeService,
+    pluginManager,
+    hookWorkbench,
+  });
+  const session = createBootstrapCommandSessionSection({
+    conversation,
+    runtime,
+    sessionManager,
+    sessionMemoryStore,
+    sessionLineageTracker,
+    changeTracker,
+  });
+  const provider = createBootstrapCommandProviderSection({
+    providerRegistry,
+    providerOptimizer,
+    favoritesStore,
+    benchmarkStore,
+  });
+  const workspace = createBootstrapCommandWorkspaceSection({
+    keybindingsManager,
+    fileUndoManager,
+    panelManager,
+    profileManager,
+    bookmarkManager,
+  }, shellServices);
+  const platform = createBootstrapCommandPlatformSection({ configManager }, shellServices);
+  const extensions = createBootstrapCommandExtensionsSection({
+    toolRegistry,
+    mcpRegistry,
+  }, shellServices);
+  const clients = createBootstrapCommandClientsSection({
+    operatorClient,
+    peerClient,
+    providerApi,
+    knowledgeApi,
+    hookApi,
+    mcpApi,
+    opsApi,
+    directTransport,
+  });
+  const actions = createBootstrapCommandActions({
+    providerRegistry,
+    configManager,
+    conversation,
+    runtime,
+    requestRender,
+    panelManager,
+    loadSystemPrompt,
+    activatePlan,
+    requestPermission,
+    completeModelSelectionSideEffect,
+  });
+
+  return {
+    session,
+    provider,
+    workspace,
+    platform,
+    ops: createBootstrapCommandOpsSection(shellServices),
+    extensions,
+    clients,
+    ...actions,
+  };
+}