@pellux/goodvibes-tui 0.19.24 → 0.19.26

package/src/input/onboarding/onboarding-wizard-apply.ts

@@ -0,0 +1,211 @@
+import type { OnboardingAcknowledgementTarget, OnboardingApplyOperation, OnboardingApplyRequest } from '../../runtime/onboarding/index.ts';
+import { EXTERNAL_SURFACE_SPECS } from './onboarding-wizard-external-surfaces.ts';
+import { buildGoodVibesSecretKey, buildGoodVibesSecretRef, isLoopbackAddress, isSecretReferenceValue } from './onboarding-wizard-helpers.ts';
+import type { OnboardingWizardController } from './onboarding-wizard.ts';
+
+export function buildOnboardingApplyRequest(controller: OnboardingWizardController): OnboardingApplyRequest {
+    const operations: OnboardingApplyOperation[] = [];
+    const hasServers = controller.hasServerCapabilitiesSelected();
+    const browserAccess = controller.shouldEnableBrowserSurface();
+    const httpListener = controller.shouldEnableHttpListener();
+    const controlPlaneRemote = controller.shouldExposeControlPlaneNetwork();
+    const networkMode = controller.getStringFieldValue('network.mode', controller.runtimeDerived.step1_5NetworkMode);
+    const customNetwork = hasServers && networkMode === 'custom';
+
+    const setConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: unknown,
+    ): void => {
+      operations.push({ kind: 'set-config', key, value });
+    };
+    const acknowledge = (target: OnboardingAcknowledgementTarget, fieldId: string): void => {
+      operations.push({
+        kind: 'acknowledge',
+        target,
+        acknowledged: controller.getBooleanFieldValue(fieldId, false),
+      });
+    };
+    const setSecret = (key: string, value: string): void => {
+      if (value.length === 0) return;
+      const medium = controller.getSelectedSecretMedium();
+      operations.push({
+        kind: 'set-secret',
+        key,
+        value,
+        scope: 'project',
+        medium,
+      });
+    };
+    const setMaskedConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: string,
+    ): void => {
+      if (value.length === 0 || isSecretReferenceValue(value)) {
+        setConfig(key, value);
+        return;
+      }
+
+      const secretKey = buildGoodVibesSecretKey(key);
+      setSecret(secretKey, value);
+      setConfig(key, buildGoodVibesSecretRef(secretKey));
+    };
+
+    if (controller.requiresAuthBootstrap()) {
+      operations.push({
+        kind: 'ensure-auth-user',
+        username: controller.getStringFieldValue('accounts.admin-username', controller.getDefaultAdminUsername()),
+        password: controller.getStringFieldValue('accounts.admin-password', ''),
+        roles: ['admin'],
+        createSession: true,
+        retireBootstrapCredential: controller.hasBootstrapCredentialPresent(),
+      });
+    }
+
+    setConfig('service.enabled', hasServers);
+    setConfig('service.autostart', hasServers);
+    setConfig('service.restartOnFailure', true);
+    setConfig('danger.daemon', hasServers);
+    setConfig('controlPlane.enabled', hasServers);
+    setConfig('danger.httpListener', httpListener);
+    setConfig('web.enabled', browserAccess);
+
+    if (hasServers) {
+      addNetworkOperations(controller, operations, customNetwork, {
+        controlPlane: hasServers,
+        controlPlaneRemote,
+        httpListener,
+        web: browserAccess,
+      });
+    } else {
+      setConfig('controlPlane.hostMode', 'local');
+      setConfig('controlPlane.host', controller.runtimeSnapshot?.bindSettings.controlPlane.host || '127.0.0.1');
+      setConfig('controlPlane.allowRemote', false);
+      setConfig('httpListener.hostMode', 'local');
+      setConfig('httpListener.host', controller.runtimeSnapshot?.bindSettings.httpListener.host || '127.0.0.1');
+      setConfig('web.hostMode', 'local');
+      setConfig('web.host', controller.runtimeSnapshot?.bindSettings.web.host || '127.0.0.1');
+    }
+
+    const defaultModel = controller.modelSelectionState.get('main');
+    if (defaultModel && defaultModel.enabled !== false && defaultModel.providerId.length > 0 && defaultModel.modelId.length > 0) {
+      setConfig('provider.provider', defaultModel.providerId);
+      setConfig('provider.model', defaultModel.modelId);
+    }
+    setConfig('provider.reasoningEffort', controller.getStringFieldValue('default-model.reasoning', controller.runtimeSnapshot?.providerRouting.primaryReasoningEffort ?? 'medium'));
+    setConfig('behavior.hitlMode', controller.getStringFieldValue('experience.hitl', controller.runtimeSnapshot?.runtimeDefaults.behavior.hitlMode ?? 'balanced'));
+    setConfig('behavior.guidanceMode', controller.getStringFieldValue('experience.guidance', controller.runtimeSnapshot?.runtimeDefaults.behavior.guidanceMode ?? 'minimal'));
+    setConfig('permissions.mode', controller.getStringFieldValue('experience.permissions', controller.runtimeSnapshot?.runtimeDefaults.permissionsMode ?? 'prompt'));
+    setConfig('storage.secretPolicy', controller.getStringFieldValue('external-services.secret-policy', controller.runtimeSnapshot?.runtimeDefaults.secretStoragePolicy ?? 'preferred_secure'));
+
+    setSecret('OPENAI_API_KEY', controller.getStringFieldValue('providers.openai-api-key', ''));
+
+    const externalIntegrations = controller.isCapabilitySelected('external-integrations');
+    for (const surface of EXTERNAL_SURFACE_SPECS) {
+      const enabled = externalIntegrations
+        && controller.getBooleanFieldValue(surface.enabledFieldId, surface.defaultEnabled(controller.runtimeSnapshot));
+      setConfig(surface.enabledConfigKey, enabled);
+      if (!enabled) continue;
+
+      for (const setupField of surface.fields) {
+        const fallback = setupField.defaultValue(controller.runtimeSnapshot);
+        if (setupField.valueType === 'number') {
+          setConfig(
+            setupField.configKey,
+            controller.getNumberFieldValue(
+              setupField.id,
+              setupField.defaultNumber ?? (Number.parseInt(fallback, 10) || 0),
+              setupField.min,
+              setupField.max,
+            ),
+          );
+          continue;
+        }
+
+        const value = controller.getStringFieldValue(setupField.id, fallback);
+        if (setupField.kind === 'masked') setMaskedConfig(setupField.configKey, value);
+        else setConfig(setupField.configKey, value);
+      }
+    }
+
+    acknowledge('providers', 'providers.reviewed');
+    acknowledge('subscriptions', 'accounts.subscriptions');
+    acknowledge('auth', 'accounts.auth');
+
+    if (controller.getBooleanFieldValue('review.project-marker', true)) {
+      operations.push({
+        kind: 'set-completion-marker',
+        scope: 'project',
+        completed: true,
+        payload: { source: 'wizard', mode: controller.mode },
+      });
+    }
+    if (controller.getBooleanFieldValue('review.user-marker', controller.defaultReviewUserMarker())) {
+      operations.push({
+        kind: 'set-completion-marker',
+        scope: 'user',
+        completed: true,
+        payload: { source: 'wizard', mode: controller.mode },
+      });
+    }
+
+    return {
+      mode: controller.mode,
+      source: 'wizard',
+      operations,
+    };
+  }
+
+export function addNetworkOperations(
+  controller: OnboardingWizardController,
+    operations: OnboardingApplyOperation[],
+    customNetwork: boolean,
+    enabled: {
+      readonly controlPlane: boolean;
+      readonly controlPlaneRemote: boolean;
+      readonly httpListener: boolean;
+      readonly web: boolean;
+    },
+  ): void {
+    const setConfig = (
+      key: Extract<OnboardingApplyOperation, { kind: 'set-config' }>['key'],
+      value: unknown,
+    ): void => {
+      operations.push({ kind: 'set-config', key, value });
+    };
+    const networkFacingEnabled = {
+      controlPlane: enabled.controlPlaneRemote,
+      httpListener: enabled.httpListener,
+      web: enabled.web,
+    };
+    const sharedIpDefault = controller.getSharedIpDefault(networkFacingEnabled);
+    const sharedIp = controller.getBooleanFieldValue('network.shared-ip', sharedIpDefault);
+    const sharedHost = controller.getStringFieldValue('network.shared-ip-address', controller.getSharedIpHostDefault(networkFacingEnabled)) || '0.0.0.0';
+    const controlPlaneHost = sharedIp
+      ? sharedHost
+      : controller.getStringFieldValue('network.service-ip', controller.runtimeSnapshot?.bindSettings.controlPlane.host ?? '0.0.0.0');
+    const httpListenerHost = sharedIp
+      ? sharedHost
+      : controller.getStringFieldValue('network.webhook-ip', controller.runtimeSnapshot?.bindSettings.httpListener.host ?? '0.0.0.0');
+    const webHost = sharedIp
+      ? sharedHost
+      : controller.getStringFieldValue('network.browser-ip', controller.runtimeSnapshot?.bindSettings.web.host ?? '0.0.0.0');
+
+    if (enabled.controlPlane) {
+      setConfig('controlPlane.hostMode', enabled.controlPlaneRemote ? (customNetwork ? 'custom' : 'network') : 'local');
+      setConfig('controlPlane.host', enabled.controlPlaneRemote ? (customNetwork ? controlPlaneHost : '0.0.0.0') : '127.0.0.1');
+      setConfig('controlPlane.port', controller.getPortFieldValue('network.service-port', controller.runtimeSnapshot?.bindSettings.controlPlane.port ?? 3421));
+      setConfig('controlPlane.allowRemote', enabled.controlPlaneRemote && (customNetwork ? !isLoopbackAddress(controlPlaneHost) : true));
+    }
+
+    if (enabled.httpListener) {
+      setConfig('httpListener.hostMode', customNetwork ? 'custom' : 'network');
+      setConfig('httpListener.host', customNetwork ? httpListenerHost : '0.0.0.0');
+      setConfig('httpListener.port', controller.getPortFieldValue('network.webhook-port', controller.runtimeSnapshot?.bindSettings.httpListener.port ?? 3422));
+    }
+
+    if (enabled.web) {
+      setConfig('web.hostMode', customNetwork ? 'custom' : 'network');
+      setConfig('web.host', customNetwork ? webHost : '0.0.0.0');
+      setConfig('web.port', controller.getPortFieldValue('network.browser-port', controller.runtimeSnapshot?.bindSettings.web.port ?? 3423));
+    }
+  }

package/src/input/onboarding/onboarding-wizard-constants.ts

@@ -0,0 +1,148 @@
+import type { OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
+import type { OnboardingWizardRadioOption, OnboardingWizardStepId } from './onboarding-wizard-types.ts';
+
+export const STEP_ORDER: readonly OnboardingWizardStepId[] = [
+  'capabilities',
+  'network',
+  'access',
+  'external-services',
+  'provider-access',
+  'default-model',
+  'experience',
+  'review',
+];
+
+export const DEFAULT_CAPABILITIES: readonly OnboardingStep1CapabilityItem[] = [
+  {
+    id: 'local-tui-only',
+    label: 'Local TUI Only (No Servers)',
+    selected: true,
+    detail: 'Keep GoodVibes in this terminal and disable browser access, background services, network listeners, and external surfaces.',
+  },
+  {
+    id: 'browser-access',
+    label: 'Open GoodVibes in a Browser',
+    selected: false,
+    detail: 'Enable the background service and web UI, reachable on the local network by default unless customized.',
+  },
+  {
+    id: 'network-access',
+    label: 'Let other devices use GoodVibes',
+    selected: false,
+    detail: 'Expose enabled GoodVibes services on your LAN so other devices can reach them. Local auth is required.',
+  },
+  {
+    id: 'webhook-events',
+    label: 'Receive webhooks or events from other tools',
+    selected: false,
+    detail: 'Turn on the HTTP listener for incoming webhooks, callbacks, and automation events.',
+  },
+  {
+    id: 'external-integrations',
+    label: 'Connect GoodVibes to external apps and services',
+    selected: false,
+    detail: 'Show Slack, Discord, Telegram, Teams, Matrix, and other app surfaces so they can be enabled and configured here.',
+  },
+];
+
+export const REASONING_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'instant', label: 'Instant', hint: 'Lowest-latency routing.' },
+  { id: 'low', label: 'Low', hint: 'Compact reasoning for quick work.' },
+  { id: 'medium', label: 'Medium', hint: 'Balanced latency and quality.' },
+  { id: 'high', label: 'High', hint: 'Deeper reasoning for complex tasks.' },
+];
+
+export const NETWORK_MODE_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'local-network-default', label: 'Local Network (Default)', hint: 'Use the default LAN-facing setup for enabled browser, service, and event features.' },
+  { id: 'custom', label: 'Custom', hint: 'Choose IP addresses and ports for each enabled service.' },
+];
+
+export const HITL_MODE_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'quiet', label: 'Quiet', hint: 'Only interrupt for important attention requests.' },
+  { id: 'balanced', label: 'Balanced', hint: 'Show important activity without turning the TUI into a log stream.' },
+  { id: 'operator', label: 'Operator', hint: 'Keep operational activity visible for hands-on supervision.' },
+];
+
+export const GUIDANCE_MODE_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'minimal', label: 'Minimal', hint: 'Use compact guidance and repair suggestions.' },
+  { id: 'guided', label: 'Guided', hint: 'Show more explanation while working.' },
+  { id: 'off', label: 'Off', hint: 'Disable proactive guidance.' },
+];
+
+export const PERMISSION_MODE_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'prompt', label: 'Ask before powerful actions', hint: 'Prompt before write, edit, network, and execution tools.' },
+  { id: 'allow-all', label: 'Allow everything', hint: 'Allow tools without approval prompts.' },
+  { id: 'custom', label: 'Custom advanced rules', hint: 'Use tool-specific permission rules.' },
+];
+
+export const SECRET_POLICY_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'preferred_secure', label: 'Use secure storage when available', hint: 'Prefer the secure secret backend and fall back only when needed.' },
+  { id: 'require_secure', label: 'Require secure storage', hint: 'Refuse plaintext secret persistence.' },
+  { id: 'plaintext_allowed', label: 'Allow plaintext storage', hint: 'Permit local plaintext secret storage.' },
+];
+
+export const TELEGRAM_MODE_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'webhook', label: 'Webhook', hint: 'Receive Telegram updates through a webhook.' },
+  { id: 'polling', label: 'Polling', hint: 'Poll Telegram for updates from the background service.' },
+];
+
+export const WHATSAPP_PROVIDER_OPTIONS: readonly OnboardingWizardRadioOption[] = [
+  { id: 'meta-cloud', label: 'Meta Cloud', hint: 'Use the Meta Cloud API.' },
+  { id: 'bridge', label: 'Bridge', hint: 'Use a configured bridge service.' },
+];
+
+export const INBOUND_EXTERNAL_SURFACE_IDS = new Set<string>([
+  'bluebubbles',
+  'discord',
+  'googleChat',
+  'imessage',
+  'mattermost',
+  'matrix',
+  'msteams',
+  'ntfy',
+  'signal',
+  'slack',
+  'telegram',
+  'webhook',
+  'whatsapp',
+]);
+
+export const REQUIRED_EXTERNAL_SETUP_FIELD_IDS = new Set<string>([
+  'external-services.slack.bot-token',
+  'external-services.slack.signing-secret',
+  'external-services.discord.bot-token',
+  'external-services.discord.application-id',
+  'external-services.discord.public-key',
+  'external-services.telegram.bot-token',
+  'external-services.telegram.webhook-secret',
+  'external-services.ntfy.topic',
+  'external-services.webhook.default-target',
+  'external-services.google-chat.webhook-url',
+  'external-services.google-chat.verification-token',
+  'external-services.signal.bridge-url',
+  'external-services.signal.account',
+  'external-services.signal.token',
+  'external-services.whatsapp.access-token',
+  'external-services.whatsapp.verify-token',
+  'external-services.whatsapp.phone-number-id',
+  'external-services.imessage.bridge-url',
+  'external-services.imessage.account',
+  'external-services.imessage.token',
+  'external-services.msteams.app-id',
+  'external-services.msteams.app-password',
+  'external-services.msteams.tenant-id',
+  'external-services.bluebubbles.server-url',
+  'external-services.bluebubbles.password',
+  'external-services.mattermost.base-url',
+  'external-services.mattermost.bot-token',
+  'external-services.matrix.homeserver-url',
+  'external-services.matrix.access-token',
+  'external-services.matrix.user-id',
+]);
+
+export const NETWORK_HOST_FIELD_IDS = new Set<string>([
+  'network.shared-ip-address',
+  'network.service-ip',
+  'network.browser-ip',
+  'network.webhook-ip',
+]);