plazbot-cli 0.2.25 → 0.3.1

package/dist/studio/render/steps.js

@@ -0,0 +1,58 @@
+/**
+ * Maps backend tool_name values to human-readable step labels for the REPL.
+ * Keeps both forms (gerund for "running" and past tense for "success").
+ */
+const LABELS = {
+    list_agents: {
+        running: 'Listing agents',
+        done: 'Agents listed',
+        failed: 'Could not list agents',
+    },
+    load_agent: {
+        running: 'Loading agent',
+        done: 'Agent loaded',
+        failed: 'Could not load agent',
+    },
+    diagnose_agent: {
+        running: 'Diagnosing agent',
+        done: 'Diagnosis complete',
+        failed: 'Could not diagnose agent',
+    },
+    create_agent_config: {
+        running: 'Generating agent configuration',
+        done: 'Configuration generated',
+        failed: 'Could not generate configuration',
+    },
+    update_agent_config: {
+        running: 'Updating agent configuration',
+        done: 'Configuration updated',
+        failed: 'Could not update configuration',
+    },
+    save_agent: {
+        running: 'Saving agent',
+        done: 'Agent saved',
+        failed: 'Could not save agent',
+    },
+    delete_agent: {
+        running: 'Deleting agent',
+        done: 'Agent deleted',
+        failed: 'Could not delete agent',
+    },
+    connect_whatsapp: {
+        running: 'Connecting WhatsApp',
+        done: 'WhatsApp connected',
+        failed: 'Could not connect WhatsApp',
+    },
+};
+export function stepLabel(toolName, status) {
+    const entry = LABELS[toolName] ?? {
+        running: `Running ${toolName}`,
+        done: `Ran ${toolName}`,
+        failed: `Failed: ${toolName}`,
+    };
+    if (status === 'running')
+        return entry.running;
+    if (status === 'success')
+        return entry.done;
+    return entry.failed;
+}

package/dist/studio/runOneShot.js

@@ -0,0 +1,96 @@
+import { getStoredCredentials } from '../utils/credentials.js';
+import { logger } from '../utils/logger.js';
+import { streamStudio } from './api/sseClient.js';
+import { StudioHttpError } from './api/types.js';
+import { stepLabel } from './render/steps.js';
+export async function runOneShot(opts) {
+    let creds;
+    try {
+        creds = await getStoredCredentials();
+    }
+    catch {
+        logger.error('No active session. Run:');
+        console.log('  plazbot init -e <email> -k <jwt> -w <workspace> -z <LA|EU>');
+        process.exit(1);
+        return;
+    }
+    const effectiveWorkspace = opts.workspaceOverride ?? creds.workspace;
+    const supportMode = !!opts.workspaceOverride && opts.workspaceOverride !== creds.workspace;
+    if (supportMode && !opts.json) {
+        process.stderr.write(`! Support mode: acting on workspace "${effectiveWorkspace}" (your account belongs to "${creds.workspace}")\n`);
+    }
+    const stream = {
+        apiKey: creds.apiKey,
+        workspaceId: effectiveWorkspace,
+        userId: creds.userId ?? creds.email ?? undefined,
+        zone: creds.zone,
+        dev: opts.dev,
+    };
+    const controller = new AbortController();
+    process.on('SIGINT', () => controller.abort());
+    let assistantText = '';
+    const onChunk = (chunk) => {
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(chunk) + '\n');
+            return;
+        }
+        switch (chunk.type) {
+            case 'text':
+                assistantText += chunk.content ?? '';
+                process.stdout.write(chunk.content ?? '');
+                break;
+            case 'tool_call':
+                process.stderr.write(`\n  ▸ ${stepLabel(chunk.tool_name, 'running')}…\n`);
+                break;
+            case 'tool_result': {
+                const tr = chunk.tool_result;
+                const ok = tr?.success !== false && !tr?.error;
+                const label = stepLabel(chunk.tool_name, ok ? 'success' : 'error');
+                process.stderr.write(`  ${ok ? '✓' : '✗'} ${label}${tr?.error ? ' — ' + tr.error : ''}\n`);
+                break;
+            }
+            case 'usage':
+                process.stderr.write(`  tokens: ${chunk.input_tokens} in / ${chunk.output_tokens} out\n`);
+                break;
+            case 'error':
+                process.stderr.write(`\n  ✖ ${chunk.error}\n`);
+                break;
+            case 'done':
+                break;
+        }
+    };
+    try {
+        await streamStudio(stream, {
+            message: opts.message,
+            messages: [{ role: 'user', content: opts.message }],
+            agentId: opts.agentId ?? null,
+        }, onChunk, controller.signal);
+        if (!opts.json)
+            process.stdout.write('\n');
+        if (!assistantText && !opts.json)
+            process.stderr.write('  (no text response)\n');
+    }
+    catch (err) {
+        process.stderr.write('\n' + formatError(err, opts.dev) + '\n');
+        process.exit(1);
+    }
+}
+function formatError(err, dev) {
+    if (err instanceof StudioHttpError) {
+        if (err.status === 401)
+            return '✖ Token expired or invalid. Run `plazbot init`.';
+        if (err.status === 403)
+            return '✖ No permission for this workspace.';
+        if (err.status === 429)
+            return '✖ Rate limit reached.';
+        if (err.status >= 500) {
+            return dev
+                ? `✖ Backend ${err.status}: ${err.body ?? err.statusText}`
+                : `✖ Backend returned ${err.status}. Retry.`;
+        }
+        return `✖ HTTP ${err.status} ${err.statusText}`;
+    }
+    if (err instanceof Error)
+        return `✖ ${err.message}`;
+    return '✖ Unknown error';
+}

package/dist/studio/runRepl.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { App } from './components/App.js';
+import { getStoredCredentials } from '../utils/credentials.js';
+import { logger } from '../utils/logger.js';
+export async function runRepl(opts) {
+    let creds;
+    try {
+        creds = await getStoredCredentials();
+    }
+    catch (err) {
+        logger.error('No active session. Run:');
+        console.log('  plazbot init -e <email> -k <jwt> -w <workspace> -z <LA|EU>');
+        process.exit(1);
+    }
+    const effectiveWorkspace = opts.workspaceOverride ?? creds.workspace;
+    const supportMode = !!opts.workspaceOverride && opts.workspaceOverride !== creds.workspace;
+    if (supportMode) {
+        logger.warning(`Support mode: acting on workspace "${effectiveWorkspace}" (your account belongs to "${creds.workspace}")`);
+        logger.warning('All actions are tied to your user and will be visible in audit trails.');
+    }
+    const stream = {
+        apiKey: creds.apiKey,
+        workspaceId: effectiveWorkspace,
+        userId: creds.userId ?? creds.email ?? undefined,
+        zone: creds.zone,
+        dev: opts.dev,
+    };
+    const version = readVersion();
+    const { waitUntilExit } = render(_jsx(App, { version: version, stream: stream, initialAgentId: opts.agentId ?? null, dev: opts.dev, supportMode: supportMode }), {
+        exitOnCtrlC: false,
+    });
+    // Cierre limpio con Ctrl+C: la App lo gestiona vía useInput.
+    process.on('SIGINT', () => {
+        // no-op aquí; App.tsx llama exit() al detectar Ctrl+C.
+    });
+    await waitUntilExit();
+}
+function readVersion() {
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/studio/slash/handlers.js

@@ -0,0 +1,199 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { slashRegistry } from './registry.js';
+import { useStudioStore } from '../state/store.js';
+function expandTilde(p) {
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/'))
+        return resolve(homedir(), p.slice(2));
+    return p;
+}
+function slugify(s) {
+    return s
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-zA-Z0-9-_]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase() || 'agent';
+}
+const CATEGORY_LABELS = {
+    general: 'General',
+    agent: 'Agent',
+    session: 'Session',
+};
+const CATEGORY_ORDER = [
+    'general',
+    'agent',
+    'session',
+];
+slashRegistry.register({
+    name: 'help',
+    aliases: ['?'],
+    description: 'Show this help with every available command',
+    category: 'general',
+    handler() {
+        const all = slashRegistry.list();
+        const grouped = new Map();
+        for (const cmd of all) {
+            const cat = cmd.category ?? 'general';
+            const arr = grouped.get(cat) ?? [];
+            arr.push(cmd);
+            grouped.set(cat, arr);
+        }
+        const lines = ['**Plazbot Studio — slash commands**', ''];
+        lines.push('Type plain text to chat with the assistant.');
+        lines.push('Slash commands run locally or send a templated prompt to the model.');
+        lines.push('');
+        for (const cat of CATEGORY_ORDER) {
+            const items = grouped.get(cat);
+            if (!items || items.length === 0)
+                continue;
+            lines.push(`**${CATEGORY_LABELS[cat]}**`);
+            for (const cmd of items) {
+                const usage = cmd.usage ?? `/${cmd.name}`;
+                const aliasPart = cmd.aliases?.length
+                    ? ` _(alias: ${cmd.aliases.map((a) => '/' + a).join(', ')})_`
+                    : '';
+                lines.push(`- \`${usage}\`${aliasPart} — ${cmd.description}`);
+            }
+            lines.push('');
+        }
+        lines.push('**Keyboard shortcuts**');
+        lines.push('- `Esc` — cancel the current stream');
+        lines.push('- `Ctrl+C` — exit Studio');
+        lines.push('');
+        lines.push('**Tip:** you can also speak naturally — e.g. _"list my agents"_, _"create a sales agent for WhatsApp"_ or _"connect this agent to WhatsApp Business"_.');
+        useStudioStore.getState().pushSyntheticAssistant(lines.join('\n'));
+        return { kind: 'noop' };
+    },
+});
+slashRegistry.register({
+    name: 'clear',
+    aliases: ['cls'],
+    description: 'Clear the conversation (keeps the loaded agent and token usage)',
+    category: 'session',
+    handler() {
+        useStudioStore.getState().clearMessages();
+        return { kind: 'noop' };
+    },
+});
+slashRegistry.register({
+    name: 'reset',
+    description: 'Full reset: clears messages, loaded agent and token usage',
+    category: 'session',
+    handler() {
+        useStudioStore.getState().reset();
+        return { kind: 'noop' };
+    },
+});
+const COMPACT_PROMPT = [
+    'You are about to compact this conversation.',
+    '',
+    'Produce a concise but complete summary of everything we have discussed so far, in Markdown:',
+    '- Goal / task the user is working on.',
+    '- Key decisions and constraints.',
+    '- Current agent configuration state (if any) and its `id`.',
+    '- Pending items or next steps.',
+    '',
+    'Reply with ONLY the summary content (no preamble, no farewell).',
+    'After this message, the previous history will be replaced by your summary so we can keep working with less context.',
+].join('\n');
+slashRegistry.register({
+    name: 'compact',
+    description: 'Summarize the conversation and replace history with that summary',
+    category: 'session',
+    handler() {
+        const store = useStudioStore.getState();
+        if (store.messages.length === 0) {
+            store.pushSyntheticAssistant('Nothing to compact yet.', { error: true });
+            return { kind: 'noop' };
+        }
+        store.setPendingCompact(true);
+        return { kind: 'message', content: COMPACT_PROMPT };
+    },
+});
+slashRegistry.register({
+    name: 'quit',
+    aliases: ['exit', 'q'],
+    description: 'Exit Studio',
+    category: 'general',
+    handler(_parsed, ctx) {
+        ctx.exit();
+        return { kind: 'exit' };
+    },
+});
+slashRegistry.register({
+    name: 'agents',
+    description: 'List the agents in the current workspace',
+    category: 'agent',
+    handler() {
+        return { kind: 'message', content: 'List all agents in my workspace.' };
+    },
+});
+slashRegistry.register({
+    name: 'load',
+    description: 'Load an agent by id and show its current configuration',
+    category: 'agent',
+    usage: '/load <agentId>',
+    handler(parsed) {
+        const id = parsed.args[0];
+        if (!id) {
+            useStudioStore.getState().pushSyntheticAssistant('Usage: `/load <agentId>`', { error: true });
+            return { kind: 'noop' };
+        }
+        useStudioStore.getState().setAgentId(id);
+        return { kind: 'message', content: `Load the agent with id "${id}" and show me its current configuration.` };
+    },
+});
+slashRegistry.register({
+    name: 'save',
+    description: 'Save the currently loaded agent configuration to the backend',
+    category: 'agent',
+    handler() {
+        const { agentConfig } = useStudioStore.getState();
+        if (!agentConfig) {
+            useStudioStore.getState().pushSyntheticAssistant('No agent configuration loaded. Create one first or use `/load <id>`.', { error: true });
+            return { kind: 'noop' };
+        }
+        return { kind: 'message', content: 'Save this agent with its current configuration.' };
+    },
+});
+slashRegistry.register({
+    name: 'diagnose',
+    description: 'Run diagnostics on the current agent and report any issues found',
+    category: 'agent',
+    handler() {
+        return { kind: 'message', content: 'Diagnose this agent and report any issues you find.' };
+    },
+});
+slashRegistry.register({
+    name: 'export',
+    aliases: ['download'],
+    description: 'Export the current agent configuration to a JSON file on disk',
+    category: 'agent',
+    usage: '/export [path]',
+    async handler(parsed) {
+        const store = useStudioStore.getState();
+        const { agentConfig } = store;
+        if (!agentConfig) {
+            store.pushSyntheticAssistant('No hay agente cargado. Crea o carga uno antes con `/load <id>`.', { error: true });
+            return { kind: 'noop' };
+        }
+        const cfg = agentConfig;
+        const baseName = slugify(cfg?.name ?? store.agentId ?? 'agent');
+        const defaultPath = `./${baseName}.json`;
+        const targetArg = parsed.args[0] ?? defaultPath;
+        const targetPath = resolve(process.cwd(), expandTilde(targetArg));
+        try {
+            await writeFile(targetPath, JSON.stringify(agentConfig, null, 2), 'utf-8');
+            store.pushSyntheticAssistant(`Agente exportado a \`${targetPath}\`.\n\nValídalo con: \`plazbot agent validate ${targetPath}\``);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            store.pushSyntheticAssistant(`No pude escribir el archivo: ${message}`, { error: true });
+        }
+        return { kind: 'noop' };
+    },
+});

package/dist/studio/slash/parser.js

@@ -0,0 +1,46 @@
+/**
+ * Parsea un input crudo del usuario.
+ *  - Si empieza con `/`, retorna { name, args, raw } para ejecutar como slash command.
+ *  - Si no, retorna null (mensaje normal al backend).
+ */
+export function parseSlash(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return null;
+    const without = trimmed.slice(1);
+    if (!without)
+        return { name: '', args: [], raw: trimmed };
+    // Split por espacios respetando comillas básicas.
+    const tokens = tokenize(without);
+    const [name, ...args] = tokens;
+    return { name: (name ?? '').toLowerCase(), args, raw: trimmed };
+}
+function tokenize(s) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    for (const ch of s) {
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+                continue;
+            }
+            cur += ch;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (/\s/.test(ch)) {
+            if (cur) {
+                out.push(cur);
+                cur = '';
+            }
+        }
+        else {
+            cur += ch;
+        }
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}

package/dist/studio/slash/registry.js

@@ -0,0 +1,16 @@
+class SlashRegistry {
+    map = new Map();
+    order = [];
+    register(spec) {
+        this.order.push(spec);
+        this.map.set(spec.name, spec);
+        spec.aliases?.forEach((a) => this.map.set(a, spec));
+    }
+    get(name) {
+        return this.map.get(name);
+    }
+    list() {
+        return this.order.slice();
+    }
+}
+export const slashRegistry = new SlashRegistry();

package/dist/studio/state/store.js

@@ -0,0 +1,181 @@
+import { create } from 'zustand';
+import { randomUUID } from 'node:crypto';
+function uid() {
+    // randomUUID está disponible en Node >=14.17 con crypto. Fallback simple.
+    try {
+        return randomUUID();
+    }
+    catch {
+        return Math.random().toString(36).slice(2);
+    }
+}
+export const useStudioStore = create((set, get) => ({
+    messages: [],
+    steps: [],
+    agentConfig: null,
+    agentId: null,
+    usage: { inputTokens: 0, outputTokens: 0 },
+    streaming: false,
+    abortController: null,
+    waConnect: null,
+    pendingCompact: false,
+    pushUserMessage(content) {
+        const id = uid();
+        set((s) => ({ messages: [...s.messages, { id, role: 'user', content }] }));
+        return id;
+    },
+    pushSyntheticAssistant(content, opts) {
+        const id = uid();
+        set((s) => ({
+            messages: [...s.messages, { id, role: 'assistant', content, synthetic: true, error: opts?.error }],
+        }));
+        return id;
+    },
+    startAssistantMessage() {
+        const id = uid();
+        set((s) => ({ messages: [...s.messages, { id, role: 'assistant', content: '', streaming: true }] }));
+        return id;
+    },
+    appendAssistantText(id, delta) {
+        set((s) => ({
+            messages: s.messages.map((m) => (m.id === id ? { ...m, content: m.content + delta } : m)),
+        }));
+    },
+    finishAssistantMessage(id) {
+        set((s) => ({
+            messages: s.messages.map((m) => (m.id === id ? { ...m, streaming: false } : m)),
+        }));
+    },
+    startStep(toolName, afterMessageId) {
+        const id = uid();
+        set((s) => ({ steps: [...s.steps, { id, toolName, status: 'running', afterMessageId }] }));
+        return id;
+    },
+    resolveLastStep(toolName, status, result, errorMessage) {
+        set((s) => {
+            const idx = [...s.steps].reverse().findIndex((x) => x.toolName === toolName && x.status === 'running');
+            if (idx === -1)
+                return {};
+            const real = s.steps.length - 1 - idx;
+            const updated = [...s.steps];
+            updated[real] = { ...updated[real], status, result, errorMessage };
+            return { steps: updated };
+        });
+    },
+    failAllRunningSteps(message) {
+        set((s) => ({
+            steps: s.steps.map((x) => x.status === 'running' ? { ...x, status: 'error', errorMessage: message ?? 'Cancelado' } : x),
+        }));
+    },
+    setAgentConfig(cfg) {
+        set({ agentConfig: cfg });
+    },
+    setAgentId(id) {
+        set({ agentId: id });
+    },
+    addUsage(inT, outT) {
+        set((s) => ({
+            usage: {
+                inputTokens: s.usage.inputTokens + (inT || 0),
+                outputTokens: s.usage.outputTokens + (outT || 0),
+            },
+        }));
+    },
+    setStreaming(streaming) {
+        set({ streaming });
+    },
+    setAbortController(abortController) {
+        set({ abortController });
+    },
+    abortStream() {
+        const ctrl = get().abortController;
+        if (ctrl && !ctrl.signal.aborted)
+            ctrl.abort();
+    },
+    startWaConnect(linkData, anchorMessageId) {
+        const id = uid();
+        set({
+            waConnect: {
+                id,
+                linkData,
+                status: 'waiting',
+                anchorMessageId,
+                attempt: 0,
+            },
+        });
+        return id;
+    },
+    updateWaConnect(patch) {
+        set((s) => (s.waConnect ? { waConnect: { ...s.waConnect, ...patch } } : {}));
+    },
+    setWaStatus(status, extra) {
+        set((s) => (s.waConnect ? { waConnect: { ...s.waConnect, status, ...(extra ?? {}) } } : {}));
+    },
+    clearWaConnect() {
+        set({ waConnect: null });
+    },
+    clearMessages() {
+        const ctrl = get().abortController;
+        if (ctrl && !ctrl.signal.aborted)
+            ctrl.abort();
+        set({
+            messages: [],
+            steps: [],
+            streaming: false,
+            abortController: null,
+            waConnect: null,
+            pendingCompact: false,
+            // agentConfig, agentId, usage se mantienen para seguir trabajando.
+        });
+    },
+    setPendingCompact(v) {
+        set({ pendingCompact: v });
+    },
+    compactInto(id) {
+        set((s) => {
+            const summary = s.messages.find((m) => m.id === id);
+            if (!summary || !summary.content.trim()) {
+                return { pendingCompact: false };
+            }
+            const newId = uid();
+            return {
+                messages: [
+                    {
+                        id: newId,
+                        role: 'assistant',
+                        content: summary.content,
+                    },
+                ],
+                steps: [],
+                waConnect: null,
+                pendingCompact: false,
+            };
+        });
+    },
+    reset() {
+        const ctrl = get().abortController;
+        if (ctrl && !ctrl.signal.aborted)
+            ctrl.abort();
+        set({
+            messages: [],
+            steps: [],
+            agentConfig: null,
+            agentId: null,
+            usage: { inputTokens: 0, outputTokens: 0 },
+            streaming: false,
+            abortController: null,
+            waConnect: null,
+            pendingCompact: false,
+        });
+    },
+}));
+/**
+ * Construye el array `messages` que se envía al backend a partir del estado.
+ * Filtra mensajes sintéticos (synthetic === true) y los aún en streaming vacíos.
+ */
+export function selectBackendMessages() {
+    const { messages } = useStudioStore.getState();
+    return messages
+        .filter((m) => !m.synthetic && (m.role === 'user' || m.role === 'assistant') && m.content.trim().length > 0)
+        .map((m) => ({ role: m.role, content: m.content }));
+}