@getpara/cli 2.15.0

package/dist/commands/keys/config/ramps.js

@@ -0,0 +1,185 @@
+import { getGlobalOptions, createFormatter, helpText } from "../../../cli.js";
+import { ensureAuthenticated } from "../../../auth/session-manager.js";
+import { resolveConfig } from "../../../config/config-manager.js";
+import { ParaApiClient } from "../../../api/client.js";
+import { CliError } from "../../../core/error-handler.js";
+import { OnRampProvider } from "../../../api/types.js";
+import { text, confirm, p } from "../../../output/prompts.js";
+import { resolveKeyId } from "./categories.js";
+const VALID_PROVIDERS = Object.values(OnRampProvider);
+const MIN_BUY_AMOUNT = 1e-4;
+const MAX_BUY_AMOUNT = 999999;
+function validateProviders(providers) {
+  for (const provider of providers) {
+    if (!VALID_PROVIDERS.includes(provider)) {
+      return `Invalid provider: "${provider}". Valid options: ${VALID_PROVIDERS.join(", ")}`;
+    }
+  }
+  if (providers.length === 0) {
+    return "At least one provider is required.";
+  }
+  return void 0;
+}
+function validateBuyAmount(value) {
+  const num = parseFloat(value);
+  if (isNaN(num)) {
+    return "Default buy amount must be a number.";
+  }
+  if (num < MIN_BUY_AMOUNT || num > MAX_BUY_AMOUNT) {
+    return `Default buy amount must be between ${MIN_BUY_AMOUNT} and ${MAX_BUY_AMOUNT}.`;
+  }
+  return void 0;
+}
+function registerRampsConfigCommand(parent) {
+  parent.command("ramps").description("Configure on/off ramp settings for an API key").argument("[key-id]", "API key ID (prompted if not given)").option("--buy-enabled", "Enable buy").option("--no-buy-enabled", "Disable buy").option("--receive-enabled", "Enable receive").option("--no-receive-enabled", "Disable receive").option("--withdraw-enabled", "Enable withdraw").option("--no-withdraw-enabled", "Disable withdraw").option("--providers <list>", `Comma-separated ordered provider list: ${VALID_PROVIDERS.join(", ")}`).option("--ramp-api-key <key>", "Ramp API key").option("--default-buy-amount <amount>", `Default buy amount (${MIN_BUY_AMOUNT}-${MAX_BUY_AMOUNT})`).option("--default-on-ramp-asset <asset>", "Default on-ramp asset").option("--default-on-ramp-network <network>", "Default on-ramp network").addHelpText(
+    "after",
+    helpText(`Examples:
+  $ para keys config ramps                                    Interactive ramp settings
+  $ para keys config ramps --buy-enabled --no-withdraw-enabled
+  $ para keys config ramps --providers "STRIPE,MOONPAY"       Set provider order
+  $ para keys config ramps --default-buy-amount 100           Set default buy amount`)
+  ).action(async (keyIdArg, cmdOpts, cmd) => {
+    const opts = await getGlobalOptions(cmd);
+    const formatter = createFormatter(opts);
+    const config = await resolveConfig(opts);
+    const session = await ensureAuthenticated(config.environment);
+    if (!config.organizationId || !config.projectId) {
+      throw new CliError(
+        "Organization and project required. Run `para orgs switch` and `para projects switch`, or pass --org and --project."
+      );
+    }
+    const client = new ParaApiClient({
+      environment: config.environment,
+      sessionId: session.sessionId
+    });
+    const { keyId, key } = await resolveKeyId(
+      client,
+      config.organizationId,
+      config.projectId,
+      config.environment,
+      keyIdArg
+    );
+    await runRampsAction(
+      client,
+      config.organizationId,
+      config.projectId,
+      config.environment,
+      keyId,
+      key,
+      formatter,
+      cmdOpts
+    );
+  });
+}
+function hasAnyFlag(flags) {
+  if (!flags) return false;
+  return Object.keys(flags).some((k) => flags[k] !== void 0);
+}
+async function runRampsAction(client, orgId, projectId, environment, keyId, currentKey, formatter, flags) {
+  const updates = {};
+  const isInteractive = !hasAnyFlag(flags);
+  if (flags?.buyEnabled !== void 0) {
+    updates.isBuyEnabled = flags.buyEnabled;
+  } else if (isInteractive) {
+    p.log.info(`Buy: ${currentKey.isBuyEnabled ? "enabled" : "disabled"}`);
+    updates.isBuyEnabled = await confirm("Enable buy?");
+  }
+  if (flags?.receiveEnabled !== void 0) {
+    updates.isReceiveEnabled = flags.receiveEnabled;
+  } else if (isInteractive) {
+    p.log.info(`Receive: ${currentKey.isReceiveEnabled ? "enabled" : "disabled"}`);
+    updates.isReceiveEnabled = await confirm("Enable receive?");
+  }
+  if (flags?.withdrawEnabled !== void 0) {
+    updates.isWithdrawEnabled = flags.withdrawEnabled;
+  } else if (isInteractive) {
+    p.log.info(`Withdraw: ${currentKey.isWithdrawEnabled ? "enabled" : "disabled"}`);
+    updates.isWithdrawEnabled = await confirm("Enable withdraw?");
+  }
+  if (flags?.providers !== void 0) {
+    const providers = flags.providers.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+    const err = validateProviders(providers);
+    if (err) throw new CliError(err);
+    updates.onRampProviders = providers;
+  } else if (isInteractive) {
+    const currentProviders = currentKey.onRampProviders ?? [];
+    p.log.info(`Current providers: ${currentProviders.length ? currentProviders.join(", ") : "(none)"}`);
+    const providersInput = await text("Providers (comma-separated, order matters):", {
+      placeholder: VALID_PROVIDERS.join(", "),
+      initialValue: currentProviders.join(", "),
+      validate: (v) => {
+        if (!v.trim()) return void 0;
+        const providers = v.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+        return validateProviders(providers);
+      }
+    });
+    if (providersInput.trim()) {
+      updates.onRampProviders = providersInput.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+    }
+  }
+  if (flags?.rampApiKey !== void 0) {
+    updates.rampApiKey = flags.rampApiKey;
+  } else if (isInteractive) {
+    p.log.info(`Ramp API key: ${currentKey.rampApiKey ? "(set)" : "(not set)"}`);
+    const rampKey = await text("Ramp API key (empty to skip):", {
+      placeholder: "ramp_..."
+    });
+    if (rampKey.trim()) {
+      updates.rampApiKey = rampKey.trim();
+    }
+  }
+  if (flags?.defaultBuyAmount !== void 0) {
+    const err = validateBuyAmount(flags.defaultBuyAmount);
+    if (err) throw new CliError(err);
+    updates.defaultBuyAmount = flags.defaultBuyAmount;
+  } else if (isInteractive) {
+    p.log.info(`Default buy amount: ${currentKey.defaultBuyAmount ?? "(not set)"}`);
+    const amount = await text("Default buy amount (empty to skip):", {
+      placeholder: "100",
+      initialValue: currentKey.defaultBuyAmount ?? "",
+      validate: (v) => {
+        if (v.trim()) return validateBuyAmount(v.trim());
+      }
+    });
+    if (amount.trim()) {
+      updates.defaultBuyAmount = amount.trim();
+    }
+  }
+  if (flags?.defaultOnRampAsset !== void 0) {
+    updates.defaultOnRampAsset = flags.defaultOnRampAsset;
+  } else if (isInteractive) {
+    p.log.info(`Default on-ramp asset: ${currentKey.defaultOnRampAsset ?? "(not set)"}`);
+    const asset = await text("Default on-ramp asset (empty to skip):", {
+      placeholder: "ETH",
+      initialValue: currentKey.defaultOnRampAsset ?? ""
+    });
+    if (asset.trim()) {
+      updates.defaultOnRampAsset = asset.trim();
+    }
+  }
+  if (flags?.defaultOnRampNetwork !== void 0) {
+    updates.defaultOnRampNetwork = flags.defaultOnRampNetwork;
+  } else if (isInteractive) {
+    p.log.info(`Default on-ramp network: ${currentKey.defaultOnRampNetwork ?? "(not set)"}`);
+    const network = await text("Default on-ramp network (empty to skip):", {
+      placeholder: "ethereum",
+      initialValue: currentKey.defaultOnRampNetwork ?? ""
+    });
+    if (network.trim()) {
+      updates.defaultOnRampNetwork = network.trim();
+    }
+  }
+  if (Object.keys(updates).length === 0) {
+    formatter.info("No changes made.");
+    formatter.flush();
+    return;
+  }
+  await client.updateApiKey(orgId, projectId, environment, keyId, updates);
+  formatter.json({ keyId, updated: updates });
+  formatter.success("Updated ramp settings.");
+  formatter.flush();
+}
+export {
+  registerRampsConfigCommand,
+  runRampsAction
+};

package/dist/commands/keys/config/security.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from 'commander';
+import { ParaApiClient } from '../../../api/client.js';
+import type { ApiKey } from '../../../api/types.js';
+import type { OutputFormatter } from '../../../output/formatter.js';
+interface SecurityFlags {
+    origins?: string;
+    authMethods?: string;
+    sessionLength?: string;
+    transactionPopups?: boolean;
+    ipAllowlist?: string;
+}
+export declare function registerSecurityConfigCommand(parent: Command): void;
+export declare function runSecurityAction(client: ParaApiClient, orgId: string, projectId: string, environment: string, keyId: string, currentKey: ApiKey, formatter: OutputFormatter, flags?: SecurityFlags): Promise<void>;
+export {};
+//# sourceMappingURL=security.d.ts.map

package/dist/commands/keys/config/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../../src/commands/keys/config/security.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAgBpE,UAAU,aAAa;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAyDnE;AAcD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,eAAe,EAC1B,KAAK,CAAC,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CAsLf"}

package/dist/commands/keys/config/security.js

@@ -0,0 +1,212 @@
+import { getGlobalOptions, createFormatter, helpText } from "../../../cli.js";
+import { ensureAuthenticated } from "../../../auth/session-manager.js";
+import { resolveConfig } from "../../../config/config-manager.js";
+import { ParaApiClient } from "../../../api/client.js";
+import { CliError } from "../../../core/error-handler.js";
+import { AuthMethod } from "../../../api/types.js";
+import { text, multiselect, select, confirm, p } from "../../../output/prompts.js";
+import { resolveKeyId } from "./categories.js";
+import {
+  validateOriginUrl,
+  validateAuthMethods,
+  AUTH_METHOD_DISPLAY_VALUES,
+  validateSessionLength,
+  minutesToMs,
+  msToMinutes,
+  SESSION_PRESETS,
+  MIN_SESSION_MINUTES,
+  MAX_SESSION_MINUTES,
+  validateCidrList
+} from "../../../validation/index.js";
+function registerSecurityConfigCommand(parent) {
+  parent.command("security").description("Configure security settings for an API key").argument("[key-id]", "API key ID (prompted if not given)").option("--origins <urls>", "Comma-separated allowed origins (empty string to clear)").option("--auth-methods <methods>", "Comma-separated auth methods: PASSKEY, PASSWORD, PIN (empty to reset)").option("--session-length <minutes>", "Session length in minutes (5-43200)").option("--transaction-popups", "Enable transaction popups").option("--no-transaction-popups", "Disable transaction popups").option("--ip-allowlist <cidrs>", "Comma-separated CIDR blocks (empty string to clear)").addHelpText(
+    "after",
+    helpText(`Examples:
+  $ para keys config security                                          Interactive security settings
+  $ para keys config security abc-123 --origins "https://example.com"  Set allowed origins
+  $ para keys config security --auth-methods "PASSKEY,PIN"             Set auth methods
+  $ para keys config security --session-length 1440                    Set session to 24 hours
+  $ para keys config security --ip-allowlist "10.0.0.0/8"             Set IP allowlist
+  $ para keys config security --ip-allowlist ""                        Clear IP allowlist`)
+  ).action(async (keyIdArg, cmdOpts, cmd) => {
+    const opts = await getGlobalOptions(cmd);
+    const formatter = createFormatter(opts);
+    const config = await resolveConfig(opts);
+    const session = await ensureAuthenticated(config.environment);
+    if (!config.organizationId || !config.projectId) {
+      throw new CliError(
+        "Organization and project required. Run `para orgs switch` and `para projects switch`, or pass --org and --project."
+      );
+    }
+    const client = new ParaApiClient({
+      environment: config.environment,
+      sessionId: session.sessionId
+    });
+    const { keyId, key } = await resolveKeyId(
+      client,
+      config.organizationId,
+      config.projectId,
+      config.environment,
+      keyIdArg
+    );
+    await runSecurityAction(
+      client,
+      config.organizationId,
+      config.projectId,
+      config.environment,
+      keyId,
+      key,
+      formatter,
+      cmdOpts
+    );
+  });
+}
+function hasAnyFlag(flags) {
+  if (!flags) return false;
+  return flags.origins !== void 0 || flags.authMethods !== void 0 || flags.sessionLength !== void 0 || flags.ipAllowlist !== void 0;
+}
+async function runSecurityAction(client, orgId, projectId, environment, keyId, currentKey, formatter, flags) {
+  const updates = {};
+  let ipUpdates;
+  const isInteractive = !hasAnyFlag(flags) && flags?.transactionPopups === void 0;
+  if (flags?.origins !== void 0) {
+    if (flags.origins === "") {
+      updates.origins = [];
+    } else {
+      const origins = flags.origins.split(",").map((s) => s.trim()).filter(Boolean);
+      for (const origin of origins) {
+        const err = validateOriginUrl(origin);
+        if (err) throw new CliError(`Invalid origin "${origin}": ${err}`);
+      }
+      updates.origins = origins;
+    }
+  } else if (isInteractive) {
+    p.log.info(`Current origins: ${currentKey.origins?.length ? currentKey.origins.join(", ") : "(none)"}`);
+    const originsInput = await text("Allowed origins (comma-separated, empty to skip):", {
+      placeholder: "https://example.com, https://app.example.com",
+      initialValue: currentKey.origins?.join(", ") ?? ""
+    });
+    if (originsInput.trim()) {
+      const origins = originsInput.split(",").map((s) => s.trim()).filter(Boolean);
+      for (const origin of origins) {
+        const err = validateOriginUrl(origin);
+        if (err) throw new CliError(`Invalid origin "${origin}": ${err}`);
+      }
+      updates.origins = origins;
+    }
+  }
+  if (flags?.authMethods !== void 0) {
+    if (flags.authMethods === "") {
+      updates.supportedAuthMethods = [AuthMethod.BASIC_LOGIN];
+    } else {
+      const methods = flags.authMethods.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+      const err = validateAuthMethods(methods);
+      if (err) throw new CliError(err);
+      updates.supportedAuthMethods = methods;
+    }
+  } else if (isInteractive) {
+    const currentMethods = (currentKey.supportedAuthMethods ?? []).filter((m) => m !== AuthMethod.BASIC_LOGIN);
+    p.log.info(`Current auth methods: ${currentMethods.length ? currentMethods.join(", ") : "(basic only)"}`);
+    const selected = await multiselect(
+      "Authentication methods:",
+      AUTH_METHOD_DISPLAY_VALUES.map((m) => ({
+        value: m,
+        label: m,
+        hint: m === AuthMethod.PASSKEY ? "Biometric / device passkey" : m === AuthMethod.PASSWORD ? "Email + password" : "Numeric PIN"
+      })),
+      { initialValues: currentMethods }
+    );
+    if (selected.length > 0) {
+      const err = validateAuthMethods(selected);
+      if (err) throw new CliError(err);
+      updates.supportedAuthMethods = selected;
+    }
+  }
+  if (flags?.sessionLength !== void 0) {
+    const minutes = parseInt(flags.sessionLength, 10);
+    const err = validateSessionLength(minutes);
+    if (err) throw new CliError(err);
+    updates.sessionMaxAge = minutesToMs(minutes);
+  } else if (isInteractive) {
+    const currentMinutes = currentKey.sessionMaxAge ? msToMinutes(currentKey.sessionMaxAge) : void 0;
+    p.log.info(`Current session length: ${currentMinutes ? `${currentMinutes} minutes` : "(default)"}`);
+    const presetOptions = SESSION_PRESETS.map((m) => ({
+      value: String(m),
+      label: `${m} minutes${m === 120 ? " (2 hours)" : m === 1440 ? " (1 day)" : m === 10080 ? " (7 days)" : " (30 days)"}`
+    }));
+    const choice = await select("Session length:", [
+      ...presetOptions,
+      { value: "custom", label: "Custom value" },
+      { value: "skip", label: "Skip (keep current)" }
+    ]);
+    if (choice !== "skip") {
+      let minutes;
+      if (choice === "custom") {
+        const input = await text(`Session length in minutes (${MIN_SESSION_MINUTES}-${MAX_SESSION_MINUTES}):`, {
+          placeholder: "1440",
+          validate: (v) => {
+            const n = parseInt(v, 10);
+            if (isNaN(n)) return "Must be a number.";
+            return validateSessionLength(n);
+          }
+        });
+        minutes = parseInt(input, 10);
+      } else {
+        minutes = parseInt(choice, 10);
+      }
+      updates.sessionMaxAge = minutesToMs(minutes);
+    }
+  }
+  if (flags?.transactionPopups !== void 0) {
+    updates.forceTransactionPopups = flags.transactionPopups;
+  } else if (isInteractive) {
+    p.log.info(`Transaction popups: ${currentKey.forceTransactionPopups ? "enabled" : "disabled"}`);
+    const enabled = await confirm("Enable transaction popups?");
+    updates.forceTransactionPopups = enabled;
+  }
+  if (flags?.ipAllowlist !== void 0) {
+    if (flags.ipAllowlist === "") {
+      ipUpdates = [];
+    } else {
+      const cidrs = flags.ipAllowlist.split(",").map((s) => s.trim()).filter(Boolean);
+      const err = validateCidrList(cidrs);
+      if (err) throw new CliError(err);
+      ipUpdates = cidrs;
+    }
+  } else if (isInteractive) {
+    const currentCidrs = currentKey.ipAllowlistCidrs ?? [];
+    p.log.info(`Current IP allowlist: ${currentCidrs.length ? currentCidrs.join(", ") : "(none \u2014 all IPs allowed)"}`);
+    const cidrsInput = await text("IP allowlist CIDR blocks (comma-separated, empty to skip):", {
+      placeholder: "10.0.0.0/8, 192.168.1.0/24",
+      initialValue: currentCidrs.join(", "),
+      validate: (v) => {
+        if (!v.trim()) return void 0;
+        const cidrs = v.split(",").map((s) => s.trim()).filter(Boolean);
+        return validateCidrList(cidrs);
+      }
+    });
+    if (cidrsInput.trim()) {
+      ipUpdates = cidrsInput.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  const hasKeyUpdates = Object.keys(updates).length > 0;
+  const hasIpUpdates = ipUpdates !== void 0;
+  if (!hasKeyUpdates && !hasIpUpdates) {
+    formatter.info("No changes made.");
+    formatter.flush();
+    return;
+  }
+  if (hasKeyUpdates) {
+    await client.updateApiKey(orgId, projectId, environment, keyId, updates);
+  }
+  if (hasIpUpdates) {
+    await client.updateIpAllowlist(orgId, projectId, environment, keyId, ipUpdates);
+  }
+  formatter.json({ keyId, updated: { ...updates, ...hasIpUpdates ? { ipAllowlistCidrs: ipUpdates } : {} } });
+  formatter.success("Updated security settings.");
+  formatter.flush();
+}
+export {
+  registerSecurityConfigCommand,
+  runSecurityAction
+};

package/dist/commands/keys/config/setup.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from 'commander';
+import { ParaApiClient } from '../../../api/client.js';
+import type { ApiKey } from '../../../api/types.js';
+import type { OutputFormatter } from '../../../output/formatter.js';
+interface SetupFlags {
+    walletTypes?: string;
+    cosmosPrefix?: string;
+    teamId?: string;
+    bundleId?: string;
+    androidPackage?: string;
+    androidFingerprints?: string;
+}
+export declare function registerSetupConfigCommand(parent: Command): void;
+export declare function runSetupAction(client: ParaApiClient, orgId: string, projectId: string, environment: string, keyId: string, currentKey: ApiKey, formatter: OutputFormatter, flags?: SetupFlags): Promise<void>;
+export {};
+//# sourceMappingURL=setup.d.ts.map

package/dist/commands/keys/config/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../src/commands/keys/config/setup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,EAAkC,MAAM,uBAAuB,CAAC;AAEpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAapE,UAAU,UAAU;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAcD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAuDhE;AAOD,wBAAsB,cAAc,CAClC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,eAAe,EAC1B,KAAK,CAAC,EAAE,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CA6Lf"}

package/dist/commands/keys/config/setup.js

@@ -0,0 +1,235 @@
+import { getGlobalOptions, createFormatter, helpText } from "../../../cli.js";
+import { ensureAuthenticated } from "../../../auth/session-manager.js";
+import { resolveConfig } from "../../../config/config-manager.js";
+import { ParaApiClient } from "../../../api/client.js";
+import { CliError } from "../../../core/error-handler.js";
+import { WalletType } from "../../../api/types.js";
+import { text, multiselect, confirm, p } from "../../../output/prompts.js";
+import { resolveKeyId } from "./categories.js";
+import {
+  validateWalletTypes,
+  WALLET_TYPE_VALUES,
+  validateCosmosPrefix,
+  validateTeamId,
+  validateBundleIdentifier,
+  validateAndroidPackageName,
+  validateAndroidFingerprint
+} from "../../../validation/index.js";
+function parseWalletTypesFlag(input) {
+  return input.split(",").map((s) => {
+    const trimmed = s.trim();
+    const optional = trimmed.startsWith("~");
+    const type = optional ? trimmed.slice(1) : trimmed;
+    return { type, optional };
+  }).filter((c) => c.type);
+}
+function registerSetupConfigCommand(parent) {
+  parent.command("setup").description("Configure wallet types and native passkey settings").argument("[key-id]", "API key ID (prompted if not given)").option("--wallet-types <types>", 'Comma-separated wallet types, ~ prefix for optional: "EVM,~SOLANA,~COSMOS"').option("--cosmos-prefix <prefix>", "Cosmos address prefix").option("--team-id <id>", "Apple Team ID (10 chars, or empty to clear)").option("--bundle-id <id>", "Apple bundle identifier").option("--android-package <name>", "Android package name").option("--android-fingerprints <fps>", "Comma-separated SHA256 fingerprints").addHelpText(
+    "after",
+    helpText(`Examples:
+  $ para keys config setup                                        Interactive setup
+  $ para keys config setup --wallet-types "EVM,~SOLANA"           Set wallet types (SOLANA optional)
+  $ para keys config setup --team-id "ABCDE12345"                 Set Apple Team ID
+  $ para keys config setup --android-package "com.example.app"    Set Android package name`)
+  ).action(async (keyIdArg, cmdOpts, cmd) => {
+    const opts = await getGlobalOptions(cmd);
+    const formatter = createFormatter(opts);
+    const config = await resolveConfig(opts);
+    const session = await ensureAuthenticated(config.environment);
+    if (!config.organizationId || !config.projectId) {
+      throw new CliError(
+        "Organization and project required. Run `para orgs switch` and `para projects switch`, or pass --org and --project."
+      );
+    }
+    const client = new ParaApiClient({
+      environment: config.environment,
+      sessionId: session.sessionId
+    });
+    const { keyId, key } = await resolveKeyId(
+      client,
+      config.organizationId,
+      config.projectId,
+      config.environment,
+      keyIdArg
+    );
+    await runSetupAction(
+      client,
+      config.organizationId,
+      config.projectId,
+      config.environment,
+      keyId,
+      key,
+      formatter,
+      cmdOpts
+    );
+  });
+}
+function hasAnyFlag(flags) {
+  if (!flags) return false;
+  return Object.keys(flags).some((k) => flags[k] !== void 0);
+}
+async function runSetupAction(client, orgId, projectId, environment, keyId, currentKey, formatter, flags) {
+  const updates = {};
+  const isInteractive = !hasAnyFlag(flags);
+  if (flags?.walletTypes !== void 0) {
+    const types = parseWalletTypesFlag(flags.walletTypes);
+    const err = validateWalletTypes(types);
+    if (err) throw new CliError(err);
+    updates.supportedWalletTypes = types;
+  } else if (isInteractive) {
+    const currentTypes = currentKey.supportedWalletTypes ?? [];
+    const display = currentTypes.map((t) => `${t.type}${t.optional ? " (optional)" : ""}`).join(", ") || "(none)";
+    p.log.info(`Current wallet types: ${display}`);
+    const selectedTypes = await multiselect(
+      "Required wallet types:",
+      WALLET_TYPE_VALUES.map((t) => ({
+        value: t,
+        label: t,
+        hint: t === WalletType.EVM ? "Ethereum & EVM chains" : t === WalletType.SOLANA ? "Solana" : "Cosmos ecosystem"
+      })),
+      {
+        required: true,
+        initialValues: currentTypes.filter((t) => !t.optional).map((t) => t.type)
+      }
+    );
+    const remainingTypes = WALLET_TYPE_VALUES.filter((t) => !selectedTypes.includes(t));
+    let optionalTypes = [];
+    if (remainingTypes.length > 0) {
+      optionalTypes = await multiselect(
+        "Optional wallet types (users can opt in):",
+        remainingTypes.map((t) => ({
+          value: t,
+          label: t,
+          hint: "Optional for users"
+        })),
+        {
+          initialValues: currentTypes.filter((t) => t.optional).map((t) => t.type)
+        }
+      );
+    }
+    const walletConfigs = [
+      ...selectedTypes.map((t) => ({ type: t })),
+      ...optionalTypes.map((t) => ({ type: t, optional: true }))
+    ];
+    const err = validateWalletTypes(walletConfigs);
+    if (err) throw new CliError(err);
+    updates.supportedWalletTypes = walletConfigs;
+  }
+  if (flags?.cosmosPrefix !== void 0) {
+    const err = validateCosmosPrefix(flags.cosmosPrefix);
+    if (err) throw new CliError(err);
+    updates.cosmosPrefix = flags.cosmosPrefix;
+  } else if (isInteractive) {
+    p.log.info(`Current cosmos prefix: ${currentKey.cosmosPrefix ?? "(default)"}`);
+    const prefix = await text("Cosmos address prefix (empty to skip):", {
+      placeholder: "cosmos",
+      initialValue: currentKey.cosmosPrefix ?? "",
+      validate: (v) => {
+        if (v.trim()) return validateCosmosPrefix(v.trim());
+        return void 0;
+      }
+    });
+    if (prefix.trim()) {
+      updates.cosmosPrefix = prefix.trim();
+    }
+  }
+  if (flags?.teamId !== void 0) {
+    if (flags.teamId === "") {
+      updates.teamId = null;
+    } else {
+      const err = validateTeamId(flags.teamId);
+      if (err) throw new CliError(err);
+      updates.teamId = flags.teamId;
+    }
+  } else if (isInteractive) {
+    p.log.info(`Current Apple Team ID: ${currentKey.teamId ?? "(not set)"}`);
+    const configureApple = await confirm("Configure Apple native passkey settings?");
+    if (configureApple) {
+      const teamId = await text("Apple Team ID (10 characters, empty to clear):", {
+        placeholder: "ABCDE12345",
+        initialValue: currentKey.teamId ?? "",
+        validate: (v) => {
+          if (v.trim()) return validateTeamId(v.trim());
+        }
+      });
+      if (teamId.trim()) {
+        updates.teamId = teamId.trim();
+      } else {
+        updates.teamId = null;
+      }
+      const bundleId = await text("Apple bundle identifier (empty to skip):", {
+        placeholder: "com.example.app",
+        initialValue: currentKey.bundleIdentifier ?? "",
+        validate: (v) => {
+          if (v.trim()) return validateBundleIdentifier(v.trim());
+        }
+      });
+      if (bundleId.trim()) {
+        updates.bundleIdentifier = bundleId.trim();
+      }
+    }
+  }
+  if (flags?.bundleId !== void 0) {
+    const err = validateBundleIdentifier(flags.bundleId);
+    if (err) throw new CliError(err);
+    updates.bundleIdentifier = flags.bundleId;
+  }
+  if (flags?.androidPackage !== void 0) {
+    const err = validateAndroidPackageName(flags.androidPackage);
+    if (err) throw new CliError(err);
+    updates.androidPackageName = flags.androidPackage;
+  }
+  if (flags?.androidFingerprints !== void 0) {
+    const fps = flags.androidFingerprints.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const fp of fps) {
+      const err = validateAndroidFingerprint(fp);
+      if (err) throw new CliError(err);
+    }
+    updates.androidSha256CertFingerprints = fps;
+  }
+  if (isInteractive && flags?.androidPackage === void 0 && flags?.androidFingerprints === void 0) {
+    p.log.info(`Current Android package: ${currentKey.androidPackageName ?? "(not set)"}`);
+    const configureAndroid = await confirm("Configure Android native passkey settings?");
+    if (configureAndroid) {
+      const pkg = await text("Android package name (empty to skip):", {
+        placeholder: "com.example.app",
+        initialValue: currentKey.androidPackageName ?? "",
+        validate: (v) => {
+          if (v.trim()) return validateAndroidPackageName(v.trim());
+        }
+      });
+      if (pkg.trim()) {
+        updates.androidPackageName = pkg.trim();
+      }
+      const currentFps = currentKey.androidSha256CertFingerprints ?? [];
+      const fpsInput = await text("SHA256 fingerprints (comma-separated, empty to skip):", {
+        placeholder: "AA:BB:CC:...",
+        initialValue: currentFps.join(", "),
+        validate: (v) => {
+          if (!v.trim()) return void 0;
+          const fps = v.split(",").map((s) => s.trim()).filter(Boolean);
+          for (const fp of fps) {
+            const err = validateAndroidFingerprint(fp);
+            if (err) return err;
+          }
+        }
+      });
+      if (fpsInput.trim()) {
+        updates.androidSha256CertFingerprints = fpsInput.split(",").map((s) => s.trim()).filter(Boolean);
+      }
+    }
+  }
+  if (Object.keys(updates).length === 0) {
+    formatter.info("No changes made.");
+    formatter.flush();
+    return;
+  }
+  await client.updateApiKey(orgId, projectId, environment, keyId, updates);
+  formatter.json({ keyId, updated: updates });
+  formatter.success("Updated setup settings.");
+  formatter.flush();
+}
+export {
+  registerSetupConfigCommand,
+  runSetupAction
+};