@murphai/murph 0.1.18 → 0.2.5

package/node_modules/@murphai/setup-cli/dist/setup-wizard.js

@@ -1,661 +1,59 @@
 import * as React from 'react';
-import { Box, Text, render, useApp, useInput } from 'ink';
-import { listAssistantCronPresets } from '@murphai/assistant-engine/assistant-cron';
-import { setupChannelValues, setupWearableValues, } from '@murphai/operator-config/setup-cli-contracts';
-import { SETUP_RUNTIME_ENV_NOTICE, } from '@murphai/operator-config/setup-runtime-env';
-import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
-import { getDefaultSetupWizardAssistantPreset, buildSetupWizardAssistantMethodBadges, buildSetupWizardAssistantProviderBadges, doesSetupWizardAssistantProviderRequireMethod, findSetupWizardAssistantMethodIndex, findSetupWizardAssistantProviderIndex, inferSetupWizardAssistantMethod, inferSetupWizardAssistantProvider, listSetupWizardAssistantMethodOptions, listSetupWizardAssistantProviderOptions, resolveSetupWizardAssistantMethodForProvider, resolveSetupWizardAssistantSelection, runSetupAssistantWizard, } from './setup-assistant-wizard.js';
-import { createSetupWizardCompletionController as createGenericSetupWizardCompletionController, wrapSetupWizardIndex, } from './setup-wizard-core.js';
-import { createSetupWizardAnsweredBlock, createSetupWizardBulletRow, createSetupWizardHintRow, createSetupWizardKeyValueRow, createSetupWizardPanel, createSetupWizardPublicUrlTargetRow, createSetupWizardSelectionRow, resolveSetupWizardToneColor, } from './setup-wizard-ui.js';
+import { render } from 'ink';
+import {} from '@murphai/operator-config/setup-cli-contracts';
+import {} from '@murphai/operator-config/setup-runtime-env';
+import { getDefaultSetupWizardAssistantPreset, runSetupAssistantWizard, } from './setup-assistant-wizard.js';
+import { SetupWizardApp } from './setup-wizard-app.js';
+import { createSetupWizardCompletionController as createGenericSetupWizardCompletionController, } from './setup-wizard-core.js';
+import { getDefaultSetupWizardChannels, getDefaultSetupWizardScheduledUpdates, getDefaultSetupWizardWearables, resolveSetupWizardInitialScheduledUpdates, sortSetupWizardChannels, sortSetupWizardWearables, } from './setup-wizard-options.js';
 export { getDefaultSetupWizardAssistantPreset, inferSetupWizardAssistantProvider, runSetupAssistantWizard, resolveSetupWizardAssistantSelection, } from './setup-assistant-wizard.js';
 export { wrapSetupWizardIndex } from './setup-wizard-core.js';
-const DEFAULT_SETUP_DEVICE_SYNC_LOCAL_BASE_URL = 'http://localhost:8788';
-const DEFAULT_SETUP_LINQ_WEBHOOK_URL = 'http://127.0.0.1:8789/linq-webhook';
-const setupWizardChannelOptions = [
-    {
-        channel: 'imessage',
-        description: 'Reply from Messages on this Mac.',
-        title: 'iMessage',
-    },
-    {
-        channel: 'telegram',
-        description: 'Reply through a Telegram bot.',
-        title: 'Telegram',
-    },
-    {
-        channel: 'linq',
-        description: 'Reply by SMS, iMessage, or RCS through Linq.',
-        title: 'Linq',
-    },
-    {
-        channel: 'email',
-        description: 'Read and reply in email.',
-        title: 'Email',
-    },
-];
-const setupWizardScheduledUpdateOptions = listAssistantCronPresets().map((preset) => ({
-    id: preset.id,
-    title: preset.title,
-    description: preset.description,
-    scheduleLabel: preset.suggestedScheduleLabel,
-}));
-const DEFAULT_SETUP_WIZARD_SCHEDULED_UPDATE_IDS = [
-    'weekly-health-snapshot',
-    'environment-health-watch',
-];
-const setupWizardWearableOptions = [
-    {
-        description: 'Sync sleep, daily health metrics, and activities from Garmin Connect.',
-        title: 'Garmin',
-        wearable: 'garmin',
-    },
-    {
-        description: 'Import sleep, readiness, and recovery from Oura.',
-        title: 'Oura',
-        wearable: 'oura',
-    },
-    {
-        description: 'Import sleep, strain, and recovery from WHOOP.',
-        title: 'WHOOP',
-        wearable: 'whoop',
-    },
-];
-export function getDefaultSetupWizardChannels(platform = process.platform) {
-    return platform === 'darwin' ? ['imessage'] : [];
-}
-export function getDefaultSetupWizardWearables() {
-    return [];
-}
-export function getDefaultSetupWizardScheduledUpdates() {
-    const available = new Set(setupWizardScheduledUpdateOptions.map((option) => option.id));
-    return sortSetupWizardScheduledUpdates(DEFAULT_SETUP_WIZARD_SCHEDULED_UPDATE_IDS.filter((id) => available.has(id)));
-}
-export function resolveSetupWizardInitialScheduledUpdates(initialScheduledUpdates) {
-    return sortSetupWizardScheduledUpdates(initialScheduledUpdates === undefined
-        ? getDefaultSetupWizardScheduledUpdates()
-        : [...initialScheduledUpdates]);
-}
+export { buildSetupWizardPublicUrlReview, describeSetupWizardPublicUrlStrategyChoice, } from './setup-wizard-public-url.js';
+export { getDefaultSetupWizardChannels, getDefaultSetupWizardScheduledUpdates, getDefaultSetupWizardWearables, resolveSetupWizardInitialScheduledUpdates, toggleSetupWizardChannel, toggleSetupWizardScheduledUpdate, toggleSetupWizardWearable, } from './setup-wizard-options.js';
 export function createSetupWizardCompletionController() {
     return createGenericSetupWizardCompletionController({
         unexpectedExitMessage: 'Murph setup wizard exited unexpectedly.',
     });
 }
-export function toggleSetupWizardChannel(selectedChannels, channel) {
-    const next = new Set(selectedChannels);
-    if (next.has(channel)) {
-        next.delete(channel);
-    }
-    else {
-        next.add(channel);
-    }
-    return sortSetupWizardChannels([...next]);
-}
-export function toggleSetupWizardWearable(selectedWearables, wearable) {
-    const next = new Set(selectedWearables);
-    if (next.has(wearable)) {
-        next.delete(wearable);
-    }
-    else {
-        next.add(wearable);
-    }
-    return sortSetupWizardWearables([...next]);
-}
-export function toggleSetupWizardScheduledUpdate(selectedPresetIds, presetId) {
-    const next = new Set(selectedPresetIds);
-    if (next.has(presetId)) {
-        next.delete(presetId);
-    }
-    else {
-        next.add(presetId);
-    }
-    return sortSetupWizardScheduledUpdates([...next]);
-}
 export async function runSetupWizard(input) {
     const initialAssistantPreset = input.initialAssistantPreset ?? getDefaultSetupWizardAssistantPreset();
-    const initialChannels = sortSetupWizardChannels(input.initialChannels && input.initialChannels.length > 0
-        ? [...input.initialChannels]
-        : getDefaultSetupWizardChannels(input.platform));
+    const initialChannels = sortSetupWizardChannels(input.initialChannels === undefined
+        ? getDefaultSetupWizardChannels(input.platform)
+        : [...input.initialChannels]);
     const initialScheduledUpdates = resolveSetupWizardInitialScheduledUpdates(input.initialScheduledUpdates);
-    const initialWearables = sortSetupWizardWearables(input.initialWearables && input.initialWearables.length > 0
-        ? [...input.initialWearables]
-        : getDefaultSetupWizardWearables());
+    const initialWearables = sortSetupWizardWearables(input.initialWearables === undefined
+        ? getDefaultSetupWizardWearables()
+        : [...input.initialWearables]);
     const commandName = input.commandName ?? 'murph';
     const completion = createSetupWizardCompletionController();
     const defaultScheduledUpdateIds = new Set(getDefaultSetupWizardScheduledUpdates());
     let instance = null;
-    const App = () => {
-        const createElement = React.createElement;
-        const { exit } = useApp();
-        const initialAssistantProvider = inferSetupWizardAssistantProvider({
-            apiKeyEnv: input.initialAssistantApiKeyEnv,
-            baseUrl: input.initialAssistantBaseUrl,
-            oss: input.initialAssistantOss,
-            preset: initialAssistantPreset,
-            providerName: input.initialAssistantProviderName,
-            providerPreset: input.initialAssistantProviderPreset,
-        });
-        const initialAssistantMethod = inferSetupWizardAssistantMethod({
-            oss: input.initialAssistantOss,
-            preset: initialAssistantPreset,
-            provider: initialAssistantProvider,
-        });
-        const [step, setStep] = React.useState('intro');
-        const [assistantProviderIndex, setAssistantProviderIndex] = React.useState(findSetupWizardAssistantProviderIndex(initialAssistantProvider));
-        const [assistantMethodIndex, setAssistantMethodIndex] = React.useState(findSetupWizardAssistantMethodIndex(initialAssistantProvider, initialAssistantMethod));
-        const [scheduledUpdateIndex, setScheduledUpdateIndex] = React.useState(0);
-        const [channelIndex, setChannelIndex] = React.useState(0);
-        const [wearableIndex, setWearableIndex] = React.useState(0);
-        const [selectedAssistantProvider, setSelectedAssistantProvider] = React.useState(initialAssistantProvider);
-        const [selectedAssistantMethod, setSelectedAssistantMethod] = React.useState(initialAssistantMethod);
-        const [selectedChannels, setSelectedChannels] = React.useState(initialChannels);
-        const [selectedScheduledUpdates, setSelectedScheduledUpdates] = React.useState(initialScheduledUpdates);
-        const [selectedWearables, setSelectedWearables] = React.useState(initialWearables);
-        const assistantProviderOptions = listSetupWizardAssistantProviderOptions();
-        const assistantSelection = resolveSetupWizardAssistantSelection({
-            initialApiKeyEnv: input.initialAssistantApiKeyEnv,
-            initialBaseUrl: input.initialAssistantBaseUrl,
-            initialProvider: initialAssistantProvider,
-            initialProviderName: input.initialAssistantProviderName,
-            method: selectedAssistantMethod,
-            provider: selectedAssistantProvider,
-        });
-        const latestAssistantRef = React.useRef(assistantSelection);
-        const latestChannelsRef = React.useRef(initialChannels);
-        const latestScheduledUpdatesRef = React.useRef(initialScheduledUpdates);
-        const latestWearablesRef = React.useRef(initialWearables);
-        const publicUrlReview = buildSetupWizardPublicUrlReview({
-            channels: selectedChannels,
-            wearables: selectedWearables,
-            publicBaseUrl: input.publicBaseUrl,
+    try {
+        instance = render(React.createElement(SetupWizardApp, {
+            channelStatuses: input.channelStatuses,
+            commandName,
+            defaultScheduledUpdateIds,
             deviceSyncLocalBaseUrl: input.deviceSyncLocalBaseUrl,
+            initialAssistantApiKeyEnv: input.initialAssistantApiKeyEnv,
+            initialAssistantBaseUrl: input.initialAssistantBaseUrl,
+            initialAssistantOss: input.initialAssistantOss,
+            initialAssistantPreset,
+            initialAssistantProviderName: input.initialAssistantProviderName,
+            initialAssistantProviderPreset: input.initialAssistantProviderPreset,
+            initialChannels,
+            initialScheduledUpdates,
+            initialWearables,
             linqLocalWebhookUrl: input.linqLocalWebhookUrl,
-        });
-        const includePublicUrlStep = publicUrlReview.enabled;
-        const includeAssistantMethodStep = doesSetupWizardAssistantProviderRequireMethod(selectedAssistantProvider);
-        const publicUrlGuidance = publicUrlReview.enabled
-            ? describeSetupWizardPublicUrlStrategyChoice({
-                review: publicUrlReview,
-                strategy: publicUrlReview.recommendedStrategy,
-            })
-            : null;
-        React.useEffect(() => {
-            latestAssistantRef.current = assistantSelection;
-        }, [assistantSelection]);
-        React.useEffect(() => {
-            latestChannelsRef.current = selectedChannels;
-        }, [selectedChannels]);
-        React.useEffect(() => {
-            latestScheduledUpdatesRef.current = selectedScheduledUpdates;
-        }, [selectedScheduledUpdates]);
-        React.useEffect(() => {
-            latestWearablesRef.current = selectedWearables;
-        }, [selectedWearables]);
-        React.useEffect(() => {
-            setAssistantMethodIndex(findSetupWizardAssistantMethodIndex(selectedAssistantProvider, selectedAssistantMethod));
-        }, [selectedAssistantMethod, selectedAssistantProvider]);
-        const assistantMethodOptions = listSetupWizardAssistantMethodOptions(selectedAssistantProvider);
-        const selectionSteps = {
-            'assistant-provider': {
-                lines: assistantProviderOptions.map((option, index) => ({
-                    active: index === assistantProviderIndex,
-                    badges: buildSetupWizardAssistantProviderBadges({
-                        currentProvider: initialAssistantProvider,
-                        provider: option.provider,
-                    }),
-                    description: option.description,
-                    key: option.provider,
-                    selected: option.provider === selectedAssistantProvider,
-                    title: option.title,
-                })),
-                marker: 'radio',
-                nextStep: includeAssistantMethodStep
-                    ? 'assistant-method'
-                    : 'scheduled-updates',
-                previousStep: 'intro',
-                selectCurrentOnEnter: true,
-                setIndex: setAssistantProviderIndex,
-                step: 'assistant-provider',
-                stepIntro: formatSetupWizardStepIntro('assistant-provider', selectedAssistantProvider),
-                toggleCurrent: () => {
-                    const activeProvider = assistantProviderOptions[assistantProviderIndex]?.provider;
-                    if (!activeProvider) {
-                        return;
-                    }
-                    const nextMethod = resolveSetupWizardAssistantMethodForProvider({
-                        currentMethod: selectedAssistantMethod,
-                        provider: activeProvider,
-                    });
-                    setSelectedAssistantProvider(activeProvider);
-                    setSelectedAssistantMethod(nextMethod);
-                    setAssistantMethodIndex(findSetupWizardAssistantMethodIndex(activeProvider, nextMethod));
-                },
-            },
-            'assistant-method': {
-                lines: assistantMethodOptions.map((option, index) => ({
-                    active: index === assistantMethodIndex,
-                    badges: buildSetupWizardAssistantMethodBadges({
-                        currentMethod: initialAssistantMethod,
-                        method: option.method,
-                        optionBadges: option.badges,
-                    }),
-                    description: option.description,
-                    detail: option.detail,
-                    key: option.method,
-                    selected: option.method === selectedAssistantMethod,
-                    title: option.title,
-                })),
-                marker: 'radio',
-                nextStep: 'scheduled-updates',
-                previousStep: 'assistant-provider',
-                selectCurrentOnEnter: true,
-                setIndex: setAssistantMethodIndex,
-                step: 'assistant-method',
-                stepIntro: formatSetupWizardStepIntro('assistant-method', selectedAssistantProvider),
-                toggleCurrent: () => {
-                    const activeMethod = assistantMethodOptions[assistantMethodIndex]?.method;
-                    if (activeMethod) {
-                        setSelectedAssistantMethod(activeMethod);
-                    }
-                },
+            onCancel: (error) => {
+                completion.fail(error);
             },
-            'scheduled-updates': {
-                lines: setupWizardScheduledUpdateOptions.map((option, index) => ({
-                    active: index === scheduledUpdateIndex,
-                    badges: buildSetupWizardScheduledUpdateBadges({
-                        isStarter: defaultScheduledUpdateIds.has(option.id),
-                    }),
-                    description: option.description,
-                    detail: `Suggested cadence: ${option.scheduleLabel}.`,
-                    key: option.id,
-                    selected: selectedScheduledUpdates.includes(option.id),
-                    title: option.title,
-                })),
-                marker: 'checkbox',
-                nextStep: 'channels',
-                previousStep: includeAssistantMethodStep
-                    ? 'assistant-method'
-                    : 'assistant-provider',
-                selectCurrentOnEnter: false,
-                setIndex: setScheduledUpdateIndex,
-                step: 'scheduled-updates',
-                stepIntro: formatSetupWizardStepIntro('scheduled-updates', selectedAssistantProvider),
-                toggleCurrent: () => {
-                    const activePresetId = setupWizardScheduledUpdateOptions[scheduledUpdateIndex]?.id;
-                    if (activePresetId) {
-                        setSelectedScheduledUpdates((current) => toggleSetupWizardScheduledUpdate(current, activePresetId));
-                    }
-                },
+            onComplete: (result) => {
+                completion.submit(result);
             },
-            channels: {
-                lines: setupWizardChannelOptions.map((option, index) => {
-                    const status = getChannelStatus(option.channel);
-                    return {
-                        active: index === channelIndex,
-                        badges: [
-                            {
-                                label: status.badge,
-                                tone: resolveSetupWizardRuntimeTone(status),
-                            },
-                        ],
-                        description: option.description,
-                        detail: formatSetupWizardRuntimeDetail(status),
-                        key: option.channel,
-                        selected: selectedChannels.includes(option.channel),
-                        title: option.title,
-                    };
-                }),
-                marker: 'checkbox',
-                nextStep: 'wearables',
-                previousStep: 'scheduled-updates',
-                selectCurrentOnEnter: false,
-                setIndex: setChannelIndex,
-                step: 'channels',
-                stepIntro: formatSetupWizardStepIntro('channels', selectedAssistantProvider),
-                toggleCurrent: () => {
-                    const activeChannel = setupWizardChannelOptions[channelIndex]?.channel;
-                    if (activeChannel) {
-                        setSelectedChannels((current) => toggleSetupWizardChannel(current, activeChannel));
-                    }
-                },
-            },
-            wearables: {
-                lines: setupWizardWearableOptions.map((option, index) => {
-                    const status = getWearableStatus(option.wearable);
-                    return {
-                        active: index === wearableIndex,
-                        badges: [
-                            {
-                                label: status.badge,
-                                tone: resolveSetupWizardRuntimeTone(status),
-                            },
-                        ],
-                        description: option.description,
-                        detail: formatSetupWizardRuntimeDetail(status),
-                        key: option.wearable,
-                        selected: selectedWearables.includes(option.wearable),
-                        title: option.title,
-                    };
-                }),
-                marker: 'checkbox',
-                nextStep: includePublicUrlStep ? 'public-url' : 'confirm',
-                previousStep: 'channels',
-                selectCurrentOnEnter: false,
-                setIndex: setWearableIndex,
-                step: 'wearables',
-                stepIntro: formatSetupWizardStepIntro('wearables', selectedAssistantProvider),
-                toggleCurrent: () => {
-                    const activeWearable = setupWizardWearableOptions[wearableIndex]?.wearable;
-                    if (activeWearable) {
-                        setSelectedWearables((current) => toggleSetupWizardWearable(current, activeWearable));
-                    }
-                },
-            },
-        };
-        const selectionStep = step === 'intro' || step === 'public-url' || step === 'confirm'
-            ? null
-            : selectionSteps[step];
-        useInput((value, key) => {
-            if ((key.ctrl && value === 'c') || value.toLowerCase() === 'q') {
-                completion.fail(new VaultCliError('setup_cancelled', 'Murph setup was cancelled.'));
-                exit();
-                return;
-            }
-            if (step === 'intro') {
-                if (key.return || value === ' ') {
-                    setStep('assistant-provider');
-                    return;
-                }
-                if (key.escape) {
-                    completion.fail(new VaultCliError('setup_cancelled', 'Murph setup was cancelled.'));
-                    exit();
-                }
-                return;
-            }
-            if (selectionStep) {
-                if (key.upArrow) {
-                    selectionStep.setIndex((current) => wrapSetupWizardIndex(current, selectionStep.lines.length, -1));
-                    return;
-                }
-                if (key.downArrow) {
-                    selectionStep.setIndex((current) => wrapSetupWizardIndex(current, selectionStep.lines.length, 1));
-                    return;
-                }
-                if (value === ' ') {
-                    selectionStep.toggleCurrent();
-                    return;
-                }
-                if (key.escape) {
-                    setStep(selectionStep.previousStep);
-                    return;
-                }
-                if (key.return) {
-                    if (selectionStep.step === 'assistant-provider') {
-                        const activeProvider = assistantProviderOptions[assistantProviderIndex]?.provider ??
-                            selectedAssistantProvider;
-                        selectionStep.toggleCurrent();
-                        setStep(doesSetupWizardAssistantProviderRequireMethod(activeProvider)
-                            ? 'assistant-method'
-                            : 'scheduled-updates');
-                        return;
-                    }
-                    if (selectionStep.selectCurrentOnEnter) {
-                        selectionStep.toggleCurrent();
-                    }
-                    setStep(selectionStep.nextStep);
-                    return;
-                }
-                return;
-            }
-            if (step === 'public-url') {
-                if (key.escape) {
-                    setStep('wearables');
-                    return;
-                }
-                if (key.return || value === ' ') {
-                    setStep('confirm');
-                }
-                return;
-            }
-            if (step === 'confirm') {
-                if (key.escape || key.leftArrow) {
-                    setStep(includePublicUrlStep ? 'public-url' : 'wearables');
-                    return;
-                }
-                if (key.return || value === ' ') {
-                    completion.submit({
-                        assistantApiKeyEnv: latestAssistantRef.current.apiKeyEnv,
-                        assistantBaseUrl: latestAssistantRef.current.baseUrl,
-                        assistantOss: latestAssistantRef.current.oss,
-                        assistantPreset: latestAssistantRef.current.preset,
-                        assistantProviderName: latestAssistantRef.current.providerName,
-                        channels: sortSetupWizardChannels(latestChannelsRef.current),
-                        scheduledUpdates: sortSetupWizardScheduledUpdates(latestScheduledUpdatesRef.current),
-                        wearables: sortSetupWizardWearables(latestWearablesRef.current),
-                    });
-                    exit();
-                }
-            }
-        });
-        const selectedChannelNames = selectedChannels.map((channel) => formatSetupChannel(channel));
-        const selectedWearableNames = selectedWearables.map((wearable) => formatSetupWearable(wearable));
-        const selectedScheduledUpdateNames = selectedScheduledUpdates.map((presetId) => formatSetupScheduledUpdate(presetId));
-        const selectedChannelSummary = formatSelectionSummary(selectedChannelNames);
-        const selectedScheduledUpdateSummary = formatSelectionSummary(selectedScheduledUpdateNames);
-        const selectedWearableSummary = formatSelectionSummary(selectedWearableNames);
-        const selectedReadyNow = [
-            ...selectedChannels.flatMap((channel) => getChannelStatus(channel).ready ? [formatSetupChannel(channel)] : []),
-            ...selectedWearables.flatMap((wearable) => getWearableStatus(wearable).ready ? [formatSetupWearable(wearable)] : []),
-        ];
-        const selectedNeedsEnv = [
-            ...selectedChannels.flatMap((channel) => {
-                const status = getChannelStatus(channel);
-                return status.missingEnv.length > 0
-                    ? [`${formatSetupChannel(channel)} (${formatMissingEnv(status.missingEnv)})`]
-                    : [];
-            }),
-            ...selectedWearables.flatMap((wearable) => {
-                const status = getWearableStatus(wearable);
-                return status.missingEnv.length > 0
-                    ? [`${formatSetupWearable(wearable)} (${formatMissingEnv(status.missingEnv)})`]
-                    : [];
-            }),
-            ...(assistantSelection.apiKeyEnv &&
-                normalizeSetupWizardText(process.env[assistantSelection.apiKeyEnv]) === null
-                ? [
-                    `Assistant (${assistantSelection.apiKeyEnv})`,
-                ]
-                : []),
-        ];
-        const hintRow = createSetupWizardHintRow(resolveSetupWizardHints({
-            commandName,
-            selectionMarker: selectionStep?.marker,
-            step,
-        }));
-        const confirmNextStep = describeSetupWizardReviewNextStep({
-            needsEnv: selectedNeedsEnv.length > 0,
-            hasScheduledUpdates: selectedScheduledUpdates.length > 0,
-        });
-        const completedBlocks = [];
-        if (hasSetupWizardStepPassed({
-            currentStep: step,
-            includeAssistantMethodStep,
-            includePublicUrlStep,
-            stepToCheck: 'assistant-provider',
-        })) {
-            completedBlocks.push(createSetupWizardAnsweredBlock({
-                label: formatSetupWizardPromptTitle('assistant-provider', selectedAssistantProvider),
-                value: assistantSelection.providerLabel,
-            }, 'completed-assistant-provider'));
-        }
-        if (includeAssistantMethodStep &&
-            hasSetupWizardStepPassed({
-                currentStep: step,
-                includeAssistantMethodStep,
-                includePublicUrlStep,
-                stepToCheck: 'assistant-method',
-            })) {
-            completedBlocks.push(createSetupWizardAnsweredBlock({
-                label: formatSetupWizardPromptTitle('assistant-method', selectedAssistantProvider),
-                value: assistantSelection.methodLabel ?? 'Skip',
-                detail: assistantSelection.detail,
-            }, 'completed-assistant-method'));
-        }
-        if (hasSetupWizardStepPassed({
-            currentStep: step,
-            includeAssistantMethodStep,
-            includePublicUrlStep,
-            stepToCheck: 'scheduled-updates',
-        })) {
-            completedBlocks.push(createSetupWizardAnsweredBlock({
-                label: formatSetupWizardPromptTitle('scheduled-updates', selectedAssistantProvider),
-                value: formatSelectionSummary(selectedScheduledUpdateNames),
-            }, 'completed-scheduled-updates'));
-        }
-        if (hasSetupWizardStepPassed({
-            currentStep: step,
-            includeAssistantMethodStep,
-            includePublicUrlStep,
-            stepToCheck: 'channels',
-        })) {
-            completedBlocks.push(createSetupWizardAnsweredBlock({
-                label: formatSetupWizardPromptTitle('channels', selectedAssistantProvider),
-                value: formatSelectionSummary(selectedChannelNames),
-            }, 'completed-channels'));
-        }
-        if (hasSetupWizardStepPassed({
-            currentStep: step,
-            includeAssistantMethodStep,
-            includePublicUrlStep,
-            stepToCheck: 'wearables',
-        })) {
-            completedBlocks.push(createSetupWizardAnsweredBlock({
-                label: formatSetupWizardPromptTitle('wearables', selectedAssistantProvider),
-                value: formatSelectionSummary(selectedWearableNames),
-            }, 'completed-wearables'));
-        }
-        if (includePublicUrlStep &&
-            hasSetupWizardStepPassed({
-                currentStep: step,
-                includeAssistantMethodStep,
-                includePublicUrlStep,
-                stepToCheck: 'public-url',
-            })) {
-            completedBlocks.push(createSetupWizardAnsweredBlock({
-                label: formatSetupWizardPromptTitle('public-url', selectedAssistantProvider),
-                value: formatSetupPublicUrlStrategy(publicUrlReview.recommendedStrategy),
-                detail: publicUrlGuidance ?? publicUrlReview.summary,
-            }, 'completed-public-url'));
-        }
-        const activePanel = step === 'intro'
-            ? createSetupWizardPanel({
-                title: 'Before you start',
-                tone: 'accent',
-                children: [
-                    createElement(Text, null, 'We’ll help you choose how Murph should answer, which chats to turn on, and any health data you want to connect.'),
-                    createElement(Text, null, ''),
-                    createSetupWizardBulletRow({
-                        body: 'You can skip anything now and change it later.',
-                        label: 'Nothing is locked in',
-                        tone: 'success',
-                    }, 'intro-change-later'),
-                    createSetupWizardBulletRow({
-                        body: 'If something needs a key or token, you can enter it for this setup run only or leave it for later.',
-                        label: 'Keys and tokens',
-                        tone: 'accent',
-                    }, 'intro-keys'),
-                    createSetupWizardBulletRow({
-                        body: SETUP_RUNTIME_ENV_NOTICE,
-                        label: 'This setup run only',
-                        tone: 'muted',
-                    }, 'intro-runtime-env'),
-                ],
-            })
-            : selectionStep
-                ? createSetupWizardPanel({
-                    title: formatSetupWizardPromptTitle(selectionStep.step, selectedAssistantProvider),
-                    tone: 'accent',
-                    children: [
-                        selectionStep.stepIntro
-                            ? createElement(Text, { color: resolveSetupWizardToneColor('muted') }, selectionStep.stepIntro)
-                            : null,
-                        selectionStep.stepIntro ? createElement(Text, null, '') : null,
-                        ...selectionStep.lines.map((line) => createSetupWizardSelectionRow({
-                            line,
-                            marker: selectionStep.marker,
-                        }, line.key)),
-                    ],
-                })
-                : step === 'public-url'
-                    ? createSetupWizardPanel({
-                        title: formatSetupWizardPromptTitle('public-url', selectedAssistantProvider),
-                        tone: 'accent',
-                        children: [
-                            createElement(Text, null, publicUrlReview.summary),
-                            createElement(Text, null, ''),
-                            createSetupWizardBulletRow({
-                                body: publicUrlGuidance ?? '',
-                                label: `Easiest path: ${formatSetupPublicUrlStrategy(publicUrlReview.recommendedStrategy)}`,
-                                tone: 'accent',
-                            }, 'public-url-recommended'),
-                            createElement(Text, null, ''),
-                            createElement(Text, { color: resolveSetupWizardToneColor('muted'), bold: true }, 'If you keep things local, use these URLs'),
-                            createElement(Text, null, ''),
-                            ...publicUrlReview.targets.map((target) => createSetupWizardPublicUrlTargetRow(target)),
-                            createElement(Text, null, ''),
-                            createElement(Text, { color: resolveSetupWizardToneColor('muted') }, 'This step is informational only. Murph does not save a public URL choice yet.'),
-                        ],
-                    })
-                    : createSetupWizardPanel({
-                        title: 'Review your setup',
-                        tone: 'accent',
-                        children: [
-                            createSetupWizardKeyValueRow({ label: 'Assistant', value: assistantSelection.summary }, 'confirm-assistant'),
-                            createSetupWizardKeyValueRow({ label: 'Chat channels', value: selectedChannelSummary }, 'confirm-channels'),
-                            createSetupWizardKeyValueRow({ label: 'Health data', value: selectedWearableSummary }, 'confirm-wearables'),
-                            createSetupWizardKeyValueRow({
-                                label: 'Auto updates',
-                                value: selectedScheduledUpdateSummary,
-                            }, 'confirm-schedules'),
-                            createElement(Text, null, ''),
-                            createSetupWizardBulletRow({
-                                body: formatSelectionSummary(selectedReadyNow),
-                                label: 'Can connect now',
-                                tone: 'success',
-                            }, 'confirm-ready'),
-                            createSetupWizardBulletRow({
-                                body: formatSelectionSummary(selectedNeedsEnv),
-                                label: 'Needs keys first',
-                                tone: selectedNeedsEnv.length > 0 ? 'warn' : 'muted',
-                            }, 'confirm-needs-env'),
-                            publicUrlGuidance
-                                ? createSetupWizardBulletRow({
-                                    body: publicUrlGuidance,
-                                    label: 'Public links',
-                                    tone: 'accent',
-                                }, 'confirm-public-url')
-                                : null,
-                            createElement(Text, null, ''),
-                            createSetupWizardBulletRow({
-                                body: confirmNextStep,
-                                label: 'Next',
-                                tone: 'accent',
-                            }, 'confirm-next-step'),
-                        ],
-                    });
-        return createElement(Box, {
-            flexDirection: 'column',
-            paddingX: 1,
-            paddingY: 1,
-        }, createElement(Text, { color: resolveSetupWizardToneColor('accent'), bold: true }, '✦ Murph setup'), createElement(Text, { color: resolveSetupWizardToneColor('muted') }, 'Choose the basics now. You can change anything later.'), createElement(Text, { color: resolveSetupWizardToneColor('muted'), dimColor: true }, `Vault: ${input.vault}`), createElement(Text, null, ''), ...completedBlocks, activePanel, createElement(Text, null, ''), hintRow);
-        function getChannelStatus(channel) {
-            return normalizeSetupWizardRuntimeStatus(input.channelStatuses?.[channel]);
-        }
-        function getWearableStatus(wearable) {
-            return normalizeSetupWizardRuntimeStatus(input.wearableStatuses?.[wearable]);
-        }
-    };
-    try {
-        instance = render(React.createElement(App), {
+            publicBaseUrl: input.publicBaseUrl,
+            vault: input.vault,
+            wearableStatuses: input.wearableStatuses,
+        }), {
             stderr: process.stderr,
             stdout: process.stderr,
             patchConsole: false,
@@ -674,306 +72,4 @@ export async function runSetupWizard(input) {
     }
     return await completion.waitForResult();
 }
-function normalizeSetupWizardRuntimeStatus(status) {
-    return (status ?? {
-        badge: 'optional',
-        detail: '',
-        missingEnv: [],
-        ready: true,
-    });
-}
-function sortSetupWizardChannels(channels) {
-    const order = new Map(setupChannelValues.map((channel, index) => [channel, index]));
-    const unique = [...new Set(channels)];
-    return unique.sort((left, right) => (order.get(left) ?? Number.MAX_SAFE_INTEGER) -
-        (order.get(right) ?? Number.MAX_SAFE_INTEGER));
-}
-function sortSetupWizardWearables(wearables) {
-    const order = new Map(setupWearableValues.map((wearable, index) => [wearable, index]));
-    const unique = [...new Set(wearables)];
-    return unique.sort((left, right) => (order.get(left) ?? Number.MAX_SAFE_INTEGER) -
-        (order.get(right) ?? Number.MAX_SAFE_INTEGER));
-}
-function sortSetupWizardScheduledUpdates(presetIds) {
-    const order = new Map(setupWizardScheduledUpdateOptions.map((option, index) => [option.id, index]));
-    const unique = [...new Set(presetIds)];
-    return unique.sort((left, right) => (order.get(left) ?? Number.MAX_SAFE_INTEGER) -
-        (order.get(right) ?? Number.MAX_SAFE_INTEGER));
-}
-function formatSetupChannel(channel) {
-    switch (channel) {
-        case 'imessage':
-            return 'iMessage';
-        case 'telegram':
-            return 'Telegram';
-        case 'linq':
-            return 'Linq';
-        case 'email':
-            return 'Email';
-    }
-}
-function formatSetupWearable(wearable) {
-    switch (wearable) {
-        case 'garmin':
-            return 'Garmin';
-        case 'oura':
-            return 'Oura';
-        case 'whoop':
-            return 'WHOOP';
-    }
-}
-function formatSetupScheduledUpdate(presetId) {
-    return (setupWizardScheduledUpdateOptions.find((option) => option.id === presetId)?.title ??
-        presetId);
-}
-function formatSelectionSummary(values) {
-    return values.length > 0 ? values.join(', ') : 'None';
-}
-function formatMissingEnv(values) {
-    if (values.length === 0) {
-        return 'nothing else';
-    }
-    if (values.length === 1) {
-        return values[0] ?? '';
-    }
-    return values.join(', ');
-}
-function formatSetupPublicUrlStrategy(strategy) {
-    return strategy === 'hosted' ? 'Hosted web app' : 'Local tunnel';
-}
-function listSetupWizardSteps(input) {
-    return [
-        'intro',
-        'assistant-provider',
-        ...(input.includeAssistantMethodStep ? ['assistant-method'] : []),
-        'scheduled-updates',
-        'channels',
-        'wearables',
-        ...(input.includePublicUrlStep ? ['public-url'] : []),
-        'confirm',
-    ];
-}
-function hasSetupWizardStepPassed(input) {
-    const steps = listSetupWizardSteps({
-        includeAssistantMethodStep: input.includeAssistantMethodStep,
-        includePublicUrlStep: input.includePublicUrlStep,
-    });
-    const currentIndex = steps.indexOf(input.currentStep);
-    const stepIndex = steps.indexOf(input.stepToCheck);
-    return currentIndex > stepIndex;
-}
-function resolveSetupWizardRuntimeTone(status) {
-    if (status.ready) {
-        return 'success';
-    }
-    return status.badge.toLowerCase().includes('macos') ? 'accent' : 'warn';
-}
-function formatSetupWizardRuntimeDetail(status) {
-    if (status.ready) {
-        return 'Ready to connect now.';
-    }
-    if (!status.ready && status.missingEnv.length > 0) {
-        return `Needs ${formatMissingEnv(status.missingEnv)} before this can connect.`;
-    }
-    return status.badge.toLowerCase().includes('macos')
-        ? 'Only available on macOS.'
-        : status.detail;
-}
-function buildSetupWizardScheduledUpdateBadges(input) {
-    return [
-        ...(input.isStarter ? [{ label: 'recommended', tone: 'accent' }] : []),
-        { label: 'set up later', tone: 'muted' },
-    ];
-}
-function formatSetupWizardPromptTitle(step, provider) {
-    switch (step) {
-        case 'intro':
-            return 'Before you start';
-        case 'assistant-provider':
-            return 'How should Murph answer?';
-        case 'assistant-method':
-            if (provider === 'openai') {
-                return 'How should Murph connect to OpenAI?';
-            }
-            return 'How should Murph connect to your endpoint?';
-        case 'scheduled-updates':
-            return 'Auto updates';
-        case 'channels':
-            return 'Chat channels';
-        case 'wearables':
-            return 'Health data';
-        case 'public-url':
-            return 'Public links';
-        case 'confirm':
-            return 'Review';
-    }
-}
-function formatSetupWizardStepIntro(step, provider) {
-    switch (step) {
-        case 'assistant-provider':
-            return 'Choose the provider or endpoint style Murph should use by default.';
-        case 'assistant-method':
-            return provider === 'openai'
-                ? 'Pick the OpenAI path that fits you best.'
-                : 'Choose a manual endpoint or keep the Codex local-model flow.';
-        case 'scheduled-updates':
-            return 'These are optional check-ins Murph can send later.';
-        case 'channels':
-            return 'Turn on the chats you want Murph to use first.';
-        case 'wearables':
-            return 'Pick any health data sources you want to connect after setup.';
-        default:
-            return undefined;
-    }
-}
-function resolveSetupWizardHints(input) {
-    switch (input.step) {
-        case 'intro':
-            return [
-                { label: `Enter start ${input.commandName}`, tone: 'accent' },
-                { label: 'q quit', tone: 'muted' },
-            ];
-        case 'assistant-provider':
-        case 'assistant-method':
-        case 'scheduled-updates':
-        case 'channels':
-        case 'wearables':
-            return [
-                { label: '↑/↓ move', tone: 'muted' },
-                {
-                    label: input.selectionMarker === 'radio' ? 'Space choose' : 'Space toggle',
-                    tone: 'accent',
-                },
-                { label: 'Enter next', tone: 'success' },
-                { label: 'Esc back', tone: 'muted' },
-                { label: 'q quit', tone: 'muted' },
-            ];
-        case 'public-url':
-            return [
-                { label: 'Enter next', tone: 'success' },
-                { label: 'Esc back', tone: 'muted' },
-                { label: 'q quit', tone: 'muted' },
-            ];
-        case 'confirm':
-            return [
-                { label: 'Enter start setup', tone: 'success' },
-                { label: 'Esc back', tone: 'muted' },
-                { label: 'q quit', tone: 'muted' },
-            ];
-    }
-}
-function describeSetupWizardReviewNextStep(input) {
-    if (input.needsEnv && input.hasScheduledUpdates) {
-        return 'Murph will ask for any missing keys for this setup run, finish setup, keep your update picks ready for later, and open anything that can connect right away.';
-    }
-    if (input.needsEnv) {
-        return 'Murph will ask for any missing keys for this setup run, finish setup, and open anything that can connect right away.';
-    }
-    if (input.hasScheduledUpdates) {
-        return 'Murph will finish setup, keep your update picks ready for later, and open anything that can connect right away.';
-    }
-    return 'Murph will finish setup and open anything that can connect right away.';
-}
-export function buildSetupWizardPublicUrlReview(input) {
-    const publicBaseUrl = normalizeSetupWizardText(input.publicBaseUrl);
-    const hasLinq = input.channels.includes('linq');
-    const selectedWearables = sortSetupWizardWearables(input.wearables);
-    const needsPublicStrategy = hasLinq || selectedWearables.length > 0;
-    const deviceSyncLocalBaseUrl = normalizeSetupWizardText(input.deviceSyncLocalBaseUrl) ??
-        DEFAULT_SETUP_DEVICE_SYNC_LOCAL_BASE_URL;
-    const linqLocalWebhookUrl = normalizeSetupWizardText(input.linqLocalWebhookUrl) ??
-        DEFAULT_SETUP_LINQ_WEBHOOK_URL;
-    if (!needsPublicStrategy || publicBaseUrl) {
-        return {
-            enabled: false,
-            recommendedStrategy: 'hosted',
-            summary: '',
-            targets: [],
-        };
-    }
-    return {
-        enabled: true,
-        recommendedStrategy: selectedWearables.length > 0 ? 'hosted' : 'tunnel',
-        summary: describeSetupWizardPublicUrlSummary({
-            hasLinq,
-            wearables: selectedWearables,
-        }),
-        targets: buildSetupWizardPublicUrlTargets({
-            hasLinq,
-            wearables: selectedWearables,
-            deviceSyncLocalBaseUrl,
-            linqLocalWebhookUrl,
-        }),
-    };
-}
-export function describeSetupWizardPublicUrlStrategyChoice(input) {
-    if (!input.review.enabled) {
-        return '';
-    }
-    if (input.strategy === 'hosted') {
-        const hasLinq = input.review.targets.some((target) => target.label === 'Linq webhook');
-        return hasLinq
-            ? 'Use hosted `apps/web` for Garmin/WHOOP/Oura, but keep Linq on the local webhook path for now.'
-            : 'Use hosted `apps/web` for Garmin/WHOOP/Oura so callbacks stay on one stable public base.';
-    }
-    const hasWearableTargets = input.review.targets.some((target) => target.label.startsWith('Garmin') || target.label.startsWith('WHOOP') || target.label.startsWith('Oura'));
-    if (hasWearableTargets) {
-        return 'Expose the local callback routes through a tunnel instead of setting up hosted `apps/web` first.';
-    }
-    return 'Expose the local Linq webhook through a tunnel. Murph does not have a hosted Linq webhook yet.';
-}
-function describeSetupWizardPublicUrlSummary(input) {
-    if (input.wearables.length > 0 && input.hasLinq) {
-        return 'Garmin/WHOOP/Oura are easiest through hosted `apps/web`, while Linq still needs the local inbox webhook today.';
-    }
-    if (input.wearables.length > 0) {
-        return 'Garmin/WHOOP/Oura need a public callback URL. Hosted `apps/web` is the easiest stable base.';
-    }
-    return 'Linq still uses the local inbox webhook today, so a tunnel to your machine is the simplest public path.';
-}
-function buildSetupWizardPublicUrlTargets(input) {
-    const targets = [];
-    if (input.wearables.includes('garmin')) {
-        targets.push({
-            label: 'Garmin callback',
-            url: new URL('/oauth/garmin/callback', input.deviceSyncLocalBaseUrl).toString(),
-            detail: 'Use this if Garmin finishes sign-in on your machine through a tunnel.',
-        });
-    }
-    if (input.wearables.includes('whoop')) {
-        targets.push({
-            label: 'WHOOP callback',
-            url: new URL('/oauth/whoop/callback', input.deviceSyncLocalBaseUrl).toString(),
-            detail: 'Use this if WHOOP sends the callback directly to your machine through a tunnel.',
-        });
-        targets.push({
-            label: 'WHOOP webhook',
-            url: new URL('/webhooks/whoop', input.deviceSyncLocalBaseUrl).toString(),
-            detail: 'Use this if WHOOP sends webhooks straight to your machine through a tunnel.',
-        });
-    }
-    if (input.wearables.includes('oura')) {
-        targets.push({
-            label: 'Oura callback',
-            url: new URL('/oauth/oura/callback', input.deviceSyncLocalBaseUrl).toString(),
-            detail: 'Use this if Oura finishes sign-in on your machine through a tunnel.',
-        });
-        targets.push({
-            label: 'Oura webhook',
-            url: new URL('/webhooks/oura', input.deviceSyncLocalBaseUrl).toString(),
-            detail: 'Optional today. Oura can still work without this, but this is the local webhook URL if you enable it.',
-        });
-    }
-    if (input.hasLinq) {
-        targets.push({
-            label: 'Linq webhook',
-            url: input.linqLocalWebhookUrl,
-            detail: 'Point your tunnel here. Hosted `apps/web` does not replace this Linq webhook yet.',
-        });
-    }
-    return targets;
-}
-function normalizeSetupWizardText(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
-}
 //# sourceMappingURL=setup-wizard.js.map