@pellux/goodvibes-agent 1.4.3 → 1.5.0

package/src/panels/base-panel.ts

@@ -1,254 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import type { Panel, PanelCategory } from './types.ts';
-import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
-import type { ComponentHealthMonitor } from '../runtime/perf/panel-health-monitor.ts';
-import { UIFactory } from '../renderer/ui-factory.ts';
-import { SPINNER_FRAMES } from '../renderer/progress.ts';
-
-export abstract class BasePanel implements Panel {
-  public needsRender = true;
-  public isTransient = false;
-  public isPinned = false;
-  protected readonly componentHealthMonitor?: ComponentHealthMonitor;
-
-  // -------------------------------------------------------------------------
-  // Timer registry
-  // -------------------------------------------------------------------------
-
-  /** All timers registered via registerTimer(). Cleared automatically on onDestroy(). */
-  private readonly _timers: Set<ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>> = new Set();
-
-  /**
-   * Register a timer id (from setInterval or setTimeout) so it is
-   * automatically cleared when the panel is destroyed. Returns the id
-   * unchanged so the call can be chained inline:
-   *
-   * ```ts
-   * this.registerTimer(setInterval(() => this.refresh(), 5_000));
-   * ```
-   */
-  protected registerTimer<T extends ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>>(id: T): T {
-    this._timers.add(id);
-    return id;
-  }
-
-  /**
-   * Clear a specific timer and remove it from the registry.
-   * Safe to call with an unregistered or already-cleared id.
-   */
-  protected clearTimer(id: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
-    clearInterval(id as ReturnType<typeof setInterval>);
-    this._timers.delete(id);
-  }
-
-  // -------------------------------------------------------------------------
-  // I2: Error surface slot
-  // -------------------------------------------------------------------------
-
-  /**
-   * Last error message to surface in the panel footer.
-   * Auto-cleared on the next keystroke by `ScrollableListPanel.handleInput()` (and any
-   * subclass that calls `super.handleInput()` or manually calls `this.clearError()` at
-   * the start of its handler). BasePanel itself does NOT auto-clear — only subclasses
-   * that opt into the contract do.
-   */
-  protected lastError: string | null = null;
-
-  /**
-   * Set a transient error message. Triggers a re-render.
-   * The error will be auto-cleared on the next keystroke if the panel extends
-   * `ScrollableListPanel` (which calls `clearError()` at the top of `handleInput()`).
-   */
-  protected setError(msg: string): void {
-    this.lastError = msg;
-    this.needsRender = true;
-  }
-
-  /** Clear the current error. */
-  protected clearError(): void {
-    this.lastError = null;
-  }
-
-  /**
-   * Build a single error Line for display above the hints footer.
-   * Returns null when there is no active error.
-   *
-   * Color: bold red foreground (palette-consistent: #ef4444).
-   */
-  protected renderErrorLine(width: number): Line | null {
-    if (!this.lastError) return null;
-    return UIFactory.stringToLine(
-      ` ✕ ${this.lastError}`.padEnd(width).slice(0, width),
-      width,
-      { fg: '#ef4444', bold: true },
-    );
-  }
-
-  // -------------------------------------------------------------------------
-  // I3: Loading spinner slot
-  // -------------------------------------------------------------------------
-
-  /** Tracks the loading label for the spinner (undefined = no spinner active). */
-  protected loadingState: 'idle' | 'loading' | 'error' = 'idle';
-  private _loadingLabel = '';
-
-  /** Begin loading. Triggers a re-render. */
-  protected startLoading(label = 'Loading...'): void {
-    this.loadingState = 'loading';
-    this._loadingLabel = label;
-    this.needsRender = true;
-  }
-
-  /** End loading (returns to idle). Triggers a re-render. */
-  protected stopLoading(): void {
-    this.loadingState = 'idle';
-    this._loadingLabel = '';
-    this.needsRender = true;
-  }
-
-  /**
-   * Run an async operation with the panel's loading spinner visible.
-   * The spinner is always cleared on completion, whether the operation succeeds or throws
-   * (uses try/finally). Rethrows any error so callers can handle it or forward to setError.
-   *
-   * @param label Optional label shown next to the spinner.
-   * @param fn    The async work to run.
-   *
-   * @example
-   * ```ts
-   * try {
-   *   await this.withLoading('Loading diff…', () => this.fetchDiff());
-   * } catch (err) {
-   *   this.setError(summarizeError(err));
-   * }
-   * ```
-   */
-  protected async withLoading<T>(label: string | undefined, fn: () => Promise<T>): Promise<T> {
-    this.startLoading(label);
-    try {
-      return await fn();
-    } finally {
-      this.stopLoading();
-    }
-  }
-
-  /**
-   * Build a spinner Line for the loading state.
-   * Returns null when loadingState is not 'loading'.
-   *
-   * @param width  Panel width in columns.
-   * @param frame  Current animation frame index (caller increments each render).
-   */
-  protected renderLoadingLine(width: number, frame = 0): Line | null {
-    if (this.loadingState !== 'loading') return null;
-    const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0]!;
-    const text = ` ${spinner} ${this._loadingLabel}`;
-    return UIFactory.stringToLine(text.padEnd(width).slice(0, width), width, { fg: '135', bold: true });
-  }
-
-  /**
-   * Optional resource contract for this panel.
-   * Override in subclasses to declare a custom contract; leave undefined
-   * to use the category default enforced by ComponentHealthMonitor.
-   */
-  public resourceContract: Readonly<ComponentResourceContract> | undefined = undefined;
-
-  /**
-   * Live health state populated by ComponentHealthMonitor.
-   * Read-only from outside the monitor.
-   */
-  public get healthState(): Readonly<ComponentHealthState> | undefined {
-    return this.componentHealthMonitor?.getHealth(this.id);
-  }
-
-  constructor(
-    public readonly id: string,
-    public readonly name: string,
-    public readonly icon: string,
-    public readonly category: PanelCategory,
-    componentHealthMonitor?: ComponentHealthMonitor,
-  ) {
-    this.componentHealthMonitor = componentHealthMonitor;
-  }
-
-  onActivate(): void { this.needsRender = true; }
-  onDeactivate(): void {}
-
-  /**
-   * Called when the panel is permanently removed. Subclasses should call
-   * `super.onDestroy()` to ensure all registered timers are cleared.
-   */
-  onDestroy(): void {
-    for (const id of this._timers) {
-      clearInterval(id as ReturnType<typeof setInterval>);
-    }
-    this._timers.clear();
-  }
-
-  abstract render(width: number, height: number): Line[];
-
-  /** R2: Mark this panel dirty — it will be re-rendered on the next compositor frame. */
-  public invalidate(): void { this.needsRender = true; }
-
-  /** R2: Called by the compositor after a successful render to clear the dirty flag. */
-  public markRendered(): void { this.needsRender = false; }
-
-  protected markDirty(): void { this.needsRender = true; }
-
-  /**
-   * Check whether the panel is currently permitted to render.
-   *
-   * Consults the shared ComponentHealthMonitor. Returns true if not registered
-   * (unthrottled) or if the monitor permits a render at this moment.
-   *
-   * Call this inside render() or before invoking render() to skip
-   * expensive work when throttled:
-   *
-   * ```ts
-   * render(width, height): Line[] {
-   *   if (!this.canRenderNow()) return this._lastLines ?? [];
-   *   // ... expensive render ...
-   * }
-   * ```
-   */
-  protected canRenderNow(now: number = Date.now()): boolean {
-    return this.componentHealthMonitor?.canRender(this.id, now) ?? true;
-  }
-
-  /**
-   * Report the duration of a completed render to the health monitor.
-   * Call this at the end of render() after measuring wall-clock cost.
-   */
-  protected reportRenderDuration(durationMs: number, now: number = Date.now()): void {
-    this.componentHealthMonitor?.recordRender(this.id, durationMs, now);
-  }
-
-  /** Cache of the most recent lines produced by trackedRender. */
-  private _lastTrackedLines: Line[] = [];
-
-  /**
-   * Wrap a render body with canRenderNow throttle check, wall-clock timing,
-   * and automatic reportRenderDuration.
-   *
-   * When throttled, returns the previously cached lines (stale but correctly
-   * sized) rather than empty lines, avoiding a flicker on every skipped frame.
-   *
-   * Usage:
-   * ```ts
-   * render(width: number, height: number): Line[] {
-   *   return this.trackedRender(() => {
-   *     // expensive render logic
-   *     return lines;
-   *   });
-   * }
-   * ```
-   */
-  protected trackedRender(fn: () => Line[]): Line[] {
-    if (!this.canRenderNow()) return this._lastTrackedLines;
-    const start = Date.now();
-    const lines = fn();
-    this.reportRenderDuration(Date.now() - start);
-    this._lastTrackedLines = lines;
-    return lines;
-  }
-}

package/src/panels/builtin/agent.ts

@@ -1,58 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { ContextVisualizerPanel } from '../context-visualizer-panel.ts';
-import { ThinkingPanel } from '../thinking-panel.ts';
-import { ToolInspectorPanel } from '../tool-inspector-panel.ts';
-import { SchedulePanel } from '../schedule-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireAutomationManager, requireUiServices } from './shared.ts';
-
-export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  manager.registerType({
-    id: 'thinking',
-    name: 'Thinking',
-    icon: 'T',
-    category: 'ai',
-    description: 'Stream model reasoning tokens in real-time with collapsible blocks per turn',
-    preload: true,
-    factory: () => new ThinkingPanel(requireUiServices(deps).events.turns),
-  });
-
-  manager.registerType({
-    id: 'tools',
-    name: 'Tools',
-    icon: 'X',
-    category: 'ai',
-    description: 'Chronological tool call inspector with expandable args/results and filtering',
-    preload: true,
-    factory: () => {
-      const ui = requireUiServices(deps);
-      return new ToolInspectorPanel(ui.events.tools, ui.events.turns);
-    },
-  });
-
-  manager.registerType({
-    id: 'context',
-    name: 'Context',
-    icon: 'C',
-    category: 'ai',
-    description: 'Context window visualizer: stacked bar showing token usage per section',
-    preload: true,
-    factory: () => new ContextVisualizerPanel(
-      requireUiServices(deps).events.turns,
-      deps.sessionMemoryStore,
-      deps.configManager,
-      deps.getOrchestratorUsage,
-      deps.contextWindow,
-      requireUiServices(deps).readModels.session,
-    ),
-  });
-
-  manager.registerType({
-    id: 'schedule',
-    name: 'Schedule',
-    icon: 'Z',
-    category: 'agent',
-    description: 'Read-only schedule posture from the connected GoodVibes host; Agent-local schedule mutation is blocked',
-    factory: () => new SchedulePanel(requireAutomationManager(deps)),
-  });
-}

package/src/panels/builtin/knowledge.ts

@@ -1,26 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { MemoryPanel } from '../memory-panel.ts';
-import { KnowledgePanel } from '../knowledge-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-
-export function registerKnowledgePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  if (!deps.memoryRegistry) return;
-
-  const { agentKnowledgeService, memoryRegistry } = deps;
-  manager.registerType({
-    id: 'knowledge',
-    name: 'Knowledge',
-    icon: 'K',
-    category: 'agent',
-    description: 'Isolated Agent Knowledge plus local non-secret memory review',
-    factory: () => new KnowledgePanel(memoryRegistry, agentKnowledgeService ?? null),
-  });
-  manager.registerType({
-    id: 'memory',
-    name: 'Memory',
-    icon: 'M',
-    category: 'agent',
-    description: 'Project memory: decisions, constraints, incidents, and patterns with provenance links',
-    factory: () => new MemoryPanel(memoryRegistry),
-  });
-}

package/src/panels/builtin/operations.ts

@@ -1,121 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { ApprovalPanel } from '../approval-panel.ts';
-import { AutomationControlPanel } from '../automation-control-panel.ts';
-import { SubscriptionPanel } from '../subscription-panel.ts';
-import { ProviderAccountsPanel } from '../provider-accounts-panel.ts';
-import { SecurityPanel } from '../security-panel.ts';
-import { TasksPanel } from '../tasks-panel.ts';
-import { ProviderStatsPanel } from '../provider-stats-panel.ts';
-import { ProviderHealthPanel } from '../provider-health-panel.ts';
-import { createProviderAccountSnapshotQuery } from '../provider-account-snapshot.ts';
-import {
-  createEnvironmentVariableQuery,
-  createProviderRuntimeInspectionQuery,
-} from '../../runtime/ui-service-queries.ts';
-import { createRuntimeProviderApi } from '@/runtime/index.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireUiServices } from './shared.ts';
-
-export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  const ui = requireUiServices(deps);
-  const providerRuntime = createProviderRuntimeInspectionQuery(createRuntimeProviderApi({
-    benchmarkStore: ui.providers.benchmarkStore,
-    favoritesStore: ui.providers.favoritesStore,
-    providerRegistry: ui.providers.providerRegistry,
-  }));
-  const providerAccounts = createProviderAccountSnapshotQuery({
-    providerModels: deps.providerRegistry,
-    services: deps.serviceRegistry,
-    subscriptions: deps.subscriptionManager,
-    environment: createEnvironmentVariableQuery(process.env),
-  });
-
-  manager.registerType({
-    id: 'approval',
-    name: 'Approval',
-    icon: 'A',
-    category: 'monitoring',
-    description: 'Action-specific approval workspace for why-prompted, why-denied, and what-if review',
-    factory: () => new ApprovalPanel(deps.policyRuntimeState),
-  });
-
-  manager.registerType({
-    id: 'automation',
-    name: 'Automation',
-    icon: 'M',
-    category: 'monitoring',
-    description: 'Read-only automation jobs, runs, deliveries, and failure posture from the connected GoodVibes host',
-    factory: () => new AutomationControlPanel(ui.readModels.automation),
-  });
-
-  manager.registerType({
-    id: 'subscription',
-    name: 'Subscriptions',
-    icon: 'B',
-    category: 'monitoring',
-    description: 'OAuth-backed provider subscriptions and supported provider override posture',
-    factory: () => new SubscriptionPanel(deps.serviceRegistry, deps.subscriptionManager),
-  });
-
-  manager.registerType({
-    id: 'accounts',
-    name: 'Accounts',
-    icon: 'Q',
-    category: 'monitoring',
-    description: 'Provider auth routes, subscription quota-window hints, and billing-path safety notes',
-    factory: () => new ProviderAccountsPanel({ providerAccounts }),
-  });
-
-  manager.registerType({
-    id: 'security',
-    name: 'Security',
-    icon: 'U',
-    category: 'monitoring',
-    description: 'Security review workspace for token posture, policy posture, MCP quarantine, and incident pressure',
-    factory: () => new SecurityPanel(ui.readModels.security),
-  });
-
-  manager.registerType({
-    id: 'tasks',
-    name: 'Tasks',
-    icon: 'J',
-    category: 'monitoring',
-    description: 'Queued, running, blocked, failed, and completed task summaries from the connected GoodVibes host',
-    factory: () => new TasksPanel(ui.readModels.tasks),
-  });
-
-  manager.registerType({
-    id: 'providers',
-    name: 'Providers',
-    icon: 'R',
-    category: 'monitoring',
-    description: 'Per-provider performance metrics: latency, error rate, request count, sparkline trends',
-    factory: () => new ProviderStatsPanel(ui.events.turns, ui.events.providers, deps.requestRender, ui.readModels.providers),
-  });
-
-  manager.registerType({
-    id: 'provider-health',
-    name: 'Health',
-    icon: 'N',
-    category: 'monitoring',
-    description: 'Provider health dashboard: real-time status, latency, errors, and rate-limit cooldowns',
-    preload: true,
-    factory: () => new ProviderHealthPanel(
-      providerRuntime,
-      {
-        configManager: deps.configManager,
-        turnEvents: ui.events.turns,
-        providerEvents: ui.events.providers,
-        providers: ui.readModels.providers,
-        session: ui.readModels.session,
-        security: ui.readModels.security,
-        localAuth: ui.readModels.localAuth,
-        settings: ui.readModels.settings,
-        remote: ui.readModels.remote,
-        continuity: ui.readModels.continuity,
-      },
-      deps.requestRender,
-    ),
-  });
-
-}

package/src/panels/builtin/session.ts

@@ -1,138 +0,0 @@
-import { networkInterfaces } from 'node:os';
-import { existsSync, readFileSync } from 'node:fs';
-import type { PanelManager } from '../panel-manager.ts';
-import { SessionBrowserPanel } from '../session-browser-panel.ts';
-import { QrPanel } from '../qr-panel.ts';
-import { DocsPanel } from '../docs-panel.ts';
-import { PanelListPanel } from '../panel-list-panel.ts';
-import { TokenBudgetPanel } from '../token-budget-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireUiServices } from './shared.ts';
-import {
-  buildCompanionConnectionInfo,
-} from '@pellux/goodvibes-sdk/platform/pairing';
-import { copyToClipboard } from '../../utils/clipboard.ts';
-import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../../config/surface.ts';
-
-function getLocalNetworkIp(): string {
-  const nets = networkInterfaces();
-  for (const name of Object.keys(nets)) {
-    for (const net of nets[name] ?? []) {
-      if (net.family === 'IPv4' && !net.internal) {
-        return net.address;
-      }
-    }
-  }
-  return 'localhost';
-}
-
-function readBootstrapPassword(credentialPath: string): string | undefined {
-  try {
-    const content = readFileSync(credentialPath, 'utf-8');
-    for (const line of content.split('\n')) {
-      if (line.startsWith('password=')) {
-        return line.slice('password='.length).trim();
-      }
-    }
-  } catch {
-    // credential file may not exist yet
-  }
-  return undefined;
-}
-
-function readOperatorToken(tokenPath: string): string | null {
-  if (!existsSync(tokenPath)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync(tokenPath, 'utf-8')) as unknown;
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
-    const token = 'token' in parsed ? parsed.token : undefined;
-    return typeof token === 'string' && token.trim().length > 0 ? token : null;
-  } catch {
-    return null;
-  }
-}
-
-export function registerSessionPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  manager.registerType({
-    id: 'qr-code',
-    name: 'QR Code',
-    icon: 'Q',
-    category: 'session',
-    description: 'QR code for companion app pairing through the connected GoodVibes host',
-    factory: () => {
-      if (!deps.connectedHostTokenDir) throw new Error('connected host token directory must be provided to the session panel factory via BuiltinPanelDeps');
-      const token = readOperatorToken(`${deps.connectedHostTokenDir}/operator-tokens.json`);
-      const connectedHostPort = deps.configManager.get('controlPlane.port');
-      const connectedHostName = String(process.env['GOODVIBES_AGENT_RUNTIME_HOST'] ?? process.env['GOODVIBES_DAEMON_HOST'] ?? getLocalNetworkIp());
-      const connectedHostUrl = `http://${connectedHostName}:${connectedHostPort}`;
-      const bootstrapPassword = readBootstrapPassword(deps.localUserAuthManager.getBootstrapCredentialPath());
-      const connectionInfo = token
-        ? buildCompanionConnectionInfo({
-          daemonUrl: connectedHostUrl,
-          token,
-          password: bootstrapPassword,
-          surface: GOODVIBES_AGENT_PAIRING_SURFACE,
-        })
-        : {
-          url: connectedHostUrl,
-          token: '',
-          username: 'admin',
-          ...(bootstrapPassword !== undefined ? { password: bootstrapPassword } : {}),
-          surface: GOODVIBES_AGENT_PAIRING_SURFACE,
-        };
-      return new QrPanel(connectionInfo, undefined, copyToClipboard);
-    },
-  });
-
-  manager.registerType({
-    id: 'sessions',
-    name: 'Sessions',
-    icon: 'H',
-    category: 'session',
-    description: 'Browse, search, and resume past conversation sessions',
-    factory: () => new SessionBrowserPanel(deps.sessionManager, deps.resumeSession),
-  });
-
-  manager.registerType({
-    id: 'docs',
-    name: 'Docs',
-    icon: '?',
-    category: 'session',
-    description: 'Tool list, model capabilities, and keyboard shortcut reference',
-    factory: () => new DocsPanel(deps.toolRegistry, deps.providerRegistry),
-  });
-
-  manager.registerType({
-    id: 'panel-list',
-    name: 'Panel List',
-    icon: 'L',
-    category: 'session',
-    description: 'Browse all registered panels grouped by category, with open/closed status and Enter-to-open',
-    factory: () => new PanelListPanel(manager, deps.componentHealthMonitor),
-  });
-
-  manager.registerType({
-    id: 'system-messages',
-    name: 'System Messages',
-    icon: 'J',
-    category: 'monitoring',
-    description: 'Operational system messages routed away from the main conversation (scans, discovery, plugin events, tool status)',
-    preload: true,
-    factory: () => deps.systemMessagesPanel,
-  });
-
-  manager.registerType({
-    id: 'tokens',
-    name: 'Tokens',
-    icon: 'K',
-    category: 'monitoring',
-    description: 'Token budget tracker: per-turn and cumulative usage with context window gauge',
-    factory: () => {
-      const panel = new TokenBudgetPanel(deps.sessionMemoryStore, deps.configManager);
-      if (deps.orchestrator && deps.getCtxWindow) {
-        panel.wire(deps.orchestrator, deps.getCtxWindow, requireUiServices(deps).readModels.session);
-      }
-      return panel;
-    },
-  });
-}