plazbot-cli 0.3.7 → 0.4.0

package/src/studio/api/studioApi.ts

@@ -1,27 +0,0 @@
-import type { StudioStreamOptions } from './types.js';
-
-/**
- * Construye la URL base según zona / modo dev.
- *  LA  -> https://api.plazbot.com
- *  EU  -> https://apieu.plazbot.com
- *  dev -> http://localhost:5090
- */
-export function getBaseUrl(zone: 'LA' | 'EU', dev?: boolean): string {
-  if (dev) return 'http://localhost:5090';
-  return zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com';
-}
-
-export function buildStudioUrl(zone: 'LA' | 'EU', dev?: boolean): string {
-  return `${getBaseUrl(zone, dev)}/api/agent/studio`;
-}
-
-export function buildStudioHeaders(opts: StudioStreamOptions): Record<string, string> {
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-    Accept: 'text/event-stream',
-    Authorization: `Bearer ${opts.apiKey}`,
-    'x-workspace-id': opts.workspaceId,
-  };
-  if (opts.userId) headers['x-user-id'] = opts.userId;
-  return headers;
-}

package/src/studio/api/types.ts

@@ -1,96 +0,0 @@
-/**
- * Tipos de los chunks que emite el endpoint POST /api/agent/studio (SSE).
- * Espejo del modelo del backend AgentStudioModels.cs.
- */
-
-export type StudioChunkType = 'text' | 'tool_call' | 'tool_result' | 'usage' | 'done' | 'error';
-
-export interface StudioChunkText {
-  type: 'text';
-  content: string;
-}
-
-export interface StudioChunkToolCall {
-  type: 'tool_call';
-  tool_name: string;
-  tool_args?: unknown;
-}
-
-/** Resultado genérico devuelto por una tool (espejo de ToolExecutionResult.cs). */
-export interface ToolExecutionResult {
-  success: boolean;
-  tool?: string;
-  type?: string; // "agent_config" | "agent_list" | "diagnostic" | "agent_loaded" | ...
-  data?: unknown;
-  message?: string;
-  error?: string;
-}
-
-export interface StudioChunkToolResult {
-  type: 'tool_result';
-  tool_name: string;
-  tool_result?: ToolExecutionResult;
-}
-
-export interface StudioChunkUsage {
-  type: 'usage';
-  input_tokens: number;
-  output_tokens: number;
-}
-
-export interface StudioChunkDone {
-  type: 'done';
-}
-
-export interface StudioChunkError {
-  type: 'error';
-  error: string;
-}
-
-export type StudioChunk =
-  | StudioChunkText
-  | StudioChunkToolCall
-  | StudioChunkToolResult
-  | StudioChunkUsage
-  | StudioChunkDone
-  | StudioChunkError;
-
-/**
- * Mensaje conversacional enviado al backend en el array `messages`.
- */
-export interface StudioMessageIn {
-  role: 'user' | 'assistant';
-  content: string;
-}
-
-/**
- * Payload del request POST /api/agent/studio.
- * NB: el backend valida `message` (singular, string) y devuelve 400 si está vacío.
- * `messages` lleva el historial; `message` lleva el último turno del usuario.
- */
-export interface StudioRequest {
-  message: string;
-  messages: StudioMessageIn[];
-  agentId?: string | null;
-  agentConfig?: unknown;
-  workspaceId?: string;
-  userId?: string;
-}
-
-/**
- * Opciones para el cliente SSE (autenticación + ruteo).
- */
-export interface StudioStreamOptions {
-  apiKey: string;       // JWT
-  workspaceId: string;
-  userId?: string;
-  zone: 'LA' | 'EU';
-  dev?: boolean;
-}
-
-export class StudioHttpError extends Error {
-  constructor(public status: number, public statusText: string, public body?: string) {
-    super(`HTTP ${status} ${statusText}`);
-    this.name = 'StudioHttpError';
-  }
-}

package/src/studio/components/App.tsx

@@ -1,274 +0,0 @@
-import React, { useCallback, useEffect, useRef } from 'react';
-import { Box, useApp, useInput } from 'ink';
-import { Header } from './Header.js';
-import { Footer } from './Footer.js';
-import { ChatLog } from './ChatLog.js';
-import { Input } from './Input.js';
-import { Suggestions } from './Suggestions.js';
-import { useStudioStore, selectBackendMessages } from '../state/store.js';
-import { parseSlash } from '../slash/parser.js';
-import '../slash/handlers.js'; // side effect: registra slashes
-import { slashRegistry } from '../slash/registry.js';
-import { streamStudio } from '../api/sseClient.js';
-import { StudioHttpError } from '../api/types.js';
-import type { StudioChunk, StudioStreamOptions } from '../api/types.js';
-import { startConnectPolling, type PollingHandle } from '../connect/polling.js';
-import { workspaceOptsFromStream } from '../connect/api.js';
-import { channelFromToolResultType, type ChannelLinkData } from '../connect/types.js';
-
-export interface AppProps {
-  version: string;
-  stream: StudioStreamOptions;
-  initialAgentId?: string | null;
-  dev: boolean;
-  supportMode?: boolean;
-}
-
-export function App({ version, stream, initialAgentId, dev, supportMode }: AppProps): React.ReactElement {
-  const { exit } = useApp();
-  const messages = useStudioStore((s) => s.messages);
-  const usage = useStudioStore((s) => s.usage);
-  const streaming = useStudioStore((s) => s.streaming);
-  const agentId = useStudioStore((s) => s.agentId);
-
-  // Active channel-connect polling handle (cancelled on Esc / unmount / new stream).
-  const connectPollingRef = useRef<PollingHandle | null>(null);
-  const streamingRef = useRef(streaming);
-  useEffect(() => { streamingRef.current = streaming; }, [streaming]);
-  // Ref so the polling onConnected callback can trigger sendToBackend from the
-  // most recent closure without resubscribing every render.
-  const sendBackendRef = useRef<(text: string) => Promise<void>>(async () => {});
-
-  const stopConnectPolling = useCallback(() => {
-    if (connectPollingRef.current) {
-      connectPollingRef.current.cancel();
-      connectPollingRef.current = null;
-    }
-  }, []);
-
-  // Cargar agente inicial si se pasó por flag.
-  useEffect(() => {
-    if (initialAgentId) {
-      useStudioStore.getState().setAgentId(initialAgentId);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  // Cleanup on unmount.
-  useEffect(() => {
-    return () => { stopConnectPolling(); };
-  }, [stopConnectPolling]);
-
-  // Atajos de teclado globales.
-  useInput((input, key) => {
-    if (key.escape) {
-      const cc = useStudioStore.getState().connectCard;
-      if (cc && (cc.status === 'waiting' || cc.status === 'activating')) {
-        stopConnectPolling();
-        useStudioStore.getState().setConnectStatus('cancelled');
-        return;
-      }
-      useStudioStore.getState().abortStream();
-      return;
-    }
-    if (key.ctrl && input === 'c') {
-      stopConnectPolling();
-      useStudioStore.getState().abortStream();
-      exit();
-      return;
-    }
-  });
-
-  const sendToBackend = useCallback(async (userText: string) => {
-    const store = useStudioStore.getState();
-    // Snapshot del historial ANTES de agregar el nuevo user message, igual que
-    // el front (AgentStudioModal.tsx:504). Si se calcula después, el último
-    // user input queda duplicado (en `message` y en `messages`).
-    const historyForApi = selectBackendMessages();
-    store.pushUserMessage(userText);
-
-    const assistantId = store.startAssistantMessage();
-    const controller = new AbortController();
-    store.setAbortController(controller);
-    store.setStreaming(true);
-
-    const onChunk = (chunk: StudioChunk) => {
-      const s = useStudioStore.getState();
-      switch (chunk.type) {
-        case 'text':
-          s.appendAssistantText(assistantId, chunk.content ?? '');
-          break;
-        case 'tool_call':
-          s.startStep(chunk.tool_name, assistantId);
-          break;
-        case 'tool_result': {
-          const tr = chunk.tool_result;
-          const success = tr?.success !== false && !tr?.error;
-          s.resolveLastStep(chunk.tool_name, success ? 'success' : 'error', tr?.data, tr?.error);
-          // Stash the agent config in state (used as `agentConfig` context on
-          // the next request) and remember its id. We no longer render it.
-          const data = tr?.data as Record<string, unknown> | undefined;
-          if (data) {
-            const cfg = data.config ?? data.agentConfig ?? data.agent ?? null;
-            if (cfg && typeof cfg === 'object') {
-              s.setAgentConfig(cfg);
-              const idCandidate = (cfg as Record<string, unknown>).id;
-              if (typeof idCandidate === 'string') s.setAgentId(idCandidate);
-            }
-          }
-          // Channel connect tool (whatsapp / instagram / messenger): spin up the
-          // card + polling. The chunk discriminator (`whatsapp_link`,
-          // `instagram_link`, `messenger_link`) tells us which channel.
-          const channel = channelFromToolResultType(tr?.type);
-          if (channel && data) {
-            const linkData = data as ChannelLinkData;
-            // No link to show (e.g. alreadyConnected without a new url) → skip card.
-            if (linkData.shortUrl) {
-              // Cancel any previous active polling before starting a new one.
-              stopConnectPolling();
-              s.startConnectCard(channel, linkData, assistantId);
-              connectPollingRef.current = startConnectPolling(
-                workspaceOptsFromStream(stream),
-                channel,
-                linkData,
-                {
-                  onAttempt(attempt) {
-                    useStudioStore.getState().updateConnectCard({ attempt });
-                  },
-                  onActivating() {
-                    useStudioStore.getState().setConnectStatus('activating');
-                  },
-                  onConnected(label) {
-                    useStudioStore.getState().setConnectStatus('connected', { connectedLabel: label });
-                    connectPollingRef.current = null;
-                    if (!streamingRef.current) {
-                      const channelName =
-                        channel === 'whatsapp' ? 'WhatsApp'
-                        : channel === 'instagram' ? 'Instagram'
-                        : 'Messenger';
-                      const followUp =
-                        `My ${channelName} is now connected. ${label ? `Label: ${label}.` : ''} ` +
-                        `Continue with the agent setup.`;
-                      void sendBackendRef.current(followUp);
-                    }
-                  },
-                  onTimeout() {
-                    useStudioStore.getState().setConnectStatus('timeout');
-                    connectPollingRef.current = null;
-                  },
-                  onError(message) {
-                    useStudioStore.getState().setConnectStatus('error', { errorMessage: message });
-                    connectPollingRef.current = null;
-                  },
-                },
-              );
-            }
-          }
-          break;
-        }
-        case 'usage':
-          s.addUsage(chunk.input_tokens ?? 0, chunk.output_tokens ?? 0);
-          break;
-        case 'error':
-          s.failAllRunningSteps(chunk.error);
-          s.pushSyntheticAssistant(`✖ ${chunk.error}`, { error: true });
-          break;
-        case 'done':
-          break;
-      }
-    };
-
-    try {
-      await streamStudio(
-        stream,
-        {
-          message: userText,
-          messages: historyForApi,
-          agentId: useStudioStore.getState().agentId,
-          agentConfig: useStudioStore.getState().agentConfig,
-        },
-        onChunk,
-        controller.signal,
-      );
-    } catch (err) {
-      const msg = formatError(err, dev);
-      useStudioStore.getState().failAllRunningSteps('Network error');
-      useStudioStore.getState().pushSyntheticAssistant(msg, { error: true });
-    } finally {
-      useStudioStore.getState().finishAssistantMessage(assistantId);
-      useStudioStore.getState().setStreaming(false);
-      useStudioStore.getState().setAbortController(null);
-      // /compact flow: replace history with the assistant summary just produced.
-      if (useStudioStore.getState().pendingCompact) {
-        useStudioStore.getState().compactInto(assistantId);
-      }
-    }
-  }, [stream, dev, stopConnectPolling]);
-
-  useEffect(() => { sendBackendRef.current = sendToBackend; }, [sendToBackend]);
-
-  const handleSubmit = useCallback(async (raw: string) => {
-    const parsed = parseSlash(raw);
-    if (parsed) {
-      const spec = slashRegistry.get(parsed.name);
-      if (!spec) {
-        useStudioStore.getState().pushSyntheticAssistant(
-          `Unknown command: \`/${parsed.name}\`. Run \`/help\` to see the list.`,
-          { error: true },
-        );
-        return;
-      }
-      const res = await spec.handler(parsed, { exit });
-      if (res.kind === 'message') {
-        await sendToBackend(res.content);
-      }
-      return;
-    }
-    await sendToBackend(raw);
-  }, [sendToBackend, exit]);
-
-  const empty = messages.length === 0;
-
-  return (
-    <Box flexDirection="column">
-      <Header
-        version={version}
-        workspace={stream.workspaceId}
-        zone={stream.zone}
-        agentId={agentId}
-        dev={dev}
-        supportMode={!!supportMode}
-      />
-
-      <Box flexDirection="column" paddingX={1}>
-        {empty ? <Suggestions /> : <ChatLog />}
-      </Box>
-
-      <Input disabled={streaming} onSubmit={handleSubmit} />
-      <Footer
-        inputTokens={usage.inputTokens}
-        outputTokens={usage.outputTokens}
-        streaming={streaming}
-      />
-    </Box>
-  );
-}
-
-function formatError(err: unknown, dev: boolean): string {
-  if (err instanceof StudioHttpError) {
-    if (err.status === 401) return '✖ Token expired or invalid. Run `plazbot init` with a valid JWT.';
-    if (err.status === 403) return '✖ No permission for this workspace.';
-    if (err.status === 429) return '✖ Rate limit reached. Wait a few seconds and try again.';
-    if (err.status >= 500) {
-      return dev
-        ? `✖ Backend error ${err.status}.\n\`\`\`\n${err.body ?? err.statusText}\n\`\`\``
-        : `✖ The backend returned error ${err.status}. Retry in a few seconds.`;
-    }
-    return `✖ HTTP ${err.status} ${err.statusText}`;
-  }
-  if (err instanceof Error) {
-    if (err.name === 'AbortError') return '✖ Stream cancelled.';
-    return `✖ ${err.message}`;
-  }
-  return '✖ Unknown error';
-}

package/src/studio/components/ChatLog.tsx

@@ -1,121 +0,0 @@
-import React from 'react';
-import { Box, Static } from 'ink';
-import { useStudioStore } from '../state/store.js';
-import type { ChatMessage, ToolStep } from '../state/store.js';
-import type { ConnectState } from '../connect/types.js';
-import { Message } from './Message.js';
-import { ToolCall } from './ToolCall.js';
-import { ConnectCard } from './ConnectCard.js';
-
-type HistoricItem =
-  | { kind: 'message'; key: string; message: ChatMessage }
-  | { kind: 'step'; key: string; step: ToolStep }
-  | { kind: 'connectCard'; key: string; state: ConnectState };
-
-/**
- * Renderiza el log de la conversacion.
- *
- * Items estables (mensajes finalizados + tool steps resueltos que no estan
- * anclados a una tarjeta de conexion activa) van dentro de <Static> para que
- * Ink los escriba al scrollback una sola vez y no los re-renderice en resize.
- *
- * El bloque dinamico al final contiene el mensaje en streaming, los steps que
- * siguen en `running`, y la tarjeta de conexion (whatsapp/instagram/messenger)
- * mientras esta activa.
- */
-export function ChatLog(): React.ReactElement {
-  const messages = useStudioStore((s) => s.messages);
-  const steps = useStudioStore((s) => s.steps);
-  const connectCard = useStudioStore((s) => s.connectCard);
-
-  const stepsByMsg = new Map<string, ToolStep[]>();
-  for (const step of steps) {
-    const arr = stepsByMsg.get(step.afterMessageId) ?? [];
-    arr.push(step);
-    stepsByMsg.set(step.afterMessageId, arr);
-  }
-
-  // La tarjeta solo permanece en el dynamic frame mientras esta "viva"
-  // (polling activo o activando). En estados terminales
-  // (connected/cancelled/timeout/error) migra a <Static> junto a su mensaje
-  // ancla, de modo que los mensajes nuevos fluyen debajo.
-  const cardActive =
-    !!connectCard && (connectCard.status === 'waiting' || connectCard.status === 'activating');
-  const cardInScrollback = !!connectCard && !cardActive;
-
-  // Mensajes que deben quedar en el dynamic frame:
-  // - el ultimo si sigue streameando
-  // - cualquiera con tool steps en running
-  // - el ancla de una tarjeta de conexion ACTIVA
-  const dynamicMsgIds = new Set<string>();
-  const last = messages[messages.length - 1];
-  if (last?.streaming) dynamicMsgIds.add(last.id);
-  for (const step of steps) {
-    if (step.status === 'running') dynamicMsgIds.add(step.afterMessageId);
-  }
-  if (cardActive && connectCard) dynamicMsgIds.add(connectCard.anchorMessageId);
-
-  const staticItems: HistoricItem[] = [];
-  let cardInjected = false;
-  for (const m of messages) {
-    if (dynamicMsgIds.has(m.id)) continue;
-    staticItems.push({ kind: 'message', key: `m-${m.id}`, message: m });
-    for (const s of stepsByMsg.get(m.id) ?? []) {
-      staticItems.push({ kind: 'step', key: `s-${s.id}`, step: s });
-    }
-    if (cardInScrollback && connectCard && connectCard.anchorMessageId === m.id) {
-      staticItems.push({
-        kind: 'connectCard',
-        key: `cc-${connectCard.id}-${connectCard.status}`,
-        state: connectCard,
-      });
-      cardInjected = true;
-    }
-  }
-  // Fallback: la tarjeta terminal quedo huerfana porque su mensaje ancla ya no
-  // esta (p.ej. tras /compact). La empujamos igual al scrollback para no perder
-  // el registro visual.
-  if (cardInScrollback && connectCard && !cardInjected) {
-    staticItems.push({
-      kind: 'connectCard',
-      key: `cc-${connectCard.id}-${connectCard.status}-orphan`,
-      state: connectCard,
-    });
-  }
-
-  const dynamicMessages = messages.filter((m) => dynamicMsgIds.has(m.id));
-
-  return (
-    <Box flexDirection="column">
-      <Static items={staticItems}>
-        {(item) => {
-          if (item.kind === 'message') {
-            return <Message key={item.key} message={item.message} />;
-          }
-          if (item.kind === 'step') {
-            return <ToolCall key={item.key} step={item.step} />;
-          }
-          return <ConnectCard key={item.key} state={item.state} />;
-        }}
-      </Static>
-
-      <Box flexDirection="column">
-        {dynamicMessages.map((m) => (
-          <React.Fragment key={m.id}>
-            <Message message={m} />
-            {(stepsByMsg.get(m.id) ?? []).map((s) => (
-              <ToolCall key={s.id} step={s} />
-            ))}
-            {cardActive && connectCard && connectCard.anchorMessageId === m.id ? (
-              <ConnectCard state={connectCard} />
-            ) : null}
-          </React.Fragment>
-        ))}
-        {/* Fallback: tarjeta activa cuyo ancla ya no esta en messages. */}
-        {cardActive && connectCard && !messages.some((m) => m.id === connectCard.anchorMessageId) ? (
-          <ConnectCard state={connectCard} />
-        ) : null}
-      </Box>
-    </Box>
-  );
-}

package/src/studio/components/ConnectCard.tsx

@@ -1,171 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import Spinner from 'ink-spinner';
-import type { ConnectChannel, ConnectState } from '../connect/types.js';
-import { CONNECT_POLL_MAX_ATTEMPTS } from '../connect/types.js';
-
-interface Props {
-  state: ConnectState;
-}
-
-function formatExpiry(iso?: string): string {
-  if (!iso) return '';
-  const d = new Date(iso);
-  if (Number.isNaN(d.getTime())) return '';
-  return d.toLocaleString('en-US', {
-    day: 'numeric',
-    month: 'short',
-    hour: '2-digit',
-    minute: '2-digit',
-  });
-}
-
-/**
- * Envuelve una URL en un hyperlink OSC 8. Terminales que no lo soportan
- * imprimen solo el label visible — iTerm2, kitty, Wezterm, Alacritty (reciente),
- * VS Code/Hyper modernos si lo soportan.
- */
-function osc8(url: string, label: string): string {
-  return `\u001b]8;;${url}\u001b\\${label}\u001b]8;;\u001b\\`;
-}
-
-interface ChannelCopy {
-  headerWaiting: string;
-  headerConnected: string;
-  typeLabel: (linkType: string | undefined) => string;
-  hint: string;
-  connectedTpl: (label: string) => string;
-}
-
-function copyFor(channel: ConnectChannel): ChannelCopy {
-  switch (channel) {
-    case 'whatsapp':
-      return {
-        headerWaiting: 'Connect your WhatsApp',
-        headerConnected: 'WhatsApp connected',
-        typeLabel: (lt) => (lt === 'whatsapp_business' ? 'WhatsApp Business' : 'WhatsApp Cloud API'),
-        hint: "Open the link from a phone with WhatsApp installed. We'll keep watching for the new number.",
-        connectedTpl: (n) => `Number ${n || '(connected)'} activated successfully.`,
-      };
-    case 'instagram':
-      return {
-        headerWaiting: 'Connect your Instagram',
-        headerConnected: 'Instagram connected',
-        typeLabel: () => 'Instagram Business',
-        hint: "Open the link in your browser and authorize the Instagram Business account linked to a Facebook Page. We'll keep watching for the connection.",
-        connectedTpl: (n) => `Account ${n || '(connected)'} activated successfully.`,
-      };
-    case 'messenger':
-      return {
-        headerWaiting: 'Connect your Messenger',
-        headerConnected: 'Messenger connected',
-        typeLabel: () => 'Facebook Page',
-        hint: "Open the link in your browser and select the Facebook Page(s) you want to use with Messenger. We'll keep watching for the connection.",
-        connectedTpl: (n) => `Page ${n || '(connected)'} activated successfully.`,
-      };
-  }
-}
-
-export function ConnectCard({ state }: Props): React.ReactElement {
-  const { channel, linkData, status, connectedLabel, errorMessage, attempt } = state;
-  const shortUrl = linkData.shortUrl || '';
-  const expiry = formatExpiry(linkData.expiresAt);
-  const copy = copyFor(channel);
-  const typeLabel = copy.typeLabel(linkData.linkType);
-
-  let headerIcon = '●';
-  let headerColor: 'green' | 'red' | 'yellow' = 'green';
-  let headerText = copy.headerWaiting;
-  if (status === 'connected') {
-    headerIcon = '✓';
-    headerColor = 'green';
-    headerText = copy.headerConnected;
-  } else if (status === 'error') {
-    headerIcon = '✖';
-    headerColor = 'red';
-    headerText = 'Could not activate the integration';
-  } else if (status === 'timeout') {
-    headerIcon = '○';
-    headerColor = 'yellow';
-    headerText = 'No connection detected';
-  } else if (status === 'cancelled') {
-    headerIcon = '○';
-    headerColor = 'yellow';
-    headerText = 'Connection cancelled';
-  }
-
-  const showLink = status !== 'connected' && status !== 'cancelled' && !!shortUrl;
-
-  return (
-    <Box
-      flexDirection="column"
-      borderStyle="round"
-      borderColor={status === 'error' ? 'red' : status === 'connected' ? 'green' : 'gray'}
-      paddingX={1}
-      marginY={1}
-      marginLeft={2}
-    >
-      {/* Header */}
-      <Box>
-        <Text bold color={headerColor}>{headerIcon} </Text>
-        <Text bold>{headerText}</Text>
-        {status !== 'connected' && status !== 'error' && status !== 'cancelled' ? (
-          <>
-            <Text dimColor>   </Text>
-            <Text dimColor>· {typeLabel}</Text>
-          </>
-        ) : null}
-      </Box>
-
-      {/* Link block */}
-      {showLink ? (
-        <Box marginTop={1} flexDirection="column">
-          <Box>
-            <Text dimColor>link: </Text>
-            <Text color="cyan" underline>{osc8(shortUrl, shortUrl)}</Text>
-          </Box>
-          {expiry ? (
-            <Box>
-              <Text dimColor>expires: {expiry}</Text>
-            </Box>
-          ) : null}
-          <Box marginTop={1}>
-            <Text dimColor>{copy.hint}</Text>
-          </Box>
-        </Box>
-      ) : null}
-
-      {/* Status line */}
-      <Box marginTop={1}>
-        {status === 'waiting' ? (
-          <>
-            <Text color="yellow"><Spinner type="dots" /></Text>
-            <Text dimColor> Waiting for connection… </Text>
-            <Text dimColor>({attempt}/{CONNECT_POLL_MAX_ATTEMPTS})</Text>
-            <Text dimColor>   · press Esc to cancel</Text>
-          </>
-        ) : null}
-        {status === 'activating' ? (
-          <>
-            <Text color="yellow"><Spinner type="dots" /></Text>
-            <Text dimColor> Connection detected, activating…</Text>
-          </>
-        ) : null}
-        {status === 'connected' ? (
-          <Text color="green">{copy.connectedTpl(connectedLabel || '')}</Text>
-        ) : null}
-        {status === 'timeout' ? (
-          <Text dimColor>
-            We didn't detect the connection within 5 minutes. Ask the agent to try again.
-          </Text>
-        ) : null}
-        {status === 'cancelled' ? (
-          <Text dimColor>Polling cancelled by user.</Text>
-        ) : null}
-        {status === 'error' ? (
-          <Text color="red">{errorMessage || 'An error occurred while activating the integration.'}</Text>
-        ) : null}
-      </Box>
-    </Box>
-  );
-}