@murphai/murph 0.1.14 → 0.1.17

package/dist/setup-wizard.js

@@ -1,1477 +0,0 @@
-import * as React from 'react';
-import { Box, Text, render, useApp, useInput } from 'ink';
-import { listNamedOpenAICompatibleProviderPresets, resolveOpenAICompatibleProviderPreset, resolveOpenAICompatibleProviderPresetFromId, } from '@murphai/assistant-core/assistant-provider';
-import { listAssistantCronPresets } from '@murphai/assistant-core/assistant-cron';
-import { DEFAULT_SETUP_OPENAI_COMPATIBLE_BASE_URL, getDefaultSetupAssistantPreset as getDefaultAssistantPreset, } from './setup-assistant.js';
-import { setupChannelValues, setupWearableValues, } from '@murphai/assistant-core/setup-cli-contracts';
-import { SETUP_RUNTIME_ENV_NOTICE, } from '@murphai/assistant-core/setup-runtime-env';
-import { VaultCliError } from '@murphai/assistant-core/vault-cli-errors';
-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 DEFAULT_SETUP_OPENAI_API_BASE_URL = 'https://api.openai.com/v1';
-const setupWizardAssistantProviderOptions = [
-    ...listNamedOpenAICompatibleProviderPresets().map((preset) => ({
-        provider: preset.id,
-        title: preset.title,
-        description: buildSetupWizardAssistantProviderDescription(preset),
-    })),
-    {
-        provider: 'custom',
-        title: 'Custom endpoint',
-        description: 'Use any other OpenAI-style endpoint, or keep the Codex local-model path.',
-    },
-    {
-        provider: 'skip',
-        title: 'Skip for now',
-        description: 'Leave the current assistant settings alone.',
-    },
-];
-const setupWizardOpenAIAssistantMethodOptions = [
-    {
-        method: 'openai-codex',
-        title: 'ChatGPT / Codex sign-in',
-        description: 'Best if you already use the Codex sign-in flow.',
-        detail: 'Murph will use your saved Codex / ChatGPT login and ask which default model to use next.',
-        badges: [{ label: 'recommended', tone: 'success' }],
-    },
-    {
-        method: 'openai-api-key',
-        title: 'OpenAI API key',
-        description: 'Use OPENAI_API_KEY and choose a model.',
-        detail: 'Good if you want direct API billing instead of the Codex sign-in path.',
-    },
-];
-const setupWizardCompatibleAssistantMethodOptions = [
-    {
-        method: 'compatible-endpoint',
-        title: 'Compatible endpoint',
-        description: 'Use any OpenAI-style endpoint and enter the details during setup.',
-        detail: 'Murph will ask for the endpoint URL and then let you choose a model.',
-        badges: [{ label: 'manual', tone: 'accent' }],
-    },
-    {
-        method: 'compatible-codex-local',
-        title: 'Codex local model',
-        description: 'Keep the Codex flow, but point it at a local OSS model.',
-        detail: 'Good if you want the Codex tooling path with a local model by default.',
-    },
-];
-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 getDefaultSetupWizardAssistantPreset() {
-    return getDefaultAssistantPreset();
-}
-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 wrapSetupWizardIndex(currentIndex, length, delta) {
-    if (length <= 0) {
-        return 0;
-    }
-    return (currentIndex + delta + length) % length;
-}
-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 function createSetupWizardCompletionController() {
-    let settled = false;
-    let exited = false;
-    let submittedResult = null;
-    let resolvePromise;
-    let rejectPromise;
-    const promise = new Promise((resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-    });
-    const maybeResolve = () => {
-        if (settled || !exited || submittedResult === null) {
-            return;
-        }
-        settled = true;
-        resolvePromise(submittedResult);
-    };
-    return {
-        completeExit() {
-            if (settled) {
-                return;
-            }
-            exited = true;
-            if (submittedResult === null) {
-                settled = true;
-                rejectPromise(new Error('Murph setup wizard exited unexpectedly.'));
-                return;
-            }
-            maybeResolve();
-        },
-        fail(error) {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            rejectPromise(error);
-        },
-        submit(result) {
-            if (settled || submittedResult !== null) {
-                return;
-            }
-            submittedResult = result;
-            maybeResolve();
-        },
-        async waitForResult() {
-            return await promise;
-        },
-    };
-}
-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 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: setupWizardAssistantProviderOptions.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 = setupWizardAssistantProviderOptions[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 = setupWizardAssistantProviderOptions[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 findSetupWizardAssistantProviderIndex(provider) {
-    const index = setupWizardAssistantProviderOptions.findIndex((option) => option.provider === provider);
-    return index >= 0 ? index : 0;
-}
-function findSetupWizardAssistantMethodIndex(provider, method) {
-    const options = listSetupWizardAssistantMethodOptions(provider);
-    const index = options.findIndex((option) => option.method === method);
-    return index >= 0 ? index : 0;
-}
-export function inferSetupWizardAssistantProvider(input) {
-    switch (input.preset) {
-        case 'codex':
-            if (input.oss === true) {
-                return resolveSetupWizardCompatibleProviderPreset(input)?.id ?? 'custom';
-            }
-            return 'openai';
-        case 'skip':
-            return 'skip';
-        case 'openai-compatible':
-            if (input.providerPreset) {
-                return input.providerPreset;
-            }
-            if (isOpenAIAssistantSelection(input)) {
-                return 'openai';
-            }
-            return resolveSetupWizardCompatibleProviderPreset(input)?.id ?? 'custom';
-    }
-}
-function inferSetupWizardAssistantMethod(input) {
-    switch (input.preset) {
-        case 'codex':
-            return input.oss === true ? 'compatible-codex-local' : 'openai-codex';
-        case 'skip':
-            return 'skip';
-        case 'openai-compatible':
-            if (input.provider === 'openai') {
-                return 'openai-api-key';
-            }
-            return doesSetupWizardAssistantProviderRequireMethod(input.provider)
-                ? 'compatible-endpoint'
-                : 'compatible-provider';
-    }
-}
-function doesSetupWizardAssistantProviderRequireMethod(provider) {
-    return provider === 'openai' || provider === 'custom';
-}
-function resolveSetupWizardAssistantMethodForProvider(input) {
-    if (input.provider === 'skip') {
-        return 'skip';
-    }
-    if (input.provider === 'openai') {
-        return input.currentMethod === 'openai-api-key'
-            ? 'openai-api-key'
-            : 'openai-codex';
-    }
-    if (input.provider === 'custom') {
-        return input.currentMethod === 'compatible-codex-local'
-            ? 'compatible-codex-local'
-            : 'compatible-endpoint';
-    }
-    return 'compatible-provider';
-}
-function listSetupWizardAssistantMethodOptions(provider) {
-    switch (provider) {
-        case 'openai':
-            return setupWizardOpenAIAssistantMethodOptions;
-        case 'custom':
-            return setupWizardCompatibleAssistantMethodOptions;
-        case 'skip':
-            return [];
-        default:
-            return [];
-    }
-}
-export function resolveSetupWizardAssistantSelection(input) {
-    const preservedSelection = input.initialProvider === input.provider
-        ? {
-            apiKeyEnv: normalizeSetupWizardText(input.initialApiKeyEnv),
-            baseUrl: normalizeSetupWizardText(input.initialBaseUrl),
-            providerName: normalizeSetupWizardText(input.initialProviderName),
-        }
-        : {
-            apiKeyEnv: null,
-            baseUrl: null,
-            providerName: null,
-        };
-    if (input.provider === 'skip') {
-        return {
-            apiKeyEnv: null,
-            baseUrl: null,
-            detail: 'Murph will leave your current assistant settings alone for now.',
-            methodLabel: null,
-            oss: null,
-            preset: 'skip',
-            providerLabel: 'Skip for now',
-            providerName: null,
-            summary: 'Skip for now',
-        };
-    }
-    if (input.provider === 'openai') {
-        if (input.method === 'openai-api-key') {
-            const apiKeyEnv = preservedSelection.apiKeyEnv ?? 'OPENAI_API_KEY';
-            return {
-                apiKeyEnv,
-                baseUrl: preservedSelection.baseUrl ?? DEFAULT_SETUP_OPENAI_API_BASE_URL,
-                detail: `Murph will use ${apiKeyEnv} and ask which model to save next.`,
-                methodLabel: 'OpenAI API key',
-                oss: false,
-                preset: 'openai-compatible',
-                providerLabel: 'OpenAI',
-                providerName: preservedSelection.providerName ?? 'openai',
-                summary: 'OpenAI · API key',
-            };
-        }
-        return {
-            apiKeyEnv: null,
-            baseUrl: null,
-            detail: 'Murph will use your saved Codex / ChatGPT sign-in and ask which default model to use next.',
-            methodLabel: 'ChatGPT / Codex sign-in',
-            oss: false,
-            preset: 'codex',
-            providerLabel: 'OpenAI',
-            providerName: null,
-            summary: 'OpenAI · ChatGPT / Codex sign-in',
-        };
-    }
-    if (input.provider === 'custom') {
-        if (input.method === 'compatible-codex-local') {
-            return {
-                apiKeyEnv: null,
-                baseUrl: null,
-                detail: 'Murph will keep the Codex flow and ask which local model to save next.',
-                methodLabel: 'Codex local model',
-                oss: true,
-                preset: 'codex',
-                providerLabel: 'Custom endpoint',
-                providerName: null,
-                summary: 'Custom endpoint · Codex local model',
-            };
-        }
-        return {
-            apiKeyEnv: preservedSelection.apiKeyEnv,
-            baseUrl: preservedSelection.baseUrl ?? DEFAULT_SETUP_OPENAI_COMPATIBLE_BASE_URL,
-            detail: 'Murph will ask for the endpoint URL and then let you choose a model.',
-            methodLabel: 'Compatible endpoint',
-            oss: false,
-            preset: 'openai-compatible',
-            providerLabel: 'Custom endpoint',
-            providerName: preservedSelection.providerName,
-            summary: 'Custom endpoint · Compatible endpoint',
-        };
-    }
-    const providerPreset = resolveOpenAICompatibleProviderPresetFromId(input.provider) ??
-        resolveOpenAICompatibleProviderPresetFromId('custom');
-    return {
-        apiKeyEnv: preservedSelection.apiKeyEnv ?? providerPreset?.apiKeyEnv ?? null,
-        baseUrl: preservedSelection.baseUrl ??
-            providerPreset?.baseUrl ??
-            DEFAULT_SETUP_OPENAI_COMPATIBLE_BASE_URL,
-        detail: buildSetupWizardNamedProviderSelectionDetail({
-            apiKeyEnv: preservedSelection.apiKeyEnv ?? providerPreset?.apiKeyEnv ?? null,
-            preset: providerPreset,
-        }),
-        methodLabel: null,
-        oss: false,
-        preset: 'openai-compatible',
-        providerLabel: providerPreset?.title ?? 'OpenAI-compatible provider',
-        providerName: preservedSelection.providerName ?? providerPreset?.providerName ?? null,
-        summary: providerPreset?.title ?? 'OpenAI-compatible provider',
-    };
-}
-function resolveSetupWizardCompatibleProviderPreset(input) {
-    const normalizedBaseUrl = normalizeSetupWizardText(input.baseUrl);
-    if (normalizedBaseUrl !== null) {
-        const preset = resolveOpenAICompatibleProviderPreset({
-            baseUrl: normalizedBaseUrl,
-        });
-        return preset?.id === 'openai' ? null : preset;
-    }
-    const normalizedProviderName = normalizeSetupWizardText(input.providerName);
-    if (normalizedProviderName !== null) {
-        const preset = resolveOpenAICompatibleProviderPreset({
-            providerName: normalizedProviderName,
-        });
-        return preset?.id === 'openai' ? null : preset;
-    }
-    const preset = resolveOpenAICompatibleProviderPreset({
-        apiKeyEnv: input.apiKeyEnv,
-    });
-    return preset?.id === 'openai' ? null : preset;
-}
-function isOpenAIAssistantSelection(input) {
-    const normalizedProviderName = normalizeSetupWizardText(input.providerName);
-    if (normalizedProviderName !== null) {
-        return (resolveOpenAICompatibleProviderPreset({
-            providerName: normalizedProviderName,
-        })?.id === 'openai');
-    }
-    const normalizedBaseUrl = normalizeSetupWizardText(input.baseUrl);
-    if (normalizedBaseUrl !== null) {
-        return (resolveOpenAICompatibleProviderPreset({
-            baseUrl: normalizedBaseUrl,
-        })?.id === 'openai');
-    }
-    return (resolveOpenAICompatibleProviderPreset({
-        apiKeyEnv: input.apiKeyEnv,
-    })?.id === 'openai');
-}
-function buildSetupWizardAssistantProviderDescription(preset) {
-    if (preset.id === 'openai') {
-        return 'Use OpenAI. You can choose ChatGPT / Codex sign-in or an API key next.';
-    }
-    if (preset.kind === 'local') {
-        return `Use ${preset.title} through its local OpenAI-compatible server.`;
-    }
-    if (preset.kind === 'gateway') {
-        return `Use ${preset.title} as an OpenAI-compatible gateway.`;
-    }
-    return `Use ${preset.title} and choose a model during setup.`;
-}
-function buildSetupWizardNamedProviderSelectionDetail(input) {
-    const providerTitle = input.preset?.title ?? 'this provider';
-    if (input.apiKeyEnv) {
-        return `Murph will use ${providerTitle} and read the key from ${input.apiKeyEnv}. It will ask which model to save next.`;
-    }
-    return `Murph will use ${providerTitle} and ask which model to save next.`;
-}
-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 resolveSetupWizardToneColor(tone) {
-    switch (tone) {
-        case 'accent':
-            return 'cyan';
-        case 'success':
-            return 'green';
-        case 'warn':
-            return 'yellow';
-        case 'danger':
-            return 'red';
-        case 'muted':
-            return 'gray';
-    }
-}
-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 buildSetupWizardAssistantProviderBadges(input) {
-    const badges = [];
-    if (input.provider === 'skip') {
-        badges.push({ label: 'no change', tone: 'muted' });
-    }
-    else if (input.provider === 'custom') {
-        badges.push({ label: 'manual', tone: 'accent' });
-    }
-    else {
-        const preset = resolveOpenAICompatibleProviderPresetFromId(input.provider);
-        if (preset?.id === 'openai') {
-            badges.push({ label: 'recommended', tone: 'success' });
-        }
-        else if (preset?.kind === 'local') {
-            badges.push({ label: 'local', tone: 'accent' });
-        }
-        else if (preset?.kind === 'gateway') {
-            badges.push({ label: 'gateway', tone: 'accent' });
-        }
-        else {
-            badges.push({ label: 'hosted', tone: 'muted' });
-        }
-    }
-    if (input.currentProvider === input.provider) {
-        badges.push({ label: 'current', tone: 'accent' });
-    }
-    return badges;
-}
-function buildSetupWizardAssistantMethodBadges(input) {
-    return [
-        ...(input.optionBadges ? [...input.optionBadges] : []),
-        ...(input.currentMethod === input.method
-            ? [{ label: 'current', tone: 'accent' }]
-            : []),
-    ];
-}
-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 createSetupWizardPanel(input) {
-    const createElement = React.createElement;
-    return createElement(Box, {
-        borderColor: resolveSetupWizardToneColor(input.tone),
-        borderStyle: 'round',
-        flexDirection: 'column',
-        paddingX: 1,
-        paddingY: 0,
-    }, createElement(Text, { color: resolveSetupWizardToneColor(input.tone), bold: true }, input.title), input.children.length > 0 ? createElement(Text, null, '') : null, ...input.children);
-}
-function createSetupWizardInlineBadgeElements(badges, keyPrefix) {
-    const createElement = React.createElement;
-    const elements = [];
-    for (const [index, badge] of badges.entries()) {
-        if (index > 0) {
-            elements.push(createElement(Text, { key: `${keyPrefix}:space:${index}` }, ' '));
-        }
-        elements.push(createElement(Text, {
-            bold: true,
-            color: resolveSetupWizardToneColor(badge.tone),
-            key: `${keyPrefix}:badge:${badge.label}:${index}`,
-        }, `[${badge.label}]`));
-    }
-    return elements;
-}
-function createSetupWizardSelectionRow(input, key) {
-    const createElement = React.createElement;
-    const markerSymbol = input.marker === 'checkbox'
-        ? input.line.selected
-            ? '■'
-            : '□'
-        : input.line.selected
-            ? '●'
-            : '○';
-    const markerTone = input.line.active
-        ? 'accent'
-        : input.line.selected
-            ? 'success'
-            : 'muted';
-    const titleColor = input.line.active
-        ? resolveSetupWizardToneColor('accent')
-        : input.line.selected
-            ? resolveSetupWizardToneColor('success')
-            : undefined;
-    return createElement(Box, {
-        flexDirection: 'column',
-        key,
-        marginBottom: 1,
-    }, createElement(Box, { flexDirection: 'row' }, createElement(Text, {
-        color: input.line.active
-            ? resolveSetupWizardToneColor('accent')
-            : resolveSetupWizardToneColor('muted'),
-        bold: input.line.active,
-    }, `${input.line.active ? '›' : ' '} `), createElement(Text, {
-        color: resolveSetupWizardToneColor(markerTone),
-        bold: true,
-    }, `${markerSymbol} `), createElement(Text, {
-        color: titleColor,
-        bold: true,
-    }, input.line.title), input.line.badges.length > 0
-        ? createElement(Box, {
-            flexDirection: 'row',
-            marginLeft: 1,
-        }, createElement(Text, null, ...createSetupWizardInlineBadgeElements(input.line.badges, key)))
-        : null), createElement(Text, { color: resolveSetupWizardToneColor('muted') }, `  ${input.line.description}`), input.line.detail
-        ? createElement(Text, {
-            color: resolveSetupWizardToneColor('muted'),
-            dimColor: true,
-        }, `  ${input.line.detail}`)
-        : null);
-}
-function createSetupWizardAnsweredBlock(input, key) {
-    const createElement = React.createElement;
-    return createElement(Box, {
-        flexDirection: 'column',
-        key,
-        marginBottom: 1,
-    }, createElement(Text, { color: resolveSetupWizardToneColor('accent'), bold: true }, `◇ ${input.label}`), createElement(Text, { bold: true }, `  ${input.value}`), input.detail
-        ? createElement(Text, {
-            color: resolveSetupWizardToneColor('muted'),
-            dimColor: true,
-        }, `  ${input.detail}`)
-        : null);
-}
-function createSetupWizardBulletRow(input, key) {
-    const createElement = React.createElement;
-    return createElement(Box, {
-        flexDirection: 'column',
-        key,
-        marginBottom: 1,
-    }, createElement(Text, null, createElement(Text, {
-        color: resolveSetupWizardToneColor(input.tone),
-        bold: true,
-    }, `• ${input.label}: `), input.body));
-}
-function createSetupWizardKeyValueRow(input, key) {
-    const createElement = React.createElement;
-    return createElement(Box, {
-        flexDirection: 'column',
-        key,
-        marginBottom: 1,
-    }, createElement(Text, null, createElement(Text, {
-        color: resolveSetupWizardToneColor('muted'),
-        bold: true,
-    }, `${input.label}: `), input.value));
-}
-function createSetupWizardPublicUrlTargetRow(target) {
-    const createElement = React.createElement;
-    return createElement(Box, {
-        flexDirection: 'column',
-        key: target.label,
-        marginBottom: 1,
-    }, createElement(Text, null, createElement(Text, {
-        color: resolveSetupWizardToneColor('muted'),
-        bold: true,
-    }, `${target.label}: `), createElement(Text, { color: resolveSetupWizardToneColor('accent') }, target.url)), createElement(Text, {
-        color: resolveSetupWizardToneColor('muted'),
-        dimColor: true,
-    }, `  ${target.detail}`));
-}
-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 createSetupWizardHintRow(hints) {
-    const createElement = React.createElement;
-    return createElement(Text, null, ...createSetupWizardInlineBadgeElements(hints, 'hint'));
-}
-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