@pellux/goodvibes-tui 0.19.28 → 0.19.29

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

@@ -1,5 +1,11 @@
 import type { OnboardingAcknowledgementTarget, OnboardingApplyOperation, OnboardingApplyRequest } from '../../runtime/onboarding/index.ts';
-import { EXTERNAL_SURFACE_SPECS } from './onboarding-wizard-external-surfaces.ts';
+import { getServerSurfaceFeatureFlags } from '../../runtime/surface-feature-flags.ts';
+import {
+  EXTERNAL_SURFACE_SPECS,
+  getExternalSurfaceAutoStartDefaultValue,
+  getExternalSurfaceAutoStartFieldId,
+  isExternalSurfaceSelectedByDefault,
+} from './onboarding-wizard-external-surfaces.ts';
 import { buildGoodVibesSecretKey, buildGoodVibesSecretRef, isLoopbackAddress, isSecretReferenceValue } from './onboarding-wizard-helpers.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
 
@@ -8,6 +14,7 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
     const hasServers = controller.hasServerCapabilitiesSelected();
     const browserAccess = controller.shouldEnableBrowserSurface();
     const httpListener = controller.shouldEnableHttpListener();
+    const httpListenerNetworkFields = controller.shouldExposeHttpListenerNetworkFields();
     const controlPlaneRemote = controller.shouldExposeControlPlaneNetwork();
     const networkMode = controller.getStringFieldValue('network.mode', controller.runtimeDerived.step1_5NetworkMode);
     const customNetwork = hasServers && networkMode === 'custom';
@@ -18,6 +25,9 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
     ): void => {
       operations.push({ kind: 'set-config', key, value });
     };
+    const enableFeatureFlags = (flagIds: readonly string[]): void => {
+      for (const flagId of flagIds) setConfig(`featureFlags.${flagId}`, 'enabled');
+    };
     const acknowledge = (target: OnboardingAcknowledgementTarget, fieldId: string): void => {
       operations.push({
         kind: 'acknowledge',
@@ -50,11 +60,13 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
       setConfig(key, buildGoodVibesSecretRef(secretKey));
     };
 
-    if (controller.requiresAuthBootstrap()) {
+    const requestedAdminPassword = controller.getStringFieldValue('accounts.admin-password', '');
+    const shouldEnsureAuthUser = controller.requiresAuthBootstrap() || requestedAdminPassword.length > 0;
+    if (shouldEnsureAuthUser) {
       operations.push({
         kind: 'ensure-auth-user',
         username: controller.getStringFieldValue('accounts.admin-username', controller.getDefaultAdminUsername()),
-        password: controller.getStringFieldValue('accounts.admin-password', ''),
+        password: requestedAdminPassword,
         roles: ['admin'],
         createSession: true,
         retireBootstrapCredential: controller.hasBootstrapCredentialPresent(),
@@ -73,7 +85,7 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
       addNetworkOperations(controller, operations, customNetwork, {
         controlPlane: hasServers,
         controlPlaneRemote,
-        httpListener,
+        httpListener: httpListenerNetworkFields,
         web: browserAccess,
       });
     } else {
@@ -100,11 +112,21 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
     setSecret('OPENAI_API_KEY', controller.getStringFieldValue('providers.openai-api-key', ''));
 
     const externalIntegrations = controller.isCapabilitySelected('external-integrations');
+    const enabledExternalSurfaceIds: string[] = [];
     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;
+      const selected = externalIntegrations
+        && controller.getBooleanFieldValue(
+          surface.enabledFieldId,
+          isExternalSurfaceSelectedByDefault(surface, controller.runtimeSnapshot),
+        );
+      const autoStart = selected
+        && controller.getStringFieldValue(
+          getExternalSurfaceAutoStartFieldId(surface),
+          getExternalSurfaceAutoStartDefaultValue(surface, controller.runtimeSnapshot),
+        ) === 'yes';
+      setConfig(surface.enabledConfigKey, autoStart);
+      if (!selected) continue;
+      enabledExternalSurfaceIds.push(surface.id);
 
       for (const setupField of surface.fields) {
         const fallback = setupField.defaultValue(controller.runtimeSnapshot);
@@ -126,6 +148,11 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
         else setConfig(setupField.configKey, value);
       }
     }
+    enableFeatureFlags(getServerSurfaceFeatureFlags({
+      serverBacked: hasServers,
+      web: browserAccess,
+      externalSurfaces: enabledExternalSurfaceIds,
+    }));
 
     acknowledge('providers', 'providers.reviewed');
     acknowledge('subscriptions', 'accounts.subscriptions');

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

@@ -17,19 +17,19 @@ 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.',
+    detail: 'Use GoodVibes only in this terminal. No browser access, background service, HTTP listener, external app surface, or network setup.',
   },
   {
     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.',
+    detail: 'Run the background service and web UI. GoodVibes will use the local network by default; you can restrict or customize it next.',
   },
   {
     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.',
+    detail: 'Make enabled GoodVibes services reachable from other devices on your LAN. Local authentication is required.',
   },
   {
     id: 'webhook-events',
@@ -41,7 +41,7 @@ export const DEFAULT_CAPABILITIES: readonly OnboardingStep1CapabilityItem[] = [
     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.',
+    detail: 'Enable setup screens for Slack, Discord, Telegram, Teams, Matrix, and other app surfaces you choose.',
   },
 ];
 
@@ -115,7 +115,6 @@ export const REQUIRED_EXTERNAL_SETUP_FIELD_IDS = new Set<string>([
   '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',

package/src/input/onboarding/onboarding-wizard-external-surfaces.ts

@@ -1,4 +1,10 @@
-import type { ConfigKey } from '../../config/index.ts';
+import {
+  GOODVIBES_NTFY_AGENT_TOPIC,
+  GOODVIBES_NTFY_CHAT_TOPIC,
+  GOODVIBES_NTFY_REMOTE_TOPIC,
+  resolveGoodVibesNtfyTopics,
+} from '@pellux/goodvibes-sdk/platform/integrations/ntfy';
+import { DEFAULT_CONFIG, type ConfigKey } from '../../config/index.ts';
 import type { OnboardingSnapshotState } from '../../runtime/onboarding/index.ts';
 import { TELEGRAM_MODE_OPTIONS, WHATSAPP_PROVIDER_OPTIONS } from './onboarding-wizard-constants.ts';
 import type { OnboardingWizardRadioOption } from './onboarding-wizard-types.ts';
@@ -24,10 +30,65 @@ export interface ExternalSurfaceSpec {
   readonly enabledConfigKey: ConfigKey;
   readonly label: string;
   readonly hint: string;
+  /**
+   * Existing SDK config key. In onboarding this maps to the per-surface
+   * auto-start choice, not to whether setup fields are shown.
+   */
   readonly defaultEnabled: (snapshot: OnboardingSnapshotState | null) => boolean;
   readonly fields: readonly ExternalSurfaceSetupFieldSpec[];
 }
 
+function normalizeConfigValue(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  return String(value).trim();
+}
+
+function getDefaultConfigValue(key: ConfigKey): unknown {
+  return key.split('.').reduce<unknown>((cursor, part) => (
+    typeof cursor === 'object' && cursor !== null && part in cursor
+      ? (cursor as Record<string, unknown>)[part]
+      : undefined
+  ), DEFAULT_CONFIG);
+}
+
+export function getExternalSurfaceAutoStartFieldId(surface: ExternalSurfaceSpec): string {
+  return `${surface.enabledFieldId}.auto-start`;
+}
+
+export function getExternalSurfaceAutoStartDefaultValue(
+  surface: ExternalSurfaceSpec,
+  snapshot: OnboardingSnapshotState | null,
+): 'yes' | 'no' {
+  return surface.defaultEnabled(snapshot) ? 'yes' : 'no';
+}
+
+export function isExternalSurfaceSelectedByDefault(
+  surface: ExternalSurfaceSpec,
+  snapshot: OnboardingSnapshotState | null,
+): boolean {
+  if (surface.defaultEnabled(snapshot)) return true;
+  if (!snapshot) return false;
+
+  return surface.fields.some((field) => {
+    const current = normalizeConfigValue(field.defaultValue(snapshot));
+    const defaultValue = normalizeConfigValue(getDefaultConfigValue(field.configKey));
+    return current.length > 0 && current !== defaultValue;
+  });
+}
+
+export function getNtfyProtocolTopicLines(snapshot: OnboardingSnapshotState | null): readonly string[] {
+  const topics = resolveGoodVibesNtfyTopics({
+    chatTopic: snapshot?.config.surfaces.ntfy.chatTopic,
+    agentTopic: snapshot?.config.surfaces.ntfy.agentTopic,
+    remoteTopic: snapshot?.config.surfaces.ntfy.remoteTopic,
+  });
+  return [
+    `Chat topic: ${topics.chatTopic}`,
+    `Agent topic: ${topics.agentTopic}`,
+    `Daemon-only remote topic: ${topics.remoteTopic}`,
+  ];
+}
+
 export const EXTERNAL_SURFACE_SPECS: readonly ExternalSurfaceSpec[] = [
   {
     id: 'slack',
@@ -200,7 +261,7 @@ export const EXTERNAL_SURFACE_SPECS: readonly ExternalSurfaceSpec[] = [
     enabledFieldId: 'external-services.ntfy',
     enabledConfigKey: 'surfaces.ntfy.enabled',
     label: 'ntfy surface',
-    hint: 'Enable ntfy notifications for lightweight device alerts.',
+    hint: 'Configure ntfy chat, agent, remote-session, and notification delivery topics.',
     defaultEnabled: (snapshot) => snapshot?.config.surfaces.ntfy.enabled ?? false,
     fields: [
       {
@@ -212,12 +273,39 @@ export const EXTERNAL_SURFACE_SPECS: readonly ExternalSurfaceSpec[] = [
         placeholder: 'https://ntfy.sh',
         defaultValue: (snapshot) => snapshot?.config.surfaces.ntfy.baseUrl ?? 'https://ntfy.sh',
       },
+      {
+        id: 'external-services.ntfy.chat-topic',
+        configKey: 'surfaces.ntfy.chatTopic',
+        kind: 'text',
+        label: 'ntfy chat topic',
+        hint: 'Messages sent here attach to the active terminal TUI session and reply back to ntfy.',
+        placeholder: GOODVIBES_NTFY_CHAT_TOPIC,
+        defaultValue: (snapshot) => snapshot?.config.surfaces.ntfy.chatTopic ?? GOODVIBES_NTFY_CHAT_TOPIC,
+      },
+      {
+        id: 'external-services.ntfy.agent-topic',
+        configKey: 'surfaces.ntfy.agentTopic',
+        kind: 'text',
+        label: 'ntfy agent topic',
+        hint: 'Messages sent here start agent work attached to the active TUI session.',
+        placeholder: GOODVIBES_NTFY_AGENT_TOPIC,
+        defaultValue: (snapshot) => snapshot?.config.surfaces.ntfy.agentTopic ?? GOODVIBES_NTFY_AGENT_TOPIC,
+      },
+      {
+        id: 'external-services.ntfy.remote-topic',
+        configKey: 'surfaces.ntfy.remoteTopic',
+        kind: 'text',
+        label: 'ntfy daemon-only remote topic',
+        hint: 'Messages sent here start an ntfy remote session in the daemon and do not appear in the TUI.',
+        placeholder: GOODVIBES_NTFY_REMOTE_TOPIC,
+        defaultValue: (snapshot) => snapshot?.config.surfaces.ntfy.remoteTopic ?? GOODVIBES_NTFY_REMOTE_TOPIC,
+      },
       {
         id: 'external-services.ntfy.topic',
         configKey: 'surfaces.ntfy.topic',
         kind: 'text',
-        label: 'ntfy topic',
-        hint: 'Default ntfy topic for notifications.',
+        label: 'ntfy default delivery topic',
+        hint: 'Optional outbound notification topic. It does not control chat, agent, or daemon-only remote routing.',
         placeholder: 'goodvibes',
         defaultValue: (snapshot) => snapshot?.config.surfaces.ntfy.topic ?? '',
       },
@@ -227,7 +315,7 @@ export const EXTERNAL_SURFACE_SPECS: readonly ExternalSurfaceSpec[] = [
         kind: 'masked',
         label: 'ntfy token',
         hint: 'Optional token for authenticated ntfy servers.',
-        placeholder: 'token',
+        placeholder: 'empty for anonymous ntfy',
         defaultValue: (snapshot) => snapshot?.config.surfaces.ntfy.token ?? '',
       },
       {

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

@@ -209,9 +209,9 @@ export function getRuntimeDerivedState(hydration: OnboardingWizardRuntimeHydrati
 }
 
 export function getOnboardingWizardBodyRows(viewportHeight: number): number {
-  return Math.max(5, viewportHeight - 5);
+  return Math.max(6, viewportHeight - 5);
 }
 
 export function getOnboardingWizardVisibleFieldCount(viewportHeight: number): number {
-  return Math.max(1, getOnboardingWizardBodyRows(viewportHeight) - 5);
+  return Math.max(1, getOnboardingWizardBodyRows(viewportHeight) - 6);
 }

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

@@ -1,6 +1,11 @@
 import type { OnboardingStep1CapabilityId } from '../../runtime/onboarding/index.ts';
 import { INBOUND_EXTERNAL_SURFACE_IDS, REQUIRED_EXTERNAL_SETUP_FIELD_IDS } from './onboarding-wizard-constants.ts';
-import { EXTERNAL_SURFACE_SPECS } from './onboarding-wizard-external-surfaces.ts';
+import {
+  EXTERNAL_SURFACE_SPECS,
+  getExternalSurfaceAutoStartDefaultValue,
+  getExternalSurfaceAutoStartFieldId,
+  isExternalSurfaceSelectedByDefault,
+} from './onboarding-wizard-external-surfaces.ts';
 import { getExternalSurfaceSpecByFieldId, normalizeText, uniqueNonEmpty } from './onboarding-wizard-helpers.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
 
@@ -124,7 +129,14 @@ export function hasSelectedInboundExternalSurface(controller: OnboardingWizardCo
     if (!controller.isCapabilitySelected('external-integrations')) return false;
     return EXTERNAL_SURFACE_SPECS.some((surface) => (
       INBOUND_EXTERNAL_SURFACE_IDS.has(surface.id)
-      && controller.getBooleanFieldValue(surface.enabledFieldId, surface.defaultEnabled(controller.runtimeSnapshot))
+      && controller.getBooleanFieldValue(
+        surface.enabledFieldId,
+        isExternalSurfaceSelectedByDefault(surface, controller.runtimeSnapshot),
+      )
+      && controller.getStringFieldValue(
+        getExternalSurfaceAutoStartFieldId(surface),
+        getExternalSurfaceAutoStartDefaultValue(surface, controller.runtimeSnapshot),
+      ) === 'yes'
     ));
   }
 
@@ -133,7 +145,10 @@ export function isRequiredExternalSetupField(controller: OnboardingWizardControl
     const surface = getExternalSurfaceSpecByFieldId(fieldId);
     if (!surface) return false;
     if (!controller.isCapabilitySelected('external-integrations')
-      || !controller.getBooleanFieldValue(surface.enabledFieldId, surface.defaultEnabled(controller.runtimeSnapshot))) {
+      || !controller.getBooleanFieldValue(
+        surface.enabledFieldId,
+        isExternalSurfaceSelectedByDefault(surface, controller.runtimeSnapshot),
+      )) {
       return false;
     }
     if (fieldId === 'external-services.telegram.webhook-secret') {
@@ -199,6 +214,10 @@ export function hasBootstrapCredentialPresent(controller: OnboardingWizardContro
 
 export function getDefaultAdminUsername(controller: OnboardingWizardController): string {
     const users = controller.runtimeSnapshot?.auth.snapshot.users ?? [];
+    if (controller.hasBootstrapCredentialPresent()) {
+      const existingAdmin = users.find((user) => user.roles.includes('admin'));
+      if (existingAdmin) return existingAdmin.username;
+    }
     const candidates = controller.hasBootstrapCredentialPresent()
       ? ['goodvibes-admin', 'admin']
       : ['admin', 'goodvibes-admin'];

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

@@ -72,21 +72,26 @@ export function getFieldValidationError(
     if (field.kind !== 'text' && field.kind !== 'masked') return null;
 
     const value = normalizeText(controller.getFieldValue(field) as string);
-    const required = field.required === true || controller.isRequiredExternalSetupField(field.id);
+    const required = field.required === true;
     if (required && value.length === 0) {
       return `${step.shortLabel}: ${field.label} is required.`;
     }
 
     if (field.id === 'accounts.admin-username') {
-      const existing = controller.runtimeSnapshot?.auth.snapshot.users.find((user) => user.username === value);
-      if (controller.hasBootstrapCredentialPresent() && existing) {
-        return `${step.shortLabel}: ${field.label} must be a new username so the wizard can replace bootstrap credentials.`;
+      const password = normalizeText(controller.getStringFieldValue('accounts.admin-password', ''));
+      if (!required && password.length > 0 && value.length === 0) {
+        return `${step.shortLabel}: ${field.label} is required when setting a local auth password.`;
       }
-      if (existing && !existing.roles.includes('admin')) {
-        return `${step.shortLabel}: ${field.label} must be a new username or an existing admin user.`;
+      const existing = controller.runtimeSnapshot?.auth.snapshot.users.find((user) => user.username === value);
+      if ((required || password.length > 0) && existing && !existing.roles.includes('admin')) {
+        return `${step.shortLabel}: ${field.label} must be an existing admin user or a new username.`;
       }
     }
 
+    if (field.id === 'accounts.admin-password' && value.length > 0 && value.length < 8) {
+      return `${step.shortLabel}: ${field.label} must be at least 8 characters.`;
+    }
+
     if (field.kind === 'masked' && isMalformedGoodVibesSecretReferenceValue(value)) {
       return `${step.shortLabel}: ${field.label} must be a secret value or a goodvibes://secrets/... reference.`;
     }
@@ -325,7 +330,7 @@ export function isFieldSatisfied(controller: OnboardingWizardController, field:
     if (field.kind === 'radio') return true;
 
     if (field.kind === 'text' || field.kind === 'masked') {
-      const required = field.required === true || controller.isRequiredExternalSetupField(field.id);
+      const required = field.required === true;
       if (!required) return true;
       return normalizeText(controller.getFieldValue(field) as string).length > 0;
     }