fix(cli): surface real --cloud-fork import failure reasons

.changeset/cloud-fork-import-errors.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/cli": patch
+---
+
+Surface the underlying reason when `kilo --cloud-fork` fails to import a cloud session (HTTP status, server message, or fetch error) in both the user-visible message and the DEBUG log stream.

packages/opencode/src/cli/cmd/run.ts

@@ -32,11 +32,14 @@ import { FormatError, FormatUnknownError } from "../error"
 import { INTERACTIVE_INPUT_ERROR, resolveInteractiveStdin } from "./run/runtime.stdin"
 import { event as normalizeEvent } from "./run/event"
 import { importCloudSession, validateCloudFork } from "@/kilocode/cloud-session" // kilocode_change
+import { errorMessage } from "@/util/error" // kilocode_change
+import { Log } from "@opencode-ai/core/util/log" // kilocode_change
 import { KiloRunAuto } from "@/kilocode/cli/run-auto" // kilocode_change
 import { KiloHeadless } from "@/kilocode/permission/headless" // kilocode_change
 import { KiloRun, KiloRunDaemon } from "@/kilocode/cli/cmd/run" // kilocode_change
 
 const runtimeTask = import("./run/runtime")
+const log = Log.create({ service: "cli.run" }) // kilocode_change
 type ModelInput = Parameters<KiloClient["session"]["prompt"]>[0]["model"]
 
 function pick(value: string | undefined): ModelInput | undefined {
@@ -441,29 +444,30 @@ export const RunCommand = effectCmd({
       async function session(sdk: KiloClient): Promise<SessionInfo | undefined> {
         // kilocode_change start - import cloud session before local lookup
         if (args.session && args["cloud-fork"]) {
-          const id = await importCloudSession(sdk, args.session).catch(() => undefined)
-          if (!id) {
-            UI.error("Failed to import session from cloud")
-            process.exit(1)
-          }
-
-          const current = await sdk.session
-            .get({
-              sessionID: id,
-            })
-            .catch(() => undefined)
+          try {
+            const id = await importCloudSession(sdk, args.session)
+            const current = await sdk.session
+              .get({
+                sessionID: id,
+              })
+              .catch(() => undefined)
+
+            if (!current?.data) {
+              UI.error("Session not found")
+              process.exit(1)
+            }
 
-          if (!current?.data) {
-            UI.error("Session not found")
+            return {
+              id: current.data.id,
+              title: current.data.title,
+              directory: current.data.directory,
+              model: current.data.model,
+            }
+          } catch (err) {
+            log.debug("failed to import cloud session", { err })
+            UI.error(`Failed to import session from cloud: ${errorMessage(err)}`)
             process.exit(1)
           }
-
-          return {
-            id: current.data.id,
-            title: current.data.title,
-            directory: current.data.directory,
-            model: current.data.model,
-          }
         }
         // kilocode_change end
 

packages/opencode/src/cli/cmd/tui/attach.ts

@@ -1,4 +1,5 @@
 import { cmd } from "../cmd"
+import { Log } from "@opencode-ai/core/util/log" // kilocode_change
 import { UI } from "@/cli/ui"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
 import { TuiConfig } from "@/cli/cmd/tui/config/tui"
@@ -8,6 +9,8 @@ import { errorMessage } from "@/util/error"
 import { validateSession } from "./validate-session"
 import { ServerAuth } from "@/server/auth"
 
+const log = Log.create({ service: "tui.attach" }) // kilocode_change
+
 export const AttachCommand = cmd({
   command: "attach <url>",
   describe: "attach to a running kilo server", // kilocode_change
@@ -89,14 +92,16 @@ export const AttachCommand = cmd({
           directory,
           headers,
         })
-        const id = await importCloudSession(sdk, args.session).catch(() => undefined)
-        if (!id) {
-          UI.error("Failed to import session from cloud")
+        try {
+          const id = await importCloudSession(sdk, args.session)
+          args.session = id
+          args.cloudFork = false
+        } catch (err) {
+          log.debug("failed to import cloud session", { err })
+          UI.error(`Failed to import session from cloud: ${errorMessage(err)}`)
           process.exitCode = 1
           return
         }
-        args.session = id
-        args.cloudFork = false
       }
       // kilocode_change end
       const config = await TuiConfig.get()

packages/opencode/src/cli/cmd/tui/thread.ts

@@ -334,14 +334,16 @@ export const TuiThreadCommand = cmd({
             headers: transport.headers, // kilocode_change
             directory: cwd,
           })
-          const id = await importCloudSession(sdk, args.session).catch(() => undefined)
-          if (!id) {
-            UI.error("Failed to import session from cloud")
+          try {
+            const id = await importCloudSession(sdk, args.session)
+            args.session = id
+            args.cloudFork = false
+          } catch (err) {
+            Log.Default.debug("failed to import cloud session", { err })
+            UI.error(`Failed to import session from cloud: ${errorMessage(err)}`)
             shutdownAndExit({ reason: "cloud-fork-failed", code: 1 })
             return
           }
-          args.session = id
-          args.cloudFork = false
         }
         // kilocode_change end
 

packages/opencode/src/kilocode/cli/cmd/tui/thread.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto"
+import { Log } from "@opencode-ai/core/util/log"
 import { UI } from "@/cli/ui"
 import type { NetworkOptions } from "@/cli/network"
 import { ServerAuth } from "@/server/auth"
@@ -10,6 +11,8 @@ import { importCloudSession } from "@/kilocode/cloud-session"
 import { DaemonClient } from "@/kilocode/daemon/client"
 import { createKiloClient } from "@kilocode/sdk/v2"
 
+const log = Log.create({ service: "kilo.tui.thread" })
+
 type TuiInput = Parameters<typeof import("@/cli/cmd/tui/app").tui>[0]
 export type StartInput = Omit<TuiInput, "renderer">
 
@@ -39,12 +42,15 @@ async function session(input: Input, daemon: DaemonClient.Connection) {
     directory: input.cwd,
     headers: daemon.headers,
   })
-  const id = await importCloudSession(client, input.args.session).catch(() => undefined)
-  if (id) return { ok: true as const, id }
-
-  UI.error("Failed to import session from cloud")
-  process.exitCode = 1
-  return { ok: false as const }
+  try {
+    const id = await importCloudSession(client, input.args.session)
+    return { ok: true as const, id }
+  } catch (err) {
+    log.debug("failed to import cloud session", { err })
+    UI.error(`Failed to import session from cloud: ${errorMessage(err)}`)
+    process.exitCode = 1
+    return { ok: false as const }
+  }
 }
 
 export namespace KiloTuiThreadDaemon {

packages/opencode/src/kilocode/cloud-session.ts

@@ -1,3 +1,5 @@
+import { errorMessage } from "@/util/error"
+
 /**
  * Validate --cloud-fork flag combinations and return an error message if invalid.
  */
@@ -21,20 +23,26 @@ export function localSessionID(args: { cloudFork?: boolean; session?: string })
  * Import a cloud session to local storage and return the new local session ID.
  * Wraps the SDK's `.kilo.cloud.session.import()` which returns `unknown` due to
  * the OpenAPI spec not typing the response.
+ *
+ * Throws when the import fails: with the server's error message on an HTTP
+ * error, or with "cloud session import returned no session id" when the
+ * response was malformed.
  */
 export async function importCloudSession(
   client: {
     kilo: {
       cloud: {
         session: {
-          import: (params: { sessionId: string }) => Promise<{ data?: unknown }>
+          import: (params: { sessionId: string }) => Promise<{ data?: unknown; error?: unknown }>
         }
       }
     }
   },
   sessionId: string,
-): Promise<string | undefined> {
+): Promise<string> {
   const result = await client.kilo.cloud.session.import({ sessionId })
+  if (result.error) throw new Error(errorMessage(result.error))
   const id = (result.data as Record<string, unknown>)?.id
-  return typeof id === "string" ? id : undefined
+  if (typeof id !== "string") throw new Error("cloud session import returned no session id")
+  return id
 }

packages/opencode/test/kilocode/cloud-session.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test"
+import { importCloudSession } from "../../src/kilocode/cloud-session"
+
+type ImportResult = { data?: unknown; error?: unknown }
+
+const client = (imp: (params: { sessionId: string }) => Promise<ImportResult>) =>
+  ({ kilo: { cloud: { session: { import: imp } } } }) as Parameters<typeof importCloudSession>[0]
+
+describe("importCloudSession", () => {
+  test("returns local id on success", async () => {
+    const c = client(async () => ({ data: { id: "ses_local" } }))
+    const id = await importCloudSession(c, "ses_cloud")
+    expect(id).toBe("ses_local")
+  })
+
+  test("throws when server returns HTTP error", async () => {
+    const c = client(async () => ({
+      data: undefined,
+      error: { name: "GatewayError", message: "session not found", status: 404 },
+    }))
+    await expect(importCloudSession(c, "ses_cloud")).rejects.toThrow("session not found")
+  })
+
+  test("throws when data.id is missing", async () => {
+    const c = client(async () => ({ data: {} }))
+    await expect(importCloudSession(c, "ses_cloud")).rejects.toThrow()
+  })
+
+  test("propagates thrown fetch exceptions", async () => {
+    const c = client(async () => {
+      throw new Error("network down")
+    })
+    await expect(importCloudSession(c, "ses_cloud")).rejects.toThrow("network down")
+  })
+})