plazbot-cli 0.2.26 → 0.3.2

package/dist/studio/api/studioApi.js

@@ -0,0 +1,25 @@
+/**
+ * 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, dev) {
+    if (dev)
+        return 'http://localhost:5090';
+    return zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com';
+}
+export function buildStudioUrl(zone, dev) {
+    return `${getBaseUrl(zone, dev)}/api/agent/studio`;
+}
+export function buildStudioHeaders(opts) {
+    const headers = {
+        '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/dist/studio/api/types.js

@@ -0,0 +1,16 @@
+/**
+ * Tipos de los chunks que emite el endpoint POST /api/agent/studio (SSE).
+ * Espejo del modelo del backend AgentStudioModels.cs.
+ */
+export class StudioHttpError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(status, statusText, body) {
+        super(`HTTP ${status} ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = 'StudioHttpError';
+    }
+}

package/dist/studio/components/AgentPanel.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStudioStore } from '../state/store.js';
+import { JsonView, safeStringify } from '../render/json.js';
+export function AgentPanel() {
+    const open = useStudioStore((s) => s.panelOpen);
+    const tab = useStudioStore((s) => s.panelTab);
+    const cfg = useStudioStore((s) => s.agentConfig);
+    if (!open)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, flexGrow: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: "green", children: "Agent panel" }) }), _jsxs(Box, { children: [_jsx(Tab, { active: tab === 'preview', children: "preview" }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), _jsx(Tab, { active: tab === 'json', children: "json" }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), _jsx(Tab, { active: tab === 'diagnose', children: "diagnose" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: renderTab(tab, cfg) })] }));
+}
+function Tab({ active, children }) {
+    return active ? _jsx(Text, { color: "cyan", bold: true, children: children }) : _jsx(Text, { dimColor: true, children: children });
+}
+function renderTab(tab, cfg) {
+    if (!cfg) {
+        return _jsx(Text, { dimColor: true, children: "No agent loaded yet." });
+    }
+    if (tab === 'json') {
+        return _jsx(JsonView, { value: cfg });
+    }
+    if (tab === 'diagnose') {
+        return _jsx(Text, { dimColor: true, children: "Run `/diagnose` to analyze the current agent." });
+    }
+    // preview: key agent fields
+    const c = cfg;
+    const name = c?.name ?? '(unnamed)';
+    const description = c?.description ?? '';
+    const model = c?.model ?? c?.modelId ?? '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Name: " }), _jsx(Text, { children: name })] }), model ? _jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Model: " }), _jsx(Text, { children: model })] }) : null, description ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Description:" }), _jsx(Text, { children: description })] })) : null, _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: truncate(safeStringify(c), 400) }) })] }));
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n) + '…' : s;
+}

package/dist/studio/components/App.js

@@ -0,0 +1,214 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { 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 { startWhatsappPolling } from '../whatsapp/polling.js';
+import { workspaceOptsFromStream } from '../whatsapp/api.js';
+export function App({ version, stream, initialAgentId, dev, supportMode }) {
+    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 WhatsApp polling handle (cancelled on Esc / unmount / new stream).
+    const waPollingRef = useRef(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(async () => { });
+    const stopWaPolling = useCallback(() => {
+        if (waPollingRef.current) {
+            waPollingRef.current.cancel();
+            waPollingRef.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 () => { stopWaPolling(); };
+    }, [stopWaPolling]);
+    // Atajos de teclado globales.
+    useInput((input, key) => {
+        if (key.escape) {
+            const wa = useStudioStore.getState().waConnect;
+            if (wa && (wa.status === 'waiting' || wa.status === 'activating')) {
+                stopWaPolling();
+                useStudioStore.getState().setWaStatus('cancelled');
+                return;
+            }
+            useStudioStore.getState().abortStream();
+            return;
+        }
+        if (key.ctrl && input === 'c') {
+            stopWaPolling();
+            useStudioStore.getState().abortStream();
+            exit();
+            return;
+        }
+    });
+    const sendToBackend = useCallback(async (userText) => {
+        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) => {
+            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;
+                    if (data) {
+                        const cfg = data.config ?? data.agentConfig ?? data.agent ?? null;
+                        if (cfg && typeof cfg === 'object') {
+                            s.setAgentConfig(cfg);
+                            const idCandidate = cfg.id;
+                            if (typeof idCandidate === 'string')
+                                s.setAgentId(idCandidate);
+                        }
+                    }
+                    // WhatsApp connect tool: spin up the card + polling.
+                    if (tr?.type === 'whatsapp_link' && data) {
+                        const linkData = data;
+                        // 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.
+                            stopWaPolling();
+                            s.startWaConnect(linkData, assistantId);
+                            waPollingRef.current = startWhatsappPolling(workspaceOptsFromStream(stream), linkData, {
+                                onAttempt(attempt) {
+                                    useStudioStore.getState().updateWaConnect({ attempt });
+                                },
+                                onActivating() {
+                                    useStudioStore.getState().setWaStatus('activating');
+                                },
+                                onConnected(number) {
+                                    useStudioStore.getState().setWaStatus('connected', { connectedNumber: number });
+                                    waPollingRef.current = null;
+                                    if (!streamingRef.current) {
+                                        const followUp = `My WhatsApp is now connected. Number: ${number || '(no number)'}. ` +
+                                            `Continue with the agent setup.`;
+                                        void sendBackendRef.current(followUp);
+                                    }
+                                },
+                                onTimeout() {
+                                    useStudioStore.getState().setWaStatus('timeout');
+                                    waPollingRef.current = null;
+                                },
+                                onError(message) {
+                                    useStudioStore.getState().setWaStatus('error', { errorMessage: message });
+                                    waPollingRef.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, stopWaPolling]);
+    useEffect(() => { sendBackendRef.current = sendToBackend; }, [sendToBackend]);
+    const handleSubmit = useCallback(async (raw) => {
+        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 (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { version: version, workspace: stream.workspaceId, zone: stream.zone, agentId: agentId, dev: dev, supportMode: !!supportMode }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: empty ? _jsx(Suggestions, {}) : _jsx(ChatLog, {}) }), _jsx(Input, { disabled: streaming, onSubmit: handleSubmit }), _jsx(Footer, { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens, streaming: streaming })] }));
+}
+function formatError(err, dev) {
+    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/dist/studio/components/ChatLog.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Static } from 'ink';
+import { useStudioStore } from '../state/store.js';
+import { Message } from './Message.js';
+import { ToolCall } from './ToolCall.js';
+import { WhatsappConnectCard } from './WhatsappConnectCard.js';
+/**
+ * Renders the conversation log.
+ *
+ * Stable items (finished assistant/user messages + resolved tool steps that
+ * are not anchored to an active WhatsApp card) are rendered inside <Static>
+ * so Ink writes them to scrollback once and never re-renders them on resize.
+ * This is what fixes the "Header echoed multiple times" effect you see when
+ * dragging the terminal window while the dynamic frame is taller than the
+ * viewport.
+ *
+ * The dynamic block at the bottom contains the streaming message, any steps
+ * still in `running`, and the WhatsApp connect card while it is active.
+ */
+export function ChatLog() {
+    const messages = useStudioStore((s) => s.messages);
+    const steps = useStudioStore((s) => s.steps);
+    const waConnect = useStudioStore((s) => s.waConnect);
+    // Group steps by their anchor message for quick lookup.
+    const stepsByMsg = new Map();
+    for (const step of steps) {
+        const arr = stepsByMsg.get(step.afterMessageId) ?? [];
+        arr.push(step);
+        stepsByMsg.set(step.afterMessageId, arr);
+    }
+    // Determine which message ids must stay in the dynamic frame:
+    // - the last message if it's still streaming
+    // - any message whose tool steps are still running
+    // - the message anchored to an active WhatsApp connect card
+    const dynamicMsgIds = new Set();
+    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 (waConnect)
+        dynamicMsgIds.add(waConnect.anchorMessageId);
+    // Build the static (scrollback) list. Each message and step gets a unique
+    // key so React/Ink only writes it once.
+    const staticItems = [];
+    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 });
+        }
+    }
+    const dynamicMessages = messages.filter((m) => dynamicMsgIds.has(m.id));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticItems, children: (item) => item.kind === 'message' ? (_jsx(Message, { message: item.message }, item.key)) : (_jsx(ToolCall, { step: item.step }, item.key)) }), _jsxs(Box, { flexDirection: "column", children: [dynamicMessages.map((m) => (_jsxs(React.Fragment, { children: [_jsx(Message, { message: m }), (stepsByMsg.get(m.id) ?? []).map((s) => (_jsx(ToolCall, { step: s }, s.id))), waConnect && waConnect.anchorMessageId === m.id ? (_jsx(WhatsappConnectCard, { state: waConnect })) : null] }, m.id))), waConnect && !messages.some((m) => m.id === waConnect.anchorMessageId) ? (_jsx(WhatsappConnectCard, { state: waConnect })) : null] })] }));
+}

package/dist/studio/components/Footer.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+function fmt(n) {
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return String(n);
+}
+export function Footer({ inputTokens, outputTokens, streaming }) {
+    return (_jsxs(Box, { paddingX: 1, flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "tokens: " }), _jsx(Text, { children: fmt(inputTokens) }), _jsx(Text, { dimColor: true, children: " in / " }), _jsx(Text, { children: fmt(outputTokens) }), _jsx(Text, { dimColor: true, children: " out" }), streaming ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: "  " }), _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { color: "yellow", children: " streaming\u2026" })] })) : null] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "/help \u00B7 Esc cancel \u00B7 Ctrl+C quit" }) })] }));
+}

package/dist/studio/components/Header.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function Header({ version, workspace, zone, agentId, dev, supportMode }) {
+    // Sin borde: cualquier `borderStyle` se acumula visualmente cuando el usuario
+    // redimensiona la terminal (Ink no limpia el scrollback). Estilo Claude Code:
+    // una sola línea con título a la izquierda y metadata a la derecha.
+    return (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: supportMode ? 'yellow' : 'green', children: "\u25CF Plazbot Studio" }), _jsxs(Text, { dimColor: true, children: [" v", version] }), dev ? _jsx(Text, { color: "yellow", children: "  dev" }) : null, supportMode ? _jsx(Text, { color: "yellow", bold: true, children: "  \u00B7 SUPPORT" }) : null] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "workspace " }), _jsx(Text, { color: supportMode ? 'yellow' : undefined, children: workspace }), _jsx(Text, { dimColor: true, children: "  zone " }), _jsx(Text, { children: zone }), agentId ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "  agent " }), _jsx(Text, { color: "cyan", children: agentId.slice(0, 12) })] })) : null] })] }));
+}

package/dist/studio/components/Input.js

@@ -0,0 +1,15 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+export function Input({ disabled, onSubmit }) {
+    const [value, setValue] = useState('');
+    return (_jsxs(Box, { borderStyle: "round", borderColor: disabled ? 'gray' : 'green', paddingX: 1, children: [_jsxs(Text, { color: disabled ? 'gray' : 'green', bold: true, children: [disabled ? '·' : '›', ' '] }), _jsx(TextInput, { value: value, onChange: disabled ? () => { } : setValue, onSubmit: (v) => {
+                    if (disabled)
+                        return;
+                    if (!v.trim())
+                        return;
+                    setValue('');
+                    onSubmit(v);
+                }, placeholder: disabled ? 'Waiting for response… (press Esc to cancel)' : 'Type a message or /help', showCursor: !disabled })] }));
+}

package/dist/studio/components/Message.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { renderMarkdown } from '../render/markdown.js';
+/**
+ * Phrases shown next to the spinner while waiting for the first text token.
+ * Rotated every ~1.8s for a Claude Code–style feel.
+ */
+const THINKING_PHRASES = [
+    'Thinking',
+    'Pondering',
+    'Cooking',
+    'Reasoning',
+    'Crafting',
+    'Working',
+    'Brewing',
+];
+function useRotatingPhrase(active) {
+    const [idx, setIdx] = useState(0);
+    useEffect(() => {
+        if (!active)
+            return;
+        const t = setInterval(() => setIdx((i) => (i + 1) % THINKING_PHRASES.length), 1800);
+        return () => clearInterval(t);
+    }, [active]);
+    return THINKING_PHRASES[idx];
+}
+function useBlinkingCursor(active) {
+    const [on, setOn] = useState(true);
+    useEffect(() => {
+        if (!active)
+            return;
+        const t = setInterval(() => setOn((v) => !v), 450);
+        return () => clearInterval(t);
+    }, [active]);
+    return on;
+}
+export function Message({ message }) {
+    const isUser = message.role === 'user';
+    const dotColor = isUser ? 'cyan' : message.error ? 'red' : 'green';
+    const labelColor = message.error ? 'red' : undefined;
+    const label = isUser ? 'You' : 'Plazbot';
+    const streamingNoContent = !!message.streaming && !message.content && !isUser;
+    const streamingWithContent = !!message.streaming && !!message.content && !isUser;
+    const phrase = useRotatingPhrase(streamingNoContent);
+    const cursorOn = useBlinkingCursor(streamingWithContent);
+    const body = useMemo(() => {
+        if (!message.content)
+            return '';
+        if (isUser)
+            return message.content;
+        return renderMarkdown(message.content);
+    }, [message.content, isUser]);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: dotColor, bold: true, children: "\u25CF " }), _jsx(Text, { bold: true, color: labelColor, children: label }), streamingNoContent ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { dimColor: true, children: [" ", phrase, "\u2026"] })] })) : null] }), body || streamingWithContent ? (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { children: [body, streamingWithContent ? (_jsx(Text, { color: "green", dimColor: true, children: cursorOn ? '▍' : ' ' })) : null] }) })) : null] }));
+}

package/dist/studio/components/Suggestions.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const HINTS = [
+    { title: 'List my agents', cmd: '/agents' },
+    { title: 'Load an agent', cmd: '/load <id>' },
+    { title: 'Diagnose the current agent', cmd: '/diagnose' },
+    { title: 'Create a new agent', cmd: 'Create a sales agent for WhatsApp' },
+];
+export function Suggestions() {
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, children: [_jsx(Text, { dimColor: true, children: "Try one of these to get started:" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: HINTS.map((h) => (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "  \u25B8 " }), _jsx(Text, { bold: true, children: h.title }), _jsxs(Text, { dimColor: true, children: ["  ", h.cmd] })] }, h.title))) })] }));
+}

package/dist/studio/components/ToolCall.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { stepLabel } from '../render/steps.js';
+/**
+ * Some tool errors are expected control flow (e.g. the model asks to load
+ * an agent that doesn't exist; the backend returns "not found"). The model
+ * always explains these in plain text afterwards, so showing a loud red ✗
+ * with a duplicated error string is just visual noise. We detect those
+ * messages and render them as a soft dim line instead.
+ */
+function isSoftFailure(msg) {
+    if (!msg)
+        return false;
+    const m = msg.toLowerCase();
+    return (m.includes('no encontrado') ||
+        m.includes('no existe') ||
+        m.includes('not found') ||
+        m.includes("doesn't exist") ||
+        m.includes('does not exist'));
+}
+export function ToolCall({ step }) {
+    const label = stepLabel(step.toolName, step.status);
+    if (step.status === 'running') {
+        return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: [label, "\u2026"] })] }));
+    }
+    if (step.status === 'success') {
+        return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: "green", children: "\u2713" }), _jsxs(Text, { dimColor: true, children: [" ", label] })] }));
+    }
+    // error
+    const soft = isSoftFailure(step.errorMessage);
+    return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: soft ? 'gray' : 'red', children: soft ? '○' : '✗' }), _jsxs(Text, { color: soft ? undefined : 'red', dimColor: soft, children: [" ", label] }), step.errorMessage ? _jsxs(Text, { dimColor: true, children: [" \u2014 ", step.errorMessage] }) : null] }));
+}

package/dist/studio/components/WhatsappConnectCard.js

@@ -0,0 +1,57 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { WA_POLL_MAX_ATTEMPTS } from '../whatsapp/types.js';
+function formatExpiry(iso) {
+    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',
+    });
+}
+/**
+ * Wraps a URL in an OSC 8 hyperlink escape sequence. Terminals that don't
+ * support it just print the visible text — but iTerm2, kitty, Wezterm,
+ * Alacritty (recent), and modern VS Code/Hyper terminals do.
+ */
+function osc8(url, label) {
+    return `\u001b]8;;${url}\u001b\\${label}\u001b]8;;\u001b\\`;
+}
+export function WhatsappConnectCard({ state }) {
+    const { linkData, status, connectedNumber, errorMessage, attempt } = state;
+    const shortUrl = linkData.shortUrl || '';
+    const expiry = formatExpiry(linkData.expiresAt);
+    const typeLabel = linkData.linkType === 'whatsapp_business' ? 'WhatsApp Business' : 'WhatsApp Cloud API';
+    // Header glyph + color per status.
+    let headerIcon = '●';
+    let headerColor = 'green';
+    let headerText = 'Connect your WhatsApp';
+    if (status === 'connected') {
+        headerIcon = '✓';
+        headerColor = 'green';
+        headerText = 'WhatsApp connected';
+    }
+    else if (status === 'error') {
+        headerIcon = '✖';
+        headerColor = 'red';
+        headerText = 'Could not activate the number';
+    }
+    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 (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === 'error' ? 'red' : status === 'connected' ? 'green' : 'gray', paddingX: 1, marginY: 1, marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, color: headerColor, children: [headerIcon, " "] }), _jsx(Text, { bold: true, children: headerText }), status !== 'connected' && status !== 'error' && status !== 'cancelled' ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "   " }), _jsxs(Text, { dimColor: true, children: ["\u00B7 ", typeLabel] })] })) : null] }), showLink ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "link: " }), _jsx(Text, { color: "cyan", underline: true, children: osc8(shortUrl, shortUrl) })] }), expiry ? (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["expires: ", expiry] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Open the link from a phone with WhatsApp installed. We'll keep watching for the new number." }) })] })) : null, _jsxs(Box, { marginTop: 1, children: [status === 'waiting' ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Waiting for connection\u2026 " }), _jsxs(Text, { dimColor: true, children: ["(", attempt, "/", WA_POLL_MAX_ATTEMPTS, ")"] }), _jsx(Text, { dimColor: true, children: "   \u00B7 press Esc to cancel" })] })) : null, status === 'activating' ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Number detected, activating\u2026" })] })) : null, status === 'connected' ? (_jsxs(Text, { color: "green", children: ["Number ", connectedNumber || '(connected)', " activated successfully."] })) : null, status === 'timeout' ? (_jsx(Text, { dimColor: true, children: "We didn't detect the connection within 5 minutes. Ask the agent to try again." })) : null, status === 'cancelled' ? (_jsx(Text, { dimColor: true, children: "Polling cancelled by user." })) : null, status === 'error' ? (_jsx(Text, { color: "red", children: errorMessage || 'An error occurred while activating the integration.' })) : null] })] }));
+}

package/dist/studio/index.js

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+export const studioCommand = new Command('studio')
+    .description('Interactive Plazbot Studio REPL (create, diagnose and manage AI agents)')
+    .option('--dev', 'Target the local backend (http://localhost:5090)', false)
+    .option('-a, --agent-id <id>', 'Preload an agent on startup')
+    .option('-w, --workspace-id <id>', 'Override the workspace (support / white-label partner mode)')
+    .option('-m, --message <text>', 'Run a one-shot prompt and exit')
+    .action(async (opts) => {
+    if (opts.message) {
+        const { runOneShot } = await import('./runOneShot.js');
+        await runOneShot({
+            dev: opts.dev,
+            agentId: opts.agentId,
+            message: opts.message,
+            workspaceOverride: opts.workspaceId,
+        });
+        return;
+    }
+    const { runRepl } = await import('./runRepl.js');
+    await runRepl({
+        dev: opts.dev,
+        agentId: opts.agentId,
+        workspaceOverride: opts.workspaceId,
+    });
+});
+studioCommand
+    .command('ask <message>')
+    .description('Run a one-shot studio query without opening the TUI')
+    .option('--dev', 'Target the local backend (http://localhost:5090)', false)
+    .option('-a, --agent-id <id>', 'Agent to use as context')
+    .option('-w, --workspace-id <id>', 'Override the workspace (support / white-label partner mode)')
+    .option('--json', 'Print SSE chunks as raw NDJSON', false)
+    .action(async (message, opts) => {
+    const { runOneShot } = await import('./runOneShot.js');
+    await runOneShot({
+        dev: opts.dev,
+        agentId: opts.agentId,
+        message,
+        json: opts.json,
+        workspaceOverride: opts.workspaceId,
+    });
+});

package/dist/studio/render/json.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+import SyntaxHighlight from 'ink-syntax-highlight';
+export function JsonView({ value, maxHeight }) {
+    const text = safeStringify(value);
+    return (_jsx(Box, { flexDirection: "column", height: maxHeight, children: _jsx(SyntaxHighlight, { code: text, language: "json" }) }));
+}
+function safeStringify(v) {
+    try {
+        return JSON.stringify(v, null, 2);
+    }
+    catch {
+        return String(v);
+    }
+}
+export { safeStringify };