@screenly/edge-apps 0.1.0 → 1.0.0-rc.2

package/README.md

@@ -6,8 +6,14 @@ A TypeScript library for interfacing with the Screenly Edge Apps API.
 
 ## Installation
 
-> [!IMPORTANT]
-> This package requires [Bun](https://bun.sh). The `edge-apps-scripts` CLI will not work with `npm` or `node` at this time.
+> [!NOTE]
+> Requires Node.js >= 20.6.0.
+
+```bash
+npm install @screenly/edge-apps
+```
+
+Or with Bun:
 
 ```bash
 bun add @screenly/edge-apps
@@ -20,26 +26,22 @@ When developing Edge Apps locally using the library from this repository, you sh
 First, in the root of this repository:
 
 ```bash
-bun link
+npm install
+npm run build
+npm link
 ```
 
 Then in your Edge App directory:
 
 ```bash
 cd /path/to/your-edge-app
-bun link @screenly/edge-apps
+npm link @screenly/edge-apps
 ```
 
 To unlink the package when you're done with local development, run the following in your Edge App directory:
 
 ```bash
-bun install --force
-```
-
-Then in the root of this repository:
-
-```bash
-bun unlink
+npm install
 ```
 
 ## Quick Start
@@ -97,7 +99,7 @@ signalReady()
 
 ## Web Components
 
-This library includes reusable web components for building consistent Edge Apps. See the [components documentation](https://github.com/Screenly/edge-apps-library/blob/master/docs/components.md) for usage details.
+This library includes reusable web components for building consistent Edge Apps. See the [components documentation](https://github.com/Screenly/edge-apps-library/blob/main/docs/components.md) for usage details.
 
 ## Edge Apps Scripts CLI
 
@@ -110,13 +112,13 @@ This package provides the `edge-apps-scripts` CLI tool for running shared develo
 Start the Vite development server with mock data from `screenly.yml` and `mock-data.yml`:
 
 ```bash
-bun run dev
+npm run dev
 ```
 
 #### Building
 
 ```bash
-bun run build
+npm run build
 ```
 
 #### Linting
@@ -124,13 +126,13 @@ bun run build
 To lint your Edge App:
 
 ```bash
-bun run lint
+npm run lint
 ```
 
 To lint and automatically fix issues:
 
 ```bash
-bun run lint -- --fix
+npm run lint -- --fix
 ```
 
 #### Type Checking
@@ -138,7 +140,7 @@ bun run lint -- --fix
 Run TypeScript type checking:
 
 ```bash
-bun run type-check
+npm run type-check
 ```
 
 ### Command-Line Utilities for Edge Apps
@@ -158,7 +160,7 @@ It is recommended to add the following scripts to your Edge App's `package.json`
     "build:dev": "edge-apps-scripts build:dev",
     "lint": "edge-apps-scripts lint",
     "type-check": "edge-apps-scripts type-check",
-    "deploy": "bun run build && screenly edge-app deploy --path=dist/"
+    "deploy": "npm run build && screenly edge-app deploy --path=dist/"
   }
 }
 ```
@@ -197,7 +199,7 @@ import type {
 ## Development
 
 ```bash
-bun install      # Install dependencies
-bun test         # Run tests
-bun run build    # Build library
+npm install      # Install dependencies
+npm test         # Run tests
+npm run build    # Build library
 ```

package/bin/edge-apps-scripts.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../scripts/cli.js'
+
+run()

package/configs/playwright.js

@@ -18,7 +18,7 @@ try {
 } catch {
   throw new Error(
     "Failed to resolve '@playwright/test' from the application. " +
-      "Please install it in your app (e.g. 'bun add -d @playwright/test') " +
+      "Please install it in your app (e.g. 'npm install -D @playwright/test') " +
       'and try again.',
   )
 }

package/eslint.config.ts

@@ -1,5 +1,6 @@
 import eslint from '@eslint/js'
 import { defineConfig, globalIgnores } from 'eslint/config'
+import globals from 'globals'
 import tseslint from 'typescript-eslint'
 
 export default defineConfig(
@@ -34,6 +35,12 @@ export default defineConfig(
       }],
     },
   },
+  {
+    files: ['scripts/**/*.js', 'bin/**/*.js'],
+    languageOptions: {
+      globals: globals.node,
+    },
+  },
   {
     files: ['**/*.test.ts', '**/*.spec.ts'],
     rules: {

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@screenly/edge-apps",
-  "version": "0.1.0",
+  "version": "1.0.0-rc.2",
   "description": "A TypeScript library for interfacing with Screenly Edge Apps API",
   "type": "module",
+  "engines": {
+    "node": ">=20.6.0"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "edge-apps-scripts": "./bin/edge-apps-scripts.ts"
+    "edge-apps-scripts": "./bin/edge-apps-scripts.js"
   },
   "exports": {
     ".": {
@@ -55,14 +58,14 @@
     "src/assets"
   ],
   "scripts": {
-    "prepublishOnly": "bun run build",
-    "prebuild": "bun run type-check",
-    "build": "bun build:types && bun run copy:assets",
+    "prepublishOnly": "npm run build",
+    "prebuild": "npm run type-check",
+    "build": "npm run build:types && npm run copy:assets",
     "build:types": "tsc",
-    "copy:assets": "bun run scripts/copy-assets.ts",
-    "test": "bun test --parallel",
-    "test:unit": "bun test --parallel",
-    "test:coverage": "bun test --coverage --parallel",
+    "copy:assets": "node scripts/copy-assets.js",
+    "test": "vitest run",
+    "test:unit": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "lint": "eslint . --fix",
     "format": "prettier --write src/ scripts/ vite-plugins/ README.md index.html",
     "format:check": "prettier --check src/ scripts/ vite-plugins/ README.md index.html",
@@ -76,6 +79,10 @@
   ],
   "author": "Screenly",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Screenly/edge-apps-library"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -105,12 +112,13 @@
     }
   },
   "devDependencies": {
-    "@types/bun": "^1.3.10",
     "@types/jsdom": "^28.0.0",
     "@types/node": "^25.4.0",
     "@types/sharp": "^0.32.0",
-    "bun-types": "^1.3.10",
+    "@vitest/coverage-v8": "^3.2.4",
+    "globals": "^13.24.0",
     "jsdom": "^28.1.0",
-    "prettier": "^3.8.1"
+    "prettier": "^3.8.1",
+    "vitest": "^3.2.4"
   }
 }

package/scripts/{cli.ts → cli.js}

@@ -1,13 +1,11 @@
-#!/usr/bin/env bun
-/**
- * CLI command dispatcher for edge-apps-scripts
- */
+#!/usr/bin/env node
 
-import { execSync, execFileSync, spawn, type ChildProcess } from 'child_process'
+import { execSync, execFileSync, spawn } from 'child_process'
 import fs from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
-import { createCommand } from './create'
+import { createCommand } from './create.js'
+import { start as startCorsProxy } from './cors-proxy-server.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -38,6 +36,10 @@ const commands = {
     description: 'Capture screenshots at all supported resolutions',
     handler: screenshotsCommand,
   },
+  'cors-proxy': {
+    description: 'Start the CORS proxy server for local development',
+    handler: startCorsProxy,
+  },
   create: {
     description:
       'Initialize a scaffolded Edge App (replaces template placeholders)',
@@ -45,20 +47,14 @@ const commands = {
   },
 }
 
-/**
- * Helper: Resolve a binary from the app's node_modules first, falling back to the library's
- */
-function resolveBin(name: string): string {
+function resolveBin(name) {
   const appBin = path.resolve(process.cwd(), 'node_modules', '.bin', name)
   return fs.existsSync(appBin)
     ? appBin
     : path.resolve(libraryRoot, 'node_modules', '.bin', name)
 }
 
-/**
- * Helper: Get NODE_PATH with library's node_modules included
- */
-function getNodePath(): string {
+function getNodePath() {
   const libraryNodeModules = path.resolve(libraryRoot, 'node_modules')
   const existingNodePath = process.env.NODE_PATH || ''
   return existingNodePath
@@ -66,26 +62,16 @@ function getNodePath(): string {
     : libraryNodeModules
 }
 
-/**
- * Helper: Setup signal handlers for spawned processes
- */
-function setupSignalHandlers(child: ChildProcess): void {
-  const handleSignal = (signal: string) => {
-    child.kill(signal as NodeJS.Signals)
+function setupSignalHandlers(child) {
+  const handleSignal = (signal) => {
+    child.kill(signal)
     child.on('exit', () => process.exit(0))
   }
   process.on('SIGINT', () => handleSignal('SIGINT'))
   process.on('SIGTERM', () => handleSignal('SIGTERM'))
 }
 
-/**
- * Helper: Spawn a process with common options and signal handling
- */
-function spawnWithSignalHandling(
-  command: string,
-  args: string[],
-  errorMessage: string,
-): void {
+function spawnWithSignalHandling(command, args, errorMessage) {
   const child = spawn(command, args, {
     stdio: 'inherit',
     cwd: process.cwd(),
@@ -104,17 +90,14 @@ function spawnWithSignalHandling(
   setupSignalHandlers(child)
 }
 
-/**
- * Helper: Get Vite binary and config paths
- */
-function getVitePaths(): { viteBin: string; configPath: string } {
+function getVitePaths() {
   return {
     viteBin: resolveBin('vite'),
     configPath: path.resolve(libraryRoot, 'vite.config.ts'),
   }
 }
 
-async function lintCommand(args: string[]) {
+async function lintCommand(args) {
   try {
     const eslintBin = resolveBin('eslint')
 
@@ -137,7 +120,7 @@ async function lintCommand(args: string[]) {
   }
 }
 
-async function devCommand(args: string[]) {
+async function devCommand(args) {
   try {
     const { viteBin, configPath } = getVitePaths()
     const viteArgs = ['--config', configPath, ...args]
@@ -148,7 +131,7 @@ async function devCommand(args: string[]) {
   }
 }
 
-async function buildCommand(args: string[]) {
+async function buildCommand(args) {
   try {
     const { viteBin, configPath } = getVitePaths()
     const sourcemaps = args.includes('--sourcemaps')
@@ -174,7 +157,7 @@ async function buildCommand(args: string[]) {
   }
 }
 
-async function buildDevCommand(args: string[]) {
+async function buildDevCommand(args) {
   try {
     const { viteBin, configPath } = getVitePaths()
     const viteArgs = [
@@ -192,7 +175,7 @@ async function buildDevCommand(args: string[]) {
   }
 }
 
-async function typeCheckCommand(args: string[]) {
+async function typeCheckCommand(args) {
   try {
     const tscBin = resolveBin('tsc')
 
@@ -212,7 +195,7 @@ async function typeCheckCommand(args: string[]) {
   }
 }
 
-async function convertPngsToWebP(screenshotsDir: string): Promise<void> {
+async function convertPngsToWebP(screenshotsDir) {
   const { default: sharp } = await import('sharp')
   const pngFiles = fs
     .readdirSync(screenshotsDir)
@@ -226,7 +209,7 @@ async function convertPngsToWebP(screenshotsDir: string): Promise<void> {
   }
 }
 
-async function screenshotsCommand(_args: string[]) {
+async function screenshotsCommand(_args) {
   try {
     const playwrightBin = resolveBin('playwright')
     const playwrightConfig = path.resolve(
@@ -280,7 +263,7 @@ export async function run() {
     process.exit(1)
   }
 
-  const handler = commands[cmd as keyof typeof commands].handler
+  const handler = commands[cmd].handler
   await handler(cmdArgs)
 }
 

package/scripts/{copy-assets.ts → copy-assets.js}

@@ -1,7 +1,4 @@
-#!/usr/bin/env bun
-/**
- * Copy assets from src to dist after TypeScript compilation
- */
+#!/usr/bin/env node
 
 import { cpSync, existsSync, mkdirSync } from 'fs'
 import { dirname } from 'path'
@@ -15,10 +12,7 @@ const srcAssets = `${libraryRoot}/src/assets`
 const distAssets = `${libraryRoot}/dist/assets`
 
 if (existsSync(srcAssets)) {
-  // Ensure dist directory exists
   mkdirSync(dirname(distAssets), { recursive: true })
-
-  // Copy assets
   cpSync(srcAssets, distAssets, { recursive: true })
   console.log('✓ Copied assets to dist/')
 } else {

package/scripts/cors-proxy-server.js

@@ -0,0 +1,190 @@
+import http from 'http'
+import https from 'https'
+import { URL } from 'url'
+
+const MAX_REDIRECTS = 10
+
+function setCorsHeaders(res) {
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader(
+    'Access-Control-Allow-Methods',
+    'GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH',
+  )
+  res.setHeader('Access-Control-Allow-Headers', '*')
+  res.setHeader('Access-Control-Max-Age', '86400')
+}
+
+function handleRedirect(
+  location,
+  req,
+  res,
+  proxyRes,
+  currentUrl,
+  redirectCount,
+) {
+  if (redirectCount >= MAX_REDIRECTS) {
+    proxyRes.resume()
+    res.writeHead(508, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify({ error: 'Too many redirects' }))
+    return
+  }
+
+  try {
+    const redirectUrl = new URL(location, currentUrl)
+    if (redirectUrl.protocol !== 'http:' && redirectUrl.protocol !== 'https:') {
+      proxyRes.resume()
+      res.writeHead(502, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ error: 'Invalid redirect location' }))
+      return
+    }
+    const redirectModule = redirectUrl.protocol === 'https:' ? https : http
+    proxyRes.resume()
+    makeProxyRequest(redirectModule, redirectUrl, req, res, redirectCount + 1)
+  } catch {
+    proxyRes.resume()
+    res.writeHead(502, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify({ error: 'Invalid redirect location' }))
+  }
+}
+
+function handleProxyResponse(proxyRes, req, res, currentUrl, redirectCount) {
+  if (
+    proxyRes.statusCode >= 301 &&
+    proxyRes.statusCode <= 308 &&
+    proxyRes.headers.location &&
+    ['GET', 'HEAD'].includes(req.method)
+  ) {
+    handleRedirect(
+      proxyRes.headers.location,
+      req,
+      res,
+      proxyRes,
+      currentUrl,
+      redirectCount,
+    )
+    return
+  }
+
+  const excludeHeaders = [
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailers',
+    'transfer-encoding',
+    'upgrade',
+  ]
+
+  Object.keys(proxyRes.headers).forEach((key) => {
+    if (!excludeHeaders.includes(key.toLowerCase())) {
+      res.setHeader(key, proxyRes.headers[key])
+    }
+  })
+
+  setCorsHeaders(res)
+  res.writeHead(proxyRes.statusCode)
+  proxyRes.pipe(res)
+}
+
+function makeProxyRequest(httpModule, parsedUrl, req, res, redirectCount = 0) {
+  const options = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
+    path: parsedUrl.pathname + parsedUrl.search,
+    method: req.method,
+    headers: {
+      ...req.headers,
+      host: parsedUrl.host,
+    },
+    rejectUnauthorized: false,
+  }
+
+  delete options.headers['x-forwarded-for']
+  delete options.headers['x-forwarded-proto']
+  delete options.headers['x-forwarded-host']
+
+  const proxyReq = httpModule.request(options, (proxyRes) =>
+    handleProxyResponse(proxyRes, req, res, parsedUrl, redirectCount),
+  )
+
+  proxyReq.on('error', (error) => {
+    console.error('Proxy error:', error.message)
+    if (!res.headersSent) {
+      res.writeHead(500, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ error: 'Proxy error', message: error.message }))
+    }
+  })
+
+  proxyReq.setTimeout(30000, () => {
+    proxyReq.destroy()
+    if (!res.headersSent) {
+      res.writeHead(504, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ error: 'Gateway timeout' }))
+    }
+  })
+
+  if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+    req.pipe(proxyReq)
+  } else {
+    proxyReq.end()
+  }
+}
+
+function handleProxyRequest(req, res) {
+  setCorsHeaders(res)
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(200)
+    res.end()
+    return
+  }
+
+  const urlMatch = req.url.match(/^\/(https?:\/\/.+)$/)
+
+  if (!urlMatch) {
+    res.writeHead(400, { 'Content-Type': 'application/json' })
+    res.end(
+      JSON.stringify({
+        error: 'Invalid request format. Expected: /{protocol}://{host}/{path}',
+      }),
+    )
+    return
+  }
+
+  const targetUrl = urlMatch[1]
+
+  try {
+    const parsedUrl = new URL(targetUrl)
+    console.log(`Proxying ${req.method} request to: ${targetUrl}`)
+
+    const httpModule = parsedUrl.protocol === 'https:' ? https : http
+    makeProxyRequest(httpModule, parsedUrl, req, res)
+  } catch (error) {
+    console.error('Invalid URL:', targetUrl, error.message)
+    res.writeHead(400, { 'Content-Type': 'application/json' })
+    res.end(
+      JSON.stringify({
+        error: 'Invalid URL format',
+        message: error.message,
+      }),
+    )
+  }
+}
+
+export function start() {
+  const host = process.env.HOST || '0.0.0.0'
+  const port = process.env.PORT || 8080
+
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+
+  const server = http.createServer((req, res) => {
+    handleProxyRequest(req, res)
+  })
+
+  server.listen(port, host, () => {
+    console.log(
+      `Running CORS Proxy (Node.js built-ins) on http://${host}:${port}`,
+    )
+  })
+}

package/scripts/{create.ts → create.js}

@@ -21,15 +21,15 @@ const TEXT_EXTENSIONS = new Set([
 
 const SKIP_DIRS = new Set(['node_modules', 'dist', '.git'])
 
-function toTitleCase(kebab: string): string {
+function toTitleCase(kebab) {
   return kebab
     .split('-')
     .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
     .join(' ')
 }
 
-function walkTextFiles(dir: string): string[] {
-  const results: string[] = []
+function walkTextFiles(dir) {
+  const results = []
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     const fullPath = path.join(dir, entry.name)
     if (entry.isDirectory()) {
@@ -45,10 +45,7 @@ function walkTextFiles(dir: string): string[] {
   return results
 }
 
-function replaceInFile(
-  filePath: string,
-  replacements: Record<string, string>,
-): void {
+function replaceInFile(filePath, replacements) {
   const original = fs.readFileSync(filePath, 'utf-8')
   const updated = Object.entries(replacements).reduce(
     (src, [placeholder, value]) => src.replaceAll(placeholder, value),
@@ -57,11 +54,11 @@ function replaceInFile(
   if (updated !== original) fs.writeFileSync(filePath, updated, 'utf-8')
 }
 
-export async function createCommand(_args: string[]) {
+export async function createCommand(_args) {
   const projectRoot = process.cwd()
   const pkgPath = path.join(projectRoot, 'package.json')
 
-  let pkg: Record<string, unknown>
+  let pkg
   try {
     pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
   } catch (error) {
@@ -84,7 +81,7 @@ export async function createCommand(_args: string[]) {
   const appTitle = toTitleCase(appName)
   const appDescription = `${appTitle} - Screenly Edge App`
 
-  const replacements: Record<string, string> = {
+  const replacements = {
     '{{APP_NAME}}': appName,
     '{{APP_TITLE}}': appTitle,
     '{{APP_DESCRIPTION}}': appDescription,
@@ -107,12 +104,12 @@ Next steps:
   1. Add an id field to screenly.yml and screenly_qc.yml.
 
   2. Install dependencies:
-       bun install
+       npm install
 
   3. Start the dev server:
-       bun run dev
+       npm run dev
 
   4. Deploy when ready:
-       bun run deploy
+       npm run deploy
 `)
 }

package/tsconfig.json

@@ -14,7 +14,7 @@
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
     "allowSyntheticDefaultImports": true,
-    "types": ["bun-types", "vite/client"]
+    "types": ["vite/client"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "**/*.test.ts"]

package/bin/edge-apps-scripts.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Edge Apps Scripts CLI
- * Wrapper around build tools for Edge Apps
- */
-
-import { run } from '../scripts/cli'
-
-run()

package/scripts/cors-proxy-server.ts

@@ -1,154 +0,0 @@
-import http from 'http'
-import https from 'https'
-import { URL } from 'url'
-
-// Listen on a specific host via the HOST environment variable
-const host = process.env.HOST || '0.0.0.0'
-// Listen on a specific port via the PORT environment variable
-const port = process.env.PORT || 8080
-
-// This script is for development purposes only and should never be deployed to production.
-// Disabling TLS certificate validation is a critical security risk.
-// Only use this in local development environments.
-process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
-
-function setCorsHeaders(res: http.ServerResponse) {
-  res.setHeader('Access-Control-Allow-Origin', '*')
-  res.setHeader(
-    'Access-Control-Allow-Methods',
-    'GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH',
-  )
-  res.setHeader('Access-Control-Allow-Headers', '*')
-  res.setHeader('Access-Control-Max-Age', '86400')
-}
-
-function makeProxyRequest(
-  httpModule: typeof http | typeof https,
-  parsedUrl: URL,
-  req: http.IncomingMessage,
-  res: http.ServerResponse,
-) {
-  const options = {
-    hostname: parsedUrl.hostname,
-    port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
-    path: parsedUrl.pathname + parsedUrl.search,
-    method: req.method,
-    headers: {
-      ...req.headers,
-      host: parsedUrl.host,
-    },
-    rejectUnauthorized: false,
-  }
-
-  delete options.headers['x-forwarded-for']
-  delete options.headers['x-forwarded-proto']
-  delete options.headers['x-forwarded-host']
-
-  const proxyReq = httpModule.request(options, (proxyRes) => {
-    const excludeHeaders = [
-      'connection',
-      'keep-alive',
-      'proxy-authenticate',
-      'proxy-authorization',
-      'te',
-      'trailers',
-      'transfer-encoding',
-      'upgrade',
-    ]
-
-    Object.keys(proxyRes.headers).forEach((key) => {
-      if (!excludeHeaders.includes(key.toLowerCase())) {
-        res.setHeader(key, proxyRes.headers[key])
-      }
-    })
-
-    res.writeHead(proxyRes.statusCode)
-    proxyRes.pipe(res)
-  })
-
-  proxyReq.on('error', (error) => {
-    console.error('Proxy error:', error.message)
-    if (!res.headersSent) {
-      res.writeHead(500, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          error: 'Proxy error',
-          message: error.message,
-        }),
-      )
-    }
-  })
-
-  proxyReq.setTimeout(30000, () => {
-    proxyReq.destroy()
-    if (!res.headersSent) {
-      res.writeHead(504, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          error: 'Gateway timeout',
-        }),
-      )
-    }
-  })
-
-  if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
-    req.pipe(proxyReq)
-  } else {
-    proxyReq.end()
-  }
-}
-
-function handleProxyRequest(
-  req: http.IncomingMessage,
-  res: http.ServerResponse,
-) {
-  setCorsHeaders(res)
-
-  if (req.method === 'OPTIONS') {
-    res.writeHead(200)
-    res.end()
-    return
-  }
-
-  const urlMatch = req.url.match(/^\/(https?:\/\/.+)$/)
-
-  if (!urlMatch) {
-    res.writeHead(400, { 'Content-Type': 'application/json' })
-    res.end(
-      JSON.stringify({
-        error: 'Invalid request format. Expected: /{protocol}://{host}/{path}',
-      }),
-    )
-    return
-  }
-
-  const targetUrl = urlMatch[1]
-
-  try {
-    const parsedUrl = new URL(targetUrl)
-    console.log(`Proxying ${req.method} request to: ${targetUrl}`)
-
-    const httpModule = parsedUrl.protocol === 'https:' ? https : http
-    makeProxyRequest(httpModule, parsedUrl, req, res)
-  } catch (error) {
-    console.error('Invalid URL:', targetUrl, error.message)
-    res.writeHead(400, { 'Content-Type': 'application/json' })
-    res.end(
-      JSON.stringify({
-        error: 'Invalid URL format',
-        message: error.message,
-      }),
-    )
-  }
-}
-
-const server = http.createServer((req, res) => {
-  handleProxyRequest(req, res)
-})
-
-// Start the server
-server.listen(port, host, () => {
-  console.log(
-    `Running CORS Proxy (Node.js built-ins) on http://${host}:${port}`,
-  )
-})