fix: make Telegram setup provision and verify its adapter

Author: Omni Loop Labs

apps/desktop/src/app/command-center/index.tsx

@@ -358,7 +358,9 @@ export function CommandCenterView({
         const started = kind === 'restart' ? await restartGateway() : await updateClio()
         let nextStatus: ActionStatusResponse | null = null
 
-        for (let attempt = 0; attempt < 18; attempt += 1) {
+        const maxAttempts = kind === 'restart' ? 65 : 300
+
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
           await new Promise(resolve => window.setTimeout(resolve, 1200))
           const polled = await getActionStatus(started.name, 180)
           nextStatus = polled
@@ -370,6 +372,11 @@ export function CommandCenterView({
           }
         }
 
+        if (nextStatus && !nextStatus.running && nextStatus.exit_code !== 0) {
+          const detail = nextStatus.lines.filter(Boolean).slice(-6).join('\n')
+          throw new Error(detail || `${nextStatus.name} failed (exit ${String(nextStatus.exit_code)}).`)
+        }
+
         if (!nextStatus) {
           const pendingStatus = {
             exit_code: null,

apps/desktop/src/app/messaging/telegram-qr-setup.test.tsx

@@ -5,17 +5,21 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 const mocks = vi.hoisted(() => ({
   applyTelegramOnboarding: vi.fn(),
   cancelTelegramOnboarding: vi.fn(),
+  getActionStatus: vi.fn(),
   getTelegramOnboardingStatus: vi.fn(),
   restartGateway: vi.fn(),
-  startTelegramOnboarding: vi.fn()
+  startTelegramOnboarding: vi.fn(),
+  testMessagingPlatform: vi.fn()
 }))
 
 vi.mock('@/clio', () => ({
   applyTelegramOnboarding: (id: string, body: unknown) => mocks.applyTelegramOnboarding(id, body),
   cancelTelegramOnboarding: (id: string) => mocks.cancelTelegramOnboarding(id),
+  getActionStatus: (name: string, lines: number) => mocks.getActionStatus(name, lines),
   getTelegramOnboardingStatus: (id: string) => mocks.getTelegramOnboardingStatus(id),
   restartGateway: () => mocks.restartGateway(),
-  startTelegramOnboarding: (body: unknown) => mocks.startTelegramOnboarding(body)
+  startTelegramOnboarding: (body: unknown) => mocks.startTelegramOnboarding(body),
+  testMessagingPlatform: (id: string) => mocks.testMessagingPlatform(id)
 }))
 vi.mock('qrcode', () => ({ default: { toDataURL: vi.fn().mockResolvedValue('data:image/png;base64,QR') } }))
 
@@ -37,7 +41,15 @@ describe('TelegramQrSetup', () => {
       status: 'ready'
     })
     mocks.applyTelegramOnboarding.mockResolvedValue({ needs_restart: true, ok: true, platform: 'telegram' })
-    mocks.restartGateway.mockResolvedValue({ ok: true })
+    mocks.restartGateway.mockResolvedValue({ name: 'gateway-restart', ok: true, pid: 42 })
+    mocks.getActionStatus.mockResolvedValue({
+      exit_code: 0,
+      lines: ['Gateway started'],
+      name: 'gateway-restart',
+      pid: 42,
+      running: false
+    })
+    mocks.testMessagingPlatform.mockResolvedValue({ message: 'Telegram is connected.', ok: true, state: 'connected' })
     mocks.cancelTelegramOnboarding.mockResolvedValue({ ok: true })
   })
 
@@ -52,7 +64,7 @@ describe('TelegramQrSetup', () => {
     expect(screen.getByText('Set up with QR')).toBeTruthy()
   })
 
-  it('runs the full flow: start → QR → ready → apply → restart', async () => {
+  it('runs the full flow and reports success only after Telegram connects', async () => {
     const onApplied = vi.fn()
     render(<TelegramQrSetup onApplied={onApplied} />)
 
@@ -73,7 +85,39 @@ describe('TelegramQrSetup', () => {
       expect(mocks.applyTelegramOnboarding).toHaveBeenCalledWith('p1', { allowed_user_ids: ['4242'] }),
     )
     await waitFor(() => expect(mocks.restartGateway).toHaveBeenCalled())
+    await waitFor(() => expect(mocks.getActionStatus).toHaveBeenCalledWith('gateway-restart', 200), { timeout: 4000 })
+    await waitFor(() => expect(mocks.testMessagingPlatform).toHaveBeenCalledWith('telegram'))
     await waitFor(() => expect(onApplied).toHaveBeenCalled())
+  }, 6000)
+
+  it('surfaces restart action failure and offers retry instead of reporting success', async () => {
+    mocks.getActionStatus.mockResolvedValue({
+      exit_code: 1,
+      lines: ['Telegram support is unavailable'],
+      name: 'gateway-restart',
+      pid: 42,
+      running: false
+    })
+    const onApplied = vi.fn()
+    render(<TelegramQrSetup onApplied={onApplied} />)
+    fireEvent.click(screen.getByText('Set up with QR'))
+    await waitFor(() => expect(screen.getByText(/Bot created/)).toBeTruthy(), { timeout: 3000 })
+
+    fireEvent.click(screen.getByText('Save & restart gateway'))
+
+    await waitFor(() => expect(screen.getByText('Retry gateway connection')).toBeTruthy(), { timeout: 4000 })
+    expect(screen.getByText(/Telegram support is unavailable/)).toBeTruthy()
+    expect(onApplied).not.toHaveBeenCalled()
+  }, 6000)
+
+  it('shows dependency preparation failure before creating a pairing', async () => {
+    mocks.startTelegramOnboarding.mockRejectedValue(new Error('Telegram support is unavailable'))
+    render(<TelegramQrSetup />)
+
+    fireEvent.click(screen.getByText('Set up with QR'))
+
+    await waitFor(() => expect(screen.getByText('Telegram support is unavailable')).toBeTruthy())
+    expect(mocks.getTelegramOnboardingStatus).not.toHaveBeenCalled()
   })
 
   it('validates that allowed user IDs are numeric', async () => {

apps/desktop/src/app/messaging/telegram-qr-setup.tsx

@@ -4,23 +4,28 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import {
   applyTelegramOnboarding,
   cancelTelegramOnboarding,
+  getActionStatus,
   getTelegramOnboardingStatus,
   restartGateway,
   startTelegramOnboarding,
-  type TelegramOnboardingStart
+  type TelegramOnboardingStart,
+  testMessagingPlatform
 } from '@/clio'
 import { Button } from '@/components/ui/button'
 import { Codicon } from '@/components/ui/codicon'
 import { Input } from '@/components/ui/input'
-import { notify, notifyError } from '@/store/notifications'
+import { notify } from '@/store/notifications'
 
 const TELEGRAM_USER_ID_RE = /^\d{1,15}$/
 const POLL_MS = 2000
+const RESTART_POLL_MS = 1200
+const RESTART_POLL_ATTEMPTS = 65
+const CONNECTION_POLL_ATTEMPTS = 45
 
-type Phase = 'applying' | 'idle' | 'ready' | 'starting' | 'waiting'
+type Phase = 'applying' | 'connecting' | 'idle' | 'ready' | 'restart_failed' | 'starting' | 'waiting'
 
 interface TelegramQrSetupProps {
-  /** Called after the bot token is saved + the gateway restart is requested. */
+  /** Called only after the gateway reports Telegram connected. */
   onApplied?: () => void
 }
 
@@ -143,6 +148,61 @@ export function TelegramQrSetup({ onApplied }: TelegramQrSetupProps) {
     setNewAllowedId('')
   }, [newAllowedId])
 
+  const restartAndVerify = useCallback(async () => {
+    setPhase('connecting')
+    setError('')
+
+    try {
+      const started = await restartGateway()
+      let completed = false
+
+      for (let attempt = 0; attempt < RESTART_POLL_ATTEMPTS; attempt += 1) {
+        await new Promise(resolve => window.setTimeout(resolve, RESTART_POLL_MS))
+        const status = await getActionStatus(started.name, 200)
+
+        if (status.running) {continue}
+        completed = true
+
+        if (status.exit_code !== 0) {
+          const detail = status.lines.filter(Boolean).slice(-6).join('\n')
+          throw new Error(detail || `Gateway restart failed (exit ${String(status.exit_code)}).`)
+        }
+
+        break
+      }
+
+      if (!completed) {
+        throw new Error('Gateway restart is taking too long. Check the gateway logs, then retry connection.')
+      }
+
+      let lastMessage = 'Telegram has not reported a connection yet.'
+
+      for (let attempt = 0; attempt < CONNECTION_POLL_ATTEMPTS; attempt += 1) {
+        const result = await testMessagingPlatform('telegram')
+        lastMessage = result.message || lastMessage
+
+        if (result.ok) {
+          reset()
+          notify({ kind: 'success', message: 'Telegram bot connected', title: 'Telegram' })
+          onApplied?.()
+
+          return
+        }
+
+        if (result.state === 'fatal') {
+          throw new Error(lastMessage)
+        }
+
+        await new Promise(resolve => window.setTimeout(resolve, POLL_MS))
+      }
+
+      throw new Error(`${lastMessage} Retry the gateway connection.`)
+    } catch (err) {
+      setPhase('restart_failed')
+      setError(err instanceof Error ? err.message : String(err))
+    }
+  }, [onApplied, reset])
+
   const apply = useCallback(async () => {
     if (!setup) {return}
 
@@ -157,22 +217,12 @@ export function TelegramQrSetup({ onApplied }: TelegramQrSetupProps) {
 
     try {
       await applyTelegramOnboarding(setup.pairing_id, { allowed_user_ids: allowedIds })
-      reset()
-      notify({ kind: 'success', message: 'Telegram bot saved', title: 'Telegram' })
-
-      try {
-        await restartGateway()
-        notify({ kind: 'success', message: 'Gateway restarting…', title: 'Telegram' })
-      } catch (restartErr) {
-        notifyError(restartErr, 'Telegram saved, but the gateway restart failed — restart it manually.')
-      }
-
-      onApplied?.()
+      await restartAndVerify()
     } catch (err) {
       setPhase('ready')
       setError(err instanceof Error ? err.message : String(err))
     }
-  }, [setup, allowedIds, reset, onApplied])
+  }, [setup, allowedIds, restartAndVerify])
 
   return (
     <div
@@ -195,7 +245,26 @@ export function TelegramQrSetup({ onApplied }: TelegramQrSetupProps) {
         </Button>
       )}
 
-      {phase === 'starting' && <p className="mt-3 text-[0.8125rem] text-(--ui-text-secondary)">Starting…</p>}
+      {phase === 'starting' && (
+        <p className="mt-3 text-[0.8125rem] text-(--ui-text-secondary)">Preparing Telegram support…</p>
+      )}
+
+      {phase === 'connecting' && (
+        <p className="mt-3 text-[0.8125rem] text-(--ui-text-secondary)">
+          Restarting the gateway and verifying Telegram…
+        </p>
+      )}
+
+      {phase === 'restart_failed' && (
+        <div className="mt-3 flex items-center gap-2">
+          <Button onClick={() => void restartAndVerify()} size="sm">
+            Retry gateway connection
+          </Button>
+          <Button onClick={reset} size="sm" variant="ghost">
+            Close
+          </Button>
+        </div>
+      )}
 
       {(phase === 'waiting' || phase === 'starting') && qrDataUrl && (
         <div className="mt-3 flex flex-col items-center gap-2">

apps/desktop/src/clio.ts

@@ -41,6 +41,7 @@ import type {
 } from '@/types/clio'
 
 const DEFAULT_GATEWAY_REQUEST_TIMEOUT_MS = 30_000
+const PLATFORM_PROVISION_TIMEOUT_MS = 330_000
 
 export type {
   ActionResponse,
@@ -455,7 +456,8 @@ export function updateMessagingPlatform(
   return window.clioDesktop.api<{ ok: boolean; platform: string }>({
     path: `/api/messaging/platforms/${encodeURIComponent(platformId)}`,
     method: 'PUT',
-    body
+    body,
+    timeoutMs: PLATFORM_PROVISION_TIMEOUT_MS
   })
 }
 
@@ -756,7 +758,8 @@ export function startTelegramOnboarding(body: { bot_name?: string }): Promise<Te
   return window.clioDesktop.api<TelegramOnboardingStart>({
     body,
     method: 'POST',
-    path: '/api/messaging/telegram/onboarding/start'
+    path: '/api/messaging/telegram/onboarding/start',
+    timeoutMs: PLATFORM_PROVISION_TIMEOUT_MS
   })
 }
 
@@ -773,7 +776,8 @@ export function applyTelegramOnboarding(
   return window.clioDesktop.api<TelegramOnboardingApplyResult>({
     body,
     method: 'POST',
-    path: `/api/messaging/telegram/onboarding/${encodeURIComponent(pairingId)}/apply`
+    path: `/api/messaging/telegram/onboarding/${encodeURIComponent(pairingId)}/apply`,
+    timeoutMs: PLATFORM_PROVISION_TIMEOUT_MS
   })
 }
 

clio_cli/gateway.py

@@ -4383,6 +4383,18 @@ def _setup_standard_platform(platform: dict):
     label = platform["label"]
     token_var = platform["token_var"]
 
+    if platform.get("key") == "telegram":
+        from clio_cli.platform_dependencies import (
+            PlatformDependencyError,
+            ensure_platform_ready,
+        )
+
+        try:
+            ensure_platform_ready("telegram", prompt=True)
+        except PlatformDependencyError as exc:
+            print_error(f"  {exc}")
+            return
+
     print()
     print(color(f"  ─── {emoji} {label} Setup ───", Colors.CYAN))