@moxxy/cli 1.2.7 → 1.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxxy/cli",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "CLI for the Moxxy agentic framework — manage agents, skills, plugins, channels, and vaults from the terminal",
   "type": "module",
   "license": "MIT",

package/src/cli.js

@@ -222,7 +222,9 @@ async function main() {
     setup:        { label: 'Setup',        hint: 'init, gateway, doctor' },
     agents:       { label: 'Agents',       hint: 'agents, skills, templates' },
     security:     { label: 'Security',     hint: 'auth tokens & secrets' },
-    integrations: { label: 'Integrations', hint: 'providers, channels, MCP, plugins' },
+    integrations: { label: 'Integrations', hint: 'channels, MCP' },
+    providers:    { label: 'Providers',    hint: 'manage AI providers' },
+    plugins:      { label: 'Plugins',      hint: 'manage plugins & extensions' },
     tools:        { label: 'Tools',        hint: 'events stream' },
     system:       { label: 'System',       hint: 'settings, update & uninstall' },
   };
@@ -243,12 +245,16 @@ async function main() {
       { value: 'vault',     label: 'Vault',     hint: 'manage secrets' },
     ],
     integrations: [
-      { value: 'provider',  label: 'Provider',  hint: 'list providers' },
       { value: 'channel',   label: 'Channel',   hint: 'manage Telegram/Discord channels' },
       { value: 'mcp',       label: 'MCP',       hint: 'manage MCP servers for agents' },
-      { value: 'plugin',    label: 'Plugin',    hint: 'manage plugins & extensions' },
       { value: 'heartbeat', label: 'Heartbeat', hint: 'schedule heartbeat rules' },
     ],
+    providers: [
+      { value: 'provider',  label: 'Provider',  hint: 'list providers' },
+    ],
+    plugins: [
+      { value: 'plugin',    label: 'Plugin',    hint: 'manage plugins & extensions' },
+    ],
     tools: [
       { value: 'events',    label: 'Events',    hint: 'stream live events' },
     ],
@@ -298,13 +304,18 @@ async function main() {
       const submenu = SUBMENUS[selected];
       if (!submenu) continue;
 
-      const subSelected = await p.select({
-        message: `${MENU_GROUPS[selected].label}`,
-        options: submenu,
-      });
+      let subSelected;
+      if (submenu.length === 1) {
+        subSelected = submenu[0].value;
+      } else {
+        subSelected = await p.select({
+          message: `${MENU_GROUPS[selected].label}`,
+          options: submenu,
+        });
 
-      if (p.isCancel(subSelected)) {
-        continue;
+        if (p.isCancel(subSelected)) {
+          continue;
+        }
       }
 
       try {

package/src/commands/channel.js

@@ -1,9 +1,24 @@
-import { p, handleCancel, withSpinner, showResult } from '../ui.js';
+import { p, handleCancel, isInteractive, withSpinner, showResult } from '../ui.js';
 import { showHelp } from '../help.js';
 import { parseFlags } from './auth.js';
 
 export async function runChannel(client, args) {
-  const [subcommand, ...rest] = args;
+  let [subcommand, ...rest] = args;
+
+  if (!subcommand && isInteractive()) {
+    subcommand = await p.select({
+      message: 'Channel action',
+      options: [
+        { value: 'list',     label: 'List channels',   hint: 'show registered channels' },
+        { value: 'create',   label: 'Create channel',  hint: 'register a new channel' },
+        { value: 'pair',     label: 'Pair channel',     hint: 'bind a channel to an agent' },
+        { value: 'bindings', label: 'List bindings',    hint: 'show channel-agent bindings' },
+        { value: 'unbind',   label: 'Unbind channel',   hint: 'remove a channel-agent binding' },
+        { value: 'delete',   label: 'Delete channel',   hint: 'remove a channel' },
+      ],
+    });
+    handleCancel(subcommand);
+  }
 
   switch (subcommand) {
     case 'create':

package/src/commands/provider.js

@@ -340,27 +340,30 @@ function sleep(ms) {
 }
 
 function tryOpenUrl(url) {
-  let cmd;
-  let args;
+  const candidates = [];
 
   if (process.platform === 'darwin') {
-    cmd = 'open';
-    args = [url];
+    candidates.push({ cmd: 'open', args: [url] });
   } else if (process.platform === 'win32') {
-    cmd = 'cmd';
-    args = ['/c', 'start', '', url];
+    candidates.push({ cmd: 'cmd', args: ['/c', 'start', '', url] });
   } else {
-    cmd = 'xdg-open';
-    args = [url];
+    candidates.push(
+      { cmd: 'xdg-open', args: [url] },
+      { cmd: 'sensible-browser', args: [url] },
+      { cmd: 'x-www-browser', args: [url] },
+    );
   }
 
-  try {
-    const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
-    child.unref();
-    return true;
-  } catch {
-    return false;
+  for (const { cmd, args } of candidates) {
+    try {
+      const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+      child.unref();
+      return true;
+    } catch {
+      // try next candidate
+    }
   }
+  return false;
 }
 
 function createCodeVerifier() {

package/src/tui/components/messages/skill-message.jsx

@@ -3,29 +3,59 @@ import { Box, Text } from 'ink';
 import { THEME } from '../../theme.js';
 
 export function SkillMessage({ msg, showDetails = false }) {
-  let icon = '⚡';
-  let color = THEME.warning;
+  const isRunning = msg.status === 'running';
+  const isError = msg.status === 'error';
+  const steps = msg.steps || [];
 
+  // Header icon and color
+  let headerIcon = '⊞';
+  let headerColor = THEME.primary;
   if (msg.status === 'completed') {
-    icon = '✓';
-    color = THEME.success;
-  } else if (msg.status === 'error') {
-    icon = '✗';
-    color = THEME.error;
+    headerIcon = '✓';
+    headerColor = THEME.success;
+  } else if (isError) {
+    headerIcon = '✗';
+    headerColor = THEME.error;
   }
 
+  // Header text
+  const headerText = isRunning
+    ? `Invoking ${msg.name}...`
+    : msg.name;
+
   return (
     <Box flexDirection="column">
       <Text>
-        <Text color={color}>{icon}</Text>
-        <Text bold color={color}> {msg.name}</Text>
-        <Text color={THEME.dim}> skill</Text>
-        {msg.status === 'running' && <Text color={THEME.dim}> …</Text>}
-        {msg.error ? <Text color={THEME.error}> - {msg.error}</Text> : null}
+        <Text color={headerColor}>{headerIcon}</Text>
+        <Text bold color={headerColor}> {headerText}</Text>
+        {isError && msg.error ? <Text color={THEME.error}> - {msg.error}</Text> : null}
       </Text>
-      {showDetails && msg.description ? (
-        <Text color={THEME.dim}>  {msg.description}</Text>
-      ) : null}
+      {steps.map((step, i) => {
+        let stepIcon = '◷';
+        let stepColor = THEME.dim;
+        if (step.status === 'completed') {
+          stepIcon = '◷';
+          stepColor = THEME.dim;
+        } else if (step.status === 'error') {
+          stepIcon = '✗';
+          stepColor = THEME.error;
+        } else {
+          stepIcon = '⏳';
+          stepColor = THEME.warning;
+        }
+        const resultText = step.error
+          ? step.error
+          : step.result
+            ? (step.result.length > 60 ? step.result.slice(0, 60) + '…' : step.result)
+            : null;
+        return (
+          <Text key={i}>
+            <Text color={stepColor}>{stepIcon}</Text>
+            <Text bold> {step.name}</Text>
+            {resultText ? <Text color={THEME.dim}> → {resultText}</Text> : null}
+          </Text>
+        );
+      })}
     </Box>
   );
 }

package/src/tui/components/messages/tool-group.jsx

@@ -24,13 +24,17 @@ export function ToolGroup({ messages, expanded = false }) {
 
   const icon = errors > 0 ? '✗' : '✓';
   const color = errors > 0 ? THEME.error : THEME.success;
-  const skills = messages.filter(m => m.type === 'skill').length;
+  const skillMsgs = messages.filter(m => m.type === 'skill');
   const tools = messages.filter(m => m.type === 'tool').length;
+  // Count total steps across all skills
+  const skillSteps = skillMsgs.reduce((sum, m) => sum + (m.steps ? m.steps.length : 0), 0);
   const parts = [];
-  if (tools > 0) parts.push(`${tools} tool${tools > 1 ? 's' : ''}`);
-  if (skills > 0) parts.push(`${skills} skill${skills > 1 ? 's' : ''}`);
+  const totalTools = tools + skillSteps;
+  if (totalTools > 0) parts.push(`${totalTools} tool${totalTools > 1 ? 's' : ''}`);
+  if (skillMsgs.length > 0) parts.push(`${skillMsgs.length} skill${skillMsgs.length > 1 ? 's' : ''}`);
   const label = parts.join(', ');
-  const detail = errors > 0 ? `${completed} done, ${errors} failed` : `${completed} done`;
+  const totalDone = completed + skillSteps;
+  const detail = errors > 0 ? `${totalDone} done, ${errors} failed` : `${totalDone} done`;
 
   if (!expanded) {
     return (

package/src/tui/events-handler.js

@@ -8,9 +8,10 @@ const ERROR_EVENTS = new Set([
 ]);
 
 // Error events that should be shown as user-friendly system messages
-// instead of raw event brackets (brackets only in debug mode)
+// instead of raw event brackets (brackets only in debug mode).
+// NOTE: primitive.failed is handled separately (with skill awareness) before this check.
 const FRIENDLY_ERROR_EVENTS = new Set([
-  'run.failed', 'primitive.failed',
+  'run.failed',
 ]);
 
 // Tool activity events always shown in chat as compact messages
@@ -104,6 +105,7 @@ export class EventsHandler {
     this._thinkingTimer = null;
     this.pendingAsk = null; // { questionId, question } = set when agent asks user
     this._subAgents = new Map(); // agentId -> { name, task, buffer, status }
+    this._activeSkillIdx = null; // index into this.messages for the running skill
     this._hiveStatus = null; // aggregated hive status tracker
     this._version = 0;
     this.messageVersion = 0;
@@ -597,6 +599,14 @@ export class EventsHandler {
         clearTimeout(this._deltaTimer);
         this._deltaTimer = null;
       }
+      // Close active skill session on final message
+      if (this._activeSkillIdx != null) {
+        const skill = this.messages[this._activeSkillIdx];
+        if (skill && skill.status === 'running') {
+          skill.status = 'completed';
+        }
+        this._activeSkillIdx = null;
+      }
       const finalContent = payload.content || payload.text || this._assistantBuffer;
       this._assistantBuffer = '';
       const last = this.messages[this.messages.length - 1];
@@ -614,6 +624,14 @@ export class EventsHandler {
     // Stop thinking on run completion or errors
     if (type === 'run.completed' || type === 'run.failed') {
       if (this.thinking) this._stopThinking();
+      // Close active skill session on run end
+      if (this._activeSkillIdx != null) {
+        const skill = this.messages[this._activeSkillIdx];
+        if (skill) {
+          skill.status = type === 'run.failed' ? 'error' : 'completed';
+        }
+        this._activeSkillIdx = null;
+      }
     }
 
     // Silence errors for hidden tool prefixes (e.g. agent.*)
@@ -621,6 +639,58 @@ export class EventsHandler {
       return;
     }
 
+    // Handle primitive.failed with skill awareness BEFORE friendly error fallback
+    if (type === 'primitive.failed') {
+      const toolName = payload.name || 'unknown';
+      const errorMsg = payload.error || 'unknown error';
+
+      // skill.execute itself failed → mark the skill as error and close session
+      if (toolName === 'skill.execute' && this._activeSkillIdx != null) {
+        const skill = this.messages[this._activeSkillIdx];
+        if (skill) {
+          skill.status = 'error';
+          skill.error = errorMsg;
+        }
+        this._activeSkillIdx = null;
+        this.messageVersion++;
+        this._notify();
+        return;
+      }
+
+      // A tool within an active skill failed → mark the step as error
+      if (this._activeSkillIdx != null) {
+        const skill = this.messages[this._activeSkillIdx];
+        if (skill && skill.status === 'running') {
+          const step = [...skill.steps].reverse().find(s => s.name === toolName && s.status === 'running');
+          if (step) {
+            step.status = 'error';
+            step.error = errorMsg;
+            this.messageVersion++;
+            this._notify();
+            return;
+          }
+        }
+      }
+
+      // Update the last tool message for the same primitive if it was just invoked
+      const last = this.messages[this.messages.length - 1];
+      if (last && last.type === 'tool' && last.name === toolName && last.status === 'invoked') {
+        last.status = 'error';
+        last.error = errorMsg;
+        this.messageVersion++;
+        this._notify();
+        return;
+      }
+
+      // Fallback: show as friendly system message (non-debug mode)
+      if (!this.debug) {
+        this.messages.push({ type: 'system', content: `Tool error: ${errorMsg}`, ts: event.ts });
+        this.messageVersion++;
+        this._notify();
+        return;
+      }
+    }
+
     // For user-facing error events, show as a friendly system message
     // (raw event format only in debug mode)
     if (!this.debug && FRIENDLY_ERROR_EVENTS.has(type)) {
@@ -636,8 +706,48 @@ export class EventsHandler {
     if (TOOL_ACTIVITY_EVENTS.has(type)) {
       if (type === 'primitive.invoked') {
         if (isHiddenTool(payload.name || '')) return;
+        const toolName = payload.name || 'unknown';
+
+        // Detect skill.execute → start a skill session
+        if (toolName === 'skill.execute') {
+          // Parse arguments — may be an object or a JSON string
+          let args = payload.arguments;
+          if (typeof args === 'string') {
+            try { args = JSON.parse(args); } catch { args = {}; }
+          }
+          const skillName = (args && args.name) || 'unknown';
+
+          // Close any previous active skill
+          if (this._activeSkillIdx != null) {
+            const prev = this.messages[this._activeSkillIdx];
+            if (prev && prev.status === 'running') {
+              prev.status = 'completed';
+            }
+          }
+
+          this.messages.push({
+            type: 'skill', name: skillName, status: 'running',
+            steps: [], ts: event.ts,
+          });
+          this._activeSkillIdx = this.messages.length - 1;
+          this.messageVersion++;
+          this._notify();
+          return;
+        }
+
+        // If a skill is active, nest this tool as a step
+        if (this._activeSkillIdx != null) {
+          const skill = this.messages[this._activeSkillIdx];
+          if (skill && skill.status === 'running') {
+            skill.steps.push({ name: toolName, status: 'running', result: null });
+            this.messageVersion++;
+            this._notify();
+            return;
+          }
+        }
+
         this.messages.push({
-          type: 'tool', name: payload.name || 'unknown', status: 'invoked',
+          type: 'tool', name: toolName, status: 'invoked',
           arguments: formatParams(payload.arguments),
           rawArguments: payload.arguments,
           ts: event.ts,
@@ -648,9 +758,41 @@ export class EventsHandler {
       }
       if (type === 'primitive.completed') {
         if (isHiddenTool(payload.name || '')) return;
+        const toolName = payload.name || 'unknown';
+
+        // skill.execute completed → just absorb (skill stays running for subsequent tools)
+        if (toolName === 'skill.execute') {
+          // Update skill name from result if available
+          if (this._activeSkillIdx != null) {
+            const skill = this.messages[this._activeSkillIdx];
+            const resultName = payload.result && typeof payload.result === 'object' && payload.result.name;
+            if (skill && resultName) {
+              skill.name = resultName;
+            }
+          }
+          this.messageVersion++;
+          this._notify();
+          return;
+        }
+
+        // If a skill is active, update the step
+        if (this._activeSkillIdx != null) {
+          const skill = this.messages[this._activeSkillIdx];
+          if (skill && skill.status === 'running') {
+            const step = [...skill.steps].reverse().find(s => s.name === toolName && s.status === 'running');
+            if (step) {
+              step.status = 'completed';
+              step.result = formatParams(payload.result);
+            }
+            this.messageVersion++;
+            this._notify();
+            return;
+          }
+        }
+
         // Update the last tool message for the same primitive if it was just invoked
         const last = this.messages[this.messages.length - 1];
-        if (last && last.type === 'tool' && last.name === (payload.name || 'unknown') && last.status === 'invoked') {
+        if (last && last.type === 'tool' && last.name === toolName && last.status === 'invoked') {
           last.status = 'completed';
           last.result = formatParams(payload.result);
           last.rawResult = payload.result;
@@ -663,10 +805,18 @@ export class EventsHandler {
 
     // Show skill activity events as compact bordered messages
     if (type === 'skill.invoked') {
+      // Close any previous active skill
+      if (this._activeSkillIdx != null) {
+        const prev = this.messages[this._activeSkillIdx];
+        if (prev && prev.status === 'running') {
+          prev.status = 'completed';
+        }
+      }
       this.messages.push({
         type: 'skill', name: payload.name || 'unknown', status: 'running',
-        description: payload.description || '', ts: event.ts,
+        steps: [], ts: event.ts,
       });
+      this._activeSkillIdx = this.messages.length - 1;
       this.messageVersion++;
       this._notify();
       return;
@@ -680,6 +830,7 @@ export class EventsHandler {
           break;
         }
       }
+      this._activeSkillIdx = null;
       this.messageVersion++;
       this._notify();
       return;
@@ -699,27 +850,15 @@ export class EventsHandler {
       if (!found) {
         this.messages.push({
           type: 'skill', name: payload.name || 'unknown', status: 'error',
-          error: payload.error || 'unknown error', ts: event.ts,
+          error: payload.error || 'unknown error', steps: [], ts: event.ts,
         });
       }
+      this._activeSkillIdx = null;
       this.messageVersion++;
       this._notify();
       return;
     }
 
-    // Show tool error events
-    if (type === 'primitive.failed') {
-      // Update the last tool message for the same primitive if it was just invoked
-      const last = this.messages[this.messages.length - 1];
-      if (last && last.type === 'tool' && last.name === (payload.name || 'unknown') && last.status === 'invoked') {
-        last.status = 'error';
-        last.error = payload.error || 'unknown error';
-        this.messageVersion++;
-        this._notify();
-        return;
-      }
-    }
-
     // Show error events always; show all events in debug mode
     if (ERROR_EVENTS.has(type) || this.debug) {
       this.messages.push({ type: 'event', eventType: type, payload, ts: event.ts });