@cuongtran001/kanna 0.39.2

package/src/server/cloudflare-tunnel/detector.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test"
+import { evaluateBashOutput } from "./detector"
+
+describe("evaluateBashOutput", () => {
+  test("extracts port from Vite-style localhost URL", () => {
+    const result = evaluateBashOutput({
+      command: "bun run dev",
+      stdout: "  ➜  Local:   http://localhost:5173/\n",
+    })
+    expect(result).toEqual({ isServer: true, ports: [5173] })
+  })
+
+  test("extracts port from 'listening on PORT'", () => {
+    const result = evaluateBashOutput({
+      command: "go run main.go",
+      stdout: "Server listening on port 8080\n",
+    })
+    expect(result).toEqual({ isServer: true, ports: [8080] })
+  })
+
+  test("dedups + sorts multiple ports", () => {
+    const result = evaluateBashOutput({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5174\nNetwork: http://127.0.0.1:5174\nHMR ready on port 5173\n",
+    })
+    expect(result).toEqual({ isServer: true, ports: [5173, 5174] })
+  })
+
+  test("handles ipv6 [::1]:port", () => {
+    const result = evaluateBashOutput({
+      command: "node server.js",
+      stdout: "Listening on [::1]:3000\n",
+    })
+    expect(result).toEqual({ isServer: true, ports: [3000] })
+  })
+
+  test("handles 0.0.0.0:port", () => {
+    const result = evaluateBashOutput({
+      command: "uvicorn app:main",
+      stdout: "Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)\n",
+    })
+    expect(result).toEqual({ isServer: true, ports: [8000] })
+  })
+
+  test("returns no-server for non-server output", () => {
+    expect(evaluateBashOutput({ command: "ls", stdout: "a b c\n" })).toEqual({ isServer: false })
+  })
+
+  test("rejects ports below 1024", () => {
+    const result = evaluateBashOutput({
+      command: "x",
+      stdout: "localhost:80 listening\n",
+    })
+    expect(result).toEqual({ isServer: false })
+  })
+
+  test("caps at 5 ports", () => {
+    const stdout = Array.from({ length: 10 }, (_, i) => `localhost:${5000 + i}`).join("\n")
+    const result = evaluateBashOutput({ command: "x", stdout })
+    if (result.isServer) {
+      expect(result.ports).toHaveLength(5)
+    } else {
+      throw new Error("expected isServer true")
+    }
+  })
+
+  test("trims stdout to last 8KB", () => {
+    const stdout = "x".repeat(20_000) + "\nLocal: http://localhost:5173"
+    const result = evaluateBashOutput({ command: "x", stdout })
+    expect(result).toEqual({ isServer: true, ports: [5173] })
+  })
+})

package/src/server/cloudflare-tunnel/detector.ts

@@ -0,0 +1,44 @@
+export interface DetectorInput {
+  command: string
+  stdout: string
+}
+
+export type DetectorResult =
+  | { isServer: true; ports: number[] }
+  | { isServer: false }
+
+const STDOUT_TAIL_LIMIT = 8192
+const MAX_PORTS = 5
+const MIN_PORT = 1024
+const MAX_PORT = 65535
+
+const STRONG_PATTERNS: RegExp[] = [
+  /\blocalhost:(\d+)/gi,
+  /\b127\.0\.0\.1:(\d+)/gi,
+  /\b0\.0\.0\.0:(\d+)/gi,
+  /\[::1?\]:(\d+)/gi,
+  /\bhttps?:\/\/[^/\s:]+:(\d+)/gi,
+  /(?:listening|ready|started|running)\s+(?:on\s+)?(?:port\s+)?:?(\d{4,5})\b/gi,
+  /\bport\s+(\d{4,5})\b/gi,
+]
+
+export function evaluateBashOutput(input: DetectorInput): DetectorResult {
+  const tail = input.stdout.slice(-STDOUT_TAIL_LIMIT)
+  const found = new Set<number>()
+
+  for (const pattern of STRONG_PATTERNS) {
+    pattern.lastIndex = 0
+    let match: RegExpExecArray | null
+    while ((match = pattern.exec(tail)) !== null) {
+      const port = Number.parseInt(match[1] ?? "", 10)
+      if (Number.isInteger(port) && port >= MIN_PORT && port <= MAX_PORT) {
+        found.add(port)
+        if (found.size >= MAX_PORTS) break
+      }
+    }
+    if (found.size >= MAX_PORTS) break
+  }
+
+  if (found.size === 0) return { isServer: false }
+  return { isServer: true, ports: [...found].sort((a, b) => a - b) }
+}

package/src/server/cloudflare-tunnel/e2e.test.ts

@@ -0,0 +1,194 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { AppSettingsManager } from "../app-settings"
+import { EventStore } from "../event-store"
+import { waitFor } from "../test-helpers/wait-for"
+import type { CloudflareTunnelEvent } from "./events"
+import { TunnelGateway } from "./gateway"
+import { TunnelLifecycle } from "./lifecycle"
+import { TunnelManager, type ChildHandle } from "./tunnel-manager"
+
+interface FakeChild extends ChildHandle {
+  emitStdout: (chunk: string) => void
+  emitExit: (code: number) => void
+}
+
+function fakeChild(): FakeChild {
+  const stdoutListeners: Array<(c: string) => void> = []
+  const exitListeners: Array<(c: number) => void> = []
+  const child: FakeChild = {
+    pid: 9999,
+    kill: () => {
+      for (const l of exitListeners) l(0)
+    },
+    onStdout: (l: (chunk: string) => void) => {
+      stdoutListeners.push(l)
+    },
+    onStderr: () => {},
+    onExit: (l: (code: number) => void) => {
+      exitListeners.push(l)
+    },
+    isKilled: () => false,
+    emitStdout: (chunk: string) => {
+      for (const l of stdoutListeners) l(chunk)
+    },
+    emitExit: (code: number) => {
+      for (const l of exitListeners) l(code)
+    },
+  }
+  return child
+}
+
+describe("cloudflare tunnel e2e", () => {
+  let dataDir: string
+  let store: EventStore
+  let appSettings: AppSettingsManager
+  let manager: TunnelManager
+  let lifecycle: TunnelLifecycle
+  let gateway: TunnelGateway
+  let pendingChildren: FakeChild[]
+  let broadcasts: string[]
+
+  beforeEach(async () => {
+    dataDir = await mkdtemp(join(tmpdir(), "kanna-tunnel-e2e-"))
+    store = new EventStore(dataDir)
+    await store.initialize()
+
+    const settingsPath = join(dataDir, "settings.json")
+    await Bun.write(
+      settingsPath,
+      JSON.stringify({
+        analyticsEnabled: false,
+        cloudflareTunnel: { enabled: true, cloudflaredPath: "cloudflared", mode: "always-ask" },
+      }),
+    )
+    appSettings = new AppSettingsManager(settingsPath)
+    await appSettings.initialize()
+
+    pendingChildren = []
+    broadcasts = []
+
+    manager = new TunnelManager({
+      cloudflaredPath: "cloudflared",
+      spawn: () => {
+        const child = fakeChild()
+        pendingChildren.push(child)
+        return child
+      },
+      onEvent: (event: CloudflareTunnelEvent) => {
+        void store.appendTunnelEvent(event)
+        broadcasts.push(event.chatId)
+      },
+    })
+    lifecycle = new TunnelLifecycle({
+      pollIntervalMs: 1000,
+      isPidAlive: () => true,
+      onSourceExit: () => {},
+    })
+    gateway = new TunnelGateway({
+      manager,
+      lifecycle,
+      settings: appSettings,
+      store,
+      broadcast: (chatId: string) => {
+        broadcasts.push(chatId)
+      },
+    })
+  })
+
+  afterEach(async () => {
+    gateway.shutdown()
+    appSettings.dispose()
+    await rm(dataDir, { recursive: true, force: true })
+  })
+
+  test("propose → accept → active → stop full flow", async () => {
+    await gateway.handleBashResult({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5173",
+      chatId: "c1",
+      sourcePid: null,
+    })
+
+    await waitFor(
+      () => store.getTunnelEvents("c1").some((e) => e.kind === "tunnel_proposed"),
+      2000,
+      "tunnel_proposed event",
+    )
+
+    const eventsAfterPropose = store.getTunnelEvents("c1")
+    expect(eventsAfterPropose.some((e) => e.kind === "tunnel_proposed")).toBe(true)
+    const proposed = eventsAfterPropose.find((e) => e.kind === "tunnel_proposed")
+    expect(proposed).toBeDefined()
+    if (!proposed || proposed.kind !== "tunnel_proposed") throw new Error("no proposed event")
+    expect(proposed.port).toBe(5173)
+
+    await gateway.accept("c1", proposed.tunnelId)
+    expect(pendingChildren).toHaveLength(1)
+
+    pendingChildren[0].emitStdout("https://abc.trycloudflare.com\n")
+
+    await waitFor(
+      () => store.getTunnelEvents("c1").some((e) => e.kind === "tunnel_active"),
+      2000,
+      "tunnel_active event",
+    )
+
+    const eventsAfterActive = store.getTunnelEvents("c1")
+    const active = eventsAfterActive.find((e) => e.kind === "tunnel_active")
+    expect(active).toBeDefined()
+    if (!active || active.kind !== "tunnel_active") throw new Error("no active event")
+    expect(active.url).toBe("https://abc.trycloudflare.com")
+
+    await gateway.stop("c1", proposed.tunnelId)
+
+    await waitFor(
+      () => store.getTunnelEvents("c1").some((e) => e.kind === "tunnel_stopped"),
+      2000,
+      "tunnel_stopped event",
+    )
+
+    const eventsAfterStop = store.getTunnelEvents("c1")
+    const stopped = eventsAfterStop.find((e) => e.kind === "tunnel_stopped")
+    expect(stopped).toBeDefined()
+    if (stopped && stopped.kind === "tunnel_stopped") {
+      expect(stopped.reason).toBe("user")
+    }
+  })
+
+  test("disabled setting → no proposed event", async () => {
+    await appSettings.setCloudflareTunnel({ enabled: false })
+    await gateway.handleBashResult({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5173",
+      chatId: "c1",
+      sourcePid: null,
+    })
+    expect(store.getTunnelEvents("c1")).toEqual([])
+  })
+
+  test("auto-expose mode triggers cloudflared without explicit accept", async () => {
+    await appSettings.setCloudflareTunnel({ mode: "auto-expose" })
+    await gateway.handleBashResult({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5173",
+      chatId: "c1",
+      sourcePid: null,
+    })
+
+    await waitFor(
+      () => store.getTunnelEvents("c1").some((e) => e.kind === "tunnel_accepted"),
+      2000,
+      "tunnel_accepted event",
+    )
+
+    expect(pendingChildren).toHaveLength(1)
+    const accepted = store.getTunnelEvents("c1").find((e) => e.kind === "tunnel_accepted")
+    expect(accepted).toBeDefined()
+    if (accepted && accepted.kind === "tunnel_accepted") {
+      expect(accepted.source).toBe("auto_setting")
+    }
+  })
+})

package/src/server/cloudflare-tunnel/events.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test"
+import { CLOUDFLARE_TUNNEL_EVENT_VERSION, type CloudflareTunnelEvent } from "./events"
+
+describe("cloudflare tunnel events", () => {
+  test("event version is 1", () => {
+    expect(CLOUDFLARE_TUNNEL_EVENT_VERSION).toBe(1)
+  })
+
+  test("discriminated union allows all five kinds", () => {
+    const kinds: CloudflareTunnelEvent["kind"][] = [
+      "tunnel_proposed",
+      "tunnel_accepted",
+      "tunnel_active",
+      "tunnel_stopped",
+      "tunnel_failed",
+    ]
+    expect(kinds).toHaveLength(5)
+  })
+
+  test("tunnel_proposed event is well-typed and fields are accessible", () => {
+    const event: CloudflareTunnelEvent = {
+      v: CLOUDFLARE_TUNNEL_EVENT_VERSION,
+      kind: "tunnel_proposed",
+      timestamp: 1_000,
+      chatId: "c1",
+      tunnelId: "t1",
+      port: 5173,
+      sourcePid: null,
+    }
+    expect(event.port).toBe(5173)
+    expect(event.sourcePid).toBeNull()
+  })
+
+  test("tunnel_stopped reason covers all four lifecycle paths", () => {
+    const reasons: ("user" | "source_exited" | "session_closed" | "server_shutdown")[] = [
+      "user",
+      "source_exited",
+      "session_closed",
+      "server_shutdown",
+    ]
+    expect(reasons).toHaveLength(4)
+  })
+})

package/src/server/cloudflare-tunnel/events.ts

@@ -0,0 +1,31 @@
+export const CLOUDFLARE_TUNNEL_EVENT_VERSION = 1 as const
+
+interface BaseTunnelEvent {
+  v: typeof CLOUDFLARE_TUNNEL_EVENT_VERSION
+  timestamp: number
+  chatId: string
+  tunnelId: string
+}
+
+export type CloudflareTunnelEvent =
+  | (BaseTunnelEvent & {
+      kind: "tunnel_proposed"
+      port: number
+      sourcePid: number | null
+    })
+  | (BaseTunnelEvent & {
+      kind: "tunnel_accepted"
+      source: "user" | "auto_setting"
+    })
+  | (BaseTunnelEvent & {
+      kind: "tunnel_active"
+      url: string
+    })
+  | (BaseTunnelEvent & {
+      kind: "tunnel_stopped"
+      reason: "user" | "source_exited" | "session_closed" | "server_shutdown"
+    })
+  | (BaseTunnelEvent & {
+      kind: "tunnel_failed"
+      error: string
+    })

package/src/server/cloudflare-tunnel/gateway.ts

@@ -0,0 +1,143 @@
+import type { AppSettingsManager } from "../app-settings"
+import type { EventStore } from "../event-store"
+import { handleBashToolResult } from "./agent-integration"
+import type { CloudflareTunnelEvent } from "./events"
+import { CLOUDFLARE_TUNNEL_EVENT_VERSION } from "./events"
+import { TunnelLifecycle } from "./lifecycle"
+import { deriveChatTunnels } from "./read-model"
+import { TunnelManager } from "./tunnel-manager"
+
+export interface TunnelGatewayArgs {
+  manager: TunnelManager
+  lifecycle: TunnelLifecycle
+  settings: AppSettingsManager
+  store: EventStore
+  broadcast: (chatId: string) => void
+  now?: () => number
+}
+
+export class TunnelGateway {
+  private readonly manager: TunnelManager
+  private readonly lifecycle: TunnelLifecycle
+  private readonly settings: AppSettingsManager
+  private readonly store: EventStore
+  private readonly broadcast: (chatId: string) => void
+  private readonly now: () => number
+  // tunnelId → sourcePid for retry
+  private readonly proposedSourcePid = new Map<string, number | null>()
+
+  constructor(args: TunnelGatewayArgs) {
+    this.manager = args.manager
+    this.lifecycle = args.lifecycle
+    this.settings = args.settings
+    this.store = args.store
+    this.broadcast = args.broadcast
+    this.now = args.now ?? (() => Date.now())
+  }
+
+  async reapOrphanedTunnels(): Promise<void> {
+    const chatIds = this.store.listTunnelChats()
+    for (const chatId of chatIds) {
+      const projection = deriveChatTunnels(this.store.getTunnelEvents(chatId), chatId)
+      for (const record of Object.values(projection.tunnels)) {
+        if (record.state !== "proposed" && record.state !== "active") continue
+        await this.persist({
+          v: CLOUDFLARE_TUNNEL_EVENT_VERSION,
+          kind: "tunnel_stopped",
+          timestamp: this.now(),
+          chatId,
+          tunnelId: record.tunnelId,
+          reason: "server_shutdown",
+        })
+      }
+    }
+  }
+
+  async handleBashResult(args: { command: string; stdout: string; chatId: string; sourcePid: number | null }): Promise<void> {
+    const snapshot = this.settings.getSnapshot()
+    const livePorts = this.collectLivePorts(args.chatId)
+    const skippedTunnels = new Set<string>()
+    await handleBashToolResult({
+      command: args.command,
+      stdout: args.stdout,
+      chatId: args.chatId,
+      sourcePid: args.sourcePid,
+      settings: snapshot.cloudflareTunnel,
+      onEvent: (e: CloudflareTunnelEvent) => {
+        if (e.kind === "tunnel_proposed") {
+          if (livePorts.has(e.port)) {
+            skippedTunnels.add(e.tunnelId)
+            return
+          }
+          this.proposedSourcePid.set(e.tunnelId, e.sourcePid)
+        }
+        if (skippedTunnels.has(e.tunnelId)) return
+        void this.persist(e)
+      },
+      autoStart: async (a) => {
+        if (skippedTunnels.has(a.tunnelId)) return
+        await this.manager.start({ chatId: a.chatId, port: a.port, sourcePid: a.sourcePid, tunnelId: a.tunnelId })
+        this.lifecycle.watch(a.tunnelId, a.sourcePid)
+      },
+      now: this.now,
+    })
+  }
+
+  private collectLivePorts(chatId: string): Set<number> {
+    const events = this.store.getTunnelEvents(chatId)
+    const projection = deriveChatTunnels(events, chatId)
+    const ports = new Set<number>()
+    for (const record of Object.values(projection.tunnels)) {
+      if (record.state === "proposed" || record.state === "active") {
+        ports.add(record.port)
+      }
+    }
+    return ports
+  }
+
+  async accept(chatId: string, tunnelId: string): Promise<void> {
+    const sourcePid = this.proposedSourcePid.get(tunnelId) ?? null
+    const proposedEvents = this.store.getTunnelEvents(chatId).filter((e: CloudflareTunnelEvent) => e.tunnelId === tunnelId)
+    const proposed = proposedEvents.find((e: CloudflareTunnelEvent) => e.kind === "tunnel_proposed")
+    if (!proposed || proposed.kind !== "tunnel_proposed") return
+    await this.persist({
+      v: CLOUDFLARE_TUNNEL_EVENT_VERSION,
+      kind: "tunnel_accepted",
+      timestamp: this.now(),
+      chatId,
+      tunnelId,
+      source: "user",
+    })
+    await this.manager.start({ chatId, port: proposed.port, sourcePid, tunnelId })
+    this.lifecycle.watch(tunnelId, sourcePid)
+  }
+
+  async stop(chatId: string, tunnelId: string): Promise<void> {
+    this.lifecycle.unwatch(tunnelId)
+    await this.manager.stop(tunnelId, "user")
+    void chatId  // chatId may be useful for logging/auditing
+  }
+
+  async retry(chatId: string, tunnelId: string): Promise<void> {
+    // For v1, retry just re-runs accept on the existing proposed record.
+    await this.accept(chatId, tunnelId)
+  }
+
+  closeChat(chatId: string): void {
+    const events = this.store.getTunnelEvents(chatId)
+    const live = deriveChatTunnels(events, chatId).liveTunnelId
+    if (!live) return
+    this.lifecycle.unwatch(live)
+    void this.manager.stop(live, "session_closed")
+  }
+
+  shutdown(): void {
+    this.lifecycle.shutdown()
+    this.manager.shutdown()
+  }
+
+  private async persist(event: CloudflareTunnelEvent): Promise<void> {
+    await this.store.appendTunnelEvent(event)
+    this.broadcast(event.chatId)
+  }
+}

package/src/server/cloudflare-tunnel/lifecycle.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test"
+import { TunnelLifecycle } from "./lifecycle"
+
+describe("TunnelLifecycle", () => {
+  test("polls source PID; calls onSourceExit when process gone", async () => {
+    const exited: string[] = []
+    let alive = true
+    const lc = new TunnelLifecycle({
+      pollIntervalMs: 5,
+      isPidAlive: () => alive,
+      onSourceExit: (id: string) => exited.push(id),
+    })
+    lc.watch("t1", 1234)
+    alive = false
+    await new Promise((r) => setTimeout(r, 30))
+    expect(exited).toContain("t1")
+    lc.shutdown()
+  })
+
+  test("unwatch stops polling for a tunnel", async () => {
+    const exited: string[] = []
+    let alive = true
+    const lc = new TunnelLifecycle({
+      pollIntervalMs: 5,
+      isPidAlive: () => alive,
+      onSourceExit: (id: string) => exited.push(id),
+    })
+    lc.watch("t1", 1234)
+    lc.unwatch("t1")
+    alive = false
+    await new Promise((r) => setTimeout(r, 30))
+    expect(exited).toEqual([])
+    lc.shutdown()
+  })
+
+  test("does not fire onSourceExit when sourcePid is null", async () => {
+    const exited: string[] = []
+    const lc = new TunnelLifecycle({
+      pollIntervalMs: 5,
+      isPidAlive: () => false,
+      onSourceExit: (id: string) => exited.push(id),
+    })
+    lc.watch("t1", null)
+    await new Promise((r) => setTimeout(r, 30))
+    expect(exited).toEqual([])
+    lc.shutdown()
+  })
+})

package/src/server/cloudflare-tunnel/lifecycle.ts

@@ -0,0 +1,62 @@
+export interface TunnelLifecycleArgs {
+  pollIntervalMs?: number
+  isPidAlive?: (pid: number) => boolean
+  onSourceExit: (tunnelId: string) => void
+}
+
+export class TunnelLifecycle {
+  private readonly pollIntervalMs: number
+  private readonly isPidAlive: (pid: number) => boolean
+  private readonly onSourceExit: (tunnelId: string) => void
+  private readonly watched = new Map<string, number | null>()
+  private timer: ReturnType<typeof setInterval> | null = null
+
+  constructor(args: TunnelLifecycleArgs) {
+    this.pollIntervalMs = args.pollIntervalMs ?? 1500
+    this.isPidAlive = args.isPidAlive ?? defaultIsPidAlive
+    this.onSourceExit = args.onSourceExit
+  }
+
+  watch(tunnelId: string, sourcePid: number | null) {
+    this.watched.set(tunnelId, sourcePid)
+    this.ensureTimer()
+  }
+
+  unwatch(tunnelId: string) {
+    this.watched.delete(tunnelId)
+    if (this.watched.size === 0 && this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+  }
+
+  shutdown() {
+    if (this.timer) clearInterval(this.timer)
+    this.timer = null
+    this.watched.clear()
+  }
+
+  private ensureTimer() {
+    if (this.timer) return
+    this.timer = setInterval(() => this.tick(), this.pollIntervalMs)
+  }
+
+  private tick() {
+    for (const [tunnelId, pid] of [...this.watched.entries()]) {
+      if (pid === null) continue
+      if (!this.isPidAlive(pid)) {
+        this.unwatch(tunnelId)
+        this.onSourceExit(tunnelId)
+      }
+    }
+  }
+}
+
+function defaultIsPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}