@norbix.ai/cli 0.1.0 → 0.3.0

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

package/dist/commands/raw.js

@@ -0,0 +1,86 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../base.js';
+import { readJsonInput } from '../lib/json.js';
+/**
+ * Raw escape hatch (like `gh api`): call ANY Norbix endpoint, including the
+ * ones this CLI has no dedicated command for yet. Sends the same auth and
+ * scope headers the SDK transport sends.
+ */
+export default class Raw extends BaseCommand {
+    static description = `Low-level escape hatch: call a raw HTTP path on the hub (default) or API.
+
+Prefer \`norbix hub ...\` / \`norbix api ...\` — they take plain words.
+Use this only for endpoints the SDK does not know yet. Sends your auth token
+plus project/account/env/region headers automatically. Use {version} in the
+path and it becomes v2.`;
+    static examples = [
+        '<%= config.bin %> api /v2/logs/settings --hub',
+        `<%= config.bin %> api '/{version}/database/collections/orders/count' --query filter='{"status":"paid"}'`,
+        `<%= config.bin %> api /v2/scheduler/tasks --hub --method POST --body '{"name":"nightly",...}'`,
+    ];
+    static args = {
+        path: Args.string({ required: true, description: 'Endpoint path, e.g. /v2/logs or /{version}/logs' }),
+    };
+    static flags = {
+        api: Flags.boolean({ description: 'Call the data-plane API service instead of the hub (hub is the default)', default: false }),
+        method: Flags.string({ char: 'X', description: 'HTTP method', default: 'GET', options: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] }),
+        body: Flags.string({ char: 'b', description: 'JSON request body (or `-` for stdin)' }),
+        query: Flags.string({ char: 'q', description: 'Query parameter key=value (repeatable)', multiple: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Raw);
+        const ctx = this.resolveContext(flags);
+        this.assertEndpoints(ctx);
+        if (!ctx.projectId)
+            this.error('No project ID configured. Run `norbix login` or pass --project.');
+        const token = ctx.bearerToken ?? ctx.apiKey;
+        if (!token)
+            this.error('Not authenticated. Run `norbix login` or pass --api-key.');
+        // resolveContext already applied profile overrides, defaults (.ai) and
+        // the region subdomain.
+        const base = flags.api ? ctx.apiUrl : ctx.hubUrl;
+        const path = args.path.replace('{version}', 'v2');
+        const url = new URL(base.replace(/\/$/, '') + (path.startsWith('/') ? path : `/${path}`));
+        for (const pair of flags.query ?? []) {
+            const eq = pair.indexOf('=');
+            if (eq < 1)
+                this.error(`--query must be key=value, got "${pair}"`);
+            url.searchParams.append(pair.slice(0, eq), pair.slice(eq + 1));
+        }
+        const headers = {
+            Accept: 'application/json',
+            Authorization: `Bearer ${token}`,
+            'norbix-project-id': ctx.projectId,
+            'X-CM-ProjectId': ctx.projectId,
+        };
+        if (ctx.accountId) {
+            headers['norbix-account-id'] = ctx.accountId;
+            headers['X-CM-AccountId'] = ctx.accountId;
+        }
+        if (ctx.env && ctx.env !== 'PROD')
+            headers['norbix-env'] = ctx.env;
+        if (ctx.region)
+            headers['nb-region'] = ctx.region;
+        let body;
+        if (flags.body) {
+            body = await readJsonInput(flags.body, 'body');
+            headers['Content-Type'] = 'application/json';
+        }
+        const res = await fetch(url, { method: flags.method, headers, body });
+        const text = await res.text();
+        let data;
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            data = text;
+        }
+        if (!res.ok) {
+            this.warn(`HTTP ${res.status} ${res.statusText}`);
+            this.print(data);
+            this.exit(1);
+        }
+        this.print(data);
+        return data;
+    }
+}

package/dist/commands/whoami.js

@@ -1,17 +1,31 @@
 import { BaseCommand } from '../base.js';
+import { PROFILES_PATH, SESSION_PATH } from '../lib/profiles.js';
 import { redact } from '../lib/store.js';
 export default class Whoami extends BaseCommand {
-    static description = 'Show the current CLI context and verify it against the server';
-    static examples = ['<%= config.bin %> whoami', '<%= config.bin %> whoami --json'];
+    static description = 'Show the resolved context (profile, auth source, endpoints) and verify it against the server';
+    static examples = [
+        '<%= config.bin %> whoami',
+        '<%= config.bin %> whoami --profile fitskin-prod',
+        '<%= config.bin %> whoami --json',
+    ];
     async run() {
         const { flags } = await this.parse(Whoami);
         const ctx = this.resolveContext(flags);
         const summary = {
+            profile: ctx.profileName ?? '(none)',
+            auth: ctx.authSource === 'session' ? `session (${ctx.userName ?? 'user'})` : ctx.authSource,
+            apiKey: ctx.apiKey ? redact(ctx.apiKey) : undefined,
             projectId: ctx.projectId,
+            accountId: ctx.accountId,
             env: ctx.env ?? 'PROD',
-            region: ctx.region ?? '(project default)',
-            auth: ctx.bearerToken ? `login token (${ctx.stored.userName ?? ctx.stored.userId ?? 'user'})` : ctx.apiKey ? `api key ${redact(ctx.apiKey)}` : 'none',
-            configFile: this.config.configDir,
+            region: ctx.region ??
+                (ctx.usesDefaultEndpoints
+                    ? '(NOT SET — required with default endpoints!)'
+                    : '(not set — optional with custom endpoints)'),
+            apiUrl: ctx.apiUrl,
+            hubUrl: ctx.hubUrl,
+            profilesFile: PROFILES_PATH,
+            sessionFile: SESSION_PATH,
         };
         let verified = false;
         let environments;
@@ -21,7 +35,7 @@ export default class Whoami extends BaseCommand {
                 const client = this.client(flags);
                 const res = await client.hub.environments.list();
                 const item = res.item;
-                environments = (item?.environments ?? []).map((e) => (typeof e === 'string' ? e : (e.name ?? String(e))));
+                environments = (item?.environments ?? []).map((e) => typeof e === 'string' ? e : (e.name ?? String(e)));
                 verified = true;
             }
             catch (error) {
@@ -29,11 +43,14 @@ export default class Whoami extends BaseCommand {
             }
         }
         this.print([
+            `Profile:  ${summary.profile}`,
+            `Auth:     ${summary.auth}${summary.apiKey ? ` (${summary.apiKey})` : ''}`,
             `Project:  ${summary.projectId ?? '(not set)'}`,
+            `Account:  ${summary.accountId ?? '(not set)'}`,
             `Env:      ${summary.env}`,
             `Region:   ${summary.region}`,
-            `Auth:     ${summary.auth}`,
-            `Config:   ${summary.configFile}`,
+            `API:      ${summary.apiUrl}`,
+            `Hub:      ${summary.hubUrl}`,
             verified
                 ? `Server:   OK${environments?.length ? ` — environments: ${environments.join(', ')}` : ''}`
                 : `Server:   not verified${verifyError ? ` (${verifyError})` : ''}`,

package/dist/help.js

@@ -0,0 +1,18 @@
+import { Help } from '@oclif/core';
+/**
+ * Custom help router. oclif intercepts --help before a command runs, which
+ * would hide the scoped help of the dynamic namespaces. For
+ * `norbix hub <words...> --help` (and `api`), delegate back to the command
+ * with an internal marker so it can print help for exactly that scope.
+ */
+export default class NorbixHelp extends Help {
+    async showHelp(argv) {
+        const words = argv.filter((a) => a !== '--help' && a !== '-h');
+        const [first, ...rest] = words;
+        if ((first === 'hub' || first === 'api') && rest.length > 0) {
+            await this.config.runCommand(first, [...rest, '--scope-help']);
+            return;
+        }
+        return super.showHelp(argv);
+    }
+}

package/dist/lib/device-login.js

@@ -0,0 +1,76 @@
+import { spawn } from 'node:child_process';
+export class DeviceFlowUnsupportedError extends Error {
+}
+export async function startDeviceFlow(hubUrl, projectId) {
+    let res;
+    try {
+        res = await fetch(`${hubUrl.replace(/\/$/, '')}/v2/auth/device/start`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify({ clientName: 'norbix-cli', projectId }),
+        });
+    }
+    catch (error) {
+        throw new DeviceFlowUnsupportedError(`Could not reach ${hubUrl}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // 404/405/501 → the hub does not implement browser login (yet).
+    if ([404, 405, 501].includes(res.status)) {
+        throw new DeviceFlowUnsupportedError(`Hub returned HTTP ${res.status} for the device flow.`);
+    }
+    if (!res.ok)
+        throw new Error(`Device login start failed: HTTP ${res.status}`);
+    const data = (await res.json());
+    if (!data.deviceCode || !data.userCode || !data.verificationUri) {
+        throw new Error('Device login start returned an unexpected response.');
+    }
+    return data;
+}
+/** Poll until the user approves in the browser (or the code expires). */
+export async function pollDeviceToken(hubUrl, start, log) {
+    const deadline = Date.now() + (start.expiresIn ?? 600) * 1000;
+    let intervalMs = (start.interval ?? 5) * 1000;
+    while (Date.now() < deadline) {
+        await sleep(intervalMs);
+        const res = await fetch(`${hubUrl.replace(/\/$/, '')}/v2/auth/device/token`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify({ deviceCode: start.deviceCode }),
+        });
+        if (res.status === 428)
+            continue; // still pending
+        const data = (await res.json().catch(() => ({})));
+        if (data.error === 'authorization_pending')
+            continue;
+        if (data.error === 'slow_down') {
+            intervalMs += 5000;
+            continue;
+        }
+        if (data.error === 'access_denied')
+            throw new Error('Login was denied in the browser.');
+        if (data.error === 'expired_token')
+            break;
+        if (!res.ok)
+            throw new Error(`Device login failed: HTTP ${res.status}`);
+        if (data.bearerToken)
+            return data;
+        log('Unexpected response while waiting — retrying...');
+    }
+    throw new Error('The login code expired. Run `norbix login` again.');
+}
+/** Open a URL in the default browser — macOS, Linux, Windows. */
+export function openBrowser(url) {
+    const [cmd, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url]]
+            : ['xdg-open', [url]];
+    try {
+        spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch {
+        // Browser could not be opened — the URL is printed anyway.
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/dispatch.js

@@ -0,0 +1,151 @@
+/**
+ * Dynamic dispatcher: turns
+ *
+ *   norbix hub database aggregates delete maggr_123 --schemaId sch_456
+ *
+ * into `client.hub.database.deleteDatabaseAggregate({id, schemaId})`.
+ *
+ * Grammar:  norbix {hub|api} {module} {words...} {positional id} {--field value}
+ *
+ * The SDK namespaces are auto-generated and uniform (every method takes one
+ * request object), so the CLI can discover modules and methods at runtime —
+ * every current AND future SDK method is callable without new command files.
+ */
+/** Split leftover argv into words, positional values and --field values. */
+export function parseArgv(argv) {
+    const words = [];
+    const positionals = [];
+    const fields = {};
+    let yes = false;
+    let dryRun = false;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--yes' || token === '-y') {
+            yes = true;
+        }
+        else if (token === '--dry-run') {
+            dryRun = true;
+        }
+        else if (token.startsWith('--')) {
+            const body = token.slice(2);
+            const eq = body.indexOf('=');
+            if (eq > 0) {
+                // --field=value syntax
+                fields[body.slice(0, eq)] = coerce(body.slice(eq + 1));
+            }
+            else {
+                const next = argv[i + 1];
+                if (next !== undefined && !next.startsWith('--')) {
+                    fields[body] = coerce(next);
+                    i++;
+                }
+                else {
+                    fields[body] = true;
+                }
+            }
+        }
+        else if (/^[a-z][a-z-]*$/i.test(token) && !looksLikeId(token)) {
+            words.push(token);
+        }
+        else {
+            positionals.push(token);
+        }
+    }
+    return { words, positionals, fields, yes, dryRun };
+}
+/** IDs look like maggr_..., sch_..., 66b2f0a1..., UPPER env names, etc. */
+function looksLikeId(token) {
+    return /[_0-9]/.test(token) || token === token.toUpperCase();
+}
+function coerce(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^-?\d+$/.test(value))
+        return Number(value);
+    return value;
+}
+function camelSplit(name) {
+    const tokens = name
+        .replaceAll(/([a-z])([A-Z])/g, '$1 $2')
+        .toLowerCase()
+        .split(' ');
+    // unArchive → "unarchive", one verb.
+    const merged = [];
+    for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i] === 'un' && tokens[i + 1]) {
+            merged.push('un' + tokens[++i]);
+        }
+        else {
+            merged.push(tokens[i]);
+        }
+    }
+    return merged;
+}
+export { camelSplit };
+function singular(word) {
+    if (word.endsWith('ies'))
+        return word.slice(0, -3) + 'y';
+    if (word.endsWith('s') && !word.endsWith('ss'))
+        return word.slice(0, -1);
+    return word;
+}
+/**
+ * Match user words against SDK method names. "aggregates get" prefers
+ * getDatabaseAggregates (plural = list); "aggregate get" (or a positional id)
+ * prefers getDatabaseAggregate.
+ */
+export function matchMethods(methods, words, moduleName) {
+    const userWords = words.map((w) => w.toLowerCase().replaceAll('-', ''));
+    const moduleTokens = new Set(camelSplit(moduleName));
+    const matches = [];
+    for (const method of methods) {
+        // Exact camelCase method name typed by the user.
+        if (words.length === 1 && words[0] === method)
+            return [{ method, exact: 99, extra: 0 }];
+        const tokens = camelSplit(method);
+        let exact = 0;
+        let ok = true;
+        for (const w of userWords) {
+            if (tokens.includes(w)) {
+                exact++;
+            }
+            else if (tokens.some((t) => singular(t) === singular(w))) {
+                // singular/plural tolerant match
+            }
+            else {
+                ok = false;
+                break;
+            }
+        }
+        if (!ok)
+            continue;
+        const extra = tokens.filter((t) => !moduleTokens.has(t) && !userWords.some((w) => singular(w) === singular(t))).length;
+        matches.push({ method, exact, extra });
+    }
+    matches.sort((a, b) => b.exact - a.exact || a.extra - b.extra || a.method.localeCompare(b.method));
+    // Keep only the best-scoring group so callers can detect ambiguity.
+    if (matches.length > 1) {
+        const best = matches[0];
+        return matches.filter((m) => m.exact === best.exact && m.extra === best.extra);
+    }
+    return matches;
+}
+const DESTRUCTIVE_VERBS = new Set(['delete', 'remove', 'clean', 'regenerate', 'rotate', 'stop']);
+export function isDestructive(method) {
+    return DESTRUCTIVE_VERBS.has(camelSplit(method)[0]);
+}
+/**
+ * Module aliases so daily language works: `norbix hub db ...`, and
+ * `norbix hub email templates get` routes into the notifications module
+ * with "email" injected as a matching word.
+ */
+export const MODULE_ALIASES = {
+    db: { module: 'database' },
+    email: { module: 'notifications', injectWord: 'email' },
+    envs: { module: 'environments' },
+    fs: { module: 'files' },
+    push: { module: 'notifications', injectWord: 'push' },
+    sms: { module: 'notifications', injectWord: 'sms' },
+};

package/dist/lib/filesIntegrationTest.js

@@ -0,0 +1,57 @@
+import { NorbixAuthError, NorbixError, NorbixValidationError } from '@norbix.ai/ts';
+/** The API version the SDK talks by default. Kept in one place. */
+const API_VERSION = 'v2';
+export async function callTestFilesIntegration(ctx, filesIntegrationId) {
+    const token = ctx.bearerToken ?? ctx.apiKey;
+    const headers = new Headers({ Accept: 'application/json' });
+    if (token)
+        headers.set('Authorization', `Bearer ${token}`);
+    if (ctx.projectId) {
+        headers.set('norbix-project-id', ctx.projectId);
+        headers.set('X-CM-ProjectId', ctx.projectId);
+    }
+    if (ctx.accountId) {
+        headers.set('norbix-account-id', ctx.accountId);
+        headers.set('X-CM-AccountId', ctx.accountId);
+    }
+    if (ctx.env && ctx.env !== 'PROD')
+        headers.set('norbix-env', ctx.env);
+    if (ctx.region)
+        headers.set('nb-region', ctx.region);
+    const base = ctx.apiUrl.endsWith('/') ? ctx.apiUrl.slice(0, -1) : ctx.apiUrl;
+    const url = `${base}/${API_VERSION}/files/${encodeURIComponent(filesIntegrationId)}/test`;
+    const response = await fetch(url, { headers, method: 'POST' });
+    const text = await response.text();
+    let raw;
+    if (text) {
+        try {
+            raw = JSON.parse(text);
+        }
+        catch {
+            raw = text;
+        }
+    }
+    if (!response.ok)
+        throw errorFrom(response.status, raw, url);
+    return (raw && typeof raw === 'object' ? raw : {});
+}
+/** Same mapping as the SDK transport: 401/403 → auth, 400 → validation, else NorbixError. */
+function errorFrom(status, raw, url) {
+    const body = raw && typeof raw === 'object' ? raw : undefined;
+    const payload = body?.responseStatus ?? body;
+    const message = payload?.message ??
+        body?.responseStatus?.errors?.find((e) => e.message)?.message ??
+        `Request failed with status ${status}`;
+    const opts = { code: payload?.errorCode, message, raw, status, url };
+    if (status === 401 || status === 403)
+        return new NorbixAuthError(opts);
+    if (status === 400)
+        return new NorbixValidationError(opts);
+    return new NorbixError(opts);
+}
+/** `Failed` / `NotTested` / `NOT_TESTED` → `FAILED` / `NOT_TESTED`. */
+export function normaliseResult(result) {
+    if (!result)
+        return 'UNKNOWN';
+    return result.replaceAll(/([a-z])([A-Z])/g, '$1_$2').replaceAll(/[\s-]+/g, '_').toUpperCase();
+}