@velaro/cli 1.2.0 → 1.4.9

package/lib/commands/pickup.js

@@ -0,0 +1,172 @@
+import { messagingGet, messagingPost, messagingPut } from '../api.js';
+import { runCommand } from '../run.js';
+
+// ── velaro pickup ──────────────────────────────────────────────────────────────
+// CLI surface for "Pickup & Reminder Texting" -- notify a contact their order/item
+// is ready, optionally with recurring reminders, mark it picked up, view history,
+// and manage the per-site config. siteId is applied server-side from the
+// vmsg-siteId header (see cli/lib/api.js messagingRequest) -- never a CLI arg.
+//
+// Backend contract: server/Velaro.Messaging/Controllers/PickupNotificationsController.cs
+//   POST   PickupNotifications/Contacts/{contactId}/notify           { message, startReminderChain, cadenceHours?, maxReminders? } -> { conversationBaseId, workflowJobId }
+//   POST   PickupNotifications/Conversations/{conversationBaseId}/mark-picked-up -> { success }
+//   GET    PickupNotifications/Contacts/{contactId}/notifications    -> history[]
+//   GET    PickupNotifications/Config                                -> config | 404
+//   POST   PickupNotifications/Config                                -> create (409 if one already exists)
+//   PUT    PickupNotifications/Config/{id}                           -> apply-if-present update
+
+const BOLD = '\x1b[1m';
+const DIM  = '\x1b[2m';
+const GRN  = '\x1b[32m';
+const RST  = '\x1b[0m';
+
+function fmtDate(d) {
+  return d ? new Date(d).toISOString().replace('T', ' ').slice(0, 19) : '-';
+}
+
+async function notifyHandler(argv) {
+  // Field names must match NotifyContactRequest (Services/Messaging/IPickupNotificationService.cs)
+  // exactly -- "startReminderChain", NOT "remind". A mismatched name binds to default(false) and
+  // the reminder chain silently never starts.
+  const result = await messagingPost(`/PickupNotifications/Contacts/${argv.contactId}/notify`, {
+    message:            argv.message,
+    startReminderChain: !!argv.remind,
+    cadenceHours:       argv.cadenceHours,
+    maxReminders:       argv.maxReminders,
+  });
+  console.log(`\n${GRN}✓${RST} Pickup notification sent to contact ${argv.contactId}.`);
+  console.log(`  Conversation: ${result.conversationBaseId}`);
+  if (result.workflowJobId) console.log(`  Reminder job: ${result.workflowJobId}`);
+  console.log('');
+}
+
+async function markPickedUpHandler(argv) {
+  await messagingPost(`/PickupNotifications/Conversations/${argv.conversationId}/mark-picked-up`, {});
+  console.log(`\n${GRN}✓${RST} Conversation ${argv.conversationId} marked picked up. Reminders stopped.\n`);
+}
+
+async function historyHandler(argv) {
+  const history = await messagingGet(`/PickupNotifications/Contacts/${argv.contactId}/notifications`);
+  if (!Array.isArray(history) || !history.length) {
+    console.log(`\n  No pickup notifications found for contact ${argv.contactId}.\n`);
+    return;
+  }
+  // Fields must match PickupNotificationSendHistoryItem exactly -- the ONLY fields on that DTO
+  // are conversationBaseId, sentAtUtc, segmentCount, isInitialSend, workflowJobId. There is no
+  // id/message/pickedUp/type field; do not print ones that don't exist.
+  console.log(`\n${BOLD}Pickup notification history -- contact ${argv.contactId}${RST}\n`);
+  for (const h of history) {
+    const kind = h.isInitialSend ? `${GRN}initial${RST}` : 'reminder';
+    const chain = h.workflowJobId ? `  ${DIM}chain:${h.workflowJobId}${RST}` : '';
+    console.log(`  ${fmtDate(h.sentAtUtc)}  conv:${h.conversationBaseId ?? '-'}  ${kind}  ${h.segmentCount ?? 0} seg${chain}`);
+  }
+  console.log('');
+}
+
+async function configGetHandler() {
+  let config;
+  try {
+    config = await messagingGet('/PickupNotifications/Config');
+  } catch (err) {
+    if (String(err.message).includes(' 404')) {
+      console.log(`\n  No Pickup & Reminder Texting config exists for this site yet. Run "velaro pickup config set" to create one.\n`);
+      return;
+    }
+    throw err;
+  }
+  console.log(`\n${BOLD}Pickup & Reminder Texting config${RST}  (id ${config.id})`);
+  console.log(`  Enabled:              ${config.isEnabled ? `${GRN}yes${RST}` : 'no'}`);
+  console.log(`  Default cadence:      ${config.defaultCadenceHours}h`);
+  console.log(`  Default max reminders:${config.defaultMaxReminders}`);
+  console.log(`  Message template:     ${config.defaultMessageTemplate ?? '-'}`);
+  console.log(`  Quiet hours override: ${config.quietHoursOverride ?? `${DIM}(account default)${RST}`}`);
+  console.log('');
+}
+
+async function configSetHandler(argv) {
+  const body = {
+    isEnabled:              argv.enabled,
+    defaultCadenceHours:    argv.cadenceHours,
+    defaultMaxReminders:    argv.maxReminders,
+    defaultMessageTemplate: argv.template,
+    quietHoursOverride:     argv.quietHoursOverride,
+  };
+
+  let existing = null;
+  try {
+    existing = await messagingGet('/PickupNotifications/Config');
+  } catch (err) {
+    if (!String(err.message).includes(' 404')) throw err;
+  }
+
+  const config = existing
+    ? await messagingPut(`/PickupNotifications/Config/${existing.id}`, body)
+    : await messagingPost('/PickupNotifications/Config', body);
+
+  console.log(`\n${GRN}✓${RST} Pickup & Reminder Texting config ${existing ? 'updated' : 'created'} (id ${config.id}).\n`);
+}
+
+const notifyCommand = {
+  command:  'notify <contactId>',
+  describe: 'Send a pickup notification text to a contact, optionally with recurring reminders',
+  builder:  (y) => y
+    .positional('contactId', { describe: 'Contact ID to notify', type: 'number' })
+    .option('message',       { describe: 'Notification text -- required; the initial send is always caller-supplied (the site template is only used for follow-up reminders)', type: 'string', demandOption: true })
+    .option('remind',        { describe: 'Schedule recurring reminders until marked picked up', type: 'boolean', default: false })
+    .option('cadence-hours', { describe: 'Hours between reminders, 1-168 (default: site config default)', type: 'number' })
+    .option('max-reminders', { describe: 'Max reminder texts, 1-14 (default: site config default)', type: 'number' }),
+  handler: runCommand(notifyHandler),
+};
+
+const markPickedUpCommand = {
+  command:  'mark-picked-up <conversationId>',
+  describe: 'Mark a conversation as picked up -- stops any further reminder texts',
+  builder:  (y) => y
+    .positional('conversationId', { describe: 'Conversation base ID', type: 'number' }),
+  handler: runCommand(markPickedUpHandler),
+};
+
+const historyCommand = {
+  command:  'history <contactId>',
+  describe: 'Show pickup notification history for a contact',
+  builder:  (y) => y
+    .positional('contactId', { describe: 'Contact ID', type: 'number' }),
+  handler: runCommand(historyHandler),
+};
+
+const configCommand = {
+  command:  'config <subcommand>',
+  describe: 'Get or set this site\'s Pickup & Reminder Texting config',
+  builder:  (y) => y
+    .command({
+      command:  'get',
+      describe: 'Show this site\'s Pickup & Reminder Texting config',
+      handler:  runCommand(configGetHandler),
+    })
+    .command({
+      command:  'set',
+      describe: 'Create or update this site\'s Pickup & Reminder Texting config (apply-if-present -- omit a flag to leave it unchanged)',
+      builder:  (y2) => y2
+        .option('enabled',            { describe: 'Enable/disable pickup notifications site-wide', type: 'boolean' })
+        .option('cadence-hours',      { describe: 'Default hours between reminders, 1-168', type: 'number' })
+        .option('max-reminders',      { describe: 'Default max reminder texts, 1-14', type: 'number' })
+        .option('template',          { describe: 'Default pickup notification message text', type: 'string' })
+        .option('quiet-hours-override', { describe: 'Quiet-hours override (pass "" to clear back to account default)', type: 'string' }),
+      handler: runCommand(configSetHandler),
+    })
+    .demandCommand(1, 'Specify a config subcommand: get | set'),
+  handler: () => {},
+};
+
+export const pickupCommand = {
+  command:  'pickup <subcommand>',
+  describe: 'Pickup & Reminder Texting -- notify contacts, manage reminders, and site config',
+  builder:  (y) => y
+    .command(notifyCommand)
+    .command(markPickedUpCommand)
+    .command(historyCommand)
+    .command(configCommand)
+    .demandCommand(1, 'Specify a pickup subcommand: notify | mark-picked-up | history | config')
+    .strict(),
+  handler: () => {},
+};

package/lib/commands/pricing.js

@@ -0,0 +1,132 @@
+// velaro pricing — view and manage the pricing catalog (superadmin only)
+import { request } from '../api.js';
+
+const TYPE_ORDER = ['plan', 'addon', 'block', 'seat', 'compliance', 'skill'];
+
+function fmt(pkg) {
+  const price = pkg.contactSales
+    ? 'Contact sales'
+    : pkg.monthlyPriceCents
+      ? `$${(pkg.monthlyPriceCents / 100).toFixed(0)}${pkg.unitLabel || '/mo'}`
+      : 'Free';
+  return `  ${pkg.packageKey.padEnd(42)} ${price.padEnd(18)} v${pkg.version}  ${pkg.displayName}`;
+}
+
+async function listPackages(args) {
+  const pkgs = await request('GET', '/Pricing/catalog');
+  if (!Array.isArray(pkgs) || !pkgs.length) { console.log('No packages found.'); return; }
+
+  const typeFilter = args.type?.toLowerCase();
+  const filtered = typeFilter ? pkgs.filter(p => p.packageType === typeFilter) : pkgs;
+  if (!filtered.length) { console.log(`No packages with type '${typeFilter}'.`); return; }
+
+  const byType = {};
+  for (const p of filtered) {
+    if (!byType[p.packageType]) byType[p.packageType] = [];
+    byType[p.packageType].push(p);
+  }
+
+  console.log(`\nPricing Catalog (${filtered.length} packages)\n`);
+  const types = TYPE_ORDER.filter(t => byType[t]);
+  for (const t of types) {
+    console.log(`── ${t.toUpperCase()} (${byType[t].length}) ──`);
+    byType[t].forEach(p => console.log(fmt(p)));
+    console.log('');
+  }
+}
+
+async function getPackage(args) {
+  if (!args.key) { console.error('Usage: velaro pricing get --key addon.appointments'); process.exit(1); }
+  const p = await request('GET', `/Pricing/catalog/${args.key}`);
+  console.log(JSON.stringify(p, null, 2));
+}
+
+async function updatePackage(args) {
+  if (!args.key) { console.error('Usage: velaro pricing update --key addon.appointments [--price 59] [--name "..."] [--contact-sales]'); process.exit(1); }
+  const payload = {};
+  if (args.price != null)       payload.monthlyPriceCents = Math.round(parseFloat(args.price) * 100);
+  if (args.discount != null)    payload.annualDiscountBps  = Math.round(parseFloat(args.discount) * 100);
+  if (args.name)                payload.displayName        = args.name;
+  if (args.description)         payload.description        = args.description;
+  if (args['contact-sales'] != null) payload.contactSales  = args['contact-sales'];
+  if (args.active != null)      payload.isActive           = args.active;
+
+  if (!Object.keys(payload).length) { console.error('No fields to update. Use --price, --name, --description, --contact-sales, --active.'); process.exit(1); }
+
+  const result = await request('PUT', `/Pricing/catalog/${args.key}`, payload);
+  console.log(`✅ Package '${result.packageKey}' updated to v${result.version}.`);
+}
+
+async function createPackage(args) {
+  if (!args.key || !args.type || !args.name) {
+    console.error('Usage: velaro pricing create --key addon.my-feature --type addon --name "My Feature" [--price 49] [--description "..."] [--contact-sales]');
+    process.exit(1);
+  }
+  const body = {
+    packageKey:        args.key,
+    packageType:       args.type,
+    displayName:       args.name,
+    description:       args.description,
+    monthlyPriceCents: args.price ? Math.round(parseFloat(args.price) * 100) : 0,
+    contactSales:      args['contact-sales'] ?? false,
+    unitLabel:         args.unit || '/mo',
+  };
+  const result = await request('POST', '/Pricing/catalog', body);
+  console.log(`✅ Created package '${result.packageKey}' (v${result.version}).`);
+}
+
+async function seedCatalog() {
+  const result = await request('POST', '/Pricing/catalog/seed', {});
+  console.log(`✅ Seeded ${result.seeded} packages from PricingCatalogSeeder.cs defaults.`);
+}
+
+async function bulkAdjust(args) {
+  if (args.percent == null) { console.error('Usage: velaro pricing bulk-adjust --percent 10 [--type addon] [--force-contact-sales]'); process.exit(1); }
+  const pct = parseFloat(args.percent);
+  if (isNaN(pct) || pct === 0) { console.error('--percent must be a non-zero number (e.g. 10 for +10%, -5 for -5%)'); process.exit(1); }
+
+  const body = { percentChange: pct };
+  if (args.type) body.packageType = args.type;
+  if (args['force-contact-sales']) body.forceContactSales = true;
+
+  const result = await request('POST', '/Pricing/catalog/bulk-adjust', body);
+  const sign = pct > 0 ? '+' : '';
+  console.log(`\n✅ Applied ${sign}${pct}% to ${result.updated} packages:\n`);
+  for (const c of result.changes) {
+    const oldFmt = `$${(c.oldPrice / 100).toFixed(0)}`;
+    const newFmt = `$${(c.newPrice / 100).toFixed(0)}`;
+    const chgFmt = c.change >= 0 ? `+$${(c.change / 100).toFixed(0)}` : `-$${(Math.abs(c.change) / 100).toFixed(0)}`;
+    console.log(`  ${c.packageKey.padEnd(42)} ${oldFmt.padStart(8)} → ${newFmt.padStart(8)}  (${chgFmt})  ${c.displayName}`);
+  }
+}
+
+export function pricingCommand(yargs) {
+  return yargs
+    .command('list', 'List all pricing packages', y => y.option('type', { type: 'string', desc: 'Filter: plan | addon | block | seat | compliance | skill' }), a => listPackages(a))
+    .command('get', 'Get a single package by key', y => y.option('key', { type: 'string', demandOption: true }), a => getPackage(a))
+    .command('update', 'Update a package price or metadata', y => y
+      .option('key',           { type: 'string', demandOption: true, desc: 'Package key' })
+      .option('price',         { type: 'number', desc: 'New monthly price in dollars (e.g. 59)' })
+      .option('discount',      { type: 'number', desc: 'Annual discount percentage (e.g. 20)' })
+      .option('name',          { type: 'string', desc: 'New display name' })
+      .option('description',   { type: 'string', desc: 'New description' })
+      .option('contact-sales', { type: 'boolean', desc: 'Set to hide price and show "Contact sales"' })
+      .option('active',        { type: 'boolean', desc: 'Set to false to deactivate' })
+    , a => updatePackage(a))
+    .command('create', 'Create a new pricing package', y => y
+      .option('key',           { type: 'string', demandOption: true, desc: 'Unique key (e.g. addon.my-feature)' })
+      .option('type',          { type: 'string', demandOption: true, desc: 'plan | addon | block | seat | compliance | skill' })
+      .option('name',          { type: 'string', demandOption: true, desc: 'Display name' })
+      .option('price',         { type: 'number', desc: 'Monthly price in dollars' })
+      .option('description',   { type: 'string', desc: 'Short description' })
+      .option('unit',          { type: 'string', desc: 'Unit label (default: /mo)' })
+      .option('contact-sales', { type: 'boolean', desc: 'Show "Contact sales" instead of price' })
+    , a => createPackage(a))
+    .command('bulk-adjust', 'Apply a blanket % price change across all or filtered packages', y => y
+      .option('percent',              { type: 'number', demandOption: true, desc: 'Percentage change: 10 = +10%, -5 = -5%' })
+      .option('type',                 { type: 'string', desc: 'Limit to one type: plan | addon | block | seat | compliance' })
+      .option('force-contact-sales',  { type: 'boolean', desc: 'Also adjust "Contact sales" packages (default: skip them)' })
+    , a => bulkAdjust(a))
+    .command('seed', 'Re-seed catalog from PricingCatalogSeeder.cs defaults', () => {}, () => seedCatalog())
+    .demandCommand(1, 'Specify a subcommand: list | get | update | create | bulk-adjust | seed');
+}

package/lib/commands/product.js

@@ -0,0 +1,55 @@
+import { get } from '../api.js';
+import { runCommand } from '../run.js';
+
+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)}%`;
+}
+
+// ── sync-status ────────────────────────────────────────────────────────────
+// GET /ProductCatalog/SyncStatus — per-platform e-commerce product ingestion
+// status (last sync time, products indexed, cap usage). Site is resolved
+// server-side from the caller's auth context — never a client-supplied value.
+
+const syncStatusCommand = {
+  command:  'sync-status',
+  describe: 'Show e-commerce product sync status (Shopify/BigCommerce/WooCommerce/Magento) — last sync time, products indexed, cap usage',
+  handler: runCommand(async () => {
+    const data = await get('/ProductCatalog/SyncStatus');
+
+    console.log('\n\x1b[1mProduct Sync Status\x1b[0m');
+
+    if (data.maxProductsIndexed > 0) {
+      const used = data.platforms.reduce((s, p) => s + (p.productsIndexed ?? 0), 0);
+      console.log(`Cap usage: ${bar(used, data.maxProductsIndexed)}  ${used.toLocaleString()} / ${data.maxProductsIndexed.toLocaleString()} products`);
+    }
+
+    console.log('');
+    for (const p of data.platforms) {
+      const name = p.platform.charAt(0).toUpperCase() + p.platform.slice(1);
+      if (!p.ingestionAvailable) {
+        console.log(`  ${name.padEnd(14)} \x1b[90mno nightly ingestion yet — always live lookup\x1b[0m`);
+        continue;
+      }
+      const configured = p.configured === null ? '' : p.configured ? '\x1b[32mconnected\x1b[0m' : '\x1b[90mnot connected\x1b[0m';
+      const errBadge = p.hasErrors ? '  \x1b[31m⚠ has errors\x1b[0m' : '';
+      const lastSync = p.lastSyncAt ? new Date(p.lastSyncAt).toLocaleString() : 'never';
+      console.log(`  ${name.padEnd(14)} ${configured}`);
+      console.log(`    Last sync: ${lastSync}   Products indexed: ${p.productsIndexed.toLocaleString()}${errBadge}`);
+    }
+    console.log('\nNote: price and availability shown to customers are always fetched live — never from this index.\n');
+  }),
+};
+
+export const productCommand = {
+  command:  'product <subcommand>',
+  describe: 'E-commerce product catalog sync status',
+  builder:  (yargs) =>
+    yargs
+      .command(syncStatusCommand)
+      .demandCommand(1, 'Specify a subcommand: sync-status'),
+  handler: () => {},
+};