sub-bridge 1.0.0

package/src/tunnel/registry.ts

@@ -0,0 +1,96 @@
+// ============================================================================
+// Tunnel Registry - Manages providers and active tunnel
+// ============================================================================
+
+import type { TunnelProvider, TunnelInstance, TunnelStatus, ProviderInfo } from './types'
+import {
+  CloudflareTunnelProvider,
+  NgrokTunnelProvider,
+  TailscaleTunnelProvider,
+} from './providers'
+
+export class TunnelRegistry {
+  private providers: Map<string, TunnelProvider> = new Map()
+  private activeTunnel: TunnelInstance | null = null
+  private startedAt: string | null = null
+  private lastError: string | null = null
+
+  constructor() {
+    const allProviders: TunnelProvider[] = [
+      new CloudflareTunnelProvider(),
+      new NgrokTunnelProvider(),
+      new TailscaleTunnelProvider(),
+    ]
+    for (const provider of allProviders) {
+      this.providers.set(provider.id, provider)
+    }
+  }
+
+  async getProviders(): Promise<ProviderInfo[]> {
+    const results: ProviderInfo[] = []
+    for (const [id, provider] of this.providers) {
+      results.push({
+        id,
+        name: provider.name,
+        available: await provider.isAvailable(),
+        supportsNamedTunnels: provider.supportsNamedTunnels,
+      })
+    }
+    return results
+  }
+
+  getStatus(): TunnelStatus {
+    if (this.activeTunnel) {
+      return {
+        active: true,
+        providerId: this.activeTunnel.providerId,
+        publicUrl: this.activeTunnel.publicUrl,
+        startedAt: this.startedAt || undefined,
+      }
+    }
+    return {
+      active: false,
+      error: this.lastError || undefined,
+    }
+  }
+
+  async start(providerId: string, localPort: number, namedUrl?: string): Promise<TunnelStatus> {
+    // Stop existing tunnel if any
+    if (this.activeTunnel) {
+      this.activeTunnel.stop()
+      this.activeTunnel = null
+    }
+
+    const provider = this.providers.get(providerId)
+    if (!provider) {
+      throw new Error(`Unknown tunnel provider: ${providerId}`)
+    }
+
+    if (!await provider.isAvailable()) {
+      throw new Error(`Tunnel provider ${provider.name} is not available`)
+    }
+
+    try {
+      this.lastError = null
+      this.activeTunnel = await provider.start(localPort, namedUrl)
+      this.startedAt = new Date().toISOString()
+      return this.getStatus()
+    } catch (error) {
+      this.lastError = error instanceof Error ? error.message : String(error)
+      throw error
+    }
+  }
+
+  stop(): TunnelStatus {
+    if (this.activeTunnel) {
+      this.activeTunnel.stop()
+      this.activeTunnel = null
+      this.startedAt = null
+    }
+    return this.getStatus()
+  }
+
+  getPublicUrl(): string | null {
+    return this.activeTunnel?.publicUrl || null
+  }
+}

package/src/tunnel/types.ts

@@ -0,0 +1,32 @@
+// ============================================================================
+// Tunnel Types
+// ============================================================================
+
+export interface TunnelProvider {
+  id: string
+  name: string
+  supportsNamedTunnels: boolean
+  isAvailable(): Promise<boolean>
+  start(localPort: number, namedUrl?: string): Promise<TunnelInstance>
+}
+
+export interface TunnelInstance {
+  providerId: string
+  publicUrl: string
+  stop(): void
+}
+
+export interface TunnelStatus {
+  active: boolean
+  providerId?: string
+  publicUrl?: string
+  startedAt?: string
+  error?: string
+}
+
+export interface ProviderInfo {
+  id: string
+  name: string
+  available: boolean
+  supportsNamedTunnels: boolean
+}

package/src/tunnel/utils.ts

@@ -0,0 +1,59 @@
+// ============================================================================
+// Tunnel Utilities
+// ============================================================================
+
+import { exec, spawn, ChildProcess } from 'child_process'
+import { promisify } from 'util'
+
+const execAsync = promisify(exec)
+
+/**
+ * Check if a binary exists in PATH
+ */
+export async function binaryExists(binary: string): Promise<boolean> {
+  try {
+    const cmd = process.platform === 'win32' ? `where ${binary}` : `which ${binary}`
+    await execAsync(cmd)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Spawn a tunnel process with standard configuration
+ */
+export function spawnTunnelProcess(command: string, args: string[]): ChildProcess {
+  return spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] })
+}
+
+/**
+ * Poll a function until it returns a value or times out
+ */
+export async function pollUntil<T>(
+  fn: () => Promise<T | null>,
+  timeout: number = 30000,
+  interval: number = 500
+): Promise<T> {
+  const start = Date.now()
+
+  while (Date.now() - start < timeout) {
+    try {
+      const result = await fn()
+      if (result !== null) return result
+    } catch {
+      // Continue polling on error
+    }
+    await new Promise(r => setTimeout(r, interval))
+  }
+
+  throw new Error('Polling timeout')
+}
+
+/**
+ * Execute shell command and return parsed JSON output
+ */
+export async function execJson<T = any>(command: string): Promise<T> {
+  const { stdout } = await execAsync(command)
+  return JSON.parse(stdout)
+}

package/src/types.ts

@@ -0,0 +1,55 @@
+// Shared type definitions
+
+export interface AnthropicRequestBody {
+  system?: Array<{ type: string; text: string }>
+  messages?: Array<any>
+  metadata?: {
+    user_id?: string
+  }
+  stream?: boolean
+  model: string
+  [key: string]: unknown
+}
+
+export interface AnthropicResponse {
+  id?: string
+  model?: string
+  stop_reason?: string | null
+  content?: Array<{
+    type: 'text' | 'tool_use'
+    text?: string
+    id?: string
+    name?: string
+    input?: unknown
+  }>
+  usage?: {
+    input_tokens: number
+    output_tokens: number
+    cache_creation_input_tokens?: number
+    cache_read_input_tokens?: number
+  }
+  [key: string]: unknown
+}
+
+export interface ErrorResponse {
+  error: string
+  message?: string
+  details?: string
+}
+
+export interface SuccessResponse {
+  success: boolean
+  message: string
+}
+
+export interface ModelInfo {
+  id: string
+  object: 'model'
+  created: number
+  owned_by: string
+}
+
+export interface ModelsListResponse {
+  object: 'list'
+  data: ModelInfo[]
+}