@velaro/cli 0.3.0 → 0.5.0

package/bin/velaro.js

@@ -3,6 +3,7 @@
 import yargs                                    from 'yargs';
 import { hideBin }                              from 'yargs/helpers';
 import { loginCommand, logoutCommand }          from '../lib/commands/login.js';
+import { envCommand }                           from '../lib/commands/env.js';
 import { whoamiCommand }                        from '../lib/commands/whoami.js';
 import { teamCommand }                          from '../lib/commands/team.js';
 import { botCommand }                           from '../lib/commands/bot.js';
@@ -28,6 +29,7 @@ await yargs(hideBin(process.argv))
   .command(loginCommand)
   .command(logoutCommand)
   .command(whoamiCommand)
+  .command(envCommand)
   // Info
   .command(siteCommand)
   .command(checkCommand)

package/lib/api.js

@@ -1,30 +1,34 @@
-import { readConfig, writeConfig } from './config.js';
-import { refreshVelaroToken }       from './oauth.js';
+import { readConfig, writeConfig, getActiveEnv, setEnvCredentials, ENVS } from './config.js';
+import { refreshVelaroToken } from './oauth.js';
 
 const REFRESH_BUFFER_MS = 5 * 60 * 1000;
 
-export async function getCredentials() {
-  let creds = readConfig();
+export async function getCredentials(envOverride) {
+  const cfg = readConfig();
+  const env = envOverride || cfg.activeEnv || 'prod';
+  let creds = cfg.envs?.[env];
 
   if (!creds?.velaroToken) {
-    throw new Error('Not logged in. Run: velaro login');
+    throw new Error(`Not logged in to ${env}. Run: velaro login${env === 'staging' ? ' --staging' : ''}`);
   }
 
   if (Date.now() + REFRESH_BUFFER_MS >= new Date(creds.velaroExpires).getTime()) {
     if (!creds.entraRefreshToken) {
-      throw new Error('Session expired. Run: velaro login');
+      throw new Error(`Session expired for ${env}. Run: velaro login${env === 'staging' ? ' --staging' : ''}`);
     }
-    creds = await refreshVelaroToken(creds);
-    writeConfig(creds);
+    const refreshed = await refreshVelaroToken({ ...creds, apiBase: creds.adminApiBase });
+    const updated = { ...creds, ...refreshed };
+    setEnvCredentials(env, updated);
+    creds = updated;
   }
 
-  return creds;
+  return { ...creds, env };
 }
 
-export async function request(method, path, body) {
-  const creds = await getCredentials();
+export async function request(method, path, body, envOverride) {
+  const creds = await getCredentials(envOverride);
 
-  const res = await fetch(`${creds.apiBase}${path}`, {
+  const res = await fetch(`${creds.adminApiBase}${path}`, {
     method,
     headers: {
       Authorization:  `Bearer ${creds.velaroToken}`,
@@ -35,7 +39,7 @@ export async function request(method, path, body) {
 
   if (!res.ok) {
     let msg = `${method} ${path} → ${res.status}`;
-    try { const t = await res.text(); if (t) msg += `: ${t}`; } catch { /* body unreadable — status already captured */ }
+    try { const t = await res.text(); if (t) msg += `: ${t}`; } catch { /* status already captured */ }
     throw new Error(msg);
   }
 

package/lib/commands/env.js

@@ -0,0 +1,45 @@
+import { readConfig, setActiveEnv, getActiveEnv, ENVS } from '../config.js';
+import { runCommand } from '../run.js';
+
+export const envCommand = {
+  command:  'env [name]',
+  describe: 'Show or switch the active environment (prod/staging)',
+  builder:  (y) =>
+    y.positional('name', {
+      describe: 'Environment to switch to: prod or staging',
+      type:     'string',
+      choices:  ['prod', 'staging'],
+    }),
+
+  handler: runCommand(async (argv) => {
+    if (argv.name) {
+      setActiveEnv(argv.name);
+      console.log(`Switched to ${argv.name}.`);
+      console.log(`All velaro commands now target: ${ENVS[argv.name].adminApiBase}`);
+      return;
+    }
+
+    // Show status of all environments
+    const cfg    = readConfig();
+    const active = cfg.activeEnv || 'prod';
+    const envs   = cfg.envs || {};
+
+    console.log('Velaro environments:\n');
+    for (const [name, urls] of Object.entries(ENVS)) {
+      const creds   = envs[name];
+      const marker  = name === active ? '▶ ' : '  ';
+      const status  = creds?.velaroToken
+        ? `logged in as ${creds.userName ?? 'unknown'} (site ${creds.siteId})`
+        : 'not logged in';
+      const expiry  = creds?.velaroExpires
+        ? new Date(creds.velaroExpires) > new Date() ? '' : '  ⚠ token expired'
+        : '';
+      console.log(`${marker}${name.padEnd(10)} ${status}${expiry}`);
+      console.log(`          ${urls.adminApiBase}`);
+    }
+
+    console.log(`\nActive: ${active}`);
+    console.log('\nTo switch:  velaro env staging  |  velaro env prod');
+    console.log('To log in:  velaro login         |  velaro login --staging');
+  }),
+};

package/lib/commands/kb.js

@@ -14,10 +14,55 @@ export const kbCommand = {
       .command(qnaCommand)
       .command(overrideCommand)
       .command(contentCommand)
-      .demandCommand(1, 'Specify a subcommand: article, qna, override, content'),
+      .command(reindexCommand)
+      .demandCommand(1, 'Specify a subcommand: article, qna, override, content, reindex'),
   handler: () => {},
 };
 
+// ────────────────────────────────────────────────────────────────────────────
+// Reindex — re-embed all KB articles with the current embedding model
+// ────────────────────────────────────────────────────────────────────────────
+
+const reindexCommand = {
+  command:  'reindex',
+  describe: 'Re-embed all KB articles into the vector index (use after embedding model upgrade)',
+  builder:  (y) =>
+    y
+      .option('all', {
+        type:     'boolean',
+        describe: 'Reindex ALL sites (Velaro staff only)',
+        default:  false,
+      })
+      .option('site', {
+        type:     'number',
+        describe: 'Reindex a specific site by ID (Velaro staff only)',
+      }),
+  handler: runCommand(async (argv) => {
+    if (argv.all) {
+      console.log('Starting bulk reindex for all sites — this runs in the background.');
+      console.log('Watch server logs ([ReindexAllKb]) for progress.\n');
+      const result = await post('/DatabaseTool/ReindexAllKb', {});
+      console.log(result.message ?? 'Queued.');
+    } else if (argv.site) {
+      console.log(`Reindexing site ${argv.site}…`);
+      const result = await post(`/DatabaseTool/ReindexKb/${argv.site}`, {});
+      if (result.success) {
+        console.log(`✅ Done — ${result.articles} articles reindexed.`);
+      } else {
+        console.error(`❌ Failed: ${result.message}`);
+      }
+    } else {
+      console.log("Reindexing your site's KB articles\u2026");
+      const result = await post('/KBSearchIndex/reindex', {});
+      if (result.success === false) {
+        console.error(`❌ Failed: ${result.message}`);
+      } else {
+        console.log(`✅ Done — ${result.articles ?? result.count ?? 'all'} articles reindexed.`);
+      }
+    }
+  }),
+};
+
 // ────────────────────────────────────────────────────────────────────────────
 // Q&A
 // ────────────────────────────────────────────────────────────────────────────

package/lib/commands/login.js

@@ -1,60 +1,86 @@
-import { requestDeviceCode, pollForToken, exchangeForVelaroToken } from '../oauth.js';
-import { readConfig, writeConfig, DEFAULT_API_BASE, STAGING_API_BASE } from '../config.js';
-import { runCommand }                                               from '../run.js';
-
-export const loginCommand = {
-  command:  'login',
-  describe: 'Authenticate with Velaro using your browser',
-  builder:  (y) =>
-    y
-      .option('staging', {
-        describe: 'Connect to the Velaro staging environment',
-        type:     'boolean',
-        default:  false,
-      })
-      .option('api', {
-        describe: 'Override the Velaro API base URL. Set VELARO_API_BASE env var to make it permanent. ' +
-                  'Production cutover: set this to your production API URL before going live.',
-        type:     'string',
-      }),
-
-  handler: runCommand(async (argv) => {
-    const apiBase = argv.api ?? (argv.staging ? STAGING_API_BASE : DEFAULT_API_BASE);
-
-    console.log('Starting Velaro login...\n');
-
-    const deviceData = await requestDeviceCode();
-
-    console.log(`  Open:  ${deviceData.verification_uri}`);
-    console.log(`  Enter: ${deviceData.user_code}\n`);
-    console.log('Waiting for you to complete login in your browser...');
-
-    const entraTokens  = await pollForToken(deviceData.device_code, deviceData.interval ?? 5);
-    const velaroResult = await exchangeForVelaroToken(entraTokens.access_token, apiBase);
-
-    writeConfig({
-      ...readConfig(),
-      apiBase,
-      velaroToken:       velaroResult.token.token,
-      velaroExpires:     velaroResult.token.expires,
-      entraRefreshToken: entraTokens.refresh_token,
-      siteId:            velaroResult.profile?.SiteId,
-      userName:          velaroResult.profile?.Name,
-    });
-
-    const envLabel = argv.staging || argv.api ? ` (${apiBase})` : '';
-    console.log(`\nLogged in as ${velaroResult.profile?.Name ?? velaroResult.profile?.UserName}${envLabel}`);
-    console.log(`Site ID: ${velaroResult.profile?.SiteId}`);
-    console.log('Credentials saved to ~/.velaro/config.json');
-  }),
-};
-
-export const logoutCommand = {
-  command:  'logout',
-  describe: 'Clear stored credentials',
-  handler:  runCommand(async () => {
-    const { clearConfig } = await import('../config.js');
-    clearConfig();
-    console.log('Logged out. Credentials removed from ~/.velaro/config.json');
-  }),
-};
+import { requestDeviceCode, pollForToken, exchangeForVelaroToken } from '../oauth.js';
+import { readConfig, writeConfig, setEnvCredentials, getActiveEnv, ENVS } from '../config.js';
+import { runCommand } from '../run.js';
+
+export const loginCommand = {
+  command:  'login',
+  describe: 'Authenticate with Velaro (saves credentials for the chosen environment)',
+  builder:  (y) =>
+    y
+      .option('staging', {
+        describe: 'Log in to the staging environment',
+        type:     'boolean',
+        default:  false,
+      })
+      .option('api', {
+        describe: 'Override the admin API base URL (advanced)',
+        type:     'string',
+      }),
+
+  handler: runCommand(async (argv) => {
+    const env = argv.staging || argv.api?.includes('staging') ? 'staging' : 'prod';
+    const adminApiBase = argv.api || ENVS[env].adminApiBase;
+
+    console.log(`Starting Velaro login (${env})...\n`);
+
+    const deviceData = await requestDeviceCode();
+
+    console.log(`  Open:  ${deviceData.verification_uri}`);
+    console.log(`  Enter: ${deviceData.user_code}\n`);
+    console.log('Waiting for you to complete login in your browser...');
+
+    const entraTokens  = await pollForToken(deviceData.device_code, deviceData.interval ?? 5);
+    const velaroResult = await exchangeForVelaroToken(entraTokens.access_token, adminApiBase);
+
+    setEnvCredentials(env, {
+      adminApiBase,
+      velaroToken:       velaroResult.token.token,
+      velaroExpires:     velaroResult.token.expires,
+      entraRefreshToken: entraTokens.refresh_token,
+      siteId:            velaroResult.profile?.SiteId,
+      userName:          velaroResult.profile?.Name,
+    });
+
+    // Set as active if it's the only env logged in, or if explicitly chosen
+    const cfg = readConfig();
+    if (!cfg.activeEnv || Object.keys(cfg.envs || {}).length === 1) {
+      cfg.activeEnv = env;
+      writeConfig(cfg);
+    }
+
+    console.log(`\n✅ Logged in to ${env} as ${velaroResult.profile?.Name ?? velaroResult.profile?.UserName}`);
+    console.log(`   Site ID: ${velaroResult.profile?.SiteId}`);
+    console.log(`   API: ${adminApiBase}`);
+    console.log('\nCredentials saved. Run "velaro env" to see all environments.');
+  }),
+};
+
+export const logoutCommand = {
+  command:  'logout',
+  describe: 'Clear stored credentials',
+  builder:  (y) =>
+    y.option('staging', { describe: 'Log out of staging only', type: 'boolean', default: false })
+     .option('all',     { describe: 'Log out of all environments', type: 'boolean', default: false }),
+
+  handler: runCommand(async (argv) => {
+    const { readConfig, writeConfig, clearConfig } = await import('../config.js');
+    if (argv.all) {
+      clearConfig();
+      console.log('Logged out of all environments.');
+      return;
+    }
+    const env = argv.staging ? 'staging' : getActiveEnv();
+    const cfg = readConfig();
+    if (cfg.envs?.[env]) {
+      delete cfg.envs[env];
+      if (cfg.activeEnv === env) {
+        const remaining = Object.keys(cfg.envs || {});
+        cfg.activeEnv = remaining[0] || 'prod';
+      }
+      writeConfig(cfg);
+      console.log(`Logged out of ${env}.`);
+    } else {
+      console.log(`Not logged in to ${env}.`);
+    }
+  }),
+};

package/lib/commands/mcp-key.js

@@ -1,4 +1,8 @@
+import fs   from 'fs';
+import path from 'path';
+import os   from 'os';
 import { get, post, del } from '../api.js';
+import { getActiveEnv, ENVS } from '../config.js';
 import { runCommand }      from '../run.js';
 
 export const mcpKeyCommand = {
@@ -10,7 +14,8 @@ export const mcpKeyCommand = {
       .command(mcpKeyCreateCommand)
       .command(mcpKeyRevokeCommand)
       .command(mcpKeyRotateCommand)
-      .demandCommand(1, 'Specify a subcommand: list, create, revoke, rotate'),
+      .command(mcpKeyInstallCommand)
+      .demandCommand(1, 'Specify a subcommand: list, create, revoke, rotate, install'),
   handler: () => {},
 };
 
@@ -64,6 +69,60 @@ const mcpKeyRevokeCommand = {
   }),
 };
 
+const mcpKeyInstallCommand = {
+  command:  'install',
+  describe: 'Create an MCP key and write it to ~/.claude/settings.json automatically',
+  builder:  (y) =>
+    y
+      .option('label', {
+        describe: 'Label for the key',
+        type:     'string',
+      })
+      .option('staging', {
+        describe: 'Install key for the staging environment',
+        type:     'boolean',
+        default:  false,
+      }),
+
+  handler: runCommand(async (argv) => {
+    const env     = argv.staging ? 'staging' : getActiveEnv();
+    const apiBase = ENVS[env].adminApiBase;
+    const label   = argv.label || (env === 'staging' ? 'Claude Code (Staging)' : 'Claude Code');
+
+    const payload = { label };
+    const result  = await post('/McpApiKeys', payload);
+    const rawKey  = result.rawKey;
+
+    // Write to ~/.claude/settings.json
+    // prod  → entry named "velaro"
+    // staging → entry named "velaro-staging"
+    const serverName  = env === 'prod' ? 'velaro' : `velaro-${env}`;
+    const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch {}
+    }
+
+    settings.mcpServers = settings.mcpServers || {};
+    settings.mcpServers[serverName] = {
+      command: 'npx',
+      args:    ['-y', '@velaro/mcp-server'],
+      env:     {
+        VELARO_MCP_KEY:   rawKey,
+        VELARO_ADMIN_API: apiBase,
+      },
+    };
+
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+    console.log(`✅ MCP key created: ${label}  (${result.keyPrefix}...)`);
+    console.log(`✅ Written to settings.json as "${serverName}" → ${apiBase}`);
+    console.log(`\nRestart Claude Code to pick up the new MCP server.`);
+    console.log(`\nTo use in Claude Code: say "use ${serverName}" to target ${env}.`);
+  }),
+};
+
 const mcpKeyRotateCommand = {
   command:  'rotate <id>',
   describe: 'Revoke an existing key and issue a replacement in one step',

package/lib/commands/status.js

@@ -1,10 +1,12 @@
-import { readConfig, DEFAULT_API_BASE } from '../config.js';
+import { readConfig, getActiveEnv, ENVS } from '../config.js';
 
 export const statusCommand = {
   command:  'status',
   describe: 'Check Velaro API health',
   handler:  async () => {
-    const apiBase = readConfig()?.apiBase ?? DEFAULT_API_BASE;
+    const cfg     = readConfig();
+    const env     = getActiveEnv();
+    const apiBase = cfg.envs?.[env]?.adminApiBase ?? ENVS[env].adminApiBase;
     process.stdout.write(`Checking ${apiBase}/Status ... `);
     try {
       const res = await fetch(`${apiBase}/Status`);

package/lib/config.js

@@ -1,28 +1,83 @@
-import { homedir } from 'os';
-import { join }    from 'path';
-import { readFileSync, writeFileSync, mkdirSync } from 'fs';
-
-const CONFIG_DIR  = join(homedir(), '.velaro');
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-
-// Production API URL — update when production messaging API is deployed.
-// messaging.velaro.com is the chat widget host (Azure SWA), not the API.
-export const DEFAULT_API_BASE  = process.env.VELARO_API_BASE   || 'https://velaro-messaging-api-staging.azurewebsites.net';
-export const STAGING_API_BASE  = process.env.VELARO_STAGING_API || 'https://velaro-messaging-api-staging.azurewebsites.net';
-
-export function readConfig() {
-  try {
-    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
-  } catch {
-    return {};
-  }
-}
-
-export function writeConfig(data) {
-  mkdirSync(CONFIG_DIR, { recursive: true }); // no-op if already exists
-  writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
-}
-
-export function clearConfig() {
-  writeConfig({});
-}
+import { homedir } from 'os';
+import { join }    from 'path';
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+
+const CONFIG_DIR  = join(homedir(), '.velaro');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export const ENVS = {
+  prod: {
+    adminApiBase:     'https://api-admin-us-east.velaro.com',
+    messagingApiBase: 'https://velaro-messaging-api-staging.azurewebsites.net',
+  },
+  staging: {
+    adminApiBase:     'https://velaro-admin-staging.azurewebsites.net',
+    messagingApiBase: 'https://velaro-messaging-api-staging.azurewebsites.net',
+  },
+};
+
+// Legacy single-entry config — migrate transparently on first read.
+function migrate(raw) {
+  if (raw.envs) return raw; // already multi-env
+  const apiBase = raw.apiBase || '';
+  const env = apiBase.includes('staging') ? 'staging' : 'prod';
+  return {
+    activeEnv: env,
+    envs: {
+      [env]: {
+        adminApiBase:      ENVS[env].adminApiBase,
+        messagingApiBase:  ENVS[env].messagingApiBase,
+        velaroToken:       raw.velaroToken,
+        velaroExpires:     raw.velaroExpires,
+        entraRefreshToken: raw.entraRefreshToken,
+        siteId:            raw.siteId,
+        userName:          raw.userName,
+      },
+    },
+    _lastUpdateCheck: raw._lastUpdateCheck,
+    _latestVersion:   raw._latestVersion,
+  };
+}
+
+export function readConfig() {
+  try {
+    const raw = JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+    return migrate(raw);
+  } catch {
+    return { activeEnv: 'prod', envs: {} };
+  }
+}
+
+export function writeConfig(data) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+export function getActiveEnv() {
+  return readConfig().activeEnv || 'prod';
+}
+
+export function setActiveEnv(env) {
+  if (!ENVS[env]) throw new Error(`Unknown environment "${env}". Use: prod, staging`);
+  const cfg = readConfig();
+  cfg.activeEnv = env;
+  writeConfig(cfg);
+}
+
+export function getEnvCredentials(env) {
+  const cfg = readConfig();
+  return cfg.envs?.[env] || null;
+}
+
+export function setEnvCredentials(env, creds) {
+  if (!ENVS[env]) throw new Error(`Unknown environment "${env}". Use: prod, staging`);
+  const cfg = readConfig();
+  cfg.envs = cfg.envs || {};
+  cfg.envs[env] = { ...ENVS[env], ...creds };
+  cfg.activeEnv = cfg.activeEnv || env;
+  writeConfig(cfg);
+}
+
+export function clearConfig() {
+  writeConfig({ activeEnv: 'prod', envs: {} });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velaro/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Velaro Workspace v20 — command-line interface for managing bots, knowledge base ingestion, and MCP API keys.",
   "type": "module",
   "bin": {