@velaro/cli 1.4.67 → 1.4.69

package/lib/commands/focus.js

@@ -220,19 +220,39 @@ const triageRulesCommand = {
 };
 
 const setTriageRuleCommand = {
-  command:  'set-triage-rule <label> <enabled>',
-  describe: `Enable or disable one fixed AI triage label (${VALID_LABELS.join(', ')})`,
+  command:  'set-triage-rule [label] [enabled]',
+  describe: `Enable/disable one fixed AI triage label (${VALID_LABELS.join(', ')}) and/or set --triage-mode`,
   builder:  (y) => y
     .positional('label',   { type: 'string', describe: `Label: ${VALID_LABELS.join(', ')}` })
-    .positional('enabled', { type: 'string', describe: 'true or false', choices: ['true', 'false'] }),
+    .positional('enabled', { type: 'string', describe: 'true or false', choices: ['true', 'false'] })
+    .option('triage-mode', { type: 'string', choices: ['off', 'economy'], describe: 'off (default) or economy (skip AI call for obvious messages)' }),
   handler:  async (argv) => {
     const { label, enabled } = argv;
-    if (!VALID_LABELS.includes(label)) {
-      console.error(`Invalid label "${label}". Valid values: ${VALID_LABELS.join(', ')}`);
+    const mode = argv['triage-mode'];
+    if (!label && !mode) {
+      console.error('Provide <label> <enabled> and/or --triage-mode <off|economy>.');
       process.exit(1);
     }
-    const result = await messagingPut('/Focus/triage-rules', [{ Label: label, Enabled: enabled === 'true' }]);
-    console.log(`\n  ${GRN}✓${RESET} Label "${label}" ${enabled === 'true' ? 'enabled' : 'disabled'}. Effective labels: ${(result?.effectiveLabels ?? []).join(', ')}\n`);
+    let labels;
+    if (label) {
+      if (!VALID_LABELS.includes(label)) {
+        console.error(`Invalid label "${label}". Valid values: ${VALID_LABELS.join(', ')}`);
+        process.exit(1);
+      }
+      if (enabled !== 'true' && enabled !== 'false') {
+        console.error('<enabled> must be true or false.');
+        process.exit(1);
+      }
+      labels = [{ Label: label, Enabled: enabled === 'true' }];
+    }
+    const body = mode ? { ...(labels ? { labels } : {}), triageMode: mode } : labels;
+    const result = await messagingPut('/Focus/triage-rules', body);
+    if (label) console.log(`
+  ${GRN}✓${RESET} Label "${label}" ${enabled === 'true' ? 'enabled' : 'disabled'}.`);
+    if (mode) console.log(`
+  ${GRN}✓${RESET} Triage mode set to ${mode}.`);
+    console.log(`  Effective labels: ${(result?.effectiveLabels ?? []).join(', ')}
+`);
   },
 };
 

package/lib/commands/routing.js

@@ -1,4 +1,5 @@
 import { messagingGet, messagingPut, messagingPost, messagingDel, get as adminGet } from '../api.js';
+import { teamConfigPath, buildTeamConfigBody, parseExtraJson } from '../routing-team-config.js';
 import {
   TERMINAL_ACTION_NAMES, buildPolicyUpdate, validatePolicyUpdate, describeChain,
   describeSimulation, describeTransfers, validateAdvancedUpdate,
@@ -391,6 +392,69 @@ const inactivityTransfersCommand = {
   },
 };
 
+// ── velaro routing team-config get|set ────────────────────────────────────────
+
+const teamConfigGetCommand = {
+  command:  'get',
+  describe: 'Show team-level routing config (omit --team for the site default row)',
+  builder:  (y) => y.option('team', { type: 'number', describe: 'Team (group) id' }),
+  handler:  async (argv) => {
+    const r = await messagingGet(teamConfigPath(argv.team));
+    console.log(JSON.stringify(r, null, 2));
+  },
+};
+
+const teamConfigSetCommand = {
+  command:  'set',
+  describe: 'Partially update team-level routing config (only passed fields change)',
+  builder:  (y) => y
+    .option('team', { type: 'number', describe: 'Team (group) id (omit for the site default row)' })
+    .option('routing-type', { type: 'string', describe: 'roundRobin | leastBusy | longestIdle (not validated here)' })
+    .option('routing-action', { type: 'string', describe: 'Routing action (server-validated)' })
+    .option('queue-timeout-enabled', { type: 'boolean' })
+    .option('queue-timeout-minutes', { type: 'number' })
+    .option('prioritize-agents', { type: 'boolean' })
+    .option('idle-alert-enabled', { type: 'boolean' })
+    .option('idle-alert-after', { type: 'number', describe: 'Minutes' })
+    .option('idle-alert-repeat', { type: 'number', describe: 'Minutes' })
+    .option('idle-alert-max', { type: 'number', describe: 'Max alerts per conversation' })
+    .option('idle-alert-title', { type: 'string' })
+    .option('idle-alert-body', { type: 'string' })
+    .option('schedule-aware', { type: 'boolean' })
+    .option('extra', { type: 'string', describe: 'JSON object of any other RoutingConfig fields, passed through as-is' }),
+  handler:  async (argv) => {
+    let body;
+    try {
+      body = buildTeamConfigBody({
+        routingType: argv['routing-type'], routingAction: argv['routing-action'],
+        queueTimeoutEnabled: argv['queue-timeout-enabled'], queueTimeoutMinutes: argv['queue-timeout-minutes'],
+        prioritizeAgents: argv['prioritize-agents'],
+        idleQueueAlertEnabled: argv['idle-alert-enabled'], idleQueueAlertAfterMinutes: argv['idle-alert-after'],
+        idleQueueAlertRepeatMinutes: argv['idle-alert-repeat'], idleQueueAlertMaxPerConversation: argv['idle-alert-max'],
+        idleQueueAlertTitle: argv['idle-alert-title'], idleQueueAlertBody: argv['idle-alert-body'],
+        scheduleAwareRoutingEnabled: argv['schedule-aware'],
+      }, parseExtraJson(argv.extra));
+    } catch (e) {
+      console.error(`  ${RED}x${RESET} ${e.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    await messagingPut(teamConfigPath(argv.team), body);
+    console.log(`\n  ${GRN}✓${RESET} Team routing config updated.\n`);
+  },
+};
+
+const teamConfigCommand = {
+  command:  'team-config <subcommand>',
+  describe: 'Get/update team-level routing config (routing type, queue timeout, idle alerts)',
+  builder:  (y) => y
+    .command(teamConfigGetCommand)
+    .command(teamConfigSetCommand)
+    .demandCommand(1, 'Specify a subcommand: get, set')
+    .strict(),
+  handler:  () => {},
+};
+
 // ── top-level routing command ─────────────────────────────────────────────────
 
 export const routingCommand = {
@@ -400,12 +464,13 @@ export const routingCommand = {
     .command(engineCommand)
     .command(circuitBreakerCommand)
     .command(policyCommand)
+    .command(teamConfigCommand)
     .command(decisionLogCommand)
     .command(explainCommand)
     .command(simulateCommand)
     .command(precedenceCommand)
     .command(inactivityTransfersCommand)
-    .demandCommand(1, 'Specify a subcommand: engine, circuit-breaker, policy, decision-log, explain, simulate, precedence, inactivity-transfers')
+    .demandCommand(1, 'Specify a subcommand: engine, circuit-breaker, policy, team-config, decision-log, explain, simulate, precedence, inactivity-transfers')
     .strict(),
   handler:  () => {},
 };

package/lib/routing-team-config.js

@@ -0,0 +1,37 @@
+// Team-level RoutingConfig helpers (REST: messaging GET/PUT /RoutingConfig?teamId=).
+// Partial update, apply-if-present. Unknown fields pass through so new server fields
+// (e.g. routingType "longestIdle", queue-broadcast, CRM-owner) work without a CLI release.
+
+const KNOWN = [
+  'routingType', 'routingAction', 'queueTimeoutEnabled', 'queueTimeoutMinutes', 'prioritizeAgents',
+  'idleQueueAlertEnabled', 'idleQueueAlertAfterMinutes', 'idleQueueAlertRepeatMinutes',
+  'idleQueueAlertMaxPerConversation', 'idleQueueAlertTitle', 'idleQueueAlertBody',
+  'scheduleAwareRoutingEnabled',
+];
+
+export function teamConfigPath(teamId) {
+  if (teamId === undefined || teamId === null || teamId === '') return '/RoutingConfig';
+  const n = Number(teamId);
+  if (!Number.isInteger(n) || n <= 0) throw new Error('teamId must be a positive integer.');
+  return `/RoutingConfig?teamId=${n}`;
+}
+
+// Build the PUT body: known fields from args + any extra object, dropping undefined.
+// null is kept (it means "inherit" server-side). No enum validation on purpose.
+export function buildTeamConfigBody(args = {}, extra = {}) {
+  const body = {};
+  for (const k of KNOWN) if (args[k] !== undefined) body[k] = args[k];
+  for (const [k, v] of Object.entries(extra || {})) if (v !== undefined) body[k] = v;
+  if (!Object.keys(body).length) throw new Error('No fields to update. Pass at least one field.');
+  return body;
+}
+
+export function parseExtraJson(text) {
+  if (text === undefined) return {};
+  let v;
+  try { v = JSON.parse(text); } catch (e) { throw new Error(`--extra must be valid JSON: ${e.message}`); }
+  if (!v || typeof v !== 'object' || Array.isArray(v)) throw new Error('--extra must be a JSON object.');
+  return v;
+}
+
+export const TEAM_CONFIG_FIELDS = KNOWN;

package/lib/routing-team-config.test.js

@@ -0,0 +1,23 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { teamConfigPath, buildTeamConfigBody, parseExtraJson } from './routing-team-config.js';
+
+test('path scopes by teamId and rejects junk', () => {
+  assert.equal(teamConfigPath(), '/RoutingConfig');
+  assert.equal(teamConfigPath(7), '/RoutingConfig?teamId=7');
+  assert.throws(() => teamConfigPath('abc'));
+  assert.throws(() => teamConfigPath(0));
+});
+
+test('body is partial, keeps null, passes new values and unknown fields through', () => {
+  const b = buildTeamConfigBody({ routingType: 'longestIdle', queueTimeoutMinutes: null }, { queueBroadcast: true });
+  assert.deepEqual(b, { routingType: 'longestIdle', queueTimeoutMinutes: null, queueBroadcast: true });
+  assert.throws(() => buildTeamConfigBody({}));
+});
+
+test('extra json must be an object', () => {
+  assert.deepEqual(parseExtraJson(undefined), {});
+  assert.deepEqual(parseExtraJson('{"a":1}'), { a: 1 });
+  assert.throws(() => parseExtraJson('[1]'));
+  assert.throws(() => parseExtraJson('{'));
+});

package/package.json

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