@norbix.ai/cli 1.0.0 → 1.2.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 |
@@ -148,6 +149,15 @@ came back negative (`norbix files integrations test`).
 not before — `norbix files publish` / `unpublish` were the two commands that
 used to treat it as a success.
 
+## Versioning
+
+The major version is frozen at **v1** until the public launch.
+
+- A breaking change is released as a **minor** (for example v1.2.0 → v1.3.0), never as a new major.
+- Write it as `feat(<scope>): <what>` and add a line `Breaking: <what changed and what callers must do>` in plain words, in the pull-request body and in the commit message.
+- Never mark it the conventional-commits way: no `!` in the title (`feat!:`), no BREAKING CHANGE footer. The `PR title` check fails a pull request that does.
+- As a safety net, the release config (`.releaserc.json` → `releaseRules`) maps breaking commits to a minor, so one that slips through still does not bump the major.
+
 ## Development
 
 ```sh

package/dist/base.js

@@ -2,6 +2,16 @@ import { Norbix, NorbixError } from '@norbix.ai/ts';
 import { Command, Flags } from '@oclif/core';
 import { DEFAULT_API_URL, DEFAULT_HUB_URL, isSessionValid, readProfiles, readSession, } from './lib/profiles.js';
 import { readStore } from './lib/store.js';
+/** Stands in for a projectId the SDK constructor insists on; never sent. */
+const NO_PROJECT_PLACEHOLDER = 'no-project';
+/** Removes the project headers the SDK adds for the placeholder projectId. */
+export const dropProjectHeaders = async (ctx) => {
+    const headers = new Headers(ctx.init.headers);
+    headers.delete('norbix-project-id');
+    headers.delete('X-CM-ProjectId');
+    ctx.init.headers = headers;
+    return ctx.next();
+};
 /**
  * Base class for every Norbix CLI command.
  *
@@ -127,18 +137,28 @@ export class BaseCommand extends Command {
                 'or set custom api_url / hub_url in the profile for self-hosted installations.');
         }
     }
-    /** Build an SDK client from the resolved context. Errors politely when auth is missing. */
+    /**
+     * Build an SDK client from the resolved context. Errors politely when auth is missing.
+     *
+     * `requireAuth: false` — the call may go out without a login (a signed link is the key);
+     * a login, when there is one, is still used.
+     * `requireProject: false` — the call does not need a project (a signed link carries it).
+     * The SDK constructor still demands a projectId, so a placeholder is passed and the
+     * project headers are taken off the wire again: the gateway never sees a fake project.
+     */
     client(flags, opts = {}) {
         const ctx = this.resolveContext(flags);
         this.assertEndpoints(ctx);
-        if (!ctx.projectId) {
+        const noProject = !ctx.projectId && opts.requireProject === false;
+        if (!ctx.projectId && !noProject) {
             this.error('No project ID configured.\nRun `norbix configure` (or `norbix login`), or pass --project.');
         }
         if (opts.requireAuth !== false && !ctx.apiKey && !ctx.bearerToken) {
             this.error('Not authenticated.\nRun `norbix login` (browser/user session) or `norbix configure` (API key profile), or pass --api-key.');
         }
         return new Norbix({
-            projectId: ctx.projectId,
+            projectId: noProject ? NO_PROJECT_PLACEHOLDER : ctx.projectId,
+            middleware: noProject ? [dropProjectHeaders] : [],
             accountId: ctx.accountId,
             apiKey: ctx.apiKey,
             bearerToken: ctx.bearerToken,

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/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/preview.js

@@ -1,19 +1,43 @@
-import { Args } from '@oclif/core';
+import { NorbixError } from '@norbix.ai/ts';
+import { Args, Flags } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 export default class PushPreview extends BaseCommand {
     static description = `Render the title, body and subtitle behind a push preview link
 
 The hash is the opaque value the backend puts in a preview link — you cannot
-build it yourself, so copy it out of the link.`;
-    static examples = ['<%= config.bin %> push preview 8f2a91c4...'];
+build it yourself, so copy it out of the link.
+
+The signed link is the key: no login and no project are needed. When you are
+logged in, your session is still sent.`;
+    static examples = [
+        '<%= config.bin %> push preview 8f2a91c4...',
+        '<%= config.bin %> push preview --hash 8f2a91c4... --region nb-eu-germany',
+    ];
     static args = {
-        hash: Args.string({ required: true, description: 'Preview hash from the preview link' }),
+        hash: Args.string({ required: false, description: 'Preview hash from the preview link' }),
+    };
+    static flags = {
+        hash: Flags.string({ description: 'Preview hash from the preview link (same as the argument)' }),
     };
     async run() {
         const { args, flags } = await this.parse(PushPreview);
-        const client = this.client(flags);
-        const res = await client.hub.notifications.previewPushNotification({ hash: args.hash });
+        const hash = flags.hash ?? args.hash;
+        if (!hash) {
+            this.error('Pass the preview hash: `norbix push preview <hash>` or `--hash <hash>`.');
+        }
+        // The signed link opens without sign-in, so neither a login nor a project
+        // is forced here. A login, when there is one, is still used.
+        const client = this.client(flags, { requireAuth: false, requireProject: false });
+        const res = await client.hub.notifications.previewPushNotification({ hash });
         this.print(res);
         return res;
     }
+    async catch(error) {
+        // A 401 here means the link is bad or expired, not that a session ran out.
+        if (error instanceof NorbixError && error.status === 401) {
+            const { code } = error;
+            return this.error(`${code ? `${code}: ` : ''}${error.message}\nThe preview link is invalid or has expired. Ask for a new link.`);
+        }
+        return super.catch(error);
+    }
 }

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