@instantkom/cli 3.129.2

package/dist/send/fallback.js

@@ -0,0 +1,38 @@
+import { ApiError } from '../errors/api-error.js';
+const ALIASES = {
+    wa: ['whatsapp', 'wa'],
+    whatsapp: ['whatsapp', 'wa'],
+    sms: ['sms'],
+};
+function channelsFromResponse(response) {
+    if (Array.isArray(response))
+        return 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));
+}
+export async function resolveFallbackChannels(client, aliasesCsv) {
+    const aliases = aliasesCsv
+        .split(',')
+        .map((alias) => alias.trim())
+        .filter(Boolean);
+    if (aliases.length === 0) {
+        throw new ApiError('user_error', '--channels must contain at least one channel alias');
+    }
+    const response = await client.get('/v1/channels', { limit: 100 });
+    const channels = channelsFromResponse(response);
+    return aliases.map((alias) => {
+        const channel = channels.find((candidate) => matchesAlias(candidate, alias));
+        if (!channel) {
+            throw new ApiError('user_error', `No channel found for alias '${alias}'`);
+        }
+        return { alias, channelId: channel.id };
+    });
+}

package/dist/send/media.d.ts

@@ -0,0 +1,2 @@
+import type { MultipartFile } from '../api-client.js';
+export declare function prepareMediaFiles(paths: string[] | undefined): MultipartFile[];

package/dist/send/media.js

@@ -0,0 +1,41 @@
+import { readFileSync, statSync } from 'fs';
+import { basename } from 'path';
+import { ApiError } from '../errors/api-error.js';
+const MIME_BY_EXTENSION = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    mp4: 'video/mp4',
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    pdf: 'application/pdf',
+};
+export function prepareMediaFiles(paths) {
+    if (!paths || paths.length === 0)
+        return [];
+    if (paths.length > 1) {
+        throw new ApiError('user_error', 'Only one --media attachment is supported by the current API');
+    }
+    return paths.map((filePath) => {
+        let stat;
+        try {
+            stat = statSync(filePath);
+        }
+        catch {
+            throw new ApiError('user_error', `Media file not found: ${filePath}`);
+        }
+        if (!stat.isFile()) {
+            throw new ApiError('user_error', `Media path is not a file: ${filePath}`);
+        }
+        const extension = filePath.split('.').pop()?.toLowerCase() ?? '';
+        return {
+            fieldName: 'media',
+            filename: basename(filePath),
+            contentType: MIME_BY_EXTENSION[extension] ?? 'application/octet-stream',
+            buffer: readFileSync(filePath),
+        };
+    });
+}

package/dist/send/payload.d.ts

@@ -0,0 +1,23 @@
+export interface MessagePayloadInput {
+    recipientId: number;
+    text: string;
+    scheduledAt?: number;
+    templateId?: number;
+}
+export interface BroadcastPayloadInput {
+    channelId?: number;
+    segmentId?: number;
+    targets?: Array<{
+        channelId: number;
+        segmentId?: number;
+    }>;
+    text: string;
+    scheduledAt?: number;
+    templateId?: number;
+    sendStatus?: 'draft' | 'scheduled' | 'sending' | 'sent' | 'failed';
+    autoApprove?: boolean;
+}
+type ApiPayload = Record<string, string | number | boolean | undefined>;
+export declare function createMessagePayload(input: MessagePayloadInput): ApiPayload;
+export declare function createBroadcastPayload(input: BroadcastPayloadInput): ApiPayload;
+export {};

package/dist/send/payload.js

@@ -0,0 +1,22 @@
+export function createMessagePayload(input) {
+    return {
+        recipientId: input.recipientId,
+        message: input.text,
+        messageType: 'text',
+        ...(input.scheduledAt ? { scheduledAt: input.scheduledAt } : {}),
+        ...(input.templateId ? { templateId: input.templateId } : {}),
+    };
+}
+export function createBroadcastPayload(input) {
+    return {
+        ...(input.channelId ? { channelId: input.channelId } : {}),
+        ...(input.segmentId ? { segmentId: input.segmentId } : {}),
+        ...(input.targets ? { targets: JSON.stringify(input.targets) } : {}),
+        message: input.text,
+        broadcastType: 'text',
+        ...(input.scheduledAt ? { scheduledAt: input.scheduledAt } : {}),
+        ...(input.templateId ? { templateId: input.templateId } : {}),
+        ...(input.sendStatus ? { sendStatus: input.sendStatus } : {}),
+        ...(input.autoApprove !== undefined ? { autoApprove: input.autoApprove } : {}),
+    };
+}

package/dist/send/recipient-resolver.d.ts

@@ -0,0 +1,13 @@
+import type { ApiClient } from '../api-client.js';
+export interface RecipientRecord {
+    id: number;
+    channelId: number;
+    identifier: string;
+    name?: string;
+}
+export interface ResolveRecipientOptions {
+    client: Pick<ApiClient, 'get' | 'post'>;
+    channelId: number;
+    to: string;
+}
+export declare function resolveRecipient({ client, channelId, to, }: ResolveRecipientOptions): Promise<RecipientRecord>;

package/dist/send/recipient-resolver.js

@@ -0,0 +1,28 @@
+import { ApiError } from '../errors/api-error.js';
+function normalizeIdentifier(value) {
+    return value.replace(/[\s().-]/g, '');
+}
+function extractRecipients(response) {
+    if (Array.isArray(response))
+        return response;
+    return response.data ?? response.items ?? [];
+}
+export async function resolveRecipient({ client, channelId, to, }) {
+    if (!Number.isInteger(channelId) || channelId < 1) {
+        throw new ApiError('user_error', '--channel must be a positive integer');
+    }
+    const trimmed = to.trim();
+    if (!trimmed) {
+        throw new ApiError('user_error', '--to is required');
+    }
+    const searched = await client.get('/v1/contacts', { channelId, search: trimmed, limit: 20 });
+    const normalizedTo = normalizeIdentifier(trimmed);
+    const existing = extractRecipients(searched).find((recipient) => (recipient.channelId === channelId
+        && normalizeIdentifier(recipient.identifier) === normalizedTo));
+    if (existing)
+        return existing;
+    return client.post('/v1/contacts', {
+        channelId,
+        identifier: trimmed,
+    });
+}

package/dist/send/schedule.d.ts

@@ -0,0 +1 @@
+export declare function parseSendAt(input: string | undefined): number | undefined;

package/dist/send/schedule.js

@@ -0,0 +1,19 @@
+import { ApiError } from '../errors/api-error.js';
+const ISO_WITH_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+export function parseSendAt(input) {
+    if (!input)
+        return undefined;
+    if (!ISO_WITH_TIME.test(input)) {
+        throw new ApiError('user_error', '--send-at must be an ISO-8601 date-time');
+    }
+    const date = new Date(input);
+    if (Number.isNaN(date.getTime())) {
+        throw new ApiError('user_error', '--send-at must be a valid ISO-8601 date-time');
+    }
+    const seconds = Math.floor(date.getTime() / 1000);
+    const now = Math.floor(Date.now() / 1000);
+    if (seconds <= now) {
+        throw new ApiError('user_error', '--send-at must be in the future');
+    }
+    return seconds;
+}

package/dist/tail/sse.d.ts

@@ -0,0 +1,24 @@
+export interface RealtimeEvent {
+    event: string;
+    payload?: unknown;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+export interface SseFrame {
+    event?: string;
+    data: string;
+}
+export declare class SseParser {
+    private buffer;
+    push(chunk: string): SseFrame[];
+    flush(): SseFrame[];
+}
+export declare function parseFrame(rawFrame: string): SseFrame | null;
+export declare function parseRealtimeEvent(frame: SseFrame): RealtimeEvent | null;
+export declare function shouldEmitForChannel(event: RealtimeEvent, channelId: number): boolean;
+export declare function streamRealtimeEvents({ apiKey, apiUrl, channelId, onEvent, }: {
+    apiKey: string;
+    apiUrl: string;
+    channelId: number;
+    onEvent: (event: RealtimeEvent) => void;
+}): Promise<void>;

package/dist/tail/sse.js

@@ -0,0 +1,139 @@
+import { ApiError } from '../errors/api-error.js';
+export class SseParser {
+    buffer = '';
+    push(chunk) {
+        this.buffer += chunk.replace(/\r\n/g, '\n');
+        const frames = [];
+        let boundary = this.buffer.indexOf('\n\n');
+        while (boundary !== -1) {
+            const rawFrame = this.buffer.slice(0, boundary);
+            this.buffer = this.buffer.slice(boundary + 2);
+            const frame = parseFrame(rawFrame);
+            if (frame)
+                frames.push(frame);
+            boundary = this.buffer.indexOf('\n\n');
+        }
+        return frames;
+    }
+    flush() {
+        if (!this.buffer.trim()) {
+            this.buffer = '';
+            return [];
+        }
+        const frame = parseFrame(this.buffer);
+        this.buffer = '';
+        return frame ? [frame] : [];
+    }
+}
+export function parseFrame(rawFrame) {
+    const data = [];
+    let event;
+    for (const line of rawFrame.split('\n')) {
+        if (!line || line.startsWith(':'))
+            continue;
+        const separator = line.indexOf(':');
+        const field = separator === -1 ? line : line.slice(0, separator);
+        const rawValue = separator === -1 ? '' : line.slice(separator + 1);
+        const value = rawValue.startsWith(' ') ? rawValue.slice(1) : rawValue;
+        if (field === 'event')
+            event = value;
+        if (field === 'data')
+            data.push(value);
+    }
+    if (data.length === 0)
+        return null;
+    return { event, data: data.join('\n') };
+}
+export function parseRealtimeEvent(frame) {
+    try {
+        const parsed = JSON.parse(frame.data);
+        if (frame.event && typeof parsed.event !== 'string') {
+            parsed.event = frame.event;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function shouldEmitForChannel(event, channelId) {
+    if (event.event === 'system:connected' || event.event === 'heartbeat')
+        return false;
+    if (event.event !== 'inbox:new-message')
+        return false;
+    const ids = collectChannelIds(event.payload);
+    return ids.has(String(channelId));
+}
+function collectChannelIds(value) {
+    const ids = new Set();
+    collectChannelIdsInto(value, ids);
+    return ids;
+}
+function collectChannelIdsInto(value, ids) {
+    if (value === null || value === undefined)
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectChannelIdsInto(item, ids);
+        return;
+    }
+    if (typeof value !== 'object')
+        return;
+    for (const [key, nested] of Object.entries(value)) {
+        if (isChannelIdKey(key) && (typeof nested === 'number' || typeof nested === 'string')) {
+            ids.add(String(nested));
+        }
+        collectChannelIdsInto(nested, ids);
+    }
+}
+function isChannelIdKey(key) {
+    return key === 'channelId' || key === 'channel_id' || key === 'cid';
+}
+export async function streamRealtimeEvents({ apiKey, apiUrl, channelId, onEvent, }) {
+    const response = await fetch(new URL('/app/realtime/stream', normalizeApiUrl(apiUrl)), {
+        headers: {
+            Accept: 'text/event-stream',
+            'X-API-KEY': apiKey,
+        },
+    });
+    if (!response.ok) {
+        throw new ApiError(mapStatus(response.status), `Realtime stream failed with HTTP ${response.status}`, response.status);
+    }
+    if (!response.body) {
+        throw new ApiError('network', 'Realtime stream response had no body');
+    }
+    const parser = new SseParser();
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            const frames = done
+                ? parser.flush()
+                : parser.push(decoder.decode(value, { stream: true }));
+            for (const frame of frames) {
+                const event = parseRealtimeEvent(frame);
+                if (event && shouldEmitForChannel(event, channelId)) {
+                    onEvent(event);
+                }
+            }
+            if (done)
+                break;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function normalizeApiUrl(apiUrl) {
+    return apiUrl.endsWith('/') ? apiUrl : `${apiUrl}/`;
+}
+function mapStatus(status) {
+    if (status === 401 || status === 403)
+        return 'unauthorized';
+    if (status === 429)
+        return 'rate_limited';
+    if (status >= 500)
+        return 'server_error';
+    return 'user_error';
+}

package/dist/templates/render-template.d.ts

@@ -0,0 +1,14 @@
+export interface TemplateLike {
+    id: number;
+    name?: string;
+    message?: string;
+    headerFooter?: unknown;
+}
+export interface RenderedTemplate {
+    id: number;
+    name?: string;
+    message: string;
+    headerFooter?: unknown;
+}
+export declare function parseVars(values: string[] | undefined): Record<string, string>;
+export declare function renderTemplate(template: TemplateLike, vars: Record<string, string>): RenderedTemplate;

package/dist/templates/render-template.js

@@ -0,0 +1,46 @@
+import { ApiError } from '../errors/api-error.js';
+const PLACEHOLDER = /\{\{\s*([A-Za-z0-9_.-]+)\s*\}\}/g;
+export function parseVars(values) {
+    const vars = {};
+    for (const value of values ?? []) {
+        const eq = value.indexOf('=');
+        if (eq <= 0) {
+            throw new ApiError('user_error', `Invalid --vars value '${value}'. Use key=value.`);
+        }
+        vars[value.slice(0, eq)] = value.slice(eq + 1);
+    }
+    return vars;
+}
+function renderString(input, vars, missing) {
+    return input.replace(PLACEHOLDER, (_match, key) => {
+        if (!(key in vars)) {
+            missing.add(key);
+            return `{{${key}}}`;
+        }
+        return vars[key] ?? '';
+    });
+}
+function renderUnknown(value, vars, missing) {
+    if (typeof value === 'string')
+        return renderString(value, vars, missing);
+    if (Array.isArray(value))
+        return value.map((item) => renderUnknown(item, vars, missing));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, renderUnknown(item, vars, missing)]));
+    }
+    return value;
+}
+export function renderTemplate(template, vars) {
+    const missing = new Set();
+    const message = renderString(template.message ?? '', vars, missing);
+    const headerFooter = renderUnknown(template.headerFooter, vars, missing);
+    if (missing.size > 0) {
+        throw new ApiError('user_error', `Missing template variables: ${Array.from(missing).sort().join(', ')}`);
+    }
+    return {
+        id: template.id,
+        name: template.name,
+        message,
+        headerFooter,
+    };
+}