@velaro/cli 1.4.96 → 1.4.98

package/bin/velaro.js

@@ -10,10 +10,12 @@ import { botCommand }        from '../lib/commands/bot.js';
 import { indexCommand }      from '../lib/commands/index.js';
 import { ingestCommand }     from '../lib/commands/ingest.js';
 import { indexMoveCommand }  from '../lib/commands/index-move.js';
+import { safetyCommand }     from '../lib/commands/safety.js';
 import { knowledgeAdvisorCommand } from '../lib/commands/knowledge-advisor.js';
 import { productCommand }    from '../lib/commands/product.js';
 import { mcpKeyCommand }     from '../lib/commands/mcp-key.js';
 import { opsCommand }        from '../lib/commands/ops.js';
+import { deployStateCommand } from '../lib/commands/deploy-state.js';
 import { checkCommand }      from '../lib/commands/check.js';
 import { logsCommand }       from '../lib/commands/logs.js';
 import { aiModelsCommand }   from '../lib/commands/ai-models.js';
@@ -109,6 +111,7 @@ import { paymentRecoveryCommand }   from '../lib/commands/payment-recovery.js';
 import { recruitingCommand }        from '../lib/commands/recruiting.js';
 import { surveyCommand }            from '../lib/commands/survey.js';
 import { bundleCommand }            from '../lib/commands/bundle.js';
+import { chatWindowCommand }        from '../lib/commands/chat-window.js';
 import { featureDiscoveryCommand }  from '../lib/commands/feature-discovery.js';
 import { tourPolicyCommand }  from '../lib/commands/tour-policy.js';
 import { scraperCommand }      from '../lib/commands/scraper.js';
@@ -141,10 +144,12 @@ await yargs(hideBin(process.argv))
   .command(indexCommand)
   .command(ingestCommand)
   .command(indexMoveCommand)
+  .command(safetyCommand)
   .command(knowledgeAdvisorCommand)
   .command(productCommand)
   .command(mcpKeyCommand)
   .command(opsCommand)
+  .command(deployStateCommand)
   .command(checkCommand)
   .command(logsCommand)
   .command(aiModelsCommand)
@@ -242,6 +247,7 @@ await yargs(hideBin(process.argv))
   .command(recruitingCommand)
   .command(surveyCommand)
   .command(bundleCommand)
+  .command(chatWindowCommand)
   .command({ command: 'feature-discovery', desc: 'View and act on feature-discovery suggestions for this site', builder: featureDiscoveryCommand, handler: () => {} })
   .command({ command: 'scraper', desc: 'Velaro staff: scraper / upload / chunk usage for any site', builder: scraperCommand, handler: () => {} })
   .command({ command: 'tour-policy', desc: 'Velaro staff: guided-tour auto-open policy (versioned, rollback-able)', builder: tourPolicyCommand, handler: () => {} })

package/lib/commands/canned-learning.js

@@ -3,22 +3,25 @@ import { runCommand } from '../run.js';
 
 const print = (data) => console.log(JSON.stringify(data, null, 2));
 
-// velaro canned-learning <list|generate|approve|reject|rollback|edits|record-edit>  (REST: messaging /CannedLearning/*)
+// velaro canned-learning <list|generate|approve|reject|rollback|edits|record-edit|teams>  (REST: messaging /CannedLearning/*)
 export const cannedLearningCommand = {
   command: 'canned-learning <action> [id]',
   describe: 'AI canned message learning: list/generate suggestions, approve/reject/rollback (human review)',
   builder: (y) => y
-    .positional('action', { choices: ['list', 'generate', 'approve', 'reject', 'rollback', 'edits', 'record-edit'] })
+    .positional('action', { choices: ['list', 'generate', 'approve', 'reject', 'rollback', 'edits', 'record-edit', 'teams'] })
     .positional('id', { type: 'number' })
+    .option('team-id', { type: 'number', describe: 'list/edits: only this team; generate: run for this team (team managers must pass one they manage)' })
     .option('state', { type: 'string', default: 'pending_review', describe: 'pending_review|approved|rejected|rolled_back|all' })
     .option('text', { type: 'string', describe: 'approve: edited replacement text (defaults to the AI proposal)' })
     .option('notes', { type: 'string', describe: 'rollback: reason' })
     .option('final-text', { type: 'string', describe: 'record-edit: the text the agent actually sent (redacted server-side)' }),
   handler: runCommand(async (a) => {
     const base = '/CannedLearning';
-    if (a.action === 'list') return print(await messagingGet(`${base}/suggestions?state=${encodeURIComponent(a.state)}`));
-    if (a.action === 'generate') return print(await messagingPost(`${base}/generate`, {}));
-    if (a.action === 'edits') return print(await messagingGet(`${base}/edit-events`));
+    const teamQs = a.teamId != null ? `&teamId=${encodeURIComponent(a.teamId)}` : '';
+    if (a.action === 'list') return print(await messagingGet(`${base}/suggestions?state=${encodeURIComponent(a.state)}${teamQs}`));
+    if (a.action === 'generate') return print(await messagingPost(`${base}/generate`, { teamId: a.teamId ?? null }));
+    if (a.action === 'edits') return print(await messagingGet(`${base}/edit-events${a.teamId != null ? `?teamId=${encodeURIComponent(a.teamId)}` : ''}`));
+    if (a.action === 'teams') return print(await messagingGet(`${base}/teams`));
     if (a.action === 'record-edit') {
       if (a.id == null || !a.finalText) throw new Error('record-edit requires a canned response id and --final-text');
       return print(await messagingPost(`${base}/edit-events`, { cannedResponseId: a.id, finalText: a.finalText }));

package/lib/commands/chat-window.js

@@ -0,0 +1,47 @@
+// velaro chat-window — per-page launcher label + opening greeting (ChatWindow/* on velaro-messaging).
+// Site isolation is enforced server-side (ClientControllerBase SiteId), never passed by the client.
+// To show different copy on different pages: create one chat window per page type, set its
+// label/greeting here, then pick it with a Select Chat Window workflow node.
+import { messagingGet, messagingPut } from '../api.js';
+import { runCommand } from '../run.js';
+
+export const chatWindowCommand = {
+  command:  'chat-window <subcommand>',
+  describe: 'Chat window launcher label and greeting — list, set-copy',
+  builder:  (yargs) =>
+    yargs
+      .command({
+        command: 'list',
+        describe: 'List chat windows with launcher label and greeting',
+        handler: runCommand(async () => {
+          const rows = (await messagingGet('/ChatWindow/list')) ?? [];
+          if (!rows.length) { console.log('No chat windows found.'); return; }
+          for (const w of rows) {
+            console.log(`${w.id}  ${w.name ?? '(unnamed)'}  [${w.languageConfig?.language ?? '?'}]`);
+            console.log(`     launcherText: ${w.styleConfig?.launcherText ?? '(none)'}`);
+            console.log(`     greeting:     ${w.languageConfig?.greeting ?? '(none)'}`);
+          }
+          console.log(`\n${rows.length} chat window(s)`);
+        }),
+      })
+      .command({
+        command: 'set-copy <id>',
+        describe: 'Set launcher label and/or greeting on one chat window (empty string clears)',
+        builder: (y) => y
+          .positional('id', { type: 'number', describe: 'Chat window ID' })
+          .option('launcher-text', { type: 'string', describe: 'Launcher label, max 60 chars' })
+          .option('greeting', { type: 'string', describe: 'Opening greeting, max 256 chars' }),
+        handler: runCommand(async (argv) => {
+          const body = {};
+          if (argv.launcherText !== undefined) body.launcherText = argv.launcherText;
+          if (argv.greeting !== undefined) body.greeting = argv.greeting;
+          if (!Object.keys(body).length) throw new Error('Pass --launcher-text and/or --greeting.');
+          const r = await messagingPut(`/ChatWindow/${argv.id}/launcher-copy`, body);
+          console.log(`Updated chat window ${r.id}.`);
+          console.log(`  launcherText: ${r.launcherText ?? '(none)'}`);
+          console.log(`  greeting:     ${r.greeting ?? '(none)'}`);
+        }),
+      })
+      .demandCommand(1, 'Specify a subcommand: list, set-copy'),
+  handler: () => {},
+};

package/lib/commands/db.js

@@ -26,6 +26,7 @@ const DB_SECRETS = {
     staging: { vault: 'velaro-eastus-stg-kv', secret: 'KnowledgeBaseConnectionString-Staging' },
   },
   messaging: {
+    staging: { vault: 'velaro-eastus-stg-kv', secret: 'MessagingConnectionString-Staging' },
     prod: { vault: 'velaro-eastus-prd-kv', secret: 'MessagingReadOnlyConnectionString' },
   },
 };

package/lib/commands/deploy-state.js

@@ -0,0 +1,26 @@
+import { collectAll, render, PRODUCTS } from '../deploy-state.js';
+
+// velaro deploy-state: what is on the staging environment, on staging slot 1 of production and in
+// production for Admin and Messaging, what is merged to dev but not in production, which gate is
+// waiting and the merge-freeze file. Uses only `gh` (logged in) and public /Version endpoints.
+export const deployStateCommand = {
+  command:  'deploy-state',
+  describe: 'Where each push landed: staging environment, staging slot 1 of production, production (Velaro staff, needs gh)',
+  builder:  (yargs) => yargs
+    .option('product', { type: 'string', choices: ['admin', 'messaging'], describe: 'Only one product (default both)' })
+    .option('json',    { type: 'boolean', describe: 'Print the raw state as JSON' })
+    .option('compact', { type: 'boolean', describe: 'One line per place' }),
+  handler: async (argv) => {
+    try {
+      const products = argv.product
+        ? [Object.keys(PRODUCTS).find((n) => n.toLowerCase() === argv.product)]
+        : undefined;
+      const state = await collectAll({ products });
+      console.log(argv.json ? JSON.stringify(state, null, 2) : render(state, { compact: !!argv.compact }));
+    } catch (e) {
+      console.error(`deploy-state failed: ${e.message}`);
+      console.error('This command needs the GitHub CLI (gh) installed and logged in with access to velaro/velaro-admin and velaro/velaro-messaging. Run: gh auth login');
+      process.exit(1);
+    }
+  },
+};

package/lib/commands/logs.js

@@ -1,6 +1,6 @@
 import { getCredentials }          from '../api.js';
 import { readConfig, ENVS }        from '../config.js';
-import { completeLogSearch, describeCompleteness, describeRawMeta } from '../log-search.js';
+import { completeLogSearch, describeCompleteness, describeRawMeta, fetchJsonRetry } from '../log-search.js';
 
 // ── helpers ──────────────────────────────────────────────────────────────────
 
@@ -57,6 +57,10 @@ async function requireAdmin(creds) {
 // ── search handler ────────────────────────────────────────────────────────────
 
 async function searchLogs(argv) {
+  try { await searchLogsInner(argv); } catch (err) { console.error(err?.message ?? String(err)); process.exit(1); }
+}
+
+async function searchLogsInner(argv) {
   const creds   = await getCredentials();
   await requireAdmin(creds);
   const msgBase = await getMsgBase(argv);
@@ -68,14 +72,8 @@ async function searchLogs(argv) {
     process.exit(1);
   }
   const headers = { Authorization: `Bearer ${creds.velaroToken}`, 'X-Internal-SiteId': String(creds.siteId) };
-  const getJson = async (query) => {
-    const res = await fetch(`${msgBase}/superadmin/logs/search?${query}`, { headers, signal: AbortSignal.timeout(30000) });
-    if (!res.ok) {
-      console.error(`HTTP ${res.status}: ${await res.text().catch(() => '')}`);
-      process.exit(1);
-    }
-    return res.json();
-  };
+  // 40 s: the server's own scan budget is 12 s (+6 s AI search) per request, and a 429 (scan gate full) is retried with Retry-After.
+  const getJson = (query) => fetchJsonRetry(`${msgBase}/superadmin/logs/search?${query}`, () => ({ headers, signal: AbortSignal.timeout(40000) }));
 
   // --raw: the server's own q= search (kept for parity). Proven 2026-10-14 to under-report (q=[HttpFallback]
   // returned 0-2 rows while 136 existed), so it now always prints the server's searchPath/scannedRows/truncated.
@@ -110,6 +108,8 @@ async function searchLogs(argv) {
     regex:    argv.regex ? argv.query : undefined,
     logger:   argv.logger,
     maxRequests: argv.maxRequests ?? 200,
+    maxSeconds: argv.maxSeconds ?? 120,
+    wanted: argv.take ?? 50,
   });
   console.log(`${result.complete ? DIM : YEL}${describeCompleteness(result)}${RESET}`);
   if (!result.entries.length) { console.log('No results.'); return; }
@@ -238,21 +238,26 @@ async function diagnoseLogs(argv) {
 
   console.log(`\n${BOLD}── Bot Diagnostic — last ${window} ──────────────────────────────${RESET2}`);
 
-  // Run error search and perf/routing search in parallel
-  async function search(q) {
-    const p = new URLSearchParams({ q, from: from.toISOString(), take: '50' });
-    const r = await fetch(`${msgBase}/superadmin/logs/search?${p}`, {
+  // Run error search and perf/routing search in parallel. FIXED 2026-10-14: the old calls searched the TEXT "level:ERROR" and the
+  // TEXT "WF-AI-ROUTE OR PERF-SLOW", which no log line contains, so this printed "No errors" no matter what. Errors are now the
+  // server-side level filter and the perf/routing pair is a regex; the server's scan metadata is surfaced so an unverified
+  // empty answer is never shown as a clean bill of health.
+  const notes = [];
+  async function search(label, p0) {
+    const p = new URLSearchParams({ from: from.toISOString(), take: '50', ...p0 });
+    const resp = await fetchJsonRetry(`${msgBase}/superadmin/logs/search?${p}`, () => ({
       headers: { Authorization: `Bearer ${creds.velaroToken}`, 'X-Internal-SiteId': String(creds.siteId) },
-      signal: AbortSignal.timeout(15000),
-    });
-    if (!r.ok) return [];
-    return extractLogEntries(await r.json());
+      signal: AbortSignal.timeout(40000),
+    })).catch((err) => { notes.push(`${label}: search failed (${err.message})`); return null; });
+    if (resp && !Array.isArray(resp) && resp.truncated !== false) notes.push(`${label}: ${describeRawMeta(resp)}`);
+    else if (Array.isArray(resp)) notes.push(`${label}: ${describeRawMeta(resp)}`);
+    return resp ? extractLogEntries(resp) : [];
   }
 
-  const [errors, perfAndRouting] = await Promise.all([
-    search('level:ERROR'),
-    search('WF-AI-ROUTE OR PERF-SLOW'),
-  ]);
+  // One at a time: the server runs at most 2 exact scans per instance.
+  const errors = await search('errors', { level: 'ERROR' });
+  const perfAndRouting = await search('perf/routing', { q: 'WF-AI-ROUTE|PERF-SLOW', regex: 'true' });
+  for (const n of notes) console.log(`  \x1b[33m!\x1b[0m  ${n}`);
 
   // ── Errors ──
   console.log(`\n${BOLD}Errors${RESET2}`);
@@ -724,6 +729,7 @@ export const logsCommand = {
         .option('to',            { describe: 'ISO end time (default now)', type: 'string' })
         .option('raw',           { describe: 'Use the server q= search (can under-report; prints searchPath/scannedRows/truncated)', boolean: true, default: false })
         .option('max-requests',  { describe: 'Request budget for the complete read', default: 200, type: 'number' })
+        .option('max-seconds',   { describe: 'Wall-clock budget for the complete read', default: 120, type: 'number' })
         .option('take',          { describe: 'Max lines to print (complete read) / server page size (--raw, max 500)', default: 50, type: 'number' })
         .option('env',           { describe: 'staging or prod', type: 'string' }),
       handler: searchLogs,

package/lib/commands/ops.js

@@ -1,5 +1,7 @@
+import { describeRawMeta, fetchRetry429 } from '../log-search.js';
 import { get, del, post, getCredentials } from '../api.js';
 import { readConfig, ENVS }   from '../config.js';
+import { collectAll, render as renderDeployState } from '../deploy-state.js';
 
 // ── helpers ──────────────────────────────────────────────────────────────────
 
@@ -153,6 +155,17 @@ export const opsCommand = {
       }
     }
 
+    // ── 1b. Where each push landed: staging environment, staging slot 1 of production, production ──
+    // Same data as `velaro deploy-state` (needs gh). Never blocks the rest of ops if gh is missing.
+    console.log('\n\x1b[1m── Where each push landed ──────────────────────────────────\x1b[0m');
+    try {
+      const state = await collectAll();
+      console.log(renderDeployState(state, { compact: true }).split('\n').map(l => '  ' + l).join('\n'));
+      console.log('  Full detail: velaro deploy-state');
+    } catch (e) {
+      console.log(`  ${WARN}  Deploy state unavailable (${e.message}). Needs gh logged in; run velaro deploy-state.`);
+    }
+
     // ── 2. API health (admin + messaging, both envs) ──────────────────────────
     const prodMsgBase    = cfg.envs?.prod?.messagingApiBase    ?? ENVS.prod.messagingApiBase;
     const stagingMsgBase = cfg.envs?.staging?.messagingApiBase ?? ENVS.staging.messagingApiBase;
@@ -236,19 +249,25 @@ export const opsCommand = {
       const stagingMsgBaseLocal = cfg.envs?.staging?.messagingApiBase ?? ENVS.staging.messagingApiBase;
       const from1h = new Date(Date.now() - 3600000).toISOString();
 
-      const [errRes, perfRes] = await Promise.all([
-        fetch(`${stagingMsgBaseLocal}/superadmin/logs/search?q=level%3AERROR&from=${from1h}&take=5`, {
-          headers: { Authorization: `Bearer ${creds.velaroToken}`, 'X-Internal-SiteId': String(creds.siteId) },
-          signal: AbortSignal.timeout(12000),
-        }),
-        fetch(`${stagingMsgBaseLocal}/superadmin/logs/search?q=WF-AI-ROUTE+OR+PERF-SLOW&from=${from1h}&take=20`, {
-          headers: { Authorization: `Bearer ${creds.velaroToken}`, 'X-Internal-SiteId': String(creds.siteId) },
-          signal: AbortSignal.timeout(12000),
-        }),
-      ]);
-
-      const errors   = errRes.ok  ? extractLogEntries(await errRes.json().catch(() => [])) : [];
-      const perfLogs = perfRes.ok ? extractLogEntries(await perfRes.json().catch(() => [])) : [];
+      // One search at a time: the server runs at most 2 exact scans per instance. 429 (gate full) is retried honouring Retry-After.
+      const errRes  = await fetchRetry429(`${stagingMsgBaseLocal}/superadmin/logs/search?level=ERROR&from=${from1h}&take=5`, () => ({
+        headers: { Authorization: `Bearer ${creds.velaroToken}`, 'X-Internal-SiteId': String(creds.siteId) },
+        signal: AbortSignal.timeout(40000),
+      }));
+      const perfRes = await fetchRetry429(`${stagingMsgBaseLocal}/superadmin/logs/search?q=${encodeURIComponent('WF-AI-ROUTE|PERF-SLOW')}&regex=true&from=${from1h}&take=20`, () => ({
+        headers: { Authorization: `Bearer ${creds.velaroToken}`, 'X-Internal-SiteId': String(creds.siteId) },
+        signal: AbortSignal.timeout(40000),
+      }));
+
+      // FIXED 2026-10-14: both searches used to look for the literal TEXT "level:ERROR" / "WF-AI-ROUTE OR PERF-SLOW" (never in any log
+      // line), so this check always said "0 errors". Errors are now the server-side level filter, perf/routing a regex, and an
+      // unverified or failed scan is reported instead of being counted as a clean result.
+      const errBody  = errRes.ok  ? await errRes.json().catch(() => null) : null;
+      const perfBody = perfRes.ok ? await perfRes.json().catch(() => null) : null;
+      const errors   = errBody  ? extractLogEntries(errBody)  : [];
+      const perfLogs = perfBody ? extractLogEntries(perfBody) : [];
+      const scanNote = (label, body, ok) => (!ok || !body) ? `${label}: search failed or timed out (HTTP ${ok ? 'ok' : 'error'}), NOT verified` : (body.truncated === false ? null : `${label}: ${describeRawMeta(body)}`);
+      for (const n of [scanNote('errors', errBody, errRes.ok), scanNote('perf/routing', perfBody, perfRes.ok)].filter(Boolean)) console.log(`  ${WARN}  ${n}`);
 
       const perfCount  = perfLogs.filter(e => (e.Message ?? e.message ?? '').includes('PERF-SLOW')).length;
       const routeCount = perfLogs.filter(e => (e.Message ?? e.message ?? '').includes('WF-AI-ROUTE')).length;

package/lib/commands/safety.js

@@ -0,0 +1,111 @@
+// velaro safety — see safety events, acknowledge them, and manage alert settings. Wraps velaro-messaging
+// SafetyEventsController. The site always comes from your login, never from an argument. Same routes the
+// admin "Safety and alerts" page uses. Needs the EnableTroubleshootingKnowledge entitlement.
+import { messagingGet, messagingPost, messagingPut } from '../api.js';
+import { runCommand } from '../run.js';
+
+const enc = encodeURIComponent;
+
+const out = (argv, data, printer) => {
+  if (argv.json) console.log(JSON.stringify(data, null, 2));
+  else printer(data);
+};
+
+const list = (v) => (v === undefined ? undefined : [].concat(v).flatMap((x) => String(x).split(',')).map((s) => s.trim()).filter(Boolean));
+
+function printEvents(r) {
+  const items = r.items ?? [];
+  if (!items.length) { console.log('No safety events.'); return; }
+  for (const e of items) {
+    console.log(`[${e.id}] ${e.createdUtc}  ${e.type}  (${e.channel})  ${e.status}`);
+    if (e.reason) console.log(`    Why: ${e.reason}`);
+    if (e.excerpt) console.log(`    "${e.excerpt}"`);
+  }
+  console.log(`\n${items.length} of ${r.total ?? items.length} shown.`);
+}
+
+function printSummary(s) {
+  console.log('Totals:');
+  for (const [k, v] of Object.entries(s.totals ?? {})) console.log(`  ${k}: ${v}`);
+  console.log('\nBy day:');
+  for (const d of s.days ?? []) console.log(`  ${d.date}  ${JSON.stringify(d.counts)}`);
+}
+
+function printSettings(s) {
+  console.log(`Alerts:            ${s.enabled ? 'on' : 'off'}`);
+  console.log(`Email recipients:  ${(s.emailRecipients ?? []).join(', ') || '(none)'}`);
+  console.log(`SMS recipients:    ${(s.smsRecipients ?? []).join(', ') || '(none)'}`);
+  console.log(`Alert right away:  ${(s.immediateTypes ?? []).join(', ') || '(none)'}`);
+  console.log(`Summary email:     ${s.digest}`);
+  console.log(`Count alert:       ${s.threshold?.count ?? 0} events in ${s.threshold?.windowMinutes ?? 60} minutes`);
+}
+
+export const safetyCommand = {
+  command: 'safety',
+  describe: 'Safety events and alerts: list events, acknowledge, alert settings, test alert, ask Velaro for help',
+  builder: (yargs) => yargs
+    .command('events', 'List safety events', (y) => y
+      .option('from', { type: 'string', describe: 'ISO start' })
+      .option('to', { type: 'string', describe: 'ISO end' })
+      .option('type', { type: 'string' })
+      .option('status', { type: 'string', choices: ['open', 'acknowledged'] })
+      .option('take', { type: 'number', default: 25 })
+      .option('skip', { type: 'number', default: 0 })
+      .option('json', { type: 'boolean' }),
+    runCommand(async (a) => {
+      const q = new URLSearchParams();
+      for (const k of ['from', 'to', 'type', 'status']) if (a[k]) q.set(k, a[k]);
+      q.set('take', String(a.take));
+      q.set('skip', String(a.skip));
+      out(a, await messagingGet(`/SafetyEvents?${q}`), printEvents);
+    }))
+    .command('summary', 'Counts by type and by day', (y) => y
+      .option('days', { type: 'number', default: 7 })
+      .option('json', { type: 'boolean' }),
+    runCommand(async (a) => out(a, await messagingGet(`/SafetyEvents/summary?days=${a.days}`), printSummary)))
+    .command('ack', 'Mark an event as reviewed', (y) => y.option('id', { type: 'string', demandOption: true }),
+    runCommand(async (a) => {
+      await messagingPost(`/SafetyEvents/${enc(a.id)}/acknowledge`);
+      console.log(`Event ${a.id} marked as reviewed.`);
+    }))
+    .command('settings <action>', 'Read or change alert settings (get | set)', (y) => y
+      .positional('action', { choices: ['get', 'set'] })
+      .option('enabled', { type: 'boolean' })
+      .option('email', { type: 'string', describe: 'Email recipients, comma separated (replaces the list)' })
+      .option('sms', { type: 'string', describe: 'SMS recipients in +15551234567 form, comma separated (replaces the list)' })
+      .option('immediate', { type: 'string', describe: 'Event types that alert right away, comma separated (replaces the list)' })
+      .option('digest', { type: 'string', choices: ['off', 'daily', 'weekly'] })
+      .option('threshold-count', { type: 'number', describe: 'Alert at this many events inside the window. 0 turns it off.' })
+      .option('threshold-window', { type: 'number', describe: 'Window in minutes, 1 to 10080' })
+      .option('json', { type: 'boolean' }),
+    runCommand(async (a) => {
+      const cur = (await messagingGet('/SafetyEvents/settings')) ?? {};
+      if (a.action === 'get') return out(a, cur, printSettings);
+      const next = { ...cur };
+      if (a.enabled !== undefined) next.enabled = a.enabled;
+      if (a.email !== undefined) next.emailRecipients = list(a.email);
+      if (a.sms !== undefined) next.smsRecipients = list(a.sms);
+      if (a.immediate !== undefined) next.immediateTypes = list(a.immediate);
+      if (a.digest !== undefined) next.digest = a.digest;
+      if (a['threshold-count'] !== undefined || a['threshold-window'] !== undefined) {
+        next.threshold = {
+          count: a['threshold-count'] ?? cur.threshold?.count ?? 0,
+          windowMinutes: a['threshold-window'] ?? cur.threshold?.windowMinutes ?? 60,
+        };
+      }
+      out(a, await messagingPut('/SafetyEvents/settings', next), (s) => { console.log('Saved.\n'); printSettings(s); });
+    }))
+    .command('test', 'Send a test alert to the configured recipients', (y) => y,
+    runCommand(async () => {
+      await messagingPost('/SafetyEvents/settings/test');
+      console.log('Test alert sent. Check the inboxes and phones on the recipient list.');
+    }))
+    .command('need-help', 'Tell the Velaro team the bot is going off the rails', (y) => y
+      .option('message', { type: 'string', demandOption: true, describe: 'What is happening' }),
+    runCommand(async (a) => {
+      await messagingPost('/SafetyEvents/need-help', { message: a.message });
+      console.log('Sent. The Velaro team has been alerted.');
+    }))
+    .demandCommand(1, 'Specify a subcommand: events, summary, ack, settings, test, need-help'),
+  handler: () => {},
+};