@velaro/cli 0.1.1 → 0.1.2

package/bin/velaro.js

@@ -8,6 +8,10 @@ import { botCommand }                           from '../lib/commands/bot.js';
 import { ingestCommand }                        from '../lib/commands/ingest.js';
 import { mcpKeyCommand }                        from '../lib/commands/mcp-key.js';
 import { statusCommand }                        from '../lib/commands/status.js';
+import { siteCommand }                          from '../lib/commands/site.js';
+import { workflowCommand }                      from '../lib/commands/workflow.js';
+import { ruleCommand }                          from '../lib/commands/rule.js';
+import { agentCommand }                         from '../lib/commands/agent.js';
 
 yargs(hideBin(process.argv))
   .scriptName('velaro')
@@ -15,7 +19,11 @@ yargs(hideBin(process.argv))
   .command(loginCommand)
   .command(logoutCommand)
   .command(whoamiCommand)
+  .command(siteCommand)
   .command(botCommand)
+  .command(workflowCommand)
+  .command(ruleCommand)
+  .command(agentCommand)
   .command(ingestCommand)
   .command(mcpKeyCommand)
   .command(statusCommand)

package/lib/commands/agent.js

@@ -0,0 +1,50 @@
+import { get, post }  from '../api.js';
+import { runCommand }  from '../run.js';
+
+const VALID_STATUSES = ['Available', 'Away', 'Offline'];
+
+export const agentCommand = {
+  command:  'agent <subcommand>',
+  describe: 'View and manage agents',
+  builder:  (yargs) => yargs
+    .command({
+      command:  'list',
+      describe: 'List agents and their current availability',
+      handler:  runCommand(async () => {
+        const [agents, teams] = await Promise.all([
+          get('/Users/List'),
+          get('/Teams/List'),
+        ]);
+
+        const teamMap = Object.fromEntries(teams.map(t => [t.id, t.name]));
+
+        if (!agents.length) { console.log('No agents found.'); return; }
+
+        const rows = agents.map(a => ({
+          id:     `[${a.id}]`,
+          status: (a.status ?? 'Offline').padEnd(9),
+          name:   a.displayName || `${a.firstName} ${a.lastName}`.trim() || a.email,
+          teams:  (a.teamIds ?? []).map(id => teamMap[id] ?? `team ${id}`).join(', ') || '—',
+        }));
+
+        const idW = Math.max(...rows.map(r => r.id.length));
+
+        for (const r of rows) {
+          console.log(`${r.id.padStart(idW)}  ${r.status}  ${r.name.padEnd(30)}  ${r.teams}`);
+        }
+        console.log(`\n${rows.length} agent(s)`);
+      }),
+    })
+    .command({
+      command:  'set-status',
+      describe: 'Set an agent\'s availability status (admin only)',
+      builder:  (y) => y
+        .option('id',     { type: 'number', demandOption: true, describe: 'Agent user ID' })
+        .option('status', { type: 'string', demandOption: true, describe: 'Available | Away | Offline', choices: VALID_STATUSES }),
+      handler: runCommand(async (argv) => {
+        await post('/UserStatus/admin', { userId: argv.id, status: argv.status });
+        console.log(`Agent ${argv.id} set to ${argv.status}.`);
+      }),
+    })
+    .demandCommand(1, 'Specify a subcommand: list | set-status'),
+};

package/lib/commands/rule.js

@@ -0,0 +1,28 @@
+import { get }       from '../api.js';
+import { runCommand } from '../run.js';
+
+export const ruleCommand = {
+  command:  'rule <subcommand>',
+  describe: 'Manage routing rules',
+  builder:  (yargs) => yargs
+    .command({
+      command:  'list',
+      describe: 'List all routing rules',
+      handler:  runCommand(async () => {
+        const rules = await get('/Rules/List');
+        if (!rules.length) { console.log('No routing rules found.'); return; }
+
+        const sorted = [...rules].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        const idW    = Math.max(...sorted.map(r => String(r.id).length + 2));
+
+        for (const r of sorted) {
+          const id      = `[${r.id}]`.padStart(idW);
+          const pri     = `priority ${r.priority ?? 0}`;
+          const trigger = r.trigger ?? '—';
+          console.log(`${id}  ${pri}  ${trigger}`);
+        }
+        console.log(`\n${sorted.length} rule(s)`);
+      }),
+    })
+    .demandCommand(1, 'Specify a subcommand: list'),
+};

package/lib/commands/site.js

@@ -0,0 +1,62 @@
+import { get }       from '../api.js';
+import { runCommand } from '../run.js';
+
+const FEATURE_MAP = {
+  enableWeb:                'Web Chat',
+  enableSms:                'SMS',
+  enableEmail:              'Email',
+  enableWhatsapp:           'WhatsApp',
+  enableIvr:                'IVR / Voice',
+  enableFacebook:           'Facebook Messenger',
+  enableInstagram:          'Instagram',
+  enableAI:                 'AI Bots',
+  enableKnowledgeBase:      'Knowledge Base',
+  enableAutomation:         'Workflows',
+  enableWorkflowRules:      'Routing Rules',
+  enableChatTranslations:   'Chat Translation',
+  enableVideoChat:          'Video Chat',
+  enableTicketing:          'Ticketing',
+  enableAgentDashboard:     'Agent Dashboard',
+  enableMcpApi:             'MCP API Gateway',
+  enableOutboundCampaigns:  'Email Campaigns',
+  enableRcs:                'RCS Messaging',
+  enablePageWidgets:        'Page Widgets',
+  enableVisitorTracking:    'Visitor Tracking',
+};
+
+const STATUS_LABEL = { Available: 'online', Away: 'away', Offline: 'offline' };
+
+export const siteCommand = {
+  command:  'site',
+  describe: 'Show site overview: active features and agent availability',
+  handler:  runCommand(async () => {
+    const [sub, agents] = await Promise.all([
+      get('/Subscription'),
+      get('/Users/List'),
+    ]);
+
+    // Active features — friendly names only, no internal flag names
+    const active = Object.entries(FEATURE_MAP)
+      .filter(([key]) => sub[key] === true)
+      .map(([, label]) => label);
+
+    console.log('\nActive features:');
+    if (active.length) {
+      console.log('  ' + active.join('  ·  '));
+    } else {
+      console.log('  (none)');
+    }
+
+    if (sub.maxCreatedUsers) {
+      console.log(`\nAgent seats: ${sub.maxCreatedUsers} licensed`);
+    }
+
+    // Agent availability summary
+    const counts = { online: 0, away: 0, offline: 0 };
+    for (const a of agents) {
+      const key = STATUS_LABEL[a.status] ?? 'offline';
+      counts[key]++;
+    }
+    console.log(`Agent status: ${counts.online} online · ${counts.away} away · ${counts.offline} offline\n`);
+  }),
+};

package/lib/commands/workflow.js

@@ -0,0 +1,32 @@
+import { get }       from '../api.js';
+import { runCommand } from '../run.js';
+
+export const workflowCommand = {
+  command:  'workflow <subcommand>',
+  describe: 'Manage workflows',
+  builder:  (yargs) => yargs
+    .command({
+      command:  'list',
+      describe: 'List all workflows',
+      handler:  runCommand(async () => {
+        const workflows = await get('/Workflows/List');
+        if (!workflows.length) { console.log('No workflows found.'); return; }
+
+        const rows = workflows.filter(w => !w.isTemplate).map(w => ({
+          id:      `[${w.id}]`,
+          status:  w.enabled ? 'enabled ' : 'disabled',
+          trigger: w.triggerType ?? '—',
+          name:    w.name,
+        }));
+
+        const idW      = Math.max(...rows.map(r => r.id.length));
+        const triggerW = Math.max(...rows.map(r => r.trigger.length));
+
+        for (const r of rows) {
+          console.log(`${r.id.padStart(idW)}  ${r.status}  ${r.trigger.padEnd(triggerW)}  ${r.name}`);
+        }
+        console.log(`\n${rows.length} workflow(s)`);
+      }),
+    })
+    .demandCommand(1, 'Specify a subcommand: list'),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velaro/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Velaro Workspace v20 — command-line interface for managing bots, knowledge base ingestion, and MCP API keys.",
   "type": "module",
   "bin": {