@norbix.ai/cli 0.1.0 → 0.2.0

package/dist/commands/files/sign.js

@@ -14,7 +14,7 @@ export default class FilesSign extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(FilesSign);
         const client = this.client(flags);
-        const integration = resolveIntegration(flags.integration, this.readStore().filesIntegrationId);
+        const integration = resolveIntegration(flags.integration, this.resolveContext(flags).filesIntegrationId);
         if (!integration) {
             this.error('No files integration ID. Pass --integration or run `norbix config set filesIntegrationId <id>`.');
         }

package/dist/commands/files/unpublish.js

@@ -0,0 +1,34 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { integrationFlag, resolveIntegration } from '../../lib/files.js';
+import { callPublicFiles } from '../../lib/publicFiles.js';
+export default class FilesUnpublish extends BaseCommand {
+    static args = {
+        remote: Args.string({ description: 'Remote file path, or folder prefix with --folder', required: true }),
+    };
+    static description = "Take away a file's (or a folder's) public link";
+    static examples = [
+        '<%= config.bin %> files unpublish invoices/2026/invoice.pdf',
+        '<%= config.bin %> files unpublish invoices --folder',
+    ];
+    static flags = {
+        folder: Flags.boolean({
+            description: 'Unpublish the whole folder prefix, and every link inside it',
+        }),
+        integration: integrationFlag,
+    };
+    async run() {
+        const { args, flags } = await this.parse(FilesUnpublish);
+        const ctx = this.resolveContext(flags);
+        this.client(flags);
+        const integration = resolveIntegration(flags.integration, ctx.filesIntegrationId);
+        if (!integration) {
+            this.error('No files integration ID. Pass --integration or run `norbix config set filesIntegrationId <id>`.');
+        }
+        await callPublicFiles(ctx, flags.folder ? 'makeFolderPrivate' : 'makeFilePrivate', { filesIntegrationId: integration, path: args.remote });
+        this.print(flags.folder
+            ? `${args.remote} is private again — every link inside it is gone`
+            : `${args.remote} is private again — its link now gives a 404`);
+        return { path: args.remote, public: false };
+    }
+}

package/dist/commands/files/upload.js

@@ -23,7 +23,7 @@ export default class FilesUpload extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(FilesUpload);
         const client = this.client(flags);
-        const integration = resolveIntegration(flags.integration, this.readStore().filesIntegrationId);
+        const integration = resolveIntegration(flags.integration, this.resolveContext(flags).filesIntegrationId);
         if (!integration) {
             this.error('No files integration ID. Pass --integration or run `norbix config set filesIntegrationId <id>`.');
         }

package/dist/commands/hub.js

@@ -0,0 +1,24 @@
+import { NamespaceCommand } from '../lib/namespace-command.js';
+export default class Hub extends NamespaceCommand {
+    target = 'hub';
+    static description = `Call any Hub endpoint with plain words.
+
+Grammar: norbix hub <module> <words...> [id] [--field value]
+The method is resolved from the words — plural means "list", singular (or a
+positional id) means one item. Destructive verbs ask for confirmation
+(skip with --yes). Add --dry-run to see what would be called.`;
+    static strict = false;
+    static examples = [
+        '<%= config.bin %> hub                              # list modules',
+        '<%= config.bin %> hub database                     # list database methods',
+        '<%= config.bin %> hub database aggregates get',
+        '<%= config.bin %> hub database aggregates delete maggr_123 --schemaId sch_456',
+        '<%= config.bin %> hub scheduler tasks get --pageSize 100',
+        '<%= config.bin %> hub logs get --level Error',
+    ];
+    async run() {
+        const { flagArgv, rest, help } = this.splitArgv();
+        const { flags } = await this.parse(Hub, flagArgv);
+        return this.dispatch(rest, flags, help);
+    }
+}

package/dist/commands/login.js

@@ -2,64 +2,110 @@ import { input, password as passwordPrompt } from '@inquirer/prompts';
 import { Norbix } from '@norbix.ai/ts';
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../base.js';
-import { writeStore } from '../lib/store.js';
+import { DeviceFlowUnsupportedError, openBrowser, pollDeviceToken, startDeviceFlow, } from '../lib/device-login.js';
+import { SESSION_PATH, readProfiles, writeProfile, writeSession } from '../lib/profiles.js';
 export default class Login extends BaseCommand {
-    static description = `Log in to Norbix and store credentials on this machine.
+    static description = `Log in to Norbix.
 
-Two ways to authenticate:
-  1. User login  — prompts for user name and password, stores a bearer token.
-  2. API key     — pass --api-key to store a long-lived key instead.`;
+Default: browser login — the CLI shows a code, opens hub in your browser,
+you approve there, and a session is saved to ~/.norbix/session.json. New
+terminal windows reuse the session while it is valid. If the hub does not
+support browser login yet, the CLI falls back to user + password.
+
+--user / --password  force the password flow.
+--api-key            saves a long-lived key into a profile instead
+                     (same as \`norbix configure\`).
+
+Commands run with --profile skip the session on purpose and use that
+profile's API key.`;
     static examples = [
         '<%= config.bin %> login',
-        '<%= config.bin %> login --user alice@example.com --project 5f1a...',
-        '<%= config.bin %> login --api-key nbk_live_... --project 5f1a...',
+        '<%= config.bin %> login --user alice@example.com',
+        '<%= config.bin %> login --api-key nbk_... --project 5f1a... --profile ci',
     ];
     static flags = {
-        user: Flags.string({ char: 'u', description: 'User name (email)' }),
-        password: Flags.string({
-            char: 'p',
-            description: 'Password (prompted securely if omitted)',
-        }),
+        user: Flags.string({ char: 'u', description: 'User name (email) — forces password login' }),
+        password: Flags.string({ char: 'p', description: 'Password (prompted securely if omitted)' }),
     };
     async run() {
         const { flags } = await this.parse(Login);
-        const stored = this.readStore();
-        const projectId = flags.project ??
-            stored.projectId ??
-            (await input({ message: 'Project ID:', required: true }));
-        const region = flags.region ?? stored.region;
-        // Mode 1: API key.
+        const profiles = readProfiles();
+        const profName = flags.profile ?? 'default';
+        const existing = profiles[profName] ?? {};
+        // Mode 1: API key → saved as a profile (long-lived identity).
         if (flags['api-key']) {
-            writeStore(this.config.configDir, {
-                ...stored,
-                projectId,
-                region,
-                apiKey: flags['api-key'],
-                bearerToken: undefined,
-                refreshToken: undefined,
-                userId: undefined,
-                userName: undefined,
+            const projectId = flags.project ?? existing.project_id ?? (await input({ message: 'Project ID:', required: true }));
+            writeProfile(profName, {
+                ...existing,
+                api_key: flags['api-key'],
+                project_id: projectId,
+                region: flags.region ?? existing.region,
             });
-            this.print(`API key saved for project ${projectId}. Run \`norbix whoami\` to verify.`);
-            return { method: 'apiKey', projectId };
+            this.print(`API key saved to profile [${profName}]. Try \`norbix whoami${profName === 'default' ? '' : ` --profile ${profName}`}\` to verify.`);
+            return { method: 'apiKey', profile: profName, projectId };
+        }
+        const ctx = this.resolveContext(flags);
+        this.assertEndpoints(ctx);
+        // Mode 2 (default): browser login via the device flow.
+        if (!flags.user && !flags.password) {
+            try {
+                return await this.browserLogin(ctx.hubUrl, flags.project ?? existing.project_id, flags);
+            }
+            catch (error) {
+                if (!(error instanceof DeviceFlowUnsupportedError))
+                    throw error;
+                this.log('Browser login is not available on this hub yet — falling back to password login.\n');
+            }
         }
-        // Mode 2: user + password.
+        // Mode 3: user + password.
+        return this.passwordLogin(flags, existing);
+    }
+    async browserLogin(hubUrl, projectId, flags) {
+        const start = await startDeviceFlow(hubUrl, projectId);
+        this.log(`First, copy your one-time code: ${start.userCode}`);
+        if (process.stdout.isTTY) {
+            await input({ message: 'Press ENTER to open the browser...' });
+            openBrowser(start.verificationUriComplete ?? start.verificationUri);
+        }
+        this.log(`Or open this URL yourself: ${start.verificationUri}`);
+        this.log('Waiting for you to approve in the browser...');
+        const token = await pollDeviceToken(hubUrl, start, (m) => this.log(m));
+        writeSession({
+            bearerToken: token.bearerToken,
+            refreshToken: token.refreshToken,
+            projectId: token.projectId ?? projectId,
+            accountId: token.accountId ?? flags.account,
+            env: flags.env,
+            region: flags.region,
+            userId: token.userId,
+            userName: token.userName,
+            savedAt: new Date().toISOString(),
+        });
+        this.print(`Logged in as ${token.displayName ?? token.userName ?? 'user'}.\nSession saved to ${SESSION_PATH}.`);
+        return { method: 'browser', userId: token.userId, userName: token.userName };
+    }
+    async passwordLogin(flags, existing) {
+        const projectId = flags.project ?? existing.project_id ?? (await input({ message: 'Project ID:', required: true }));
+        const region = flags.region ?? existing.region;
         const userName = flags.user ?? (await input({ message: 'User name (email):', required: true }));
         const pwd = flags.password ?? (await passwordPrompt({ message: 'Password:', mask: '*' }));
-        const client = new Norbix({ projectId, region, env: flags.env ?? stored.env, baseUrl: { api: stored.apiUrl, hub: stored.hubUrl } }, { envSource: {} });
+        const ctx = this.resolveContext({ ...flags, project: projectId, region });
+        const client = new Norbix({ projectId, region, env: flags.env ?? existing.env, baseUrl: { api: ctx.apiUrl, hub: ctx.hubUrl } }, { envSource: {} });
         const res = await client.login({ userName, password: pwd });
         if (!res.bearerToken)
             this.error('Login succeeded but no token was returned.');
-        writeStore(this.config.configDir, {
-            ...stored,
-            projectId,
-            region,
+        writeSession({
             bearerToken: res.bearerToken,
             refreshToken: res.refreshToken,
+            projectId,
+            accountId: flags.account ?? existing.account_id,
+            env: flags.env ?? existing.env,
+            region,
             userId: res.userId,
             userName: res.userName ?? userName,
+            savedAt: new Date().toISOString(),
         });
-        this.print(`Logged in as ${res.displayName ?? res.userName ?? userName} (project ${projectId}).`);
+        this.print(`Logged in as ${res.displayName ?? res.userName ?? userName} (project ${projectId}).\nSession saved to ${SESSION_PATH}.`);
         return { method: 'credentials', projectId, userId: res.userId, userName: res.userName ?? userName };
     }
 }

package/dist/commands/logout.js

@@ -1,17 +1,16 @@
-import { Flags } from '@oclif/core';
 import { BaseCommand } from '../base.js';
+import { clearSession } from '../lib/profiles.js';
 import { writeStore } from '../lib/store.js';
 export default class Logout extends BaseCommand {
-    static description = 'Remove stored credentials from this machine';
-    static examples = ['<%= config.bin %> logout', '<%= config.bin %> logout --all'];
-    static flags = {
-        all: Flags.boolean({
-            description: 'Also remove the stored API key (default: only the login token)',
-            default: false,
-        }),
-    };
+    static description = `Remove the login session from this machine.
+
+Profiles in ~/.norbix/config (API keys) are NOT touched — manage those with
+\`norbix configure\` or by editing the file.`;
+    static examples = ['<%= config.bin %> logout'];
     async run() {
-        const { flags } = await this.parse(Logout);
+        await this.parse(Logout);
+        clearSession();
+        // Also clear tokens from the legacy per-OS config location.
         const stored = this.readStore();
         writeStore(this.config.configDir, {
             ...stored,
@@ -19,9 +18,8 @@ export default class Logout extends BaseCommand {
             refreshToken: undefined,
             userId: undefined,
             userName: undefined,
-            ...(flags.all ? { apiKey: undefined } : {}),
         });
-        this.print(flags.all ? 'Logged out. API key removed too.' : 'Logged out.');
-        return { loggedOut: true, removedApiKey: flags.all };
+        this.print('Logged out. Session removed.');
+        return { loggedOut: true };
     }
 }

package/dist/commands/profiles.js

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../base.js';
+import { PROFILES_PATH, isSessionValid, readProfiles, readSession } from '../lib/profiles.js';
+import { redact } from '../lib/store.js';
+export default class Profiles extends BaseCommand {
+    static description = 'List profiles from ~/.norbix/config (keys redacted) and the active session';
+    static examples = ['<%= config.bin %> profiles'];
+    async run() {
+        await this.parse(Profiles);
+        const profiles = readProfiles();
+        const session = readSession();
+        const display = Object.fromEntries(Object.entries(profiles).map(([name, p]) => [
+            name,
+            { ...p, api_key: redact(p.api_key) },
+        ]));
+        const sessionInfo = session
+            ? {
+                user: session.userName ?? session.userId,
+                projectId: session.projectId,
+                valid: isSessionValid(session),
+            }
+            : undefined;
+        this.print({ file: PROFILES_PATH, profiles: display, session: sessionInfo ?? '(none — run `norbix login`)' });
+        return { profiles: display, session: sessionInfo };
+    }
+}

package/dist/commands/push/archive.js

@@ -9,7 +9,10 @@ export default class PushArchive extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(PushArchive);
         const client = this.client(flags);
-        const res = await client.hub.notifications.archivePushTemplate({ id: args.id });
+        // The route token is `{Id}` and the transport fills tokens by exact name,
+        // so the request must carry `Id`. The generated type calls the field `id`,
+        // which throws NORBIX_MISSING_PATH_PARAM — hence the cast.
+        const res = await client.hub.notifications.archivePushTemplate({ Id: args.id });
         this.print(`Template ${args.id} archived.`);
         return res;
     }

package/dist/commands/push/clone.js

@@ -9,7 +9,10 @@ export default class PushClone extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(PushClone);
         const client = this.client(flags);
-        const res = await client.hub.notifications.clonePushTemplate({ id: args.id });
+        // The route token is `{Id}` and the transport fills tokens by exact name,
+        // so the request must carry `Id`. The generated type calls the field `id`,
+        // which throws NORBIX_MISSING_PATH_PARAM — hence the cast.
+        const res = await client.hub.notifications.clonePushTemplate({ Id: args.id });
         this.print(`Template ${args.id} cloned.`);
         return res;
     }

package/dist/commands/push/delete.js

@@ -18,7 +18,10 @@ export default class PushDelete extends BaseCommand {
             if (!ok)
                 return this.print('Cancelled.');
         }
-        const res = await client.hub.notifications.deletePushTemplate({ id: args.id });
+        // The route token is `{Id}` and the transport fills tokens by exact name,
+        // so the request must carry `Id`. The generated type calls the field `id`,
+        // which throws NORBIX_MISSING_PATH_PARAM — hence the cast.
+        const res = await client.hub.notifications.deletePushTemplate({ Id: args.id });
         this.print(`Template ${args.id} deleted.`);
         return res;
     }

package/dist/commands/push/device/register.js

@@ -0,0 +1,35 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushDeviceRegister extends BaseCommand {
+    static description = `Register a device so push campaigns can reach it
+
+A device belongs to a user, so --user is required. --os is the operating
+system the token came from; the backend uses it to pick a provider.`;
+    static examples = [
+        '<%= config.bin %> push device register --user usr_123 --token dGVzdA== --os iOS',
+    ];
+    static flags = {
+        user: Flags.string({ required: true, description: 'User ID the device belongs to' }),
+        token: Flags.string({ required: true, description: 'Device token from the platform' }),
+        os: Flags.string({ required: true, description: 'Operating system, e.g. iOS or Android' }),
+        'device-id': Flags.string({ description: 'Stable device identifier' }),
+        model: Flags.string({ description: 'Device model, e.g. iPhone 15' }),
+        name: Flags.string({ description: "The device's own name" }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushDeviceRegister);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.registerDevice({
+            userId: flags.user,
+            pushDeviceDto: {
+                deviceId: flags['device-id'],
+                deviceOs: flags.os,
+                token: flags.token,
+                modelName: flags.model,
+                deviceName: flags.name,
+            },
+        });
+        this.print(res);
+        return res;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushIntegrationDefault extends BaseCommand {
+    static description = 'Make a push integration the default one for this project';
+    static examples = ['<%= config.bin %> push integration default 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Integration ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushIntegrationDefault);
+        const client = this.client(flags);
+        // The generated request type calls this field `id`, but the route token is
+        // `{Id}` and the transport fills tokens by exact name — passing `id`
+        // throws NORBIX_MISSING_PATH_PARAM. Send `Id` until the type is fixed.
+        const res = await client.hub.notifications.setPushIntegrationAsDefault({ Id: args.id });
+        this.print(`Integration ${args.id} is now the default.`);
+        return res;
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushIntegrationDisable extends BaseCommand {
+    static description = 'Turn a push integration off';
+    static examples = ['<%= config.bin %> push integration disable 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Integration ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushIntegrationDisable);
+        const client = this.client(flags);
+        // The generated request type calls this field `id`, but the route token is
+        // `{Id}` and the transport fills tokens by exact name — passing `id`
+        // throws NORBIX_MISSING_PATH_PARAM. Send `Id` until the type is fixed.
+        const res = await client.hub.notifications.disablePushIntegration({ Id: args.id });
+        this.print(`Integration ${args.id} disabled.`);
+        return res;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushIntegrationEnable extends BaseCommand {
+    static description = 'Turn a push integration on';
+    static examples = ['<%= config.bin %> push integration enable 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Integration ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushIntegrationEnable);
+        const client = this.client(flags);
+        // The generated request type calls this field `id`, but the route token is
+        // `{Id}` and the transport fills tokens by exact name — passing `id`
+        // throws NORBIX_MISSING_PATH_PARAM. Send `Id` until the type is fixed.
+        const res = await client.hub.notifications.enablePushIntegration({ Id: args.id });
+        this.print(`Integration ${args.id} enabled.`);
+        return res;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+export default class PushIntegrationTest extends BaseCommand {
+    static description = `Send a test push through an integration
+
+Point this at the Fake integration while you are developing — it accepts the
+send and contacts no push service, so nothing reaches a real device.`;
+    static examples = [
+        '<%= config.bin %> push integration test --integration 66b2f0a1... --token dGVzdA== --family Ios',
+    ];
+    static flags = {
+        integration: Flags.string({ required: true, description: 'Integration ID to send through' }),
+        token: Flags.string({ description: 'Device token to send the test to' }),
+        family: Flags.string({
+            description: 'Which platform the token came from',
+            options: ['Ios', 'Android', 'Chrome', 'Safari', 'Expo'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushIntegrationTest);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.testPushIntegration({
+            integrationId: flags.integration,
+            testToken: flags.token,
+            deliveryFamily: flags.family,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/integration.js

@@ -0,0 +1,16 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PushIntegration extends BaseCommand {
+    static description = 'Show one push integration';
+    static examples = ['<%= config.bin %> push integration 66b2f0a1...'];
+    static args = {
+        id: Args.string({ required: true, description: 'Integration ID' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushIntegration);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushIntegration({ id: args.id });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/integrations.js

@@ -0,0 +1,20 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PushIntegrations extends BaseCommand {
+    static description = 'List the push integrations set up for this project';
+    static examples = ['<%= config.bin %> push integrations --page-size 50'];
+    static flags = {
+        'page-size': Flags.integer({ description: 'Records per page' }),
+        after: Flags.string({ description: 'Cursor: fetch the page after this item' }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushIntegrations);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushIntegrations({
+            pageSize: flags['page-size'],
+            startingAfter: flags.after,
+        });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/preview.js

@@ -0,0 +1,19 @@
+import { Args } 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...'];
+    static args = {
+        hash: Args.string({ required: true, description: 'Preview hash from the preview link' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PushPreview);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.previewPushNotification({ hash: args.hash });
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/settings.js

@@ -0,0 +1,16 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PushSettings extends BaseCommand {
+    static description = 'Show the project push settings';
+    static examples = ['<%= config.bin %> push settings'];
+    static flags = {
+        id: Flags.string({ description: 'Settings ID (defaults to the project settings)' }),
+    };
+    async run() {
+        const { flags } = await this.parse(PushSettings);
+        const client = this.client(flags);
+        const res = await client.hub.notifications.getPushSettings(flags.id ? { id: flags.id } : {});
+        this.print(res);
+        return res;
+    }
+}

package/dist/commands/push/unarchive.js

@@ -9,7 +9,10 @@ export default class PushUnarchive extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(PushUnarchive);
         const client = this.client(flags);
-        const res = await client.hub.notifications.unArchivePushTemplate({ id: args.id });
+        // The route token is `{Id}` and the transport fills tokens by exact name,
+        // so the request must carry `Id`. The generated type calls the field `id`,
+        // which throws NORBIX_MISSING_PATH_PARAM — hence the cast.
+        const res = await client.hub.notifications.unArchivePushTemplate({ Id: args.id });
         this.print(`Template ${args.id} restored.`);
         return res;
     }