wldx-cli 0.1.0 → 1.0.0

package/src/phone/xml.mjs

@@ -0,0 +1,56 @@
+// A small XML reader for the bodies of the SIP event packages of the PBX (dialog-info, reginfo, active-device):
+// elements, attributes, text. No DTD, no external entities (a DOCTYPE is refused). Element names are matched
+// without their namespace prefix, as ltx does.
+
+const TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[([\s\S]*?)\]\]>|<\?[\s\S]*?\?>|<\/\s*([^\s>]+)\s*>|<([^\s/>!?]+)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>|([^<]+)/y;
+const ATTR = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const NAMED = {lt: '<', gt: '>', amp: '&', quot: '"', apos: "'"};
+
+function decode(s) {
+  return s.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-z]+);/g, (m, e) => {
+    if (e[0] === '#') {
+      const code = e[1] === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+      return code <= 0x10ffff ? String.fromCodePoint(code) : m;
+    }
+    return NAMED[e] ?? m;
+  });
+}
+
+const local = (name) => name.slice(name.indexOf(':') + 1);
+
+// Parses a document and returns its root element: {name, attrs, children, text}. Throws on what is not XML.
+export function parseXml(text) {
+  const s = String(text ?? '').trim();
+  if (/<!DOCTYPE/i.test(s)) throw new Error('XML with a DOCTYPE is not accepted');
+  const root = {name: '#document', attrs: {}, children: [], text: ''};
+  const stack = [root];
+  TOKEN.lastIndex = 0;
+  while (TOKEN.lastIndex < s.length) {
+    const at = TOKEN.lastIndex;
+    const m = TOKEN.exec(s);
+    if (!m || m.index !== at) throw new Error(`not XML at character ${at}`);
+    const top = stack[stack.length - 1];
+    const [whole, cdata, closing, opening, attrText, selfClosing, chars] = m;
+    if (whole.startsWith('<!--') || whole.startsWith('<?')) continue;
+    if (cdata !== undefined) top.text += cdata;
+    else if (chars !== undefined) top.text += decode(chars);
+    else if (closing !== undefined) {
+      if (stack.length < 2 || top.name !== local(closing)) throw new Error(`unexpected </${closing}>`);
+      stack.pop();
+    } else if (opening !== undefined) {
+      const attrs = {};
+      for (const a of (attrText ?? '').matchAll(ATTR)) attrs[a[1]] = decode(a[2] ?? a[3] ?? '');
+      const el = {name: local(opening), attrs, children: [], text: ''};
+      top.children.push(el);
+      if (!selfClosing) stack.push(el);
+    }
+  }
+  if (stack.length !== 1) throw new Error(`<${stack[stack.length - 1].name}> is not closed`);
+  const [el] = root.children;
+  if (!el || root.children.length > 1) throw new Error('an XML document has one root element');
+  return el;
+}
+
+export const child = (el, name) => el?.children.find((c) => c.name === name);
+export const children = (el, name) => el?.children.filter((c) => c.name === name) ?? [];
+export const text = (el) => (el ? el.text.trim() : undefined);

package/src/services.mjs

@@ -0,0 +1,58 @@
+// The addresses of the Wildix services. The token is sent only to these: https/wss hosts under wildix.com, the
+// x-bees API, and the user's own PBX named in the claims of the login token. Overrides (tests against a local
+// server) are honoured only with WILDIX_ALLOW_CUSTOM_URL=1, except WILDIX_STREAM_URL and WILDIX_WDA_URL, which may
+// name another https host under wildix.com.
+import {jwtClaims} from './auth.mjs';
+import {UsageError} from './errors.mjs';
+
+export const XBEES_API = 'https://api.x-bees.com';
+
+const UNDER_WILDIX = (scheme) => new RegExp(`^${scheme}://[a-z0-9-]+(\\.[a-z0-9-]+)*\\.wildix\\.com(:[0-9]+)?$`);
+const HTTPS_WILDIX = UNDER_WILDIX('https');
+const HOST = /^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)+$/;
+
+const custom = (env) => env.WILDIX_ALLOW_CUSTOM_URL === '1';
+const trim = (url) => url.replace(/\/+$/, '');
+
+// base(variable, default, env, {wildixOverride}): the default, or the override in `variable` when allowed.
+function base(variable, fallback, env, {wildixOverride = false} = {}) {
+  const given = env[variable];
+  if (!given) return fallback;
+  const url = trim(given);
+  if (custom(env)) return url;
+  if (wildixOverride && HTTPS_WILDIX.test(url)) return url;
+  throw new UsageError(
+    wildixOverride
+      ? `${variable} must be https://<host>.wildix.com (another address only with WILDIX_ALLOW_CUSTOM_URL=1), got: ${url}`
+      : `${variable} is honoured only with WILDIX_ALLOW_CUSTOM_URL=1 (tests), got: ${url}`,
+  );
+}
+
+function region(env) {
+  const r = env.WILDIX_STREAM_REGION || 'eu-1';
+  if (!/^[a-z0-9-]{1,32}$/.test(r)) throw new UsageError(`WILDIX_STREAM_REGION is not a region: ${r}`);
+  return r;
+}
+
+// Chats (the stream service): https://<region>.stream.wildix.com, the live feed wss://<region>-ws.stream.wildix.com.
+export const streamUrl = (env = process.env) => base('WILDIX_STREAM_URL', `https://${region(env)}.stream.wildix.com`, env, {wildixOverride: true});
+export const streamWsUrl = (env = process.env) => base('WILDIX_STREAM_WS_URL', `wss://${region(env)}-ws.stream.wildix.com`, env);
+
+// Wildix Data Analytics: history, insights, reports (https://wda.wildix.com), the live stream (wss://wda-ws...).
+export const wdaUrl = (env = process.env) => base('WILDIX_WDA_URL', 'https://wda.wildix.com', env, {wildixOverride: true});
+export const wdaWsUrl = (env = process.env) => base('WILDIX_WDA_WS_URL', 'wss://wda-ws.wildix.com', env);
+
+// The x-bees API (users, conversations of the older service, token check).
+export const xbeesUrl = (env = process.env) => base('WILDIX_XBEES_URL', XBEES_API, env);
+
+// The user's PBX: the login token names it (custom:pbx_domain, custom:pbx_port) and the PBX accepts that token.
+export function pbxUrl(token, env = process.env) {
+  if (env.WILDIX_PBX_URL) return base('WILDIX_PBX_URL', undefined, env);
+  const claims = jwtClaims(token);
+  const host = claims['custom:pbx_domain'];
+  const port = claims['custom:pbx_port'];
+  if (!host) throw new UsageError('This login is not linked to a PBX (the token has no custom:pbx_domain): this needs a PBX user');
+  if (!HOST.test(host)) throw new UsageError(`The PBX address in the login is not a host name: ${host}`);
+  if (port !== undefined && port !== '' && !/^[0-9]{1,5}$/.test(String(port))) throw new UsageError(`The PBX port in the login is not a number: ${port}`);
+  return `https://${host}${port && String(port) !== '443' ? `:${port}` : ''}`;
+}

package/src/stream.mjs

@@ -1,19 +1,12 @@
 // The Wildix stream service (chats): https://<region>.stream.wildix.com/api/v1, region eu-1 by default.
 import {UsageError} from './errors.mjs';
 import {request} from './http.mjs';
+import {streamUrl} from './services.mjs';
 
-const WILDIX_HOST = /^https:\/\/[a-z0-9-]+(\.[a-z0-9-]+)*\.wildix\.com(:[0-9]+)?$/;
 const ID = /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
 
-// The base address. The token is only ever sent to https://<host>.wildix.com; WILDIX_ALLOW_CUSTOM_URL=1 lifts this
-// for tests against a local server.
-export function streamBase(env = process.env) {
-  const base = (env.WILDIX_STREAM_URL || `https://${env.WILDIX_STREAM_REGION || 'eu-1'}.stream.wildix.com`).replace(/\/+$/, '');
-  if (env.WILDIX_ALLOW_CUSTOM_URL !== '1' && !WILDIX_HOST.test(base)) {
-    throw new UsageError(`The stream service address must be https://<host>.wildix.com, got: ${base}`);
-  }
-  return base;
-}
+// The base address (see services.mjs for the overrides).
+export const streamBase = (env = process.env) => streamUrl(env);
 
 const valid = (v) => ID.test(v) && !v.includes('..');
 
@@ -38,6 +31,6 @@ export function messageId(input) {
 export function streamClient({token, env = process.env, fetchImpl}) {
   const api = `${streamBase(env)}/api/v1`;
   return {
-    call: (method, path, body) => request(api + path, {method, token, body, fetchImpl, service: 'the stream service'}),
+    call: (method, path, body, options = {}) => request(api + path, {method, token, body, fetchImpl, service: 'the stream service', ...options}),
   };
 }

package/src/commands/auth.mjs

@@ -1,32 +0,0 @@
-// wx auth: the saved Wildix sessions (shared with the wildix-auth agent skill). Never prints a token.
-import {AuthError} from '../errors.mjs';
-import {pickAccount, sessions} from '../auth.mjs';
-
-export default {
-  summary: 'the Wildix accounts you are logged in with',
-  commands: {
-    status: {
-      summary: 'saved sessions, which one is used and until when its token is valid (no network)',
-      usage: 'wx auth status',
-      options: {},
-      args: [0, 0],
-      async run({values, env, now}) {
-        let account = null;
-        try {
-          account = pickAccount(env, values.account);
-        } catch (e) {
-          if (!(e instanceof AuthError)) throw e;
-        }
-        return {
-          account,
-          tokenFromEnvironment: Boolean(env.WILDIX_ID_TOKEN),
-          sessions: sessions(env).map((s) => ({
-            email: s.email,
-            tokenValidUntil: s.expiresAt ? new Date(s.expiresAt).toISOString() : null,
-            expired: s.expiresAt <= now,
-          })),
-        };
-      },
-    },
-  },
-};