@api-now/cli 1.0.4

package/dist/commands/orgs.js

@@ -0,0 +1,104 @@
+import { getSdkClient, handleApiError } from '../utils/api.js';
+import { config } from '../utils/config.js';
+import { Formatter, CliErrorCode } from '../utils/formatter.js';
+/**
+ * Registers organization commands (list, set-default) with the main Commander program.
+ *
+ * @param program - The root Commander program.
+ */
+export function registerOrgsCommands(program) {
+    const orgsCmd = program.command('orgs').description('Manage organization configurations');
+    orgsCmd
+        .command('list')
+        .description('List all organizations you belong to')
+        .action(async () => {
+        const formatter = new Formatter({ format: config.resolved.format });
+        try {
+            const client = getSdkClient();
+            const res = await client.organizations.list({ token: client.token });
+            const orgs = res.data || [];
+            const resolved = config.resolved;
+            const rows = orgs.map((org) => ({
+                id: org.key,
+                name: org.name,
+                slug: org.slug,
+                isDefault: org.key === resolved.org ? 'Yes' : 'No',
+            }));
+            formatter.list(rows, ['id', 'name', 'slug', 'isDefault'], {
+                headers: ['ID', 'NAME', 'SLUG', 'DEFAULT'],
+            });
+        }
+        catch (err) {
+            const apiErr = handleApiError(err);
+            formatter.error(apiErr);
+            process.exit(1);
+        }
+    });
+    orgsCmd
+        .command('set-default <oid>')
+        .description('Set your default organization ID')
+        .action(async (oid) => {
+        const formatter = new Formatter({ format: config.resolved.format });
+        try {
+            const client = getSdkClient();
+            const res = await client.organizations.list({ token: client.token });
+            const orgs = res.data || [];
+            const exists = orgs.some((org) => org.key === oid);
+            if (!exists) {
+                formatter.error({
+                    code: CliErrorCode.INVALID_ARGUMENT,
+                    message: `Organization ID '${oid}' not found in your authorized list.`,
+                    detail: 'Run `apinow orgs list` to see all authorized organizations and their IDs.',
+                });
+                process.exit(1);
+            }
+            config.writeProperty('org', oid);
+            formatter.success(`Default organization ID set to '${oid}'.`);
+        }
+        catch (err) {
+            const apiErr = handleApiError(err);
+            formatter.error(apiErr);
+            process.exit(1);
+        }
+    });
+    orgsCmd
+        .command('default')
+        .alias('get-default')
+        .description('Get the default configured organization')
+        .action(async () => {
+        const formatter = new Formatter({ format: config.resolved.format });
+        try {
+            const resolved = config.resolved;
+            if (!resolved.org) {
+                formatter.error({
+                    code: CliErrorCode.MISSING_REQUIRED,
+                    message: 'No default organization configured.',
+                    detail: 'Set one using `apinow orgs set-default <oid>`. Run `apinow orgs list` to list available organizations.',
+                });
+                process.exit(1);
+            }
+            const client = getSdkClient();
+            const res = await client.organizations.list({ token: client.token });
+            const orgs = res.data || [];
+            const org = orgs.find((org) => org.key === resolved.org);
+            if (!org) {
+                formatter.error({
+                    code: CliErrorCode.INVALID_ARGUMENT,
+                    message: `Default organization ID '${resolved.org}' not found in your authorized list.`,
+                    detail: 'Run `apinow orgs set-default <oid>` to configure a valid default organization.',
+                });
+                process.exit(1);
+            }
+            formatter.object({
+                id: org.key,
+                name: org.name,
+                slug: org.slug,
+            });
+        }
+        catch (err) {
+            const apiErr = handleApiError(err);
+            formatter.error(apiErr);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/tokens.js

@@ -0,0 +1,145 @@
+import { getSdkClient, handleApiError } from '../utils/api.js';
+import { config } from '../utils/config.js';
+import { Formatter, CliErrorCode, style } from '../utils/formatter.js';
+/**
+ * Helper function to decode the active token and extract its ID (jti or id claim).
+ *
+ * @returns The active token's ID if available, otherwise null.
+ */
+function getActiveTokenId() {
+    const token = config.resolved.token;
+    if (!token)
+        return null;
+    try {
+        const parts = token.split('.');
+        if (parts.length === 3) {
+            const payload = parts[1];
+            const decoded = Buffer.from(payload, 'base64url').toString('utf8');
+            const parsed = JSON.parse(decoded);
+            if (parsed && typeof parsed === 'object') {
+                return parsed.jti || parsed.id || null;
+            }
+        }
+    }
+    catch {
+        // Ignore and return null if decoding fails
+    }
+    return null;
+}
+/**
+ * Registers personal access tokens commands (list, create, delete) under the auth command namespace.
+ *
+ * @param authCmd - The auth subcommand router.
+ */
+export function registerTokensCommands(authCmd) {
+    const tokensCmd = authCmd.command('tokens').description('Manage personal access tokens');
+    tokensCmd
+        .command('list')
+        .description('List all personal access tokens')
+        .action(async () => {
+        const formatter = new Formatter({ format: config.resolved.format });
+        try {
+            const client = getSdkClient();
+            if (!client.token) {
+                formatter.error({
+                    code: CliErrorCode.UNAUTHORIZED,
+                    message: 'Not logged in.',
+                    detail: 'Use `apinow auth login <provider>` to authenticate.',
+                });
+                process.exit(1);
+            }
+            const tokens = await client.users.listTokens({ token: client.token });
+            const activeTokenId = getActiveTokenId();
+            const rows = tokens.map((token) => ({
+                id: token.id,
+                name: token.name || 'N/A',
+                lastUsedAt: token.lastUsedAt || 'Never',
+                expiresAt: token.expiresAt || 'Never',
+                active: token.id === activeTokenId ? 'Yes' : 'No',
+            }));
+            formatter.list(rows, ['id', 'name', 'lastUsedAt', 'expiresAt', 'active'], {
+                headers: ['ID', 'NAME', 'LAST USED', 'EXPIRES', 'ACTIVE'],
+            });
+        }
+        catch (err) {
+            const apiErr = handleApiError(err);
+            formatter.error(apiErr);
+            process.exit(1);
+        }
+    });
+    tokensCmd
+        .command('create')
+        .description('Create a new personal access token')
+        .option('--name <name>', 'Optional name to identify the token')
+        .option('--expires-at <expires>', 'Optional expiration time (e.g. "30 days", "10 minutes", or timestamp)')
+        .action(async (options) => {
+        const formatter = new Formatter({ format: config.resolved.format });
+        try {
+            const client = getSdkClient();
+            if (!client.token) {
+                formatter.error({
+                    code: CliErrorCode.UNAUTHORIZED,
+                    message: 'Not logged in.',
+                    detail: 'Use `apinow auth login <provider>` to authenticate.',
+                });
+                process.exit(1);
+            }
+            const payload = {};
+            if (options.name) {
+                payload.name = options.name;
+            }
+            if (options.expiresAt) {
+                if (/^\d+$/.test(options.expiresAt)) {
+                    payload.expiresAt = parseInt(options.expiresAt, 10);
+                }
+                else {
+                    payload.expiresAt = options.expiresAt;
+                }
+            }
+            const res = await client.users.createToken(payload, { token: client.token });
+            if (config.resolved.format === 'json') {
+                formatter.success('Token created successfully!', res);
+            }
+            else {
+                formatter.success('Token created successfully!');
+                console.log('\n' +
+                    style.yellow('⚠ WARNING: Make sure to copy your personal access token now. You will NOT be able to see it again!') +
+                    '\n');
+                console.log(`${style.bold('Raw Token')}: ${style.cyan(res.token)}`);
+                console.log(`${style.bold('ID')}: ${res.id}`);
+                console.log(`${style.bold('Name')}: ${res.name || 'N/A'}`);
+                console.log(`${style.bold('Type')}: ${res.type}`);
+                console.log(`${style.bold('Expires At')}: ${res.expiresAt || 'Never'}\n`);
+            }
+        }
+        catch (err) {
+            const apiErr = handleApiError(err);
+            formatter.error(apiErr);
+            process.exit(1);
+        }
+    });
+    tokensCmd
+        .command('delete <id>')
+        .description('Delete a personal access token by ID')
+        .action(async (id) => {
+        const formatter = new Formatter({ format: config.resolved.format });
+        try {
+            const client = getSdkClient();
+            if (!client.token) {
+                formatter.error({
+                    code: CliErrorCode.UNAUTHORIZED,
+                    message: 'Not logged in.',
+                    detail: 'Use `apinow auth login <provider>` to authenticate.',
+                });
+                process.exit(1);
+            }
+            await client.users.deleteToken(id, { token: client.token });
+            formatter.success(`Token '${id}' deleted successfully.`);
+        }
+        catch (err) {
+            const apiErr = handleApiError(err);
+            formatter.error(apiErr);
+            process.exit(1);
+        }
+    });
+}

package/dist/index.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Main entry point for the API NOW! Platform Command Line Interface (CLI) tool.
+ * Binds global options, imports all subcommands, and executes the parser.
+ */
+import { createRequire } from 'node:module';
+import updateNotifier from 'update-notifier';
+import { Command } from 'commander';
+import { registerConfigCommands } from './commands/config.js';
+import { registerAuthCommands } from './commands/auth.js';
+import { registerOrgsCommands } from './commands/orgs.js';
+import { registerFilesCommands } from './commands/files.js';
+import { registerCatalogCommands } from './commands/catalog.js';
+import { config } from './utils/config.js';
+import { Formatter, CliErrorCode } from './utils/formatter.js';
+// Guard Node.js version >= 22
+if (parseInt(process.versions.node.split('.')[0], 10) < 22) {
+    console.error('Error: apinow requires Node.js 22 or higher.');
+    process.exit(1);
+}
+function getOutputFormat() {
+    const index = process.argv.indexOf('--format');
+    if (index !== -1 && index + 1 < process.argv.length) {
+        const val = process.argv[index + 1];
+        if (val === 'json')
+            return 'json';
+    }
+    try {
+        return config.resolved.format || 'text';
+    }
+    catch {
+        return 'text';
+    }
+}
+process.on('uncaughtException', (err) => {
+    const formatter = new Formatter({ format: getOutputFormat() });
+    formatter.error({
+        code: CliErrorCode.UNKNOWN,
+        message: err.message || 'An unexpected error occurred.',
+        detail: err.stack,
+    });
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    const formatter = new Formatter({ format: getOutputFormat() });
+    const message = reason instanceof Error ? reason.message : String(reason);
+    const detail = reason instanceof Error ? reason.stack : undefined;
+    formatter.error({
+        code: CliErrorCode.UNKNOWN,
+        message: `Unhandled promise rejection: ${message}`,
+        detail,
+    });
+    process.exit(1);
+});
+// Load package.json for metadata
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+// Check for updates and notify the user on exit
+updateNotifier({ pkg }).notify();
+// Load configuration initially
+config.load();
+const program = new Command();
+program
+    .name('apinow')
+    .description('API NOW! Platform CLI Tool')
+    .version(pkg.version, '--version')
+    .option('--format <format>', 'Output format: text, json', 'text')
+    .option('--api-url <url>', 'Override target API server base URL')
+    .option('--debug', 'Enable debug/verbose logging');
+program.hook('preAction', () => {
+    config.saturate({
+        apiUrl: program.opts().apiUrl,
+        format: program.opts().format,
+    });
+});
+// Register command routers
+registerConfigCommands(program);
+registerAuthCommands(program);
+registerOrgsCommands(program);
+registerFilesCommands(program);
+registerCatalogCommands(program);
+// Parse arguments
+await program.parseAsync(process.argv);

package/dist/utils/api.js

@@ -0,0 +1,54 @@
+import { StoreSdk } from '@api-now/core/sdk/StoreSdkNode.js';
+import { config } from './config.js';
+import { CliErrorCode } from './formatter.js';
+/**
+ * Configures and returns a StoreSdk instance for communicating with the API NOW! platform.
+ * Reads the token from local configuration and configures it on the SDK automatically.
+ *
+ * @param options - Configuration overrides for the client connection.
+ * @returns A StoreSdk instance ready for requests.
+ */
+export function getSdkClient(options = {}) {
+    const resolved = config.resolved;
+    const apiUrl = options.apiUrl || resolved.apiUrl;
+    const sdk = new StoreSdk(apiUrl);
+    if (resolved.token) {
+        sdk.token = resolved.token;
+    }
+    return sdk;
+}
+/**
+ * Standardizes raw error throws from the SDK into a consistent, readable format.
+ *
+ * @param error - The raw error object caught in a try/catch block.
+ * @returns A standardized ApiErrorResponse object.
+ */
+export function handleApiError(error) {
+    if (error && typeof error === 'object') {
+        const err = error;
+        const status = err.status;
+        const code = err.code;
+        let message = err.message || 'An unknown error occurred.';
+        const help = err.help;
+        if (status === 401) {
+            message = 'Unauthorized. Please login using `auth login`.';
+            return {
+                message,
+                status,
+                code: CliErrorCode.UNAUTHORIZED,
+                help,
+            };
+        }
+        return {
+            message,
+            status,
+            code: code || CliErrorCode.API_FAILURE,
+            help,
+        };
+    }
+    const err = error;
+    return {
+        message: err?.message || 'An unknown error occurred.',
+        code: CliErrorCode.UNKNOWN,
+    };
+}

package/dist/utils/config.js

@@ -0,0 +1,202 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+/**
+ * The fallback API URL when not configured.
+ */
+const DEFAULT_API_URL = 'http://localhost:8080';
+/**
+ * The folder name for the CLI configuration.
+ */
+const CLI_FOLDER = 'apinow-cli';
+/**
+ * The config file name.
+ */
+const CONFIG_FILE = 'config.json';
+/**
+ * Manager class for resolving, loading, and saturating the CLI configuration.
+ */
+class CliConfigManager {
+    _resolved = null;
+    /**
+     * The resolved read-only CLI configuration.
+     */
+    get resolved() {
+        if (!this._resolved) {
+            this.load();
+        }
+        const res = this._resolved;
+        if (!res) {
+            throw new Error('Configuration could not be loaded.');
+        }
+        return res;
+    }
+    /**
+     * The directory path for storing configuration files.
+     */
+    configDir = this.#getConfigDir();
+    /**
+     * The absolute configuration file path.
+     */
+    configPath = path.join(this.configDir, CONFIG_FILE);
+    /**
+     * Loads configuration from disk and environment variables.
+     */
+    load() {
+        const diskConfig = this.#readConfig();
+        const token = process.env.APINOW_API_TOKEN || process.env.APINOW_TOKEN || diskConfig.token;
+        const apiUrl = process.env.APINOW_API_URL || diskConfig.apiUrl || DEFAULT_API_URL;
+        const org = diskConfig.org || '';
+        this._resolved = {
+            token,
+            apiUrl,
+            org,
+            format: 'text',
+        };
+    }
+    /**
+     * Saturates/overrides configuration fields with commander options.
+     */
+    saturate(options) {
+        if (!this._resolved) {
+            this.load();
+        }
+        const current = this._resolved;
+        if (!current) {
+            throw new Error('Configuration could not be loaded.');
+        }
+        this._resolved = {
+            token: current.token,
+            apiUrl: options.apiUrl || current.apiUrl,
+            org: current.org,
+            format: options.format === 'json' ? 'json' : 'text',
+        };
+    }
+    /**
+     * Returns the directory path for storing configuration files depending on the OS platform.
+     *
+     * - Windows: `%APPDATA%/apinow-cli`
+     * - MacOS: `~/Library/Preferences/apinow-cli`
+     * - Linux: `~/.config/apinow-cli` (or respects `$XDG_CONFIG_HOME`)
+     *
+     * @returns The absolute directory path.
+     */
+    #getConfigDir() {
+        if (process.platform === 'win32') {
+            const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+            if (!appData) {
+                throw new Error('Could not determine the configuration directory.');
+            }
+            return path.join(appData, CLI_FOLDER);
+        }
+        if (process.platform === 'darwin') {
+            return path.join(os.homedir(), 'Library', 'Preferences', CLI_FOLDER);
+        }
+        return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), CLI_FOLDER);
+    }
+    /**
+     * Reads and parses the CLI configuration from the configuration file.
+     * If the configuration file does not exist, returns default settings.
+     *
+     * @example
+     * ```typescript
+     * const config = this.#readConfig();
+     * console.log(config.apiUrl);
+     * ```
+     *
+     * @returns The current configuration object.
+     */
+    #readConfig() {
+        try {
+            if (!fs.existsSync(this.configPath)) {
+                return { apiUrl: DEFAULT_API_URL };
+            }
+            const content = fs.readFileSync(this.configPath, 'utf8');
+            const config = JSON.parse(content);
+            return {
+                apiUrl: DEFAULT_API_URL,
+                ...config,
+            };
+        }
+        catch (_error) {
+            return { apiUrl: DEFAULT_API_URL };
+        }
+    }
+    /**
+     * Writes a single property to the configuration file on disk.
+     */
+    writeProperty(key, value) {
+        const current = this.#readConfig();
+        current[key] = value;
+        this.#writeConfig(current);
+    }
+    /**
+     * Merges and writes the provided settings to the configuration file on disk.
+     * Creates the directory structure if it does not exist.
+     *
+     * @example
+     * ```typescript
+     * writeConfig({ token: 'my-secret-token' });
+     * ```
+     *
+     * @param config A partial config object containing keys to set or update.
+     */
+    #writeConfig(config) {
+        try {
+            const current = this.#readConfig();
+            const updated = { ...current, ...config };
+            if (!fs.existsSync(this.configDir)) {
+                fs.mkdirSync(this.configDir, { recursive: true });
+            }
+            fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2), 'utf8');
+        }
+        catch (error) {
+            console.error('Failed to write configuration:', error);
+        }
+    }
+    /**
+     * Clears/removes a specific configuration key from the configuration file.
+     *
+     * @example
+     * ```typescript
+     * clearConfigKey('token');
+     * ```
+     *
+     * @param key The key of the CliConfig to remove.
+     */
+    clearConfigKey(key) {
+        try {
+            const current = this.#readConfig();
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete current[key];
+            if (!fs.existsSync(this.configDir)) {
+                fs.mkdirSync(this.configDir, { recursive: true });
+            }
+            fs.writeFileSync(this.configPath, JSON.stringify(current, null, 2), 'utf8');
+        }
+        catch (error) {
+            console.error(`Failed to clear key ${key} from configuration:`, error);
+        }
+    }
+    /**
+     * Resets/removes the configuration file and directory.
+     */
+    reset() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                fs.unlinkSync(this.configPath);
+            }
+            if (fs.existsSync(this.configDir)) {
+                const files = fs.readdirSync(this.configDir);
+                if (files.length === 0) {
+                    fs.rmdirSync(this.configDir);
+                }
+            }
+            this._resolved = null;
+        }
+        catch (error) {
+            console.error('Failed to reset configuration:', error);
+        }
+    }
+}
+export const config = new CliConfigManager();