@norbix.ai/cli 1.0.0 → 1.1.0

package/README.md

@@ -48,7 +48,8 @@ norbix scheduler list
 | `norbix apikeys list/regenerate` | Show or regenerate project API keys |
 | `norbix webhooks show/secret/enable/disable/remove` | Inspect the webhook integration |
 | `norbix email templates/template/clone/archive/unarchive/delete/campaigns/campaign/stop` | Email templates and campaigns |
-| `norbix push ...` / `norbix sms ...` | Push and SMS — same commands as email |
+| `norbix push ...` | Push module, integrations, devices, templates, campaigns — every push endpoint, see [docs/push.md](docs/push.md) |
+| `norbix sms ...` | SMS — same commands as email |
 | `norbix account profile/status/usage/projects/team/regions/billing-portal` | Account-level info |
 | `norbix payments integrations/triggers/trigger/enable/disable` | Payment integrations and triggers |
 | `norbix integrations <module>` | List integrations of any module |

package/dist/commands/push/campaign/batch.js

@@ -0,0 +1,39 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushCampaignBatch extends BaseCommand {
+    static description = `List the notifications in one batch — or show one of them
+
+Give a notification ID as the third argument to see just that notification.`;
+    static examples = [
+        '<%= config.bin %> push campaign batch 66b2f0a1... b7c3...',
+        '<%= config.bin %> push campaign batch 66b2f0a1... b7c3... n9d4...',
+    ];
+    static args = {
+        id: Args.string({ required: true, description: 'Campaign ID' }),
+        batchId: Args.string({ required: true, description: 'Batch ID (from `push campaign batches`)' }),
+        notificationId: Args.string({ description: 'Notification ID' }),
+    };
+    static flags = {
+        'page-size': Flags.integer({ description: 'Items per page' }),
+        after: Flags.string({ description: 'Cursor from the previous page' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushCampaignBatch);
+        const client = this.client(flags);
+        const n = client.hub.notifications;
+        const res = args.notificationId
+            ? await n.getPushCampaignBatchNotification({
+                id: args.id,
+                batchId: args.batchId,
+                notificationId: args.notificationId,
+            })
+            : await n.getPushCampaignBatchNotifications({
+                id: args.id,
+                batchId: args.batchId,
+                pageSize: flags['page-size'],
+                startingAfter: flags.after,
+            });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/campaign/batches.js

@@ -0,0 +1,24 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushCampaignBatches extends BaseCommand {
+    static description = 'List the send batches of a push campaign';
+    static examples = ['<%= config.bin %> push campaign batches 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Campaign ID' }),
+    };
+    static flags = {
+        'page-size': Flags.integer({ description: 'Items per page' }),
+        after: Flags.string({ description: 'Cursor from the previous page' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushCampaignBatches);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushCampaignBatches({
+            id: args.id,
+            pageSize: flags['page-size'],
+            startingAfter: flags.after,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/campaign/create.js

@@ -0,0 +1,102 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+import { parseTokens, readJsonObject } from '../../../lib/push.js';
+/** --audience value → the `source` discriminator the server routes the body by. */
+const AUDIENCES = {
+    'all-users': 'allUsers',
+    users: 'specifiedUsers',
+    'account-users': 'accountUsers',
+    collection: 'collection',
+    devices: 'devices',
+};
+export default class PushCampaignCreate extends BaseCommand {
+    static description = `Create a push campaign
+
+--audience picks who receives it:
+  all-users      every user; narrow with --role / --tag
+  users          the users named with --user
+  account-users  the account users named with --user
+  collection     the users referenced by --field in the --schema collection
+  devices        raw device tokens, --device <token>:<family> (Ios, Android, Chrome, Safari, Expo)
+
+Without --at the campaign is sent right away. Anything the flags do not cover
+goes in --config as a JSON object and is merged into the campaign.`;
+    static examples = [
+        '<%= config.bin %> push campaign create --template 66b2f0a1... --audience all-users --tag beta',
+        '<%= config.bin %> push campaign create --template 66b2f0a1... --audience users --user usr_1 --user usr_2',
+        '<%= config.bin %> push campaign create --template 66b2f0a1... --audience devices --device dGVzdA==:Ios',
+    ];
+    static flags = {
+        template: Flags.string({ required: true, description: 'Template ID' }),
+        audience: Flags.string({ required: true, description: 'Who receives it', options: Object.keys(AUDIENCES) }),
+        user: Flags.string({ description: 'User ID (users / account-users; repeat for several)', multiple: true }),
+        role: Flags.string({ description: 'Role name (all-users / collection; repeat for several)', multiple: true }),
+        tag: Flags.string({ description: 'User tag (all-users; repeat for several)', multiple: true }),
+        schema: Flags.string({ description: 'Collection name (collection)' }),
+        field: Flags.string({ description: 'Field that holds the recipient (collection; repeat for several)', multiple: true }),
+        'field-type': Flags.string({ description: 'What --field holds (collection)', options: ['User', 'Email'] }),
+        device: Flags.string({ description: 'Device as <token>:<family> (devices; repeat for several)', multiple: true }),
+        integration: Flags.string({ description: 'Push integration ID (defaults to the project default)' }),
+        language: Flags.string({ description: 'Template language to send' }),
+        notes: Flags.string({ description: 'Internal notes' }),
+        at: Flags.string({ description: 'Send later: ISO 8601 date-time or Unix seconds' }),
+        token: Flags.string({ description: 'Token value as key=value (repeat for several)', multiple: true }),
+        'database-integration': Flags.string({ description: 'Database integration ID (defaults to the project default)' }),
+        config: Flags.string({ description: 'Extra campaign fields as a JSON object, @file or -' }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushCampaignCreate);
+        const client = this.client(flags);
+        const extra = flags.config ? await readJsonObject(flags.config, 'config') : {};
+        const campaign = {
+            ...extra,
+            source: AUDIENCES[flags.audience],
+            templateId: flags.template,
+            integrationId: flags.integration,
+            language: flags.language,
+            notes: flags.notes,
+            campaignTime: flags.at ? toUnixSeconds(flags.at) : undefined,
+            mappedTokens: parseTokens(flags.token),
+            ...this.audienceFields(flags),
+        };
+        const res = await client.hub.notifications.createPushCampaign({
+            campaign,
+            databaseIntegrationId: flags['database-integration'],
+        });
+        this.print(res);
+        return res;
+    }
+    audienceFields(flags) {
+        switch (flags.audience) {
+            case 'all-users':
+                return { rolesNames: flags.role, userTags: flags.tag };
+            case 'users':
+            case 'account-users':
+                if (!flags.user?.length)
+                    this.error(`--audience ${flags.audience} needs at least one --user`);
+                return { userRecipients: flags.user };
+            case 'collection':
+                if (!flags.schema || !flags.field?.length)
+                    this.error('--audience collection needs --schema and --field');
+                return { schemaName: flags.schema, fields: flags.field, fieldType: flags['field-type'], roleNames: flags.role };
+            default:
+                if (!flags.device?.length)
+                    this.error('--audience devices needs at least one --device <token>:<family>');
+                return { devices: flags.device.map((d) => this.device(d)) };
+        }
+    }
+    device(value) {
+        const at = value.lastIndexOf(':');
+        if (at < 1)
+            this.error(`--device must look like <token>:<family>, got "${value}"`);
+        return { token: value.slice(0, at), deliveryFamily: value.slice(at + 1) };
+    }
+}
+function toUnixSeconds(value) {
+    if (/^\d+$/.test(value))
+        return Number(value);
+    const ms = Date.parse(value);
+    if (Number.isNaN(ms))
+        throw new Error(`--at is not a date: "${value}"`);
+    return Math.floor(ms / 1000);
+}

package/dist/commands/push/campaign/delete.js

@@ -0,0 +1,27 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushCampaignDelete extends BaseCommand {
+    static description = 'Delete a push campaign';
+    static examples = ['<%= config.bin %> push campaign delete 66b2f0a1... --yes'];
+    static args = {
+        id: Args.string({ required: true, description: 'Campaign ID' }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: 'y', description: 'Skip the confirmation prompt', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushCampaignDelete);
+        const client = this.client(flags);
+        if (!flags.yes && process.stdout.isTTY) {
+            const ok = await confirm({ message: `Delete push campaign ${args.id}?`, default: false });
+            if (!ok)
+                return this.print('Cancelled.');
+        }
+        // The route is `/campaigns/{Id}` but the generated request type is empty,
+        // so the id goes in as `Id` — the transport fills tokens by exact name.
+        const res = await client.hub.notifications.deletePushCampaign({ Id: args.id });
+        this.print(`Campaign ${args.id} deleted.`);
+        return res;
+    }
+}

package/dist/commands/push/campaign/message.js

@@ -0,0 +1,28 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushCampaignMessage extends BaseCommand {
+    static description = 'Show one push message a campaign sent';
+    static examples = ['<%= config.bin %> push campaign message 66b2f0a1... n9d4... --batch b7c3...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Campaign ID' }),
+        messageId: Args.string({ required: true, description: 'Message (notification) ID' }),
+    };
+    static flags = {
+        batch: Flags.string({ required: true, description: 'Batch the message belongs to' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushCampaignMessage);
+        const client = this.client(flags);
+        // The gateway route now names its token `{notificationId}`, and the
+        // regenerated request type has the matching field — so the workaround
+        // this command used to carry (an extra `id` plus a cast, because the
+        // token and the field had different names) is gone.
+        const res = await client.hub.notifications.getPushCampaignMessage({
+            campaignId: args.id,
+            notificationId: args.messageId,
+            campaignBatchId: flags.batch,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/campaign/messages.js

@@ -0,0 +1,26 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushCampaignMessages extends BaseCommand {
+    static description = 'List the push messages a campaign sent';
+    static examples = ['<%= config.bin %> push campaign messages 66b2f0a1... --batch b7c3...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Campaign ID' }),
+    };
+    static flags = {
+        batch: Flags.string({ description: 'Only this batch (from `push campaign batches`)' }),
+        'page-size': Flags.integer({ description: 'Items per page' }),
+        after: Flags.string({ description: 'Cursor from the previous page' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushCampaignMessages);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushCampaignMessages({
+            campaignId: args.id,
+            campaignBatchId: flags.batch,
+            pageSize: flags['page-size'],
+            startingAfter: flags.after,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/device.js

@@ -0,0 +1,16 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PushDevice extends BaseCommand {
+    static description = 'Show one registered push device, with the user it belongs to';
+    static examples = ['<%= config.bin %> push device pnd_123'];
+    static args = {
+        id: Args.string({ required: true, description: 'Device ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushDevice);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushDevice({ id: args.id });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/devices.js

@@ -0,0 +1,33 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PushDevices extends BaseCommand {
+    static description = `List the devices registered for push
+
+Narrow the list with --user, --token or --platform. Devices are stored
+inside their user, so a page is a page of users carrying every matching
+device they hold — follow hasMore rather than stopping at a short page.`;
+    static examples = [
+        '<%= config.bin %> push devices',
+        '<%= config.bin %> push devices --platform ios',
+        '<%= config.bin %> push devices --user usr_123',
+    ];
+    static flags = {
+        user: Flags.string({ description: 'Only the devices of this user' }),
+        token: Flags.string({ description: 'Only the device registered with this provider token' }),
+        platform: Flags.string({
+            description: 'Only devices of this platform',
+            options: ['ios', 'android', 'chrome', 'safari', 'expo'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushDevices);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushDevices({
+            userId: flags.user,
+            deviceKey: flags.token,
+            platform: flags.platform,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/disable-dependencies.js

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base.js';
+export default class PushDisableDependencies extends BaseCommand {
+    static description = 'List what still depends on push — check this before `push disable`';
+    static examples = ['<%= config.bin %> push disable-dependencies'];
+    async run() {
+        const { flags } = await this.parse(PushDisableDependencies);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushDisableDependencies({});
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/disable.js

@@ -0,0 +1,24 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PushDisable extends BaseCommand {
+    static description = `Turn off the push module for the project
+
+Run \`push disable-dependencies\` first to see what still depends on push.`;
+    static examples = ['<%= config.bin %> push disable --yes'];
+    static flags = {
+        yes: Flags.boolean({ char: 'y', description: 'Skip the confirmation prompt', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushDisable);
+        const client = this.client(flags);
+        if (!flags.yes && process.stdout.isTTY) {
+            const ok = await confirm({ message: 'Turn off push for this project?', default: false });
+            if (!ok)
+                return this.print('Cancelled.');
+        }
+        const res = await client.hub.notifications.disablePush({});
+        this.print('Push disabled.');
+        return res;
+    }
+}

package/dist/commands/push/enable.js

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base.js';
+export default class PushEnable extends BaseCommand {
+    static description = 'Turn on the push module for the project';
+    static examples = ['<%= config.bin %> push enable'];
+    async run() {
+        const { flags } = await this.parse(PushEnable);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.enablePush({});
+        this.print('Push enabled.');
+        return res;
+    }
+}

package/dist/commands/push/integration/app-request.js

@@ -0,0 +1,34 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushIntegrationAppRequest extends BaseCommand {
+    static description = `Register a Norbix app push integration request (managed service)
+
+This is one step of the managed-app pairing flow: the Norbix mobile app shows
+a request ID, a PIN and a public key, and this call registers them for the
+account. It is account-scoped, so an account ID must be configured or passed
+with --account.`;
+    static examples = [
+        '<%= config.bin %> push integration app-request --user usr_1 --request-id req_1 --pin 123456 --valid-till 2026-09-20T12:00:00Z --public-key MIIB...',
+    ];
+    static flags = {
+        user: Flags.string({ required: true, description: 'User ID the app is paired to' }),
+        'request-id': Flags.string({ required: true, description: 'Request ID shown by the app' }),
+        pin: Flags.integer({ required: true, description: 'PIN shown by the app' }),
+        'valid-till': Flags.string({ required: true, description: 'When the request expires (ISO 8601)' }),
+        'public-key': Flags.string({ required: true, description: "The app's public key" }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushIntegrationAppRequest);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.registerCodeMashAppPushIntegration({
+            accountId: this.resolveContext(flags).accountId,
+            userId: flags.user,
+            requestId: flags['request-id'],
+            pin: flags.pin,
+            validTill: flags['valid-till'],
+            publicKey: flags['public-key'],
+        });
+        this.print('App push integration request registered.');
+        return res;
+    }
+}

package/dist/commands/push/integration/confirm-delivery.js

@@ -0,0 +1,19 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushIntegrationConfirmDelivery extends BaseCommand {
+    static description = `Confirm that a test push reached a real person
+
+After \`push integration test\`, run this once you have seen the push on the
+device. It marks the integration as proven to deliver.`;
+    static examples = ['<%= config.bin %> push integration confirm-delivery 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Integration ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushIntegrationConfirmDelivery);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.confirmPushIntegrationHumanDelivery({ integrationId: args.id });
+        this.print(`Delivery confirmed for integration ${args.id}.`);
+        return res;
+    }
+}

package/dist/commands/push/integration/save.js

@@ -0,0 +1,41 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+import { readJsonObject } from '../../../lib/push.js';
+/** The provider names the server's integration converter accepts. */
+const PROVIDERS = ['Fake', 'AppleApns', 'AndroidFirebase', 'SafariPush', 'ChromeWeb', 'FirefoxWeb', 'EdgeWeb', 'ChromePush'];
+export default class PushIntegrationSave extends BaseCommand {
+    static description = `Create or update a push integration
+
+--provider picks the body shape. Fake needs nothing else: it accepts every send
+and contacts no push service, so use it while you develop. The real providers
+need their credentials — put the provider-specific fields in --config (inline
+JSON, @file.json, or - for stdin). Pass --id to update an existing integration.`;
+    static examples = [
+        '<%= config.bin %> push integration save --provider Fake',
+        '<%= config.bin %> push integration save --provider AndroidFirebase --name Android --config @firebase.json',
+    ];
+    static flags = {
+        provider: Flags.string({ required: true, description: 'Push provider', options: PROVIDERS }),
+        name: Flags.string({ description: 'Integration name (Fake ignores it and uses its own)' }),
+        id: Flags.string({ description: 'Integration ID — set it to update instead of create' }),
+        disabled: Flags.boolean({ description: 'Save it turned off', default: false }),
+        config: Flags.string({ description: 'Provider-specific fields as a JSON object, @file or -' }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushIntegrationSave);
+        const client = this.client(flags);
+        const extra = flags.config ? await readJsonObject(flags.config, 'config') : {};
+        const integration = {
+            ...extra,
+            provider: flags.provider,
+            integrationId: flags.id,
+            integrationName: flags.name ?? '',
+            isEnabled: !flags.disabled,
+        };
+        // The provider-specific fields are not on the generated base type, so the
+        // body is cast: the server picks the shape from `provider`.
+        const res = await client.hub.notifications.savePushIntegration({ integration });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/stop.js

@@ -18,12 +18,10 @@ export default class PushStop extends BaseCommand {
             if (!ok)
                 return this.print('Cancelled.');
         }
-        const n = client.hub.notifications;
-        if (!n.stopPushCampaign) {
-            this.error('Your installed @norbix.ai/ts does not support stopping campaigns yet.\n' +
-                `Update the SDK, or run: norbix api "/{version}/notifications/push/campaigns/${args.id}/stop" --hub --method POST`);
-        }
-        const res = await n.stopPushCampaign({ id: args.id });
+        // The route is `/campaigns/{Id}/stop` and the transport fills tokens by
+        // exact name, but the generated request type has no field at all — so the
+        // id goes in as `Id`. Sending `id` throws NORBIX_MISSING_PATH_PARAM.
+        const res = await client.hub.notifications.stopPushCampaign({ Id: args.id });
         this.print(`Campaign ${args.id} stopped.`);
         return res;
     }

package/dist/commands/push/template/create.js

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../../base.js';
+import { templateBody, templateFlags } from '../../../lib/push.js';
+export default class PushTemplateCreate extends BaseCommand {
+    static description = `Create a push template
+
+One language: --title and --body. Several languages: --translations with a
+JSON array of {language, content: {title, body}}.`;
+    static examples = [
+        '<%= config.bin %> push template create --name Welcome --title "Hi @Model.Name" --body "Thanks for joining"',
+        '<%= config.bin %> push template create --name Welcome --translations @welcome.json',
+    ];
+    static flags = templateFlags;
+    async run() {
+        const { flags } = await this.parse(PushTemplateCreate);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.createPushTemplate((await templateBody(flags)));
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/template/render.js

@@ -0,0 +1,28 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+import { parseTokens } from '../../../lib/push.js';
+export default class PushTemplateRender extends BaseCommand {
+    static description = `Render one push field (title, body or subtitle) with token values
+
+Use it to check a Razor template before you save it. When the template needs a
+token you did not pass, the answer lists the missing ones.`;
+    static examples = [
+        '<%= config.bin %> push template render --code "Hi @Model.Name" --token Name=Ada',
+    ];
+    static flags = {
+        code: Flags.string({ required: true, description: 'Razor source of the field' }),
+        token: Flags.string({ description: 'Token value as key=value (repeat for several)', multiple: true }),
+        preview: Flags.boolean({ description: 'Render for a preview (less strict)', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushTemplateRender);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.renderPush({
+            code: flags.code,
+            tokens: parseTokens(flags.token),
+            isForPreview: flags.preview,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/template/tokens.js

@@ -0,0 +1,16 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushTemplateTokens extends BaseCommand {
+    static description = 'List the tokens a push template uses — the values a campaign must fill';
+    static examples = ['<%= config.bin %> push template tokens 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Template ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushTemplateTokens);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushMessageContentTokens({ id: args.id });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/template/update.js

@@ -0,0 +1,25 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+import { templateBody, templateFlags } from '../../../lib/push.js';
+export default class PushTemplateUpdate extends BaseCommand {
+    static description = `Replace a push template's name, channel, tags and content
+
+The whole template is sent, so pass every language you want to keep.`;
+    static examples = [
+        '<%= config.bin %> push template update 66b2f0a1... --name Welcome --title "Hi" --body "Thanks for joining"',
+    ];
+    static args = {
+        id: Args.string({ required: true, description: 'Template ID' }),
+    };
+    static flags = templateFlags;
+    async run() {
+        const { args, flags } = await this.parse(PushTemplateUpdate);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.updatePushTemplate({
+            ...(await templateBody(flags)),
+            viewId: args.id,
+        });
+        this.print(`Template ${args.id} updated.`);
+        return res;
+    }
+}

package/dist/lib/push.js

@@ -0,0 +1,70 @@
+import { readFileSync } from 'node:fs';
+import { Flags } from '@oclif/core';
+import { readJsonInput } from './json.js';
+/**
+ * Read a JSON object from a flag: inline JSON, `-` for stdin, or `@path` for a
+ * file. Used by the push commands whose body is too rich for flags alone
+ * (template translations, provider credentials, campaign audiences).
+ */
+export async function readJsonObject(value, flagName) {
+    const raw = value.startsWith('@') ? readFileSync(value.slice(1), 'utf8') : value;
+    const parsed = JSON.parse(await readJsonInput(raw, flagName));
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`--${flagName} must be a JSON object`);
+    }
+    return parsed;
+}
+/** Turn repeated `--token key=value` flags into token mappings with the Custom resolver. */
+export function parseTokens(values) {
+    if (!values?.length)
+        return undefined;
+    return values.map((pair) => {
+        const at = pair.indexOf('=');
+        if (at < 1)
+            throw new Error(`--token must look like key=value, got "${pair}"`);
+        return { key: pair.slice(0, at), value: pair.slice(at + 1), resolver: 'Custom' };
+    });
+}
+/**
+ * Build the template body. Either --translations (a JSON array, @file or -)
+ * for several languages, or --title + --body for one language.
+ */
+export async function templateBody(flags) {
+    let translations;
+    if (flags.translations) {
+        const raw = flags.translations.startsWith('@') ? readFileSync(flags.translations.slice(1), 'utf8') : flags.translations;
+        translations = JSON.parse(await readJsonInput(raw, 'translations'));
+        if (!Array.isArray(translations))
+            throw new Error('--translations must be a JSON array');
+    }
+    else {
+        if (!flags.title || !flags.body) {
+            throw new Error('Pass --title and --body, or --translations for several languages.');
+        }
+        translations = [{ language: flags.language, content: { title: flags.title, body: flags.body } }];
+    }
+    return {
+        templateName: flags.name,
+        description: flags.description,
+        communicationChannel: flags.channel,
+        tags: flags.tag,
+        translations,
+    };
+}
+export const templateFlags = {
+    name: Flags.string({ required: true, description: 'Template name' }),
+    description: Flags.string({ description: 'What the template is for' }),
+    channel: Flags.string({
+        description: 'Communication channel',
+        options: ['Transactional', 'Marketing', 'System'],
+        default: 'Transactional',
+    }),
+    tag: Flags.string({ description: 'Tag (repeat for several)', multiple: true }),
+    language: Flags.string({ description: 'Language of --title / --body', default: 'en' }),
+    title: Flags.string({ description: 'Push title (Razor allowed)' }),
+    body: Flags.string({ description: 'Push body (Razor allowed)' }),
+    translations: Flags.string({
+        description: 'All languages as a JSON array of {language, content: {title, body}} — inline, @file or -',
+        exclusive: ['title', 'body'],
+    }),
+};