@cuongtran001/kanna 0.39.2

package/src/server/cli-runtime.ts

@@ -0,0 +1,405 @@
+import process from "node:process"
+import { spawnSync } from "node:child_process"
+import { hasCommand, spawnDetached } from "./process-utils"
+import { APP_NAME, CLI_COMMAND, getDataDirDisplay, LOG_PREFIX, PACKAGE_NAME } from "../shared/branding"
+import type { ShareMode } from "../shared/share"
+import { assertNoHostOverride, getShareCliFlag, isShareEnabled, isTokenShareMode } from "../shared/share"
+import type { UpdateInstallErrorCode } from "../shared/types"
+import { PROD_SERVER_PORT } from "../shared/ports"
+import { CLI_SUPPRESS_OPEN_ONCE_ENV_VAR } from "./restart"
+import { logShareDetails, renderTerminalQr, startShareTunnel, type StartedShareTunnel } from "./share"
+
+export interface CliOptions {
+  port: number
+  host: string
+  openBrowser: boolean
+  share: ShareMode
+  password: string | null
+  strictPort: boolean
+}
+
+export interface CliUpdateOptions {
+  version: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  argv: string[]
+  command: string
+}
+
+export interface StartedCli {
+  kind: "started"
+  stop: () => Promise<void>
+}
+
+export interface RestartingCli {
+  kind: "restarting"
+  reason: "startup_update" | "ui_update"
+}
+
+export interface ExitedCli {
+  kind: "exited"
+  code: number
+}
+
+export type CliRunResult = StartedCli | RestartingCli | ExitedCli
+
+export interface CliRuntimeDeps {
+  version: string
+  bunVersion: string
+  startServer: (options: CliOptions & {
+    update: CliUpdateOptions
+    onMigrationProgress?: (message: string) => void
+    trustProxy?: boolean
+  }) => Promise<{ port: number; stop: () => Promise<void> }>
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  openUrl: (url: string) => void
+  log: (message: string) => void
+  warn: (message: string) => void
+  renderShareQr?: (url: string) => Promise<string>
+  startShareTunnel?: (localUrl: string, shareMode: Exclude<ShareMode, false>) => Promise<StartedShareTunnel>
+}
+
+export interface UpdateInstallAttemptResult {
+  ok: boolean
+  errorCode: UpdateInstallErrorCode | null
+  userTitle: string | null
+  userMessage: string | null
+}
+
+type ParsedArgs =
+  | { kind: "run"; options: CliOptions }
+  | { kind: "help" }
+  | { kind: "version" }
+
+const MINIMUM_BUN_VERSION = "1.3.5"
+
+function throwShareConflict(share: Exclude<ShareMode, false>, hostFlag: "--host" | "--remote"): never {
+  throw new Error(`${getShareCliFlag(share)} cannot be used with ${hostFlag}`)
+}
+
+function printHelp() {
+  console.log(`${APP_NAME} — local-only project chat UI
+
+Usage:
+  ${CLI_COMMAND} [options]
+
+Options:
+  --port <number>      Port to listen on (default: ${PROD_SERVER_PORT})
+  --host <host>        Bind to a specific host or IP
+  --remote             Shortcut for --host 0.0.0.0
+  --share              Create a public Cloudflare quick tunnel with terminal QR
+  --cloudflared <token>
+                       Run a named Cloudflare tunnel from a token
+  --password <secret>  Require a password before loading the app
+  --strict-port        Fail instead of trying another port
+  --no-open            Don't open browser automatically
+  --version            Print version and exit
+  --help               Show this help message`)
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  let port = PROD_SERVER_PORT
+  let host = "127.0.0.1"
+  let openBrowser = true
+  let share: ShareMode = false
+  let password: string | null = null
+  let sawHost = false
+  let sawRemote = false
+  let strictPort = false
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+    if (arg === "--version" || arg === "-v") {
+      return { kind: "version" }
+    }
+    if (arg === "--help" || arg === "-h") {
+      return { kind: "help" }
+    }
+    if (arg === "--port") {
+      const next = argv[index + 1]
+      if (!next) throw new Error("Missing value for --port")
+      port = Number(next)
+      index += 1
+      continue
+    }
+    if (arg === "--host") {
+      const next = argv[index + 1]
+      if (!next || next.startsWith("-")) throw new Error("Missing value for --host")
+      if (isShareEnabled(share)) {
+        throwShareConflict(share, "--host")
+      }
+      host = next
+      sawHost = true
+      index += 1
+      continue
+    }
+    if (arg === "--remote") {
+      if (isShareEnabled(share)) {
+        throwShareConflict(share, "--remote")
+      }
+      host = "0.0.0.0"
+      sawRemote = true
+      continue
+    }
+    if (arg === "--share") {
+      assertNoHostOverride("--share", sawHost, sawRemote)
+      share = "quick"
+      continue
+    }
+    if (arg === "--cloudflared") {
+      assertNoHostOverride("--cloudflared", sawHost, sawRemote)
+      const next = argv[index + 1]
+      if (!next || next.startsWith("-")) throw new Error("Missing value for --cloudflared")
+      share = { kind: "token", token: next }
+      index += 1
+      continue
+    }
+    if (arg === "--no-open") {
+      openBrowser = false
+      continue
+    }
+    if (arg === "--password") {
+      const next = argv[index + 1]
+      if (!next || next.startsWith("-")) throw new Error("Missing value for --password")
+      password = next
+      index += 1
+      continue
+    }
+    if (arg === "--strict-port") {
+      strictPort = true
+      continue
+    }
+    if (!arg.startsWith("-")) throw new Error(`Unexpected positional argument: ${arg}`)
+  }
+
+  return {
+    kind: "run",
+    options: {
+      port,
+      host,
+      openBrowser,
+      share,
+      password,
+      strictPort,
+    },
+  }
+}
+
+export function compareVersions(currentVersion: string, latestVersion: string) {
+  const currentParts = normalizeVersion(currentVersion)
+  const latestParts = normalizeVersion(latestVersion)
+  const length = Math.max(currentParts.length, latestParts.length)
+
+  for (let index = 0; index < length; index += 1) {
+    const current = currentParts[index] ?? 0
+    const latest = latestParts[index] ?? 0
+    if (current === latest) continue
+    return current < latest ? -1 : 1
+  }
+
+  return 0
+}
+
+function normalizeVersion(version: string) {
+  return version
+    .trim()
+    .replace(/^v/i, "")
+    .split("-")[0]
+    .split(".")
+    .map((part) => Number.parseInt(part, 10))
+    .filter((part) => Number.isFinite(part))
+}
+
+async function maybeSelfUpdate(_argv: string[], deps: CliRuntimeDeps) {
+  if (process.env.KANNA_DISABLE_SELF_UPDATE === "1") {
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} checking for updates`)
+
+  let latestVersion: string
+  try {
+    latestVersion = await deps.fetchLatestVersion(PACKAGE_NAME)
+  }
+  catch (error) {
+    deps.warn(`${LOG_PREFIX} update check failed, continuing current version`)
+    if (error instanceof Error && error.message) {
+      deps.warn(`${LOG_PREFIX} ${error.message}`)
+    }
+    return null
+  }
+
+  if (!latestVersion || compareVersions(deps.version, latestVersion) >= 0) {
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} installing ${PACKAGE_NAME}@${latestVersion}`)
+  const installResult = deps.installVersion(PACKAGE_NAME, latestVersion)
+  if (!installResult.ok) {
+    deps.warn(`${LOG_PREFIX} update failed, continuing current version`)
+    if (installResult.userMessage) {
+      deps.warn(`${LOG_PREFIX} ${installResult.userMessage}`)
+    }
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} restarting into updated version`)
+  return "startup_update"
+}
+
+export async function runCli(argv: string[], deps: CliRuntimeDeps): Promise<CliRunResult> {
+  const parsedArgs = parseArgs(argv)
+  if (parsedArgs.kind === "version") {
+    deps.log(deps.version)
+    return { kind: "exited", code: 0 }
+  }
+  if (parsedArgs.kind === "help") {
+    printHelp()
+    return { kind: "exited", code: 0 }
+  }
+
+  if (compareVersions(deps.bunVersion, MINIMUM_BUN_VERSION) < 0) {
+    deps.warn(`${LOG_PREFIX} Bun ${MINIMUM_BUN_VERSION}+ is required for the embedded terminal. Current Bun: ${deps.bunVersion}`)
+    return { kind: "exited", code: 1 }
+  }
+
+  const shouldRestart = await maybeSelfUpdate(argv, deps)
+  if (shouldRestart !== null) {
+    return { kind: "restarting", reason: shouldRestart }
+  }
+
+  const { port, stop } = await deps.startServer({
+    ...parsedArgs.options,
+    trustProxy: isShareEnabled(parsedArgs.options.share),
+    onMigrationProgress: deps.log,
+    update: {
+      version: deps.version,
+      fetchLatestVersion: deps.fetchLatestVersion,
+      installVersion: deps.installVersion,
+      argv,
+      command: CLI_COMMAND,
+    },
+  })
+  const bindHost = parsedArgs.options.host
+  const displayHost = isShareEnabled(parsedArgs.options.share) || bindHost === "127.0.0.1" || bindHost === "0.0.0.0" ? "localhost" : bindHost
+  const launchUrl = `http://${displayHost}:${port}`
+  let shareTunnelStop: (() => void) | null = null
+
+  deps.log(`${LOG_PREFIX} listening on http://${bindHost}:${port}`)
+  deps.log(`${LOG_PREFIX} data dir: ${getDataDirDisplay()}`)
+
+  const suppressOpenBrowser = process.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] === "1"
+  if (isShareEnabled(parsedArgs.options.share)) {
+    try {
+      const shareTunnel = await (deps.startShareTunnel ?? ((localUrl, shareMode) => startShareTunnel(localUrl, shareMode, {
+        log: (message) => deps.log(`${LOG_PREFIX} ${message}`),
+      })))(launchUrl, parsedArgs.options.share)
+      shareTunnelStop = shareTunnel.stop
+      if (shareTunnel.publicUrl) {
+        await logShareDetails(deps.log, shareTunnel.publicUrl, launchUrl, deps.renderShareQr ?? renderTerminalQr)
+      } else {
+        deps.warn(`${LOG_PREFIX} named tunnel started but no public hostname was detected`)
+        if (isTokenShareMode(parsedArgs.options.share)) {
+          deps.warn(`${LOG_PREFIX} use the hostname configured for the provided Cloudflare tunnel token`)
+        }
+        deps.log("Local URL:")
+        deps.log(launchUrl)
+      }
+    } catch (error) {
+      await stop()
+      deps.warn(`${LOG_PREFIX} failed to start Cloudflare share tunnel`)
+      if (error instanceof Error && error.message) {
+        deps.warn(`${LOG_PREFIX} ${error.message}`)
+      }
+      return { kind: "exited", code: 1 }
+    }
+  }
+
+  if (parsedArgs.options.openBrowser && !isShareEnabled(parsedArgs.options.share) && !suppressOpenBrowser) {
+    deps.openUrl(launchUrl)
+  }
+
+  return {
+    kind: "started",
+    stop: async () => {
+      shareTunnelStop?.()
+      await stop()
+    },
+  }
+}
+
+export function openUrl(url: string) {
+  const platform = process.platform
+  if (platform === "darwin") {
+    void spawnDetached("open", [url]).catch(() => {})
+  } else if (platform === "win32") {
+    void spawnDetached("cmd", ["/c", "start", "", url]).catch(() => {})
+  } else {
+    void spawnDetached("xdg-open", [url]).catch(() => {})
+  }
+  console.log(`${LOG_PREFIX} opened in default browser`)
+}
+
+export async function fetchLatestPackageVersion(packageName: string) {
+  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`)
+  if (!response.ok) {
+    throw new Error(`registry returned ${response.status}`)
+  }
+
+  const payload = await response.json() as { version?: unknown }
+  if (typeof payload.version !== "string" || !payload.version.trim()) {
+    throw new Error("registry response did not include a version")
+  }
+
+  return payload.version
+}
+
+export function classifyInstallVersionFailure(output: string): UpdateInstallAttemptResult {
+  const normalizedOutput = output.trim()
+  if (/No version matching .* found|failed to resolve/i.test(normalizedOutput)) {
+    return {
+      ok: false,
+      errorCode: "version_not_live_yet",
+      userTitle: "Update not live yet",
+      userMessage: "This update is still propagating. Try again in a few minutes.",
+    }
+  }
+
+  return {
+    ok: false,
+    errorCode: "install_failed",
+    userTitle: "Update failed",
+    userMessage: "Kanna could not install the update. Try again later.",
+  }
+}
+
+export function installPackageVersion(packageName: string, version: string) {
+  if (!hasCommand("bun")) {
+    return {
+      ok: false,
+      errorCode: "command_missing",
+      userTitle: "Bun not found",
+      userMessage: "Kanna could not find Bun to install the update.",
+    } satisfies UpdateInstallAttemptResult
+  }
+
+  const result = spawnSync("bun", ["install", "-g", `${packageName}@${version}`], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+  })
+  const stdout = result.stdout ?? ""
+  const stderr = result.stderr ?? ""
+  if (stdout) process.stdout.write(stdout)
+  if (stderr) process.stderr.write(stderr)
+  if (result.status === 0) {
+    return {
+      ok: true,
+      errorCode: null,
+      userTitle: null,
+      userMessage: null,
+    } satisfies UpdateInstallAttemptResult
+  }
+
+  return classifyInstallVersionFailure(`${stdout}\n${stderr}`)
+}

package/src/server/cli-supervisor.ts

@@ -0,0 +1,102 @@
+import process from "node:process"
+import { spawn } from "node:child_process"
+import { CLI_COMMAND, LOG_PREFIX } from "../shared/branding"
+import {
+  CLI_CHILD_ARGS_ENV_VAR,
+  CLI_CHILD_COMMAND_ENV_VAR,
+  CLI_CHILD_MODE,
+  CLI_CHILD_MODE_ENV_VAR,
+  CLI_STARTUP_UPDATE_RESTART_EXIT_CODE,
+  CLI_SUPPRESS_OPEN_ONCE_ENV_VAR,
+  isUiUpdateRestart,
+  parseChildArgsEnv,
+  shouldRestartCliProcess,
+} from "./restart"
+
+interface ChildExit {
+  code: number | null
+  signal: NodeJS.Signals | null
+}
+
+function getChildProcessSpec() {
+  const command = process.env[CLI_CHILD_COMMAND_ENV_VAR] || CLI_COMMAND
+  const args = parseChildArgsEnv(process.env[CLI_CHILD_ARGS_ENV_VAR])
+  return { command, args }
+}
+
+function spawnChild(argv: string[]) {
+  const childProcess = getChildProcessSpec()
+  const suppressOpenThisChild = suppressOpenOnNextChild
+  const skipUpdateThisChild = skipUpdateOnNextChild
+  suppressOpenOnNextChild = false
+  skipUpdateOnNextChild = false
+  return new Promise<ChildExit>((resolve, reject) => {
+    const child = spawn(childProcess.command, [...childProcess.args, ...argv], {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        [CLI_CHILD_MODE_ENV_VAR]: CLI_CHILD_MODE,
+        ...(suppressOpenThisChild ? { [CLI_SUPPRESS_OPEN_ONCE_ENV_VAR]: "1" } : {}),
+        ...(skipUpdateThisChild ? { KANNA_DISABLE_SELF_UPDATE: "1" } : {}),
+      },
+    })
+
+    const forwardSignal = (signal: NodeJS.Signals) => {
+      if (child.exitCode !== null) return
+      child.kill(signal)
+    }
+
+    const onSigint = () => {
+      forwardSignal("SIGINT")
+    }
+    const onSigterm = () => {
+      forwardSignal("SIGTERM")
+    }
+
+    process.on("SIGINT", onSigint)
+    process.on("SIGTERM", onSigterm)
+
+    child.once("error", (error) => {
+      process.off("SIGINT", onSigint)
+      process.off("SIGTERM", onSigterm)
+      reject(error)
+    })
+
+    child.once("exit", (code, signal) => {
+      process.off("SIGINT", onSigint)
+      process.off("SIGTERM", onSigterm)
+      resolve({ code, signal })
+    })
+  })
+}
+
+const argv = process.argv.slice(2)
+let suppressOpenOnNextChild = false
+let skipUpdateOnNextChild = false
+let lastStartupUpdateRestart = false
+
+while (true) {
+  const result = await spawnChild(argv)
+  if (shouldRestartCliProcess(result.code, result.signal)) {
+    const isStartupUpdate = result.signal === null && result.code === CLI_STARTUP_UPDATE_RESTART_EXIT_CODE
+
+    // Guard against infinite restart loops: if two consecutive startup-update
+    // restarts happen it means the installed update did not change the binary
+    // that actually runs (e.g. when launched via `bunx`, which maintains its
+    // own package cache). Skip the self-update on the next spawn so the child
+    // proceeds normally instead of trying to update again.
+    if (isStartupUpdate && lastStartupUpdateRestart) {
+      console.log(`${LOG_PREFIX} update installed but the running binary did not change, continuing with current version`)
+      skipUpdateOnNextChild = true
+      lastStartupUpdateRestart = false
+    } else {
+      lastStartupUpdateRestart = isStartupUpdate
+    }
+
+    suppressOpenOnNextChild = isUiUpdateRestart(result.code, result.signal)
+    console.log(`${LOG_PREFIX} supervisor restarting ${CLI_COMMAND} in the same terminal session`)
+    continue
+  }
+
+  process.exit(result.code ?? (result.signal ? 1 : 0))
+}

package/src/server/cli.ts

@@ -0,0 +1,64 @@
+import process from "node:process"
+import { LOG_PREFIX } from "../shared/branding"
+import {
+  fetchLatestPackageVersion,
+  installPackageVersion,
+  openUrl,
+  runCli,
+} from "./cli-runtime"
+import { CLI_STARTUP_UPDATE_RESTART_EXIT_CODE, CLI_UI_UPDATE_RESTART_EXIT_CODE } from "./restart"
+import { startKannaServer } from "./server"
+
+// Read version from package.json at the package root
+const pkg = await Bun.file(new URL("../../package.json", import.meta.url)).json()
+const VERSION: string = pkg.version ?? "0.0.0"
+
+const argv = process.argv.slice(2)
+let resolveExitAction: ((action: "ui_restart" | "exit") => void) | null = null
+
+const result = await runCli(argv, {
+  version: VERSION,
+  bunVersion: Bun.version,
+  startServer: async (options) => {
+    const started = await startKannaServer(options)
+    if (started.updateManager && options.update) {
+      started.updateManager.onChange((snapshot) => {
+        if (snapshot.status !== "restart_pending") return
+        console.log(`${LOG_PREFIX} update installed, shutting down current process for restart`)
+        resolveExitAction?.("ui_restart")
+      })
+    }
+
+    return started
+  },
+  fetchLatestVersion: fetchLatestPackageVersion,
+  installVersion: installPackageVersion,
+  openUrl,
+  log: console.log,
+  warn: console.warn,
+})
+
+if (result.kind === "exited") {
+  process.exit(result.code)
+}
+
+if (result.kind === "restarting") {
+  process.exit(result.reason === "startup_update" ? CLI_STARTUP_UPDATE_RESTART_EXIT_CODE : CLI_UI_UPDATE_RESTART_EXIT_CODE)
+}
+
+const exitAction = await new Promise<"ui_restart" | "exit">((resolve) => {
+  resolveExitAction = resolve
+
+  const shutdown = () => {
+    resolve("exit")
+  }
+
+  process.once("SIGINT", shutdown)
+  process.once("SIGTERM", shutdown)
+})
+
+await result.stop()
+if (exitAction === "ui_restart") {
+  console.log(`${LOG_PREFIX} current process stopped, handing restart back to supervisor`)
+}
+process.exit(exitAction === "ui_restart" ? CLI_UI_UPDATE_RESTART_EXIT_CODE : 0)

package/src/server/cloudflare-tunnel/agent-integration.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test"
+import { handleBashToolResult } from "./agent-integration"
+import type { CloudflareTunnelEvent } from "./events"
+import type { CloudflareTunnelSettings } from "../../shared/types"
+
+const baseSettings: CloudflareTunnelSettings = {
+  enabled: true,
+  cloudflaredPath: "cloudflared",
+  mode: "always-ask",
+}
+
+describe("handleBashToolResult", () => {
+  test("emits one tunnel_proposed per detected port", async () => {
+    const events: CloudflareTunnelEvent[] = []
+    let autoCalls = 0
+    await handleBashToolResult({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5173\nNetwork: http://127.0.0.1:5174",
+      chatId: "c1",
+      sourcePid: 100,
+      settings: baseSettings,
+      onEvent: (e: CloudflareTunnelEvent) => events.push(e),
+      autoStart: async () => { autoCalls++ },
+    })
+    const proposed = events.filter((e: CloudflareTunnelEvent) => e.kind === "tunnel_proposed")
+    expect(proposed).toHaveLength(2)
+    const ports = proposed.map((e) => (e.kind === "tunnel_proposed" ? e.port : 0)).sort((a, b) => a - b)
+    expect(ports).toEqual([5173, 5174])
+    expect(autoCalls).toBe(0)
+  })
+
+  test("skips when feature disabled", async () => {
+    const events: CloudflareTunnelEvent[] = []
+    await handleBashToolResult({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5173",
+      chatId: "c1",
+      sourcePid: 100,
+      settings: { ...baseSettings, enabled: false },
+      onEvent: (e: CloudflareTunnelEvent) => events.push(e),
+      autoStart: async () => {},
+    })
+    expect(events).toEqual([])
+  })
+
+  test("auto-expose mode emits accepted + triggers autoStart per port", async () => {
+    const events: CloudflareTunnelEvent[] = []
+    let startCalls = 0
+    await handleBashToolResult({
+      command: "bun run dev",
+      stdout: "Local: http://localhost:5173",
+      chatId: "c1",
+      sourcePid: 100,
+      settings: { ...baseSettings, mode: "auto-expose" },
+      onEvent: (e: CloudflareTunnelEvent) => events.push(e),
+      autoStart: async () => { startCalls++ },
+    })
+    expect(startCalls).toBe(1)
+    expect(events.some((e) => e.kind === "tunnel_proposed")).toBe(true)
+    expect(events.some((e) => e.kind === "tunnel_accepted")).toBe(true)
+  })
+
+  test("no events when detector reports no server", async () => {
+    const events: CloudflareTunnelEvent[] = []
+    await handleBashToolResult({
+      command: "ls",
+      stdout: "a b c",
+      chatId: "c1",
+      sourcePid: null,
+      settings: baseSettings,
+      onEvent: (e: CloudflareTunnelEvent) => events.push(e),
+      autoStart: async () => {},
+    })
+    expect(events).toEqual([])
+  })
+})

package/src/server/cloudflare-tunnel/agent-integration.ts

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto"
+import type { CloudflareTunnelSettings } from "../../shared/types"
+import { evaluateBashOutput } from "./detector"
+import type { CloudflareTunnelEvent } from "./events"
+import { CLOUDFLARE_TUNNEL_EVENT_VERSION } from "./events"
+
+export interface HandleBashArgs {
+  command: string
+  stdout: string
+  chatId: string
+  sourcePid: number | null
+  settings: CloudflareTunnelSettings
+  onEvent: (event: CloudflareTunnelEvent) => void
+  autoStart: (args: { chatId: string; tunnelId: string; port: number; sourcePid: number | null }) => Promise<void>
+  now?: () => number
+}
+
+export function handleBashToolResult(args: HandleBashArgs): Promise<void> {
+  return runHandleBashToolResult(args)
+}
+
+async function runHandleBashToolResult(args: HandleBashArgs): Promise<void> {
+  if (!args.settings.enabled) return
+  const result = evaluateBashOutput({
+    command: args.command,
+    stdout: args.stdout,
+  })
+  if (!result.isServer) return
+
+  const now = (args.now ?? Date.now)()
+  for (const port of result.ports) {
+    const tunnelId = randomUUID()
+    args.onEvent({
+      v: CLOUDFLARE_TUNNEL_EVENT_VERSION,
+      kind: "tunnel_proposed",
+      timestamp: now,
+      chatId: args.chatId,
+      tunnelId,
+      port,
+      sourcePid: args.sourcePid,
+    })
+
+    if (args.settings.mode === "auto-expose") {
+      args.onEvent({
+        v: CLOUDFLARE_TUNNEL_EVENT_VERSION,
+        kind: "tunnel_accepted",
+        timestamp: now,
+        chatId: args.chatId,
+        tunnelId,
+        source: "auto_setting",
+      })
+      await args.autoStart({ chatId: args.chatId, tunnelId, port, sourcePid: args.sourcePid })
+    }
+  }
+}