@eide/foir-cli 0.1.0

package/dist/commands/segments.js

@@ -0,0 +1,143 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo, success } from '../lib/output.js';
+import { parseInputData, isUUID, confirmAction } from '../lib/input.js';
+import { SEGMENTS, SEGMENT, SEGMENT_BY_KEY, CREATE_SEGMENT, UPDATE_SEGMENT, DELETE_SEGMENT, PREVIEW_SEGMENT_RULES, TEST_SEGMENT_EVALUATION, } from '../graphql/queries.js';
+export function registerSegmentsCommands(program, globalOpts) {
+    const segments = program.command('segments').description('Manage segments');
+    // list
+    segments
+        .command('list')
+        .description('List segments')
+        .option('--active', 'Only active segments')
+        .option('--limit <n>', 'Max results', '50')
+        .option('--offset <n>', 'Skip results', '0')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(SEGMENTS, {
+            isActive: cmdOpts.active ? true : undefined,
+            limit: parseInt(String(cmdOpts.limit ?? '50'), 10),
+            offset: parseInt(String(cmdOpts.offset ?? '0'), 10),
+        });
+        formatList(data.segments, opts, {
+            columns: [
+                { key: 'id', header: 'ID', width: 28 },
+                { key: 'key', header: 'Key', width: 20 },
+                { key: 'name', header: 'Name', width: 24 },
+                { key: 'memberCount', header: 'Members', width: 10 },
+                {
+                    key: 'isActive',
+                    header: 'Active',
+                    width: 8,
+                    format: (v) => (v ? 'yes' : 'no'),
+                },
+                {
+                    key: 'updatedAt',
+                    header: 'Updated',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+        });
+    }));
+    // get
+    segments
+        .command('get <idOrKey>')
+        .description('Get a segment by ID or key')
+        .action(withErrorHandler(globalOpts, async (idOrKey) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        let result;
+        if (isUUID(idOrKey)) {
+            const data = await client.request(SEGMENT, { id: idOrKey });
+            result = data.segment;
+        }
+        else {
+            const data = await client.request(SEGMENT_BY_KEY, { key: idOrKey });
+            result = data.segmentByKey;
+        }
+        if (!result)
+            throw new Error(`Segment "${idOrKey}" not found.`);
+        formatOutput(result, opts);
+    }));
+    // create
+    segments
+        .command('create')
+        .description('Create a new segment')
+        .option('-d, --data <json>', 'Segment data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const input = await parseInputData(cmdOpts);
+        const data = await client.request(CREATE_SEGMENT, { input });
+        formatOutput(data.createSegment, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Created segment ${data.createSegment.key}`);
+    }));
+    // update
+    segments
+        .command('update <id>')
+        .description('Update a segment')
+        .option('-d, --data <json>', 'Segment data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (id, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const input = await parseInputData(cmdOpts);
+        const data = await client.request(UPDATE_SEGMENT, { id, input });
+        formatOutput(data.updateSegment, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Updated segment ${id}`);
+    }));
+    // delete
+    segments
+        .command('delete <id>')
+        .description('Delete a segment')
+        .option('--confirm', 'Skip confirmation prompt')
+        .action(withErrorHandler(globalOpts, async (id, cmdOpts) => {
+        const opts = globalOpts();
+        const confirmed = await confirmAction(`Delete segment ${id}?`, {
+            confirm: !!cmdOpts.confirm,
+        });
+        if (!confirmed) {
+            console.log('Aborted.');
+            return;
+        }
+        const client = await createClient(opts);
+        await client.request(DELETE_SEGMENT, { id });
+        if (opts.json || opts.jsonl)
+            formatOutput({ deleted: true, id }, opts);
+        else
+            success(`Deleted segment ${id}`);
+    }));
+    // preview
+    segments
+        .command('preview')
+        .description('Preview segment rules against sample customers')
+        .option('-f, --file <path>', 'Rules JSON file')
+        .option('-d, --data <json>', 'Rules as inline JSON')
+        .option('--sample-size <n>', 'Sample size', '100')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const inputData = await parseInputData(cmdOpts);
+        const rules = inputData.rules ?? inputData;
+        const data = await client.request(PREVIEW_SEGMENT_RULES, {
+            rules,
+            sampleSize: parseInt(cmdOpts.sampleSize ?? '100', 10),
+        });
+        formatOutput(data.previewSegmentRules, opts);
+    }));
+    // test
+    segments
+        .command('test <segmentId> <customerId>')
+        .description('Test whether a customer matches a segment')
+        .action(withErrorHandler(globalOpts, async (segmentId, customerId) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(TEST_SEGMENT_EVALUATION, { segmentId, customerId });
+        formatOutput(data.testSegmentEvaluation, opts);
+    }));
+}

package/dist/commands/select-project.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import { type GlobalOptions } from '../lib/config.js';
+export declare function registerSelectProjectCommand(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=select-project.d.ts.map

package/dist/commands/select-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-project.d.ts","sourceRoot":"","sources":["../../src/commands/select-project.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAC;AA+K1B,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CAoGN"}

package/dist/commands/select-project.js

@@ -0,0 +1,144 @@
+import inquirer from 'inquirer';
+import { getCredentials, updateCredentials } from '../auth/credentials.js';
+import { getApiUrl, getGraphQLEndpoint, } from '../lib/config.js';
+import { withErrorHandler } from '../lib/errors.js';
+const CLI_API_KEY_NAME = 'Foir CLI';
+const CLI_API_KEY_SCOPES = [
+    'records:read',
+    'records:write',
+    'records:delete',
+    'records:publish',
+    'files:read',
+    'files:write',
+    'extensions:read',
+    'operations:read',
+    'operations:execute',
+];
+async function gqlRequest(apiUrl, accessToken, query, variables, extraHeaders) {
+    const response = await fetch(getGraphQLEndpoint(apiUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            ...extraHeaders,
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!response.ok) {
+        throw new Error(`GraphQL request failed: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors?.length) {
+        throw new Error(`GraphQL error: ${result.errors[0].message}`);
+    }
+    return result.data;
+}
+async function fetchSessionContext(apiUrl, accessToken) {
+    const data = await gqlRequest(apiUrl, accessToken, `query { sessionContext { tenantId projectId availableTenants { id name } availableProjects { id name tenantId } } }`);
+    return data.sessionContext;
+}
+async function fetchApiKeys(apiUrl, accessToken, projectId, tenantId) {
+    const data = await gqlRequest(apiUrl, accessToken, `query { listApiKeys(includeInactive: false, limit: 100) { apiKeys { id name isActive } } }`, undefined, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
+    return data.listApiKeys?.apiKeys ?? [];
+}
+async function createApiKey(apiUrl, accessToken, projectId, tenantId) {
+    const data = await gqlRequest(apiUrl, accessToken, `mutation($input: CreateApiKeyInput!) { createApiKey(input: $input) { apiKey { id name isActive } plainKey } }`, {
+        input: {
+            name: CLI_API_KEY_NAME,
+            projectId,
+            scopes: CLI_API_KEY_SCOPES,
+        },
+    }, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
+    return data.createApiKey;
+}
+async function rotateApiKey(apiUrl, accessToken, projectId, tenantId, keyId) {
+    const data = await gqlRequest(apiUrl, accessToken, `mutation($id: ID!) { rotateApiKey(id: $id) { apiKey { id name isActive } plainKey } }`, { id: keyId }, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
+    return data.rotateApiKey;
+}
+async function provisionApiKey(apiUrl, accessToken, projectId, tenantId) {
+    const apiKeys = await fetchApiKeys(apiUrl, accessToken, projectId, tenantId);
+    const existing = apiKeys.find((k) => k.name === CLI_API_KEY_NAME && k.isActive);
+    if (existing) {
+        console.log('  Rotating existing CLI API key...');
+        const rotated = await rotateApiKey(apiUrl, accessToken, projectId, tenantId, existing.id);
+        return { apiKey: rotated.plainKey, apiKeyId: rotated.apiKey.id };
+    }
+    console.log('  Creating CLI API key...');
+    const created = await createApiKey(apiUrl, accessToken, projectId, tenantId);
+    return { apiKey: created.plainKey, apiKeyId: created.apiKey.id };
+}
+export function registerSelectProjectCommand(program, globalOpts) {
+    program
+        .command('select-project')
+        .description('Choose which project to work with')
+        .option('--project-id <id>', 'Project ID to select directly')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const apiUrl = getApiUrl(opts);
+        const credentials = await getCredentials();
+        if (!credentials) {
+            console.log('Not logged in. Run `foir login` first.');
+            process.exit(1);
+        }
+        console.log('Fetching your projects...\n');
+        const sessionContext = await fetchSessionContext(apiUrl, credentials.accessToken);
+        const { availableTenants: tenants, availableProjects: projects } = sessionContext;
+        if (projects.length === 0) {
+            console.log('No projects found. Create one in the platform first.');
+            process.exit(1);
+        }
+        const tenantNameMap = new Map(tenants.map((t) => [t.id, t.name]));
+        let selectedProject;
+        if (cmdOpts.projectId) {
+            const found = projects.find((p) => p.id === cmdOpts.projectId);
+            if (!found) {
+                console.log(`Project with ID "${cmdOpts.projectId}" not found.`);
+                console.log('Available projects:');
+                for (const p of projects) {
+                    console.log(`  - ${p.name} (${p.id})`);
+                }
+                process.exit(1);
+            }
+            selectedProject = found;
+        }
+        else {
+            const byTenant = projects.reduce((acc, p) => {
+                const key = tenantNameMap.get(p.tenantId) ?? 'Unknown';
+                if (!acc[key])
+                    acc[key] = [];
+                acc[key].push(p);
+                return acc;
+            }, {});
+            const choices = Object.entries(byTenant).flatMap(([tenantName, tenantProjects]) => [
+                new inquirer.Separator(`── ${tenantName} ──`),
+                ...tenantProjects.map((p) => ({
+                    name: `  ${p.name}`,
+                    value: p.id,
+                    short: p.name,
+                })),
+            ]);
+            const { projectId } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'projectId',
+                    message: 'Select a project:',
+                    choices,
+                },
+            ]);
+            selectedProject = projects.find((p) => p.id === projectId);
+        }
+        console.log('\nProvisioning API key for CLI access...');
+        const { apiKey, apiKeyId } = await provisionApiKey(apiUrl, credentials.accessToken, selectedProject.id, selectedProject.tenantId);
+        await updateCredentials({
+            selectedProject: {
+                id: selectedProject.id,
+                name: selectedProject.name,
+                tenantId: selectedProject.tenantId,
+                apiKey,
+                apiKeyId,
+            },
+        });
+        console.log(`\n✓ Selected project: ${selectedProject.name}`);
+        console.log('✓ API key provisioned for CLI access');
+    }));
+}

package/dist/commands/settings.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerSettingsCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=settings.d.ts.map

package/dist/commands/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/commands/settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AA0BtD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CA0HN"}

package/dist/commands/settings.js

@@ -0,0 +1,113 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, success } from '../lib/output.js';
+import { ALL_SETTINGS, SETTINGS_BY_CATEGORY, SETTING, SET_SETTING, DELETE_SETTING, } from '../graphql/queries.js';
+function inferDataType(value) {
+    if (value === 'true' || value === 'false')
+        return { dataType: 'BOOLEAN', parsed: value === 'true' };
+    const num = Number(value);
+    if (!isNaN(num) && value !== '')
+        return { dataType: 'NUMBER', parsed: num };
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === 'object')
+            return { dataType: 'JSON', parsed };
+    }
+    catch {
+        /* not JSON */
+    }
+    return { dataType: 'STRING', parsed: value };
+}
+export function registerSettingsCommands(program, globalOpts) {
+    const settings = program.command('settings').description('Manage settings');
+    // list
+    settings
+        .command('list')
+        .description('List all settings')
+        .option('--category <cat>', 'Filter by category')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        let items;
+        if (cmdOpts.category) {
+            const data = await client.request(SETTINGS_BY_CATEGORY, { category: cmdOpts.category });
+            items = data.settingsByCategory;
+        }
+        else {
+            const data = await client.request(ALL_SETTINGS);
+            items = data.allSettings;
+        }
+        formatList(items, opts, {
+            columns: [
+                { key: 'key', header: 'Key', width: 28 },
+                {
+                    key: 'value',
+                    header: 'Value',
+                    width: 28,
+                    format: (v) => typeof v === 'object' ? JSON.stringify(v) : String(v ?? ''),
+                },
+                { key: 'category', header: 'Category', width: 16 },
+                { key: 'dataType', header: 'Type', width: 10 },
+                {
+                    key: 'isPublic',
+                    header: 'Public',
+                    width: 8,
+                    format: (v) => (v ? 'yes' : 'no'),
+                },
+            ],
+        });
+    }));
+    // get
+    settings
+        .command('get <key>')
+        .description('Get a setting by key')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(SETTING, { key });
+        if (!data.setting)
+            throw new Error(`Setting "${key}" not found.`);
+        formatOutput(data.setting, opts);
+    }));
+    // set
+    settings
+        .command('set <key> <value>')
+        .description('Set a setting value')
+        .option('--category <cat>', 'Category (required for new settings)')
+        .option('--data-type <type>', 'Data type (STRING, NUMBER, BOOLEAN, JSON)')
+        .action(withErrorHandler(globalOpts, async (key, value, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        // Try to fetch existing to get category/dataType
+        const existing = await client.request(SETTING, { key });
+        const inferred = inferDataType(value);
+        const category = cmdOpts.category ?? existing.setting?.category;
+        if (!category)
+            throw new Error('--category is required for new settings.');
+        const dataType = cmdOpts.dataType ?? existing.setting?.dataType ?? inferred.dataType;
+        const data = await client.request(SET_SETTING, {
+            input: {
+                key,
+                value: inferred.parsed,
+                category,
+                dataType,
+            },
+        });
+        formatOutput(data.setSetting, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Set ${key} = ${value}`);
+    }));
+    // reset (delete)
+    settings
+        .command('reset <key>')
+        .description('Delete a setting (reset to default)')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        await client.request(DELETE_SETTING, { key });
+        if (opts.json || opts.jsonl)
+            formatOutput({ deleted: true, key }, opts);
+        else
+            success(`Deleted setting ${key}`);
+    }));
+}

package/dist/commands/variant-catalog.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerVariantCatalogCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=variant-catalog.d.ts.map

package/dist/commands/variant-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant-catalog.d.ts","sourceRoot":"","sources":["../../src/commands/variant-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AActD,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CAgJN"}

package/dist/commands/variant-catalog.js

@@ -0,0 +1,111 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, success } from '../lib/output.js';
+import { parseInputData, isUUID, confirmAction } from '../lib/input.js';
+import { VARIANT_CATALOG, VARIANT_CATALOG_ENTRY, VARIANT_CATALOG_ENTRY_BY_KEY, CREATE_VARIANT_CATALOG_ENTRY, UPDATE_VARIANT_CATALOG_ENTRY, DELETE_VARIANT_CATALOG_ENTRY, } from '../graphql/queries.js';
+export function registerVariantCatalogCommands(program, globalOpts) {
+    const catalog = program
+        .command('variant-catalog')
+        .description('Manage variant catalog entries (markets, devices, locales)');
+    // list
+    catalog
+        .command('list')
+        .description('List variant catalog entries')
+        .option('--active', 'Only active entries')
+        .option('--limit <n>', 'Max results', '50')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(VARIANT_CATALOG, {
+            isActive: cmdOpts.active ? true : undefined,
+            limit: parseInt(String(cmdOpts.limit ?? '50'), 10),
+        });
+        formatList(data.variantCatalog, opts, {
+            columns: [
+                { key: 'key', header: 'Key', width: 20 },
+                { key: 'name', header: 'Name', width: 24 },
+                {
+                    key: 'isDefault',
+                    header: 'Default',
+                    width: 8,
+                    format: (v) => (v ? 'yes' : ''),
+                },
+                {
+                    key: 'isActive',
+                    header: 'Active',
+                    width: 8,
+                    format: (v) => (v ? 'yes' : 'no'),
+                },
+            ],
+        });
+    }));
+    // get
+    catalog
+        .command('get <idOrKey>')
+        .description('Get a variant catalog entry by ID or key')
+        .action(withErrorHandler(globalOpts, async (idOrKey) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        let result;
+        if (isUUID(idOrKey)) {
+            const data = await client.request(VARIANT_CATALOG_ENTRY, { id: idOrKey });
+            result = data.variantCatalogEntry;
+        }
+        else {
+            const data = await client.request(VARIANT_CATALOG_ENTRY_BY_KEY, { key: idOrKey });
+            result = data.variantCatalogEntryByKey;
+        }
+        if (!result)
+            throw new Error(`Variant catalog entry "${idOrKey}" not found.`);
+        formatOutput(result, opts);
+    }));
+    // create
+    catalog
+        .command('create')
+        .description('Create a variant catalog entry')
+        .option('-d, --data <json>', 'Entry data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const input = await parseInputData(cmdOpts);
+        const data = await client.request(CREATE_VARIANT_CATALOG_ENTRY, { input });
+        formatOutput(data.createVariantCatalogEntry, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Created variant catalog entry ${data.createVariantCatalogEntry.key}`);
+    }));
+    // update
+    catalog
+        .command('update <id>')
+        .description('Update a variant catalog entry')
+        .option('-d, --data <json>', 'Entry data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (id, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const input = await parseInputData(cmdOpts);
+        const data = await client.request(UPDATE_VARIANT_CATALOG_ENTRY, { id, input });
+        formatOutput(data.updateVariantCatalogEntry, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Updated variant catalog entry ${data.updateVariantCatalogEntry.key}`);
+    }));
+    // delete
+    catalog
+        .command('delete <id>')
+        .description('Delete a variant catalog entry')
+        .option('--confirm', 'Skip confirmation prompt')
+        .action(withErrorHandler(globalOpts, async (id, cmdOpts) => {
+        const opts = globalOpts();
+        const confirmed = await confirmAction(`Delete variant catalog entry ${id}?`, { confirm: !!cmdOpts.confirm });
+        if (!confirmed) {
+            console.log('Aborted.');
+            return;
+        }
+        const client = await createClient(opts);
+        await client.request(DELETE_VARIANT_CATALOG_ENTRY, { id });
+        if (opts.json || opts.jsonl)
+            formatOutput({ deleted: true, id }, opts);
+        else
+            success(`Deleted variant catalog entry ${id}`);
+    }));
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerWhoamiCommand(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=whoami.d.ts.map

package/dist/commands/whoami.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../src/commands/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CAwDN"}

package/dist/commands/whoami.js

@@ -0,0 +1,50 @@
+import { getCredentials, isTokenExpired } from '../auth/credentials.js';
+import { withErrorHandler } from '../lib/errors.js';
+import { formatOutput } from '../lib/output.js';
+export function registerWhoamiCommand(program, globalOpts) {
+    program
+        .command('whoami')
+        .description('Show current authentication status')
+        .action(withErrorHandler(globalOpts, async () => {
+        const opts = globalOpts();
+        const credentials = await getCredentials();
+        if (!credentials) {
+            if (opts.json || opts.jsonl) {
+                formatOutput({ authenticated: false }, opts);
+            }
+            else {
+                console.log('Not logged in.');
+                console.log('\nRun `foir login` to authenticate.');
+            }
+            process.exit(1);
+        }
+        const expired = isTokenExpired(credentials);
+        if (opts.json || opts.jsonl) {
+            formatOutput({
+                authenticated: true,
+                tokenValid: !expired,
+                user: credentials.user,
+                selectedProject: credentials.selectedProject ?? null,
+            }, opts);
+            return;
+        }
+        console.log('Authentication Status');
+        console.log('─'.repeat(40));
+        console.log(`User:    ${credentials.user.name} <${credentials.user.email}>`);
+        console.log(`User ID: ${credentials.user.id}`);
+        console.log(`Token:   ${expired ? '⚠ Expired' : '✓ Valid'}`);
+        if (credentials.selectedProject) {
+            console.log('');
+            console.log('Selected Project');
+            console.log('─'.repeat(40));
+            console.log(`Name:      ${credentials.selectedProject.name}`);
+            console.log(`ID:        ${credentials.selectedProject.id}`);
+            console.log(`Tenant ID: ${credentials.selectedProject.tenantId}`);
+        }
+        else {
+            console.log('');
+            console.log('No project selected.');
+            console.log('Run `foir select-project` to choose a project.');
+        }
+    }));
+}