wldx-cli 1.0.0 → 1.1.0

package/src/commands/conversations.mjs

@@ -1,31 +1,84 @@
 // wx conversations: the search over calls, conferences and chats with the AI summary of each (WDA Insights), the
 // counts, the statistics of a dimension (the data of a chart) and the tags. By default only the conversations the
 // logged-in user took part in; --everyone drops that (the service still decides what the login may see).
-import {jwtClaims} from '../auth.mjs';
-import {UsageError} from '../errors.mjs';
-import {localTime, oneLine, table} from '../format.mjs';
-import {query} from '../http.mjs';
+import {jwtClaims} from 'wldx-core/auth';
+import {UsageError} from 'wldx-core/errors';
+import {localTime, oneLine, table} from 'wldx-core/format';
+import {query} from 'wldx-core/http';
 import {secs} from '../history/text.mjs';
 import {alt, checkIso, checkZone, intOption, isoSeconds, localZone, pick, unique, wdaClient} from '../history/wda.mjs';
 
-export const WHEN = ['TODAY', 'YESTERDAY', 'THIS_WEEK', 'PREVIOUS_WEEK', 'THIS_MONTH', 'PREVIOUS_MONTH', 'THIS_QUARTER', 'LAST_30_DAYS'];
-export const DIMENSIONS = ['direction', 'entity', 'channel', 'recorded', 'language', 'country', 'location', 'pbx', 'trunk', 'queue', 'service', 'extension', 'group', 'department', 'tag', 'chatbot', 'voicebot', 'duration', 'connectTime', 'talkTime', 'waitTime', 'queueTime', 'holdTime', 'date', 'dayOfWeek', 'hourOfDay'];
+export const WHEN = [
+  'TODAY',
+  'YESTERDAY',
+  'THIS_WEEK',
+  'PREVIOUS_WEEK',
+  'THIS_MONTH',
+  'PREVIOUS_MONTH',
+  'THIS_QUARTER',
+  'LAST_30_DAYS',
+];
+export const DIMENSIONS = [
+  'direction',
+  'entity',
+  'channel',
+  'recorded',
+  'language',
+  'country',
+  'location',
+  'pbx',
+  'trunk',
+  'queue',
+  'service',
+  'extension',
+  'group',
+  'department',
+  'tag',
+  'chatbot',
+  'voicebot',
+  'duration',
+  'connectTime',
+  'talkTime',
+  'waitTime',
+  'queueTime',
+  'holdTime',
+  'date',
+  'dayOfWeek',
+  'hourOfDay',
+];
 const ZONED = new Set(['date', 'dayOfWeek', 'hourOfDay']);
 const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
 
 // The options of the filter (find, count, aggregate).
 const FILTER_OPTIONS = {
-  entity: {type: 'string', multiple: true, choices: ['call', 'conference', 'chat'], description: 'only calls, conferences or chats'},
-  email: {type: 'string', multiple: true, placeholder: 'E', description: 'a participant by e-mail (all named must have taken part)'},
+  entity: {
+    type: 'string',
+    multiple: true,
+    choices: ['call', 'conference', 'chat'],
+    description: 'only calls, conferences or chats',
+  },
+  email: {
+    type: 'string',
+    multiple: true,
+    placeholder: 'E',
+    description: 'a participant by e-mail (all named must have taken part)',
+  },
   phone: {type: 'string', multiple: true, placeholder: 'P', description: 'a participant by phone number'},
   extension: {type: 'string', multiple: true, placeholder: 'X', description: 'a participant by extension'},
-  everyone: {type: 'boolean', description: 'not only your own conversations: everything the login may see (only when asked)'},
+  everyone: {
+    type: 'boolean',
+    description: 'not only your own conversations: everything the login may see (only when asked)',
+  },
   transcribed: {type: 'boolean', description: 'only conversations with a transcript'},
   recorded: {type: 'boolean', description: 'only recorded conversations'},
   direction: {type: 'string', choices: ['inbound', 'outbound', 'internal'], description: 'only this direction'},
   from: {type: 'string', placeholder: 'ISO', description: 'from this time (ISO)'},
   to: {type: 'string', placeholder: 'ISO', description: 'up to this time (ISO)'},
-  tz: {type: 'string', placeholder: 'ZONE', description: 'the time zone of --from/--to/--when (and of the time dimensions of aggregate)'},
+  tz: {
+    type: 'string',
+    placeholder: 'ZONE',
+    description: 'the time zone of --from/--to/--when (and of the time dimensions of aggregate)',
+  },
   when: {type: 'string', choices: WHEN, description: 'a ready period'},
   tag: {type: 'string', multiple: true, placeholder: 'T', description: 'only conversations with this tag'},
   language: {type: 'string', multiple: true, placeholder: 'L', description: 'only conversations in this language'},
@@ -36,7 +89,11 @@ const FILTER_OPTIONS = {
 export function buildFilter(values, token) {
   const f = {};
   if (values.entity?.length) f.entity = Object.fromEntries(values.entity.map((e) => [e, true]));
-  const parts = [...(values.email ?? []).map((email) => ({email})), ...(values.phone ?? []).map((phone) => ({phone})), ...(values.extension ?? []).map((extension) => ({extension}))];
+  const parts = [
+    ...(values.email ?? []).map((email) => ({email})),
+    ...(values.phone ?? []).map((phone) => ({phone})),
+    ...(values.extension ?? []).map((extension) => ({extension})),
+  ];
   if (!parts.length && !values.everyone) {
     const me = String(jwtClaims(token).email ?? '').toLowerCase();
     if (!me) throw new Error('the token carries no e-mail');
@@ -49,7 +106,13 @@ export function buildFilter(values, token) {
   const tz = checkZone(values.tz);
   if (values.when) f.date = {predefined: {type: values.when, ...(tz ? {timeZone: tz} : {})}};
   else if (values.from || values.to) {
-    f.date = {absolute: {...(values.from ? {from: checkIso('--from', values.from)} : {}), ...(values.to ? {to: checkIso('--to', values.to)} : {}), ...(tz ? {timeZone: tz} : {})}};
+    f.date = {
+      absolute: {
+        ...(values.from ? {from: checkIso('--from', values.from)} : {}),
+        ...(values.to ? {to: checkIso('--to', values.to)} : {}),
+        ...(tz ? {timeZone: tz} : {}),
+      },
+    };
   }
   if (values.tag?.length) f.tag = values.tag;
   if (values.language?.length) f.language = values.language;
@@ -68,7 +131,10 @@ export function briefItem(it) {
     title: v.subject ?? null,
     direction: v.direction ?? null,
     status: alt(v.status, v.callStatus),
-    participants: type === 'conference' ? unique((v.participants ?? []).map((p) => alt(p.info?.name, p.info?.email)).filter((n) => n !== null)) : null,
+    participants:
+      type === 'conference'
+        ? unique((v.participants ?? []).map((p) => alt(p.info?.name, p.info?.email)).filter((n) => n !== null))
+        : null,
     summary: pick(it.summary, ['status', 'title', 'brief']),
   };
 }
@@ -80,7 +146,8 @@ export function aggregationOf(dim, tz) {
     if (!m) throw new UsageError(`a projection is projection:<id>:<field>: ${dim}`);
     return {projection: {id: m[1], fieldId: m[2]}};
   }
-  if (!DIMENSIONS.includes(dim)) throw new UsageError(`not a dimension: ${dim} (one of ${DIMENSIONS.join(', ')}, or projection:<id>:<field>)`);
+  if (!DIMENSIONS.includes(dim))
+    throw new UsageError(`not a dimension: ${dim} (one of ${DIMENSIONS.join(', ')}, or projection:<id>:<field>)`);
   return {[dim]: ZONED.has(dim) ? {timeZone: tz} : {}};
 }
 
@@ -116,7 +183,10 @@ export function projectionsOf(r) {
       .map((x) => ({
         by: `projection:${x.aggregation.projection.id}:${x.aggregation.projection.fieldId}`,
         values: x.buckets.reduce((n, b) => n + (b.count ?? 0), 0),
-        top: [...x.buckets].sort((a, b) => b.count - a.count).slice(0, 5).map((b) => ({key: b.key ?? null, count: b.count ?? null})),
+        top: [...x.buckets]
+          .sort((a, b) => b.count - a.count)
+          .slice(0, 5)
+          .map((b) => ({key: b.key ?? null, count: b.count ?? null})),
       })),
   };
 }
@@ -125,7 +195,10 @@ const bucketLabel = (b) => (b.day ? `${b.day}` : b.key === null || b.key === ''
 
 // The buckets of a level (and of the levels under it, indented) as rows of label and count.
 function levelRows(l, indent = '') {
-  return l.buckets.flatMap((b) => [[`${indent}${oneLine(bucketLabel(b), 60)}`, String(b.count)], ...(b.then ? levelRows(b.then, `${indent}  `) : [])]);
+  return l.buckets.flatMap((b) => [
+    [`${indent}${oneLine(bucketLabel(b), 60)}`, String(b.count)],
+    ...(b.then ? levelRows(b.then, `${indent}  `) : []),
+  ]);
 }
 
 const chain = (l) => (l.buckets.find((b) => b.then) ? [l.by, ...chain(l.buckets.find((b) => b.then).then)] : [l.by]);
@@ -136,15 +209,37 @@ function aggregateText(r, ctx) {
   const whose = v.everyone ? 'visible to the login' : 'your own';
   if (v.projections) {
     if (!r.projections.length) return `${r.count} conversations (${whose}); no AI fields with values.`;
-    return [`${r.count} conversations (${whose}); AI fields with values:`, ...table(r.projections.map((p) => [p.by, String(p.values), p.top.map((t) => `${oneLine(t.key, 30)} ${t.count}`).join(', ')]))];
+    return [
+      `${r.count} conversations (${whose}); AI fields with values:`,
+      ...table(
+        r.projections.map((p) => [
+          p.by,
+          String(p.values),
+          p.top.map((t) => `${oneLine(t.key, 30)} ${t.count}`).join(', '),
+        ]),
+      ),
+    ];
   }
   const head = `${r.count} conversations (${whose}), times in ${r.timeZone}`;
-  if (r.results) return [head, ...r.results.flatMap((l) => ['', `by ${l.by}:`, ...(l.buckets.length ? table(levelRows(l, '  ')) : ['  (none)'])])];
-  return [head, '', `by ${chain(r).join(', then ')}:`, ...(r.buckets.length ? table(levelRows(r, '  ')) : ['  (none)'])];
+  if (r.results)
+    return [
+      head,
+      ...r.results.flatMap((l) => [
+        '',
+        `by ${l.by}:`,
+        ...(l.buckets.length ? table(levelRows(l, '  ')) : ['  (none)']),
+      ]),
+    ];
+  return [
+    head,
+    '',
+    `by ${chain(r).join(', then ')}:`,
+    ...(r.buckets.length ? table(levelRows(r, '  ')) : ['  (none)']),
+  ];
 }
 
 function findText(r, ctx) {
-  const items = ctx.values.brief ? r.items ?? [] : (r.items ?? []).map(briefItem);
+  const items = ctx.values.brief ? (r.items ?? []) : (r.items ?? []).map(briefItem);
   const lines = items.length
     ? table(
         items.map((i) => [
@@ -168,12 +263,18 @@ const group = {
   commands: {
     find: {
       summary: 'the search over conversations with the summary of each, 10 per page',
-      usage: 'wx conversations find [--entity call|conference|chat]... [--email E]... [--phone P]... [--extension X]... [--everyone] [--transcribed] [--recorded] [--direction inbound|outbound|internal] [--from ISO --to ISO [--tz ZONE]] [--when PERIOD] [--tag T]... [--language L]... [--cursor KEY] [--brief]',
-      details: 'Only the conversations you took part in, unless --everyone (only when asked: it may return the conversations of colleagues). The next page: --cursor with nextCursor (lastEvaluatedKey) of the answer.',
+      usage:
+        'wx conversations find [--entity call|conference|chat]... [--email E]... [--phone P]... [--extension X]... [--everyone] [--transcribed] [--recorded] [--direction inbound|outbound|internal] [--from ISO --to ISO [--tz ZONE]] [--when PERIOD] [--tag T]... [--language L]... [--cursor KEY] [--brief]',
+      details:
+        'Only the conversations you took part in, unless --everyone (only when asked: it may return the conversations of colleagues). The next page: --cursor with nextCursor (lastEvaluatedKey) of the answer.',
       options: {
         ...FILTER_OPTIONS,
         cursor: {type: 'string', placeholder: 'KEY', description: 'the next page (nextCursor of the previous answer)'},
-        brief: {type: 'boolean', description: 'one short object per conversation: type, id, start, duration, title, direction, status, participants, summary'},
+        brief: {
+          type: 'boolean',
+          description:
+            'one short object per conversation: type, id, start, duration, title, direction, status, participants, summary',
+        },
       },
       args: [0, 0],
       async run(ctx) {
@@ -189,12 +290,15 @@ const group = {
       usage: 'wx conversations count [the filter of find, without --cursor and --brief]',
       options: FILTER_OPTIONS,
       args: [0, 0],
-      run: (ctx) => ctx.client(wdaClient).post('/insights/conversations/count', {filter: buildFilter(ctx.values, ctx.token)}),
-      text: (r, ctx) => `${r.count ?? JSON.stringify(r)} conversations (${ctx.values.everyone ? 'visible to the login' : 'your own'})`,
+      run: (ctx) =>
+        ctx.client(wdaClient).post('/insights/conversations/count', {filter: buildFilter(ctx.values, ctx.token)}),
+      text: (r, ctx) =>
+        `${r.count ?? JSON.stringify(r)} conversations (${ctx.values.everyone ? 'visible to the login' : 'your own'})`,
     },
     aggregate: {
       summary: 'how many conversations fall into each value of a dimension (the data of a chart)',
-      usage: 'wx conversations aggregate (--by DIM[,DIM...] | --by DIM --then DIM [--then DIM] | --projections) [the filter of find] [--tz ZONE] [--top N] [--raw]',
+      usage:
+        'wx conversations aggregate (--by DIM[,DIM...] | --by DIM --then DIM [--then DIM] | --projections) [the filter of find] [--tz ZONE] [--top N] [--raw]',
       details: [
         'Several dimensions side by side (--by a,b: at most 10), or one broken down by others (--by a --then b [--then c]).',
         `Dimensions: ${DIMENSIONS.join(' ')}, and projection:<id>:<field> (an AI insight field; --projections lists those with values).`,
@@ -204,10 +308,18 @@ const group = {
       options: {
         ...FILTER_OPTIONS,
         by: {type: 'string', placeholder: 'DIM[,DIM]', description: 'the dimensions (comma-separated)'},
-        then: {type: 'string', multiple: true, placeholder: 'DIM', description: 'break each value of --by down by this dimension (at most two)'},
+        then: {
+          type: 'string',
+          multiple: true,
+          placeholder: 'DIM',
+          description: 'break each value of --by down by this dimension (at most two)',
+        },
         top: {type: 'string', placeholder: 'N', description: 'keep the N biggest values of each level (1-1000)'},
         raw: {type: 'boolean', description: 'the answer of the service as it is'},
-        projections: {type: 'boolean', description: 'the AI insight fields that have values in the filter, with their biggest values'},
+        projections: {
+          type: 'boolean',
+          description: 'the AI insight fields that have values in the filter, with their biggest values',
+        },
       },
       args: [0, 0],
       async run(ctx) {
@@ -242,7 +354,12 @@ const group = {
       usage: 'wx conversations tags <prefix> [--limit 1-20]',
       options: {limit: {type: 'string', placeholder: '1-20', description: 'how many tags'}},
       args: [1, 1],
-      run: (ctx) => ctx.client(wdaClient).get(`/insights/conversations/tags${query({tagPrefix: ctx.positionals[0], limit: intOption('--limit', ctx.values.limit, 1, 20)})}`),
+      run: (ctx) =>
+        ctx
+          .client(wdaClient)
+          .get(
+            `/insights/conversations/tags${query({tagPrefix: ctx.positionals[0], limit: intOption('--limit', ctx.values.limit, 1, 20)})}`,
+          ),
       text: (r) => ((r.tags ?? []).length ? r.tags.map(String) : 'No tags.'),
     },
   },

package/src/commands/file.mjs

@@ -1,17 +1,25 @@
 // wx file: files in chat channels (the agent skill's files.sh). Uploads and downloads go through presigned links
 // of the storage, which get no token.
-import {UsageError} from '../errors.mjs';
-import {table} from '../format.mjs';
-import {apiPath} from '../http.mjs';
+import {UsageError} from 'wldx-core/errors';
+import {table} from 'wldx-core/format';
+import {apiPath} from 'wldx-core/http';
 import {channelId, messageId} from '../stream.mjs';
 import {api, checkId, downloadFile, uploadFile} from '../chat/lib.mjs';
 
-const fileRows = (f) => table([['File', f.name ?? ''], ['fsId', f.fsId ?? ''], ['Type', f.mime ?? ''], ['Size', f.size === undefined ? '' : `${f.size} bytes`], ...(f.width ? [['Image', `${f.width}x${f.height}`]] : [])]);
+const fileRows = (f) =>
+  table([
+    ['File', f.name ?? ''],
+    ['fsId', f.fsId ?? ''],
+    ['Type', f.mime ?? ''],
+    ['Size', f.size === undefined ? '' : `${f.size} bytes`],
+    ...(f.width ? [['Image', `${f.width}x${f.height}`]] : []),
+  ]);
 
 const upload = {
   summary: 'upload a file to a channel and print the attachment object (to put into a message)',
   usage: 'wx file upload <channel> <path>',
-  details: 'Sending a file in one step: wx chat send <channel> <text> --file PATH. Files in credential folders and files that look like secrets are refused.',
+  details:
+    'Sending a file in one step: wx chat send <channel> <text> --file PATH. Files in credential folders and files that look like secrets are refused.',
   options: {},
   args: [2, 2],
   async run(ctx) {

package/src/commands/inbox.mjs

@@ -1,22 +1,26 @@
 // wx inbox: the logged-in user's inbox on the stream service (the agent skill's inbox.sh): what is unread, and the
 // user's own state of a channel (read, muted, pinned, hidden). Changes here are seen only by the user.
-import {UsageError} from '../errors.mjs';
-import {paint, table} from '../format.mjs';
-import {apiPath, query} from '../http.mjs';
+import {UsageError} from 'wldx-core/errors';
+import {paint, table} from 'wldx-core/format';
+import {apiPath, query} from 'wldx-core/http';
 import {channelId, messageId} from '../stream.mjs';
 import {channelLines, channelUserIds, done} from '../chat/format.mjs';
 import {api, withNames} from '../chat/lib.mjs';
 
 export function sectionLines(sections, ctx) {
   const c = paint(ctx);
-  return table((sections ?? []).map((s) => [
-    c.bold(s.name ?? s.sectionId),
-    s.sectionId,
-    s.type ?? '',
-    `${s.channelCount ?? 0} channels`,
-    s.unmutedUnreadMessageCount ? c.yellow(`${s.unmutedUnreadMessageCount} new in ${s.unmutedUnreadChannelCount ?? '?'}`) : '',
-    s.unreadMentionCount ? c.yellow(`@${s.unreadMentionCount}`) : '',
-  ]));
+  return table(
+    (sections ?? []).map((s) => [
+      c.bold(s.name ?? s.sectionId),
+      s.sectionId,
+      s.type ?? '',
+      `${s.channelCount ?? 0} channels`,
+      s.unmutedUnreadMessageCount
+        ? c.yellow(`${s.unmutedUnreadMessageCount} new in ${s.unmutedUnreadChannelCount ?? '?'}`)
+        : '',
+      s.unreadMentionCount ? c.yellow(`@${s.unreadMentionCount}`) : '',
+    ]),
+  );
 }
 
 const get = {
@@ -37,7 +41,9 @@ const get = {
 };
 
 const mark = (read) => ({
-  summary: read ? 'mark a channel read, up to the latest message (or up to a message)' : 'mark a channel unread from a message on',
+  summary: read
+    ? 'mark a channel read, up to the latest message (or up to a message)'
+    : 'mark a channel unread from a message on',
   usage: `wx inbox ${read ? 'mark-read' : 'mark-unread'} <channel> [--message MESSAGE]${read ? '' : ' [--force]'}`,
   options: {
     message: {type: 'string', description: 'the message (id or inbox link)'},
@@ -63,7 +69,8 @@ const mute = {
     const ch = channelId(ctx.positionals[0]);
     const body = {};
     if (ctx.values.until !== undefined) {
-      if (!/^\d{4}-\d{2}-\d{2}T/.test(ctx.values.until) || Number.isNaN(Date.parse(ctx.values.until))) throw new UsageError(`--until must be an ISO 8601 time: ${ctx.values.until}`);
+      if (!/^\d{4}-\d{2}-\d{2}T/.test(ctx.values.until) || Number.isNaN(Date.parse(ctx.values.until)))
+        throw new UsageError(`--until must be an ISO 8601 time: ${ctx.values.until}`);
       body.mutedUntil = ctx.values.until;
     }
     return api(ctx).call('POST', apiPath`/channels/${ch}/mute`, body);

package/src/commands/index.mjs

@@ -1,10 +1,5 @@
-// The commands of wx. GROUPS: `wx <group> <command>`; COMMANDS: single commands, `wx <command>`.
-//
-// A group is {summary, auth?, commands: {name: Command}}; a Command is
-//   {summary, usage, options, args: [min, max], auth?, run(ctx)}
-// `auth` (on the command, else on its group) loads a valid token before run(). An option is a node:util parseArgs
-// option plus `description` (help and completion), `choices` (the router refuses other values, completion offers
-// them) and `complete: 'profiles'` (completion offers the logged-in profiles).
+// The commands of wx. GROUPS: `wx <group> <command>`; COMMANDS: single commands, `wx <command>`. What a group and
+// a command are: wldx-core/registry. login, logout, status and profile come from the core, shared with wx-admin.
 import {groups as calls} from './calls.mjs';
 import {groups as channel} from './channel.mjs';
 import {groups as chat} from './chat.mjs';
@@ -12,13 +7,13 @@ import {groups as conversations} from './conversations.mjs';
 import {groups as file} from './file.mjs';
 import {groups as inbox} from './inbox.mjs';
 import {groups as live} from './live.mjs';
-import {login, logout} from './login.mjs';
+import {login, logout} from 'wldx-core/commands/login';
 import {groups as meetings} from './meetings.mjs';
 import {groups as phone} from './phone.mjs';
-import {groups as profile} from './profile.mjs';
+import {groups as profile} from 'wldx-core/commands/profile';
 import {groups as reports} from './reports.mjs';
 import {groups as section} from './section.mjs';
-import status from './status.mjs';
+import status from 'wldx-core/commands/status';
 import {groups as user} from './user.mjs';
 
 // In the order of the help: chats, then calls and meetings on record, then now, then the phone.
@@ -39,22 +34,3 @@ export const GROUPS = {
 };
 
 export const COMMANDS = {login, logout, status};
-
-export const COMMON_OPTIONS = {
-  help: {type: 'boolean', short: 'h', description: 'help of the command'},
-};
-
-// Taken by the router wherever they stand (as in the internal Wildix CLI); a command never defines these names.
-export const GLOBAL_OPTIONS = {
-  profile: {type: 'string', placeholder: 'EMAIL', description: 'the profile (a logged-in e-mail) to use; else WILDIX_EMAIL, else the default', complete: 'profiles'},
-  output: {type: 'string', choices: ['text', 'json'], description: 'text for people (default), JSON for scripts and agents'},
-  pretty: {type: 'boolean', description: 'indent the JSON'},
-  'no-color': {type: 'boolean', description: 'no colors in the text'},
-};
-
-export const REGISTRY = {groups: GROUPS, commands: COMMANDS};
-
-const own = (o, k) => (o && Object.hasOwn(o, k) ? o[k] : undefined);
-export const groupOf = (name, registry = REGISTRY) => own(registry.groups, name);
-export const commandOf = (group, name) => own(group?.commands, name);
-export const singleOf = (name, registry = REGISTRY) => own(registry.commands, name);

package/src/commands/live.mjs

@@ -5,13 +5,23 @@
 // skill (live.sh, live.mjs, stats.mjs): the same commands, options, limits and JSON; `watch` and
 // `transcript --follow` print one JSON object per event, {"event": "<EVENT>", "data": {…}} (the skill printed
 // `<EVENT> {…}`).
-import {jwtClaims} from '../auth.mjs';
-import {AuthError, UsageError} from '../errors.mjs';
+import {jwtClaims} from 'wldx-core/auth';
+import {AuthError, UsageError} from 'wldx-core/errors';
 import {connect, explain, subscription} from '../live/socket.mjs';
 import {SLA_SECONDS, WINDOWS, statsOptions} from '../live/stats.mjs';
 import {conversationsText, eventText, presenceText, queuesText, transcriptText} from '../live/text.mjs';
-import {callIdBySip, conversationsResult, drop, makeViews, presenceResult, queuesResult, transcriptEvents, transcriptSnapshot, watchFrames} from '../live/views.mjs';
-import {wdaWsUrl} from '../services.mjs';
+import {
+  callIdBySip,
+  conversationsResult,
+  drop,
+  makeViews,
+  presenceResult,
+  queuesResult,
+  transcriptEvents,
+  transcriptSnapshot,
+  watchFrames,
+} from '../live/views.mjs';
+import {wdaWsUrl} from 'wldx-core/services';
 
 // Settings of the connection; tests replace them (the WebSocket constructor, shorter waits).
 export const liveOptions = {
@@ -33,7 +43,12 @@ const retryDelay = (attempt) => liveOptions.retryDelays[attempt - 1] ?? liveOpti
 function loginOf(token) {
   const claims = jwtClaims(token);
   const ext = claims['custom:pbx_user_extension'];
-  return {company: claims.company, myExtension: ext ? String(ext) : undefined, license: claims['custom:pbx_license'], exp: claims.exp};
+  return {
+    company: claims.company,
+    myExtension: ext ? String(ext) : undefined,
+    license: claims['custom:pbx_license'],
+    exp: claims.exp,
+  };
 }
 
 function open(ctx, token, login) {
@@ -48,7 +63,12 @@ function open(ctx, token, login) {
 }
 
 function viewsOf(ctx, login) {
-  return makeViews({full: Boolean(ctx.values.full), company: login.company, myExtension: login.myExtension, now: () => ctx.clock()});
+  return makeViews({
+    full: Boolean(ctx.values.full),
+    company: login.company,
+    myExtension: login.myExtension,
+    now: () => ctx.clock(),
+  });
 }
 
 // A one-shot command: connect, run fn(connection, login), close. Ctrl-C closes the connection and prints nothing.
@@ -72,7 +92,8 @@ async function oneShot(ctx, fn) {
 // ── option checks (the limits of live.sh) ─────────────────────────────────────────────────────────────────────
 function wholeNumber(name, value, min, max) {
   if (value === undefined) return undefined;
-  if (!/^[0-9]{1,12}$/.test(value) || Number(value) < min || Number(value) > max) throw new UsageError(`--${name} must be a whole number from ${min} to ${max}: ${value}`);
+  if (!/^[0-9]{1,12}$/.test(value) || Number(value) < min || Number(value) > max)
+    throw new UsageError(`--${name} must be a whole number from ${min} to ${max}: ${value}`);
   return Number(value);
 }
 
@@ -85,20 +106,33 @@ const EXTENSION = /^[0-9]{1,15}$/;
 const wantsStats = (v) => Boolean(v.stats || v.window !== undefined || v.sla !== undefined);
 const statsOptsOf = (ctx) => statsOptions(ctx.values.window ?? 'today', Number(ctx.values.sla ?? 20), ctx.clock());
 
-const full = {type: 'boolean', description: 'everything the service sends, also e-mail, IP address, location and user agent of people'};
+const full = {
+  type: 'boolean',
+  description: 'everything the service sends, also e-mail, IP address, location and user agent of people',
+};
 const statsOptionsDef = {
   stats: {type: 'boolean', description: 'the figures of each queue, of each agent in it and of all of them together'},
-  window: {type: 'string', choices: WINDOWS, description: 'the window of the figures: today (default, from the local midnight) or the last minutes (implies --stats)'},
-  sla: {type: 'string', choices: SLA_SECONDS.map(String), description: 'the answer-within target of the service level, seconds (20 by default; implies --stats)'},
+  window: {
+    type: 'string',
+    choices: WINDOWS,
+    description:
+      'the window of the figures: today (default, from the local midnight) or the last minutes (implies --stats)',
+  },
+  sla: {
+    type: 'string',
+    choices: SLA_SECONDS.map(String),
+    description: 'the answer-within target of the service level, seconds (20 by default; implies --stats)',
+  },
 };
 
 // ── commands ─────────────────────────────────────────────────────────────────────────────────────────────────
 const queues = {
   summary: 'the call queues of the company: strategy, calls in them now, agents with their status (Premium)',
-  usage: 'wx live queues [--name TEXT] [--pbx SERIAL] [--busy] [--paused] [--active] [--stats] [--window W] [--sla S] [--full]',
+  usage:
+    'wx live queues [--name TEXT] [--pbx SERIAL] [--busy] [--paused] [--active] [--stats] [--window W] [--sla S] [--full]',
   details: [
-    'The queues with calls first. An agent\'s status is the queue\'s view (available, pause…); reason and message are',
-    'the user\'s own status (DND, AWAY and its text). --stats counts since the local midnight (--window today) or over',
+    "The queues with calls first. An agent's status is the queue's view (available, pause…); reason and message are",
+    "the user's own status (DND, AWAY and its text). --stats counts since the local midnight (--window today) or over",
     'the last 15/30/45/60 minutes (WDA counts in 15-minute buckets: window.minutes says what was covered). In text the',
     'agents are listed under their queue when 10 queues or fewer are shown.',
   ].join('\n'),
@@ -115,11 +149,16 @@ const queues = {
   async run(ctx) {
     const v = ctx.values;
     check('pbx', v.pbx, /^[A-Za-z0-9]{4,32}$/, 'Not a PBX serial');
-    if (v.name !== undefined && v.name.length > 100) throw new UsageError('--name is too long (100 characters at most)');
+    if (v.name !== undefined && v.name.length > 100)
+      throw new UsageError('--name is too long (100 characters at most)');
     const stats = wantsStats(v);
     return oneShot(ctx, async (conn, login) => {
       const items = await conn.snapshot('services', stats ? statsOptsOf(ctx) : {});
-      return queuesResult(items, {pbx: v.pbx, name: v.name, busy: v.busy, paused: v.paused, active: v.active, stats}, viewsOf(ctx, login));
+      return queuesResult(
+        items,
+        {pbx: v.pbx, name: v.name, busy: v.busy, paused: v.paused, active: v.active, stats},
+        viewsOf(ctx, login),
+      );
     });
   },
   text: queuesText,
@@ -128,13 +167,19 @@ const queues = {
 const conversations = {
   summary: 'the calls, customer chats and conferences going on now, newest first, with their live insights (Premium)',
   usage: 'wx live conversations [--calls] [--chats] [--conferences] [--mine] [--status S] [--limit N] [--full]',
-  details: 'byType counts all of them before the filters. --status keeps the chats in that status (or the calls whose last flow is in it).',
+  details:
+    'byType counts all of them before the filters. --status keeps the chats in that status (or the calls whose last flow is in it).',
   options: {
     calls: {type: 'boolean', description: 'only calls'},
     chats: {type: 'boolean', description: 'only customer chats'},
     conferences: {type: 'boolean', description: 'only conferences'},
     mine: {type: 'boolean', description: 'only your own calls'},
-    status: {type: 'string', placeholder: 'S', description: 'only this status: TALKING, HOLD, CONNECTING, WAITFIRSTREPLY, WAITREPLYFROMAGENT, WAITREPLYFROMGUEST…'},
+    status: {
+      type: 'string',
+      placeholder: 'S',
+      description:
+        'only this status: TALKING, HOLD, CONNECTING, WAITFIRSTREPLY, WAITREPLYFROMAGENT, WAITREPLYFROMGUEST…',
+    },
     limit: {type: 'string', placeholder: 'N', description: 'at most N items, 1 to 1000 (50 by default)'},
     full,
   },
@@ -155,7 +200,8 @@ const conversations = {
 const presence = {
   summary: 'status, status message, "until" and phone registration of colleagues (is someone available)',
   usage: 'wx live presence <extension>... [--full]',
-  details: 'Up to 50 extensions of your company. phone is REGISTERED when a phone of theirs is online; an extension nobody has gives status unknown.',
+  details:
+    'Up to 50 extensions of your company. phone is REGISTERED when a phone of theirs is online; an extension nobody has gives status unknown.',
   options: {full},
   args: [1, 50],
   async run(ctx) {
@@ -199,7 +245,8 @@ const transcript = {
   args: [1, 1],
   async run(ctx) {
     const arg = ctx.positionals[0];
-    if (!/^(conference:)?[A-Za-z0-9._@:+-]{1,200}$/.test(arg)) throw new UsageError(`Name the call: its WDA id or its SIP call id (or conference:<id>): ${arg}`);
+    if (!/^(conference:)?[A-Za-z0-9._@:+-]{1,200}$/.test(arg))
+      throw new UsageError(`Name the call: its WDA id or its SIP call id (or conference:<id>): ${arg}`);
     const secs = wholeNumber('for', ctx.values.for, 1, MAX_SECONDS) ?? 0;
     return oneShot(ctx, async (conn, login) => {
       const views = viewsOf(ctx, login);
@@ -209,7 +256,11 @@ const transcript = {
       try {
         items = await conn.snapshot('transcriptions', {state: true, filter: [[kind, id]]});
       } catch (e) {
-        throw new Error(e.message.includes('not found') ? `${kind} ${id} is not going on now (a live transcript exists only while it lasts)` : e.message);
+        throw new Error(
+          e.message.includes('not found')
+            ? `${kind} ${id} is not going on now (a live transcript exists only while it lasts)`
+            : e.message,
+        );
       }
       const {call, snapshot} = transcriptSnapshot(items, id, kind, views);
       if (!ctx.values.follow) return snapshot;
@@ -248,7 +299,8 @@ const transcript = {
 
 const watch = {
   summary: 'a live feed: one line per change of the conversations, queues or presence until stopped',
-  usage: 'wx live watch [--conversations] [--calls] [--mine] [--queues] [--stats] [--window W] [--sla S] [--presence EXT]... [--for SECONDS] [--full]',
+  usage:
+    'wx live watch [--conversations] [--calls] [--mine] [--queues] [--stats] [--window W] [--sla S] [--presence EXT]... [--for SECONDS] [--full]',
   details: [
     'Without a choice: --conversations. --stats implies --queues and adds QUEUES and QUEUE_STATS lines. Events: READY,',
     'RECONNECTING, RECONNECTED, ERROR, CALL, CALL_COMPLETE, CALL_INTERRUPTED, CALL_ANNOTATION, CHAT…, CONFERENCE…,',
@@ -295,7 +347,9 @@ const watch = {
     const subscriptions = (first = false) => [
       ...(wantConv ? [subscription('conversations', {state: false})] : []),
       ...(wantQueues ? [queueSub(first && wantStats)] : []),
-      ...(presenceExt.length ? [subscription('presence', {state: false, filter: presenceExt.map((e) => [null, login.company, e])})] : []),
+      ...(presenceExt.length
+        ? [subscription('presence', {state: false, filter: presenceExt.map((e) => [null, login.company, e])})]
+        : []),
     ];
 
     return new Promise((resolve, reject) => {
@@ -369,13 +423,17 @@ const watch = {
         for (const s of subscriptions(true)) c.send(s);
         attempts = 0;
         clearInterval(keepalive);
-        keepalive = setInterval(() => subscriptions().forEach((s) => conn?.send(s)), liveOptions.keepaliveMs);
+        keepalive = setInterval(() => {
+          for (const s of subscriptions()) conn?.send(s);
+        }, liveOptions.keepaliveMs);
         ctx.emit({
           event: ready ? 'RECONNECTED' : 'READY',
           data: drop({
             extension: login.myExtension,
             license: login.license,
-            topics: [wantConv && 'conversations', wantQueues && 'queues', presenceExt.length && 'presence'].filter(Boolean),
+            topics: [wantConv && 'conversations', wantQueues && 'queues', presenceExt.length && 'presence'].filter(
+              Boolean,
+            ),
             calls: v.calls || undefined,
             mine: v.mine || undefined,
             stats: wantQueues && wantStats ? statsOpts() : undefined,