@instantkom/cli 3.169.0 → 3.171.0

package/dist/api-client.js

@@ -42,6 +42,11 @@ export class ApiClient {
             if (!response.ok)
                 return false;
             const data = await this.parseResponse(response);
+            // A 2xx without an accessToken (empty/malformed body) must not count as a
+            // successful refresh -- otherwise ensureJwtToken hands back a stale/undefined
+            // token and the next request sends `Authorization: Bearer undefined` (#5264c).
+            if (!data.accessToken)
+                return false;
             this.jwtAccessToken = data.accessToken;
             if (data.refreshToken)
                 this.jwtRefreshToken = data.refreshToken;

package/dist/commands/send.js

@@ -51,9 +51,7 @@ export default class Send extends BaseCommand {
         }
         const scheduledAt = parseSendAt(flags['send-at']);
         const media = prepareMediaFiles(flags.media);
-        const idempotencyHeaders = flags['idempotency-key']
-            ? { 'Idempotency-Key': flags['idempotency-key'] }
-            : undefined;
+        const idempotencyKey = flags['idempotency-key'];
         if (flags['dry-run']) {
             const payload = {
                 channelId: flags.channel,
@@ -77,9 +75,22 @@ export default class Send extends BaseCommand {
         const channelAttempts = flags.channels
             ? await resolveFallbackChannels(client, flags.channels)
             : [{ alias: String(flags.channel), channelId: flags.channel }];
+        // Only the multi-channel fallback needs per-channel idempotency keys.
+        // Reusing one key across fallback channels let the API dedupe the SMS retry
+        // against the failed WhatsApp attempt, silently defeating fallback (#5264b).
+        // A single explicit channel keeps the exact key the caller passed, so
+        // audit-by-key / retry-with-key behaviour is unchanged.
+        const isFallback = channelAttempts.length > 1;
         const failures = [];
         for (const attempt of channelAttempts) {
             try {
+                const idempotencyHeaders = idempotencyKey
+                    ? {
+                        'Idempotency-Key': isFallback
+                            ? `${idempotencyKey}-${attempt.channelId}`
+                            : idempotencyKey,
+                    }
+                    : undefined;
                 const message = await this.sendViaChannel({
                     channelId: attempt.channelId,
                     client,

package/dist/send/fallback.js

@@ -1,8 +1,13 @@
 import { ApiError } from '../errors/api-error.js';
-const ALIASES = {
-    wa: ['whatsapp', 'wa'],
-    whatsapp: ['whatsapp', 'wa'],
-    sms: ['sms'],
+// Messenger aliases resolve to numeric gateway type ids (channel.gatewayTypeId,
+// = the DB gwtype). Matching on the id is robust against the API returning human
+// display names for gatewayType ("WhatsApp Cloud API"), which an exact string
+// match would miss. wa/whatsapp cover both the legacy on-prem WhatsApp (13) and
+// the modern Cloud API (17). Keep in sync with GatewayType (services/api).
+const ALIAS_GATEWAY_TYPE_IDS = {
+    wa: [13, 17],
+    whatsapp: [13, 17],
+    sms: [2],
 };
 function channelsFromResponse(response) {
     if (Array.isArray(response))
@@ -10,13 +15,31 @@ function channelsFromResponse(response) {
     return response.data ?? response.items ?? [];
 }
 function matchesAlias(channel, alias) {
-    const needles = ALIASES[alias.toLowerCase()] ?? [alias.toLowerCase()];
-    const haystack = [
-        String(channel.id),
-        channel.name ?? '',
-        channel.gatewayType ?? '',
-    ].join(' ').toLowerCase();
-    return needles.some((needle) => haystack.includes(needle));
+    const normalized = alias.toLowerCase();
+    // A numeric alias addresses a channel by its exact id. Substring matching
+    // here let '2' false-match ids 20/12/21 (#5264a).
+    if (/^\d+$/.test(normalized)) {
+        return String(channel.id) === normalized;
+    }
+    const gatewayType = (channel.gatewayType ?? '').toLowerCase();
+    // Known messenger aliases match on the numeric gateway type id, so multi-word
+    // display names ("WhatsApp Cloud API", gatewayTypeId 17) resolve correctly.
+    // The user-chosen channel name is deliberately never consulted -- a channel
+    // named "WA Backup via SMS" must not receive a WhatsApp message (#5264a).
+    const typeIds = ALIAS_GATEWAY_TYPE_IDS[normalized];
+    if (typeIds) {
+        if (channel.gatewayTypeId !== undefined) {
+            return typeIds.includes(channel.gatewayTypeId);
+        }
+        // Defensive fallback if a response omits gatewayTypeId: match the gateway
+        // display name by prefix (still never the channel name).
+        return normalized === 'sms'
+            ? gatewayType === 'sms'
+            : gatewayType.startsWith('whatsapp');
+    }
+    // Arbitrary alias: exact case-insensitive match on the gateway display name
+    // (never a substring, never the channel name).
+    return gatewayType === normalized;
 }
 export async function resolveFallbackChannels(client, aliasesCsv) {
     const aliases = aliasesCsv

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@instantkom/cli",
-  "version": "3.169.0",
+  "version": "3.171.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@instantkom/cli",
-      "version": "3.169.0",
+      "version": "3.171.0",
       "license": "MIT",
       "dependencies": {
         "@oclif/core": "^4",