adapty 0.8.4-beta.1 → 0.8.5

package/dist/lib/asa-keyword-action.js

@@ -0,0 +1,175 @@
+import { isValidUuid } from './flags.js';
+export const ADD_AS_KEYWORD_ACTION = 'add-as-keyword-to';
+export const CPT_BID_TYPES = ['ad_group_default_bid', 'keyword_current_bid', 'search_term_current_cpt', 'set_to'];
+export const KEYWORD_MATCH_TYPES = ['BROAD', 'EXACT'];
+export const NEGATE_TYPES = ['ad-group', 'campaign'];
+const SEARCH_TERM = 'search-term';
+const TARGETING_KEYWORD = 'targeting-keyword';
+const BID_TYPE_IGNORING_VALUE = 'ad_group_default_bid';
+const BID_TYPES_READING_MARKUP = new Set(['keyword_current_bid', 'search_term_current_cpt']);
+// KeywordMatchType also carries AUTO. --match-type never offers it — an automation creates a
+// keyword, and AUTO is not something a keyword can be — but a rule that already stores AUTO keeps
+// it rather than being pushed onto another match type by an edit that never mentioned match types.
+const STORED_MATCH_TYPES = new Set(['AUTO', ...KEYWORD_MATCH_TYPES]);
+const SHARED_FLAGS = ['target-ad-group', 'match-type', 'cpt-bid-type', 'cpt-bid'];
+const SEARCH_TERM_FLAGS = ['negate', 'no-negate', 'skip-enable-duplicates'];
+const TARGETING_KEYWORD_FLAGS = ['pause-original'];
+const ALL_FLAGS = [...SHARED_FLAGS, ...SEARCH_TERM_FLAGS, ...TARGETING_KEYWORD_FLAGS];
+const MISSING_REASONS = {
+    'cpt-bid': 'the bid to set, required by --cpt-bid-type set_to',
+    'cpt-bid-type': 'where the bid of the new keyword comes from; the API has no default',
+    'match-type': 'BROAD or EXACT; the API has no default',
+    'target-ad-group': 'the ad groups the keyword is added to; a rule with none does nothing',
+};
+function dashed(name) {
+    return `--${name}`;
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+}
+function isFlagSet(flags, name) {
+    const value = flags[name];
+    if (value === undefined) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    // --no-negate has no negated form of its own, so only a true means it was passed.
+    return name === 'no-negate' ? value === true : true;
+}
+export function hasAddKeywordActionFlags(flags) {
+    return ALL_FLAGS.some(name => isFlagSet(flags, name));
+}
+// Params are rebuilt, not patched: a rule may store the add-as-negative-keyword shape
+// ({target_type, ids}) under an add-as-keyword-to action, and the API picks the params variant by
+// shape without a discriminator — so every stray key silently changes which action gets run.
+// Only what fits the expected shape is carried over; the rest has to come from the flags.
+function storedInternalIds(params) {
+    const ids = asRecord(params.targets).internal_ids;
+    return Array.isArray(ids) ? ids.filter((id) => typeof id === 'string' && isValidUuid(id)) : [];
+}
+function storedMatchType(params) {
+    const matchType = params.match_type;
+    return typeof matchType === 'string' && STORED_MATCH_TYPES.has(matchType) ? matchType : undefined;
+}
+function storedCptBidType(params) {
+    const { type } = asRecord(params.cpt_bid);
+    return typeof type === 'string' && CPT_BID_TYPES.includes(type) ? type : undefined;
+}
+function storedCptBidValue(params) {
+    const { value } = asRecord(params.cpt_bid);
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function storedBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function storedNegate(params) {
+    const { enabled, type } = asRecord(params.negate);
+    if (typeof enabled !== 'boolean') {
+        return undefined;
+    }
+    if (type === null || type === undefined) {
+        return { enabled, type: null };
+    }
+    return typeof type === 'string' && NEGATE_TYPES.includes(type) ? { enabled, type } : undefined;
+}
+function resolveNegate(flags, params) {
+    if (flags.negate !== undefined) {
+        return { enabled: true, type: flags.negate };
+    }
+    if (flags['no-negate'] === true) {
+        return { enabled: false, type: null };
+    }
+    return storedNegate(params) ?? { enabled: false, type: null };
+}
+function resolveCptBidValue(cptBidType, bid, params) {
+    if (cptBidType === 'set_to') {
+        return bid === undefined ? storedCptBidValue(params) : Number(bid);
+    }
+    if (cptBidType !== undefined && BID_TYPES_READING_MARKUP.has(cptBidType)) {
+        return bid === undefined ? (storedCptBidValue(params) ?? null) : Number(bid);
+    }
+    return null;
+}
+function isSearchTermRule(operateWith) {
+    if (operateWith === SEARCH_TERM) {
+        return true;
+    }
+    if (operateWith === TARGETING_KEYWORD) {
+        return false;
+    }
+    const shown = typeof operateWith === 'string' && operateWith.length > 0 ? `"${operateWith}"` : 'missing';
+    throw new Error(`${ADD_AS_KEYWORD_ACTION} runs on a "${SEARCH_TERM}" or "${TARGETING_KEYWORD}" rule only; this rule's operate_with is ${shown}.`);
+}
+function rejectForeignFlags(searchTerm, flags) {
+    const foreign = (searchTerm ? TARGETING_KEYWORD_FLAGS : SEARCH_TERM_FLAGS).filter(name => isFlagSet(flags, name));
+    if (foreign.length === 0) {
+        return;
+    }
+    const applicable = [...SHARED_FLAGS, ...(searchTerm ? SEARCH_TERM_FLAGS : TARGETING_KEYWORD_FLAGS)];
+    throw new Error(`${foreign.map(name => dashed(name)).join(', ')} ${foreign.length === 1 ? 'has' : 'have'} no place in the params of an `
+        + `operate_with "${searchTerm ? SEARCH_TERM : TARGETING_KEYWORD}" rule, and the API drops params it cannot `
+        + `place. Applicable action flags: ${applicable.map(name => dashed(name)).join(', ')}.`);
+}
+function missingFlagsError(missing) {
+    const lines = missing.map(name => `  ${dashed(name)} — ${MISSING_REASONS[name]}`);
+    return new Error(`The ${ADD_AS_KEYWORD_ACTION} params are incomplete. Pass:\n${lines.join('\n')}`);
+}
+export function buildAddKeywordParams(operateWith, stored, flags) {
+    const searchTerm = isSearchTermRule(operateWith);
+    rejectForeignFlags(searchTerm, flags);
+    const params = asRecord(stored);
+    const missing = [];
+    const internalIds = flags['target-ad-group'] ?? storedInternalIds(params);
+    if (internalIds.length === 0) {
+        missing.push('target-ad-group');
+    }
+    const matchType = flags['match-type'] ?? storedMatchType(params);
+    if (matchType === undefined) {
+        missing.push('match-type');
+    }
+    const cptBidType = flags['cpt-bid-type'] ?? storedCptBidType(params);
+    if (cptBidType === undefined) {
+        missing.push('cpt-bid-type');
+    }
+    const bid = flags['cpt-bid'];
+    if (bid !== undefined && cptBidType === BID_TYPE_IGNORING_VALUE) {
+        throw new Error(`--cpt-bid has no meaning with --cpt-bid-type ${BID_TYPE_IGNORING_VALUE}; that type copies the target ad group's default bid.`);
+    }
+    const cptBidValue = resolveCptBidValue(cptBidType, bid, params);
+    if (cptBidValue === undefined) {
+        missing.push('cpt-bid');
+    }
+    if (missing.length > 0) {
+        throw missingFlagsError(missing);
+    }
+    const built = {
+        cpt_bid: { type: cptBidType, value: cptBidValue ?? null },
+        match_type: matchType,
+        targets: { internal_ids: internalIds, type: 'ad-group' },
+    };
+    if (searchTerm) {
+        built.negate = resolveNegate(flags, params);
+        built.skip_enable_duplicate_keywords
+            = flags['skip-enable-duplicates'] ?? storedBoolean(params.skip_enable_duplicate_keywords) ?? false;
+    }
+    else {
+        built.pause_in_original_ad_group
+            = flags['pause-original'] ?? storedBoolean(params.pause_in_original_ad_group) ?? false;
+    }
+    return built;
+}
+export function requireSingleAction(actions) {
+    if (!Array.isArray(actions) || actions.length !== 1) {
+        throw new Error('A rule needs exactly one action: the API stores one action and one condition per rule.');
+    }
+    return asRecord(actions[0]);
+}
+export function rebuildAddKeywordAction(actions, operateWith, flags) {
+    const action = requireSingleAction(actions);
+    if (action.type !== ADD_AS_KEYWORD_ACTION) {
+        throw new Error(`The action flags only apply to an ${ADD_AS_KEYWORD_ACTION} action; this rule's action is "${String(action.type)}".`);
+    }
+    return [{ ...action, params: buildAddKeywordParams(operateWith, action.params, flags) }];
+}

package/dist/lib/asa-schemas.d.ts

@@ -4,11 +4,11 @@ export type AsaKeywordMatchType = 'BROAD' | 'EXACT';
 export type AsaKeywordStatus = 'ACTIVE' | 'PAUSED';
 export type AsaStatus = 'ENABLED' | 'PAUSED';
 export type AsaNegativeKeywordScope = 'AD_GROUP' | 'ALL_CAMPAIGN_AD_GROUPS' | 'CAMPAIGN';
-export interface AsaMoney {
+export type AsaMoney = {
     amount: string;
     currency: string;
-}
-export interface AsaMetricsDTO {
+};
+export type AsaMetricsDTO = {
     avg_cpm: string;
     avg_cpt: string;
     impressions: number;
@@ -29,16 +29,36 @@ export interface AsaMetricsDTO {
     view_installs: number;
     view_new_downloads: number;
     view_redownloads: number;
-}
-export interface AsaMeDTO {
+};
+export type AsaMetricsResponse = {
+    data: Record<string, unknown>[];
+    meta: {
+        max_valid_day?: number;
+        pagination: {
+            count: number;
+            page: number;
+            pages: number;
+        };
+    };
+};
+export type AsaEffectiveLimitsDTO = {
+    keywords_read_limit_per_minute: number;
+    max_breakdown_rows_per_page: number;
+    metrics_burst_limit: number;
+    metrics_inflight_limit: number;
+    metrics_limit_per_minute: number;
+    read_limit_per_minute: number;
+};
+export type AsaMeDTO = {
     access_source: AsaAccessSource;
     apple_credentials_status: AsaAppleCredentialsStatus;
     company_id: string;
-}
-export interface AsaAppleOAuthDTO {
+    limits?: AsaEffectiveLimitsDTO;
+};
+export type AsaAppleOAuthDTO = {
     auth_url: string;
-}
-export interface AsaAppDTO {
+};
+export type AsaAppDTO = {
     adam_id: number;
     bundle_id: null | string;
     campaign_group_ids: string[];
@@ -47,15 +67,15 @@ export interface AsaAppDTO {
     internal_id: string;
     last_synced_at: string;
     name: string;
-}
-export interface AsaLocInvoiceDetails {
+};
+export type AsaLocInvoiceDetails = {
     billing_contact_email: null | string;
     buyer_email: null | string;
     buyer_name: null | string;
     client_name: null | string;
     order_number: null | string;
-}
-export interface AsaCampaignGroupDTO {
+};
+export type AsaCampaignGroupDTO = {
     currency: string;
     internal_id: string;
     last_synced_at: string;
@@ -64,8 +84,8 @@ export interface AsaCampaignGroupDTO {
     parent_org_id: number;
     payment_model: null | string;
     time_zone: string;
-}
-export interface AsaCampaignDTO {
+};
+export type AsaCampaignDTO = {
     ad_channel_type: string;
     adam_id: number;
     app_id: string;
@@ -88,8 +108,8 @@ export interface AsaCampaignDTO {
     status: AsaStatus;
     supply_sources: string[];
     target_cpa: AsaMoney | null;
-}
-export interface AsaAdGroupDTO {
+};
+export type AsaAdGroupDTO = {
     ad_group_id: number;
     app_id: string;
     automated_keywords_opt_in: boolean | null;
@@ -109,8 +129,8 @@ export interface AsaAdGroupDTO {
     start_time: null | string;
     status: AsaStatus | null;
     target_cpa: AsaMoney | null;
-}
-export interface AsaKeywordDTO {
+};
+export type AsaKeywordDTO = {
     ad_group_id: string;
     app_id: string;
     bid_amount: AsaMoney;
@@ -122,8 +142,8 @@ export interface AsaKeywordDTO {
     match_type: AsaKeywordMatchType;
     status: AsaKeywordStatus | null;
     text: string;
-}
-export interface AsaSearchTermDTO {
+};
+export type AsaSearchTermDTO = {
     ad_group_id: string;
     app_id: string;
     campaign_group_id: string;
@@ -136,8 +156,8 @@ export interface AsaSearchTermDTO {
     search_popularity: null | number;
     source: null | string;
     text: null | string;
-}
-export interface AsaNegativeKeywordDTO {
+};
+export type AsaNegativeKeywordDTO = {
     ad_group_id: null | string;
     ad_group_name: null | string;
     campaign_id: string;
@@ -147,8 +167,8 @@ export interface AsaNegativeKeywordDTO {
     match_type: AsaKeywordMatchType;
     status: AsaKeywordStatus;
     text: string;
-}
-export interface AsaCreativeDTO {
+};
+export type AsaCreativeDTO = {
     adam_id: number;
     app_id: string;
     campaign_group_id: string;
@@ -160,8 +180,8 @@ export interface AsaCreativeDTO {
     state: string;
     state_reasons: string[];
     type: string;
-}
-export interface AsaProductPageDTO {
+};
+export type AsaProductPageDTO = {
     adam_id: number;
     app_id: string;
     deep_link: null | string;
@@ -172,8 +192,8 @@ export interface AsaProductPageDTO {
     last_synced_at: string;
     name: string;
     state: string;
-}
-export interface AsaAdDTO {
+};
+export type AsaAdDTO = {
     ad_group_id: string;
     ad_group_name: null | string;
     ad_id: number;
@@ -191,8 +211,8 @@ export interface AsaAdDTO {
     serving_state_reasons: string[];
     serving_status: string;
     status: AsaStatus;
-}
-export interface AsaAutomationDTO {
+};
+export type AsaAutomationDTO = {
     actions: unknown[];
     apply_to: unknown[];
     conditions: unknown[];
@@ -206,46 +226,46 @@ export interface AsaAutomationDTO {
     run_frequency: Record<string, unknown>;
     status: number;
     updated_at: string;
-}
-export interface AsaAutomationRunDTO {
+};
+export type AsaAutomationRunDTO = {
     [key: string]: unknown;
     id?: string;
-}
-export interface AsaAutomationRunEnqueuedDTO {
+};
+export type AsaAutomationRunEnqueuedDTO = {
     automation_id: string;
     dry_run: boolean;
     run_id: null | string;
-}
-export interface AsaProductPageSyncDTO {
+};
+export type AsaProductPageSyncDTO = {
     accepted_at: string;
     message: string;
     org_targets: number;
     replayed: boolean;
     state: string;
     sync_id: string;
-}
-export interface AsaCompetitorTopAppDTO {
+};
+export type AsaCompetitorTopAppDTO = {
     adamId: number;
     avgSov: string;
     countries: string[];
     iconUrl: null | string;
     name: null | string;
     termsCount: number;
-}
-export interface AsaCompetitorContestedTermDTO {
+};
+export type AsaCompetitorContestedTermDTO = {
     competitorCount: number;
     maxSov: string;
     term: string;
-}
-export interface AsaCompetitorsSummaryTotalDTO {
+};
+export type AsaCompetitorsSummaryTotalDTO = {
     competitorsCount: number;
     countriesAsaCount: number;
     countriesWithAsaTerms: number;
     mostContestedTerms: AsaCompetitorContestedTermDTO[];
     topAppsByPerformance: AsaCompetitorTopAppDTO[];
     totalUniqueTerms: number;
-}
-export interface AsaCompetitorAppTermsDTO {
+};
+export type AsaCompetitorAppTermsDTO = {
     adamId: number;
     countries: Record<string, {
         sov: string;
@@ -253,12 +273,12 @@ export interface AsaCompetitorAppTermsDTO {
     }[]>;
     iconUrl: null | string;
     name: null | string;
-}
-export interface AsaCompetitorsSummaryDTO {
+};
+export type AsaCompetitorsSummaryDTO = {
     byApps: AsaCompetitorAppTermsDTO[];
     total: AsaCompetitorsSummaryTotalDTO;
-}
-export interface AsaMutationError {
+};
+export type AsaMutationError = {
     apple_error_code?: null | string;
     apple_error_message?: null | string;
     entity_type?: string;
@@ -267,12 +287,12 @@ export interface AsaMutationError {
     retryable?: boolean;
     validation_error_code?: string;
     validation_error_message?: string;
-}
-export interface AsaCampaignMutationDTO {
+};
+export type AsaCampaignMutationDTO = {
     campaign: AsaCampaignMutationEntity | null;
     errors: AsaMutationError[];
-}
-export interface AsaCampaignMutationEntity {
+};
+export type AsaCampaignMutationEntity = {
     campaign_group_id: string;
     campaign_id: number;
     internal_id: string;
@@ -282,39 +302,39 @@ export interface AsaCampaignMutationEntity {
     serving_state_reasons: null | string[];
     serving_status: null | string;
     status: AsaStatus;
-}
-export interface AsaAdGroupMutationDTO {
+};
+export type AsaAdGroupMutationDTO = {
     ad_group: null | Record<string, unknown>;
     errors: AsaMutationError[];
-}
-export interface AsaAdMutationDTO {
+};
+export type AsaAdMutationDTO = {
     ad: AsaAdDTO | null;
     errors: AsaMutationError[];
-}
-export interface AsaKeywordMutationDTO {
+};
+export type AsaKeywordMutationDTO = {
     errors: AsaMutationError[];
     is_validation_failure: boolean;
     keywords: Record<string, unknown>[];
-}
-export interface AsaNegativeKeywordMutationDTO {
+};
+export type AsaNegativeKeywordMutationDTO = {
     errors: AsaMutationError[];
     is_validation_failure: boolean;
     negative_keywords: Record<string, unknown>[];
-}
-export interface AsaAutomationMutationDTO {
+};
+export type AsaAutomationMutationDTO = {
     automation: AsaAutomationDTO | null;
-}
+};
 export type AsaBulkOperationStatus = 'failed' | 'partial' | 'pending' | 'running' | 'success';
-export interface AsaBulkOperationAcceptedDTO {
+export type AsaBulkOperationAcceptedDTO = {
     operation_id: string;
-}
-export interface AsaBulkOperationCountsDTO {
+};
+export type AsaBulkOperationCountsDTO = {
     applied: number;
     failed: number;
     pending: number;
     total: number;
-}
-export interface AsaBulkOperationObjectDTO {
+};
+export type AsaBulkOperationObjectDTO = {
     apple_error_code: null | string;
     apple_error_message: null | string;
     entity_kind: string;
@@ -322,8 +342,8 @@ export interface AsaBulkOperationObjectDTO {
     item_ref: string;
     status: string;
     step_type: string;
-}
-export interface AsaBulkOperationStateDTO {
+};
+export type AsaBulkOperationStateDTO = {
     counts: AsaBulkOperationCountsDTO;
     created_at: string;
     finished_at: null | string;
@@ -332,8 +352,8 @@ export interface AsaBulkOperationStateDTO {
     pipelines: Record<string, unknown>[];
     started_at: null | string;
     status: AsaBulkOperationStatus;
-}
-export interface AsaBulkOperationListItemDTO {
+};
+export type AsaBulkOperationListItemDTO = {
     app_id: string;
     created_at: string;
     error: null | string;
@@ -341,21 +361,21 @@ export interface AsaBulkOperationListItemDTO {
     operation_id: string;
     started_at: null | string;
     status: AsaBulkOperationStatus;
-}
-export interface AsaBulkOperationListDTO {
+};
+export type AsaBulkOperationListDTO = {
     items: AsaBulkOperationListItemDTO[];
     limit: number;
     offset: number;
     total: number;
-}
-export interface AsaTemplateIssueDTO {
+};
+export type AsaTemplateIssueDTO = {
     column: null | string;
     message: string;
     row: null | number;
     sheet: null | string;
-}
-export interface AsaBulkConvertResultDTO {
+};
+export type AsaBulkConvertResultDTO = {
     errors: AsaTemplateIssueDTO[];
     request: null | Record<string, unknown>;
     warnings: AsaTemplateIssueDTO[];
-}
+};

package/dist/lib/auth.js

@@ -1,8 +1,9 @@
 import { readConfig } from './config.js';
 export async function resolveToken(configDir) {
     const envToken = process.env.ADAPTY_TOKEN;
-    if (envToken)
+    if (envToken) {
         return envToken;
+    }
     const config = await readConfig(configDir);
     return config.access_token ?? null;
 }

package/dist/lib/client-from-config.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from '@oclif/core';
 import { ApiClient } from './api-client.js';
+import type { Config } from '@oclif/core';
 export declare function buildUserAgent(config: Config): string;
 export declare function createAuthenticatedClient(config: Config): Promise<ApiClient>;

package/dist/lib/client-from-config.js

@@ -6,8 +6,9 @@ export function buildUserAgent(config) {
 }
 export async function createAuthenticatedClient(config) {
     const token = await resolveToken(config.configDir);
-    if (!token)
+    if (!token) {
         throw new AuthRequiredError();
+    }
     return new ApiClient({
         token,
         userAgent: buildUserAgent(config),

package/dist/lib/config.d.ts

@@ -1,9 +1,9 @@
-export interface AdaptyConfig {
+export type AdaptyConfig = {
     access_token?: string;
     user?: {
         email: string;
         name: string;
     };
-}
+};
 export declare function readConfig(configDir?: string): Promise<AdaptyConfig>;
 export declare function writeConfig(config: AdaptyConfig, configDir?: string): Promise<void>;

package/dist/lib/confirm.d.ts

@@ -1,18 +1,18 @@
-import { Command } from '@oclif/core';
+import type { Command } from '@oclif/core';
 export declare const confirmFlags: {
     yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
 export type ConfirmDecision = 'ask' | 'proceed' | 'refuse';
 export declare function decideConfirmation(opts: {
-    isTty: boolean;
+    isTty: boolean | undefined;
     json: boolean;
     yes: boolean;
 }): ConfirmDecision;
-export interface MutationPreview {
+export type MutationPreview = {
     body?: unknown;
     method: string;
     path: string;
     summary: string;
-}
+};
 export declare function renderPreview(preview: MutationPreview): string;
 export declare function confirmMutation(command: Command, preview: MutationPreview, yes: boolean): Promise<void>;

package/dist/lib/confirm.js

@@ -1,5 +1,5 @@
-import { Flags } from '@oclif/core';
 import { createInterface } from 'node:readline/promises';
+import { Flags } from '@oclif/core';
 export const confirmFlags = {
     yes: Flags.boolean({
         char: 'y',
@@ -7,22 +7,26 @@ export const confirmFlags = {
     }),
 };
 export function decideConfirmation(opts) {
-    if (opts.yes)
+    if (opts.yes) {
         return 'proceed';
-    if (opts.json || !opts.isTty)
+    }
+    if (opts.json || !opts.isTty) {
         return 'refuse';
+    }
     return 'ask';
 }
 export function renderPreview(preview) {
     const lines = [preview.summary, `${preview.method} ${preview.path}`];
-    if (preview.body !== undefined)
+    if (preview.body !== undefined) {
         lines.push(JSON.stringify(preview.body, null, 2));
+    }
     return lines.join('\n');
 }
 export async function confirmMutation(command, preview, yes) {
-    const decision = decideConfirmation({ isTty: process.stdin.isTTY === true, json: command.jsonEnabled(), yes });
-    if (decision === 'proceed')
+    const decision = decideConfirmation({ isTty: process.stdin.isTTY, json: command.jsonEnabled(), yes });
+    if (decision === 'proceed') {
         return;
+    }
     if (decision === 'refuse') {
         const reason = `${preview.summary} changes your account. Re-run with --yes to apply it without a prompt.`;
         process.stderr.write(`${reason}\n${renderPreview(preview)}\n`);
@@ -32,8 +36,9 @@ export async function confirmMutation(command, preview, yes) {
     const reader = createInterface({ input: process.stdin, output: process.stderr });
     try {
         const answer = await reader.question('Apply? [y/N] ');
-        if (!/^y(es)?$/i.test(answer.trim()))
+        if (!/^y(es)?$/i.test(answer.trim())) {
             command.error('Cancelled, nothing was sent.', { exit: 1 });
+        }
     }
     finally {
         reader.close();