gpxe 1.0.0

package/bin/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const { run } = require('../src/main');
+
+run(process.argv).catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});
+module.exports = { run };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "gpxe",
+  "version": "1.0.0",
+  "description": "CLI-first telemetry for Gridpoint Analytics.",
+  "main": "bin/index.js",
+  "scripts": {
+    "test": "node test/cli.spec.js"
+  },
+  "keywords": [
+    "analytics",
+    "cli",
+    "cloudflare",
+    "observability",
+    "telemetry",
+    "gridpoint"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "axios": "^1.13.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "conf": "^15.0.2",
+    "enquirer": "^2.4.1"
+  },
+  "bin": {
+    "gpxe": "bin/index.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "package.json"
+  ]
+}

package/src/api.js

@@ -0,0 +1,39 @@
+const axios = require('axios');
+const { config } = require('./config');
+
+const DEFAULT_ENDPOINT = "https://gridpoint-engine.awalker-3.workers.dev";
+
+const normalizeEndpoint = (endpoint) => {
+    if (!endpoint) return endpoint;
+    return endpoint.replace(/\/+$/, '');
+};
+
+const resolveEndpoint = (explicitEndpoint) => {
+    return normalizeEndpoint(explicitEndpoint || process.env.GRIDPOINT_ENDPOINT || config.get('endpoint') || DEFAULT_ENDPOINT);
+};
+
+const resolveToken = () => process.env.GRIDPOINT_TOKEN || config.get('token');
+
+const buildHeaders = () => {
+    const token = resolveToken();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+};
+
+const request = async (method, endpoint, path, data, params) => {
+    return axios({
+        method,
+        url: `${endpoint}${path}`,
+        data,
+        params,
+        headers: { "Content-Type": "application/json", ...buildHeaders() },
+        timeout: 10000
+    });
+};
+
+module.exports = {
+    DEFAULT_ENDPOINT,
+    normalizeEndpoint,
+    resolveEndpoint,
+    resolveToken,
+    request
+};

package/src/billing.js

@@ -0,0 +1,91 @@
+const { config } = require('./config');
+const { request, resolveEndpoint } = require('./api');
+const { program } = require('commander');
+const { getCommandPath } = require('./util');
+const chalk = require('chalk');
+
+let cachedBillingContext = null;
+let billingContextPromise = null;
+
+const resolveBillingContext = async (endpoint) => {
+    if (cachedBillingContext) return cachedBillingContext;
+    const accountId = process.env.GRIDPOINT_ACCOUNT_ID || config.get('account_id');
+    const workspaceId = process.env.GRIDPOINT_WORKSPACE_ID || config.get('workspace_id');
+    if (accountId || workspaceId) {
+        cachedBillingContext = { accountId: accountId || null, workspaceId: workspaceId || null };
+        return cachedBillingContext;
+    }
+    if (!endpoint) return null;
+    if (billingContextPromise) return billingContextPromise;
+    billingContextPromise = (async () => {
+        try {
+            const response = await request('get', endpoint, '/billing/account');
+            const account = response.data?.account || null;
+            if (account?.id || account?.workspace_id) {
+                cachedBillingContext = {
+                    accountId: account.id || null,
+                    workspaceId: account.workspace_id || null
+                };
+            }
+            return cachedBillingContext;
+        } catch (e) {
+            return null;
+        } finally {
+            billingContextPromise = null;
+        }
+    })();
+    return billingContextPromise;
+};
+
+const isMeteringEnabled = (opts) => {
+    if (opts?.demo) return false;
+    const demoEnv = ['1', 'true', 'yes', 'on'].includes((process.env.GRIDPOINT_DEMO || '').toLowerCase());
+    return !demoEnv;
+};
+
+const shouldMeterCommand = (commandPath) => {
+    if (!commandPath) return false;
+    const top = commandPath.split(' ')[0];
+    return !['login', 'init', 'config', 'billing', 'help'].includes(top);
+};
+
+const recordUsage = async (actionCommand) => {
+    const opts = typeof actionCommand?.opts === 'function' ? actionCommand.opts() : {};
+    if (!isMeteringEnabled(opts)) return;
+    const commandPath = getCommandPath(actionCommand);
+    if (!shouldMeterCommand(commandPath)) return;
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const context = await resolveBillingContext(endpoint);
+    if (!context?.accountId && !context?.workspaceId) return;
+    const started = opts?._startTime;
+    const durationMs = Number.isFinite(started) ? Date.now() - started : null;
+    const payload = {
+        account_id: context?.accountId || null,
+        workspace_id: context?.workspaceId || null,
+        service: commandPath,
+        quantity: 1,
+        unit: 'commands',
+        source: 'cli',
+        metadata: {
+            command: commandPath,
+            duration_ms: Number.isFinite(durationMs) ? durationMs : null,
+            cli_version: program.version(),
+            platform: process.platform,
+            node_version: process.version
+        }
+    };
+    try {
+        await request('post', endpoint, '/billing/usage', payload);
+    } catch (e) {
+        if (showHints) {
+            console.log(chalk.gray('Tip: unable to record billing usage; check account/workspace id.'));
+        }
+    }
+};
+
+module.exports = {
+    resolveBillingContext,
+    isMeteringEnabled,
+    shouldMeterCommand,
+    recordUsage,
+};

package/src/commands/alerts.js

@@ -0,0 +1,66 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { toInt, printRequestError, shouldShowHints, formatPercent } = require('../util');
+const { isDemo, demoAlertsTune } = require('../demo');
+
+const alertsCommand = program.command('alerts').description('Alert intelligence commands.');
+
+alertsCommand
+    .command('tune')
+    .description('Suggest adaptive alert thresholds.')
+    .option('--window <window>', 'Lookback window (e.g. 24h)', '24h')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--limit <count>', 'Max recommendations', '5')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = {
+        window: opts.window,
+        limit: toInt(opts.limit, 5)
+    };
+    if (opts.service) params.service = opts.service;
+    try {
+        const data = isDemo(opts)
+            ? demoAlertsTune(params.window, params.service)
+            : (await request('get', endpoint, '/alerts/tune', null, params)).data || {};
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const windowLabel = data.window || opts.window;
+        const serviceLabel = data.service || opts.service || 'all services';
+        console.log(chalk.cyan(`Adaptive alerting (service/${serviceLabel}, window: ${windowLabel})`));
+        const summary = data.summary || {};
+        if (Number.isFinite(summary.noisy_alerts) || Number.isFinite(summary.total_alerts)) {
+            const noisy = Number.isFinite(summary.noisy_alerts) ? summary.noisy_alerts : 'n/a';
+            const total = Number.isFinite(summary.total_alerts) ? summary.total_alerts : 'n/a';
+            const pct = Number.isFinite(summary.noise_pct) ? `${summary.noise_pct}%` : 'n/a';
+            console.log(`Noisy alerts: ${noisy} / ${total} (${pct})`);
+        }
+        const recommendations = Array.isArray(data.recommendations) ? data.recommendations : [];
+        if (recommendations.length === 0) {
+            console.log('No tuning recommendations.');
+            if (shouldShowHints()) {
+                console.log(chalk.gray('Tip: ingest alert data or run with --demo.'));
+            }
+            return;
+        }
+        console.log('');
+        console.log('Recommendations:');
+        recommendations.slice(0, params.limit).forEach((rec, index) => {
+            const name = rec.alert || rec.name || 'alert';
+            const action = rec.action || 'adjust';
+            const current = rec.current || 'n/a';
+            const suggested = rec.suggested || 'n/a';
+            const reduction = Number.isFinite(rec.expected_noise_reduction_pct)
+                ? ` (${formatPercent(rec.expected_noise_reduction_pct)} noise reduction)`
+                : '';
+            console.log(`${index + 1}) ${name}: ${action} ${current} -> ${suggested}${reduction}`);
+        });
+    } catch (e) {
+        printRequestError(e, 'Failed to tune alerts.', endpoint);
+    }
+});

package/src/commands/basic.js

@@ -0,0 +1,110 @@
+const { program } = require('commander');
+const { prompt } = require('enquirer');
+const chalk = require('chalk');
+const { config } = require('../config');
+const { DEFAULT_ENDPOINT, normalizeEndpoint, resolveEndpoint, resolveToken, request } = require('../api');
+const { shouldShowHints, printRequestError } = require('../util');
+
+program.command('login')
+    .description('Save an API token so the CLI can fetch telemetry.')
+    .option('--token <token>', 'API token (or use the prompt)')
+    .action(async (opts) => {
+    let token = opts.token;
+    if (!token) {
+        const res = await prompt({ type: 'password', name: 'token', message: 'Cloudflare API token (read-only ok):' });
+        token = res.token;
+    }
+    if (!token) {
+        console.log(chalk.red('No token provided.'));
+        return;
+    }
+    config.set('token', token);
+            console.log(chalk.green('✔ Authenticated. Next: gpxe init'));    if (shouldShowHints()) {
+        console.log(chalk.gray('Tip: set GRIDPOINT_TOKEN to override this device setting.'));
+    }
+});
+
+program.command('init')
+    .description('Store the Gridpoint engine endpoint for this device.')
+    .option('--endpoint <url>', 'Override endpoint')
+    .action(async (opts) => {
+    let endpoint = opts.endpoint || process.env.GRIDPOINT_ENDPOINT;
+    if (!endpoint) {
+        const res = await prompt({
+            type: 'input',
+            name: 'endpoint',
+            message: 'Gridpoint engine endpoint (press enter for default):',
+            initial: DEFAULT_ENDPOINT
+        });
+        endpoint = res.endpoint;
+    }
+    if (!endpoint) {
+        console.log(chalk.red('No endpoint provided.'));
+        return;
+    }
+    endpoint = normalizeEndpoint(endpoint);
+    config.set('endpoint', endpoint);
+            console.log(chalk.green(`✔ Linked to ${endpoint}. Next: gpxe status`));    if (shouldShowHints()) {
+        console.log(chalk.gray('Tip: set GRIDPOINT_ENDPOINT to override this device setting.'));
+    }
+});
+
+program.command('onboard')
+    .description('Guided onboarding for tokens, endpoints, and workspace billing.')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--token <token>', 'API token')
+    .option('--workspace <id>', 'Workspace identifier')
+    .action(async (opts) => {
+    let token = opts.token || resolveToken();
+    if (!token) {
+        const res = await prompt({ type: 'password', name: 'token', message: 'API token:' });
+        token = res.token;
+    }
+    if (!token) {
+        console.log(chalk.red('No token provided.'));
+        return;
+    }
+    config.set('token', token);
+
+    let endpoint = normalizeEndpoint(opts.endpoint || process.env.GRIDPOINT_ENDPOINT || config.get('endpoint'));
+    if (!endpoint) {
+        const res = await prompt({
+            type: 'input',
+            name: 'endpoint',
+            message: 'Gridpoint engine endpoint:',
+            initial: DEFAULT_ENDPOINT
+        });
+        endpoint = normalizeEndpoint(res.endpoint);
+    }
+    if (!endpoint) {
+        console.log(chalk.red('No endpoint provided.'));
+        return;
+    }
+    config.set('endpoint', endpoint);
+
+    let workspaceId = opts.workspace || process.env.GRIDPOINT_WORKSPACE_ID || config.get('workspace_id');
+    if (!workspaceId) {
+        const res = await prompt({
+            type: 'input',
+            name: 'workspace',
+            message: 'Workspace id (used for billing attribution):'
+        });
+        workspaceId = res.workspace;
+    }
+    if (workspaceId) {
+        config.set('workspace_id', workspaceId);
+    }
+
+    console.log(chalk.green('✔ Workspace connected.'));
+    try {
+        const params = workspaceId ? { workspace_id: workspaceId } : undefined;
+        const data = (await request('get', endpoint, '/billing/account', null, params)).data || {};
+        const account = data.account || {};
+        console.log(`Plan: ${account.plan || 'starter'} (${account.status || 'active'})`);
+        if (account.portal_url) {
+            console.log(`Billing portal: ${account.portal_url}`);
+        }
+    } catch (e) {
+        printRequestError(e, 'Unable to load billing account.', endpoint);
+    }
+                console.log(chalk.gray('Next: gpxe status'));});

package/src/commands/billing.js

@@ -0,0 +1,118 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { parseQuantity, printRequestError, wantsJSON, formatCents } = require('../util');
+const { isDemo, demoBillingStatus, demoBillingUsageReport } = require('../demo');
+
+const billingCommand = program.command('billing').description('Billing and usage commands.');
+
+billingCommand
+    .command('status')
+    .description('Show billing status, usage, and invoices.')
+    .option('--account <id>', 'Billing account id')
+    .option('--workspace <id>', 'Workspace id')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = {};
+    if (opts.account) params.account_id = opts.account;
+    if (opts.workspace) params.workspace_id = opts.workspace;
+    try {
+        const data = isDemo(opts)
+            ? demoBillingStatus()
+            : (await request('get', endpoint, '/billing/account', null, params)).data || {};
+        if (opts.json || wantsJSON()) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const account = data.account;
+        if (!account) {
+            console.log(chalk.yellow('No billing account on file.'));
+            return;
+        }
+        console.log(chalk.cyan('Billing account'));
+        console.log(`Account: ${account.id}`);
+        if (account.workspace_id) console.log(`Workspace: ${account.workspace_id}`);
+        console.log(`Plan: ${account.plan} (${account.status || 'active'})`);
+        if (account.usage_tier) console.log(`Usage tier: ${account.usage_tier}`);
+        if (account.period_start || account.period_end) {
+            console.log(`Period: ${account.period_start || 'n/a'} -> ${account.period_end || 'n/a'}`);
+        }
+        if (data.usage) {
+            const limit = account.usage_limit;
+            const total = data.usage.total ?? 0;
+            const usageLine = limit
+                ? `${total.toLocaleString('en-US')} / ${limit.toLocaleString('en-US')} ${data.usage.unit || ''}`
+                : `${total.toLocaleString('en-US')} ${data.usage.unit || ''}`;
+            console.log(`Usage (${data.usage.month}): ${usageLine.trim()}`);
+        }
+        if (account.payment_method?.brand || account.payment_method?.last4) {
+            console.log(
+                `Payment method: ${account.payment_method?.brand || 'Card'} ${account.payment_method?.last4 ? `•••• ${account.payment_method.last4}` : ''}`.trim()
+            );
+        }
+        if (account.next_invoice?.amount) {
+            console.log(
+                `Next invoice: ${formatCents(account.next_invoice.amount, account.next_invoice.currency)} due ${account.next_invoice.due_at || 'n/a'}`
+            );
+        }
+        if (Array.isArray(data.invoices) && data.invoices.length > 0) {
+            console.log('');
+            console.log('Recent invoices:');
+            data.invoices.slice(0, 5).forEach((invoice) => {
+                const amount = formatCents(invoice.amount_due, invoice.currency);
+                console.log(`- ${invoice.number || invoice.id} ${amount} (${invoice.status || 'unknown'})`);
+            });
+        }
+    } catch (e) {
+        printRequestError(e, 'Failed to fetch billing status.', endpoint);
+    }
+});
+
+const billingUsageCommand = billingCommand.command('usage').description('Usage reporting commands.');
+
+billingUsageCommand
+    .command('report')
+    .description('Report metered usage for billing.')
+    .option('--count <count>', 'Usage count to report')
+    .option('--service <name>', 'Service name')
+    .option('--unit <unit>', 'Usage unit (events, metrics, traces)', 'events')
+    .option('--account <id>', 'Billing account id')
+    .option('--workspace <id>', 'Workspace id')
+    .option('--source <source>', 'Usage source tag', 'cli')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    const quantity = parseQuantity(opts.count);
+    if (!Number.isFinite(quantity) || quantity <= 0) {
+        console.log(chalk.red('Provide a positive usage count via --count.'));
+        return;
+    }
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const payload = {
+        account_id: opts.account || null,
+        workspace_id: opts.workspace || null,
+        service: opts.service || null,
+        quantity,
+        unit: opts.unit || 'events',
+        source: opts.source || 'cli'
+    };
+    try {
+        const data = isDemo(opts)
+            ? demoBillingUsageReport(payload)
+            : (await request('post', endpoint, '/billing/usage', payload)).data || {};
+        if (opts.json || wantsJSON()) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(chalk.cyan('Usage recorded'));
+        console.log(`Count: ${quantity.toLocaleString('en-US')} ${payload.unit}`);
+        if (payload.service) console.log(`Service: ${payload.service}`);
+        if (payload.workspace_id) console.log(`Workspace: ${payload.workspace_id}`);
+    } catch (e) {
+        printRequestError(e, 'Failed to report usage.', endpoint);
+    }
+});

package/src/commands/capacity.js

@@ -0,0 +1,62 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { toInt, printRequestError, shouldShowHints, formatPercent, formatCurrency } = require('../util');
+const { isDemo, demoCapacityForecast } = require('../demo');
+
+const capacityCommand = program.command('capacity').description('Capacity and cost intelligence commands.');
+
+capacityCommand
+    .command('forecast')
+    .description('Forecast capacity and cost trends.')
+    .option('--window <window>', 'Forecast window (e.g. 30d)', '30d')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = { window: opts.window };
+    if (opts.service) params.service = opts.service;
+    try {
+        const data = isDemo(opts)
+            ? demoCapacityForecast(params.window, params.service)
+            : (await request('get', endpoint, '/capacity/forecast', null, params)).data || {};
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const windowLabel = data.window || opts.window;
+        const serviceLabel = data.service || opts.service || 'all services';
+        console.log(chalk.cyan(`Capacity forecast (service/${serviceLabel}, window: ${windowLabel})`));
+        const saturation = data.saturation || {};
+        if (Number.isFinite(saturation.days) || Number.isFinite(saturation.utilization_pct)) {
+            const days = Number.isFinite(saturation.days) ? `${saturation.days}d` : 'n/a';
+            const util = formatPercent(saturation.utilization_pct);
+            console.log(`Saturation window: ${days} (util ${util})`);
+        }
+        const cost = data.cost || {};
+        if (Number.isFinite(cost.projected_monthly_usd) || Number.isFinite(cost.delta_pct)) {
+            const monthly = formatCurrency(cost.projected_monthly_usd);
+            const delta = Number.isFinite(cost.delta_pct) ? ` (${formatPercent(cost.delta_pct)})` : '';
+            console.log(`Projected cost: ${monthly}${delta}`);
+        }
+        const recommendations = Array.isArray(data.recommendations) ? data.recommendations : [];
+        if (recommendations.length === 0) {
+            console.log('No capacity recommendations.');
+            if (shouldShowHints()) {
+                console.log(chalk.gray('Tip: ingest capacity forecasts or run with --demo.'));
+            }
+            return;
+        }
+        console.log('');
+        console.log('Recommendations:');
+        recommendations.forEach((rec, index) => {
+            const label = rec.action || 'action';
+            const detail = rec.detail || rec.note || 'Review capacity plan.';
+            console.log(`${index + 1}) ${label}: ${detail}`);
+        });
+    } catch (e) {
+        printRequestError(e, 'Failed to forecast capacity.', endpoint);
+    }
+});

package/src/commands/changes.js

@@ -0,0 +1,51 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { resolveEndpoint, request } = require('../api');
+const { toInt, printRequestError, shouldShowHints, formatImpact } = require('../util');
+const { isDemo, demoChangesCorrelate } = require('../demo');
+
+program.command('changes')
+    .description('Change intelligence commands.')
+    .command('correlate')
+    .description('List the most correlated recent changes.')
+    .option('--window <window>', 'Lookback window (e.g. 24h)', '24h')
+    .option('--service <name>', 'Filter to a specific service')
+    .option('--limit <count>', 'Max results to return', '10')
+    .option('--endpoint <url>', 'Override endpoint')
+    .option('--json', 'Output raw JSON')
+    .option('--demo', 'Use demo data')
+    .action(async (opts) => {
+    const endpoint = resolveEndpoint(opts.endpoint);
+    const params = {
+        window: opts.window,
+        limit: toInt(opts.limit, 10)
+    };
+    if (opts.service) params.service = opts.service;
+    try {
+        const data = isDemo(opts)
+            ? demoChangesCorrelate(params.window)
+            : (await request('get', endpoint, '/changes/correlate', null, params)).data || {};
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const windowLabel = data.window || opts.window;
+        const results = Array.isArray(data.results) ? data.results : [];
+        console.log(chalk.cyan(`Top correlated changes (window: ${windowLabel})`));
+        if (results.length === 0) {
+            console.log('No correlated changes found.');
+            if (shouldShowHints()) {
+                console.log(chalk.gray('Tip: ingest change events or run with --demo.'));
+            }
+            return;
+        }
+        results.slice(0, params.limit).forEach((entry, index) => {
+            const label = [entry.type, entry.id].filter(Boolean).join(':') || 'change';
+            const score = Number.isFinite(entry.score) ? entry.score : 'n/a';
+            const impactLabel = formatImpact(entry.impact);
+            console.log(`${index + 1}) ${label}  score: ${score}  ${impactLabel}`);
+        });
+    } catch (e) {
+        printRequestError(e, 'Failed to correlate changes.', endpoint);
+    }
+});

package/src/commands/config.js

@@ -0,0 +1,72 @@
+const { program } = require('commander');
+const chalk = require('chalk');
+const { config, CONFIG_PATH } = require('../config');
+const { resolveEndpoint, resolveToken } = require('../api');
+const { maskToken, shouldShowHints } = require('../util');
+
+const configCommand = program.command('config')
+    .description('Show the saved endpoint and token status.')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => {
+    const endpoint = config.get('endpoint');
+    const resolvedEndpoint = resolveEndpoint();
+    const token = resolveToken();
+    const workspaceId = config.get('workspace_id');
+    const accountId = config.get('account_id');
+    const payload = {
+        endpoint: endpoint || null,
+        resolvedEndpoint,
+        token: maskToken(token),
+        tokenSet: Boolean(token),
+        workspace_id: workspaceId || null,
+        account_id: accountId || null,
+        configPath: CONFIG_PATH
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(chalk.cyan('Configuration'));
+    console.log(`Endpoint (configured): ${payload.endpoint || 'not set'}`);
+    console.log(`Endpoint (resolved):  ${payload.resolvedEndpoint}`);
+    console.log(`Token: ${payload.token || 'not set'}`);
+    console.log(`Workspace: ${payload.workspace_id || 'not set'}`);
+    console.log(`Account: ${payload.account_id || 'not set'}`);
+    if (shouldShowHints()) {
+        console.log(chalk.gray(`Config file: ${CONFIG_PATH}`));
+    }
+});
+
+configCommand
+    .command('set <key> <value>')
+    .description('Set a configuration value.')
+    .action((key, value) => {
+        config.set(key, value);
+        const message = key === 'token' ? `token set to ${maskToken(value)}` : `${key} set to ${value}`;
+        console.log(chalk.green(`✔ ${message}`));
+    });
+
+configCommand
+    .command('get <key>')
+    .description('Get a configuration value.')
+    .action((key) => {
+        const value = config.get(key);
+        if (value === null) {
+            console.log(chalk.yellow(`${key} is not set`));
+            return;
+        }
+        const output = key === 'token' ? maskToken(value) : value;
+        console.log(output);
+    });
+
+configCommand
+    .command('unset <key>')
+    .description('Remove a configuration value.')
+    .action((key) => {
+        const removed = config.unset(key);
+        if (!removed) {
+            console.log(chalk.yellow(`${key} was not set`));
+            return;
+        }
+        console.log(chalk.green(`✔ ${key} removed`));
+    });