@pellux/goodvibes-tui 0.18.4

package/src/runtime/ui-events.ts

@@ -0,0 +1,46 @@
+import type {
+  AgentEvent,
+  AnyRuntimeEvent,
+  OpsEvent,
+  PlannerEvent,
+  ProviderEvent,
+  RuntimeEventBus,
+  RuntimeEventEnvelope,
+  SessionEvent,
+  ToolEvent,
+  TurnEvent,
+  WorkflowEvent,
+} from './events/index.ts';
+import { createRuntimeEventFeed, type RuntimeEventFeed } from '@pellux/goodvibes-sdk/platform/runtime/event-feeds';
+
+export type UiEventFeed<TEvent extends AnyRuntimeEvent> = RuntimeEventFeed<TEvent>;
+
+export interface UiRuntimeEvents {
+  readonly sessions: UiEventFeed<SessionEvent>;
+  readonly turns: UiEventFeed<TurnEvent>;
+  readonly tools: UiEventFeed<ToolEvent>;
+  readonly providers: UiEventFeed<ProviderEvent>;
+  readonly agents: UiEventFeed<AgentEvent>;
+  readonly workflows: UiEventFeed<WorkflowEvent>;
+  readonly planner: UiEventFeed<PlannerEvent>;
+  readonly ops: UiEventFeed<OpsEvent>;
+}
+
+function createUiEventFeed<TEvent extends AnyRuntimeEvent>(runtimeBus: RuntimeEventBus): UiEventFeed<TEvent> {
+  return createRuntimeEventFeed<TEvent>((type, listener) => (
+    runtimeBus.on(type as TEvent['type'], listener as (envelope: RuntimeEventEnvelope<TEvent['type'], TEvent>) => void)
+  ));
+}
+
+export function createUiRuntimeEvents(runtimeBus: RuntimeEventBus): UiRuntimeEvents {
+  return {
+    sessions: createUiEventFeed<SessionEvent>(runtimeBus),
+    turns: createUiEventFeed<TurnEvent>(runtimeBus),
+    tools: createUiEventFeed<ToolEvent>(runtimeBus),
+    providers: createUiEventFeed<ProviderEvent>(runtimeBus),
+    agents: createUiEventFeed<AgentEvent>(runtimeBus),
+    workflows: createUiEventFeed<WorkflowEvent>(runtimeBus),
+    planner: createUiEventFeed<PlannerEvent>(runtimeBus),
+    ops: createUiEventFeed<OpsEvent>(runtimeBus),
+  };
+}

package/src/runtime/ui-read-model-helpers.ts

@@ -0,0 +1,32 @@
+import type { RuntimeServices } from './services.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+
+export function combineSubscriptions(...teardowns: Array<() => void>): () => void {
+  return () => {
+    for (const teardown of teardowns) {
+      teardown();
+    }
+  };
+}
+
+export function createStoreBackedReadModel<TSnapshot>(
+  runtimeServices: RuntimeServices,
+  getSnapshot: () => TSnapshot,
+): UiReadModel<TSnapshot> {
+  return {
+    getSnapshot,
+    subscribe(listener) {
+      return runtimeServices.runtimeStore.subscribe(listener);
+    },
+  };
+}
+
+export function listProviderIds(runtimeServices: RuntimeServices): readonly string[] {
+  const providerIds = new Set<string>(
+    runtimeServices.providerRegistry.listProviders().map((provider) => provider.name),
+  );
+  for (const model of runtimeServices.providerRegistry.listModels()) {
+    providerIds.add(model.provider);
+  }
+  return [...providerIds].sort();
+}

package/src/runtime/ui-read-models-core.ts

@@ -0,0 +1,95 @@
+import type { RuntimeServices } from './services.ts';
+import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import type { RuntimeAgent } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+import type { SessionDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
+import type { TurnState } from './store/domains/conversation.ts';
+import { createStoreBackedReadModel, listProviderIds } from './ui-read-model-helpers.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+
+export interface UiProvidersSnapshot {
+  readonly providerIds: readonly string[];
+}
+
+export interface UiSessionSnapshot {
+  readonly session: SessionDomainState;
+  readonly totalTurns: number;
+  readonly messageCount: number;
+  readonly estimatedContextTokens: number;
+  readonly contextWindow: number;
+  readonly turnState: TurnState;
+  readonly streamToolPreview?: string;
+  readonly contextWarningActive: boolean;
+  readonly pendingApproval: boolean;
+  readonly denialCount: number;
+}
+
+export interface UiAgentsSnapshot {
+  readonly active: readonly RuntimeAgent[];
+  readonly totalSpawned: number;
+  readonly totalCompleted: number;
+  readonly totalFailed: number;
+}
+
+export interface UiTasksSnapshot {
+  readonly tasks: readonly RuntimeTask[];
+}
+
+export interface UiCoreReadModels {
+  readonly providers: UiReadModel<UiProvidersSnapshot>;
+  readonly session: UiReadModel<UiSessionSnapshot>;
+  readonly agents: UiReadModel<UiAgentsSnapshot>;
+  readonly tasks: UiReadModel<UiTasksSnapshot>;
+}
+
+export function createCoreReadModels(runtimeServices: RuntimeServices): UiCoreReadModels {
+  const { runtimeStore } = runtimeServices;
+
+  return {
+    providers: {
+      getSnapshot() {
+        return {
+          providerIds: listProviderIds(runtimeServices),
+        };
+      },
+      subscribe(listener) {
+        return runtimeServices.runtimeBus.on('PROVIDERS_CHANGED', listener);
+      },
+    },
+    session: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState();
+      return {
+        session: state.session,
+        totalTurns: state.conversation.totalTurns,
+        messageCount: state.conversation.messageCount,
+        estimatedContextTokens: state.conversation.estimatedContextTokens,
+        contextWindow: state.model.tokenLimits.contextWindow,
+        turnState: state.conversation.turnState,
+        streamToolPreview: state.conversation.stream.partialToolPreview,
+        contextWarningActive: state.conversation.contextWarningActive,
+        pendingApproval: state.permissions.awaitingDecision,
+        denialCount: state.permissions.denialCount,
+      };
+    }),
+    agents: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState().agents;
+      const active = state.activeAgentIds
+        .map((id) => state.agents.get(id))
+        .filter((agent): agent is RuntimeAgent => agent !== undefined);
+      return {
+        active,
+        totalSpawned: state.totalSpawned,
+        totalCompleted: state.totalCompleted,
+        totalFailed: state.totalFailed,
+      };
+    }),
+    tasks: createStoreBackedReadModel(runtimeServices, () => {
+      const tasksState = runtimeStore.getState().tasks;
+      const tasks = [...tasksState.tasks.values()].sort((a, b) => {
+        const aTime = a.startedAt ?? a.queuedAt;
+        const bTime = b.startedAt ?? b.queuedAt;
+        return bTime - aTime || a.title.localeCompare(b.title);
+      });
+      return { tasks };
+    }),
+  };
+}

package/src/runtime/ui-read-models-observability-maintenance.ts

@@ -0,0 +1,81 @@
+import type { RuntimeServices } from './services.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+import { createStoreBackedReadModel } from './ui-read-model-helpers.ts';
+import type {
+  ContinuitySnapshot as IntegrationContinuitySnapshot,
+  SettingsSnapshot as IntegrationSettingsSnapshot,
+  WorktreeSnapshot as IntegrationWorktreeSnapshot,
+} from './integration/helpers.ts';
+import type { SessionReturnContextSummary } from './session-return-context.ts';
+import type { ManagedWorktreeMeta } from './worktree/registry.ts';
+
+export interface UiSettingsSnapshot {
+  readonly available: boolean;
+  readonly conflictCount: number;
+  readonly recentFailureCount: number;
+  readonly managedLockCount: number;
+  readonly hasStagedManagedBundle: boolean;
+}
+
+export interface UiContinuitySnapshot {
+  readonly sessionId: string;
+  readonly status: string;
+  readonly recoveryState: string;
+  readonly lastSessionPointer: string | null;
+  readonly recoveryFilePresent: boolean;
+  readonly recoveryFile: Record<string, unknown> | null;
+  readonly returnContext?: SessionReturnContextSummary;
+}
+
+export interface UiWorktreeSnapshot {
+  readonly summary: {
+    readonly total: number;
+    readonly active: number;
+    readonly paused: number;
+    readonly cleanupPending: number;
+    readonly discard: number;
+  };
+  readonly records: readonly ManagedWorktreeMeta[];
+}
+
+export interface UiMaintenanceObservabilityReadModels {
+  readonly settings: UiReadModel<UiSettingsSnapshot>;
+  readonly continuity: UiReadModel<UiContinuitySnapshot>;
+  readonly worktrees: UiReadModel<UiWorktreeSnapshot>;
+}
+
+export function createMaintenanceObservabilityReadModels(runtimeServices: RuntimeServices): UiMaintenanceObservabilityReadModels {
+  return {
+    settings: {
+      getSnapshot() {
+        const snapshot = runtimeServices.integrationHelpers.getSettingsSnapshot() as IntegrationSettingsSnapshot;
+        return {
+          available: snapshot.available,
+          conflictCount: snapshot.available ? snapshot.conflicts.length : 0,
+          recentFailureCount: snapshot.available ? snapshot.recentFailures.length : 0,
+          managedLockCount: snapshot.available ? snapshot.managedLockCount : 0,
+          hasStagedManagedBundle: snapshot.available ? Boolean(snapshot.stagedManagedBundle) : false,
+        };
+      },
+      subscribe() {
+        return () => {};
+      },
+    },
+    continuity: createStoreBackedReadModel(runtimeServices, () => {
+      const snapshot = runtimeServices.integrationHelpers.getContinuitySnapshot() as IntegrationContinuitySnapshot;
+      return snapshot;
+    }),
+    worktrees: {
+      getSnapshot() {
+        const snapshot = runtimeServices.integrationHelpers.getWorktreeSnapshot() as IntegrationWorktreeSnapshot;
+        return {
+          summary: snapshot.summary,
+          records: snapshot.records,
+        };
+      },
+      subscribe() {
+        return () => {};
+      },
+    },
+  };
+}

package/src/runtime/ui-read-models-observability-options.ts

@@ -0,0 +1,5 @@
+import type { ForensicsRegistry } from './forensics/index.ts';
+
+export interface UiObservabilityReadModelOptions {
+  readonly forensicsRegistry?: ForensicsRegistry;
+}

package/src/runtime/ui-read-models-observability-remote.ts

@@ -0,0 +1,73 @@
+import type { RuntimeServices } from './services.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+import { createStoreBackedReadModel } from './ui-read-model-helpers.ts';
+import type { RemoteSupervisorSnapshot } from './remote/supervisor.ts';
+import type { DistributedPendingWork, DistributedPeerRecord, DistributedRuntimePairRequest } from '@pellux/goodvibes-sdk/platform/runtime/remote/distributed-runtime-types';
+
+export interface UiRemoteSnapshot {
+  readonly daemon: {
+    readonly transportState: string;
+    readonly isRunning: boolean;
+    readonly reconnectAttempts: number;
+    readonly runningJobCount: number;
+    readonly lastError?: string;
+  };
+  readonly acp: {
+    readonly transportState: string;
+    readonly totalMessages: number;
+    readonly activeConnections: readonly import('@pellux/goodvibes-sdk/platform/runtime/store/domains/acp').AcpConnection[];
+  };
+  readonly pools: ReturnType<RuntimeServices['remoteRunnerRegistry']['listPools']>;
+  readonly contracts: ReturnType<RuntimeServices['remoteRunnerRegistry']['listContracts']>;
+  readonly artifacts: ReturnType<RuntimeServices['remoteRunnerRegistry']['listArtifacts']>;
+  readonly supervisor: RemoteSupervisorSnapshot;
+  readonly distributed: {
+    readonly pairRequests: readonly DistributedRuntimePairRequest[];
+    readonly peers: readonly DistributedPeerRecord[];
+    readonly work: readonly DistributedPendingWork[];
+  };
+}
+
+export interface UiRemoteReadModels {
+  readonly remote: UiReadModel<UiRemoteSnapshot>;
+}
+
+export function createRemoteReadModels(runtimeServices: RuntimeServices): UiRemoteReadModels {
+  const { runtimeStore } = runtimeServices;
+
+  return {
+    remote: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState();
+      const distributedRaw = runtimeServices.distributedRuntime.getSnapshot() as {
+        pairRequests?: readonly DistributedRuntimePairRequest[];
+        peers?: readonly DistributedPeerRecord[];
+        work?: readonly DistributedPendingWork[];
+      };
+      return {
+        daemon: {
+          transportState: state.daemon.transportState,
+          isRunning: state.daemon.isRunning,
+          reconnectAttempts: state.daemon.reconnectAttempts,
+          runningJobCount: state.daemon.runningJobCount,
+          lastError: state.daemon.lastError,
+        },
+        acp: {
+          transportState: state.acp.managerTransportState,
+          totalMessages: state.acp.totalMessages,
+          activeConnections: state.acp.activeConnectionIds
+            .map((id) => state.acp.connections.get(id))
+            .filter((connection): connection is import('@pellux/goodvibes-sdk/platform/runtime/store/domains/acp').AcpConnection => connection !== undefined),
+        },
+        pools: runtimeServices.remoteRunnerRegistry.listPools(),
+        contracts: runtimeServices.remoteRunnerRegistry.listContracts(),
+        artifacts: runtimeServices.remoteRunnerRegistry.listArtifacts(),
+        supervisor: runtimeServices.remoteSupervisor.getSnapshot(runtimeStore),
+        distributed: {
+          pairRequests: distributedRaw.pairRequests ?? [],
+          peers: distributedRaw.peers ?? [],
+          work: distributedRaw.work ?? [],
+        },
+      };
+    }),
+  };
+}

package/src/runtime/ui-read-models-observability-security.ts

@@ -0,0 +1,172 @@
+import { buildMcpAttackPathReview } from './mcp/index.ts';
+import type { McpDecisionRecord, McpSecuritySnapshot } from '@pellux/goodvibes-sdk/platform/runtime/mcp/types';
+import type { RuntimeServices } from './services.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+import { combineSubscriptions } from './ui-read-model-helpers.ts';
+import type { SecurityPanelSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/security';
+import type { PluginStatus } from '../plugins/manager.ts';
+
+export interface UiMcpServerSnapshot {
+  readonly name: string;
+  readonly role: string;
+  readonly trustMode: string;
+  readonly status: string;
+  readonly schemaFreshness: string;
+  readonly toolCount: number;
+  readonly lastError?: string;
+  readonly quarantineReason?: string;
+  readonly quarantineDetail?: string;
+}
+
+export interface UiSecuritySnapshot {
+  readonly audit: SecurityPanelSnapshot;
+  readonly policy: {
+    readonly preflightStatus: string;
+    readonly preflightIssueCount: number;
+    readonly lintFindingCount: number;
+  };
+  readonly deniedPermissions: number;
+  readonly incidents: ReturnType<import('./forensics/index.ts').ForensicsRegistry['getAll']>;
+  readonly latestIncident: ReturnType<import('./forensics/index.ts').ForensicsRegistry['latest']>;
+  readonly mcpServers: readonly McpSecuritySnapshot[];
+  readonly recentMcpDecisions: readonly McpDecisionRecord[];
+  readonly attackPathReview: ReturnType<typeof buildMcpAttackPathReview>;
+  readonly plugins: readonly PluginStatus[];
+  readonly quarantinedPlugins: readonly PluginStatus[];
+  readonly untrustedPlugins: readonly PluginStatus[];
+}
+
+export interface UiMcpSnapshot {
+  readonly servers: readonly UiMcpServerSnapshot[];
+  readonly connectedServerNames: readonly string[];
+  readonly availableToolCount: number;
+  readonly totalCalls: number;
+  readonly totalErrors: number;
+  readonly recentDecisions: readonly McpDecisionRecord[];
+}
+
+export interface UiLocalAuthSnapshot {
+  readonly bootstrapCredentialPresent: boolean;
+  readonly userCount: number;
+  readonly sessionCount: number;
+}
+
+export interface UiSecurityObservabilityReadModels {
+  readonly security: UiReadModel<UiSecuritySnapshot>;
+  readonly mcp: UiReadModel<UiMcpSnapshot>;
+  readonly localAuth: UiReadModel<UiLocalAuthSnapshot>;
+}
+
+export function createSecurityObservabilityReadModels(
+  runtimeServices: RuntimeServices,
+  options: import('./ui-read-models-observability-options.ts').UiObservabilityReadModelOptions = {},
+): UiSecurityObservabilityReadModels {
+  const { runtimeStore } = runtimeServices;
+
+  return {
+    security: {
+      getSnapshot() {
+        const audit = runtimeServices.tokenAuditor.auditAll(Date.now());
+        const mcpServers = [...runtimeStore.getState().mcp.servers.values()].map((server): McpSecuritySnapshot => ({
+          name: server.name,
+          role: server.role,
+          trustMode: server.trustMode,
+          allowedPaths: server.allowedPaths,
+          allowedHosts: server.allowedHosts,
+          schemaFreshness: server.schemaFreshness,
+          quarantineReason: server.quarantineReason,
+          quarantineDetail: server.quarantineDetail,
+          connected: server.status === 'connected' || server.status === 'degraded',
+        }));
+        const recentMcpDecisions = runtimeServices.mcpRegistry.listRecentSecurityDecisions(8);
+        const attackPathReview = buildMcpAttackPathReview({
+          servers: mcpServers,
+          recentDecisions: recentMcpDecisions,
+        });
+        const plugins = runtimeServices.pluginManager.list();
+        const policySnapshot = runtimeServices.policyRuntimeState.getSnapshot();
+        const snapshot: SecurityPanelSnapshot = {
+          managed: runtimeServices.tokenAuditor.isManaged,
+          totalTokens: runtimeServices.tokenAuditor.tokenCount,
+          results: audit.results,
+          blocked: audit.blocked,
+          scopeViolations: audit.scopeViolations,
+          rotationWarnings: audit.rotationWarnings,
+          rotationOverdue: audit.rotationOverdue,
+          lastAuditAt: audit.capturedAt,
+          capturedAt: new Date().toISOString(),
+        };
+        return {
+          audit: snapshot,
+          policy: {
+            preflightStatus: policySnapshot.lastPreflightReview?.status ?? 'n/a',
+            preflightIssueCount: policySnapshot.lastPreflightReview?.issueCount ?? 0,
+            lintFindingCount: policySnapshot.lintFindings.length,
+          },
+          deniedPermissions: runtimeStore.getState().permissions.denialCount,
+          incidents: options.forensicsRegistry?.getAll() ?? [],
+          latestIncident: options.forensicsRegistry?.latest(),
+          mcpServers,
+          recentMcpDecisions,
+          attackPathReview,
+          plugins,
+          quarantinedPlugins: plugins.filter((plugin) => plugin.quarantined),
+          untrustedPlugins: plugins.filter((plugin) => plugin.trustTier === 'untrusted'),
+        };
+      },
+      subscribe(listener) {
+        const unsubs: Array<() => void> = [
+          runtimeStore.subscribe(listener),
+          runtimeServices.pluginManager.subscribe(listener),
+          runtimeServices.policyRuntimeState.subscribe(listener),
+        ];
+        if (options.forensicsRegistry) {
+          unsubs.push(options.forensicsRegistry.subscribe(listener));
+        }
+        return combineSubscriptions(...unsubs);
+      },
+    },
+    mcp: {
+      getSnapshot() {
+        const state = runtimeStore.getState().mcp;
+        const servers = [...state.servers.values()]
+          .map((server): UiMcpServerSnapshot => ({
+            name: server.name,
+            role: server.role,
+            trustMode: server.trustMode,
+            status: server.status,
+            schemaFreshness: server.schemaFreshness,
+            toolCount: server.toolCount,
+            lastError: server.lastError,
+            quarantineReason: server.quarantineReason,
+            quarantineDetail: server.quarantineDetail,
+          }))
+          .sort((a, b) => a.name.localeCompare(b.name));
+        return {
+          servers,
+          connectedServerNames: state.connectedServerNames,
+          availableToolCount: state.availableToolCount,
+          totalCalls: state.totalCalls,
+          totalErrors: state.totalErrors,
+          recentDecisions: runtimeServices.mcpRegistry.listRecentSecurityDecisions(8),
+        };
+      },
+      subscribe(listener) {
+        return runtimeStore.subscribe(listener);
+      },
+    },
+    localAuth: {
+      getSnapshot() {
+        const snapshot = runtimeServices.localUserAuthManager.inspect();
+        return {
+          bootstrapCredentialPresent: snapshot.bootstrapCredentialPresent,
+          userCount: snapshot.userCount,
+          sessionCount: snapshot.sessionCount,
+        };
+      },
+      subscribe() {
+        return () => {};
+      },
+    },
+  };
+}