@aderis-erp/cli 1.0.2 → 1.0.3

package/dist/commands/{pubsub.d.ts → async-endpoints-internal.d.ts}

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Pubsub extends Command {
+export default class AsyncEndpointsInternal extends Command {
     static description: string;
     static examples: never[];
     static args: {

package/dist/commands/{pubsub.js → async-endpoints-internal.js}

@@ -8,11 +8,11 @@ const HAS_CAMT053 = false;
 const NESTED_IMPORTS = [];
 const SUBCOMMANDS = [...["webhook-events", "processor-jobs"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
 const ENDPOINTS = {
-    'webhook-events': { method: 'POST', path: '/v1/pubsub/webhook-events', summary: 'GCP Pub/Sub push endpoint for webhook event delivery', pathParams: [], hasBody: false, isMultipart: false },
-    'processor-jobs': { method: 'POST', path: '/v1/pubsub/processor-jobs', summary: 'GCP Pub/Sub push endpoint for processor-job.v1 envelopes (PDF rendering)', pathParams: [], hasBody: false, isMultipart: false },
+    'webhook-events': { method: 'POST', path: '/v1/pubsub/webhook-events', summary: '[INTERNAL] Async push endpoint for webhook event delivery', pathParams: [], hasBody: false, isMultipart: false },
+    'processor-jobs': { method: 'POST', path: '/v1/pubsub/processor-jobs', summary: '[INTERNAL] Async push endpoint for processor-job.v1 envelopes', pathParams: [], hasBody: false, isMultipart: false },
 };
-export default class Pubsub extends Command {
-    static description = 'Manage pubsub';
+export default class AsyncEndpointsInternal extends Command {
+    static description = 'Manage async endpoints internal';
     static examples = [];
     static args = {
         action: Args.string({ description: 'Action: ' + SUBCOMMANDS.join(', '), required: true }),
@@ -38,7 +38,7 @@ export default class Pubsub extends Command {
         'show-http-request': Flags.boolean({ description: 'Show HTTP request details (method, URL, body)' }),
     };
     async run() {
-        const { args, flags } = await this.parse(Pubsub);
+        const { args, flags } = await this.parse(AsyncEndpointsInternal);
         // Handle import action specially
         if (args.action === 'import') {
             if (!HAS_IMPORT)
@@ -84,7 +84,7 @@ export default class Pubsub extends Command {
                 // First path param always comes from positional argument
                 value = args.id;
                 if (!value)
-                    this.error('Missing required argument: id. Usage: aderis pubsub <action> <id>');
+                    this.error('Missing required argument: id. Usage: aderis async-endpoints-internal <action> <id>');
             }
             else {
                 const flagName = param.replace(/\./g, '-').replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
@@ -647,7 +647,7 @@ export default class Pubsub extends Command {
     }
     async runNestedImport(suffix, parentId, flags) {
         if (!parentId) {
-            this.error(`Missing required argument: id. Usage: aderis pubsub import-${suffix} <parent-id> --file data.json`);
+            this.error(`Missing required argument: id. Usage: aderis async-endpoints-internal import-${suffix} <parent-id> --file data.json`);
         }
         const context = flags.context ? getContext(flags.context) : getCurrentContext();
         if (!context)
@@ -809,32 +809,44 @@ export default class Pubsub extends Command {
     filterFields(data, fields) {
         const isUnsafeKey = (k) => k === '__proto__' || k === 'constructor' || k === 'prototype';
         const pick = (obj, keys) => {
-            const result = {};
+            // Group keys by their first segment so sibling sub-paths
+            // (e.g. 'items.amount' + 'items._type') resolve in one recursive pass
+            // and don't clobber each other on merge.
+            const directKeys = new Set();
+            const nestedKeys = new Map();
             for (const key of keys) {
                 if (key.split('.').some(isUnsafeKey))
                     continue;
                 if (key.includes('.')) {
-                    // Handle nested fields like 'customer.name' or 'allocations.salesInvoiceId'
                     const [first, ...rest] = key.split('.');
-                    const val = obj[first];
-                    if (val && typeof val === 'object') {
-                        const restKey = rest.join('.');
-                        if (Array.isArray(val)) {
-                            // Map over array elements (e.g., allocations[].salesInvoiceId)
-                            const existing = Array.isArray(result[first]) ? result[first] : [];
-                            result[first] = val.map((item, i) => ({
-                                ...(existing[i] || {}),
-                                ...pick(item, [restKey]),
-                            }));
-                        }
-                        else {
-                            const nested = pick(val, [restKey]);
-                            result[first] = { ...(result[first] || {}), ...nested };
-                        }
+                    if (isUnsafeKey(first))
+                        continue;
+                    const list = nestedKeys.get(first);
+                    if (list) {
+                        list.push(rest.join('.'));
                     }
+                    else {
+                        nestedKeys.set(first, [rest.join('.')]);
+                    }
+                }
+                else {
+                    directKeys.add(key);
                 }
-                else if (key in obj) {
+            }
+            const result = {};
+            for (const key of directKeys) {
+                if (key in obj)
                     result[key] = obj[key];
+            }
+            for (const [first, restKeys] of nestedKeys) {
+                const val = obj[first];
+                if (!val || typeof val !== 'object')
+                    continue;
+                if (Array.isArray(val)) {
+                    result[first] = val.map(item => pick(item, restKeys));
+                }
+                else {
+                    result[first] = pick(val, restKeys);
                 }
             }
             return result;

package/dist/commands/audit-log.d.ts

@@ -0,0 +1,39 @@
+import { Command } from '@oclif/core';
+export default class AuditLog extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        action: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        context: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        table: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        csv: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        data: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        set: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        page: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        include: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        search: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'sort-by': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        filter: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        query: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        fields: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sanitize: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'show-http-request': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private runImport;
+    private runExport;
+    private runCamt053Import;
+    private runNestedImport;
+    private filterFields;
+    private sanitizeOutput;
+    private getColumns;
+    private getValue;
+    private printTable;
+    private printCsv;
+}

package/dist/commands/{processing-logs.js → audit-log.js}

@@ -3,18 +3,20 @@ import { apiRequest, ApiError } from '../lib/api-client.js';
 import { getCurrentContext, getContext, getBaseUrls } from '../lib/config.js';
 // Add 'import' action if both create and update exist
 const HAS_IMPORT = false;
-const HAS_EXPORT = false;
+const HAS_EXPORT = true;
 const HAS_CAMT053 = false;
 const NESTED_IMPORTS = [];
-const SUBCOMMANDS = [...["get", "get-processingId"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
+const SUBCOMMANDS = [...["list", "find-entity", "find-workflow"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
 const ENDPOINTS = {
-    'get': { method: 'GET', path: '/v1/processing-logs', summary: 'List recent inbox processing logs (newest first)', pathParams: [], hasBody: false, isMultipart: false },
-    'get-processingId': { method: 'GET', path: '/v1/processing-logs/{processingId}', summary: 'Get a processing run by its processing identifier', pathParams: ['processingId'], hasBody: false, isMultipart: false },
+    'list': { method: 'GET', path: '/v1/audit-log', summary: 'Get audit log entries', pathParams: [], hasBody: false, isMultipart: false },
+    'find-entity': { method: 'GET', path: '/v1/audit-log/entity/{entityId}', summary: 'Get audit history for a specific entity', pathParams: ['entityId'], hasBody: false, isMultipart: false },
+    'find-workflow': { method: 'GET', path: '/v1/audit-log/workflow/{workflowId}', summary: 'Get audit log entries for a specific workflow', pathParams: ['workflowId'], hasBody: false, isMultipart: false },
 };
-export default class ProcessingLogs extends Command {
-    static description = 'Manage processing logs';
+export default class AuditLog extends Command {
+    static description = 'Manage audit log';
     static examples = [
-        '<%= config.bin %> processing-logs get <id>',
+        '<%= config.bin %> audit-log list',
+        '<%= config.bin %> audit-log export --csv > audit-log.csv',
     ];
     static args = {
         action: Args.string({ description: 'Action: ' + SUBCOMMANDS.join(', '), required: true }),
@@ -40,7 +42,7 @@ export default class ProcessingLogs extends Command {
         'show-http-request': Flags.boolean({ description: 'Show HTTP request details (method, URL, body)' }),
     };
     async run() {
-        const { args, flags } = await this.parse(ProcessingLogs);
+        const { args, flags } = await this.parse(AuditLog);
         // Handle import action specially
         if (args.action === 'import') {
             if (!HAS_IMPORT)
@@ -86,7 +88,7 @@ export default class ProcessingLogs extends Command {
                 // First path param always comes from positional argument
                 value = args.id;
                 if (!value)
-                    this.error('Missing required argument: id. Usage: aderis processing-logs <action> <id>');
+                    this.error('Missing required argument: id. Usage: aderis audit-log <action> <id>');
             }
             else {
                 const flagName = param.replace(/\./g, '-').replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
@@ -649,7 +651,7 @@ export default class ProcessingLogs extends Command {
     }
     async runNestedImport(suffix, parentId, flags) {
         if (!parentId) {
-            this.error(`Missing required argument: id. Usage: aderis processing-logs import-${suffix} <parent-id> --file data.json`);
+            this.error(`Missing required argument: id. Usage: aderis audit-log import-${suffix} <parent-id> --file data.json`);
         }
         const context = flags.context ? getContext(flags.context) : getCurrentContext();
         if (!context)
@@ -811,32 +813,44 @@ export default class ProcessingLogs extends Command {
     filterFields(data, fields) {
         const isUnsafeKey = (k) => k === '__proto__' || k === 'constructor' || k === 'prototype';
         const pick = (obj, keys) => {
-            const result = {};
+            // Group keys by their first segment so sibling sub-paths
+            // (e.g. 'items.amount' + 'items._type') resolve in one recursive pass
+            // and don't clobber each other on merge.
+            const directKeys = new Set();
+            const nestedKeys = new Map();
             for (const key of keys) {
                 if (key.split('.').some(isUnsafeKey))
                     continue;
                 if (key.includes('.')) {
-                    // Handle nested fields like 'customer.name' or 'allocations.salesInvoiceId'
                     const [first, ...rest] = key.split('.');
-                    const val = obj[first];
-                    if (val && typeof val === 'object') {
-                        const restKey = rest.join('.');
-                        if (Array.isArray(val)) {
-                            // Map over array elements (e.g., allocations[].salesInvoiceId)
-                            const existing = Array.isArray(result[first]) ? result[first] : [];
-                            result[first] = val.map((item, i) => ({
-                                ...(existing[i] || {}),
-                                ...pick(item, [restKey]),
-                            }));
-                        }
-                        else {
-                            const nested = pick(val, [restKey]);
-                            result[first] = { ...(result[first] || {}), ...nested };
-                        }
+                    if (isUnsafeKey(first))
+                        continue;
+                    const list = nestedKeys.get(first);
+                    if (list) {
+                        list.push(rest.join('.'));
                     }
+                    else {
+                        nestedKeys.set(first, [rest.join('.')]);
+                    }
+                }
+                else {
+                    directKeys.add(key);
                 }
-                else if (key in obj) {
+            }
+            const result = {};
+            for (const key of directKeys) {
+                if (key in obj)
                     result[key] = obj[key];
+            }
+            for (const [first, restKeys] of nestedKeys) {
+                const val = obj[first];
+                if (!val || typeof val !== 'object')
+                    continue;
+                if (Array.isArray(val)) {
+                    result[first] = val.map(item => pick(item, restKeys));
+                }
+                else {
+                    result[first] = pick(val, restKeys);
                 }
             }
             return result;

package/dist/commands/auth/login.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class AuthLogin extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'client-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        context: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        new: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private createNewContext;
+}

package/dist/commands/auth/login.js

@@ -0,0 +1,116 @@
+import { input, select } from '@inquirer/prompts';
+import { Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { login, testAuth } from '../../lib/auth.js';
+import { addContext, DEFAULT_CLIENT_IDS, getContext, getCurrentContext, } from '../../lib/config.js';
+export default class AuthLogin extends Command {
+    static description = 'Login to an Aderis environment using OAuth';
+    static examples = [
+        '<%= config.bin %> auth login',
+        '<%= config.bin %> auth login --context my-client',
+        '<%= config.bin %> auth login --new --name my-client --environment dev',
+    ];
+    static flags = {
+        'client-id': Flags.string({
+            description: 'OAuth client ID (uses default if not specified)',
+        }),
+        context: Flags.string({
+            char: 'c',
+            description: 'Context to login with (uses current context if not specified)',
+        }),
+        environment: Flags.string({
+            char: 'e',
+            description: 'Environment (dev, test, live)',
+            options: ['dev', 'test', 'live'],
+        }),
+        name: Flags.string({
+            description: 'Name for the new context (required with --new)',
+        }),
+        new: Flags.boolean({
+            char: 'n',
+            default: false,
+            description: 'Create a new context before logging in',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AuthLogin);
+        let context = null;
+        if (flags.new) {
+            context = await this.createNewContext(flags);
+        }
+        else if (flags.context) {
+            context = getContext(flags.context);
+            if (!context) {
+                this.error(`Context "${flags.context}" not found. Use --new to create it.`);
+            }
+        }
+        else {
+            context = getCurrentContext();
+            if (!context) {
+                this.log("No context found. Let's create one.");
+                context = await this.createNewContext(flags);
+            }
+        }
+        const spinner = ora(`Logging in to ${context.name} (${context.environment})...`).start();
+        try {
+            spinner.text = 'Waiting for browser authentication...';
+            await login(context);
+            spinner.text = 'Verifying authentication...';
+            const user = await testAuth(context.name);
+            spinner.succeed(`Successfully logged in as ${user.email || user.name || 'user'}`);
+            this.log(`\nContext: ${context.name}`);
+            this.log(`Environment: ${context.environment}`);
+            if (context.tenant_id) {
+                this.log(`Tenant ID: ${context.tenant_id}`);
+            }
+        }
+        catch (error) {
+            spinner.fail('Login failed');
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            throw error;
+        }
+    }
+    async createNewContext(flags) {
+        // Get context name
+        let contextName = flags.name;
+        if (!contextName) {
+            contextName = await input({
+                message: 'Context name (e.g., acme-dev, my-company-prod):',
+                validate(value) {
+                    if (!value.trim())
+                        return 'Name is required';
+                    if (!/^[\w-]+$/.test(value))
+                        return 'Name can only contain letters, numbers, and hyphens';
+                    if (getContext(value))
+                        return `Context "${value}" already exists`;
+                    return true;
+                },
+            });
+        }
+        // Get environment
+        let environment;
+        environment = flags.environment ? flags.environment : (await select({
+            choices: [
+                { description: 'Development environment', name: 'dev', value: 'dev' },
+                { description: 'Test/staging environment', name: 'test', value: 'test' },
+                { description: 'Production environment', name: 'live', value: 'live' },
+            ],
+            message: 'Environment:',
+        }));
+        const defaultClientId = DEFAULT_CLIENT_IDS[environment];
+        const clientId = flags['client-id'] || defaultClientId;
+        if (!clientId) {
+            this.error(`No default client ID configured for ${environment} environment. Please provide --client-id`);
+        }
+        const context = {
+            client_id: clientId,
+            environment,
+            name: contextName,
+        };
+        addContext(context);
+        this.log(`\nContext "${context.name}" created.`);
+        return context;
+    }
+}

package/dist/commands/auth/logout.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class AuthLogout extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        context: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/logout.js

@@ -0,0 +1,58 @@
+import { Command, Flags } from '@oclif/core';
+import { clearTokens, getContext, getCurrentContext } from '../../lib/config.js';
+export default class AuthLogout extends Command {
+    static description = 'Logout from the current or specified context';
+    static examples = [
+        '<%= config.bin %> auth logout',
+        '<%= config.bin %> auth logout --context my-client',
+        '<%= config.bin %> auth logout --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Logout from all contexts',
+        }),
+        context: Flags.string({
+            char: 'c',
+            description: 'Specific context to logout from',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AuthLogout);
+        const { listContexts } = await import('../../lib/config.js');
+        if (flags.all) {
+            const contexts = listContexts();
+            for (const ctx of contexts) {
+                if (ctx.tokens) {
+                    clearTokens(ctx.name);
+                    this.log(`Logged out from ${ctx.name}`);
+                }
+            }
+            this.log('\nLogged out from all contexts.');
+            return;
+        }
+        let contextName;
+        if (flags.context) {
+            const ctx = getContext(flags.context);
+            if (!ctx) {
+                this.error(`Context "${flags.context}" not found.`);
+            }
+            contextName = flags.context;
+        }
+        else {
+            const current = getCurrentContext();
+            if (!current) {
+                this.error('No current context. Use --context to specify one.');
+            }
+            contextName = current.name;
+        }
+        const context = getContext(contextName);
+        if (!context?.tokens) {
+            this.log(`Already logged out from ${contextName}`);
+            return;
+        }
+        clearTokens(contextName);
+        this.log(`Successfully logged out from ${contextName}`);
+    }
+}

package/dist/commands/auth/status.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class AuthStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        context: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private showAllContexts;
+    private showContextStatus;
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,101 @@
+import { Command, Flags } from '@oclif/core';
+import { testAuth } from '../../lib/auth.js';
+import { getContext, getCurrentContext, listContexts } from '../../lib/config.js';
+export default class AuthStatus extends Command {
+    static description = 'Show authentication status for contexts';
+    static examples = [
+        '<%= config.bin %> auth status',
+        '<%= config.bin %> auth status --context my-client',
+        '<%= config.bin %> auth status --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Show status for all contexts',
+        }),
+        context: Flags.string({
+            char: 'c',
+            description: 'Specific context to check',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AuthStatus);
+        if (flags.all) {
+            await this.showAllContexts();
+            return;
+        }
+        let contextName;
+        if (flags.context) {
+            const ctx = getContext(flags.context);
+            if (!ctx) {
+                this.error(`Context "${flags.context}" not found.`);
+            }
+            contextName = flags.context;
+        }
+        else {
+            const current = getCurrentContext();
+            if (!current) {
+                this.log('No current context configured.');
+                this.log('Run: aderis auth login --new');
+                return;
+            }
+            contextName = current.name;
+        }
+        await this.showContextStatus(contextName, true);
+    }
+    async showAllContexts() {
+        const contexts = listContexts();
+        const current = getCurrentContext();
+        if (contexts.length === 0) {
+            this.log('No contexts configured.');
+            this.log('Run: aderis auth login --new');
+            return;
+        }
+        this.log('Contexts:\n');
+        for (const ctx of contexts) {
+            const isCurrent = current?.name === ctx.name;
+            const prefix = isCurrent ? '* ' : '  ';
+            const status = ctx.tokens ? '✓ logged in' : '✗ not logged in';
+            this.log(`${prefix}${ctx.name} (${ctx.environment}) - ${status}`);
+        }
+        this.log('\n* = current context');
+    }
+    async showContextStatus(name, detailed) {
+        const context = getContext(name);
+        const current = getCurrentContext();
+        if (!context) {
+            this.error(`Context "${name}" not found.`);
+        }
+        const isCurrent = current?.name === name;
+        this.log(`Context: ${context.name}${isCurrent ? ' (current)' : ''}`);
+        this.log(`Environment: ${context.environment}`);
+        this.log(`Client ID: ${context.client_id}`);
+        if (!context.tokens) {
+            this.log(`Status: Not logged in`);
+            this.log(`\nRun: aderis auth login${isCurrent ? '' : ` --context ${name}`}`);
+            return;
+        }
+        this.log(`Tenant ID: ${context.tenant_id || 'N/A'}`);
+        if (context.tokens.expires_at) {
+            const expiresAt = new Date(context.tokens.expires_at);
+            const isExpired = expiresAt < new Date();
+            this.log(`Token expires: ${expiresAt.toLocaleString()}${isExpired ? ' (EXPIRED)' : ''}`);
+        }
+        if (detailed) {
+            try {
+                const user = await testAuth(name);
+                this.log(`\nLogged in as: ${user.email || user.name || 'Unknown'}`);
+                this.log('Status: ✓ Authenticated');
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.log(`\nStatus: ✗ ${error.message}`);
+                }
+                else {
+                    this.log('\nStatus: ✗ Authentication error');
+                }
+            }
+        }
+    }
+}

package/dist/commands/auth/tenant.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class AuthTenant extends Command {
+    static args: {
+        action: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        tenantId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        context: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private interactiveSwitch;
+    private listTenants;
+    private showCurrentTenant;
+    private switchTenant;
+    private resolveTenantName;
+}