@norbix.ai/cli 0.3.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 |
@@ -125,6 +126,29 @@ pipe into `jq`:
 norbix db find orders --json | jq '.list.items[] | ._id'
 ```
 
+## Errors
+
+A failed call prints one line: the error code, the message, and the HTTP
+status.
+
+```sh
+$ norbix files info nbin_1 a/b.txt
+ ›   Error: CM-ERRORS-FILES-016: File not found: "a/b.txt" does not exist in
+ ›   Local (nbin_1). (HTTP 404)
+```
+
+The code and the message are the gateway's own — they come out of
+`responseStatus.errors[]`, where the gateway puts them. Before this, every
+failure read "Request failed with status 404" with no code.
+
+Exit codes do not change: `1` for a failed call, `2` for a check that ran and
+came back negative (`norbix files integrations test`).
+
+**A refusal the gateway answers with HTTP 200** and
+`responseStatus.isSuccess = false` now exits non-zero as well, wherever it did
+not before — `norbix files publish` / `unpublish` were the two commands that
+used to treat it as a success.
+
 ## Development
 
 ```sh

package/dist/base.js

@@ -157,12 +157,23 @@ export class BaseCommand extends Command {
             this.log(typeof data === 'string' ? data : JSON.stringify(data, null, 2));
         }
     }
+    /**
+     * One line for a failed call: `<errorCode>: <message> (HTTP <status>)`.
+     *
+     * The code comes first because it is the part a reader can search for and a
+     * script can match on. It is the gateway's own code — the SDK reads it out
+     * of `responseStatus.errors[]`, where the gateway puts it (10b-files slice
+     * ERRORS, issue #66). The exit codes do not change.
+     */
     async catch(error) {
         if (error instanceof NorbixError) {
-            const status = error.status;
-            const suffix = status ? ` (HTTP ${status})` : '';
+            const { code, status } = error;
+            const prefix = code ? `${code}: ` : '';
+            // The SDK's last-resort message already ends in "(HTTP <status>)" —
+            // do not say it twice.
+            const suffix = status && !error.message.includes(`(HTTP ${status})`) ? ` (HTTP ${status})` : '';
             const hint = status === 401 ? '\nYour session may have expired. Run `norbix login` again.' : '';
-            return this.error(`${error.message}${suffix}${hint}`);
+            return this.error(`${prefix}${error.message}${suffix}${hint}`);
         }
         return super.catch(error);
     }

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;
+    }
+}