@murphai/murph 1.3.0 → 1.3.1

package/node_modules/@murphai/setup-cli/dist/setup-services/channels.js

@@ -1,434 +1,173 @@
 import { reconcileManagedAssistantAutoReplyChannelsLocal } from '@murphai/assistant-engine/assistant-state';
-import { resolveAgentmailApiKey } from '@murphai/operator-config/agentmail-runtime';
-import { getAssistantChannelAdapter } from '@murphai/assistant-engine/assistant-runtime';
 import { resolveSetupChannelMissingEnv, SETUP_RUNTIME_ENV_NOTICE, } from '@murphai/operator-config/setup-runtime-env';
-import { setupChannelValues, } from '@murphai/operator-config/setup-cli-contracts';
+import {} from '@murphai/operator-config/setup-cli-contracts';
 import { resolveTelegramBotToken } from '@murphai/operator-config/telegram-runtime';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
 import { createStep } from './steps.js';
 const TELEGRAM_SETUP_CONNECTOR_ID = 'telegram:bot';
 const TELEGRAM_SETUP_ACCOUNT_ID = 'bot';
-const EMAIL_SETUP_CONNECTOR_ID = 'email:agentmail';
-const EMAIL_SETUP_DISPLAY_NAME = 'Murph';
-const SETUP_CHANNEL_ORDER = [
-    'telegram',
-    'email',
-];
-function isSetupChannelSupportedOnPlatform(channel, platform) {
-    void channel;
-    void platform;
-    return true;
-}
-function isSetupChannel(value) {
-    return setupChannelValues.includes(value);
-}
 export function normalizeSetupChannels(value) {
     return [...new Set(value ?? [])];
 }
-function isSetupManagedAutoReplyChannel(channel, platform) {
-    return isSetupChannel(channel) && isSetupChannelSupportedOnPlatform(channel, platform);
-}
 function isTelegramSetupConnector(connector) {
     return (connector.id === TELEGRAM_SETUP_CONNECTOR_ID ||
         (connector.source === 'telegram' &&
             connector.accountId === TELEGRAM_SETUP_ACCOUNT_ID));
 }
-function isEmailSetupConnector(connector) {
-    return connector.id === EMAIL_SETUP_CONNECTOR_ID;
-}
-function isSetupAddedEmailConnectorResult(value) {
-    return 'selectedInbox' in value;
-}
-function describeConfiguredEmailAction(input) {
-    if (input.added.provisionedMailbox) {
-        return 'Provisioned';
-    }
-    if (input.added.reusedMailbox || input.selectedInbox) {
-        return 'Reused';
-    }
-    return 'Provisioned';
-}
-const CHANNEL_SPECS = {
-    telegram: {
-        channel: 'telegram',
-        title: 'Telegram channel',
-        stepId: 'channel-telegram',
-        runtimeUnavailableMessage: 'Murph setup cannot configure Telegram because the inbox source management services are unavailable in this build.',
-        readiness: {
-            fallbackReason: 'Telegram readiness probe failed',
-            kind: 'doctor-probe',
-        },
-        plan(context) {
-            const token = resolveTelegramBotToken(context.env);
-            const readyForSetup = getAssistantChannelAdapter('telegram')?.isReadyForSetup(context.env) ??
-                Boolean(token);
-            const missingEnv = resolveSetupChannelMissingEnv('telegram', context.env);
-            return {
-                supported: true,
-                connectorId: TELEGRAM_SETUP_CONNECTOR_ID,
-                dryRunDetail: token
-                    ? 'Would configure the Telegram bot connector and enable assistant auto-reply for Telegram direct chats.'
-                    : `Telegram needs TELEGRAM_BOT_TOKEN in the current environment before setup can enable the channel. ${SETUP_RUNTIME_ENV_NOTICE}`,
-                dryRunStepDetail: token
-                    ? 'Would verify the Telegram bot token, add or reuse the telegram:bot inbox connector, and enable assistant auto-reply for Telegram direct chats.'
-                    : 'Would configure Telegram once TELEGRAM_BOT_TOKEN is available in the shell or local `.env`.',
-                missingEnv,
-                readyForSetup,
-            };
-        },
-        findExistingConnector(connectors) {
-            return connectors.find(isTelegramSetupConnector) ?? null;
-        },
-        async addConnector(context, sourceAdd) {
-            return sourceAdd({
-                account: TELEGRAM_SETUP_ACCOUNT_ID,
-                id: TELEGRAM_SETUP_CONNECTOR_ID,
-                requestId: context.requestId,
-                source: 'telegram',
-                vault: context.vault,
-            });
-        },
-        describeMissingEnv({ existingConnector }) {
-            return {
-                stepDetail: existingConnector
-                    ? `Reused the Telegram inbox connector "${existingConnector.id}", but did not enable assistant auto-reply because TELEGRAM_BOT_TOKEN was not available in the shell or local \`.env\`.`
-                    : 'Telegram was selected, but setup did not add the connector because TELEGRAM_BOT_TOKEN was not available in the shell or local `.env`.',
-                detail: existingConnector
-                    ? `Reused the Telegram connector "${existingConnector.id}", but skipped assistant auto-reply until a bot token is available in the current environment. ${SETUP_RUNTIME_ENV_NOTICE}`
-                    : `Telegram needs TELEGRAM_BOT_TOKEN in the current environment before setup can add the connector and enable assistant auto-reply. ${SETUP_RUNTIME_ENV_NOTICE}`,
-            };
-        },
-        describeReused({ connector, readiness }) {
-            return {
-                stepDetail: readiness.ready
-                    ? `Reusing the Telegram inbox connector "${connector.id}" and enabling assistant auto-reply for Telegram direct chats.`
-                    : `Reused the Telegram inbox connector "${connector.id}", but did not enable assistant auto-reply because the bot token could not authenticate${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-                detail: readiness.ready
-                    ? `Reused the Telegram connector "${connector.id}" and enabled assistant auto-reply for Telegram direct chats.`
-                    : `Reused the Telegram connector "${connector.id}", but skipped assistant auto-reply until the bot token authenticates successfully with Telegram${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-            };
-        },
-        describeAdded({ added, readiness }) {
-            return {
-                stepDetail: readiness.ready
-                    ? `Added the Telegram inbox connector "${added.connector.id}" and enabled assistant auto-reply for Telegram direct chats.`
-                    : `Added the Telegram inbox connector "${added.connector.id}", but did not enable assistant auto-reply because the bot token could not authenticate${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-                detail: readiness.ready
-                    ? `Configured the Telegram connector "${added.connector.id}" and enabled assistant auto-reply for Telegram direct chats.`
-                    : `Configured the Telegram connector "${added.connector.id}", but skipped assistant auto-reply until the bot token authenticates successfully with Telegram${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-            };
-        },
-        matchesConfiguredConnector: isTelegramSetupConnector,
-    },
-    email: {
-        channel: 'email',
-        title: 'Email channel',
-        stepId: 'channel-email',
-        runtimeUnavailableMessage: 'Murph setup cannot configure email because the inbox source management services are unavailable in this build.',
-        readiness: {
-            fallbackReason: 'Email readiness probe failed',
-            kind: 'doctor-probe',
-            treatProbeWarnAsReady: true,
-        },
-        plan(context) {
-            const apiKey = resolveAgentmailApiKey(context.env);
-            const missingEnv = resolveSetupChannelMissingEnv('email', context.env);
-            return {
-                supported: true,
-                connectorId: EMAIL_SETUP_CONNECTOR_ID,
-                dryRunDetail: apiKey
-                    ? 'Would reuse an existing AgentMail inbox when possible, or provision a new inbox connector and enable assistant auto-reply for direct email threads.'
-                    : `Email needs AGENTMAIL_API_KEY in the current environment before setup can enable the channel. ${SETUP_RUNTIME_ENV_NOTICE}`,
-                dryRunStepDetail: apiKey
-                    ? 'Would provision or reuse an AgentMail inbox, verify email polling, and enable assistant auto-reply for direct email threads.'
-                    : 'Would configure email once AGENTMAIL_API_KEY is available in the shell or local `.env`.',
-                missingEnv,
-                readyForSetup: Boolean(apiKey),
-            };
-        },
-        findExistingConnector(connectors) {
-            return connectors.find(isEmailSetupConnector) ?? null;
-        },
-        async addConnector(context, sourceAdd) {
-            const apiKey = resolveAgentmailApiKey(context.env);
-            const selectedInbox = context.resolveAgentmailInboxSelection && apiKey
-                ? await context.resolveAgentmailInboxSelection({
-                    allowPrompt: context.allowPrompt,
-                    env: context.env,
-                })
-                : null;
-            const added = await sourceAdd({
-                account: selectedInbox?.accountId,
-                address: selectedInbox?.emailAddress ?? undefined,
-                id: EMAIL_SETUP_CONNECTOR_ID,
-                provision: selectedInbox === null,
-                emailDisplayName: EMAIL_SETUP_DISPLAY_NAME,
-                requestId: context.requestId,
-                source: 'email',
-                vault: context.vault,
-            });
-            return { ...added, selectedInbox };
-        },
-        describeMissingEnv({ existingConnector }) {
-            return {
-                stepDetail: existingConnector
-                    ? `Reused the email inbox connector "${existingConnector.id}", but did not enable assistant auto-reply because AGENTMAIL_API_KEY was not available in the shell or local \`.env\`.`
-                    : 'Email was selected, but setup did not add the connector because AGENTMAIL_API_KEY was not available in the shell or local `.env`.',
-                detail: existingConnector
-                    ? `Reused the email connector "${existingConnector.id}", but skipped assistant auto-reply until an AgentMail API key is available in the current environment. ${SETUP_RUNTIME_ENV_NOTICE}`
-                    : `Email needs AGENTMAIL_API_KEY in the current environment before setup can reuse or provision the connector and enable assistant auto-reply. ${SETUP_RUNTIME_ENV_NOTICE}`,
-            };
-        },
-        describeReused({ connector, readiness }) {
-            return {
-                stepDetail: readiness.ready
-                    ? `Reusing the email inbox connector "${connector.id}" and enabling assistant auto-reply for direct email threads.`
-                    : `Reused the email inbox connector "${connector.id}", but did not enable assistant auto-reply because AgentMail readiness checks failed${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-                detail: readiness.ready
-                    ? `Reused the email connector "${connector.id}" and enabled assistant auto-reply for direct email threads.`
-                    : `Reused the email connector "${connector.id}", but skipped assistant auto-reply until AgentMail readiness checks succeed${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-            };
-        },
-        describeAdded({ added, readiness }) {
-            const selectedInbox = isSetupAddedEmailConnectorResult(added)
-                ? added.selectedInbox ?? null
-                : null;
-            const configuredAddress = added.provisionedMailbox?.emailAddress ??
-                added.reusedMailbox?.emailAddress ??
-                selectedInbox?.emailAddress ??
-                added.connector.options.emailAddress ??
-                null;
-            const actionVerb = describeConfiguredEmailAction({
-                added,
-                selectedInbox,
-            });
-            return {
-                stepDetail: readiness.ready
-                    ? `${actionVerb} the AgentMail inbox connector "${added.connector.id}"${configuredAddress ? ` at ${configuredAddress}` : ''} and enabled assistant auto-reply for direct email threads.`
-                    : `${actionVerb} the AgentMail inbox connector "${added.connector.id}"${configuredAddress ? ` at ${configuredAddress}` : ''}, but did not enable assistant auto-reply because AgentMail readiness checks failed${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-                detail: readiness.ready
-                    ? `Configured the email connector "${added.connector.id}"${configuredAddress ? ` at ${configuredAddress}` : ''} and enabled assistant auto-reply for direct email threads.`
-                    : `Configured the email connector "${added.connector.id}"${configuredAddress ? ` at ${configuredAddress}` : ''}, but skipped assistant auto-reply until AgentMail readiness checks succeed${readiness.reason ? ` (${readiness.reason})` : ''}.`,
-            };
-        },
-        matchesConfiguredConnector: isEmailSetupConnector,
-    },
-};
-const CHANNEL_CONFIGURERS = {
-    telegram: configureTelegramChannel,
-    email: configureEmailChannel,
-};
 export async function configureSetupChannels(input) {
     const configured = [];
-    const platform = input.platform ?? process.platform;
-    const context = {
-        allowPrompt: input.allowPrompt ?? false,
-        dryRun: input.dryRun,
-        env: input.env,
-        inboxServices: input.inboxServices,
-        platform,
-        requestId: input.requestId,
-        resolveAgentmailInboxSelection: input.resolveAgentmailInboxSelection,
-        steps: input.steps,
-        vault: input.vault,
-    };
     const selectedChannels = new Set(normalizeSetupChannels(input.channels));
-    for (const channel of SETUP_CHANNEL_ORDER) {
-        if (!selectedChannels.has(channel)) {
-            continue;
-        }
-        configured.push(await CHANNEL_CONFIGURERS[channel](context));
+    if (selectedChannels.has('telegram')) {
+        configured.push(await configureTelegramSetupChannel(input));
     }
     if (!input.dryRun) {
-        await reconcileDeselectedSetupChannels({
-            channels: input.channels,
+        await reconcileDeselectedTelegramChannel({
+            selected: selectedChannels.has('telegram'),
             inboxServices: input.inboxServices,
-            platform,
             requestId: input.requestId,
             vault: input.vault,
         });
-        await updateAssistantChannelState({
-            autoReplyChannels: configured
+        await reconcileManagedAssistantAutoReplyChannelsLocal({
+            desiredChannels: configured
                 .filter((channel) => channel.autoReply)
                 .map((channel) => channel.channel),
-            platform,
+            isManagedChannel: (channel) => channel === 'telegram',
             vault: input.vault,
         });
     }
     return configured;
 }
-async function configureTelegramChannel(context) {
-    return configureSetupChannel(CHANNEL_SPECS.telegram, context);
-}
-async function configureEmailChannel(context) {
-    return configureSetupChannel(CHANNEL_SPECS.email, context);
-}
-async function configureSetupChannel(spec, context) {
-    const plan = spec.plan(context);
-    if (isUnsupportedSetupChannelPlan(plan)) {
-        return recordSetupChannelResult(spec, context, {
-            autoReplyReady: false,
-            connectorEnabled: false,
-            connectorId: plan.connectorId,
-            connectorPresent: false,
-            detail: plan.detail,
-            missingEnv: plan.missingEnv,
-            outcome: 'unsupported',
-            stepDetail: plan.stepDetail,
-            stepStatus: 'skipped',
-        });
-    }
-    if (context.dryRun) {
-        return recordSetupChannelResult(spec, context, {
-            autoReplyReady: plan.readyForSetup,
-            connectorEnabled: plan.readyForSetup,
-            connectorId: plan.connectorId,
-            connectorPresent: false,
-            detail: plan.dryRunDetail,
-            missingEnv: plan.missingEnv,
-            outcome: 'dry-run',
-            stepDetail: plan.dryRunStepDetail,
-            stepStatus: 'planned',
-        });
+async function configureTelegramSetupChannel(input) {
+    const token = resolveTelegramBotToken(input.env);
+    const missingEnv = resolveSetupChannelMissingEnv('telegram', input.env);
+    if (input.dryRun) {
+        input.steps.push(createStep({
+            detail: token
+                ? 'Would verify the Telegram bot token, add or reuse the telegram:bot inbox connector, and enable assistant auto-reply for Telegram direct chats.'
+                : 'Would configure Telegram once TELEGRAM_BOT_TOKEN is available in the shell or local `.env`.',
+            id: 'channel-telegram',
+            kind: 'configure',
+            status: 'planned',
+            title: 'Telegram channel',
+        }));
+        return {
+            autoReply: Boolean(token),
+            channel: 'telegram',
+            configured: false,
+            connectorId: TELEGRAM_SETUP_CONNECTOR_ID,
+            detail: token
+                ? 'Would configure the Telegram bot connector and enable assistant auto-reply for Telegram direct chats.'
+                : `Telegram needs TELEGRAM_BOT_TOKEN in the current environment before setup can enable the channel. ${SETUP_RUNTIME_ENV_NOTICE}`,
+            enabled: true,
+            missingEnv,
+        };
     }
-    const doctor = context.inboxServices.doctor;
-    const sourceList = context.inboxServices.sourceList;
-    const sourceAdd = context.inboxServices.sourceAdd;
-    const sourceSetEnabled = context.inboxServices.sourceSetEnabled;
+    const doctor = input.inboxServices.doctor;
+    const sourceAdd = input.inboxServices.sourceAdd;
+    const sourceList = input.inboxServices.sourceList;
+    const sourceSetEnabled = input.inboxServices.sourceSetEnabled;
     if (!sourceList || !sourceAdd) {
-        throw new VaultCliError('runtime_unavailable', spec.runtimeUnavailableMessage);
+        throw new VaultCliError('runtime_unavailable', 'Murph setup cannot configure Telegram because the inbox source management services are unavailable in this build.');
     }
     const listed = await sourceList({
-        vault: context.vault,
-        requestId: context.requestId,
+        requestId: input.requestId,
+        vault: input.vault,
     });
-    const existingConnector = spec.findExistingConnector(listed.connectors);
-    if (!plan.readyForSetup) {
-        const messages = spec.describeMissingEnv({
-            existingConnector,
-        });
-        const connectorPresent = existingConnector !== null;
-        const connectorEnabled = existingConnector?.enabled ?? false;
-        return recordSetupChannelResult(spec, context, {
-            autoReplyReady: false,
-            connectorEnabled,
+    const existingConnector = listed.connectors.find(isTelegramSetupConnector) ?? null;
+    if (!token) {
+        input.steps.push(createStep({
+            detail: existingConnector
+                ? `Reused the Telegram inbox connector "${existingConnector.id}", but did not enable assistant auto-reply because TELEGRAM_BOT_TOKEN was not available in the shell or local \`.env\`.`
+                : 'Telegram was selected, but setup did not add the connector because TELEGRAM_BOT_TOKEN was not available in the shell or local `.env`.',
+            id: 'channel-telegram',
+            kind: 'configure',
+            status: existingConnector ? 'reused' : 'skipped',
+            title: 'Telegram channel',
+        }));
+        return {
+            autoReply: false,
+            channel: 'telegram',
+            configured: existingConnector !== null,
             connectorId: existingConnector?.id ?? null,
-            connectorPresent,
-            detail: messages.detail,
-            missingEnv: plan.missingEnv,
-            outcome: 'missing-env',
-            stepDetail: messages.stepDetail,
-            stepStatus: existingConnector ? 'reused' : 'skipped',
-        });
+            detail: existingConnector
+                ? `Reused the Telegram connector "${existingConnector.id}", but skipped assistant auto-reply until a bot token is available in the current environment. ${SETUP_RUNTIME_ENV_NOTICE}`
+                : `Telegram needs TELEGRAM_BOT_TOKEN in the current environment before setup can add the connector and enable assistant auto-reply. ${SETUP_RUNTIME_ENV_NOTICE}`,
+            enabled: true,
+            missingEnv,
+        };
     }
     if (existingConnector) {
-        const connectorEnabled = await ensureSetupConnectorEnabled({
-            connectorId: existingConnector.id,
-            enabled: existingConnector.enabled,
-            requestId: context.requestId,
-            sourceSetEnabled,
-            vault: context.vault,
-        });
-        const readiness = await resolveSetupChannelReadiness({
+        if (!existingConnector.enabled && sourceSetEnabled) {
+            await sourceSetEnabled({
+                connectorId: existingConnector.id,
+                enabled: true,
+                requestId: input.requestId,
+                vault: input.vault,
+            });
+        }
+        const readiness = await probeSetupReadiness({
             connectorId: existingConnector.id,
             doctor,
-            requestId: context.requestId,
-            readiness: spec.readiness,
-            vault: context.vault,
-        });
-        const autoReplyReady = readiness.ready;
-        const messages = spec.describeReused({
-            connector: existingConnector,
-            readiness,
+            fallbackReason: 'Telegram readiness probe failed',
+            requestId: input.requestId,
+            vault: input.vault,
         });
-        return recordSetupChannelResult(spec, context, {
-            autoReplyReady,
-            connectorEnabled,
+        input.steps.push(createStep({
+            detail: readiness.ready
+                ? `Reusing the Telegram inbox connector "${existingConnector.id}" and enabling assistant auto-reply for Telegram direct chats.`
+                : `Reused the Telegram inbox connector "${existingConnector.id}", but did not enable assistant auto-reply because the bot token could not authenticate${readiness.reason ? ` (${readiness.reason})` : ''}.`,
+            id: 'channel-telegram',
+            kind: 'configure',
+            status: 'reused',
+            title: 'Telegram channel',
+        }));
+        return {
+            autoReply: readiness.ready,
+            channel: 'telegram',
+            configured: readiness.ready,
             connectorId: existingConnector.id,
-            connectorPresent: true,
-            detail: messages.detail,
+            detail: readiness.ready
+                ? `Reused the Telegram connector "${existingConnector.id}" and enabled assistant auto-reply for Telegram direct chats.`
+                : `Reused the Telegram connector "${existingConnector.id}", but skipped assistant auto-reply until the bot token authenticates successfully with Telegram${readiness.reason ? ` (${readiness.reason})` : ''}.`,
+            enabled: true,
             missingEnv: [],
-            outcome: 'reused',
-            stepDetail: messages.stepDetail,
-            stepStatus: 'reused',
-        });
+        };
     }
-    const added = await spec.addConnector(context, sourceAdd);
-    const autoReplyReadiness = await resolveSetupChannelReadiness({
-        connectorId: added.connector.id,
-        doctor,
-        requestId: context.requestId,
-        readiness: spec.readiness,
-        vault: context.vault,
-    });
-    const autoReplyReady = autoReplyReadiness.ready;
-    const messages = spec.describeAdded({
-        added,
-        readiness: autoReplyReadiness,
+    const added = await sourceAdd({
+        account: TELEGRAM_SETUP_ACCOUNT_ID,
+        id: TELEGRAM_SETUP_CONNECTOR_ID,
+        requestId: input.requestId,
+        source: 'telegram',
+        vault: input.vault,
     });
-    return recordSetupChannelResult(spec, context, {
-        autoReplyReady,
-        connectorEnabled: added.connector.enabled,
+    const readiness = await probeSetupReadiness({
         connectorId: added.connector.id,
-        connectorPresent: true,
-        detail: messages.detail,
-        missingEnv: [],
-        outcome: 'added',
-        stepDetail: messages.stepDetail,
-        stepStatus: 'completed',
+        doctor,
+        fallbackReason: 'Telegram readiness probe failed',
+        requestId: input.requestId,
+        vault: input.vault,
     });
-}
-function isUnsupportedSetupChannelPlan(plan) {
-    return plan.supported === false;
-}
-function recordSetupChannelResult(spec, context, resolution) {
-    context.steps.push(createStep({
-        detail: resolution.stepDetail,
-        id: spec.stepId,
+    input.steps.push(createStep({
+        detail: readiness.ready
+            ? `Added the Telegram inbox connector "${added.connector.id}" and enabled assistant auto-reply for Telegram direct chats.`
+            : `Added the Telegram inbox connector "${added.connector.id}", but did not enable assistant auto-reply because the bot token could not authenticate${readiness.reason ? ` (${readiness.reason})` : ''}.`,
+        id: 'channel-telegram',
         kind: 'configure',
-        status: resolution.stepStatus,
-        title: spec.title,
+        status: 'completed',
+        title: 'Telegram channel',
     }));
     return {
-        autoReply: resolution.autoReplyReady,
-        channel: spec.channel,
-        configured: mapConfiguredSetupChannelResolution(resolution),
-        connectorId: resolution.connectorId,
-        detail: resolution.detail,
-        // Preserve the historical setup result contract at the boundary while the
-        // orchestration tracks connector presence/readiness separately.
+        autoReply: readiness.ready,
+        channel: 'telegram',
+        configured: readiness.ready,
+        connectorId: added.connector.id,
+        detail: readiness.ready
+            ? `Configured the Telegram connector "${added.connector.id}" and enabled assistant auto-reply for Telegram direct chats.`
+            : `Configured the Telegram connector "${added.connector.id}", but skipped assistant auto-reply until the bot token authenticates successfully with Telegram${readiness.reason ? ` (${readiness.reason})` : ''}.`,
         enabled: true,
-        missingEnv: resolution.missingEnv,
+        missingEnv: [],
     };
 }
-function mapConfiguredSetupChannelResolution(resolution) {
-    switch (resolution.outcome) {
-        case 'missing-env':
-            return resolution.connectorPresent;
-        case 'reused':
-        case 'added':
-            return resolution.autoReplyReady;
-        case 'unsupported':
-        case 'dry-run':
-            return false;
-    }
-}
-async function resolveSetupChannelReadiness(input) {
-    if (input.readiness.kind === 'always-ready') {
-        return {
-            ready: true,
-            reason: null,
-        };
-    }
-    return probeSetupReadiness({
-        connectorId: input.connectorId,
-        doctor: input.doctor,
-        fallbackReason: input.readiness.fallbackReason,
-        requestId: input.requestId,
-        treatProbeWarnAsReady: input.readiness.treatProbeWarnAsReady,
-        vault: input.vault,
-    });
-}
 async function probeSetupReadiness(input) {
     if (!input.doctor) {
         return {
@@ -443,42 +182,32 @@ async function probeSetupReadiness(input) {
     });
     const probeCheck = result.checks.find((check) => check.name === 'probe') ?? null;
     const driverImportCheck = result.checks.find((check) => check.name === 'driver-import') ?? null;
-    const ready = Boolean((probeCheck?.status === 'pass' ||
-        (input.treatProbeWarnAsReady === true && probeCheck?.status === 'warn')) &&
+    const ready = Boolean(probeCheck?.status === 'pass' &&
         (driverImportCheck === null || driverImportCheck.status === 'pass'));
     return {
         ready,
         reason: ready
             ? null
-            : probeCheck?.message ?? driverImportCheck?.message ?? input.fallbackReason,
+            : probeCheck?.message ??
+                driverImportCheck?.message ??
+                input.fallbackReason,
     };
 }
-async function updateAssistantChannelState(input) {
-    await reconcileManagedAssistantAutoReplyChannelsLocal({
-        desiredChannels: normalizeSetupChannels(input.autoReplyChannels).filter((channel) => isSetupChannelSupportedOnPlatform(channel, input.platform)),
-        isManagedChannel: (channel) => isSetupManagedAutoReplyChannel(channel, input.platform),
-        vault: input.vault,
-    });
-}
-async function reconcileDeselectedSetupChannels(input) {
+async function reconcileDeselectedTelegramChannel(input) {
+    if (input.selected) {
+        return;
+    }
     const sourceList = input.inboxServices.sourceList;
     const sourceSetEnabled = input.inboxServices.sourceSetEnabled;
     if (!sourceList || !sourceSetEnabled) {
         return;
     }
-    const selectedChannels = new Set(normalizeSetupChannels(input.channels));
     const listed = await sourceList({
-        vault: input.vault,
         requestId: input.requestId,
+        vault: input.vault,
     });
     for (const connector of listed.connectors) {
-        if (!connector.enabled) {
-            continue;
-        }
-        const setupChannel = resolveSetupChannelForConnector(connector);
-        if (!setupChannel ||
-            !isSetupChannelSupportedOnPlatform(setupChannel, input.platform) ||
-            selectedChannels.has(setupChannel)) {
+        if (!connector.enabled || !isTelegramSetupConnector(connector)) {
             continue;
         }
         await sourceSetEnabled({
@@ -489,27 +218,4 @@ async function reconcileDeselectedSetupChannels(input) {
         });
     }
 }
-async function ensureSetupConnectorEnabled(input) {
-    if (input.enabled) {
-        return true;
-    }
-    if (!input.sourceSetEnabled) {
-        return false;
-    }
-    await input.sourceSetEnabled({
-        connectorId: input.connectorId,
-        enabled: true,
-        requestId: input.requestId,
-        vault: input.vault,
-    });
-    return true;
-}
-function resolveSetupChannelForConnector(connector) {
-    for (const channel of SETUP_CHANNEL_ORDER) {
-        if (CHANNEL_SPECS[channel].matchesConfiguredConnector(connector)) {
-            return channel;
-        }
-    }
-    return null;
-}
 //# sourceMappingURL=channels.js.map