From f83b22c4de5ac5cf9c46f31e2d32c284e9c61de0 Mon Sep 17 00:00:00 2001 From: YeonGyu-Kim Date: Mon, 12 Jan 2026 14:49:07 +0900 Subject: [PATCH] fix(cli/run): properly serialize error objects to prevent [object Object] output - Add serializeError utility to handle Error instances, plain objects, and nested message paths - Fix handleSessionError to use serializeError instead of naive String() conversion - Fix runner.ts catch block to use serializeError for detailed error messages - Add session.error case to logEventVerbose for better error visibility - Add comprehensive tests for serializeError function Fixes error logging in sisyphus-agent workflow where errors were displayed as '[object Object]' --- src/cli/run/events.test.ts | 59 +++++++++++++++++++++++++++++++++++++- src/cli/run/events.ts | 56 ++++++++++++++++++++++++++++++++++-- src/cli/run/runner.ts | 4 +-- 3 files changed, 113 insertions(+), 6 deletions(-) diff --git a/src/cli/run/events.test.ts b/src/cli/run/events.test.ts index bcf9fd51a..1ba48ca5d 100644 --- a/src/cli/run/events.test.ts +++ b/src/cli/run/events.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect } from "bun:test" -import { createEventState, type EventState } from "./events" +import { createEventState, serializeError, type EventState } from "./events" import type { RunContext, EventPayload } from "./types" const createMockContext = (sessionID: string = "test-session"): RunContext => ({ @@ -15,6 +15,63 @@ async function* toAsyncIterable(items: T[]): AsyncIterable { } } +describe("serializeError", () => { + it("returns 'Unknown error' for null/undefined", () => { + // #given / #when / #then + expect(serializeError(null)).toBe("Unknown error") + expect(serializeError(undefined)).toBe("Unknown error") + }) + + it("returns message from Error instance", () => { + // #given + const error = new Error("Something went wrong") + + // #when / #then + expect(serializeError(error)).toBe("Something went wrong") + }) + + it("returns string as-is", () => { + // #given / #when / #then + expect(serializeError("Direct error message")).toBe("Direct error message") + }) + + it("extracts message from plain object", () => { + // #given + const errorObj = { message: "Object error message", code: "ERR_001" } + + // #when / #then + expect(serializeError(errorObj)).toBe("Object error message") + }) + + it("extracts message from nested error object", () => { + // #given + const errorObj = { error: { message: "Nested error message" } } + + // #when / #then + expect(serializeError(errorObj)).toBe("Nested error message") + }) + + it("extracts message from data.message path", () => { + // #given + const errorObj = { data: { message: "Data error message" } } + + // #when / #then + expect(serializeError(errorObj)).toBe("Data error message") + }) + + it("JSON stringifies object without message property", () => { + // #given + const errorObj = { code: "ERR_001", status: 500 } + + // #when + const result = serializeError(errorObj) + + // #then + expect(result).toContain("ERR_001") + expect(result).toContain("500") + }) +}) + describe("createEventState", () => { it("creates initial state with correct defaults", () => { // #given / #when diff --git a/src/cli/run/events.ts b/src/cli/run/events.ts index 10b9c6133..f6e0ca696 100644 --- a/src/cli/run/events.ts +++ b/src/cli/run/events.ts @@ -11,6 +11,51 @@ import type { ToolResultProps, } from "./types" +export function serializeError(error: unknown): string { + if (!error) return "Unknown error" + + if (error instanceof Error) { + const parts = [error.message] + if (error.cause) { + parts.push(`Cause: ${serializeError(error.cause)}`) + } + return parts.join(" | ") + } + + if (typeof error === "string") { + return error + } + + if (typeof error === "object") { + const obj = error as Record + + const messagePaths = [ + obj.message, + obj.error, + (obj.data as Record)?.message, + (obj.data as Record)?.error, + (obj.error as Record)?.message, + ] + + for (const msg of messagePaths) { + if (typeof msg === "string" && msg.length > 0) { + return msg + } + } + + try { + const json = JSON.stringify(error, null, 2) + if (json !== "{}") { + return json + } + } catch (_) { + void _ + } + } + + return String(error) +} + export interface EventState { mainSessionIdle: boolean mainSessionError: boolean @@ -125,6 +170,13 @@ function logEventVerbose(ctx: RunContext, payload: EventPayload): void { break } + case "session.error": { + const errorProps = props as SessionErrorProps | undefined + const errorMsg = serializeError(errorProps?.error) + console.error(pc.red(`${sessionTag} ❌ SESSION.ERROR: ${errorMsg}`)) + break + } + default: console.error(pc.dim(`${sessionTag} ${payload.type}`)) } @@ -166,9 +218,7 @@ function handleSessionError( const props = payload.properties as SessionErrorProps | undefined if (props?.sessionID === ctx.sessionID) { state.mainSessionError = true - state.lastError = props?.error - ? String(props.error instanceof Error ? props.error.message : props.error) - : "Unknown error" + state.lastError = serializeError(props?.error) console.error(pc.red(`\n[session.error] ${state.lastError}`)) } } diff --git a/src/cli/run/runner.ts b/src/cli/run/runner.ts index 1013d9fd8..a648417af 100644 --- a/src/cli/run/runner.ts +++ b/src/cli/run/runner.ts @@ -2,7 +2,7 @@ import { createOpencode } from "@opencode-ai/sdk" import pc from "picocolors" import type { RunOptions, RunContext } from "./types" import { checkCompletionConditions } from "./completion" -import { createEventState, processEvents } from "./events" +import { createEventState, processEvents, serializeError } from "./events" const POLL_INTERVAL_MS = 500 const DEFAULT_TIMEOUT_MS = 0 @@ -115,7 +115,7 @@ export async function run(options: RunOptions): Promise { if (err instanceof Error && err.name === "AbortError") { return 130 } - console.error(pc.red(`Error: ${err}`)) + console.error(pc.red(`Error: ${serializeError(err)}`)) return 1 } }