mppx 0.8.17 → 0.8.19

package/src/stripe/server/Methods.ts

@@ -1,441 +0,0 @@
-import * as EvmAssets from '../../evm/Assets.js'
-import { charge as evmCharge } from '../../evm/server/Charge.js'
-import type * as Method from '../../Method.js'
-import * as tempoDefaults from '../../tempo/internal/defaults.js'
-import { charge as tempoCharge } from '../../tempo/server/Charge.js'
-import { session as tempoSession } from '../../tempo/session/server/Session.js'
-import type { StripeClient } from '../internal/types.js'
-import { charge as charge_ } from './Charge.js'
-import { findOrCreateDepositAddress as _findOrCreateDepositAddress } from './internal/deposit-address.js'
-import { recordCryptoPayment } from './internal/record-payment.js'
-import { type ConnectConfig } from './internal/request.js'
-
-// --- Public types ---
-
-export declare namespace stripe {
-  type Network = 'tempo' | 'base' | 'solana'
-
-  type DepositAddress<N extends Network = Network> = string & {
-    readonly __brand: 'StripeDepositAddress'
-    readonly __network: N
-  }
-
-  // TODO: make networkId and livemode also accept dynamic resolvers (fetched from
-  // GET /v2/network/business_profiles/me which returns { id, livemode, ... }).
-  // This would allow `stripe.create({ secretKey })` with no other params.
-  type Parameters = {
-    client: StripeClient
-    networkId: string
-    livemode: boolean
-    connect?: ConnectConfig
-    depositAddresses?: Partial<Record<Network, string>> | ((network: Network) => Promise<string>)
-    metadata?: Record<string, string> | undefined
-  }
-}
-
-// --- Internal types ---
-
-type CustomRailFactory = (address: string) => Method.AnyServer | readonly Method.AnyServer[]
-
-type ServerOf<N extends string, I extends string> = Omit<Method.AnyServer, 'name' | 'intent'> & {
-  name: N
-  intent: I
-}
-
-type TempoServer = ServerOf<'tempo', 'charge'>
-type TempoSessionServer = ServerOf<'tempo', 'session'>
-type SptServer = ServerOf<'stripe', 'charge'>
-type EvmServer = ServerOf<'evm', 'charge'>
-
-type BaseConfig = {
-  x402: NonNullable<Parameters<typeof evmCharge>[0]['x402']>
-} & Partial<Omit<Parameters<typeof evmCharge>[0], 'currency' | 'recipient' | 'x402'>>
-
-type CustomRailNetwork = Exclude<stripe.Network, 'tempo' | 'base'>
-
-type AdditionalConfig = {
-  base?: BaseConfig
-  tempo?: { session: Omit<tempoSession.Parameters, 'currency' | 'recipient'> }
-} & { [K in CustomRailNetwork]?: CustomRailFactory }
-
-type DefaultMethods = readonly [TempoServer, SptServer]
-
-type DefaultMethodsWithAdditional<C extends AdditionalConfig> = readonly [
-  TempoServer,
-  SptServer,
-  ...(C extends { base: object } ? [EvmServer] : []),
-  ...(C extends { tempo: { session: any } } ? [TempoSessionServer] : []),
-]
-
-type DefaultMethodName = 'tempo' | 'spt'
-const defaultMethodNames: readonly DefaultMethodName[] = ['tempo', 'spt']
-
-type AdditionalBuiltinKey = 'base' | 'tempo'
-const additionalBuiltinKeys: readonly AdditionalBuiltinKey[] = ['base', 'tempo']
-
-type DefaultMethodsConfig = {
-  exclude?: DefaultMethodName[]
-}
-
-type SyncMethodsResult = DefaultMethods & {
-  additional<C extends AdditionalConfig>(config: C): DefaultMethodsWithAdditional<C>
-}
-
-interface StripeMachinePayments<P extends stripe.Parameters = stripe.Parameters> {
-  spt: {
-    charge: (params?: { paymentMethodTypes?: string[] }) => SptServer
-  }
-  tempo: {
-    charge: (
-      params: {
-        recipient: stripe.DepositAddress<'tempo'>
-        metadata?: Record<string, string>
-      } & Partial<Omit<Parameters<typeof tempoCharge>[0], 'currency' | 'recipient'>>,
-    ) => TempoServer
-    session: (
-      params: { recipient: stripe.DepositAddress<'tempo'> } & Omit<
-        tempoSession.Parameters,
-        'currency' | 'recipient'
-      >,
-    ) => TempoSessionServer
-  }
-  base: {
-    charge: (
-      params: {
-        recipient: stripe.DepositAddress<'base'>
-        metadata?: Record<string, string>
-      } & BaseConfig,
-    ) => EvmServer
-  }
-  findOrCreateDepositAddress: <N extends stripe.Network>(
-    network: N,
-  ) => Promise<stripe.DepositAddress<N>>
-  defaultMethods: (
-    config?: DefaultMethodsConfig,
-  ) => P['depositAddresses'] extends Partial<Record<stripe.Network, string>>
-    ? SyncMethodsResult
-    : DefaultMethodsBuilder
-}
-
-class DefaultMethodsBuilder implements PromiseLike<DefaultMethods> {
-  readonly #resolve: (additional?: AdditionalConfig) => Promise<any>
-  #additional: AdditionalConfig | undefined
-
-  constructor(resolve: (additional?: AdditionalConfig) => Promise<any>) {
-    this.#resolve = resolve
-  }
-
-  additional<C extends AdditionalConfig>(config: C): PromiseLike<DefaultMethodsWithAdditional<C>> {
-    this.#additional = config
-    return this as unknown as PromiseLike<DefaultMethodsWithAdditional<C>>
-  }
-
-  then<T = DefaultMethods, U = never>(
-    onfulfilled?: ((value: DefaultMethods) => T | PromiseLike<T>) | null,
-    onrejected?: ((reason: unknown) => U | PromiseLike<U>) | null,
-  ): Promise<T | U> {
-    return this.#resolve(this.#additional).then(onfulfilled, onrejected)
-  }
-}
-
-/**
- * Creates a configured Stripe machine payments instance.
- *
- * @example
- * ```ts
- * import { Mppx, stripe } from 'mppx/server'
- *
- * const machinePayments = stripe.create({
- *   client: stripeClient,
- *   networkId: process.env.STRIPE_PROFILE_ID!,
- *   livemode: !process.env.STRIPE_SECRET_KEY!.includes('_test_'),
- * })
- *
- * // Async: deposit addresses resolved from Stripe API
- * const mppx = Mppx.create({
- *   methods: await machinePayments.defaultMethods(),
- *   secretKey: mppSecretKey,
- * })
- * ```
- *
- * @example
- * ```ts
- * // Sync: deposit addresses provided statically
- * const machinePayments = stripe.create({
- *   client: stripeClient,
- *   networkId: process.env.STRIPE_PROFILE_ID!,
- *   livemode: !process.env.STRIPE_SECRET_KEY!.includes('_test_'),
- *   depositAddresses: { tempo: process.env.TEMPO_DEPOSIT_ADDRESS! },
- * })
- *
- * const mppx = Mppx.create({
- *   methods: machinePayments.defaultMethods(),
- *   secretKey: mppSecretKey,
- * })
- * ```
- *
- * @example
- * ```ts
- * // With additional custom rails
- * const mppx = Mppx.create({
- *   methods: await machinePayments.defaultMethods().additional({
- *     base: { x402: { facilitator } },
- *     solana: (address) => solana.charge({ recipient: address, currency: USDC, decimals: 6 }),
- *   }),
- *   secretKey: mppSecretKey,
- * })
- * ```
- */
-export function stripe<const P extends stripe.Parameters>(parameters: P): StripeMachinePayments<P> {
-  const { client, networkId, livemode, connect, depositAddresses, metadata } = parameters
-  if (!client.rawRequest)
-    throw new Error('stripe.create() requires a Stripe SDK client with rawRequest() (v15+)')
-  const tempoCurrency = (
-    livemode ? tempoDefaults.tokens.usdc : tempoDefaults.tokens.pathUsd
-  ) as `0x${string}`
-  const tempoPaymentHandler = createPaymentSuccessHandler(client, 'tempo', connect, metadata)
-  const basePaymentHandler = createPaymentSuccessHandler(client, 'base', connect, metadata)
-
-  // All stripe-managed crypto rails use 6-decimal stablecoins. Reject amounts
-  // below 1 cent since Stripe cannot record them.
-  const cryptoCanOffer = ({ request }: { request: { amount: string } }) =>
-    Number(request.amount) >= 10_000
-
-  function makeSptCharge(params?: { paymentMethodTypes?: string[] }): Method.AnyServer {
-    return charge_({
-      client,
-      networkId,
-      currency: 'usd',
-      decimals: 2,
-      paymentMethodTypes: params?.paymentMethodTypes ?? ['card', 'link'],
-      ...(connect && { connect }),
-      ...(metadata && { metadata }),
-    } as Parameters<typeof charge_>[0]) as Method.AnyServer
-  }
-
-  function makeTempoCharge(
-    params: { recipient: `0x${string}`; metadata?: Record<string, string> } & Partial<
-      Omit<Parameters<typeof tempoCharge>[0], 'currency' | 'recipient'>
-    >,
-  ): Method.AnyServer {
-    const { recipient, metadata: callMetadata, ...rest } = params
-    const handler = callMetadata
-      ? createPaymentSuccessHandler(client, 'tempo', connect, { ...metadata, ...callMetadata })
-      : tempoPaymentHandler
-    return tempoCharge({
-      currency: tempoCurrency,
-      recipient,
-      ...(!livemode && { testnet: true }),
-      canOffer: cryptoCanOffer,
-      onPaymentSuccess: handler,
-      ...rest,
-    }) as Method.AnyServer
-  }
-
-  function makeTempoSession(
-    params: { recipient: `0x${string}` } & Omit<tempoSession.Parameters, 'currency' | 'recipient'>,
-  ): Method.AnyServer {
-    const { recipient, ...rest } = params
-    return tempoSession({
-      currency: tempoCurrency,
-      recipient,
-      ...(!livemode && { testnet: true }),
-      ...rest,
-    } as tempoSession.Parameters) as Method.AnyServer
-  }
-
-  function makeBaseCharge(
-    params: { recipient: `0x${string}`; metadata?: Record<string, string> } & BaseConfig,
-  ): Method.AnyServer {
-    const { recipient, x402, metadata: callMetadata, ...rest } = params
-    const handler = callMetadata
-      ? createPaymentSuccessHandler(client, 'base', connect, { ...metadata, ...callMetadata })
-      : basePaymentHandler
-    return evmCharge({
-      currency: livemode ? EvmAssets.base.USDC : EvmAssets.baseSepolia.USDC,
-      recipient,
-      x402,
-      canOffer: cryptoCanOffer,
-      onPaymentSuccess: handler,
-      ...rest,
-    }) as Method.AnyServer
-  }
-
-  const defaultMethodBuilders: Record<
-    DefaultMethodName,
-    (addresses: Map<string, string>) => Method.AnyServer | null
-  > = {
-    tempo: (addresses) => {
-      const address = addresses.get('tempo')
-      if (!address) return null
-      return makeTempoCharge({ recipient: address as `0x${string}` })
-    },
-    spt: () => makeSptCharge(),
-  }
-
-  const additionalBuilders: Record<
-    AdditionalBuiltinKey,
-    (addresses: Map<string, string>, config: AdditionalConfig) => Method.AnyServer | null
-  > = {
-    base: (addresses, config) => {
-      if (!config.base) return null
-      const address = addresses.get('base')
-      if (!address) return null
-      return makeBaseCharge({ recipient: address as `0x${string}`, ...config.base })
-    },
-    tempo: (addresses, config) => {
-      if (!config.tempo?.session) return null
-      const address = addresses.get('tempo')
-      if (!address) return null
-      return makeTempoSession({ recipient: address as `0x${string}`, ...config.tempo.session })
-    },
-  }
-
-  function createMethodsFromAddresses(
-    addresses: Map<string, string>,
-    excluded: Set<string>,
-    additional?: AdditionalConfig,
-  ): DefaultMethods {
-    const result: Method.AnyServer[] = []
-
-    for (const name of defaultMethodNames) {
-      if (excluded.has(name)) continue
-      const method = defaultMethodBuilders[name](addresses)
-      if (method) result.push(method)
-    }
-
-    if (additional) {
-      for (const key of Object.keys(additionalBuilders) as AdditionalBuiltinKey[]) {
-        const method = additionalBuilders[key](addresses, additional)
-        if (method) result.push(method)
-      }
-
-      for (const [network, factory] of customRails(additional)) {
-        const address = requireAddress(addresses, network)
-        const recorder = createPaymentSuccessHandler(
-          client,
-          network as stripe.Network,
-          connect,
-          metadata,
-        )
-        for (const m of toArray(factory(address))) {
-          const onPaymentSuccess = m.onPaymentSuccess
-            ? (params: any) =>
-                Promise.all([m.onPaymentSuccess!(params), recorder(params)]).then(() => {})
-            : recorder
-          const canOffer = m.canOffer
-            ? (params: any) => cryptoCanOffer(params) && m.canOffer!(params)
-            : cryptoCanOffer
-          result.push({ ...m, canOffer, onPaymentSuccess } as Method.AnyServer)
-        }
-      }
-    }
-
-    return result as unknown as DefaultMethods
-  }
-
-  function resolveAddress(network: string): Promise<string> {
-    if (typeof depositAddresses === 'function') return depositAddresses(network as stripe.Network)
-    return _findOrCreateDepositAddress(client, network, connect ? { connect } : undefined)
-  }
-
-  function defaultMethods(
-    config?: DefaultMethodsConfig,
-  ): SyncMethodsResult | DefaultMethodsBuilder {
-    const excluded = new Set(config?.exclude)
-
-    if (depositAddresses && typeof depositAddresses !== 'function') {
-      // Sync: static deposit addresses provided at stripe.create() time
-      const addresses = new Map(Object.entries(depositAddresses)) as Map<string, string>
-      return Object.assign(createMethodsFromAddresses(addresses, excluded), {
-        additional: (additional: AdditionalConfig) =>
-          createMethodsFromAddresses(addresses, excluded, additional),
-      }) as SyncMethodsResult
-    } else {
-      // Async: resolve addresses dynamically
-      return new DefaultMethodsBuilder(async (additional) => {
-        const networks = neededNetworks(excluded, additional)
-        const results = await Promise.all(
-          networks.map(async (network) => ({
-            network,
-            address: await resolveAddress(network),
-          })),
-        )
-        const addresses = new Map(results.map(({ network, address }) => [network, address]))
-        return createMethodsFromAddresses(addresses, excluded, additional)
-      })
-    }
-  }
-
-  return {
-    spt: { charge: makeSptCharge },
-    tempo: { charge: makeTempoCharge, session: makeTempoSession },
-    base: { charge: makeBaseCharge },
-    findOrCreateDepositAddress: async <N extends stripe.Network>(network: N) => {
-      const address = await resolveAddress(network)
-      return address as stripe.DepositAddress<N>
-    },
-    defaultMethods,
-  } as StripeMachinePayments
-}
-
-export namespace stripe {
-  export const spt = charge_
-
-  /** @deprecated Use `stripe.spt()` instead. */
-  export const charge = charge_
-
-  export const create = stripe
-
-  export const findOrCreateDepositAddress = _findOrCreateDepositAddress
-}
-
-function neededNetworks(excluded: Set<string>, additional?: AdditionalConfig): stripe.Network[] {
-  const networks: stripe.Network[] = []
-  if (!excluded.has('tempo') || additional?.tempo?.session) networks.push('tempo')
-  if (additional?.base) networks.push('base')
-  for (const [network] of customRails(additional)) {
-    networks.push(network as stripe.Network)
-  }
-  return networks
-}
-
-function requireAddress(addresses: Map<string, string>, network: string): string {
-  const address = addresses.get(network)
-  if (!address) throw new Error(`stripe: missing deposit address for ${network}`)
-  return address
-}
-
-function toArray(
-  value: Method.AnyServer | readonly Method.AnyServer[],
-): readonly Method.AnyServer[] {
-  return Array.isArray(value) ? value : [value]
-}
-
-function customRails(additional?: AdditionalConfig): [string, CustomRailFactory][] {
-  if (!additional) return []
-  return Object.entries(additional).filter((entry): entry is [string, CustomRailFactory] => {
-    const [k, v] = entry
-    return !(additionalBuiltinKeys as readonly string[]).includes(k) && typeof v === 'function'
-  })
-}
-
-function createPaymentSuccessHandler(
-  client: StripeClient,
-  network: stripe.Network,
-  connect?: ConnectConfig,
-  metadata?: Record<string, string>,
-) {
-  return (params: { receipt: any; request: any }) => {
-    const { receipt, request } = params
-    if (receipt?.reference && request?.amount) {
-      return recordCryptoPayment(client, {
-        network,
-        reference: receipt.reference,
-        amount: String(request.amount),
-        ...(connect && { connect }),
-        ...(metadata && { metadata }),
-      })
-    }
-  }
-}

package/src/stripe/server/index.ts

@@ -1,2 +0,0 @@
-export { charge } from './Charge.js'
-export { stripe } from './Methods.js'

package/src/stripe/server/internal/deposit-address.ts

@@ -1,57 +0,0 @@
-import type { StripeClient } from '../../internal/types.js'
-import { stripeRequest, type ConnectConfig } from './request.js'
-
-export type DepositAddressResolver = (
-  client: StripeClient,
-  network: string,
-  options?: { connect?: ConnectConfig },
-) => Promise<string>
-
-const cache = new WeakMap<StripeClient, Map<string, string>>()
-
-/**
- * Finds an existing deposit address or creates a new one for the given network.
- * Cached per client+network+stripeAccount for the process lifetime.
- */
-export async function findOrCreateDepositAddress(
-  client: StripeClient,
-  network: string,
-  options?: { connect?: ConnectConfig },
-): Promise<string> {
-  let clientCache = cache.get(client)
-  if (!clientCache) {
-    clientCache = new Map()
-    cache.set(client, clientCache)
-  }
-  const key = options?.connect?.stripeAccount
-    ? `${options.connect.stripeAccount}:${network}`
-    : network
-  const cached = clientCache.get(key)
-  if (cached) return cached
-
-  const list = (await stripeRequest(
-    client,
-    'GET',
-    `/v1/crypto/deposit_addresses?network=${network}&limit=1`,
-    undefined,
-    options,
-  )) as {
-    data?: { address: string }[]
-  }
-  if (list.data && list.data.length > 0) {
-    clientCache.set(key, list.data[0]!.address)
-    return list.data[0]!.address
-  }
-
-  const created = (await stripeRequest(
-    client,
-    'POST',
-    '/v1/crypto/deposit_addresses',
-    { network },
-    options,
-  )) as {
-    address: string
-  }
-  clientCache.set(key, created.address)
-  return created.address
-}

package/src/stripe/server/internal/html/main.ts

@@ -1,165 +0,0 @@
-import type { Appearance } from '@stripe/stripe-js'
-import { loadStripe } from '@stripe/stripe-js/pure'
-
-import { stripe } from '../../../../client/index.js'
-import * as Html from '../../../../Html.js'
-import { mergeDefined } from '../../../../server/internal/html/config.js'
-import type { charge as chargeClient } from '../../../../stripe/client/Charge.js'
-import type { charge } from '../../../../stripe/server/Charge.js'
-import type * as Methods from '../../../Methods.js'
-
-const c = Html.init<typeof Methods.charge, NonNullable<charge.Parameters['html']>>('stripe')
-
-const css = String.raw
-const style = document.createElement('style')
-style.textContent = css`
-  form {
-    display: flex;
-    flex-direction: column;
-    gap: calc(${c.vars.spacingUnit} * 8);
-  }
-  button {
-    background: ${c.vars.accent};
-    border-radius: ${c.vars.radius};
-    color: ${c.vars.background};
-    cursor: pointer;
-    font-weight: 500;
-    padding: calc(${c.vars.spacingUnit} * 4) calc(${c.vars.spacingUnit} * 8);
-    width: 100%;
-  }
-  button:hover:not(:disabled) {
-    opacity: 0.85;
-  }
-  button:disabled {
-    cursor: default;
-    opacity: 0.5;
-  }
-`
-c.root.append(style)
-
-;(async () => {
-  if (import.meta.env.MODE === 'test') {
-    const button = document.createElement('button')
-    button.textContent = c.text.pay
-    c.root.appendChild(button)
-    button.onclick = async () => {
-      try {
-        button.disabled = true
-        const method = stripe({ createToken })[0]
-        const credential = await method.createCredential({
-          challenge: c.challenge,
-          context: { paymentMethod: 'pm_card_visa' },
-        })
-        await c.submit(credential)
-      } catch (error) {
-        c.error(error instanceof Error ? error.message : 'Payment failed')
-      } finally {
-        button.disabled = false
-      }
-    }
-    return
-  }
-
-  const stripeJs = await loadStripe(c.config.publishableKey)
-  if (!stripeJs) throw new Error('Failed to loadStripe')
-
-  const darkQuery = window.matchMedia('(prefers-color-scheme: dark)')
-  const getAppearance = () => {
-    const theme = (() => {
-      if (c.config.elements?.options?.appearance?.theme)
-        return c.config.elements?.options?.appearance?.theme
-      switch (c.theme.colorScheme) {
-        case 'light dark':
-          return (darkQuery.matches ? 'night' : 'stripe') as 'night' | 'stripe'
-        case 'light':
-          return 'stripe' as const
-        case 'dark':
-          return 'night' as const
-      }
-    })()
-    const resolvedColorSchemeIndex = darkQuery.matches ? 1 : 0
-    return mergeDefined(
-      {
-        disableAnimations: true,
-        theme,
-        variables: {
-          borderRadius: c.theme.radius,
-          colorBackground: c.theme.surface[resolvedColorSchemeIndex],
-          colorDanger: c.theme.negative[resolvedColorSchemeIndex],
-          colorPrimary: c.theme.accent[resolvedColorSchemeIndex],
-          colorText: c.theme.foreground[resolvedColorSchemeIndex],
-          colorTextSecondary: c.theme.muted[resolvedColorSchemeIndex],
-          fontSizeBase: c.theme.fontSizeBase,
-          fontFamily: c.theme.fontFamily,
-          spacingUnit: c.theme.spacingUnit,
-        },
-      } satisfies Appearance,
-      (c.config.elements?.options?.appearance as never) ?? {},
-    )
-  }
-
-  const elements = stripeJs.elements({
-    appearance: getAppearance(),
-    ...c.config.elements?.options,
-    amount: Number(c.challenge.request.amount),
-    currency: c.challenge.request.currency,
-    mode: 'payment',
-    paymentMethodCreation: 'manual',
-    paymentMethodTypes: c.challenge.request.methodDetails.paymentMethodTypes,
-  })
-
-  darkQuery.addEventListener('change', () => {
-    elements.update({ appearance: getAppearance() })
-  })
-
-  const form = document.createElement('form')
-  elements.create('payment', c.config.elements?.paymentOptions).mount(form)
-  c.root.appendChild(form)
-
-  const button = document.createElement('button')
-  button.textContent = c.text.pay
-  button.type = 'submit'
-  form.appendChild(button)
-
-  form.onsubmit = async (event) => {
-    event.preventDefault()
-    c.error()
-    button.disabled = true
-    try {
-      await elements.submit()
-      const { paymentMethod, error: stripeError } = await stripeJs.createPaymentMethod({
-        ...c.config.elements?.createPaymentMethodOptions,
-        elements,
-      })
-      if (stripeError || !paymentMethod)
-        throw stripeError ?? new Error('Failed to create payment method')
-      const method = stripe({ client: stripeJs, createToken })[0]
-      const credential = await method.createCredential({
-        challenge: c.challenge,
-        context: { paymentMethod: paymentMethod.id },
-      })
-      await c.submit(credential)
-    } catch (error) {
-      c.error(error instanceof Error ? error.message : 'Payment failed')
-    } finally {
-      button.disabled = false
-    }
-  }
-})()
-
-async function createToken(opts: chargeClient.OnChallengeParameters) {
-  const createTokenUrl = new URL(c.config.createTokenUrl, location.origin)
-  if (createTokenUrl.origin !== location.origin)
-    throw new Error('createTokenUrl must be same-origin')
-  const res = await fetch(createTokenUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(opts),
-  })
-  if (!res.ok) {
-    const text = await res.text().catch(() => '<response body unavailable>')
-    throw new Error(`Failed to create SPT (${res.status}): ${text}`)
-  }
-  const json = (await res.json()) as { spt: string }
-  return json.spt
-}

package/src/stripe/server/internal/html/node_modules/.bin/mppx

@@ -1,22 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*)
-        if command -v cygpath > /dev/null 2>&1; then
-            basedir=`cygpath -w "$basedir"`
-        fi
-    ;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/runner/work/mppx/mppx/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/home/runner/work/mppx/mppx/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../mppx/src/bin.js" "$@"
-else
-  exec node  "$basedir/../mppx/src/bin.js" "$@"
-fi
-# cmd-shim-target=/home/runner/work/mppx/mppx/src/stripe/server/internal/html/node_modules/mppx/src/bin.js