@velaro/cli 1.2.0 → 1.4.8

package/lib/commands/teams-phone.js

@@ -0,0 +1,131 @@
+/**
+ * velaro teams-phone - Microsoft Teams Phone (SiteVoiceConfig ProviderSlug="teams") config CRUD
+ *
+ *   velaro teams-phone status                    Show current configuration
+ *   velaro teams-phone set --tenant-id ...        Create or update the configuration
+ *   velaro teams-phone remove                     Delete the configuration
+ *   velaro teams-phone test                       Test the Graph subscription connectivity
+ *
+ * Backend contract: server/Velaro.Messaging/Controllers/Voice/TeamsPhoneConfigController.cs
+ * (velaro-messaging). Site is resolved server-side from the auth context — never
+ * caller-supplied here or on the server.
+ *
+ * Live in-call actions (hold/resume/end/transfer, TeamsPhoneCtiController) are
+ * intentionally NOT exposed here — see mcp-cli-exempt comments on that controller.
+ */
+
+import { messagingGet, messagingPost, messagingPut, messagingDel } from '../api.js';
+
+const GRN  = '\x1b[32m';
+const RED  = '\x1b[31m';
+const YEL  = '\x1b[33m';
+const DIM  = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RST  = '\x1b[0m';
+
+function printConfig(c) {
+  if (!c?.configured) {
+    console.log(`\n${DIM}Teams Phone is not configured for this site.${RST}\n`);
+    return;
+  }
+  console.log(`\n${BOLD}Teams Phone configuration${RST}`);
+  console.log(`  Tenant ID:                       ${c.tenantId ?? '(none)'}`);
+  console.log(`  Application instance object ID:  ${c.applicationInstanceObjectId ?? '(none)'}`);
+  console.log(`  Assigned phone number:           ${c.assignedPhoneNumber ?? '(none)'}`);
+  console.log(`  Webhook secret configured:       ${c.webhookSecretConfigured ? `${GRN}yes${RST}` : `${DIM}no${RST}`}`);
+  const subColor = c.graphSubscriptionActive ? GRN : YEL;
+  console.log(`  Graph subscription active:       ${subColor}${c.graphSubscriptionActive}${RST}` +
+    (c.graphSubscriptionExpiresAt ? `  (expires ${c.graphSubscriptionExpiresAt})` : ''));
+  console.log('');
+}
+
+// -- status ------------------------------------------------------------------------
+
+async function statusHandler() {
+  const config = await messagingGet('/TeamsPhone/Config');
+  printConfig(config);
+}
+
+// -- set (create or update) ---------------------------------------------------------
+
+async function setHandler(argv) {
+  const existing = await messagingGet('/TeamsPhone/Config');
+  const body = {
+    tenantId: argv.tenantId,
+    applicationInstanceObjectId: argv.applicationInstanceObjectId,
+    assignedPhoneNumber: argv.assignedPhoneNumber,
+    webhookSecret: argv.webhookSecret,
+  };
+
+  if (!existing?.configured) {
+    if (!body.tenantId) throw new Error('--tenant-id is required to create a new Teams Phone configuration.');
+    const created = await messagingPost('/TeamsPhone/Config', body);
+    console.log(`\n${GRN}✓${RST} Teams Phone configuration created.`);
+    printConfig(created);
+    return;
+  }
+
+  const updated = await messagingPut('/TeamsPhone/Config', body);
+  console.log(`\n${GRN}✓${RST} Teams Phone configuration updated.`);
+  printConfig(updated);
+}
+
+// -- remove ---------------------------------------------------------------------------
+
+async function removeHandler() {
+  const result = await messagingDel('/TeamsPhone/Config');
+  console.log(`\n  ${GRN}✓${RST} ${result?.deleted ? 'Deleted.' : 'Delete request completed.'}\n`);
+}
+
+// -- test -------------------------------------------------------------------------
+
+async function testHandler() {
+  const result = await messagingPost('/TeamsPhone/Config/Test', {});
+  const color = result?.success ? GRN : RED;
+  console.log(`\n${color}${result?.success ? 'Success' : 'Failed'}${RST}: ${result?.message ?? '(no message)'}\n`);
+  if (!result?.success) process.exitCode = 1;
+}
+
+// -- command export ------------------------------------------------------------------
+
+export const teamsPhoneCommand = {
+  command:  'teams-phone <subcommand>',
+  describe: 'Microsoft Teams Phone integration configuration (config CRUD only — live call control is UI-only)',
+  builder: y => y
+    .command({
+      command:  'status',
+      describe: 'Show the Teams Phone configuration for this site',
+      builder:  yy => yy,
+      handler:  statusHandler,
+    })
+    .command({
+      command:  'set',
+      describe: 'Create or update the Teams Phone configuration (apply-if-present, partial update on existing config)',
+      builder: yy => yy
+        .option('tenant-id', { describe: 'Customer Microsoft 365 tenant ID (required on create)', type: 'string' })
+        .option('application-instance-object-id', { describe: 'Teams resource account (application instance) object ID. Pass "" to clear.', type: 'string' })
+        .option('assigned-phone-number', { describe: 'Phone number assigned to the resource account. Pass "" to clear.', type: 'string' })
+        .option('webhook-secret', { describe: 'Webhook secret. Omit to auto-generate on create or leave unchanged on update.', type: 'string' }),
+      handler: argv => setHandler({
+        tenantId: argv.tenantId,
+        applicationInstanceObjectId: argv.applicationInstanceObjectId,
+        assignedPhoneNumber: argv.assignedPhoneNumber,
+        webhookSecret: argv.webhookSecret,
+      }),
+    })
+    .command({
+      command:  'remove',
+      describe: 'Delete the Teams Phone configuration for this site',
+      builder:  yy => yy,
+      handler:  removeHandler,
+    })
+    .command({
+      command:  'test',
+      describe: 'Test the Teams Phone connection by creating/renewing the Graph /communications/calls subscription',
+      builder:  yy => yy,
+      handler:  testHandler,
+    })
+    .demandCommand(1, 'Specify a teams-phone subcommand.')
+    .strict(),
+  handler: () => {},
+};

package/lib/commands/teams.js

@@ -0,0 +1,106 @@
+import { request } from '../api.js';
+
+export const teamsCommand = {
+  command: 'teams <subcommand>',
+  describe: 'Send messages to Microsoft Teams channels',
+  builder: (yargs) =>
+    yargs
+      .command(
+        'notify [message]',
+        'Send a message to a Teams channel webhook',
+        (y) =>
+          y
+            .positional('message', { type: 'string', describe: 'Message to send' })
+            .option('title', { type: 'string', describe: 'Card title', alias: 't' })
+            .option('id', { type: 'number', describe: 'Webhook config ID (omit to list)', alias: 'i' }),
+        async (argv) => {
+          const webhooks = await request('GET', '/TeamsNotification');
+
+          if (!Array.isArray(webhooks) || !webhooks.length) {
+            console.log('No Teams webhooks configured. Go to Integrations → Microsoft Teams to add one.');
+            return;
+          }
+
+          if (!argv.id) {
+            console.log('Available Teams webhooks:');
+            for (const w of webhooks) {
+              console.log(`  [${w.id}] ${w.name}${w.isEnabled ? '' : ' (disabled)'}`);
+            }
+            console.log('\nRun with --id <number> to send a message.');
+            return;
+          }
+
+          const webhook = webhooks.find((w) => w.id === argv.id);
+          if (!webhook) { console.error(`No webhook with id ${argv.id}`); process.exit(1); }
+          if (!webhook.isEnabled) { console.error(`Webhook "${webhook.name}" is disabled.`); process.exit(1); }
+
+          const message = argv.message;
+          if (!message) { console.error('Message is required. Pass it as an argument: velaro teams notify "hello"'); process.exit(1); }
+
+          await request('POST', `/TeamsNotification/Send/${argv.id}`, {
+            message,
+            title: argv.title || null,
+          });
+          console.log(`✓ Sent to Teams webhook "${webhook.name}"`);
+        }
+      )
+      .command(
+        'list',
+        'List configured Teams webhooks',
+        () => {},
+        async () => {
+          const webhooks = await request('GET', '/TeamsNotification');
+          if (!Array.isArray(webhooks) || !webhooks.length) {
+            console.log('No Teams webhooks configured.');
+            return;
+          }
+          for (const w of webhooks) {
+            console.log(`[${w.id}] ${w.name} — ${w.isEnabled ? 'enabled' : 'disabled'}`);
+          }
+        }
+      )
+      .command(
+        'create <name> <webhookUrl>',
+        'Register a Teams incoming webhook (validated live before saving — see Integrations → Microsoft Teams for how to generate the URL in Teams)',
+        (y) =>
+          y
+            .positional('name', { type: 'string', describe: 'Label for this webhook, e.g. "ops-alerts"' })
+            .positional('webhookUrl', { type: 'string', describe: 'https://...logic.azure.com/... Workflows webhook URL' }),
+        async (argv) => {
+          const result = await request('POST', '/TeamsNotification', {
+            name: argv.name,
+            webhookUrl: argv.webhookUrl,
+            isEnabled: true,
+          });
+          console.log(`✓ Registered webhook "${result.name}" (id ${result.id}). Use: velaro teams notify-card --id ${result.id} ...`);
+        }
+      )
+      .command(
+        'notify-card',
+        'Send a rich Adaptive Card (title + fact fields + optional button) to a Teams webhook — for CI/QA/ops summaries',
+        (y) =>
+          y
+            .option('id', { type: 'number', describe: 'Webhook config ID (see: velaro teams list)', alias: 'i', demandOption: true })
+            .option('title', { type: 'string', describe: 'Card title', alias: 't', demandOption: true })
+            .option('fact', { type: 'array', describe: 'Repeatable "Label=Value" fact, e.g. --fact "Fixed=3" --fact "Commits=abc123"' })
+            .option('button-label', { type: 'string', describe: 'Optional action button label' })
+            .option('button-url', { type: 'string', describe: 'Optional action button URL (required if --button-label is set)' }),
+        async (argv) => {
+          const fields = (argv.fact || []).map((f) => {
+            const eq = f.indexOf('=');
+            if (eq < 0) { console.error(`--fact must be "Label=Value", got: ${f}`); process.exit(1); }
+            return { label: f.slice(0, eq), value: f.slice(eq + 1) };
+          });
+          const result = await request('POST', '/TeamsNotification/SendWorkflow', {
+            webhookId: argv.id,
+            title: argv.title,
+            fields,
+            ...(argv.buttonLabel ? { buttonLabel: argv.buttonLabel, buttonUrl: argv.buttonUrl } : {}),
+          });
+          if (result?.success) console.log('✓ Card sent to Teams.');
+          else { console.error(`Send failed: ${result?.message || 'unknown error'}`); process.exit(1); }
+        }
+      )
+      .demandCommand(1, 'Specify a subcommand: notify, notify-card, create, list'),
+  handler: () => {},
+};

package/lib/commands/telephony.js

@@ -0,0 +1,99 @@
+/**
+ * velaro telephony - Velaro Voice (white-label phone) provisioning
+ *
+ *   velaro telephony status         Show provisioning status for the site
+ *   velaro telephony provision      Provision (or re-confirm) a phone account
+ *   velaro telephony deprovision    Tear down the site's phone account
+ *
+ * Backend contract: server/Velaro.Messaging/Controllers/Voice/TelephonyProvisioningController.cs
+ * (velaro-messaging). Site is resolved server-side from the auth context — never
+ * caller-supplied here or on the server.
+ */
+
+import { messagingGet, messagingPost, messagingDel } from '../api.js';
+
+const GRN  = '\x1b[32m';
+const RED  = '\x1b[31m';
+const YEL  = '\x1b[33m';
+const DIM  = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RST  = '\x1b[0m';
+
+function printStatus(record) {
+  const provisioned = !!record?.provisioned;
+  const statusColor = provisioned ? GRN : record?.status === 'Failed' ? RED : YEL;
+  console.log(`\n${BOLD}Velaro Voice provisioning${RST}`);
+  console.log(`  Provisioned:  ${provisioned ? `${GRN}yes${RST}` : `${DIM}no${RST}`}`);
+  console.log(`  Status:       ${statusColor}${record?.status ?? '?'}${RST}`);
+  if (record?.providerSlug)        console.log(`  Provider:     ${record.providerSlug}`);
+  if (record?.externalAccountId)   console.log(`  Account ID:   ${record.externalAccountId}`);
+  if (record?.externalExtensionId) console.log(`  Extension ID: ${record.externalExtensionId}`);
+  if (record?.provisionedNumber)   console.log(`  Number:       ${record.provisionedNumber}`);
+  if (record?.errorMessage)        console.log(`  ${RED}Error:        ${record.errorMessage}${RST}`);
+  console.log('');
+}
+
+// -- status ------------------------------------------------------------------------
+
+async function statusHandler() {
+  const record = await messagingGet('/TelephonyProvisioning');
+  printStatus(record);
+}
+
+// -- provision ----------------------------------------------------------------------
+
+async function provisionHandler(argv) {
+  const body = {
+    siteName:           argv.siteName,
+    contactEmail:        argv.contactEmail,
+    areaCodePreference:  argv.areaCode,
+    extensionNumber:     argv.extension,
+  };
+  const record = await messagingPost('/TelephonyProvisioning', body);
+  printStatus(record);
+}
+
+// -- deprovision ----------------------------------------------------------------------
+
+async function deprovisionHandler() {
+  const record = await messagingDel('/TelephonyProvisioning');
+  console.log(`\n  ${GRN}✓${RST} Deprovisioned. Status: ${record?.status ?? 'Deprovisioned'}\n`);
+}
+
+// -- command export ------------------------------------------------------------------
+
+export const telephonyCommand = {
+  command:  'telephony <subcommand>',
+  describe: 'Velaro Voice (white-label phone) provisioning',
+  builder: y => y
+    .command({
+      command:  'status',
+      describe: 'Show Velaro Voice provisioning status for the site',
+      builder:  yy => yy,
+      handler:  statusHandler,
+    })
+    .command({
+      command:  'provision',
+      describe: 'Provision (or idempotently re-confirm) a Velaro Voice phone account for the site',
+      builder: yy => yy
+        .option('site-name',  { describe: 'Display name for the account (default: "site-{id}")', type: 'string' })
+        .option('contact-email', { describe: 'Contact email for the carrier account', type: 'string' })
+        .option('area-code',  { describe: 'Preferred area code, e.g. "805"', type: 'string' })
+        .option('extension',  { describe: 'Extension number to provision alongside the account', type: 'number' }),
+      handler: argv => provisionHandler({
+        siteName: argv.siteName,
+        contactEmail: argv.contactEmail,
+        areaCode: argv.areaCode,
+        extension: argv.extension,
+      }),
+    })
+    .command({
+      command:  'deprovision',
+      describe: 'Deprovision the site\'s Velaro Voice phone account and release its number',
+      builder:  yy => yy,
+      handler:  deprovisionHandler,
+    })
+    .demandCommand(1, 'Specify a telephony subcommand.')
+    .strict(),
+  handler: () => {},
+};

package/lib/commands/update.js

@@ -1,47 +1,47 @@
-import { execSync }    from 'child_process';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-const { version: currentVersion } = require('../../package.json');
-
-const NPM_REGISTRY = 'https://registry.npmjs.org/@velaro/cli/latest';
-
-export const updateCommand = {
-  command:  'update',
-  describe: 'Update the Velaro CLI to the latest version',
-  handler:  async () => {
-    process.stdout.write('Checking for updates... ');
-
-    let latest;
-    try {
-      const res = await fetch(NPM_REGISTRY, { signal: AbortSignal.timeout(8000) });
-      const data = await res.json();
-      latest = data?.version;
-    } catch {
-      console.error('Could not reach npm registry. Check your connection and try again.');
-      process.exit(1);
-    }
-
-    if (!latest) {
-      console.error('Could not determine the latest version.');
-      process.exit(1);
-    }
-
-    if (latest === currentVersion) {
-      console.log(`already up to date (${currentVersion}).`);
-      return;
-    }
-
-    console.log(`${currentVersion} → ${latest}`);
-    console.log('Running: npm install -g @velaro/cli@latest\n');
-
-    try {
-      execSync('npm install -g @velaro/cli@latest', { stdio: 'inherit' });
-      console.log('\nUpdated successfully. Run velaro --version to confirm.');
-    } catch {
-      console.error('\nUpdate failed. Try running manually:');
-      console.error('  npm install -g @velaro/cli@latest');
-      process.exit(1);
-    }
-  },
-};
+import { execSync }    from 'child_process';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { version: currentVersion } = require('../../package.json');
+
+const NPM_REGISTRY = 'https://registry.npmjs.org/@velaro/cli/latest';
+
+export const updateCommand = {
+  command:  'update',
+  describe: 'Update the Velaro CLI to the latest version',
+  handler:  async () => {
+    process.stdout.write('Checking for updates... ');
+
+    let latest;
+    try {
+      const res = await fetch(NPM_REGISTRY, { signal: AbortSignal.timeout(8000) });
+      const data = await res.json();
+      latest = data?.version;
+    } catch {
+      console.error('Could not reach npm registry. Check your connection and try again.');
+      process.exit(1);
+    }
+
+    if (!latest) {
+      console.error('Could not determine the latest version.');
+      process.exit(1);
+    }
+
+    if (latest === currentVersion) {
+      console.log(`already up to date (${currentVersion}).`);
+      return;
+    }
+
+    console.log(`${currentVersion} → ${latest}`);
+    console.log('Running: npm install -g @velaro/cli@latest\n');
+
+    try {
+      execSync('npm install -g @velaro/cli@latest', { stdio: 'inherit' });
+      console.log('\nUpdated successfully. Run velaro --version to confirm.');
+    } catch {
+      console.error('\nUpdate failed. Try running manually:');
+      console.error('  npm install -g @velaro/cli@latest');
+      process.exit(1);
+    }
+  },
+};

package/lib/commands/webflow.js

@@ -0,0 +1,128 @@
+/**
+ * velaro webflow - Webflow config CRUD (WebflowController.cs, this repo/admin API)
+ *
+ *   velaro webflow status                 List connected Webflow sites for this account
+ *   velaro webflow set <id> --enabled     Update an existing connection (partial update)
+ *   velaro webflow remove <id>            Disconnect a Webflow site
+ *   velaro webflow test <id>              Test connectivity (live Webflow /v2/sites call)
+ *
+ * Backend contract: server/Velaro.Admin/Controllers/WebflowController.cs (this repo). Site is
+ * resolved server-side from GetSiteIdAsync() — never caller-supplied here or on the server.
+ *
+ * There is no "create" subcommand — a new Webflow connection is only created via the OAuth
+ * Connect flow in the admin UI (Webflow needs a real browser redirect to Webflow's own consent
+ * screen); this CLI only manages connections that already exist.
+ */
+
+import { get, post, put, del } from '../api.js';
+
+const GRN  = '\x1b[32m';
+const RED  = '\x1b[31m';
+const DIM  = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RST  = '\x1b[0m';
+
+function printConfig(c) {
+  console.log(`\n${BOLD}[${c.id}] ${c.webflowSiteName || c.displayName}${RST}`);
+  console.log(`  Webflow site ID:          ${c.webflowSiteId ?? '(none)'}`);
+  console.log(`  Webflow workspace ID:     ${c.webflowWorkspaceId ?? '(none)'}`);
+  console.log(`  Widget injected:          ${c.scriptRegistered ? `${GRN}yes${RST}` : `${DIM}no${RST}`}`);
+  console.log(`  Push form submissions:    ${c.pushFormSubmissions ? 'yes' : 'no'}`);
+  console.log(`  Enabled:                  ${c.enabled ? `${GRN}yes${RST}` : `${DIM}no${RST}`}`);
+  console.log(`  Defer widget load:        ${c.deferWidgetLoadSeconds ? `${c.deferWidgetLoadSeconds}s` : `${DIM}off (immediate)${RST}`}`);
+  console.log(`  Require cookie consent:   ${c.requireCookieConsent ? 'yes' : 'no'}`);
+  console.log('');
+}
+
+// -- status ------------------------------------------------------------------------
+
+async function statusHandler() {
+  const configs = await get('/Webflow/Configs');
+  if (!Array.isArray(configs) || configs.length === 0) {
+    console.log(`\n${DIM}No Webflow sites connected for this account.${RST}\n`);
+    return;
+  }
+  configs.forEach(printConfig);
+}
+
+// -- set (update only) ---------------------------------------------------------------
+
+async function setHandler(argv) {
+  if (!argv.id) throw new Error('Provide the Webflow config ID: velaro webflow set <id> [options]');
+  const body = {};
+  if (argv.displayName !== undefined) body.displayName = argv.displayName;
+  if (argv.enabled !== undefined) body.enabled = argv.enabled;
+  if (argv.pushFormSubmissions !== undefined) body.pushFormSubmissions = argv.pushFormSubmissions;
+  if (argv.deferWidgetLoadSeconds !== undefined) body.deferWidgetLoadSeconds = argv.deferWidgetLoadSeconds;
+  if (argv.requireCookieConsent !== undefined) body.requireCookieConsent = argv.requireCookieConsent;
+
+  const updated = await put(`/Webflow/Configs/${argv.id}`, body);
+  console.log(`\n${GRN}✓${RST} Webflow configuration updated.`);
+  printConfig(updated);
+}
+
+// -- remove ---------------------------------------------------------------------------
+
+async function removeHandler(argv) {
+  if (!argv.id) throw new Error('Provide the Webflow config ID: velaro webflow remove <id>');
+  await del(`/Webflow/Configs/${argv.id}`);
+  console.log(`\n  ${GRN}✓${RST} Disconnected. Note: this does not remove the widget already injected on the live Webflow site — use "inject-widget"/"remove-widget" endpoints or the admin UI for that.\n`);
+}
+
+// -- test -------------------------------------------------------------------------
+
+async function testHandler(argv) {
+  if (!argv.id) throw new Error('Provide the Webflow config ID: velaro webflow test <id>');
+  const result = await get(`/Webflow/Configs/${argv.id}/TestConnection`);
+  const color = result?.success ? GRN : RED;
+  console.log(`\n${color}${result?.success ? 'Success' : 'Failed'}${RST}: ${result?.message ?? '(no message)'}\n`);
+  if (!result?.success) process.exitCode = 1;
+}
+
+// -- command export ------------------------------------------------------------------
+
+export const webflowCommand = {
+  command:  'webflow <subcommand>',
+  describe: 'Webflow integration configuration (config CRUD + connection test — new connections are OAuth/browser-only via the admin UI)',
+  builder: y => y
+    .command({
+      command:  'status',
+      describe: 'List all Webflow site connections for this account',
+      builder:  yy => yy,
+      handler:  statusHandler,
+    })
+    .command({
+      command:  'set <id>',
+      describe: 'Update an existing Webflow connection (apply-if-present, partial update)',
+      builder: yy => yy
+        .positional('id', { describe: 'Webflow config ID', type: 'number' })
+        .option('display-name', { describe: 'Display name for this connection', type: 'string' })
+        .option('enabled', { describe: 'Enable/disable this connection', type: 'boolean' })
+        .option('push-form-submissions', { describe: 'Push Webflow form submissions into Velaro', type: 'boolean' })
+        .option('defer-widget-load-seconds', { describe: 'Delay widget init by N seconds or until first interaction, whichever first. 0 = load immediately (default).', type: 'number' })
+        .option('require-cookie-consent', { describe: 'Wait for a window "consent-granted" event before initializing the widget', type: 'boolean' }),
+      handler: argv => setHandler({
+        id: argv.id,
+        displayName: argv.displayName,
+        enabled: argv.enabled,
+        pushFormSubmissions: argv.pushFormSubmissions,
+        deferWidgetLoadSeconds: argv.deferWidgetLoadSeconds,
+        requireCookieConsent: argv.requireCookieConsent,
+      }),
+    })
+    .command({
+      command:  'remove <id>',
+      describe: 'Disconnect a Webflow site (does not remove the already-injected widget)',
+      builder:  yy => yy.positional('id', { describe: 'Webflow config ID', type: 'number' }),
+      handler:  removeHandler,
+    })
+    .command({
+      command:  'test <id>',
+      describe: 'Test the Webflow connection with a live /v2/sites call',
+      builder:  yy => yy.positional('id', { describe: 'Webflow config ID', type: 'number' }),
+      handler:  testHandler,
+    })
+    .demandCommand(1, 'Specify a webflow subcommand.')
+    .strict(),
+  handler: () => {},
+};

package/lib/commands/whoami.js

@@ -1,22 +1,25 @@
-import { readConfig } from '../config.js';
-
-export const whoamiCommand = {
-  command:  'whoami',
-  describe: 'Show current login and site info',
-  handler:  () => {
-    const cfg = readConfig();
-
-    if (!cfg?.velaroToken) {
-      console.error('Not logged in. Run: velaro login');
-      process.exit(1);
-    }
-
-    const expires = new Date(cfg.velaroExpires);
-    const minLeft = Math.round((expires - Date.now()) / 60000);
-
-    console.log(`User:    ${cfg.userName ?? '(unknown)'}`);
-    console.log(`Site ID: ${cfg.siteId   ?? '(unknown)'}`);
-    console.log(`API:     ${cfg.apiBase}`);
-    console.log(`Token:   ${expires > new Date() ? `valid (expires in ${minLeft}m)` : 'EXPIRED — run velaro login'}`);
-  },
-};
+import { readConfig } from '../config.js';
+
+export const whoamiCommand = {
+  command:  'whoami',
+  describe: 'Show current login and site info',
+  handler:  () => {
+    const cfg  = readConfig();
+    const env  = cfg.activeEnv || 'prod';
+    const creds = cfg.envs?.[env];
+
+    if (!creds?.velaroToken) {
+      console.error(`Not logged in to ${env}. Run: velaro login${env === 'staging' ? ' --staging' : ''}`);
+      process.exit(1);
+    }
+
+    const expires = new Date(creds.velaroExpires);
+    const minLeft = Math.round((expires - Date.now()) / 60000);
+
+    console.log(`Env:     ${env}`);
+    console.log(`User:    ${creds.userName ?? '(unknown)'}`);
+    console.log(`Site ID: ${creds.siteId   ?? '(unknown)'}`);
+    console.log(`API:     ${creds.adminApiBase}`);
+    console.log(`Token:   ${expires > new Date() ? `valid (expires in ${minLeft}m)` : 'EXPIRED (refresh token will be used on next command)'}`);
+  },
+};