@murphai/murph 0.1.14 → 0.1.17

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

@@ -0,0 +1,979 @@
+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';
+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 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 initialScheduledUpdates = resolveSetupWizardInitialScheduledUpdates(input.initialScheduledUpdates);
+    const initialWearables = sortSetupWizardWearables(input.initialWearables && input.initialWearables.length > 0
+        ? [...input.initialWearables]
+        : getDefaultSetupWizardWearables());
+    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,
+            deviceSyncLocalBaseUrl: input.deviceSyncLocalBaseUrl,
+            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);
+                    }
+                },
+            },
+            '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));
+                    }
+                },
+            },
+            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), {
+            stderr: process.stderr,
+            stdout: process.stderr,
+            patchConsole: false,
+        });
+        void instance.waitUntilExit().then(() => {
+            completion.completeExit();
+        }, (error) => {
+            completion.fail(error);
+        });
+    }
+    catch (error) {
+        completion.fail(error);
+    }
+    if (!instance) {
+        completion.fail(new Error('Murph setup wizard failed to initialize.'));
+    }
+    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