chatbase 0.1.0 → 0.2.0

package/dist/commands/whatsapp/send-template.js

@@ -0,0 +1,94 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { readTextInput } from '../../base/body-input.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+/** Parse --variables: a JSON object grouped by component, the exact shape
+ * `whatsapp templates` reports per template. Leaf validation is the API's
+ * job — it returns field-level errors for bad keys or non-string values. */
+async function parseVariables(value) {
+    const raw = await readTextInput(value, '--variables');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new UsageError('--variables must be valid JSON (inline, @file, or @-).');
+    }
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        Array.isArray(parsed)) {
+        throw new UsageError('--variables must be a JSON object grouped by component, e.g. \'{"body":{"1":"Jane"}}\'.');
+    }
+    return parsed;
+}
+export default class WhatsappSendTemplate extends AgentCommand {
+    static summary = 'Send an approved WhatsApp template message';
+    static description = 'Send an approved WhatsApp template to a phone number from one of the ' +
+        'agent’s connected numbers. No user ID is needed — a Chatbase user is ' +
+        'resolved or created from the recipient number, and replies flow ' +
+        'through the agent’s regular WhatsApp pipeline. Use `whatsapp ' +
+        'templates` to see available templates and the variables each expects.';
+    static examples = [
+        '<%= config.bin %> whatsapp send-template order_update --to 14155552671 -a agt_123',
+        '<%= config.bin %> whatsapp send-template order_update --to 14155552671 --language en_US --variables \'{"header":{"1":"#1042"},"body":{"1":"Jane","2":"Friday"}}\' -a agt_123'
+    ];
+    static args = {
+        template: Args.string({
+            required: true,
+            description: 'Name of the approved template'
+        })
+    };
+    static flags = {
+        ...AgentCommand.baseFlags,
+        to: Flags.string({
+            required: true,
+            description: 'Recipient phone number in international format (digits with country code)'
+        }),
+        from: Flags.string({
+            description: 'Which connected WhatsApp number to send from — optional when the agent has exactly one'
+        }),
+        language: Flags.string({
+            description: 'Template language code (e.g. en_US) — optional when the template exists in a single language'
+        }),
+        variables: Flags.string({
+            description: 'Template variable values as JSON grouped by component (@file, @-, or inline), e.g. \'{"body":{"1":"Jane"}}\''
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WhatsappSendTemplate);
+        const variables = flags.variables
+            ? await parseVariables(flags.variables)
+            : undefined;
+        const client = this.apiClient(flags);
+        const agentId = await this.agentId(flags, client);
+        const body = {
+            to: flags.to,
+            ...(flags.from ? { from: flags.from } : {}),
+            template: {
+                name: args.template,
+                ...(flags.language ? { language: flags.language } : {}),
+                // The spec defaults variables to {} and the generated type
+                // makes it required — send the default explicitly.
+                variables: variables ?? {}
+            }
+        };
+        const { data, error, response } = await client.POST('/agents/{agentId}/whatsapp/messages/template', {
+            params: { path: { agentId } },
+            body
+        });
+        throwIfError(response, error);
+        const sent = data;
+        if (flags.json) {
+            process.stdout.write(`${JSON.stringify(sent, null, 2)}\n`);
+            return;
+        }
+        this.success(flags, `Sent template "${args.template}" to ${sent.to}`);
+        if (sent.conversationId) {
+            this.note(flags, `Conversation: ${sent.conversationId}`);
+        }
+        if (sent.messageId) {
+            process.stdout.write(`${sent.messageId}\n`);
+        }
+    }
+}

package/dist/commands/whatsapp/templates.js

@@ -0,0 +1,55 @@
+import { AgentCommand } from '../../base/agent-command.js';
+import { throwIfError } from '../../client/client.js';
+const COLUMNS = [
+    { key: 'name', header: 'NAME' },
+    { key: 'language', header: 'LANGUAGE' },
+    { key: 'category', header: 'CATEGORY' },
+    { key: 'format', header: 'FORMAT' },
+    { key: 'wabaId', header: 'WABA' },
+    { key: 'variables', header: 'VARIABLES' }
+];
+/** {header: ["1"], body: ["1","2"]} → "header:1 body:1,2" — the keys a send
+ * must supply, in the grouping `send-template --variables` expects. */
+function variablesSummary(variables) {
+    return Object.entries(variables)
+        .map(([component, keys]) => `${component}:${keys.join(',')}`)
+        .join(' ');
+}
+export default class WhatsappTemplates extends AgentCommand {
+    static summary = 'List approved WhatsApp templates for an agent';
+    static description = 'List the approved WhatsApp templates available to the agent, across ' +
+        'all of its connected WhatsApp Business Accounts. A template can only ' +
+        'be sent from a number on its own Business Account — pick a sender ' +
+        'whose WABA matches the template’s WABA column.';
+    static examples = [
+        '<%= config.bin %> whatsapp templates -a agt_123',
+        '<%= config.bin %> whatsapp templates -a agt_123 --json'
+    ];
+    static flags = { ...AgentCommand.baseFlags };
+    async run() {
+        const { flags } = await this.parse(WhatsappTemplates);
+        const client = this.apiClient(flags);
+        const agentId = await this.agentId(flags, client);
+        const { data, error, response } = await client.GET('/agents/{agentId}/whatsapp/templates', { params: { path: { agentId } } });
+        throwIfError(response, error);
+        const result = data;
+        const rows = result.templates.map((t) => ({
+            name: t.name,
+            language: t.language,
+            category: t.category,
+            format: t.parameterFormat,
+            wabaId: t.wabaId,
+            variables: variablesSummary(t.variables)
+        }));
+        this.printData(flags, result, rows, COLUMNS);
+        if (result.senders.length > 0) {
+            const senders = result.senders
+                .map((s) => `${s.from}${s.verifiedName ? ` (${s.verifiedName})` : ''} — waba ${s.wabaId}`)
+                .join('; ');
+            this.note(flags, `Senders: ${senders}`);
+        }
+        if (!result.complete) {
+            this.note(flags, `Warning: partial list — could not read WABA(s): ${result.unavailableWabaIds.join(', ')}. Retry to pick them up.`);
+        }
+    }
+}