@stacksjs/rpx 0.10.0 → 0.11.0

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 import type { ProxyConfig } from './types';
-
+export declare function getConfig(): Promise<ProxyConfig>;
 export declare const defaultConfig: ProxyConfig;
+// For backwards compatibility - synchronous access with default fallback
 export declare const config: ProxyConfig;

package/dist/dns.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Start the DNS server
+ */
+export declare function startDnsServer(domains: string[], verbose?: boolean): Promise<boolean>;
+/**
+ * Stop the DNS server
+ */
+export declare function stopDnsServer(verbose?: boolean): void;
+/**
+ * Check if DNS server is running
+ */
+export declare function isDnsServerRunning(): boolean;
+/**
+ * Set up the macOS resolver for configured domains
+ * Creates /etc/resolver/<tld> files pointing to our local DNS server
+ */
+export declare function setupResolver(verbose?: boolean, domains?: string[]): Promise<boolean>;
+/**
+ * Remove the macOS resolver files we created
+ */
+export declare function removeResolver(verbose?: boolean): Promise<void>;

package/dist/hosts.d.ts

@@ -1,6 +1,4 @@
-declare const execAsync: unknown;
-export declare const hostsFilePath: string;
-declare function execSudo(command: string): Promise<void>;
 export declare function addHosts(hosts: string[], verbose?: boolean): Promise<void>;
 export declare function removeHosts(hosts: string[], verbose?: boolean): Promise<void>;
-export declare function checkHosts(hosts: string[], verbose?: boolean): Promise<boolean[]>;
+export declare function checkHosts(hosts: string[], verbose?: boolean): Promise<boolean[]>;
+export declare const hostsFilePath: string;

package/dist/https.d.ts

@@ -1,12 +1,39 @@
-import type { ProxyConfigs, ProxyOption, ProxyOptions, TlsConfig } from './types';
-
+import { config } from './config';
+import type { ProxyConfigs, ProxyOption, ProxyOptions, SSLConfig, TlsConfig } from './types';
+/**
+ * Resolves SSL paths based on configuration
+ */
 export declare function resolveSSLPaths(options: ProxyConfigs, defaultConfig: typeof config): TlsConfig;
+// Generate wildcard patterns for a domain
 export declare function generateWildcardPatterns(domain: string): string[];
-export declare function generateSSLPaths(options?: ProxyOptions): void;
+/**
+ * Generates SSL file paths based on domain
+ */
+export declare function generateSSLPaths(options?: ProxyOptions): {
+  caCertPath: string
+  certPath: string
+  keyPath: string
+};
 export declare function getAllDomains(options: ProxyOption | ProxyOptions): Set<string>;
+/**
+ * Load SSL certificates from files or use provided strings
+ */
 export declare function loadSSLConfig(options: ProxyOption): Promise<SSLConfig | null>;
+/**
+ * Force trust a certificate - exposing for direct use
+ */
+export declare function forceTrustCertificate(certPath: string): Promise<boolean>;
 export declare function generateCertificate(options: ProxyOptions): Promise<void>;
-export declare function getSSLConfig(): void;
+export declare function getSSLConfig(): { key: string, cert: string, ca?: string } | null;
+// needs to accept the options
 export declare function checkExistingCertificates(options?: ProxyOptions): Promise<SSLConfig | null>;
 export declare function httpsConfig(options: ProxyOption | ProxyOptions, verbose?: boolean): TlsConfig;
-export declare function cleanupCertificates(domain: string, verbose?: boolean): Promise<void>;
+/**
+ * Clean up SSL certificates for a specific domain
+ */
+export declare function cleanupCertificates(domain: string, verbose?: boolean): Promise<void>;
+/**
+ * Checks if a certificate is trusted by the system (macOS only for now)
+ * If options.regenerateUntrustedCerts is false, always returns true (skips trust check)
+ */
+export declare function isCertTrusted(certPath: string, options?: { verbose?: boolean, regenerateUntrustedCerts?: boolean }): Promise<boolean>;

package/dist/index.d.ts

@@ -1,12 +1,21 @@
-import { startProxies } from './start';
-
-
-export { config } from './config'
-
-export * from './hosts'
-export * from './https'
-export * from './start'
-export * from './types'
-export * from './utils'
-
-export default startProxies;
+export { config, config as defaultConfig } from './config';
+export {
+  addHosts,
+  checkHosts,
+  removeHosts,
+} from './hosts';
+export {
+  checkExistingCertificates,
+  cleanupCertificates,
+  forceTrustCertificate,
+  generateCertificate,
+  httpsConfig,
+  isCertTrusted,
+  loadSSLConfig,
+} from './https';
+export { DefaultPortManager, findAvailablePort, isPortInUse, portManager } from './port-manager';
+export { cleanup } from './start';
+export { startProxies, startProxy, startServer } from './start';
+export * from './types';
+export * from './utils';
+export default startProxiesFunc;

package/dist/logger.d.ts

@@ -0,0 +1,10 @@
+export declare const log: {
+  info: (...args: any[]) => void
+  success: (...args: any[]) => void
+  warn: (...args: any[]) => void
+  error: (...args: any[]) => void
+  debug: (...args: any[]) => void
+  log: (...args: any[]) => void
+  start: (...args: any[]) => void
+  box: (...args: any[]) => void
+};

package/dist/port-manager.d.ts

@@ -0,0 +1,25 @@
+import type { PortManager } from './types';
+/**
+ * Check if a port is in use
+ */
+export declare function isPortInUse(port: number, hostname: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Find next available port
+ */
+export declare function findAvailablePort(startPort: number, hostname: string, verbose?: boolean, maxAttempts?: any): Promise<number>;
+/**
+ * Test if a port is actually connectable
+ */
+export declare function testPortConnectivity(port: number, hostname: string, timeout?: any, verbose?: boolean): Promise<boolean>;
+// Global port manager instance
+export declare const portManager: DefaultPortManager;
+export declare class DefaultPortManager implements PortManager {
+  usedPorts: Set<number>;
+  private hostname: string;
+  private verbose?: boolean;
+  private maxRetries: number;
+  constructor(hostname?: string, verbose?: boolean, maxRetries?: any);
+  getNextAvailablePort(startPort: number, testConnectivity?: any): Promise<number>;
+  private findNextAvailablePort(startPort: number, testConnectivity?: any): Promise<number>;
+  releasePort(port: number): void;
+}

package/dist/process-manager.d.ts

@@ -1,6 +1,6 @@
 import type { ChildProcess } from 'node:child_process';
 import type { StartOptions } from './types';
-
+export declare const processManager: ProcessManager;
 export declare interface ManagedProcess {
   command: string
   cwd: string
@@ -8,145 +8,10 @@ export declare interface ManagedProcess {
   env?: Record<string, string>
 }
 export declare class ProcessManager {
-  private processes: Map<string, ManagedProcess> = new Map()
-  private isShuttingDown = false
-
-  async startProcess(id: string, options: StartOptions, verbose?: boolean): Promise<void> {
-    if (this.processes.has(id)) {
-      debugLog('start', `Process ${id} is already running`, verbose)
-      return
-    }
-
-    const [cmd, ...args] = options.command.split(' ')
-    const cwd = options.cwd || process.cwd()
-
-    debugLog('start', `Starting process ${id}:`, verbose)
-    debugLog('start', `  Command: ${cmd} ${args.join(' ')}`, verbose)
-    debugLog('start', `  Working directory: ${cwd}`, verbose)
-    debugLog('start', `  Environment variables: ${JSON.stringify(options.env)}`, verbose)
-
-    const childProcess = spawn(cmd, args, {
-      cwd,
-      env: { ...process.env, ...options.env },
-      shell: true,
-      stdio: 'inherit',
-    })
-
-    this.processes.set(id, {
-      command: options.command,
-      cwd,
-      process: childProcess,
-      env: options.env,
-    })
-
-    return new Promise((resolve, reject) => {
-      childProcess.on('error', (err) => {
-        if (!this.isShuttingDown) {
-          debugLog('start', `Process ${id} failed to start: ${err}`, verbose)
-          this.processes.delete(id)
-          reject(err)
-          process.emit('SIGINT')
-        }
-      })
-
-      childProcess.on('exit', (code) => {
-        if (!this.isShuttingDown && code !== null && code !== 0) {
-          debugLog('start', `Process ${id} exited with code ${code}`, verbose)
-          this.processes.delete(id)
-          reject(new Error(`Process ${id} exited with code ${code}`))
-          process.emit('SIGINT')
-        }
-      })
-
-      if (verbose) {
-        childProcess.stdout?.on('data', (data) => {
-          debugLog('process', `[${id}] ${data.toString().trim()}`, true)
-        })
-
-        childProcess.stderr?.on('data', (data) => {
-          debugLog('process', `[${id}] ERR: ${data.toString().trim()}`, true)
-        })
-      }
-
-      setTimeout(() => {
-        if (!this.isShuttingDown && childProcess.killed) {
-          this.processes.delete(id)
-          reject(new Error(`Process ${id} was killed during startup`))
-        }
-        else {
-          debugLog('start', `Process ${id} started successfully`, verbose)
-          resolve()
-        }
-      }, 1000)
-    })
-  }
-
-  async stopProcess(id: string, verbose?: boolean): Promise<void> {
-    const managed = this.processes.get(id)
-    if (!managed?.process) {
-      debugLog('start', `No process found for ${id}`, verbose)
-      return
-    }
-
-    debugLog('start', `Stopping process ${id}`, verbose)
-
-    return new Promise((resolve) => {
-      if (!managed.process) {
-        resolve()
-        return
-      }
-
-      managed.process.once('exit', () => {
-        this.processes.delete(id)
-        debugLog('start', `Process ${id} stopped`, verbose)
-        resolve()
-      })
-
-      try {
-        managed.process.kill('SIGTERM')
-
-        setTimeout(() => {
-          if (managed.process) {
-            debugLog('start', `Force killing process ${id}`, verbose)
-            try {
-              managed.process.kill('SIGKILL')
-            }
-            catch (err) {
-            }
-          }
-        }, 3000)
-      }
-      catch (err) {
-        debugLog('start', `Error stopping process ${id}: ${err}`, verbose)
-        this.processes.delete(id)
-        resolve()
-      }
-    })
-  }
-
-  async stopAll(verbose?: boolean): Promise<void> {
-    if (this.isShuttingDown) {
-      debugLog('start', 'Already shutting down, skipping duplicate stopAll call', verbose)
-      return
-    }
-
-    this.isShuttingDown = true
-    debugLog('start', 'Stopping all processes', verbose)
-
-    const promises = Array.from(this.processes.keys()).map(id =>
-      this.stopProcess(id, verbose).catch((err) => {
-        log.error(`Failed to stop process ${id}:`, err)
-      }),
-    )
-
-    await Promise.allSettled(promises)
-    this.processes.clear()
-    this.isShuttingDown = false
-  }
-
-  isRunning(id: string): boolean {
-    const managed = this.processes.get(id)
-    return !!managed?.process && !managed.process.killed
-  }
-}
-export declare const processManager: ProcessManager;
+  private processes: Map<string, ManagedProcess>;
+  private isShuttingDown: any;
+  startProcess(id: string, options: StartOptions, verbose?: boolean): Promise<void>;
+  stopProcess(id: string, verbose?: boolean): Promise<void>;
+  stopAll(verbose?: boolean): Promise<void>;
+  isRunning(id: string): boolean;
+}

package/dist/src/index.js

@@ -1 +1 @@
-import{A as Q,B as R,C as S,D as T,E as U,F as o,b as r,c as j,d as k,e as n,f as q,g as v,h as w,i as y,j as z,k as A,l as B,m as C,n as D,o as E,p as F,q as G,r as H,s as I,t as J,u as K,v as L,w as M,x as N,y as O}from"../chunk-1rkjbws7.js";import"../chunk-ny83tnrp.js";import"../chunk-7am1svx0.js";var i=o;export{R as startServer,U as startProxy,o as startProxies,T as startHttpRedirectServer,S as setupProxy,A as safeDeleteFile,F as resolveSSLPaths,D as removeHosts,J as loadSSLConfig,n as isValidRootCA,y as isSingleProxyOptions,z as isSingleProxyConfig,w as isMultiProxyOptions,v as isMultiProxyConfig,N as httpsConfig,B as hostsFilePath,L as getSSLConfig,q as getPrimaryDomain,I as getAllDomains,G as generateWildcardPatterns,H as generateSSLPaths,K as generateCertificate,k as extractHostname,i as default,j as debugLog,r as config,O as cleanupCertificates,Q as cleanup,E as checkHosts,M as checkExistingCertificates,C as addHosts};
+import{b as o,c as t,d as e,e as f,f as a,g as i,h as s,i as p,j as c,k as x,l as n,m,n as g,o as C,p as P,r as l,s as d,t as u,u as r}from"../chunk-szmp12hh.js";import"../chunk-b6654twv.js";import{C as L,D as U,E as j,F as q,G as z,H as B,I as G,J as I,K as J,L as K,M as N}from"../chunk-4csm61sj.js";import"../chunk-4960052z.js";var F=r;export{d as startServer,u as startProxy,r as startProxies,N as safeDeleteFile,e as removeHosts,P as portManager,a as loadSSLConfig,z as isValidRootCA,J as isSingleProxyOptions,K as isSingleProxyConfig,m as isPortInUse,I as isMultiProxyOptions,G as isMultiProxyConfig,n as isCertTrusted,c as httpsConfig,L as getSudoPassword,B as getPrimaryDomain,s as generateCertificate,i as forceTrustCertificate,g as findAvailablePort,q as extractHostname,U as execSudoSync,o as defaultConfig,F as default,j as debugLog,o as config,x as cleanupCertificates,l as cleanup,f as checkHosts,p as checkExistingCertificates,t as addHosts,C as DefaultPortManager};

package/dist/start.d.ts

@@ -1,94 +1,10 @@
-import type { CleanupOptions, ProxyOption } from './types';
-import type { IncomingHttpHeaders } from 'node:http2';
-
-declare const activeServers: Set<http.Server | https.Server>;
-declare type AnyServerType = http.Server | https.Server | http2.Http2SecureServer
-type AnyIncomingMessage = http.IncomingMessage | http2.Http2ServerRequest
-type AnyServerResponse = http.ServerResponse | http2.Http2ServerResponse
-
-let isCleaningUp = false
-
-export async function cleanup(options?: CleanupOptions): Promise<void> {
-  if (isCleaningUp) {
-    debugLog('cleanup', 'Cleanup already in progress, skipping', options?.verbose)
-    return
-  }
-
-  isCleaningUp = true
-  debugLog('cleanup', 'Starting cleanup process', options?.verbose)
-
-  try {
-    await processManager.stopAll(options?.verbose)
-
-    log.info('Shutting down proxy servers...')
-
-    const cleanupPromises: Promise<void>[] = []
-
-    const serverClosePromises = Array.from(activeServers).map(server =>
-      new Promise<void>((resolve) => {
-        server.close(() => {
-          debugLog('cleanup', 'Server closed successfully', options?.verbose)
-          resolve()
-        })
-      }),
-    )
-    cleanupPromises.push(...serverClosePromises)
-
-    if (options?.hosts && options.domains?.length) {
-      debugLog('cleanup', 'Cleaning up hosts file entries', options?.verbose)
-      const domainsToClean = options.domains.filter(domain => !domain.includes('localhost'))
-
-      if (domainsToClean.length > 0) {
-        log.info('Cleaning up hosts file entries...')
-        cleanupPromises.push(
-          removeHosts(domainsToClean, options?.verbose)
-            .then(() => {
-              debugLog('cleanup', `Removed hosts entries for ${domainsToClean.join(', ')}`, options?.verbose)
-            })
-            .catch((err) => {
-              debugLog('cleanup', `Failed to remove hosts entries: ${err}`, options?.verbose)
-              log.warn(`Failed to clean up hosts file entries for ${domainsToClean.join(', ')}:`, err)
-            }),
-        )
-      }
-    }
-
-    if (options?.certs && options.domains?.length) {
-      debugLog('cleanup', 'Cleaning up SSL certificates', options?.verbose)
-      log.info('Cleaning up SSL certificates...')
-
-      const certCleanupPromises = options.domains.map(async (domain) => {
-        try {
-          await cleanupCertificates(domain, options?.verbose)
-          debugLog('cleanup', `Removed certificates for ${domain}`, options?.verbose)
-        }
-        catch (err) {
-          debugLog('cleanup', `Failed to remove certificates for ${domain}: ${err}`, options?.verbose)
-          log.warn(`Failed to clean up certificates for ${domain}:`, err)
-        }
-      })
-
-      cleanupPromises.push(...certCleanupPromises)
-    }
-
-    await Promise.allSettled(cleanupPromises)
-    debugLog('cleanup', 'All cleanup tasks completed successfully', options?.verbose)
-    log.success('All cleanup tasks completed successfully')
-  }
-  catch (err) {
-    debugLog('cleanup', `Error during cleanup: ${err}`, options?.verbose)
-    log.error('Error during cleanup:', err)
-  }
-  finally {
-    isCleaningUp = false
-    process.exit(0)
-  }
-}
-
-let isHandlingSignal = false
-declare function signalHandler(): void;
-declare function isPortInUse(port: number, hostname: string, verbose?: boolean): Promise<boolean>;
-declare function normalizeHeaders(headers: IncomingHttpHeaders): http.OutgoingHttpHeaders;
-declare function setupServer(serverInstance: AnyServerType): void;
+import type { CleanupOptions, ProxyOption, ProxyOptions, ProxySetupOptions, SingleProxyConfig } from './types';
+export declare function cleanup(options?: CleanupOptions): Promise<void>;
+export declare function startServer(options: SingleProxyConfig): Promise<void>;
+export declare function setupProxy(options: ProxySetupOptions): Promise<void>;
 export declare function startHttpRedirectServer(verbose?: boolean): void;
-export declare function startProxy(options: ProxyOption): void;
+export declare function startProxy(options: ProxyOption): void;
+export declare function startProxies(options?: ProxyOptions): Promise<void>;
+declare type AnyServerType = http.Server | https.Server | http2.Http2SecureServer
+declare type AnyIncomingMessage = http.IncomingMessage | http2.Http2ServerRequest
+declare type AnyServerResponse = http.ServerResponse | http2.Http2ServerResponse

package/dist/types.d.ts

@@ -1,28 +1,23 @@
 import type { TlsConfig, TlsOption } from '@stacksjs/tlsx';
-
-export type { TlsConfig, TlsOption }
+export type { TlsConfig, TlsOption };
 export declare interface StartOptions {
   command: string
   cwd?: string
   env?: Record<string, string>
 }
 export declare interface BaseProxyConfig {
-  from: string 
-  to: string 
+  from: string
+  to: string
   start?: StartOptions
 }
-export declare type BaseProxyOptions = Partial<BaseProxyConfig>
-
-export interface CleanupConfig {
-  domains: string[] 
-  hosts: boolean 
-  certs: boolean 
-  verbose: boolean 
+export declare interface CleanupConfig {
+  domains: string[]
+  hosts: boolean
+  certs: boolean
+  verbose: boolean
+  vitePluginUsage?: boolean
 }
-
-export type CleanupOptions = Partial<CleanupConfig>
-
-export interface SharedProxyConfig {
+export declare interface SharedProxyConfig {
   https: boolean | TlsOption
   cleanup: boolean | CleanupOptions
   vitePluginUsage: boolean
@@ -30,30 +25,21 @@ export interface SharedProxyConfig {
   _cachedSSLConfig?: SSLConfig | null
   start?: StartOptions
   cleanUrls: boolean
+  changeOrigin?: boolean
+  regenerateUntrustedCerts?: boolean
 }
+export declare interface SingleProxyConfig extends BaseProxyConfig, SharedProxyConfig {
 
-export type SharedProxyOptions = Partial<SharedProxyConfig>
-
-export interface SingleProxyConfig extends BaseProxyConfig, SharedProxyConfig {}
-
-export interface MultiProxyConfig extends SharedProxyConfig {
+}
+export declare interface MultiProxyConfig extends SharedProxyConfig {
   proxies: Array<BaseProxyConfig & { cleanUrls: boolean }>
 }
-
-export type ProxyConfig = SingleProxyConfig
-export type ProxyConfigs = SingleProxyConfig | MultiProxyConfig
-
-export type BaseProxyOption = Partial<BaseProxyConfig>
-export type ProxyOption = Partial<SingleProxyConfig>
-export type ProxyOptions = Partial<SingleProxyConfig> | Partial<MultiProxyConfig>
-
-export interface SSLConfig {
+export declare interface SSLConfig {
   key: string
   cert: string
   ca?: string | string[]
 }
-
-export interface ProxySetupOptions extends Omit<ProxyOption, 'from'> {
+export declare interface ProxySetupOptions extends Omit<ProxyOption, 'from'> {
   fromPort: number
   sourceUrl: Pick<URL, 'hostname' | 'host'>
   ssl: SSLConfig | null
@@ -61,8 +47,15 @@ export interface ProxySetupOptions extends Omit<ProxyOption, 'from'> {
   to: string
   portManager?: PortManager
 }
-
-export interface PortManager {
+export declare interface PortManager {
   usedPorts: Set<number>
   getNextAvailablePort: (startPort: number) => Promise<number>
-}
+}
+export type BaseProxyOptions = Partial<BaseProxyConfig>
+export type CleanupOptions = Partial<CleanupConfig>
+export type SharedProxyOptions = Partial<SharedProxyConfig>
+export type ProxyConfig = SingleProxyConfig
+export type ProxyConfigs = SingleProxyConfig | MultiProxyConfig
+export type BaseProxyOption = Partial<BaseProxyConfig>
+export type ProxyOption = Partial<SingleProxyConfig>
+export type ProxyOptions = Partial<SingleProxyConfig> | Partial<MultiProxyConfig>

package/dist/utils.d.ts

@@ -1,15 +1,37 @@
-import type { ProxyConfigs, ProxyOption } from './types';
-
+import type { MultiProxyConfig, ProxyConfigs, ProxyOption, ProxyOptions, SingleProxyConfig } from './types';
+/**
+ * Get sudo password from environment variable if set
+ */
+export declare function getSudoPassword(): string | undefined;
+/**
+ * Execute a command with sudo, using SUDO_PASSWORD if available
+ */
+export declare function execSudoSync(command: string): string;
 export declare function debugLog(category: string, message: string, verbose?: boolean): void;
+/**
+ * Extracts hostnames from proxy configuration
+ */
 export declare function extractHostname(options: ProxyOption | ProxyOptions): string[];
-declare interface RootCA {
-  certificate: string
-  privateKey: string
-}
 export declare function isValidRootCA(value: unknown): value is RootCA;
 export declare function getPrimaryDomain(options?: ProxyOption | ProxyOptions): string;
+/**
+ * Type guard for multi-proxy configuration
+ */
 export declare function isMultiProxyConfig(options: ProxyConfigs | ProxyOptions): options is MultiProxyConfig;
+/**
+ * Type guard to check if options are for multi-proxy configuration
+ */
 export declare function isMultiProxyOptions(options: ProxyOption | ProxyOptions): options is MultiProxyConfig;
+/**
+ * Type guard to check if options are for single-proxy configuration
+ */
 export declare function isSingleProxyOptions(options: ProxyOption | ProxyOptions): options is SingleProxyConfig;
 export declare function isSingleProxyConfig(options: ProxyConfigs | ProxyOptions): options is SingleProxyConfig;
-export declare function safeDeleteFile(filePath: string, verbose?: boolean): Promise<void>;
+/**
+ * Safely delete a file if it exists
+ */
+export declare function safeDeleteFile(filePath: string, verbose?: boolean): Promise<void>;
+declare interface RootCA {
+  certificate: string
+  privateKey: string
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/rpx",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A modern and smart reverse proxy.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -26,6 +26,7 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/src/index.js"
     }
   },
@@ -35,7 +36,10 @@
     "rpx": "./dist/bin/cli.js",
     "reverse-proxy": "./dist/bin/cli.js"
   },
-  "files": ["README.md", "dist"],
+  "files": [
+    "README.md",
+    "dist"
+  ],
   "scripts": {
     "build": "bun build.ts && bun run compile",
     "compile": "bun build ./bin/cli.ts --compile --minify --outfile bin/rpx",
@@ -49,41 +53,32 @@
     "lint:fix": "bunx --bun eslint . --fix",
     "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
     "changelog": "changelogen --output CHANGELOG.md",
-    "prepublishOnly": "bun --bun run build && bun run compile:all",
-    "release": "bun run changelog && bumpp package.json --all",
+    "prepublishOnly": "bun --bun run build && bun run compile:all && bun run zip",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
-    "dev:docs": "bun --bun vitepress dev docs",
-    "build:docs": "bun --bun vitepress build docs",
-    "preview:docs": "bun --bun vitepress preview docs"
+    "zip": "bun run zip:all",
+    "zip:all": "bun run zip:linux-x64 && bun run zip:linux-arm64 && bun run zip:windows-x64 && bun run zip:darwin-x64 && bun run zip:darwin-arm64",
+    "zip:linux-x64": "zip -j bin/rpx-linux-x64.zip bin/rpx-linux-x64",
+    "zip:linux-arm64": "zip -j bin/rpx-linux-arm64.zip bin/rpx-linux-arm64",
+    "zip:windows-x64": "zip -j bin/rpx-windows-x64.zip bin/rpx-windows-x64.exe",
+    "zip:darwin-x64": "zip -j bin/rpx-darwin-x64.zip bin/rpx-darwin-x64",
+    "zip:darwin-arm64": "zip -j bin/rpx-darwin-arm64.zip bin/rpx-darwin-arm64"
   },
   "devDependencies": {
-    "@iconify-json/carbon": "^1.2.5",
-    "@shikijs/vitepress-twoslash": "^2.1.0",
-    "@stacksjs/eslint-config": "^3.15.1-beta.4",
     "@stacksjs/tlsx": "^0.10.0",
-    "@types/bun": "^1.2.0",
-    "@vite-pwa/vitepress": "^0.5.3",
-    "bumpp": "^10.0.1",
-    "bun-plugin-dtsx": "^0.21.9",
-    "bunfig": "^0.5.3",
+    "bun-plugin-dtsx": "^0.21.17",
+    "bunfig": "^0.15.6",
     "cac": "^6.7.14",
-    "changelogen": "^0.5.7",
-    "consola": "^3.4.0",
-    "typescript": "^5.7.3",
-    "unocss": "^65.4.3",
-    "unplugin-icons": "^22.0.0",
-    "unplugin-vue-components": "^28.0.0",
-    "vite-plugin-pwa": "^0.21.1",
-    "vitepress": "^1.6.3"
-  },
-  "overrides": {
-    "unconfig": "0.3.10"
+    "consola": "^3.4.2",
+    "typescript": "^5.9.3"
   },
   "simple-git-hooks": {
     "pre-commit": "bunx lint-staged"
   },
   "lint-staged": {
     "*.{js,ts}": "bunx eslint . --fix"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.1"
   }
 }