kanna-code 0.32.4 → 0.33.1

package/src/server/auth.test.ts

@@ -11,10 +11,15 @@ afterEach(async () => {
   await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
 })
 
-async function startPasswordServer() {
+async function startPasswordServer(options: { trustProxy?: boolean; port?: number } = {}) {
   const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-auth-test-"))
   tempDirs.push(projectDir)
-  const server = await startKannaServer({ port: 4320, strictPort: true, password: "secret" })
+  const server = await startKannaServer({
+    port: options.port ?? 4320,
+    strictPort: true,
+    password: "secret",
+    trustProxy: options.trustProxy ?? false,
+  })
   const project = await server.store.openProject(projectDir, "Project")
   return { server, projectDir, project }
 }
@@ -26,13 +31,14 @@ function extractCookie(response: Response) {
 }
 
 describe("password auth", () => {
-  test("redirects unauthenticated html requests to the login page", async () => {
+  test("serves the app shell to unauthenticated browser requests", async () => {
     const { server } = await startPasswordServer()
 
     try {
-      const response = await fetch(`http://localhost:${server.port}/`, { redirect: "manual", headers: { Accept: "text/html" } })
-      expect(response.status).toBe(302)
-      expect(response.headers.get("location")).toBe(`http://localhost:${server.port}/auth/login?next=%2F`)
+      const response = await fetch(`http://localhost:${server.port}/chat/demo`, { headers: { Accept: "text/html" } })
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toContain("text/html")
+      expect(await response.text()).toContain('id="root"')
     } finally {
       await server.stop()
     }
@@ -49,14 +55,13 @@ describe("password auth", () => {
     }
   })
 
-  test("serves the login page without authentication", async () => {
+  test("redirects /auth/login back into the app", async () => {
     const { server } = await startPasswordServer()
 
     try {
-      const response = await fetch(`http://localhost:${server.port}/auth/login`)
-      expect(response.status).toBe(200)
-      expect(response.headers.get("content-type")).toContain("text/html")
-      expect(await response.text()).toContain("This server is password protected")
+      const response = await fetch(`http://localhost:${server.port}/auth/login?next=%2Fchat%2Fdemo`, { redirect: "manual" })
+      expect(response.status).toBe(302)
+      expect(response.headers.get("location")).toBe(`http://localhost:${server.port}/chat/demo`)
     } finally {
       await server.stop()
     }
@@ -66,20 +71,16 @@ describe("password auth", () => {
     const { server } = await startPasswordServer()
 
     try {
-      const formData = new FormData()
-      formData.append("password", "secret")
-      formData.append("next", "/")
       const response = await fetch(`http://localhost:${server.port}/auth/login`, {
         method: "POST",
-        body: formData,
-        redirect: "manual",
+        body: JSON.stringify({ password: "secret", next: "/" }),
         headers: {
+          "Content-Type": "application/json",
           Origin: `http://localhost:${server.port}`,
         },
       })
 
-      expect(response.status).toBe(302)
-      expect(response.headers.get("location")).toBe(`http://localhost:${server.port}/`)
+      expect(response.status).toBe(200)
       expect(extractCookie(response)).toContain("kanna_session=")
     } finally {
       await server.stop()
@@ -90,19 +91,16 @@ describe("password auth", () => {
     const { server } = await startPasswordServer()
 
     try {
-      const formData = new FormData()
-      formData.append("password", "wrong")
       const response = await fetch(`http://localhost:${server.port}/auth/login`, {
         method: "POST",
-        body: formData,
-        redirect: "manual",
+        body: JSON.stringify({ password: "wrong", next: "/" }),
         headers: {
+          "Content-Type": "application/json",
           Origin: `http://localhost:${server.port}`,
         },
       })
 
-      expect(response.status).toBe(302)
-      expect(response.headers.get("location")).toContain("/auth/login?error=1")
+      expect(response.status).toBe(401)
       expect(response.headers.get("set-cookie")).toBeNull()
     } finally {
       await server.stop()
@@ -169,6 +167,115 @@ describe("password auth", () => {
     }
   })
 
+  test("ignores forwarded proto when trustProxy is off", async () => {
+    const { server } = await startPasswordServer({ port: 54321 })
+
+    try {
+      const response = await fetch(`http://localhost:${server.port}/auth/login?next=%2F`, {
+        redirect: "manual",
+        headers: {
+          "X-Forwarded-Proto": "https",
+        },
+      })
+      expect(response.status).toBe(302)
+      expect(response.headers.get("location")).toBe(`http://localhost:${server.port}/`)
+
+      const loginResponse = await fetch(`http://localhost:${server.port}/auth/login`, {
+        method: "POST",
+        body: JSON.stringify({ password: "secret", next: "/" }),
+        headers: {
+          "Content-Type": "application/json",
+          Origin: "https://evil.test",
+          "X-Forwarded-Proto": "https",
+        },
+      })
+      expect(loginResponse.status).toBe(403)
+
+      const goodLoginResponse = await fetch(`http://localhost:${server.port}/auth/login`, {
+        method: "POST",
+        body: JSON.stringify({ password: "secret", next: "/" }),
+        headers: {
+          "Content-Type": "application/json",
+          Origin: `http://localhost:${server.port}`,
+          "X-Forwarded-Proto": "https",
+        },
+      })
+      expect(goodLoginResponse.status).toBe(200)
+      const cookieHeader = goodLoginResponse.headers.get("set-cookie") ?? ""
+      expect(cookieHeader).not.toContain("Secure")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("honors forwarded proto when trustProxy is on", async () => {
+    const { server } = await startPasswordServer({ port: 54322, trustProxy: true })
+
+    try {
+      const redirect = await fetch(`http://localhost:${server.port}/auth/login?next=%2F`, {
+        redirect: "manual",
+        headers: {
+          "X-Forwarded-Proto": "https",
+        },
+      })
+      expect(redirect.status).toBe(302)
+      expect(redirect.headers.get("location")).toBe(`https://localhost:${server.port}/`)
+
+      const loginResponse = await fetch(`http://localhost:${server.port}/auth/login`, {
+        method: "POST",
+        body: JSON.stringify({ password: "secret", next: "/" }),
+        headers: {
+          "Content-Type": "application/json",
+          Origin: `https://localhost:${server.port}`,
+          "X-Forwarded-Proto": "https",
+        },
+      })
+      expect(loginResponse.status).toBe(200)
+      expect(loginResponse.headers.get("set-cookie") ?? "").toContain("Secure")
+
+      const evilResponse = await fetch(`http://localhost:${server.port}/auth/login`, {
+        method: "POST",
+        body: JSON.stringify({ password: "secret", next: "/" }),
+        headers: {
+          "Content-Type": "application/json",
+          Origin: `http://localhost:${server.port}`,
+        },
+      })
+      expect(evilResponse.status).toBe(200)
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("ignores invalid forwarded proto values", async () => {
+    const { server } = await startPasswordServer({ port: 54323, trustProxy: true })
+
+    try {
+      const redirect = await fetch(`http://localhost:${server.port}/auth/login?next=%2F`, {
+        redirect: "manual",
+        headers: {
+          "X-Forwarded-Proto": "ftp",
+        },
+      })
+      expect(redirect.status).toBe(302)
+      expect(redirect.headers.get("location")).toBe(`http://localhost:${server.port}/`)
+
+      const loginResponse = await fetch(`http://localhost:${server.port}/auth/login`, {
+        method: "POST",
+        body: JSON.stringify({ password: "secret", next: "/" }),
+        headers: {
+          "Content-Type": "application/json",
+          Origin: `http://localhost:${server.port}`,
+          "X-Forwarded-Proto": "ftp",
+        },
+      })
+      expect(loginResponse.status).toBe(200)
+      expect(loginResponse.headers.get("set-cookie") ?? "").not.toContain("Secure")
+    } finally {
+      await server.stop()
+    }
+  })
+
   test("clears the session cookie on logout", async () => {
     const { server } = await startPasswordServer()
 

package/src/server/auth.ts

@@ -1,5 +1,4 @@
 import { randomBytes, timingSafeEqual } from "node:crypto"
-import { APP_NAME } from "../shared/branding"
 
 const SESSION_COOKIE_NAME = "kanna_session"
 
@@ -9,17 +8,12 @@ export interface AuthStatusPayload {
 }
 
 export interface AuthManager {
-  readonly enabled: true
   isAuthenticated(req: Request): boolean
   validateOrigin(req: Request): boolean
-  createSessionCookie(req: Request): string
-  clearSessionCookie(req: Request): string
-  verifyPassword(candidate: string): boolean
+  redirectToApp(req: Request): Response
   handleLogin(req: Request, nextPath: string): Promise<Response>
   handleLogout(req: Request): Response
   handleStatus(req: Request): Response
-  renderLoginPage(req: Request): Response
-  unauthorizedResponse(req: Request): Response
 }
 
 function parseCookies(header: string | null) {
@@ -47,11 +41,30 @@ function sanitizeNextPath(nextPath: string | null | undefined) {
   return nextPath
 }
 
-function shouldUseSecureCookie(req: Request) {
+function forwardedProto(req: Request): "http" | "https" | null {
+  const xfp = req.headers.get("x-forwarded-proto")
+  if (!xfp) return null
+  const value = xfp.split(",")[0]?.trim().toLowerCase()
+  return value === "http" || value === "https" ? value : null
+}
+
+function effectiveOrigin(req: Request, trustProxy: boolean): string {
+  const url = new URL(req.url)
+  if (!trustProxy) return url.origin
+  const proto = forwardedProto(req)
+  const scheme = proto ?? url.protocol.replace(":", "")
+  return `${scheme}://${url.host}`
+}
+
+function shouldUseSecureCookie(req: Request, trustProxy: boolean) {
+  if (trustProxy) {
+    const proto = forwardedProto(req)
+    if (proto) return proto === "https"
+  }
   return new URL(req.url).protocol === "https:"
 }
 
-function buildCookie(name: string, value: string, req: Request, extras: string[] = []) {
+function buildCookie(name: string, value: string, req: Request, trustProxy: boolean, extras: string[] = []) {
   const parts = [
     `${name}=${encodeURIComponent(value)}`,
     "Path=/",
@@ -59,7 +72,7 @@ function buildCookie(name: string, value: string, req: Request, extras: string[]
     "SameSite=Strict",
   ]
 
-  if (shouldUseSecureCookie(req)) {
+  if (shouldUseSecureCookie(req, trustProxy)) {
     parts.push("Secure")
   }
 
@@ -75,7 +88,6 @@ async function readLoginForm(req: Request) {
     return {
       password: typeof payload.password === "string" ? payload.password : "",
       nextPath: sanitizeNextPath(typeof payload.next === "string" ? payload.next : "/"),
-      wantsJson: true,
     }
   }
 
@@ -83,27 +95,26 @@ async function readLoginForm(req: Request) {
   return {
     password: String(formData.get("password") ?? ""),
     nextPath: sanitizeNextPath(String(formData.get("next") ?? "/")),
-    wantsJson: false,
   }
 }
 
-function requestWantsHtml(req: Request) {
-  const accept = req.headers.get("accept") ?? ""
-  return accept.includes("text/html")
-}
-
-function escapeHtml(value: string) {
-  return value
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll("\"", "&quot;")
-    .replaceAll("'", "&#39;")
+export interface AuthManagerOptions {
+  /**
+   * When true, the auth layer trusts X-Forwarded-Proto to decide whether the
+   * public origin is http or https. The hostname always comes from the Host
+   * header (never X-Forwarded-Host) because X-Forwarded-Host is passed
+   * through by some tunnels unmodified and would otherwise allow open
+   * redirects.
+   * Enable only when the server is reachable solely through a trusted reverse
+   * proxy such as cloudflared.
+   */
+  trustProxy?: boolean
 }
 
-export function createAuthManager(password: string): AuthManager {
+export function createAuthManager(password: string, options: AuthManagerOptions = {}): AuthManager {
   const sessions = new Set<string>()
   const expectedPassword = Buffer.from(password)
+  const trustProxy = options.trustProxy ?? false
 
   function getSessionToken(req: Request) {
     return parseCookies(req.headers.get("cookie")).get(SESSION_COOKIE_NAME) ?? null
@@ -117,13 +128,15 @@ export function createAuthManager(password: string): AuthManager {
   function validateOrigin(req: Request) {
     const origin = req.headers.get("origin")
     if (!origin) return true
-    return origin === new URL(req.url).origin
+    if (origin === new URL(req.url).origin) return true
+    if (!trustProxy) return false
+    return origin === effectiveOrigin(req, trustProxy)
   }
 
   function createSessionCookie(req: Request) {
     const sessionToken = randomBytes(32).toString("base64url")
     sessions.add(sessionToken)
-    return buildCookie(SESSION_COOKIE_NAME, sessionToken, req)
+    return buildCookie(SESSION_COOKIE_NAME, sessionToken, req, trustProxy)
   }
 
   function clearSessionCookie(req: Request) {
@@ -131,7 +144,7 @@ export function createAuthManager(password: string): AuthManager {
     if (sessionToken) {
       sessions.delete(sessionToken)
     }
-    return buildCookie(SESSION_COOKIE_NAME, "", req, ["Max-Age=0"])
+    return buildCookie(SESSION_COOKIE_NAME, "", req, trustProxy, ["Max-Age=0"])
   }
 
   function verifyPassword(candidate: string) {
@@ -149,108 +162,9 @@ export function createAuthManager(password: string): AuthManager {
     } satisfies AuthStatusPayload)
   }
 
-  function unauthorizedResponse(req: Request) {
-    if (req.method === "GET" && requestWantsHtml(req)) {
-      const url = new URL(req.url)
-      const loginUrl = new URL("/auth/login", req.url)
-      loginUrl.searchParams.set("next", sanitizeNextPath(`${url.pathname}${url.search}`))
-      return Response.redirect(loginUrl, 302)
-    }
-
-    return Response.json({ error: "Unauthorized" }, { status: 401 })
-  }
-
-  function renderLoginPage(req: Request) {
-    if (isAuthenticated(req)) {
-      const currentUrl = new URL(req.url)
-      return Response.redirect(new URL(sanitizeNextPath(currentUrl.searchParams.get("next")), req.url), 302)
-    }
-
+  function redirectToApp(req: Request) {
     const currentUrl = new URL(req.url)
-    const nextPath = sanitizeNextPath(currentUrl.searchParams.get("next"))
-    const showError = currentUrl.searchParams.get("error") === "1"
-    const html = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${escapeHtml(APP_NAME)} Login</title>
-    <style>
-      :root { color-scheme: dark; }
-      * { box-sizing: border-box; }
-      body {
-        margin: 0;
-        min-height: 100vh;
-        font-family: ui-sans-serif, system-ui, sans-serif;
-        background:
-          radial-gradient(circle at top, rgba(255,255,255,0.10), transparent 28%),
-          linear-gradient(160deg, #16181d 0%, #0b0d10 55%, #050608 100%);
-        color: #f4f7fb;
-        display: grid;
-        place-items: center;
-        padding: 24px;
-      }
-      .card {
-        width: min(420px, 100%);
-        border: 1px solid rgba(255,255,255,0.12);
-        background: rgba(12, 15, 20, 0.88);
-        backdrop-filter: blur(10px);
-        border-radius: 24px;
-        padding: 28px;
-        box-shadow: 0 24px 70px rgba(0,0,0,0.35);
-      }
-      h1 { margin: 0 0 8px; font-size: 28px; }
-      p { margin: 0 0 20px; color: #a6b0bd; line-height: 1.5; }
-      label { display: block; font-size: 13px; margin-bottom: 8px; color: #d7dce4; }
-      input {
-        width: 100%;
-        border-radius: 14px;
-        border: 1px solid rgba(255,255,255,0.16);
-        background: rgba(255,255,255,0.04);
-        color: inherit;
-        padding: 14px 16px;
-        font-size: 15px;
-        margin-bottom: 16px;
-      }
-      button {
-        width: 100%;
-        border: 0;
-        border-radius: 14px;
-        padding: 14px 16px;
-        background: linear-gradient(135deg, #f4ede0 0%, #d9c4a1 100%);
-        color: #16181d;
-        font-size: 15px;
-        font-weight: 700;
-        cursor: pointer;
-      }
-      .error {
-        margin-bottom: 16px;
-        border-radius: 14px;
-        background: rgba(255, 106, 106, 0.12);
-        border: 1px solid rgba(255, 106, 106, 0.24);
-        color: #ffb8b8;
-        padding: 12px 14px;
-        font-size: 14px;
-      }
-    </style>
-  </head>
-  <body>
-    <form class="card" method="post" action="/auth/login">
-      <h1>${escapeHtml(APP_NAME)}</h1>
-      <p>This server is password protected. Enter the launch password to continue.</p>
-      ${showError ? '<div class="error">Incorrect password. Try again.</div>' : ""}
-      <input type="hidden" name="next" value="${escapeHtml(nextPath)}" />
-      <label for="password">Password</label>
-      <input id="password" name="password" type="password" autocomplete="current-password" autofocus required />
-      <button type="submit">Unlock</button>
-    </form>
-  </body>
-</html>`
-    return new Response(html, {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-      },
-    })
+    return Response.redirect(new URL(sanitizeNextPath(currentUrl.searchParams.get("next")), effectiveOrigin(req, trustProxy)), 302)
   }
 
   async function handleLogin(req: Request, fallbackNextPath: string) {
@@ -258,21 +172,12 @@ export function createAuthManager(password: string): AuthManager {
       return Response.json({ error: "Forbidden" }, { status: 403 })
     }
 
-    const { password: candidate, nextPath, wantsJson } = await readLoginForm(req)
+    const { password: candidate, nextPath } = await readLoginForm(req)
     if (!verifyPassword(candidate)) {
-      if (wantsJson) {
-        return Response.json({ error: "Invalid password" }, { status: 401 })
-      }
-
-      const redirectUrl = new URL("/auth/login", req.url)
-      redirectUrl.searchParams.set("error", "1")
-      redirectUrl.searchParams.set("next", sanitizeNextPath(nextPath || fallbackNextPath))
-      return Response.redirect(redirectUrl, 302)
+      return Response.json({ error: "Invalid password" }, { status: 401 })
     }
 
-    const response = wantsJson
-      ? Response.json({ ok: true, nextPath: sanitizeNextPath(nextPath || fallbackNextPath) })
-      : Response.redirect(new URL(sanitizeNextPath(nextPath || fallbackNextPath), req.url), 302)
+    const response = Response.json({ ok: true, nextPath: sanitizeNextPath(nextPath || fallbackNextPath) })
 
     response.headers.set("Set-Cookie", createSessionCookie(req))
     return response
@@ -289,16 +194,11 @@ export function createAuthManager(password: string): AuthManager {
   }
 
   return {
-    enabled: true,
     isAuthenticated,
     validateOrigin,
-    createSessionCookie,
-    clearSessionCookie,
-    verifyPassword,
+    redirectToApp,
     handleLogin,
     handleLogout,
     handleStatus,
-    renderLoginPage,
-    unauthorizedResponse,
   }
 }

package/src/server/cli-runtime.test.ts

@@ -27,6 +27,7 @@ function createDeps(overrides: Partial<Parameters<typeof runCli>[1]> = {}) {
       share: false | "quick" | { kind: "token"; token: string }
       password: string | null
       strictPort: boolean
+      trustProxy?: boolean
       update: {
         version: string
         argv: string[]
@@ -290,6 +291,7 @@ describe("runCli", () => {
       share: false,
       password: null,
       strictPort: false,
+      trustProxy: false,
       update: {
         version: "0.3.0",
         argv: ["--port", "4000", "--no-open"],
@@ -356,6 +358,7 @@ describe("runCli", () => {
 
     expect(result.kind).toBe("started")
     expect(calls.openUrl).toEqual([])
+    expect(calls.startServer[0]?.trustProxy).toBe(true)
     expect(calls.shareTunnel).toEqual([{ localUrl: "http://localhost:4000", shareMode: "quick" }])
     expect(calls.renderShareQr).toEqual(["https://kanna.trycloudflare.com"])
     expect(calls.log).toContain("QR Code:")
@@ -452,6 +455,7 @@ describe("runCli", () => {
     const result = await runCli(["--cloudflared", "secret-token"], deps)
 
     expect(result.kind).toBe("started")
+    expect(calls.startServer[0]?.trustProxy).toBe(true)
     expect(calls.shareTunnel).toEqual([{
       localUrl: "http://localhost:3210",
       shareMode: { kind: "token", token: "secret-token" },

package/src/server/cli-runtime.ts

@@ -49,6 +49,7 @@ export interface CliRuntimeDeps {
   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
@@ -270,6 +271,7 @@ export async function runCli(argv: string[], deps: CliRuntimeDeps): Promise<CliR
 
   const { port, stop } = await deps.startServer({
     ...parsedArgs.options,
+    trustProxy: isShareEnabled(parsedArgs.options.share),
     onMigrationProgress: deps.log,
     update: {
       version: deps.version,

package/src/server/codex-app-server-protocol.ts

@@ -45,6 +45,17 @@ export interface ThreadResumeParams {
   persistExtendedHistory: boolean
 }
 
+export interface ThreadForkParams {
+  threadId: string
+  model?: string | null
+  cwd?: string | null
+  serviceTier?: ServiceTier | null
+  approvalPolicy?: "never" | "on-request" | "on-failure" | "untrusted" | null
+  sandbox?: "read-only" | "workspace-write" | "danger-full-access" | null
+  ephemeral?: boolean
+  persistExtendedHistory: boolean
+}
+
 export interface TextUserInput {
   type: "text"
   text: string
@@ -90,6 +101,7 @@ export interface ThreadStartResponse {
 }
 
 export type ThreadResumeResponse = ThreadStartResponse
+export type ThreadForkResponse = ThreadStartResponse
 
 export interface TurnSummary {
   id: string

package/src/server/codex-app-server.test.ts

@@ -120,6 +120,38 @@ describe("CodexAppServerManager", () => {
     ])
   })
 
+  test("forks a thread when a pending fork session token is provided", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/fork") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-fork-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    const sessionToken = await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+      pendingForkSessionToken: "thread-source",
+    })
+
+    expect(sessionToken).toBe("thread-fork-1")
+    expect(process.messages.map((message: any) => message.method)).toEqual([
+      "initialize",
+      "initialized",
+      "thread/fork",
+    ])
+  })
+
   test("maps fast mode and reasoning into app-server params", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

package/src/server/codex-app-server.ts

@@ -34,6 +34,8 @@ import {
   type ThreadItem,
   type ThreadResumeParams,
   type ThreadResumeResponse,
+  type ThreadForkParams,
+  type ThreadForkResponse,
   type ThreadStartParams,
   type ThreadStartResponse,
   type ThreadTokenUsageUpdatedNotification,
@@ -118,6 +120,7 @@ export interface StartCodexSessionArgs {
   model: string
   serviceTier?: ServiceTier
   sessionToken: string | null
+  pendingForkSessionToken?: string | null
 }
 
 export interface StartCodexTurnArgs {
@@ -745,7 +748,7 @@ export class CodexAppServerManager {
 
   async startSession(args: StartCodexSessionArgs) {
     const existing = this.sessions.get(args.chatId)
-    if (existing && !existing.closed && existing.cwd === args.cwd) {
+    if (existing && !existing.closed && existing.cwd === args.cwd && !args.pendingForkSessionToken) {
       return
     }
 
@@ -791,8 +794,18 @@ export class CodexAppServerManager {
       persistExtendedHistory: false,
     } satisfies ThreadStartParams
 
-    let response: ThreadStartResponse | ThreadResumeResponse
-    if (args.sessionToken) {
+    let response: ThreadStartResponse | ThreadResumeResponse | ThreadForkResponse
+    if (args.pendingForkSessionToken) {
+      response = await this.sendRequest<ThreadForkResponse>(context, "thread/fork", {
+        threadId: args.pendingForkSessionToken,
+        model: args.model,
+        cwd: args.cwd,
+        serviceTier: args.serviceTier,
+        approvalPolicy: "never",
+        sandbox: "danger-full-access",
+        persistExtendedHistory: false,
+      } satisfies ThreadForkParams)
+    } else if (args.sessionToken) {
       try {
         response = await this.sendRequest<ThreadResumeResponse>(context, "thread/resume", {
           threadId: args.sessionToken,
@@ -815,6 +828,7 @@ export class CodexAppServerManager {
     }
 
     context.sessionToken = response.thread.id
+    return context.sessionToken
   }
 
   async startTurn(args: StartCodexTurnArgs): Promise<HarnessTurn> {