@velaro/cli 0.4.0 → 0.7.0

package/lib/commands/index.js

@@ -0,0 +1,212 @@
+import { get, post, getCredentials } from '../api.js';
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function isVelaroAdmin(creds) {
+  return creds.siteId === 1032;
+}
+
+function mb(n) {
+  if (n >= 1024) return `${(n / 1024).toFixed(1)} GB`;
+  return `${n} MB`;
+}
+
+function bar(used, total, width = 20) {
+  if (!total) return '[          ] n/a';
+  const pct = Math.min(used / total, 1);
+  const filled = Math.round(pct * width);
+  const color = pct >= 0.9 ? '\x1b[31m' : pct >= 0.7 ? '\x1b[33m' : '\x1b[32m';
+  return `${color}[${'█'.repeat(filled)}${' '.repeat(width - filled)}]\x1b[0m ${(pct * 100).toFixed(0)}%`;
+}
+
+// ── list ─────────────────────────────────────────────────────────────────────
+
+const listCommand = {
+  command:  'list',
+  describe: 'List indexes. Velaro admins see all physical indexes; customers see their virtual indexes + quota.',
+  builder:  (y) =>
+    y.option('site', { type: 'number', describe: 'Site ID (Velaro staff only)' }),
+  handler: async (argv) => {
+    const creds = await getCredentials();
+
+    if (isVelaroAdmin(creds)) {
+      // ── Velaro admin: show all physical indexes with storage health ─────────
+      const stats = await get('/DatabaseTool/SearchIndexStats');
+
+      console.log('\n\x1b[1mPhysical Indexes\x1b[0m');
+      console.log(`  Shared: ${stats.sharedIndexes.length}  Dedicated: ${stats.dedicatedIndexes.length}  Total: ${stats.totalSlots}`);
+
+      const LIMIT_MB = 160 * 1024;
+
+      console.log('\n\x1b[1mShared Indexes\x1b[0m');
+      for (const idx of stats.sharedIndexes) {
+        console.log(`\n  \x1b[36m${idx.indexName}\x1b[0m  ${idx.sites?.length ?? 0} sites  ${idx.totalDocuments.toLocaleString()} docs`);
+        console.log(`  Storage: ${bar(idx.storageMb, LIMIT_MB)}  ${mb(idx.storageMb)} / ${mb(LIMIT_MB)}`);
+        if (idx.sites?.length) {
+          for (const s of idx.sites.slice(0, 10)) {
+            const badge = s.assignmentType === 'legacy-fallback' ? '\x1b[33m[legacy]\x1b[0m' :
+                          s.assignmentType === 'dedicated'        ? '\x1b[35m[dedicated]\x1b[0m' :
+                                                                    '\x1b[34m[shared]\x1b[0m';
+            console.log(`    Site ${s.siteId.toString().padEnd(8)} ${badge}  ${s.documentCount.toLocaleString()} docs`);
+          }
+          if (idx.sites.length > 10) console.log(`    ... and ${idx.sites.length - 10} more`);
+        }
+      }
+
+      if (stats.dedicatedIndexes.length) {
+        console.log('\n\x1b[1mDedicated Indexes\x1b[0m');
+        for (const idx of stats.dedicatedIndexes) {
+          console.log(`  \x1b[35m${idx.indexName}\x1b[0m  Site ${idx.siteId}  ${idx.documentCount.toLocaleString()} docs`);
+          console.log(`  Storage: ${bar(idx.storageMb, LIMIT_MB)}  ${mb(idx.storageMb)} / ${mb(LIMIT_MB)}`);
+        }
+      }
+
+      const legacy = stats.sharedIndexes.flatMap(s => s.sites ?? []).filter(s => s.assignmentType === 'legacy-fallback').length;
+      if (legacy > 0) {
+        console.log(`\n\x1b[33m⚠ ${legacy} legacy site(s) have no index assignment (fallback to velaro-shared-index)\x1b[0m`);
+      }
+    } else {
+      // ── Customer: show their virtual indexes + quota ────────────────────────
+      const siteId = argv.site ?? creds.siteId;
+      const [indexes, breakdown] = await Promise.all([
+        get('/AzureIndexes/List'),
+        get(`/DatabaseTool/SearchIndexSite?siteId=${siteId}`).catch(() => null),
+      ]);
+
+      // Quota from subscription
+      const sub = await get('/Subscription/Get').catch(() => null);
+      const chunkCap = sub?.maxIndexedChunkTotal ?? 0;
+      const usedChunks = indexes.reduce((s, i) => s + (i.documentCount ?? 0), 0);
+
+      console.log('\n\x1b[1mYour Search Indexes\x1b[0m');
+
+      if (chunkCap > 0) {
+        console.log(`\nQuota: ${bar(usedChunks, chunkCap)}  ${usedChunks.toLocaleString()} / ${chunkCap.toLocaleString()} chunks used`);
+        const remaining = chunkCap - usedChunks;
+        if (remaining <= 0) {
+          console.log('\x1b[31m✗ Quota full — new content will not be indexed until you upgrade or remove content.\x1b[0m');
+        } else if (remaining < chunkCap * 0.1) {
+          console.log(`\x1b[33m⚠ Only ${remaining.toLocaleString()} chunks remaining. Consider upgrading your plan.\x1b[0m`);
+        }
+      }
+
+      if (breakdown) {
+        const typeLabel = breakdown.assignmentType === 'dedicated' ? '\x1b[35m[dedicated index]\x1b[0m' :
+                          breakdown.assignmentType === 'shared'    ? '\x1b[34m[shared index]\x1b[0m' :
+                                                                     '\x1b[33m[legacy]\x1b[0m';
+        console.log(`\nPhysical index: \x1b[36m${breakdown.physicalIndex}\x1b[0m  ${typeLabel}`);
+      }
+
+      console.log('');
+      for (const idx of indexes) {
+        const docs = idx.documentCount != null ? `${idx.documentCount.toLocaleString()} docs` : '';
+        console.log(`  \x1b[36m${idx.name}\x1b[0m  (id: ${idx.id})  ${docs}`);
+        if (idx.description) console.log(`    ${idx.description}`);
+      }
+
+      if (!indexes.length) console.log('  No indexes found. Create one in your bot settings.');
+    }
+    console.log('');
+  },
+};
+
+// ── site (Velaro staff only) ──────────────────────────────────────────────────
+
+const siteCommand = {
+  command:  'site <siteId>',
+  describe: 'Show index breakdown for a specific site (Velaro staff only)',
+  handler: async (argv) => {
+    const creds = await getCredentials();
+    if (!isVelaroAdmin(creds)) {
+      console.error('This command is only available to Velaro staff.');
+      process.exit(1);
+    }
+    const data = await get(`/DatabaseTool/SearchIndexSite?siteId=${argv.siteId}`);
+    console.log(`\nSite ${argv.siteId}  →  \x1b[36m${data.physicalIndex}\x1b[0m  [${data.assignmentType}]`);
+    console.log(`Total docs: ${data.totalDocuments.toLocaleString()}\n`);
+    for (const t of data.indexTypes) {
+      console.log(`  ${t.indexName.padEnd(40)} ${t.count.toLocaleString()} docs`);
+    }
+    console.log('');
+  },
+};
+
+// ── provision (Velaro staff only) ─────────────────────────────────────────────
+
+const provisionCommand = {
+  command:  'provision <siteId>',
+  describe: 'Provision a dedicated physical index for a site (Velaro staff only)',
+  handler: async (argv) => {
+    const creds = await getCredentials();
+    if (!isVelaroAdmin(creds)) {
+      console.error('This command is only available to Velaro staff.');
+      process.exit(1);
+    }
+    console.log(`Provisioning dedicated index for site ${argv.siteId}...`);
+    const result = await post('/DatabaseTool/ProvisionDedicatedIndex', { SiteId: argv.siteId });
+    console.log(`\x1b[32m✓ ${result.message}\x1b[0m`);
+    console.log(`  Index: \x1b[36m${result.indexName}\x1b[0m`);
+    console.log('\nNote: Re-ingest content to populate the new index.');
+  },
+};
+
+// ── reingest (customer-facing, credit-gated) ──────────────────────────────────
+
+const reingestCommand = {
+  command:  'reingest',
+  describe: 'Re-ingest all content sources for your site (requires available index quota)',
+  builder:  (y) =>
+    y
+      .option('source', {
+        type:     'string',
+        describe: 'Specific source to reingest: kb | shopify | bigcommerce | scraper',
+      })
+      .option('site', {
+        type:     'number',
+        describe: 'Site ID (Velaro staff only)',
+      }),
+  handler: async (argv) => {
+    const creds = await getCredentials();
+
+    // Check quota before allowing reingest
+    const sub = await get('/Subscription/Get').catch(() => null);
+    if (!isVelaroAdmin(creds) && sub?.maxIndexedChunkTotal > 0) {
+      const indexes = await get('/AzureIndexes/List').catch(() => []);
+      const usedChunks = indexes.reduce((s, i) => s + (i.documentCount ?? 0), 0);
+      if (usedChunks >= sub.maxIndexedChunkTotal) {
+        console.error(`\x1b[31m✗ Index quota full (${usedChunks.toLocaleString()} / ${sub.maxIndexedChunkTotal.toLocaleString()} chunks).\x1b[0m`);
+        console.error('  Upgrade your plan or remove content before reingesting.');
+        process.exit(1);
+      }
+    }
+
+    const sources = argv.source ? [argv.source] : ['kb', 'shopify', 'bigcommerce', 'scraper'];
+    const siteParam = isVelaroAdmin(creds) && argv.site ? `?siteId=${argv.site}` : '';
+
+    for (const source of sources) {
+      try {
+        console.log(`  Syncing ${source}...`);
+        await post(`/AzureIndexes/SyncIntegration${siteParam}`, { source, forceAll: true });
+        console.log(`  \x1b[32m✓ ${source} queued\x1b[0m`);
+      } catch (e) {
+        console.log(`  \x1b[33m⚠ ${source} skipped: ${e.message}\x1b[0m`);
+      }
+    }
+    console.log('\nReingest queued. Run `velaro index list` to monitor progress.');
+  },
+};
+
+// ── export ────────────────────────────────────────────────────────────────────
+
+export const indexCommand = {
+  command:  'index <subcommand>',
+  describe: 'Manage search indexes — view quota, physical index health, and reingest content',
+  builder:  (yargs) =>
+    yargs
+      .command(listCommand)
+      .command(siteCommand)
+      .command(provisionCommand)
+      .command(reingestCommand)
+      .demandCommand(1, 'Specify a subcommand: list, site, provision, reingest'),
+  handler: () => {},
+};

package/lib/commands/ingest.js

@@ -1,31 +1,31 @@
-import { getCredentials, post } from '../api.js';
-import { runCommand }           from '../run.js';
-
-export const ingestCommand = {
-  command:  'ingest',
-  describe: 'Trigger knowledge base ingestion for a completed scraper job',
-  builder:  (y) =>
-    y.option('job-id', {
-      describe:     'Scraper job ID to ingest',
-      type:         'string',
-      demandOption: true,
-    }),
-
-  handler: runCommand(async (argv) => {
-    // Single credential resolution — avoids double readConfig() from calling readConfig()
-    // here and again inside post() → getCredentials().
-    const creds = await getCredentials();
-
-    console.log(`Triggering ingestion for job ${argv['job-id']} on site ${creds.siteId}...`);
-
-    const result = await post('/AzureIndexes/IngestJobDirect', {
-      siteId: creds.siteId,
-      jobId:  argv['job-id'],
-    });
-
-    console.log('Ingestion started.');
-    console.log(`  Job ID: ${result.jobId}`);
-    console.log(`  Index:  ${result.physicalIndex}`);
-    console.log('\nEmbedding runs in the background. Check logs for completion.');
-  }),
-};
+import { getCredentials, post } from '../api.js';
+import { runCommand }           from '../run.js';
+
+export const ingestCommand = {
+  command:  'ingest',
+  describe: 'Trigger knowledge base ingestion for a completed scraper job',
+  builder:  (y) =>
+    y.option('job-id', {
+      describe:     'Scraper job ID to ingest',
+      type:         'string',
+      demandOption: true,
+    }),
+
+  handler: runCommand(async (argv) => {
+    // Single credential resolution — avoids double readConfig() from calling readConfig()
+    // here and again inside post() → getCredentials().
+    const creds = await getCredentials();
+
+    console.log(`Triggering ingestion for job ${argv['job-id']} on site ${creds.siteId}...`);
+
+    const result = await post('/AzureIndexes/IngestJobDirect', {
+      siteId: creds.siteId,
+      jobId:  argv['job-id'],
+    });
+
+    console.log('Ingestion started.');
+    console.log(`  Job ID: ${result.jobId}`);
+    console.log(`  Index:  ${result.physicalIndex}`);
+    console.log('\nEmbedding runs in the background. Check logs for completion.');
+  }),
+};

package/lib/commands/kb.js

@@ -14,10 +14,78 @@ 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 KB articles or scraper/ingestion content (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)',
+      })
+      .option('ingestion', {
+        type:     'boolean',
+        describe: 'Reindex scraper/ingestion Azure Search indexers instead of KB articles',
+        default:  false,
+      }),
+  handler: runCommand(async (argv) => {
+    if (argv.ingestion) {
+      if (argv.all) {
+        console.log('Starting bulk ingestion reindex for all sites — runs in background.');
+        console.log('Watch server logs ([ReindexAllIngestion]) for progress.\n');
+        const result = await post('/DatabaseTool/ReindexAllIngestionIndexes', {});
+        console.log(result.message ?? 'Queued.');
+      } else if (argv.site) {
+        console.log(`Reindexing scraper/ingestion index for site ${argv.site}…`);
+        const result = await post(`/DatabaseTool/ReindexIngestionIndex/${argv.site}`, {});
+        if (result.success) {
+          console.log(`✅ Triggered ${result.indexersRun} indexer(s) — re-processing in background.`);
+        } else {
+          console.error(`❌ Failed: ${result.message}`);
+        }
+      } else {
+        console.error('--ingestion requires --site <id> or --all (Velaro staff only)');
+        process.exit(1);
+      }
+    } else if (argv.all) {
+      console.log('Starting bulk KB 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 KB articles for 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,27 +1,27 @@
 import { requestDeviceCode, pollForToken, exchangeForVelaroToken } from '../oauth.js';
-import { readConfig, writeConfig, DEFAULT_API_BASE, STAGING_API_BASE } from '../config.js';
-import { runCommand }                                               from '../run.js';
+import { readConfig, writeConfig, setEnvCredentials, getActiveEnv, ENVS } from '../config.js';
+import { runCommand } from '../run.js';
 
 export const loginCommand = {
   command:  'login',
-  describe: 'Authenticate with Velaro using your browser',
+  describe: 'Authenticate with Velaro (saves credentials for the chosen environment)',
   builder:  (y) =>
     y
       .option('staging', {
-        describe: 'Connect to the Velaro staging environment',
+        describe: 'Log in to the 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.',
+        describe: 'Override the admin API base URL (advanced)',
         type:     'string',
       }),
 
   handler: runCommand(async (argv) => {
-    const apiBase = argv.api ?? (argv.staging ? STAGING_API_BASE : DEFAULT_API_BASE);
+    const env = argv.staging || argv.api?.includes('staging') ? 'staging' : 'prod';
+    const adminApiBase = argv.api || ENVS[env].adminApiBase;
 
-    console.log('Starting Velaro login...\n');
+    console.log(`Starting Velaro login (${env})...\n`);
 
     const deviceData = await requestDeviceCode();
 
@@ -30,11 +30,10 @@ export const loginCommand = {
     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);
+    const velaroResult = await exchangeForVelaroToken(entraTokens.access_token, adminApiBase);
 
-    writeConfig({
-      ...readConfig(),
-      apiBase,
+    setEnvCredentials(env, {
+      adminApiBase,
       velaroToken:       velaroResult.token.token,
       velaroExpires:     velaroResult.token.expires,
       entraRefreshToken: entraTokens.refresh_token,
@@ -42,19 +41,46 @@ export const loginCommand = {
       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');
+    // 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',
-  handler:  runCommand(async () => {
-    const { clearConfig } = await import('../config.js');
-    clearConfig();
-    console.log('Logged out. Credentials removed from ~/.velaro/config.json');
+  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

@@ -2,6 +2,7 @@ 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 = {
@@ -76,28 +77,34 @@ const mcpKeyInstallCommand = {
       .option('label', {
         describe: 'Label for the key',
         type:     'string',
-        default:  'Claude Code',
       })
-      .option('api', {
-        describe: 'Velaro API base URL (defaults to production)',
-        type:     'string',
+      .option('staging', {
+        describe: 'Install key for the staging environment',
+        type:     'boolean',
+        default:  false,
       }),
 
   handler: runCommand(async (argv) => {
-    const payload = { label: argv.label };
+    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 {}
     }
 
-    const apiBase = argv.api || 'https://api-admin-us-east.velaro.com';
     settings.mcpServers = settings.mcpServers || {};
-    settings.mcpServers.velaro = {
+    settings.mcpServers[serverName] = {
       command: 'npx',
       args:    ['-y', '@velaro/mcp-server'],
       env:     {
@@ -109,10 +116,10 @@ const mcpKeyInstallCommand = {
     fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 
-    console.log(`✅ MCP key created: ${result.label}  (${result.keyPrefix}...)`);
-    console.log(`✅ Written to: ${settingsPath}`);
+    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 verify: run 'velaro mcp-key list' or check Settings → Developer → MCP Keys in the admin portal.`);
+    console.log(`\nTo use in Claude Code: say "use ${serverName}" to target ${env}.`);
   }),
 };