@pellux/goodvibes-tui 0.19.27 → 0.19.29

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,10 +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, Math.floor((getOnboardingWizardBodyRows(viewportHeight) - 5) / 2));
+  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';
 
@@ -30,10 +35,6 @@ export function getSharedIpHostDefault(
     return hosts[0] ?? '0.0.0.0';
   }
 
-export function defaultReviewUserMarker(controller: OnboardingWizardController): boolean {
-    return controller.mode === 'new';
-  }
-
 export function toggleCapability(controller: OnboardingWizardController, capabilityId: OnboardingStep1CapabilityId): void {
     if (capabilityId === 'local-tui-only') {
       for (const capability of controller.getCurrentCapabilities()) {
@@ -69,6 +70,18 @@ export function selectLocalTuiOnly(controller: OnboardingWizardController): void
     }
   }
 
+export function selectAllExternalSurfaces(controller: OnboardingWizardController): void {
+    for (const surface of EXTERNAL_SURFACE_SPECS) {
+      controller.toggleState.set(surface.enabledFieldId, true);
+    }
+  }
+
+export function clearExternalSurfaces(controller: OnboardingWizardController): void {
+    for (const surface of EXTERNAL_SURFACE_SPECS) {
+      controller.toggleState.set(surface.enabledFieldId, false);
+    }
+  }
+
 export function setCapabilityValue(controller: OnboardingWizardController, capabilityId: OnboardingStep1CapabilityId, selected: boolean): void {
     if (capabilityId === 'local-tui-only') {
       if (selected) {
@@ -116,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'
     ));
   }
 
@@ -125,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') {
@@ -172,7 +195,7 @@ export function shouldExposeControlPlaneNetwork(controller: OnboardingWizardCont
 
 export function requiresAuthBootstrap(controller: OnboardingWizardController): boolean {
     return controller.hasServerCapabilitiesSelected()
-      && (!controller.hasAdminAuthUser() || controller.hasBootstrapCredentialPresent());
+      && (!controller.hasLocalAuthUser() || controller.hasBootstrapCredentialPresent());
   }
 
 export function hasAdminAuthUser(controller: OnboardingWizardController): boolean {
@@ -180,12 +203,21 @@ export function hasAdminAuthUser(controller: OnboardingWizardController): boolea
       .some((user) => user.roles.includes('admin'));
   }
 
+export function hasLocalAuthUser(controller: OnboardingWizardController): boolean {
+    return (controller.runtimeSnapshot?.auth.snapshot.userCount ?? 0) > 0
+      || (controller.runtimeSnapshot?.auth.snapshot.users ?? []).length > 0;
+  }
+
 export function hasBootstrapCredentialPresent(controller: OnboardingWizardController): boolean {
     return controller.runtimeSnapshot?.auth.snapshot.bootstrapCredentialPresent === true;
   }
 
 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.`;
     }
@@ -313,14 +318,20 @@ export function isFieldDirtyByDefinition(controller: OnboardingWizardController,
   }
 
 export function isFieldSatisfied(controller: OnboardingWizardController, field: OnboardingWizardFieldDefinition): boolean {
-    if (field.kind === 'checklist' || field.kind === 'acknowledgement') {
-      if (field.kind === 'acknowledgement' && !field.required) return true;
+    if (field.kind === 'checklist') {
+      return true;
+    }
+
+    if (field.kind === 'acknowledgement') {
+      if (!field.required) return true;
       return Boolean(controller.getFieldValue(field));
     }
 
     if (field.kind === 'radio') return true;
 
     if (field.kind === 'text' || field.kind === 'masked') {
+      const required = field.required === true;
+      if (!required) return true;
       return normalizeText(controller.getFieldValue(field) as string).length > 0;
     }