@pellux/goodvibes-agent 0.1.0

package/src/input/session-picker-modal.ts

@@ -0,0 +1,136 @@
+/**
+ * SessionPickerModal — state management for the /sessions picker modal.
+ *
+ * Lists sessions from SessionManager.list(), tracks selected index,
+ * and handles load/delete actions.
+ */
+
+import { unlinkSync } from 'node:fs';
+import type { SessionInfo, SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
+import type { ConversationManager } from '../core/conversation';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+// ---------------------------------------------------------------------------
+// SessionPickerModal
+// ---------------------------------------------------------------------------
+
+export class SessionPickerModal {
+  public active = false;
+  public sessions: SessionInfo[] = [];
+  public selectedIndex = 0;
+  public scrollOffset = 0;
+  public visibleRows = 8;
+  public deleteConfirmationTarget: string | null = null;
+
+  /** Last status message to show in the modal (e.g. error or success). */
+  public statusMessage = '';
+
+  public constructor(private readonly sessionManager: SessionManager) {}
+
+  /**
+   * Open the modal, loading sessions from SessionManager.
+   */
+  open(): void {
+    this.sessions = this.sessionManager.list();
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.statusMessage = '';
+    this.deleteConfirmationTarget = null;
+    this.active = true;
+  }
+
+  close(): void {
+    this.active = false;
+    this.statusMessage = '';
+    this.deleteConfirmationTarget = null;
+  }
+
+  moveUp(): void {
+    if (this.sessions.length === 0) return;
+    this.selectedIndex = (this.selectedIndex - 1 + this.sessions.length) % this.sessions.length;
+    this._clampScroll();
+    this.deleteConfirmationTarget = null;
+  }
+
+  moveDown(): void {
+    if (this.sessions.length === 0) return;
+    this.selectedIndex = (this.selectedIndex + 1) % this.sessions.length;
+    this._clampScroll();
+    this.deleteConfirmationTarget = null;
+  }
+
+  setVisibleRows(rows: number): void {
+    this.visibleRows = Math.max(3, rows);
+    this._clampScroll();
+  }
+
+  getSelected(): SessionInfo | null {
+    return this.sessions[this.selectedIndex] ?? null;
+  }
+
+  /**
+   * Load the currently selected session into the given ConversationManager.
+   * Returns true on success, false on error.
+   */
+  loadSelected(conversationManager: ConversationManager): boolean {
+    const session = this.getSelected();
+    if (!session) return false;
+
+    try {
+      const { meta, messages } = this.sessionManager.load(session.name);
+      conversationManager.resetAll();
+      conversationManager.fromJSON({ messages: messages as never[] });
+      if (meta.title) conversationManager.title = meta.title;
+      conversationManager.rebuildHistory();
+      this.statusMessage = `Loaded: ${session.name} (${messages.length} messages)`;
+      return true;
+    } catch (e) {
+      this.statusMessage = `Error: ${summarizeError(e)}`;
+      return false;
+    }
+  }
+
+  /**
+   * Delete the currently selected session from disk.
+   * Refreshes the list after deletion.
+   */
+  deleteSelected(): boolean {
+    const session = this.getSelected();
+    if (!session) return false;
+    if (this.deleteConfirmationTarget !== session.name) {
+      this.deleteConfirmationTarget = session.name;
+      this.statusMessage = `Press d again to delete ${session.name}.`;
+      return false;
+    }
+
+    try {
+      // Delete directly via filePath so it works with any session directory
+      unlinkSync(session.filePath);
+      // Reload list from the global session manager (removes the deleted entry)
+      this.sessions = this.sessionManager.list();
+      // Adjust selection
+      if (this.selectedIndex >= this.sessions.length) {
+        this.selectedIndex = Math.max(0, this.sessions.length - 1);
+      }
+      this._clampScroll();
+      this.deleteConfirmationTarget = null;
+      this.statusMessage = `Deleted: ${session.name}`;
+      return true;
+    } catch (e) {
+      this.deleteConfirmationTarget = null;
+      this.statusMessage = `Error: ${summarizeError(e)}`;
+      return false;
+    }
+  }
+
+  private _clampScroll(): void {
+    const visRows = Math.max(3, this.visibleRows);
+    if (this.selectedIndex < this.scrollOffset) {
+      this.scrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollOffset + visRows) {
+      this.scrollOffset = this.selectedIndex - visRows + 1;
+    }
+    const maxOffset = Math.max(0, this.sessions.length - visRows);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+  }
+}

package/src/input/settings-modal-behavior.ts

@@ -0,0 +1,37 @@
+import type { ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
+import type { ModelPickerTarget } from './model-picker.ts';
+
+export type ModelPickerLaunch =
+  | { readonly flow: 'providerModel'; readonly target: ModelPickerTarget }
+  | { readonly flow: 'model'; readonly target: ModelPickerTarget };
+
+/**
+ * Map config keys to the shared provider/model picker flows.
+ */
+export function modelPickerLaunchForKey(key: string): ModelPickerLaunch | null {
+  if (key === 'provider.model') return { flow: 'providerModel', target: 'main' };
+  if (key === 'helper.globalProvider') return { flow: 'providerModel', target: 'helper' };
+  if (key === 'helper.globalModel') return { flow: 'model', target: 'helper' };
+  if (key === 'tools.llmProvider') return { flow: 'providerModel', target: 'tool' };
+  if (key === 'tools.llmModel') return { flow: 'model', target: 'tool' };
+  if (key === 'tts.llmProvider') return { flow: 'providerModel', target: 'tts' };
+  if (key === 'tts.llmModel') return { flow: 'model', target: 'tts' };
+  return null;
+}
+
+export function roundToPrecision(value: number, precision: number): number {
+  const factor = 10 ** precision;
+  return Math.round(value * factor) / factor;
+}
+
+export function getNumericAdjustmentMeta(setting: ConfigSetting): {
+  step: number;
+  min?: number;
+  max?: number;
+  precision: number;
+} {
+  if (setting.key === 'wrfc.scoreThreshold') {
+    return { step: 0.1, min: 0, max: 10, precision: 1 };
+  }
+  return { step: 1, precision: 0 };
+}

package/src/input/settings-modal-secrets.ts

@@ -0,0 +1,41 @@
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { SecretsManager } from '../config/secrets.ts';
+import {
+  buildSecretBackedConfigUpdate,
+  getSecretWriteMedium,
+} from '../config/secret-config.ts';
+
+export type SettingsSecretsManager = Pick<SecretsManager, 'delete' | 'set'>;
+
+export function setSecretBackedSettingValue(args: {
+  key: ConfigKey;
+  value: string;
+  configManager: ConfigManager;
+  secretsManager: SettingsSecretsManager | null;
+  setConfigValue: (key: ConfigKey, value: unknown) => void;
+}): void {
+  const { key, value, configManager, secretsManager, setConfigValue } = args;
+  if (!secretsManager) {
+    setConfigValue(key, value.trim());
+    return;
+  }
+
+  const update = buildSecretBackedConfigUpdate(key, value);
+  if (update.secretKey && update.secretValue !== undefined) {
+    void secretsManager.set(update.secretKey, update.secretValue, {
+      scope: 'user',
+      medium: getSecretWriteMedium(configManager.get('storage.secretPolicy')),
+    }).catch((error) => {
+      logger.error('SettingsModal: failed to store secret config value', { key, error: summarizeError(error) });
+    });
+  }
+  if (update.clearSecretKey) {
+    void secretsManager.delete(update.clearSecretKey, { scope: 'user' }).catch((error) => {
+      logger.error('SettingsModal: failed to clear secret config value', { key, error: summarizeError(error) });
+    });
+  }
+  setConfigValue(key, update.configValue);
+}

package/src/input/settings-modal-subscriptions.ts

@@ -0,0 +1,95 @@
+import type { ProviderAuthFreshness } from '@/runtime/index.ts';
+import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
+import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
+import type { SubscriptionEntry } from './settings-modal-types.ts';
+
+export function buildSubscriptionEntries(
+  manager: SubscriptionManager | null,
+  serviceRegistry: Pick<ServiceInspectionQuery, 'getAll'> | null,
+): SubscriptionEntry[] {
+  if (!manager) return [];
+
+  const services = serviceRegistry?.getAll() ?? {};
+  const providers = new Map<string, SubscriptionEntry>();
+  const builtinProviders = new Set(listBuiltinSubscriptionProviders().map((builtin) => builtin.provider));
+
+  for (const provider of builtinProviders) {
+    providers.set(provider, {
+      provider,
+      state: 'available',
+      oauthConfigured: true,
+      preferredRoute: 'subscription',
+      activeRoute: 'unconfigured',
+      authFreshness: 'unconfigured',
+      routeReason: 'Built-in subscription adapter is available, but no active subscription session is stored yet.',
+      nextActions: [`Use /subscription login ${provider} start to begin browser sign-in.`],
+    });
+  }
+
+  for (const service of Object.values(services)) {
+    if (service.authType !== 'oauth' || !service.oauth) continue;
+    const provider = service.providerId ?? service.name;
+    providers.set(provider, {
+      provider,
+      state: 'available',
+      oauthConfigured: true,
+      preferredRoute: 'subscription',
+      activeRoute: providers.get(provider)?.activeRoute ?? 'unconfigured',
+      authFreshness: providers.get(provider)?.authFreshness ?? 'unconfigured',
+      routeReason: providers.get(provider)?.routeReason ?? 'OAuth metadata is configured for this provider.',
+      nextActions: providers.get(provider)?.nextActions ?? [`Use /subscription login ${provider} start to begin browser sign-in.`],
+    });
+  }
+
+  for (const pending of manager.listPending()) {
+    providers.set(pending.provider, {
+      provider: pending.provider,
+      state: 'pending',
+      oauthConfigured: providers.get(pending.provider)?.oauthConfigured ?? false,
+      preferredRoute: 'subscription',
+      activeRoute: 'unconfigured',
+      authFreshness: 'pending',
+      routeReason: 'OAuth login is pending completion for this provider.',
+      nextActions: [`Finish /subscription login ${pending.provider} finish <code> to activate this session.`],
+    });
+  }
+
+  for (const subscription of manager.list()) {
+    const freshness = determineFreshness(subscription.expiresAt);
+    const issues = freshness === 'expired'
+      ? ['Stored subscription session is expired and needs refresh.']
+      : freshness === 'expiring'
+        ? ['Stored subscription session expires within 24 hours.']
+        : [];
+    const nextActions = freshness === 'expired'
+      ? [`Refresh or replace the ${subscription.provider} subscription session.`]
+      : freshness === 'expiring'
+        ? [`Verify or renew the ${subscription.provider} subscription session soon.`]
+        : [];
+    providers.set(subscription.provider, {
+      provider: subscription.provider,
+      state: 'active',
+      tokenType: subscription.tokenType,
+      expiresAt: subscription.expiresAt,
+      oauthConfigured: providers.get(subscription.provider)?.oauthConfigured ?? builtinProviders.has(subscription.provider),
+      activeRoute: freshness === 'expired' ? 'unconfigured' : 'subscription',
+      preferredRoute: 'subscription',
+      authFreshness: freshness,
+      routeReason: subscription.overrideAmbientApiKeys
+        ? 'Subscription route overrides ambient API-key resolution for this provider.'
+        : 'Subscription route is stored for supported flows without automatically replacing ambient API-key resolution.',
+      issues,
+      nextActions,
+    });
+  }
+
+  return [...providers.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+}
+
+function determineFreshness(expiresAt?: number): ProviderAuthFreshness {
+  if (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt)) return 'healthy';
+  if (expiresAt <= Date.now()) return 'expired';
+  if (expiresAt <= Date.now() + 24 * 60 * 60 * 1000) return 'expiring';
+  return 'healthy';
+}

package/src/input/settings-modal-types.ts

@@ -0,0 +1,91 @@
+import type { ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
+import type { ProviderAuthFreshness, ProviderAuthRoute } from '@/runtime/index.ts';
+import type { FeatureFlag, FlagState } from '@/runtime/index.ts';
+
+export type SettingsCategory =
+  | 'display'
+  | 'ui'
+  | 'provider'
+  | 'subscriptions'
+  | 'behavior'
+  | 'storage'
+  | 'permissions'
+  | 'orchestration'
+  | 'wrfc'
+  | 'tools'
+  | 'helper'
+  | 'tts'
+  | 'service'
+  | 'controlPlane'
+  | 'httpListener'
+  | 'web'
+  | 'network'
+  | 'surfaces'
+  | 'cloudflare'
+  | 'batch'
+  | 'automation'
+  | 'watchers'
+  | 'runtime'
+  | 'telemetry'
+  | 'cache'
+  | 'sandbox'
+  | 'mcp'
+  | 'flags'
+  | 'release'
+  | 'danger';
+
+export type SettingsFocusPane = 'categories' | 'settings';
+
+export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
+  readonly label: string;
+  readonly categories: readonly SettingsCategory[];
+}> = [
+  { label: 'Interface', categories: ['display', 'ui', 'behavior', 'permissions'] },
+  { label: 'AI Routing', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts'] },
+  { label: 'Service & Network', categories: ['service', 'network', 'controlPlane', 'httpListener', 'web'] },
+  { label: 'Surfaces & Cloud', categories: ['surfaces', 'mcp', 'cloudflare'] },
+  { label: 'Automation', categories: ['batch', 'automation', 'watchers', 'orchestration', 'wrfc'] },
+  { label: 'Runtime & Data', categories: ['storage', 'sandbox', 'runtime', 'cache', 'telemetry'] },
+  { label: 'Advanced', categories: ['flags', 'release', 'danger'] },
+];
+
+export const SETTINGS_CATEGORIES: SettingsCategory[] = SETTINGS_CATEGORY_GROUPS.flatMap(group => group.categories);
+
+export interface SettingEntry {
+  setting: ConfigSetting;
+  currentValue: unknown;
+  isDefault: boolean;
+  effectiveSource?: 'default' | 'local' | 'synced' | 'managed';
+  locked?: boolean;
+  conflict?: boolean;
+  sourceLabel?: string;
+  lockReason?: string;
+}
+
+export interface FlagEntry {
+  flag: FeatureFlag;
+  state: FlagState;
+}
+
+export interface McpEntry {
+  name: string;
+  connected: boolean;
+  role: string;
+  trustMode: 'constrained' | 'ask-on-risk' | 'allow-all' | 'blocked';
+  allowedPaths: string[];
+  allowedHosts: string[];
+}
+
+export interface SubscriptionEntry {
+  provider: string;
+  state: 'active' | 'pending' | 'available';
+  tokenType?: string;
+  expiresAt?: number;
+  oauthConfigured: boolean;
+  activeRoute?: ProviderAuthRoute;
+  preferredRoute?: ProviderAuthRoute;
+  authFreshness?: ProviderAuthFreshness;
+  routeReason?: string;
+  issues?: string[];
+  nextActions?: string[];
+}