spaps 0.7.6 → 0.7.8

package/src/handlers.js

@@ -2,24 +2,30 @@ const chalk = require('chalk');
 const fs = require('fs');
 const { DEFAULT_PORT } = require('./config');
 const { handleError } = require('./error-handler');
-const { showInteractiveHelp, showQuickHelp } = require('./help-system');
-const { showInteractiveDocs, showQuickReference, searchDocs } = require('./docs-system');
-const { getQuickStartInstructions, getServerStatus, runQuickTest } = require('./ai-helper');
-const { buildToolSpec } = require('./ai-tool-spec');
-const { runDoctor } = require('./doctor');
-const {
-  applyFixtures,
-  exportStorageState,
-  initFixtureKernel,
-  resetFixtures,
-} = require('./fixture-kernel');
-const { createProjectStarter } = require('./project-scaffolder');
-const {
-  loginHandler,
-  logoutHandler,
-  whoamiHandler,
-  tokenHandler,
-} = require('./auth/handlers');
+const { hasInteractiveTerminal } = require('./auth/env');
+const { showQuickHelp } = require('./help-quick');
+const { showQuickReference } = require('./docs-quick');
+
+function lazy(factory) {
+  let value;
+  return () => {
+    if (value === undefined) {
+      value = factory();
+    }
+    return value;
+  };
+}
+
+const loadHelpSystem = lazy(() => require('./help-system'));
+const loadDocsSystem = lazy(() => require('./docs-system'));
+const loadAiHelper = lazy(() => require('./ai-helper'));
+const loadAiToolSpec = lazy(() => require('./ai-tool-spec'));
+const loadDoctor = lazy(() => require('./doctor'));
+const loadHomeView = lazy(() => require('./home-view'));
+const loadFixtureKernel = lazy(() => require('./fixture-kernel'));
+const loadProjectScaffolder = lazy(() => require('./project-scaffolder'));
+const loadAuthCommandHandlers = lazy(() => require('./auth/handlers'));
+const loadDomainCli = lazy(() => require('./domain-cli'));
 
 function createHandlers(version, logo) {
   function invalidArgument(message) {
@@ -28,7 +34,62 @@ function createHandlers(version, logo) {
     return error;
   }
 
+  function emitInteractiveFallback(message) {
+    console.log(
+      chalk.yellow(`\n⚠️  ${message}. Showing the quick reference instead.\n`)
+    );
+  }
+
+  const verifyHandler = async ({ options }) => {
+    const { runQuickTest } = loadAiHelper();
+    const result = await runQuickTest({
+      port: options.port,
+      serverUrl: options.serverUrl,
+      cwd: process.cwd(),
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    console.log(chalk.yellow('\n🍠 SPAPS Verify\n'));
+    console.log(result.success ? chalk.green(result.summary) : chalk.yellow(result.summary));
+    console.log();
+    (result.results || []).forEach((entry) => {
+      const mark = entry.success ? chalk.green('✓') : chalk.red('✗');
+      const message = entry.message ? `: ${entry.message}` : '';
+      console.log(`  ${mark} ${entry.test}${message}`);
+      if (!entry.success && entry.fix) {
+        console.log(chalk.gray(`    fix: ${entry.fix}`));
+      }
+    });
+    if (Array.isArray(result.next_steps) && result.next_steps.length > 0) {
+      console.log();
+      console.log(chalk.bold('Next'));
+      result.next_steps.forEach((step) => {
+        console.log(chalk.cyan(`  ${step}`));
+      });
+    }
+    console.log();
+  };
+
   return {
+    home: async ({ options }) => {
+      const { buildHomeView, renderHomeView } = loadHomeView();
+      const view = await buildHomeView({
+        port: options.port,
+        serverUrl: options.serverUrl,
+        cwd: process.cwd(),
+      });
+
+      if (options.json) {
+        console.log(JSON.stringify(view, null, 2));
+        return;
+      }
+
+      renderHomeView(view, { logo });
+    },
     local: async ({ options }) => {
       const isJson = options.json;
       if (!isJson) console.log(logo);
@@ -86,6 +147,7 @@ function createHandlers(version, logo) {
       }
     },
     quickstart: async ({ options }) => {
+      const { getQuickStartInstructions } = loadAiHelper();
       const instructions = await getQuickStartInstructions(options.port);
       if (options.json) {
         console.log(JSON.stringify(instructions, null, 2));
@@ -104,6 +166,7 @@ function createHandlers(version, logo) {
       }
     },
     status: async ({ options }) => {
+      const { getServerStatus } = loadAiHelper();
       const status = await getServerStatus(options.port);
       if (options.json) {
         console.log(JSON.stringify(status));
@@ -127,10 +190,7 @@ function createHandlers(version, logo) {
         }
       }
     },
-    test: async ({ options }) => {
-      const result = await runQuickTest(options.port);
-      console.log(JSON.stringify(result, null, 2));
-    },
+    verify: verifyHandler,
     init: async ({ options }) => {
       const isJson = options.json;
       const envContent = `# SPAPS Local Development\nSPAPS_API_URL=http://localhost:${DEFAULT_PORT}\n# SPAPS_API_KEY=your-api-key-here\n`;
@@ -158,6 +218,7 @@ function createHandlers(version, logo) {
     },
     create: async ({ options }) => {
       const isJson = options.json;
+      const { createProjectStarter } = loadProjectScaffolder();
 
       try {
         const result = await createProjectStarter({
@@ -223,7 +284,12 @@ function createHandlers(version, logo) {
     },
     help: async ({ options }) => {
       if (options.interactive) {
-        await showInteractiveHelp();
+        if (!hasInteractiveTerminal()) {
+          emitInteractiveFallback('Interactive help requires a TTY');
+          showQuickHelp();
+          return;
+        }
+        await loadHelpSystem().showInteractiveHelp();
       } else if (options.quick) {
         showQuickHelp();
       } else {
@@ -232,7 +298,7 @@ function createHandlers(version, logo) {
     },
     docs: async ({ options }) => {
       if (options.search) {
-        const results = searchDocs(options.search);
+        const results = loadDocsSystem().searchDocs(options.search);
         if (options.json) {
           console.log(JSON.stringify({ results }, null, 2));
         } else {
@@ -250,12 +316,18 @@ function createHandlers(version, logo) {
           console.log(chalk.blue('  to browse full documentation\n'));
         }
       } else if (options.interactive) {
-        await showInteractiveDocs();
+        if (!hasInteractiveTerminal()) {
+          emitInteractiveFallback('Interactive docs require a TTY');
+          showQuickReference();
+          return;
+        }
+        await loadDocsSystem().showInteractiveDocs();
       } else {
         showQuickReference();
       }
     },
     tools: async ({ options }) => {
+      const { buildToolSpec } = loadAiToolSpec();
       const spec = await buildToolSpec({
         format: options.format || 'openai',
         port: options.port,
@@ -282,6 +354,12 @@ function createHandlers(version, logo) {
     },
     fixtures: async ({ options }) => {
       const isJson = options.json;
+      const {
+        applyFixtures,
+        exportStorageState,
+        initFixtureKernel,
+        resetFixtures,
+      } = loadFixtureKernel();
 
       try {
         if (options.format && options.format !== 'playwright') {
@@ -305,6 +383,8 @@ function createHandlers(version, logo) {
               port: options.port,
               baseUrl: options.baseUrl,
               version,
+              persona: options.persona,
+              seed: options.seed,
             });
             break;
           case 'reset':
@@ -313,6 +393,7 @@ function createHandlers(version, logo) {
               port: options.port,
               baseUrl: options.baseUrl,
               version,
+              seed: options.seed,
             });
             break;
           case 'storage-state':
@@ -325,6 +406,7 @@ function createHandlers(version, logo) {
               baseUrl: options.baseUrl,
               version,
               persona: options.persona,
+              seed: options.seed,
             });
             break;
           default:
@@ -362,6 +444,13 @@ function createHandlers(version, logo) {
           });
         }
 
+        if (Array.isArray(result.seeding?.personas) && result.seeding.personas.length > 0) {
+          console.log(chalk.green('\nSeeded personas:'));
+          result.seeding.personas.forEach((entry) => {
+            console.log(chalk.gray(`  • ${entry.persona} (${entry.request_count} requests)`));
+          });
+        }
+
         if (result.generated?.personas?.length) {
           console.log(chalk.green('\nGenerated personas:'));
           result.generated.personas.forEach((entry) => {
@@ -408,13 +497,430 @@ function createHandlers(version, logo) {
       }
     },
     doctor: async ({ options }) => {
+      const { runDoctor } = loadDoctor();
       await runDoctor({ port: options.port || DEFAULT_PORT, stripe: options.stripe || null, json: options.json });
     },
-    login: loginHandler,
-    logout: logoutHandler,
-    whoami: whoamiHandler,
-    token: tokenHandler,
+    test: verifyHandler,
+    login: async (...args) => loadAuthCommandHandlers().loginHandler(...args),
+    logout: async (...args) => loadAuthCommandHandlers().logoutHandler(...args),
+    whoami: async (...args) => loadAuthCommandHandlers().whoamiHandler(...args),
+    token: async (...args) => loadAuthCommandHandlers().tokenHandler(...args),
+    dayrate: dayrateHandler,
+    email: emailHandler,
+    policy: policyHandler,
+    webhook: webhookHandler,
+    'issue-reports': issueReportsHandler,
   };
 }
 
+function emitText({ intent, result, isJson, successMessage = null }) {
+  const { emit } = loadDomainCli();
+  if (isJson) {
+    emit({ intent, result, isJson, successMessage });
+    return;
+  }
+  if (!result.ok) {
+    emit({ intent, result, isJson, successMessage });
+    return;
+  }
+  if (successMessage) {
+    console.log(successMessage);
+  }
+  const output = typeof result.data === 'string' ? result.data : JSON.stringify(result.data, null, 2);
+  process.stdout.write(output);
+  if (!output.endsWith('\n')) process.stdout.write('\n');
+}
+
+function parseJsonFlag(raw, label) {
+  if (raw === null || raw === undefined) {
+    return { ok: true, value: null };
+  }
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    console.error(`${label}: must be valid JSON`);
+    process.exitCode = 2;
+    return { ok: false, value: null };
+  }
+}
+
+function parseBooleanFlag(raw, label) {
+  if (raw === null || raw === undefined) {
+    return { ok: true, value: null };
+  }
+
+  if (typeof raw === 'boolean') {
+    return { ok: true, value: raw };
+  }
+
+  const normalized = String(raw).trim().toLowerCase();
+  if (['true', '1', 'yes', 'y'].includes(normalized)) {
+    return { ok: true, value: true };
+  }
+  if (['false', '0', 'no', 'n'].includes(normalized)) {
+    return { ok: true, value: false };
+  }
+
+  console.error(`${label}: must be one of true|false|1|0|yes|no`);
+  process.exitCode = 2;
+  return { ok: false, value: null };
+}
+
+function requireOption(value, message) {
+  if (value !== null && value !== undefined && value !== '') {
+    return true;
+  }
+  console.error(message);
+  process.exitCode = 2;
+  return false;
+}
+
+function assignIfDefined(target, key, value) {
+  if (value !== null && value !== undefined) {
+    target[key] = value;
+  }
+}
+
+async function dayrateHandler({ options }) {
+  const { callEndpoint, emit, emitAuthError } = loadDomainCli();
+  const isJson = Boolean(options.json);
+  const sub = options.subcommand;
+  if (sub !== 'config') {
+    console.error('dayrate: unknown subcommand. Supported: config');
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const result = await callEndpoint({ options, method: 'GET', path: '/api/dayrate/admin/config' });
+    emit({ intent: 'dayrate.config', result, isJson });
+    if (!result.ok) process.exitCode = 1;
+  } catch (err) {
+    emitAuthError('dayrate.config', err, isJson);
+    process.exitCode = 1;
+  }
+}
+
+async function emailHandler({ options }) {
+  const { callEndpoint, emit, emitAuthError } = loadDomainCli();
+  const isJson = Boolean(options.json);
+  const sub = options.subcommand;
+
+  try {
+    if (sub === 'send') {
+      if (!requireOption(options.templateKey, 'email send: --template-key is required')) return;
+      if (!requireOption(options.to, 'email send: --to is required')) return;
+
+      const context = parseJsonFlag(options.context, 'email send: --context');
+      if (!context.ok) return;
+
+      const body = {
+        template_key: options.templateKey,
+        to: options.to,
+      };
+      assignIfDefined(body, 'context', context.value);
+      assignIfDefined(body, 'user_id', options.userId);
+      assignIfDefined(body, 'owner_id', options.ownerId);
+      assignIfDefined(body, 'subject_override', options.subjectOverride);
+      assignIfDefined(body, 'body_override', options.bodyOverride);
+
+      const result = await callEndpoint({ options, method: 'POST', path: '/api/email/send', body });
+      emit({ intent: 'email.send', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'get-template') {
+      if (!requireOption(options.templateKey, 'email get-template: --template-key is required')) return;
+      const result = await callEndpoint({
+        options,
+        method: 'GET',
+        path: `/api/email/templates/${encodeURIComponent(options.templateKey)}`,
+      });
+      emit({ intent: 'email.get-template', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'preview') {
+      if (!requireOption(options.templateKey, 'email preview: --template-key is required')) return;
+
+      const context = parseJsonFlag(options.context, 'email preview: --context');
+      if (!context.ok) return;
+
+      const path = `/api/email/templates/${encodeURIComponent(options.templateKey)}/preview`;
+      const result = context.value === null
+        ? await callEndpoint({ options, method: 'GET', path })
+        : await callEndpoint({
+            options,
+            method: 'POST',
+            path,
+            body: { context: context.value },
+          });
+
+      emitText({ intent: 'email.preview', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'logs') {
+      const query = {};
+      if (options.ownerId) query.owner_id = options.ownerId;
+      if (options.userId) query.user_id = options.userId;
+      if (options.limit) query.limit = options.limit;
+      if (options.offset) query.offset = options.offset;
+      const result = await callEndpoint({ options, method: 'GET', path: '/api/email/logs', query });
+      emit({ intent: 'email.logs', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'list-templates') {
+      const result = await callEndpoint({ options, method: 'GET', path: '/api/email/templates' });
+      emit({ intent: 'email.list-templates', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'create-template') {
+      if (!requireOption(options.templateKey, 'email create-template: --template-key is required')) return;
+      if (!requireOption(options.name, 'email create-template: --name is required')) return;
+      if (!requireOption(options.subject, 'email create-template: --subject is required')) return;
+      if (!requireOption(options.htmlBody, 'email create-template: --html-body is required')) return;
+
+      const variables = parseJsonFlag(options.variables, 'email create-template: --variables');
+      if (!variables.ok) return;
+      const sampleContext = parseJsonFlag(options.sampleContext, 'email create-template: --sample-context');
+      if (!sampleContext.ok) return;
+      const isActive = parseBooleanFlag(options.isActive, 'email create-template: --is-active');
+      if (!isActive.ok) return;
+
+      const body = {
+        template_key: options.templateKey,
+        name: options.name,
+        subject: options.subject,
+        html_body: options.htmlBody,
+      };
+      assignIfDefined(body, 'description', options.description);
+      assignIfDefined(body, 'text_body', options.textBody);
+      assignIfDefined(body, 'from_email', options.fromEmail);
+      assignIfDefined(body, 'from_name', options.fromName);
+      assignIfDefined(body, 'reply_to', options.replyTo);
+      assignIfDefined(body, 'variables', variables.value);
+      assignIfDefined(body, 'sample_context', sampleContext.value);
+      assignIfDefined(body, 'is_active', isActive.value);
+      assignIfDefined(body, 'category', options.category);
+
+      const result = await callEndpoint({ options, method: 'POST', path: '/api/email/templates', body });
+      emit({ intent: 'email.create-template', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'update-template') {
+      if (!requireOption(options.templateKey, 'email update-template: --template-key is required')) return;
+
+      const variables = parseJsonFlag(options.variables, 'email update-template: --variables');
+      if (!variables.ok) return;
+      const sampleContext = parseJsonFlag(options.sampleContext, 'email update-template: --sample-context');
+      if (!sampleContext.ok) return;
+      const isActive = parseBooleanFlag(options.isActive, 'email update-template: --is-active');
+      if (!isActive.ok) return;
+
+      const body = {};
+      assignIfDefined(body, 'name', options.name);
+      assignIfDefined(body, 'description', options.description);
+      assignIfDefined(body, 'subject', options.subject);
+      assignIfDefined(body, 'html_body', options.htmlBody);
+      assignIfDefined(body, 'text_body', options.textBody);
+      assignIfDefined(body, 'from_email', options.fromEmail);
+      assignIfDefined(body, 'from_name', options.fromName);
+      assignIfDefined(body, 'reply_to', options.replyTo);
+      assignIfDefined(body, 'variables', variables.value);
+      assignIfDefined(body, 'sample_context', sampleContext.value);
+      assignIfDefined(body, 'is_active', isActive.value);
+      assignIfDefined(body, 'category', options.category);
+
+      if (Object.keys(body).length === 0) {
+        console.error('email update-template: provide at least one field to update');
+        process.exitCode = 2;
+        return;
+      }
+
+      const result = await callEndpoint({
+        options,
+        method: 'PUT',
+        path: `/api/email/templates/${encodeURIComponent(options.templateKey)}`,
+        body,
+      });
+      emit({ intent: 'email.update-template', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'get-override') {
+      if (!requireOption(options.templateKey, 'email get-override: --template-key is required')) return;
+      const result = await callEndpoint({
+        options,
+        method: 'GET',
+        path: `/api/email/templates/${encodeURIComponent(options.templateKey)}/override`,
+      });
+      emit({ intent: 'email.get-override', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'set-override') {
+      if (!requireOption(options.templateKey, 'email set-override: --template-key is required')) return;
+      const body = {};
+      assignIfDefined(body, 'subject_override', options.subjectOverride);
+      assignIfDefined(body, 'body_override', options.bodyOverride);
+      if (Object.keys(body).length === 0) {
+        console.error('email set-override: provide --subject-override and/or --body-override');
+        process.exitCode = 2;
+        return;
+      }
+      const result = await callEndpoint({
+        options,
+        method: 'PUT',
+        path: `/api/email/templates/${encodeURIComponent(options.templateKey)}/override`,
+        body,
+      });
+      emit({ intent: 'email.set-override', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    if (sub === 'clear-override') {
+      if (!requireOption(options.templateKey, 'email clear-override: --template-key is required')) return;
+      const result = await callEndpoint({
+        options,
+        method: 'DELETE',
+        path: `/api/email/templates/${encodeURIComponent(options.templateKey)}/override`,
+      });
+      emit({ intent: 'email.clear-override', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+
+    console.error(
+      'email: unknown subcommand. Supported: send, get-template, preview, logs, list-templates, create-template, update-template, get-override, set-override, clear-override'
+    );
+    process.exitCode = 2;
+  } catch (err) {
+    emitAuthError(`email.${sub || 'unknown'}`, err, isJson);
+    process.exitCode = 1;
+  }
+}
+
+async function policyHandler({ options }) {
+  const { callEndpoint, emit, emitAuthError } = loadDomainCli();
+  const isJson = Boolean(options.json);
+  const sub = options.subcommand;
+  try {
+    if (sub === 'list') {
+      const query = {};
+      if (options.isActive !== null && options.isActive !== undefined) query.is_active = options.isActive;
+      if (options.limit) query.limit = options.limit;
+      const result = await callEndpoint({ options, method: 'GET', path: '/api/policies', query });
+      emit({ intent: 'policy.list', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+    if (sub === 'create') {
+      if (!options.name || !options.effect) {
+        console.error('policy create: --name and --effect are required');
+        process.exitCode = 2;
+        return;
+      }
+      let conditions = {};
+      if (options.conditions) {
+        try { conditions = JSON.parse(options.conditions); }
+        catch { console.error('policy create: --conditions must be valid JSON'); process.exitCode = 2; return; }
+      }
+      const body = {
+        name: options.name,
+        effect: options.effect,
+        conditions,
+        description: options.description || null,
+        priority: options.priority || 0,
+      };
+      const result = await callEndpoint({ options, method: 'POST', path: '/api/policies', body });
+      emit({ intent: 'policy.create', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+    if (sub === 'delete') {
+      if (!options.id) {
+        console.error('policy delete: --id is required');
+        process.exitCode = 2;
+        return;
+      }
+      const result = await callEndpoint({ options, method: 'DELETE', path: `/api/policies/${encodeURIComponent(options.id)}` });
+      emit({ intent: 'policy.delete', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+    console.error('policy: unknown subcommand. Supported: list, create, delete');
+    process.exitCode = 2;
+  } catch (err) {
+    emitAuthError(`policy.${sub || 'unknown'}`, err, isJson);
+    process.exitCode = 1;
+  }
+}
+
+async function webhookHandler({ options }) {
+  const { callEndpoint, emit, emitAuthError } = loadDomainCli();
+  const isJson = Boolean(options.json);
+  const sub = options.subcommand;
+  try {
+    if (sub === 'list') {
+      const result = await callEndpoint({ options, method: 'GET', path: '/api/webhooks' });
+      emit({ intent: 'webhook.list', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+    if (sub === 'register') {
+      if (!options.url || !options.events) {
+        console.error('webhook register: --url and --events (comma-separated) are required');
+        process.exitCode = 2;
+        return;
+      }
+      const events = String(options.events).split(',').map((e) => e.trim()).filter(Boolean);
+      const body = { url: options.url, events };
+      const result = await callEndpoint({ options, method: 'POST', path: '/api/webhooks', body });
+      emit({ intent: 'webhook.register', result, isJson });
+      if (!result.ok) process.exitCode = 1;
+      return;
+    }
+    console.error('webhook: unknown subcommand. Supported: list, register');
+    process.exitCode = 2;
+  } catch (err) {
+    emitAuthError(`webhook.${sub || 'unknown'}`, err, isJson);
+    process.exitCode = 1;
+  }
+}
+
+async function issueReportsHandler({ options }) {
+  const { callEndpoint, emit, emitAuthError } = loadDomainCli();
+  const isJson = Boolean(options.json);
+  const sub = options.subcommand;
+  if (sub !== 'list-mine') {
+    console.error('issue-reports: unknown subcommand. Supported: list-mine');
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const query = {};
+    if (options.status) query.status = options.status;
+    if (options.limit) query.limit = options.limit;
+    if (options.offset) query.offset = options.offset;
+    const result = await callEndpoint({ options, method: 'GET', path: '/api/v1/issue-reports', query });
+    emit({ intent: 'issue-reports.list-mine', result, isJson });
+    if (!result.ok) process.exitCode = 1;
+  } catch (err) {
+    emitAuthError('issue-reports.list-mine', err, isJson);
+    process.exitCode = 1;
+  }
+}
+
 module.exports = { createHandlers };