spaps 0.7.5 → 0.7.7

package/src/handlers.js

@@ -7,6 +7,7 @@ const { showInteractiveDocs, showQuickReference, searchDocs } = require('./docs-
 const { getQuickStartInstructions, getServerStatus, runQuickTest } = require('./ai-helper');
 const { buildToolSpec } = require('./ai-tool-spec');
 const { runDoctor } = require('./doctor');
+const { buildHomeView, renderHomeView } = require('./home-view');
 const {
   applyFixtures,
   exportStorageState,
@@ -20,6 +21,7 @@ const {
   whoamiHandler,
   tokenHandler,
 } = require('./auth/handlers');
+const { callEndpoint, emit, emitAuthError } = require('./domain-cli');
 
 function createHandlers(version, logo) {
   function invalidArgument(message) {
@@ -28,7 +30,54 @@ function createHandlers(version, logo) {
     return error;
   }
 
+  const verifyHandler = async ({ options }) => {
+    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 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);
@@ -127,10 +176,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`;
@@ -305,6 +351,8 @@ function createHandlers(version, logo) {
               port: options.port,
               baseUrl: options.baseUrl,
               version,
+              persona: options.persona,
+              seed: options.seed,
             });
             break;
           case 'reset':
@@ -313,6 +361,7 @@ function createHandlers(version, logo) {
               port: options.port,
               baseUrl: options.baseUrl,
               version,
+              seed: options.seed,
             });
             break;
           case 'storage-state':
@@ -325,6 +374,7 @@ function createHandlers(version, logo) {
               baseUrl: options.baseUrl,
               version,
               persona: options.persona,
+              seed: options.seed,
             });
             break;
           default:
@@ -362,6 +412,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) => {
@@ -410,11 +467,421 @@ function createHandlers(version, logo) {
     doctor: async ({ options }) => {
       await runDoctor({ port: options.port || DEFAULT_PORT, stripe: options.stripe || null, json: options.json });
     },
+    test: verifyHandler,
     login: loginHandler,
     logout: logoutHandler,
     whoami: whoamiHandler,
     token: tokenHandler,
+    dayrate: dayrateHandler,
+    email: emailHandler,
+    policy: policyHandler,
+    webhook: webhookHandler,
+    'issue-reports': issueReportsHandler,
   };
 }
 
+function emitText({ intent, result, isJson, successMessage = null }) {
+  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 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 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 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 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 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 };