@supertokens-plugins/rownd-nodejs 0.2.0 → 0.3.0-beta.0

package/dist/generateAppConfig.js

@@ -0,0 +1,731 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// scripts/generateAppConfig.ts
+var generateAppConfig_exports = {};
+__export(generateAppConfig_exports, {
+  convertRowndConfigToPluginConfig: () => convertRowndConfigToPluginConfig
+});
+module.exports = __toCommonJS(generateAppConfig_exports);
+var fs2 = __toESM(require("fs/promises"));
+var import_node_path2 = require("path");
+
+// scripts/scriptUtils.ts
+var fs = __toESM(require("fs/promises"));
+var import_node_path = require("path");
+var import_yaml = require("yaml");
+var import_zod = require("zod");
+var SCRIPT_DIR = __dirname;
+var ConfigSchema = import_zod.z.object({
+  limit: import_zod.z.preprocess(
+    (value) => value === void 0 ? Number.POSITIVE_INFINITY : value,
+    import_zod.z.union([import_zod.z.literal(Number.POSITIVE_INFINITY), import_zod.z.number().int().positive()])
+  ),
+  checkpoint: import_zod.z.object({
+    file: import_zod.z.string(),
+    resume: import_zod.z.boolean().default(false)
+  }),
+  retry: import_zod.z.object({
+    maxAttempts: import_zod.z.number().int().positive(),
+    initialDelayMs: import_zod.z.number().int().positive()
+  }),
+  rownd: import_zod.z.object({
+    appId: import_zod.z.string(),
+    appKey: import_zod.z.string(),
+    appSecret: import_zod.z.string(),
+    bearerToken: import_zod.z.string().optional(),
+    pageSize: import_zod.z.number().int().positive()
+  }),
+  supertokens: import_zod.z.object({
+    connectionURI: import_zod.z.string(),
+    apiKey: import_zod.z.string().optional(),
+    batchSize: import_zod.z.number().int().positive()
+  }),
+  thirdPartyProviders: import_zod.z.array(
+    import_zod.z.object({
+      thirdPartyId: import_zod.z.string(),
+      name: import_zod.z.string().optional(),
+      clients: import_zod.z.array(
+        import_zod.z.object({
+          clientType: import_zod.z.string().optional(),
+          clientId: import_zod.z.string(),
+          clientSecret: import_zod.z.string().optional(),
+          scope: import_zod.z.array(import_zod.z.string()).optional()
+        })
+      )
+    })
+  ).optional()
+});
+var RowndUserRecordSchema = import_zod.z.looseObject({
+  user_id: import_zod.z.string().optional(),
+  rownd_user: import_zod.z.string().optional(),
+  subject: import_zod.z.string().optional(),
+  state: import_zod.z.string().optional(),
+  auth_level: import_zod.z.string().optional(),
+  data: import_zod.z.looseObject({
+    user_id: import_zod.z.string(),
+    email: import_zod.z.string().optional(),
+    phone_number: import_zod.z.string().optional(),
+    google_id: import_zod.z.string().optional(),
+    apple_id: import_zod.z.string().optional(),
+    first_name: import_zod.z.string().optional(),
+    last_name: import_zod.z.string().optional()
+  }),
+  verified_data: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({}),
+  attributes: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.string())).optional(),
+  groups: import_zod.z.array(import_zod.z.unknown()).optional(),
+  meta: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  connection_map: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var RowndUserListItemSchema = import_zod.z.object({
+  data: RowndUserRecordSchema
+});
+var RowndUsersPageSchema = import_zod.z.object({
+  results: import_zod.z.array(RowndUserRecordSchema).optional(),
+  data: import_zod.z.array(RowndUserListItemSchema).optional(),
+  total_results: import_zod.z.number().optional()
+}).superRefine((value, context) => {
+  if (!value.results && !value.data) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "Rownd API response is missing a results/data array."
+    });
+  }
+});
+function parseConfig(rawConfig, configDir = SCRIPT_DIR) {
+  const parsed = ConfigSchema.parse(rawConfig);
+  const checkpointFile = (0, import_node_path.isAbsolute)(parsed.checkpoint.file) ? parsed.checkpoint.file : (0, import_node_path.resolve)(configDir, parsed.checkpoint.file);
+  return {
+    limit: parsed.limit,
+    checkpoint: {
+      file: checkpointFile,
+      resume: parsed.checkpoint.resume
+    },
+    retry: parsed.retry,
+    rownd: parsed.rownd,
+    supertokens: parsed.supertokens,
+    thirdPartyProviders: parsed.thirdPartyProviders
+  };
+}
+async function loadConfig(configFilePath) {
+  const configFile = await fs.readFile(configFilePath, "utf8");
+  return parseConfig((0, import_yaml.parse)(configFile), (0, import_node_path.dirname)(configFilePath));
+}
+function parseRequiredConfigArg(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--config" || arg === "-c") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      return (0, import_node_path.resolve)(value);
+    }
+  }
+  throw new Error("Missing required --config <path>");
+}
+function hasHelpArg(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+async function fetchWithRetry({
+  url,
+  requestInit,
+  retryConfig,
+  operation
+}) {
+  let lastError;
+  for (let attempt = 1; attempt <= retryConfig.maxAttempts; attempt += 1) {
+    try {
+      const response = await fetch(url, requestInit);
+      if (response.ok || !isRetryableStatus(response.status) || attempt === retryConfig.maxAttempts) {
+        return response;
+      }
+      const responseText = await response.text();
+      lastError = new Error(
+        `${operation} failed with ${response.status}${responseText ? ` ${responseText}` : ""}`
+      );
+    } catch (error) {
+      if (attempt === retryConfig.maxAttempts) {
+        throw error;
+      }
+      lastError = error instanceof Error ? error : new Error(`${operation} failed`);
+    }
+    const delayMs = Math.round(
+      retryConfig.initialDelayMs * 2 ** (attempt - 1) * (1 + Math.random() * 0.2)
+    );
+    console.log(
+      `${operation} attempt ${attempt} failed. Retrying in ${delayMs}ms.`
+    );
+    await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+  }
+  throw lastError ?? new Error(`${operation} failed`);
+}
+
+// scripts/generateAppConfig.ts
+function printHelp() {
+  console.log(`Usage: rownd-nodejs generate-plugin-config --config <path> [options]
+
+Options:
+  -c, --config <path>  Path to the bulk migration config file
+  -o, --output <path>  Destination path for generated plugin config
+  --raw-output <path>  Also write the raw Rownd app config response to this path
+  --include-sub-brands Fetch and include Rownd sub-brands. Requires rownd.bearerToken.
+  -h, --help           Show this help message`);
+}
+function getRowndApiAuthHeaders(config) {
+  if (config.rownd.bearerToken) {
+    return { Authorization: `Bearer ${config.rownd.bearerToken}` };
+  }
+  return {
+    "x-rownd-app-key": config.rownd.appKey,
+    "x-rownd-app-secret": config.rownd.appSecret
+  };
+}
+function convertRowndConfigToPluginConfig(rowndApp, creds) {
+  const config = getObject(rowndApp.config);
+  const customizations = getObject(config.customizations);
+  const hub = getObject(config.hub);
+  const hubCustomizations = getObject(hub.customizations);
+  const hubAuth = getObject(hub.auth);
+  const legal = getObject(hub.legal);
+  const customContent = getObject(hub.custom_content);
+  const profile = getObject(hub.profile);
+  const instructions = [];
+  const authTokens = getObject(getObject(config.auth).access_tokens);
+  const appConfig = {
+    id: getString(rowndApp.id),
+    name: getString(rowndApp.name),
+    icon: getString(rowndApp.icon),
+    userVerificationFields: parseStringArray(rowndApp.user_verification_fields),
+    branding: {
+      primaryColor: getString(customizations.primary_color),
+      primaryColorDarkMode: getString(
+        hubCustomizations.primary_color_dark_mode
+      ),
+      logo: getString(customizations.logo),
+      logoDarkMode: getString(customizations.logo_dark_mode),
+      animations: getOptionalObject(customizations.animations),
+      roundedCorners: getBoolean(hubCustomizations.rounded_corners),
+      containerBorderRadius: getNumber(
+        hubCustomizations.container_border_radius
+      ),
+      placement: getString(hubCustomizations.placement),
+      hubPrimaryColor: getString(hubCustomizations.primary_color),
+      backgroundColor: getString(hubCustomizations.background_color),
+      fontFamily: getString(hubCustomizations.font_family),
+      hideVerificationIcons: getBoolean(
+        hubCustomizations.hide_verification_icons
+      ),
+      visualSwoops: getBoolean(hubCustomizations.visual_swoops),
+      blurBackground: getBoolean(hubCustomizations.blur_background),
+      blurBackgroundOpacity: getNumber(
+        hubCustomizations.blur_background_opacity
+      ),
+      offsetX: getNumber(hubCustomizations.offset_x),
+      offsetY: getNumber(hubCustomizations.offset_y),
+      propertyOverrides: getOptionalObject(hubCustomizations.property_overrides),
+      darkMode: parseDarkMode(hubCustomizations.dark_mode),
+      showAppIcon: getBoolean(hubAuth.show_app_icon),
+      customScripts: parseCustomScripts(hub.custom_scripts),
+      customStyles: parseCustomStyles(hub.custom_styles)
+    },
+    capabilities: getOptionalObject(config.capabilities),
+    web: getOptionalObject(config.web),
+    bottomSheet: getOptionalObject(config.bottom_sheet),
+    profileStorageVersion: getString(config.profile_storage_version),
+    allowedWebOrigins: parseStringArray(hub.allowed_web_origins),
+    legal: {
+      companyName: getString(legal.company_name),
+      privacyPolicyUrl: getString(legal.privacy_policy_url),
+      termsConditionsUrl: getString(legal.terms_conditions_url),
+      supportEmail: getString(legal.support_email)
+    },
+    customContent: {
+      signInModal: isRecord(customContent.sign_in_modal) ? {
+        title: getString(customContent.sign_in_modal.title),
+        subtitle: getString(customContent.sign_in_modal.subtitle),
+        signInTitle: getString(customContent.sign_in_modal.sign_in_title),
+        signUpTitle: getString(customContent.sign_in_modal.sign_up_title),
+        signInSubtitle: getString(
+          customContent.sign_in_modal.sign_in_subtitle
+        ),
+        signUpSubtitle: getString(
+          customContent.sign_in_modal.sign_up_subtitle
+        ),
+        signInButton: getString(customContent.sign_in_modal.sign_in_button),
+        signUpButton: getString(customContent.sign_in_modal.sign_up_button)
+      } : void 0,
+      profileModal: isRecord(customContent.profile_modal) ? { title: getString(customContent.profile_modal.title) } : void 0,
+      verificationModal: isRecord(customContent.verification_modal) ? {
+        title: getString(customContent.verification_modal.title),
+        subtitle: getString(customContent.verification_modal.subtitle)
+      } : void 0,
+      signInFailureModal: isRecord(customContent.sign_in_failure_modal) ? {
+        failureMessage: getString(
+          customContent.sign_in_failure_modal.failure_message
+        )
+      } : void 0,
+      noAccountMessage: isRecord(customContent.no_account_message) ? { title: getString(customContent.no_account_message.title) } : void 0,
+      mobile: getOptionalObject(customContent.mobile)
+    },
+    profile: {
+      accountInformation: getObject(profile.account_information),
+      personalInformation: getObject(profile.personal_information),
+      preferences: getObject(profile.preferences),
+      signOutButton: getObject(profile.sign_out_button),
+      deleteAccountButton: getObject(profile.delete_account_button),
+      addSignInMethodsButton: getObject(profile.add_sign_in_methods_button)
+    },
+    auth: {
+      additionalFields: parseAdditionalFields(hubAuth.additional_fields),
+      rememberSignInMethod: getBoolean(hubAuth.remember_sign_in_method),
+      useExplicitSignUpFlow: getBoolean(hubAuth.use_explicit_sign_up_flow),
+      allowUnverifiedUsers: getBoolean(hubAuth.allow_unverified_users),
+      email: parseAuthEmailConfig(hubAuth.email),
+      mobile: parseAuthMobileConfig(hubAuth.mobile),
+      primarySignUpMethod: getString(hubAuth.primary_sign_up_method),
+      preferredMethod: getString(hubAuth.preferred_method),
+      order: parseAuthOrder(hubAuth.order)
+    },
+    signInMethods: (() => {
+      const methods = getObject(hubAuth.sign_in_methods);
+      const instantUser = getObject(hubAuth.instant_user);
+      const result = [];
+      for (const [key, value] of Object.entries(methods)) {
+        if (!value || !value.enabled) continue;
+        if (key === "google") {
+          result.push({
+            method: "google",
+            clientId: value.client_id,
+            iosClientId: value.ios_client_id,
+            scopes: value.scopes,
+            signInFasterWithGoogle: parseSignInFasterWithGoogle(
+              value.sign_in_faster_with_google
+            ),
+            oneTap: value.one_tap ? {
+              browser: value.one_tap.browser ? {
+                autoPrompt: value.one_tap.browser.auto_prompt,
+                delay: value.one_tap.browser.delay
+              } : void 0,
+              mobileApp: value.one_tap.mobile_app ? {
+                autoPrompt: value.one_tap.mobile_app.auto_prompt,
+                delay: value.one_tap.mobile_app.delay
+              } : void 0
+            } : void 0
+          });
+          instructions.push(
+            `Google sign-in was enabled. Please ensure you configure the "google" provider in your SuperTokens ThirdParty recipe. You will need to manually provide the Google 'clientSecret' as Rownd cannot export it.`
+          );
+        } else if (key === "apple") {
+          result.push({
+            method: "apple",
+            clientId: value.client_id
+          });
+          instructions.push(
+            `Apple sign-in was enabled. Please ensure you configure the "apple" provider in your SuperTokens ThirdParty recipe. You will need to manually provide the Apple 'clientSecret' (or private key) as Rownd cannot export it.`
+          );
+        } else if (key === "email" || key === "phone") {
+          result.push({ method: key });
+          instructions.push(
+            `${key} sign-in was enabled. Please ensure you configure the SuperTokens Passwordless recipe with the appropriate contactMethod.`
+          );
+        } else if (key === "anonymous") {
+          result.push({
+            method: "anonymous",
+            type: parseAnonymousType(value.type) ?? "guest",
+            displayName: value.display_name,
+            iconLightUrl: value.icon_light_url,
+            iconDarkUrl: value.icon_dark_url
+          });
+        } else {
+          result.push({
+            method: key,
+            displayName: value.display_name,
+            iconLightUrl: value.icon_light_url,
+            iconDarkUrl: value.icon_dark_url
+          });
+          instructions.push(
+            `Custom provider '${key}' was enabled. Please ensure you configure this provider in your SuperTokens ThirdParty recipe. You will need to manually provide the 'clientSecret' as Rownd cannot export it.`
+          );
+        }
+      }
+      if (!methods.anonymous?.enabled && getBoolean(instantUser.enabled)) {
+        result.push({
+          method: "anonymous",
+          type: "instant"
+        });
+      }
+      return result;
+    })()
+  };
+  const cleanSchema = {};
+  if (isRecord(rowndApp.schema)) {
+    for (const [key, field] of Object.entries(
+      rowndApp.schema
+    )) {
+      cleanSchema[key] = {
+        display_name: field.display_name,
+        type: field.type,
+        user_visible: field.user_visible,
+        owned_by: field.owned_by,
+        read_only: field.read_only,
+        show_empty: field.show_empty
+      };
+      const schemaField = cleanSchema[key];
+      if (schemaField) {
+        for (const fieldKey of Object.keys(schemaField)) {
+          if (schemaField[fieldKey] === void 0) {
+            delete schemaField[fieldKey];
+          }
+        }
+      }
+    }
+  }
+  const customClaims = getObject(authTokens.custom_claims);
+  for (const [claimName, claimConfig] of Object.entries(
+    customClaims
+  )) {
+    if (claimConfig.source !== "user_profile") {
+      instructions.push(
+        `Custom claim '${claimName}' uses source '${claimConfig.source ?? "unknown"}'. Please configure this claim manually in SuperTokens.`
+      );
+      continue;
+    }
+    if (typeof claimConfig.value !== "string") {
+      instructions.push(
+        `Custom claim '${claimName}' references a non-string user profile field. Please configure this claim manually in SuperTokens.`
+      );
+      continue;
+    }
+    const schemaField = cleanSchema[claimConfig.value];
+    if (!schemaField) {
+      instructions.push(
+        `Custom claim '${claimName}' references user profile field '${claimConfig.value}', but that field was not found in the exported Rownd schema. Please configure this claim manually in SuperTokens.`
+      );
+      continue;
+    }
+    schemaField.include_in_session_claims = true;
+    if (claimName !== claimConfig.value) {
+      schemaField.session_claim_name = claimName;
+    }
+  }
+  const cleanAppConfig = JSON.parse(JSON.stringify(appConfig));
+  return {
+    rowndAppKey: creds.appKey,
+    rowndAppSecret: creds.appSecret,
+    schema: cleanSchema,
+    appConfig: cleanAppConfig,
+    ...instructions.length > 0 ? { _instructions: instructions } : {}
+  };
+}
+function mergeRowndAppWithVariant(rowndApp, variant) {
+  return deepMerge(rowndApp, {
+    name: variant.name,
+    config: variant.config
+  });
+}
+function deepMerge(base, overlay) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existingValue = result[key];
+    if (isRecord(existingValue) && isRecord(value)) {
+      result[key] = deepMerge(existingValue, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function fetchRowndVariants(config) {
+  const url = new URL(
+    `/api/applications/${config.rownd.appId}/variants`,
+    "https://app.rownd.io"
+  );
+  console.log(`Fetching Rownd sub-brands for app_id: ${config.rownd.appId}...`);
+  const response = await fetchWithRetry({
+    url: url.toString(),
+    requestInit: {
+      headers: getRowndApiAuthHeaders(config)
+    },
+    retryConfig: config.retry,
+    operation: "Fetching Rownd sub-brands"
+  });
+  if (!response.ok) {
+    if (response.status === 401 && !config.rownd.bearerToken) {
+      throw new Error(
+        "Rownd variants API returned 401. Add rownd.bearerToken to config.yaml; this endpoint requires Rownd API bearer authorization."
+      );
+    }
+    throw new Error(
+      `Rownd variants API error: ${response.status} ${await response.text()}`
+    );
+  }
+  const rawVariants = await response.json();
+  const variants = Array.isArray(rawVariants) ? rawVariants : isRecord(rawVariants) && Array.isArray(rawVariants.results) ? rawVariants.results : [];
+  return variants.flatMap((variant) => {
+    if (!isRecord(variant) || typeof variant.id !== "string") {
+      return [];
+    }
+    return [
+      {
+        id: variant.id,
+        name: getString(variant.name),
+        config: getObject(variant.config)
+      }
+    ];
+  });
+}
+function getObject(value) {
+  return isRecord(value) ? value : {};
+}
+function getOptionalObject(value) {
+  return isRecord(value) ? value : void 0;
+}
+function getString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function getBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function getNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function parseDarkMode(value) {
+  return value === "auto" || value === "light" || value === "dark" ? value : void 0;
+}
+function parseCustomStyles(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.flatMap((entry) => {
+    if (!isRecord(entry) || typeof entry.content !== "string") {
+      return [];
+    }
+    return [{ content: entry.content }];
+  });
+}
+function parseCustomScripts(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.flatMap((entry) => {
+    if (!isRecord(entry) || typeof entry.content !== "string") {
+      return [];
+    }
+    return [{
+      content: entry.content,
+      type: getString(entry.type)
+    }];
+  });
+}
+function parseStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+}
+function parseAuthEmailConfig(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return {
+    fromAddress: getString(value.from_address),
+    image: getString(value.image),
+    subject: getString(value.subject),
+    callToActionText: getString(value.call_to_action_text),
+    verifyTemplate: getString(value.verify_template),
+    customContent: getString(value.custom_content),
+    customClosingContent: getString(value.custom_closing_content)
+  };
+}
+function parseAuthMobileConfig(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return {
+    title: getString(value.title),
+    image: getString(value.image),
+    callToActionText: getString(value.call_to_action_text),
+    hyperlinkText: getString(value.hyperlink_text),
+    hyperlinkRedirectUrl: getString(value.hyperlink_redirect_url),
+    customContent: getString(value.custom_content)
+  };
+}
+function parseAdditionalFields(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function parseAuthOrder(value) {
+  return isRecord(value) ? value : void 0;
+}
+function parseAnonymousType(value) {
+  return value === "guest" || value === "instant" ? value : void 0;
+}
+function parseSignInFasterWithGoogle(value) {
+  return value === "enabled" || value === "disabled" ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function run() {
+  const args = process.argv.slice(2);
+  if (hasHelpArg(args)) {
+    printHelp();
+    return;
+  }
+  const config = await loadConfig(parseRequiredConfigArg(args));
+  if (!config.rownd.appId || !config.rownd.appKey || !config.rownd.appSecret) {
+    throw new Error(
+      "Missing rownd.appId, rownd.appKey, or rownd.appSecret in config.yaml"
+    );
+  }
+  const url = new URL("/hub/app-config", "https://api.rownd.io");
+  url.searchParams.set("app_id", config.rownd.appId);
+  console.log(`Fetching Rownd app config for app_id: ${config.rownd.appId}...`);
+  const response = await fetchWithRetry({
+    url: url.toString(),
+    requestInit: {
+      headers: {
+        "x-rownd-app-key": config.rownd.appKey,
+        "x-rownd-app-secret": config.rownd.appSecret
+      }
+    },
+    retryConfig: config.retry,
+    operation: "Fetching Rownd App Config"
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Rownd API error: ${response.status} ${await response.text()}`
+    );
+  }
+  const rawConfig = await response.json();
+  if (!isRecord(rawConfig) || !isRecord(rawConfig.app)) {
+    throw new Error("Rownd API response is missing the 'app' property.");
+  }
+  const rawOutputPath = parseRawOutputArg(args);
+  if (rawOutputPath) {
+    const resolvedRawOutputPath = (0, import_node_path2.resolve)(rawOutputPath);
+    await fs2.writeFile(
+      resolvedRawOutputPath,
+      JSON.stringify(rawConfig, null, 2),
+      "utf8"
+    );
+    console.log(`Successfully saved raw Rownd config to ${resolvedRawOutputPath}`);
+  }
+  const pluginConfig = convertRowndConfigToPluginConfig(rawConfig.app, {
+    appKey: config.rownd.appKey,
+    appSecret: config.rownd.appSecret
+  });
+  const subBrands = {};
+  if (hasIncludeSubBrandsArg(args)) {
+    const variants = await fetchRowndVariants(config);
+    for (const variant of variants) {
+      const variantPluginConfig = convertRowndConfigToPluginConfig(
+        mergeRowndAppWithVariant(rawConfig.app, variant),
+        {
+          appKey: config.rownd.appKey,
+          appSecret: config.rownd.appSecret
+        }
+      );
+      if (!variantPluginConfig.appConfig) {
+        continue;
+      }
+      subBrands[variant.id] = {
+        ...variantPluginConfig.appConfig,
+        variant: {
+          id: variant.id,
+          name: variant.name,
+          config: variant.config
+        }
+      };
+      if (variantPluginConfig._instructions) {
+        pluginConfig._instructions = [
+          ...pluginConfig._instructions ?? [],
+          ...variantPluginConfig._instructions.map(
+            (instruction) => `Sub-brand ${variant.id}: ${instruction}`
+          )
+        ];
+      }
+    }
+  }
+  if (Object.keys(subBrands).length > 0) {
+    pluginConfig.subBrands = subBrands;
+  }
+  if (pluginConfig._instructions) {
+    console.warn("\n=== IMPORTANT INSTRUCTIONS ===");
+    pluginConfig._instructions.forEach((inst) => console.warn(`- ${inst}`));
+    console.warn("==============================\n");
+  }
+  delete pluginConfig._instructions;
+  const outputPath = (0, import_node_path2.resolve)(parseOutputArg(args));
+  await fs2.writeFile(outputPath, JSON.stringify(pluginConfig, null, 2), "utf8");
+  console.log(`Successfully generated config and saved to ${outputPath}`);
+}
+function parseOutputArg(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--output" || arg === "-o") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      return value;
+    }
+  }
+  return "rownd-plugin-config.json";
+}
+function parseRawOutputArg(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--raw-output") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      return value;
+    }
+  }
+  return void 0;
+}
+function hasIncludeSubBrandsArg(args) {
+  return args.includes("--include-sub-brands");
+}
+if (require.main === module) {
+  run().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertRowndConfigToPluginConfig
+});