@moxxy/cli 0.0.12 → 0.1.0

package/src/tui/helpers.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+
+export const COLORS = {
+  user: '#FF9500',
+  assistant: 'white',
+  event: 'gray',
+  error: 'red',
+  warning: 'yellow',
+  info: 'cyan',
+  dim: 'gray',
+  border: 'gray',
+  accent: 'cyan',
+  status: {
+    idle: 'yellow',
+    running: 'green',
+    stopped: 'gray',
+    error: 'red',
+  },
+};
+
+// Chalk style functions matching COLORS
+export const styles = {
+  user: chalk.hex('#FF9500'),
+  assistant: chalk.white,
+  event: chalk.gray,
+  error: chalk.red,
+  warning: chalk.yellow,
+  info: chalk.cyan,
+  dim: chalk.dim,
+  border: chalk.gray,
+  accent: chalk.cyan,
+  bold: chalk.bold,
+  inverse: chalk.inverse,
+  status: {
+    idle: chalk.yellow,
+    running: chalk.green,
+    stopped: chalk.gray,
+    error: chalk.red,
+  },
+};
+
+export function shortId(id) {
+  return id ? id.slice(0, 12) : '?';
+}
+
+export function formatTs(ts) {
+  if (!ts) return '';
+  return new Date(typeof ts === 'number' ? ts : Date.parse(ts)).toLocaleTimeString();
+}
+
+export function formatNumber(n) {
+  return (n || 0).toLocaleString();
+}
+
+export function makeBar(count, maxCount) {
+  const maxWidth = 10;
+  const width = maxCount > 0 ? Math.round((count / maxCount) * maxWidth) : 0;
+  return '\u2588'.repeat(width);
+}

package/src/tui/hooks/use-command-handler.js

@@ -0,0 +1,451 @@
+import { useReducer, useCallback } from 'react';
+import { SLASH_COMMANDS } from '../slash-commands.js';
+
+const INITIAL_STATE = { type: 'idle' };
+
+function reducer(state, action) {
+  switch (action.type) {
+    case 'vault_set_pending':
+      return { type: 'vault_set', keyName: action.keyName };
+    case 'vault_set_key':
+      return { type: 'vault_set_key' };
+    case 'vault_remove_key':
+      return { type: 'vault_remove_key' };
+    case 'mcp_add_transport':
+      return { type: 'mcp_transport' };
+    case 'mcp_add_detail':
+      return { type: 'mcp_detail', transport: action.transport };
+    case 'mcp_add_id':
+      return { type: 'mcp_id', transport: action.transport, detail: action.detail };
+    case 'mcp_remove_id':
+      return { type: 'mcp_remove_id' };
+    case 'mcp_test_id':
+      return { type: 'mcp_test_id' };
+    case 'template_assign_slug':
+      return { type: 'template_assign_slug' };
+    case 'reset':
+      return INITIAL_STATE;
+    default:
+      return state;
+  }
+}
+
+/**
+ * Hook that encapsulates all slash command routing and two-step command state.
+ * Returns { handleSubmit } where handleSubmit is the main input handler.
+ */
+export function useCommandHandler({
+  client,
+  agent,
+  agentId,
+  eventsHandler,
+  onStop,
+  onExit,
+  onAgentUpdate,
+  onContextSync,
+  onOpenModelPicker,
+  onOpenVaultPicker,
+  onOpenVaultSetWizard,
+  onOpenVaultRemoveWizard,
+  onOpenMcpPicker,
+  onOpenMcpTransportPicker,
+  onOpenMcpServerPicker,
+  onOpenTemplatePicker,
+  onOpenTemplateAssignWizard,
+}) {
+  const [twoStep, dispatch] = useReducer(reducer, INITIAL_STATE);
+
+  const handleSubmit = useCallback(async (text) => {
+    const task = text.trim().replace(/^\/{2,}/, '/');
+    if (!task) return;
+
+    // Pending ask: agent asked for user input
+    if (eventsHandler.pendingAsk) {
+      const { questionId } = eventsHandler.pendingAsk;
+      eventsHandler.pendingAsk = null;
+      eventsHandler.addUserMessage(task);
+      try {
+        await client.respondToAsk(agentId, questionId, task);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error responding: ${err.message}`);
+      }
+      return;
+    }
+
+    // Two-step: vault set (capture secret value)
+    if (twoStep.type === 'vault_set') {
+      const { keyName } = twoStep;
+      dispatch({ type: 'reset' });
+      try {
+        await client.createSecret({ key_name: keyName, backend_key: keyName, value: task });
+        eventsHandler.addSystemMessage(`Secret "${keyName}" stored.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    if (twoStep.type === 'vault_set_key') {
+      const keyName = task.trim();
+      if (!keyName) {
+        eventsHandler.addSystemMessage('Secret key name cannot be empty. Cancelled.');
+        dispatch({ type: 'reset' });
+        return;
+      }
+      dispatch({ type: 'vault_set_pending', keyName });
+      eventsHandler.addSystemMessage(`Enter the secret value for "${keyName}":`);
+      return;
+    }
+
+    if (twoStep.type === 'vault_remove_key') {
+      const keyName = task.trim();
+      dispatch({ type: 'reset' });
+      if (!keyName) {
+        eventsHandler.addSystemMessage('Secret key name cannot be empty. Cancelled.');
+        return;
+      }
+      try {
+        const secrets = await client.listSecrets();
+        const match = secrets.find(s => s.key_name === keyName);
+        if (!match) {
+          eventsHandler.addSystemMessage(`Secret "${keyName}" not found.`);
+          return;
+        }
+        await client.deleteSecret(match.id);
+        eventsHandler.addSystemMessage(`Secret "${keyName}" removed.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    // Two-step: mcp add - transport selection
+    if (twoStep.type === 'mcp_transport') {
+      const choice = task.toLowerCase().trim();
+      if (choice !== 'stdio' && choice !== 'sse') {
+        eventsHandler.addSystemMessage('Invalid transport. Enter "stdio" or "sse". Cancelled.');
+        dispatch({ type: 'reset' });
+        return;
+      }
+      const prompt = choice === 'stdio' ? 'Enter the command to start the server:' : 'Enter the SSE URL:';
+      eventsHandler.addSystemMessage(prompt);
+      dispatch({ type: 'mcp_add_detail', transport: choice });
+      return;
+    }
+
+    // Two-step: mcp add - command/url
+    if (twoStep.type === 'mcp_detail') {
+      if (!task) {
+        eventsHandler.addSystemMessage('Empty value. Cancelled.');
+        dispatch({ type: 'reset' });
+        return;
+      }
+      eventsHandler.addSystemMessage('Enter a server ID (unique name for this server):');
+      dispatch({ type: 'mcp_add_id', transport: twoStep.transport, detail: task });
+      return;
+    }
+
+    // Two-step: mcp add - server ID
+    if (twoStep.type === 'mcp_id') {
+      const serverId = task.trim();
+      dispatch({ type: 'reset' });
+      if (!serverId) {
+        eventsHandler.addSystemMessage('Empty server ID. Cancelled.');
+        return;
+      }
+      try {
+        const config = { transport: twoStep.transport, server_id: serverId };
+        if (twoStep.transport === 'stdio') {
+          config.command = twoStep.detail;
+        } else {
+          config.url = twoStep.detail;
+        }
+        await client.addMcpServer(agentId, config);
+        eventsHandler.addSystemMessage(`MCP server "${serverId}" added.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    if (twoStep.type === 'mcp_remove_id') {
+      const serverId = task.trim();
+      dispatch({ type: 'reset' });
+      if (!serverId) {
+        eventsHandler.addSystemMessage('Server ID cannot be empty. Cancelled.');
+        return;
+      }
+      try {
+        await client.removeMcpServer(agentId, serverId);
+        eventsHandler.addSystemMessage(`MCP server "${serverId}" removed.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    if (twoStep.type === 'mcp_test_id') {
+      const serverId = task.trim();
+      dispatch({ type: 'reset' });
+      if (!serverId) {
+        eventsHandler.addSystemMessage('Server ID cannot be empty. Cancelled.');
+        return;
+      }
+      try {
+        const result = await client.testMcpServer(agentId, serverId);
+        const status = result.success ? 'Connection successful' : `Connection failed: ${result.error || 'unknown error'}`;
+        eventsHandler.addSystemMessage(`MCP test "${serverId}": ${status}`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    if (twoStep.type === 'template_assign_slug') {
+      const slug = task.trim();
+      dispatch({ type: 'reset' });
+      if (!slug) {
+        eventsHandler.addSystemMessage('Template slug cannot be empty. Cancelled.');
+        return;
+      }
+      try {
+        await client.setAgentTemplate(agentId, slug);
+        eventsHandler.addSystemMessage(`Template "${slug}" assigned. Changes take effect on next run.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    // Slash commands
+    if (task === '/exit') {
+      onExit();
+      return;
+    }
+    if (task === '/stop') {
+      await onStop();
+      return;
+    }
+    if (task === '/new' || task === '/reset') {
+      try {
+        await client.resetSession(agentId);
+        eventsHandler.clearMessages();
+        eventsHandler.addSystemMessage('Session reset. Starting fresh.');
+        if (onAgentUpdate) onAgentUpdate({ status: 'idle' });
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+    if (task === '/clear') {
+      eventsHandler.clearMessages();
+      return;
+    }
+    if (task === '/help') {
+      const lines = [
+        'Commands: ' + SLASH_COMMANDS.map(c => c.name).join(', '),
+        'Shortcuts: Ctrl+C copy/exit | Ctrl+X cut/stop | Ctrl+V paste',
+      ];
+      eventsHandler.addSystemMessage(lines.join('\n'));
+      return;
+    }
+    if (task === '/status') {
+      const status = agent
+        ? `Agent ${agent.name}: ${agent.status} | Provider: ${agent.provider_id} | Model: ${agent.model_id} | SSE: ${eventsHandler.connected ? 'connected' : 'disconnected'}`
+        : 'No agent connected';
+      eventsHandler.addSystemMessage(status);
+      return;
+    }
+    // Vault commands
+    if (task === '/vault') {
+      await onOpenVaultPicker();
+      return;
+    }
+    if (task === '/vault list') {
+      try {
+        const secrets = await client.listSecrets();
+        if (!secrets || secrets.length === 0) {
+          eventsHandler.addSystemMessage('No vault secrets found.');
+        } else {
+          const lines = secrets.map(s =>
+            `  ${s.key_name} (${s.backend_key}) [${s.policy_label || 'default'}]`
+          );
+          eventsHandler.addSystemMessage('Vault secrets:\n' + lines.join('\n'));
+        }
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+    if (task.startsWith('/vault set')) {
+      const keyName = task.slice('/vault set'.length).trim();
+      if (!keyName) {
+        await onOpenVaultSetWizard();
+        return;
+      }
+      dispatch({ type: 'vault_set_pending', keyName });
+      eventsHandler.addSystemMessage(`Enter the secret value for "${keyName}":`);
+      return;
+    }
+    if (task.startsWith('/vault remove') || task.startsWith('/vault delete')) {
+      const keyName = task.replace(/^\/vault (remove|delete)/, '').trim();
+      if (!keyName) {
+        await onOpenVaultRemoveWizard();
+        return;
+      }
+      try {
+        const secrets = await client.listSecrets();
+        const match = secrets.find(s => s.key_name === keyName);
+        if (!match) {
+          eventsHandler.addSystemMessage(`Secret "${keyName}" not found.`);
+          return;
+        }
+        await client.deleteSecret(match.id);
+        eventsHandler.addSystemMessage(`Secret "${keyName}" removed.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    if (task === '/model') {
+      await onOpenModelPicker();
+      return;
+    }
+
+    // MCP commands
+    if (task === '/mcp') {
+      await onOpenMcpPicker();
+      return;
+    }
+    if (task === '/mcp list') {
+      try {
+        const servers = await client.listMcpServers(agentId);
+        if (!servers || servers.length === 0) {
+          eventsHandler.addSystemMessage('No MCP servers connected.');
+        } else {
+          const lines = servers.map(s => {
+            const id = s.id || s.server_id || 'unknown';
+            const status = s.enabled === false ? 'disabled' : 'enabled';
+            const detail = s.transport === 'stdio'
+              ? `cmd=${s.command || '?'}`
+              : `url=${s.url || '?'}`;
+            return `  ${id} [${s.transport || 'unknown'}] ${status}  ${detail}`;
+          });
+          eventsHandler.addSystemMessage('MCP servers:\n' + lines.join('\n'));
+        }
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+    if (task === '/mcp add') {
+      await onOpenMcpTransportPicker();
+      return;
+    }
+    if (task === '/mcp add stdio' || task === '/mcp add sse' || task === '/mcp add streamable_http') {
+      const transport = task.slice('/mcp add '.length).trim();
+      const prompt = transport === 'stdio'
+        ? 'Enter the command to start the server:'
+        : 'Enter the server URL:';
+      eventsHandler.addSystemMessage(prompt);
+      dispatch({ type: 'mcp_add_detail', transport });
+      return;
+    }
+    if (task.startsWith('/mcp remove')) {
+      const serverId = task.slice('/mcp remove'.length).trim();
+      if (!serverId) {
+        await onOpenMcpServerPicker('remove');
+        return;
+      }
+      try {
+        await client.removeMcpServer(agentId, serverId);
+        eventsHandler.addSystemMessage(`MCP server "${serverId}" removed.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+    if (task.startsWith('/mcp test')) {
+      const serverId = task.slice('/mcp test'.length).trim();
+      if (!serverId) {
+        await onOpenMcpServerPicker('test');
+        return;
+      }
+      try {
+        const result = await client.testMcpServer(agentId, serverId);
+        const status = result.status === 'ok'
+          ? 'Connection successful'
+          : `Connection failed: ${result.error || 'unknown error'}`;
+        eventsHandler.addSystemMessage(`MCP test "${serverId}": ${status}`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    // Template commands
+    if (task === '/template') {
+      await onOpenTemplatePicker();
+      return;
+    }
+    if (task === '/template list') {
+      try {
+        const templates = await client.listTemplates();
+        if (!templates || templates.length === 0) {
+          eventsHandler.addSystemMessage('No templates found.');
+        } else {
+          const lines = templates.map(t =>
+            `  ${t.name} v${t.version}  (${t.slug})${t.tags && t.tags.length > 0 ? ` [${t.tags.join(', ')}]` : ''}`
+          );
+          eventsHandler.addSystemMessage('Templates:\n' + lines.join('\n'));
+        }
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+    if (task.startsWith('/template assign')) {
+      const slug = task.slice('/template assign'.length).trim();
+      if (!slug) {
+        await onOpenTemplateAssignWizard();
+        return;
+      }
+      try {
+        await client.setAgentTemplate(agentId, slug);
+        eventsHandler.addSystemMessage(`Template "${slug}" assigned. Changes take effect on next run.`);
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+    if (task === '/template clear') {
+      try {
+        await client.setAgentTemplate(agentId, null);
+        eventsHandler.addSystemMessage('Template cleared. Changes take effect on next run.');
+      } catch (err) {
+        eventsHandler.addSystemMessage(`Error: ${err.message}`);
+      }
+      return;
+    }
+
+    // Regular task: send to agent
+    eventsHandler.addUserMessage(task);
+    if (agent) {
+      try {
+        await client.startRun(agent.name, task);
+        if (onAgentUpdate) onAgentUpdate({ status: 'running' });
+      } catch (err) {
+        if (err.isGatewayDown) {
+          eventsHandler.addSystemMessage(err.message);
+        } else {
+          eventsHandler.addSystemMessage(`Error: ${err.message}`);
+        }
+      }
+    } else {
+      eventsHandler.addSystemMessage('No agent connected. Cannot run task.');
+    }
+  }, [client, agent, agentId, eventsHandler, twoStep, onStop, onExit, onAgentUpdate, onContextSync, onOpenModelPicker, onOpenVaultPicker, onOpenVaultSetWizard, onOpenVaultRemoveWizard, onOpenMcpPicker, onOpenMcpTransportPicker, onOpenMcpServerPicker, onOpenTemplatePicker, onOpenTemplateAssignWizard, dispatch]);
+
+  return { handleSubmit, twoStepState: twoStep };
+}

package/src/tui/index.jsx

@@ -0,0 +1,55 @@
+import React from 'react';
+import { render } from 'ink';
+import { App } from './app.jsx';
+import { parseFlags } from '../commands/auth.js';
+import { isInteractive, pickAgent } from '../ui.js';
+
+export async function startTui(client, args) {
+  const flags = parseFlags(args);
+  let agentId = flags.agent || flags.id;
+  const debug = !!flags.debug;
+
+  if (!agentId) {
+    try {
+      const agents = await client.listAgents();
+      if (!agents || agents.length === 0) {
+        console.error('No agents found. Create one first: moxxy agent create');
+        process.exitCode = 1;
+        return;
+      }
+      if (agents.length === 1) {
+        agentId = agents[0].name;
+        console.log(`Auto-selected agent: ${agentId}`);
+      } else if (isInteractive()) {
+        agentId = await pickAgent(client, 'Select agent for chat');
+      } else {
+        console.error('Multiple agents found. Specify one: moxxy tui --agent <name>');
+        process.exitCode = 1;
+        return;
+      }
+    } catch (err) {
+      if (err.isGatewayDown) {
+        console.log(err.message);
+      } else {
+        console.error(`Failed to list agents: ${err.message}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const instance = render(
+    <App
+      client={client}
+      agentId={agentId}
+      debug={debug}
+      onExit={() => {
+        instance.unmount();
+        process.exit(0);
+      }}
+    />,
+    { exitOnCtrlC: false }
+  );
+
+  await instance.waitUntilExit();
+}

package/src/tui/input-utils.js

@@ -0,0 +1,26 @@
+export function resolveAutocompleteSelection(inputValue, matches, selectedIndex) {
+  if (!Array.isArray(matches) || matches.length === 0) return null;
+  const selected = matches[selectedIndex];
+  if (!selected?.name) return null;
+
+  const current = String(inputValue || '').trim();
+  if (!current.startsWith('/')) return null;
+  if (current === selected.name) return null;
+
+  return selected.name;
+}
+
+export function clampAutocompleteScroll(selectedIndex, scrollOffset, visibleRows, totalCount) {
+  if (!visibleRows || visibleRows <= 0) return 0;
+
+  const total = Math.max(0, Number(totalCount) || 0);
+  const viewport = Math.max(1, Number(visibleRows) || 1);
+  const maxScroll = Math.max(0, total - viewport);
+  const selected = Math.max(0, Math.min(Math.max(0, Number(selectedIndex) || 0), Math.max(0, total - 1)));
+  const scroll = Math.max(0, Math.min(Math.max(0, Number(scrollOffset) || 0), maxScroll));
+  const end = scroll + viewport - 1;
+
+  if (selected < scroll) return selected;
+  if (selected > end) return Math.min(selected - viewport + 1, maxScroll);
+  return scroll;
+}

package/src/tui/markdown-renderer.js

@@ -0,0 +1,66 @@
+import { marked } from 'marked';
+
+/**
+ * Render markdown content as an array of plain text strings.
+ * Used for simple text extraction. The TUI chat panel handles
+ * display formatting directly via pi-tui's wrapTextWithAnsi.
+ *
+ * @param {string} content - Raw markdown string
+ * @returns {string[]} Array of text lines
+ */
+export function renderMarkdown(content) {
+  if (!content) return [''];
+
+  const tokens = marked.lexer(content);
+  const lines = [];
+
+  for (const token of tokens) {
+    const tokenLines = renderToken(token);
+    lines.push(...tokenLines);
+  }
+
+  return lines.length > 0 ? lines : [''];
+}
+
+function renderToken(token) {
+  switch (token.type) {
+    case 'heading':
+      return ['#'.repeat(token.depth) + ' ' + stripInline(token.text)];
+
+    case 'paragraph':
+      return [stripInline(token.text)];
+
+    case 'code':
+      return [
+        (token.lang ? `[${token.lang}]` : ''),
+        token.text,
+      ].filter(Boolean);
+
+    case 'list':
+      return token.items.map((item, j) => {
+        const bullet = token.ordered ? `${j + 1}. ` : '- ';
+        return bullet + stripInline(item.text);
+      });
+
+    case 'blockquote':
+      return ['> ' + stripInline(token.text || '')];
+
+    case 'hr':
+      return ['---'];
+
+    case 'space':
+      return [''];
+
+    default:
+      return token.raw ? [token.raw.trim()] : [];
+  }
+}
+
+function stripInline(text) {
+  if (!text) return '';
+  return text
+    .replace(/\*\*(.+?)\*\*/g, '$1')
+    .replace(/\*(.+?)\*/g, '$1')
+    .replace(/`(.+?)`/g, '`$1`')
+    .replace(/\[(.+?)\]\((.+?)\)/g, '$1 ($2)');
+}