arcane-os 0.15.2 → 0.16.0

package/src/mail.mjs

@@ -20,65 +20,38 @@ export const MAIL_COMMAND_ACTIONS=[
 
 const ACTION_SET=new Set(MAIL_COMMAND_ACTIONS);
 
-function usage(message){
+function throwMailUsageError(message){
     throw new ArcaneError(ERROR_CODES.usage,message);
 }
 
-function validateOptions(options){
+function validateMailCommandOptions(options){
     if(!options||!is.object(options)||is.array(options)){
-        usage('Mail command options must be an object.');
+        throwMailUsageError('Mail command options must be an object.');
     }
     if(!is.string(options.action)||!ACTION_SET.has(options.action)){
-        usage(`Mail action must be one of: ${MAIL_COMMAND_ACTIONS.join(', ')}.`);
+        throwMailUsageError(`Mail action must be one of: ${MAIL_COMMAND_ACTIONS.join(', ')}.`);
     }
     return options;
 }
 
-function dependency(options,name,fallback){
+function resolveMailCommandDependency(options,name,fallback){
     const value=options[name]??fallback;
     if(!is.function(value)){
-        usage(`${name} must be a function when supplied.`);
+        throwMailUsageError(`${name} must be a function when supplied.`);
     }
     return value;
 }
 
-function recipientList(value,label){
-    if(value===undefined||value===null||value===''||(is.array(value)&&value.length===0)){
+function mailRecipientOptions(value,label){
+    if(value===undefined||value===null||value===''){
         return [];
     }
-    const entries=is.array(value)
-        ? value
-        : is.string(value)
-            ? value.split(',')
-            : null;
-    if(!entries||entries.length===0){
-        usage(`${label} must contain at least one email address when supplied.`);
-    }
-    const result=entries.map(function normalizeMailRecipient(entry){
-        if(!is.string(entry)||!entry.trim()){
-            usage(`${label} contains an empty email address.`);
-        }
-        return entry.trim();
-    });
-    if(new Set(result.map(function lowercaseRecipient(entry){
-        return entry.toLowerCase();
-    })).size!==result.length){
-        usage(`${label} must not contain duplicate email addresses.`);
-    }
-    return result;
-}
-
-function originList(value){
-    const entries=is.array(value)?value:[value];
-    if(entries.length===0||entries.some(function invalidOrigin(entry){
-        return !is.string(entry)||!entry.trim();
-    })){
-        usage('Mail serve requires at least one exact allowed origin.');
-    }
-    return entries.map(function normalizeAllowedOrigin(entry){return entry.trim();});
+    if(is.array(value))return [...value];
+    if(is.string(value))return value.split(',');
+    throwMailUsageError(`${label} must be an address array or comma-separated string.`);
 }
 
-function credentialOptions(options){
+function mailCredentialOptions(options){
     return {
         profile:options.profile,
         platform:options.platform,
@@ -91,60 +64,40 @@ function credentialOptions(options){
     };
 }
 
-async function setCredential(options){
-    const readSecret=dependency(options,'readSecret',null);
-    const store=dependency(options,'setCredential',setMailCredential);
+async function setMailCredentialFromInput(options){
+    const readSecret=resolveMailCommandDependency(options,'readSecret',null);
+    const store=resolveMailCommandDependency(options,'setCredential',setMailCredential);
     throwIfAborted(options.signal);
     let secret='';
     try{
         secret=await readSecret();
         throwIfAborted(options.signal);
-        return await store({...credentialOptions(options),secret});
+        return await store({...mailCredentialOptions(options),secret});
     }finally{
         secret='';
     }
 }
 
-async function credentialStatus(options){
-    const status=dependency(options,'getCredentialStatus',getMailCredentialStatus);
+async function readMailCredentialStatus(options){
+    const status=resolveMailCommandDependency(options,'getCredentialStatus',getMailCredentialStatus);
     throwIfAborted(options.signal);
-    return status(credentialOptions(options));
+    return status(mailCredentialOptions(options));
 }
 
-async function deleteCredential(options){
-    const remove=dependency(options,'deleteCredential',deleteMailCredential);
+async function deleteMailCredentialProfile(options){
+    const remove=resolveMailCommandDependency(options,'deleteCredential',deleteMailCredential);
     throwIfAborted(options.signal);
-    return remove(credentialOptions(options));
+    return remove(mailCredentialOptions(options));
 }
 
-function withoutMailCredentials(value,seen=new WeakMap()){
-    if(!value||!is.object(value))return value;
-    if(seen.has(value))return seen.get(value);
-    const copy=is.array(value)?[]:{};
-    seen.set(value,copy);
-    for(const [key,entry] of Object.entries(value)){
-        if(key==='apiKey'||key==='appKey')continue;
-        copy[key]=withoutMailCredentials(entry,seen);
-    }
-    return copy;
-}
-
-function completeSendFailure(result){
-    if(!result||!is.object(result)||is.array(result)){
-        return {provider:'resend',result:withoutMailCredentials(result)};
-    }
-    // Complete provider detail remains visible; only credential fields are omitted.
-    return withoutMailCredentials(result);
-}
-
-async function sendMail(options){
-    const readReport=dependency(options,'readReport',null);
-    const readCredential=dependency(options,'readCredential',readMailCredential);
-    const send=dependency(options,'sendMail',sendResendMail);
+async function sendMailFromReport(options){
+    const readReport=resolveMailCommandDependency(options,'readReport',null);
+    const readCredential=resolveMailCommandDependency(options,'readCredential',readMailCredential);
+    const send=resolveMailCommandDependency(options,'sendMail',sendResendMail);
     throwIfAborted(options.signal);
     const report=await readReport();
     throwIfAborted(options.signal);
-    let apiKey=await readCredential(credentialOptions(options));
+    let apiKey=await readCredential(mailCredentialOptions(options));
     if(apiKey===null){
         throw new ArcaneError(
             ERROR_CODES.prerequisiteMissing,
@@ -173,9 +126,11 @@ async function sendMail(options){
             signal:options.signal
         });
         if(result?.classification==='accepted'&&result.status==='accepted'){
-            return withoutMailCredentials(result);
+            return result;
         }
-        const details=completeSendFailure(result);
+        const details=result&&is.object(result)&&!is.array(result)
+            ?result
+            :{provider:'resend',result};
         throw new ArcaneError(
             ERROR_CODES.operationFailed,
             `Resend did not authoritatively accept the mail request (${details.classification||'unknown'}).`,
@@ -186,12 +141,11 @@ async function sendMail(options){
     }
 }
 
-async function serveMail(options){
-    const readCredential=dependency(options,'readCredential',readMailCredential);
-    const readAppKey=dependency(options,'readAppKey',null);
-    const startServer=dependency(options,'startServer',startResendMailServer);
+async function serveMailGateway(options){
+    const readCredential=resolveMailCommandDependency(options,'readCredential',readMailCredential);
+    const startServer=resolveMailCommandDependency(options,'startServer',startResendMailServer);
     throwIfAborted(options.signal);
-    let apiKey=await readCredential(credentialOptions(options));
+    let apiKey=await readCredential(mailCredentialOptions(options));
     if(apiKey===null){
         throw new ArcaneError(
             ERROR_CODES.prerequisiteMissing,
@@ -204,60 +158,46 @@ async function serveMail(options){
             'The configured Resend credential could not be read.'
         );
     }
-    let appKey='';
     try{
         throwIfAborted(options.signal);
-        appKey=await readAppKey();
-        if(!is.string(appKey)||!appKey){
-            throw new ArcaneError(
-                ERROR_CODES.operationFailed,
-                'The local Mail gateway app key could not be read.'
-            );
-        }
-        throwIfAborted(options.signal);
-        const recipientAllowlist=recipientList(options.allowTo,'allowTo');
+        const recipientAllowlist=mailRecipientOptions(options.allowTo,'allowTo');
         const errorRecipients=options.errorTo===undefined
             ? recipientAllowlist
-            : recipientList(options.errorTo,'errorTo');
+            : mailRecipientOptions(options.errorTo,'errorTo');
         return await startServer({
             apiKey,
-            appKey,
             appId:options.appId,
-            allowedOrigins:originList(options.origin),
-            bodyQueueTimeoutMs:options.bodyQueueTimeoutMs,
+            allowedOrigins:options.origin===undefined
+                ?[]
+                :is.array(options.origin)?[...options.origin]:[options.origin],
             bodyTimeoutMs:options.bodyTimeoutMs,
             errorRecipients,
             fetchImpl:options.fetchImpl,
             from:options.from,
-            host:options.host,
-            maxConcurrentBodyReads:options.maxConcurrentBodyReads,
-            maxConcurrentSends:options.maxConcurrentSends,
-            maxQueuedBodyReads:options.maxQueuedBodyReads,
-            maxQueuedSends:options.maxQueuedSends,
+            host:options.host??'0.0.0.0',
             onEvent:options.onEvent,
             port:options.port,
             providerTimeoutMs:options.requestTimeout,
             recipientAllowlist,
             requestIdFactory:options.requestIdFactory,
             retryableDelayMs:options.retryableDelayMs,
-            sendQueueTimeoutMs:options.sendQueueTimeoutMs,
-            signal:options.signal
+            signal:options.signal,
+            verifySubscription:options.verifySubscription
         });
     }finally{
         apiKey='';
-        appKey='';
     }
 }
 
 export async function executeMailCommand(rawOptions={}){
-    const options=validateOptions(rawOptions);
+    const options=validateMailCommandOptions(rawOptions);
     switch(options.action){
-        case 'key-set':return setCredential(options);
-        case 'key-status':return credentialStatus(options);
-        case 'key-delete':return deleteCredential(options);
-        case 'send':return sendMail(options);
-        case 'serve':return serveMail(options);
-        default:usage('Unsupported Mail action.');
+        case 'key-set':return setMailCredentialFromInput(options);
+        case 'key-status':return readMailCredentialStatus(options);
+        case 'key-delete':return deleteMailCredentialProfile(options);
+        case 'send':return sendMailFromReport(options);
+        case 'serve':return serveMailGateway(options);
+        default:throwMailUsageError('Unsupported Mail action.');
     }
 }