@norbix.ai/cli 0.1.0 → 0.3.0

package/dist/lib/namespace-command.js

@@ -0,0 +1,148 @@
+import { confirm } from '@inquirer/prompts';
+import { Norbix } from '@norbix.ai/ts';
+import { BaseCommand } from '../base.js';
+import { MODULE_ALIASES, camelSplit, isDestructive, matchMethods, parseArgv } from './dispatch.js';
+/**
+ * Shared engine for `norbix hub ...` and `norbix api ...` — resolves the
+ * module and method from plain words and calls the SDK.
+ */
+export class NamespaceCommand extends BaseCommand {
+    /**
+     * oclif rejects unknown flags even in non-strict mode, but here unknown
+     * flags ARE the request fields (--schemaId ...). Split the raw argv:
+     * known global flags go to oclif, everything else goes to the dispatcher.
+     */
+    splitArgv() {
+        const VALUE_FLAGS = new Set(['--project', '--env', '--region', '--api-key', '--account', '--profile']);
+        const BOOL_FLAGS = new Set(['--json']);
+        const flagArgv = [];
+        const rest = [];
+        let help = false;
+        const raw = this.argv;
+        for (let i = 0; i < raw.length; i++) {
+            const token = raw[i];
+            const name = token.split('=')[0];
+            if (name === '--help' || name === '-h' || name === '--scope-help') {
+                help = true;
+            }
+            else if (VALUE_FLAGS.has(name)) {
+                flagArgv.push(token);
+                if (!token.includes('=') && raw[i + 1] !== undefined)
+                    flagArgv.push(raw[++i]);
+            }
+            else if (BOOL_FLAGS.has(name)) {
+                flagArgv.push(token);
+            }
+            else {
+                rest.push(token);
+            }
+        }
+        return { flagArgv, rest, help };
+    }
+    /** camelCase method → the plain-word form of this CLI (noun first, verb last). */
+    wordForm(method, moduleName, hide = new Set()) {
+        const tokens = camelSplit(method);
+        const moduleTokens = new Set(camelSplit(moduleName));
+        const [verb, ...rest] = tokens;
+        const nouns = rest.filter((t) => !moduleTokens.has(t) && !hide.has(t));
+        return [...nouns, verb].join(' ');
+    }
+    /** Scoped help: everything callable under `norbix {target} {module} {words...}`. */
+    scopeHelp(moduleWord, moduleName, methods, words, labelWords = words, hideWord) {
+        const scoped = words.length === 0
+            ? methods
+            : methods.filter((m) => matchMethods([m], words, moduleName).length > 0);
+        // The alias word (email/sms/push) is implied by the module word — hide it
+        // from the printed forms so `hub email ...` reads naturally.
+        const hide = new Set(hideWord ? [hideWord] : []);
+        const list = scoped.length > 0 ? scoped : methods;
+        const rows = list
+            .map((m) => {
+            const form = this.wordForm(m, moduleName, hide);
+            const marker = isDestructive(m) ? '  (asks confirmation)' : '';
+            return `  norbix ${this.target} ${moduleWord} ${form}${marker}`;
+        })
+            .join('\n');
+        this.print(`Commands in scope "${this.target} ${moduleWord}${labelWords.length > 0 ? ' ' + labelWords.join(' ') : ''}"` +
+            `${scoped.length === 0 ? ' (no exact scope match — showing the whole module)' : ''}:\n\n${rows}\n\n` +
+            `Add an ID as a plain value and request fields as flags:\n` +
+            `  norbix ${this.target} ${moduleWord} ${this.wordForm(list[0], moduleName, hide)} <id> --someField value\n\n` +
+            `Useful extras: --dry-run (preview the call), --yes (skip confirmation),\n` +
+            `--json (machine output), --profile/--env/--region/--project (context).`);
+        return { scope: `${this.target}.${moduleName}`, commands: list.map((m) => this.wordForm(m, moduleName, hide)) };
+    }
+    async dispatch(argv, flags, help = false) {
+        const parsed = parseArgv(argv);
+        const [moduleWord, ...restWords] = parsed.words;
+        // Introspection client — never used for requests.
+        const probe = new Norbix({ projectId: 'introspect', apiKey: 'introspect' }, { envSource: {} });
+        const namespace = probe[this.target];
+        const moduleNames = Object.keys(namespace).sort();
+        if (!moduleWord) {
+            this.print(`Usage: norbix ${this.target} <module> <words...> [id] [--field value]\n\nModules:\n  ${moduleNames.join('\n  ')}\n\n` +
+                `Get help at any level:\n  norbix ${this.target} <module> --help\n  norbix ${this.target} <module> <words...> --help\n\n` +
+                `Example: norbix ${this.target} database aggregates delete maggr_123 --schemaId sch_456`);
+            return { modules: moduleNames };
+        }
+        const alias = MODULE_ALIASES[moduleWord];
+        const moduleName = alias && namespace[alias.module] ? alias.module : moduleWord;
+        const sdkModule = namespace[moduleName];
+        if (!sdkModule) {
+            this.error(`Unknown module "${moduleWord}" on ${this.target}.\nAvailable: ${moduleNames.join(', ')}`);
+        }
+        // Only real SDK methods — internals like `transport` are not callable.
+        const methods = Object.keys(sdkModule)
+            .filter((k) => typeof sdkModule[k] === 'function')
+            .sort();
+        if (help) {
+            const injected = alias?.injectWord && moduleName !== moduleWord ? alias.injectWord : undefined;
+            const helpWords = injected ? [injected, ...restWords] : [...restWords];
+            return this.scopeHelp(moduleWord, moduleName, methods, helpWords, restWords, injected);
+        }
+        if (restWords.length === 0 && parsed.positionals.length === 0) {
+            this.print(`Methods of ${this.target}.${moduleName}:\n  ${methods.join('\n  ')}\n\nCall one with plain words, e.g.:\n  norbix ${this.target} ${moduleWord} aggregates get\n  norbix ${this.target} ${moduleWord} aggregates delete <id>`);
+            return { module: moduleName, methods };
+        }
+        const words = [...restWords];
+        if (alias?.injectWord && moduleName !== moduleWord)
+            words.unshift(alias.injectWord);
+        const matches = matchMethods(methods, words, moduleName);
+        if (matches.length === 0) {
+            // Show only methods sharing at least one word — the full list can be 100+.
+            const lower = words.map((w) => w.toLowerCase().replace(/s$/, ''));
+            const related = methods.filter((m) => lower.some((w) => m.toLowerCase().includes(w)));
+            const shown = (related.length > 0 ? related : methods).slice(0, 25);
+            this.error(`No ${this.target}.${moduleName} method matches "${words.join(' ')}".\n` +
+                `${related.length > 0 ? 'Close methods' : 'Methods'}:\n  ${shown.join('\n  ')}` +
+                `${shown.length < methods.length ? `\n  … run \`norbix ${this.target} ${moduleWord}\` for the full list` : ''}`);
+        }
+        if (matches.length > 1) {
+            this.error(`"${words.join(' ')}" is ambiguous — did you mean:\n  ${matches.map((m) => m.method).join('\n  ')}\nAdd a word (e.g. the verb) to be specific.`);
+        }
+        const method = matches[0].method;
+        const request = { ...parsed.fields };
+        if (parsed.positionals.length > 0 && request.id === undefined) {
+            request.id = parsed.positionals[0];
+            if (parsed.positionals.length > 1) {
+                this.error(`Only one positional value is allowed (became "id"). Pass the rest as flags, e.g. --schemaId ${parsed.positionals[1]}`);
+            }
+        }
+        if (parsed.dryRun) {
+            this.print({ wouldCall: `${this.target}.${moduleName}.${method}`, request });
+            return { method: `${this.target}.${moduleName}.${method}`, request, dryRun: true };
+        }
+        if (isDestructive(method) && !parsed.yes && process.stdout.isTTY) {
+            const ok = await confirm({
+                message: `Run ${method}(${JSON.stringify(request)})?`,
+                default: false,
+            });
+            if (!ok)
+                return this.print('Cancelled.');
+        }
+        const client = this.client(flags);
+        const liveModule = client[this.target][moduleName];
+        const res = await liveModule[method](request);
+        this.print(res);
+        return res;
+    }
+}

package/dist/lib/profiles.js

@@ -0,0 +1,138 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Profile storage — one INI file, AWS-style but simpler:
+ *
+ *   ~/.norbix/config          (mode 600, secrets + settings together)
+ *   ---------------------------------------------------------------
+ *   [default]
+ *   api_key = nbk_live_...
+ *   project_id = 5f1a...
+ *
+ *   [fitskin-prod]
+ *   api_key = nbk_live_...
+ *   project_id = 64ff...
+ *   account_id = ...
+ *   env = TEST
+ *   api_url = https://api.norbix.ai
+ *   hub_url = https://hub.norbix.ai
+ *
+ * Browser/password login sessions live in ~/.norbix/session.json —
+ * separate on purpose: sessions rotate and are machine-managed, the
+ * config file is edited by people.
+ */
+export const NORBIX_DIR = join(homedir(), '.norbix');
+export const PROFILES_PATH = join(NORBIX_DIR, 'config');
+export const SESSION_PATH = join(NORBIX_DIR, 'session.json');
+export const DEFAULT_API_URL = 'https://api.norbix.ai';
+export const DEFAULT_HUB_URL = 'https://hub.norbix.ai';
+export const PROFILE_KEYS = [
+    'api_key',
+    'project_id',
+    'account_id',
+    'env',
+    'region',
+    'api_url',
+    'hub_url',
+    'files_integration_id',
+];
+// ---------- tiny INI reader/writer (no dependency) ----------
+export function parseIni(text) {
+    const out = {};
+    let section = 'default';
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#') || line.startsWith(';'))
+            continue;
+        const sec = line.match(/^\[(.+)\]$/);
+        if (sec) {
+            section = sec[1].trim();
+            out[section] ??= {};
+            continue;
+        }
+        const eq = line.indexOf('=');
+        if (eq > 0) {
+            out[section] ??= {};
+            out[section][line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
+        }
+    }
+    return out;
+}
+export function stringifyIni(data) {
+    const parts = [];
+    for (const [section, values] of Object.entries(data)) {
+        parts.push(`[${section}]`);
+        for (const [k, v] of Object.entries(values)) {
+            if (v !== undefined && v !== '')
+                parts.push(`${k} = ${v}`);
+        }
+        parts.push('');
+    }
+    return parts.join('\n');
+}
+// ---------- profiles ----------
+export function readProfiles() {
+    try {
+        return parseIni(readFileSync(PROFILES_PATH, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeProfile(name, profile) {
+    mkdirSync(NORBIX_DIR, { recursive: true });
+    const all = readProfiles();
+    const clean = Object.fromEntries(Object.entries(profile).filter(([, v]) => v !== undefined && v !== ''));
+    all[name] = clean;
+    writeFileSync(PROFILES_PATH, stringifyIni(all), { mode: 0o600 });
+    try {
+        chmodSync(PROFILES_PATH, 0o600); // enforce even when the file pre-existed
+    }
+    catch {
+        /* windows: no-op */
+    }
+}
+export function deleteProfile(name) {
+    const all = readProfiles();
+    if (!(name in all))
+        return false;
+    delete all[name];
+    mkdirSync(NORBIX_DIR, { recursive: true });
+    writeFileSync(PROFILES_PATH, stringifyIni(all), { mode: 0o600 });
+    return true;
+}
+export function readSession() {
+    try {
+        const s = JSON.parse(readFileSync(SESSION_PATH, 'utf8'));
+        return s.bearerToken ? s : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeSession(session) {
+    mkdirSync(NORBIX_DIR, { recursive: true });
+    writeFileSync(SESSION_PATH, JSON.stringify(session, null, 2) + '\n', { mode: 0o600 });
+}
+export function clearSession() {
+    if (existsSync(SESSION_PATH))
+        unlinkSync(SESSION_PATH);
+}
+/** Decode a JWT `exp` claim (ms). Returns undefined when not decodable. */
+export function jwtExpiryMs(token) {
+    try {
+        const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString());
+        return typeof payload.exp === 'number' ? payload.exp * 1000 : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A session is usable when it has a token that is not (provably) expired. */
+export function isSessionValid(session) {
+    if (!session?.bearerToken)
+        return false;
+    const exp = jwtExpiryMs(session.bearerToken);
+    return exp === undefined || exp > Date.now() + 30_000;
+}

package/dist/lib/publicFiles.js

@@ -0,0 +1,63 @@
+import { NorbixError } from '@norbix.ai/ts';
+const ROUTES = {
+    makeFilePrivate: 'files/item/private',
+    makeFilePublic: 'files/item/public',
+    makeFolderPrivate: 'files/folder/private',
+    makeFolderPublic: 'files/folder/public',
+};
+/** The Hub version the SDK talks by default. Kept in one place. */
+const HUB_VERSION = 'v2';
+export async function callPublicFiles(ctx, operation, body) {
+    const token = ctx.bearerToken ?? ctx.apiKey;
+    const headers = new Headers({
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    });
+    if (token)
+        headers.set('Authorization', `Bearer ${token}`);
+    if (ctx.projectId)
+        headers.set('X-CM-ProjectId', ctx.projectId);
+    if (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.hubUrl.endsWith('/') ? ctx.hubUrl.slice(0, -1) : ctx.hubUrl;
+    const url = `${base}/${HUB_VERSION}/${ROUTES[operation]}`;
+    const response = await fetch(url, { body: JSON.stringify(body), headers, method: 'POST' });
+    const text = await response.text();
+    let payload = {};
+    if (text) {
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = {};
+        }
+    }
+    if (!response.ok) {
+        throw new NorbixError({
+            code: payload.status,
+            message: payload.message ?? text ?? 'Request failed',
+            status: response.status,
+        });
+    }
+    return payload;
+}
+/**
+ * The address anyone can open. The gateway builds the same one and puts it on
+ * the file's `publicUrl`; this is what to print right after publishing, when
+ * the caller has only just been handed the id.
+ *
+ * `remote` is the path that was published. For a file the link ends with its
+ * name; for a folder it ends with a slash, and a file inside it is reached by
+ * appending the path inside the folder.
+ */
+export function publicUrlFor(apiUrl, publicId, remote, isFolder) {
+    const base = apiUrl.endsWith('/') ? apiUrl.slice(0, -1) : apiUrl;
+    if (isFolder)
+        return `${base}/v3/files/public/${publicId}/`;
+    const name = remote.split('/').filter(Boolean).pop() ?? remote;
+    return `${base}/v3/files/public/${publicId}/${name.split('/').map(encodeURIComponent).join('/')}`;
+}