@stacksjs/tunnel 0.70.55 → 0.70.57

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/tunnel",
   "type": "module",
-  "version": "0.70.55",
+  "version": "0.70.57",
   "description": "Local development tunnel.",
   "author": "Chris Breuer",
   "contributors": [
@@ -27,20 +27,23 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "bun": "./src/index.ts",
-      "import": "./dist/index.js"
+      "development": "./src/index.ts",
+      "bun": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./*": {
-      "bun": "./src/*",
-      "import": "./dist/*"
+      "development": "./src/*",
+      "bun": "./dist/*",
+      "import": "./dist/*",
+      "default": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "README.md",
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
     "build": "bun build.ts",

package/src/index.ts

@@ -1,42 +0,0 @@
-/// <reference path="./shims.d.ts" />
-import type { LocalTunnel, TunnelOptions } from './tunnel'
-import { localTunnel } from './tunnel'
-
-export async function createLocalTunnel(port: number): Promise<string> {
-  const tunnel = await localTunnel({ port })
-  return tunnel.url
-}
-
-/**
- * Deploy a tunnel server to AWS EC2.
- * Only needed for custom domains — localtunnel.dev is the shared default.
- */
-export async function deployTunnelServer(config: {
-  domain: string
-  region?: string
-  instanceType?: string
-  prefix?: string
-  enableSsl?: boolean
-  porkbunApiKey?: string
-  porkbunSecretKey?: string
-  verbose?: boolean
-}) {
-  const { deployTunnelInfrastructure } = await import('localtunnels/cloud')
-  return deployTunnelInfrastructure(config)
-}
-
-/**
- * Destroy a previously deployed tunnel server from AWS.
- */
-export async function destroyTunnelServer(config: {
-  domain?: string
-  region?: string
-  prefix?: string
-  verbose?: boolean
-}) {
-  const { destroyTunnelInfrastructure } = await import('localtunnels/cloud')
-  return destroyTunnelInfrastructure(config)
-}
-
-export { localTunnel }
-export type { LocalTunnel, TunnelOptions }

package/src/localtunnels.d.ts

@@ -1,66 +0,0 @@
-// Type declarations for localtunnels package
-// The published package has broken exports paths (dtsx issue)
-// These declarations bridge the gap until the package is fixed
-
-declare module 'localtunnels' {
-  import { EventEmitter } from 'node:events'
-
-  export function startLocalTunnel(_options: {
-    port: number
-    subdomain?: string
-    host?: string
-    server?: string
-    verbose?: boolean
-    timeout?: number
-    maxReconnectAttempts?: number
-    manageHosts?: boolean
-    onConnect?: (info: { url: string, subdomain: string }) => void
-    onRequest?: (req: { method: string, url: string }) => void
-    onResponse?: (res: { status: number, size: number, duration?: number }) => void
-    onError?: (error: Error) => void
-    onReconnecting?: (info: { attempt: number, delay: number }) => void
-  }): Promise<TunnelClient>
-
-  export class TunnelClient extends EventEmitter {
-    getState(): string
-    connect(): Promise<void>
-    disconnect(): Promise<void>
-    isConnected(): boolean
-    getSubdomain(): string
-    getTunnelUrl(): string
-  }
-
-  export class TunnelServer extends EventEmitter {
-    start(): Promise<void>
-    stop(): void
-  }
-}
-
-declare module 'localtunnels/cloud' {
-  export interface TunnelDeployConfig {
-    region?: string
-    prefix?: string
-    domain?: string
-    hostedZoneId?: string
-    instanceType?: string
-    keyName?: string
-    verbose?: boolean
-    enableSsl?: boolean
-    porkbunApiKey?: string
-    porkbunSecretKey?: string
-  }
-
-  export interface TunnelDeployResult {
-    publicIp: string
-    instanceId: string
-    securityGroupId: string
-    allocationId: string
-    serverUrl: string
-    wsUrl: string
-    domain?: string
-    region: string
-  }
-
-  export function deployTunnelInfrastructure(config?: TunnelDeployConfig): Promise<TunnelDeployResult>
-  export function destroyTunnelInfrastructure(config?: TunnelDeployConfig): Promise<void>
-}

package/src/shims.d.ts

@@ -1,9 +0,0 @@
-declare module 'localtunnels/cloud' {
-  export function deployTunnelInfrastructure(config: Record<string, unknown>): Promise<unknown>
-  export function destroyTunnelInfrastructure(config: Record<string, unknown>): Promise<unknown>
-}
-
-declare module 'localtunnels' {
-  export type TunnelClient = any
-  export function startLocalTunnel(options?: any): Promise<any>
-}

package/src/tunnel.ts

@@ -1,63 +0,0 @@
-/// <reference path="./shims.d.ts" />
-import type { TunnelClient } from 'localtunnels'
-import { startLocalTunnel } from 'localtunnels'
-
-export interface TunnelOptions {
-  /** Local port to expose through the tunnel */
-  port: number
-  /** Tunnel server URL (default: api.localtunnel.dev) */
-  server?: string
-  /** Request a specific subdomain */
-  subdomain?: string
-  /** Enable verbose logging */
-  verbose?: boolean
-  /** Connection timeout in milliseconds */
-  timeout?: number
-  /** Maximum reconnection attempts */
-  maxReconnectAttempts?: number
-  /** Called when tunnel connects */
-  onConnect?: (info: { url: string, subdomain: string }) => void
-  /** Called on each proxied request */
-  onRequest?: (req: { method: string, url: string }) => void
-  /** Called on each proxied response */
-  onResponse?: (res: { status: number, size: number, duration?: number }) => void
-  /** Called on error */
-  onError?: (error: Error) => void
-  /** Called when reconnecting */
-  onReconnecting?: (info: { attempt: number, delay: number }) => void
-}
-
-export interface LocalTunnel {
-  url: string
-  subdomain: string
-  client: TunnelClient
-  close: () => Promise<void>
-}
-
-export async function localTunnel(options?: TunnelOptions | { port: number }): Promise<LocalTunnel> {
-  const opts: TunnelOptions = options || { port: 3000 }
-  const port = opts.port || 3000
-
-  const tunnelOpts: Parameters<typeof startLocalTunnel>[0] = {
-    port,
-    ...(opts.server ? { server: opts.server } : {}),
-    ...(opts.subdomain ? { subdomain: opts.subdomain } : {}),
-    ...(opts.verbose !== undefined ? { verbose: opts.verbose } : {}),
-    ...(opts.timeout ? { timeout: opts.timeout } : {}),
-    ...(opts.maxReconnectAttempts ? { maxReconnectAttempts: opts.maxReconnectAttempts } : {}),
-    ...(opts.onConnect ? { onConnect: opts.onConnect } : {}),
-    ...(opts.onRequest ? { onRequest: opts.onRequest } : {}),
-    ...(opts.onResponse ? { onResponse: opts.onResponse } : {}),
-    ...(opts.onError ? { onError: opts.onError } : {}),
-    ...(opts.onReconnecting ? { onReconnecting: opts.onReconnecting } : {}),
-  }
-
-  const client = await startLocalTunnel(tunnelOpts)
-
-  return {
-    url: client.getTunnelUrl(),
-    subdomain: client.getSubdomain(),
-    client,
-    close: () => client.disconnect() as Promise<void>,
-  }
-}