feat(page): print the eval-js value bare and use exception_detail for failures

internal/cmd/execution_failure_test.go

@@ -0,0 +1,70 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/nottelabs/notte-cli/internal/api"
+)
+
+func strPtr(s string) *string { return &s }
+
+// The API sends the failure twice: `exception` is a bare string rendered in the
+// server's ErrorConfig mode (often the generic user-facing sentence), while
+// `exception_detail` carries the concrete type and the per-audience messages.
+// The CLI must report the structured one when it is there.
+func TestExecutionFailureError_PrefersStructuredDetail(t *testing.T) {
+	detail := &api.SerializedError{
+		ErrorType:   "ActionExecutionError",
+		DevMessage:  "Failed to execute action: evaluate_js on https://x. Reason: ReferenceError: foo is not defined",
+		UserMessage: "Sorry, this action cannot be executed at the moment.",
+	}
+
+	err := executionFailureError(detail, strPtr("Sorry, this action cannot be executed at the moment."), "boom")
+
+	got := err.Error()
+	if !strings.Contains(got, "ActionExecutionError") {
+		t.Fatalf("expected the concrete error type, got %q", got)
+	}
+	if !strings.Contains(got, "ReferenceError: foo is not defined") {
+		t.Fatalf("expected the actual reason, got %q", got)
+	}
+	if strings.Contains(got, "Sorry, this action cannot be executed") {
+		t.Fatalf("expected the generic user message to be dropped, got %q", got)
+	}
+}
+
+func TestExecutionFailureError_FallsBackToUserMessage(t *testing.T) {
+	detail := &api.SerializedError{ErrorType: "BrowserError", UserMessage: "Something unexpected happened."}
+
+	err := executionFailureError(detail, nil, "")
+
+	if got := err.Error(); got != "BrowserError: Something unexpected happened." {
+		t.Fatalf("unexpected error: %q", got)
+	}
+}
+
+// API builds that predate exception_detail send only the legacy string.
+func TestExecutionFailureError_LegacyExceptionString(t *testing.T) {
+	err := executionFailureError(nil, strPtr("boom"), "click failed")
+
+	if got := err.Error(); got != "boom: click failed" {
+		t.Fatalf("unexpected error: %q", got)
+	}
+}
+
+func TestExecutionFailureError_MessageOnly(t *testing.T) {
+	err := executionFailureError(nil, nil, "click failed")
+
+	if got := err.Error(); got != "action failed: click failed" {
+		t.Fatalf("unexpected error: %q", got)
+	}
+}
+
+func TestExecutionFailureError_NothingToGoOn(t *testing.T) {
+	err := executionFailureError(nil, nil, "")
+
+	if got := err.Error(); got != "action failed" {
+		t.Fatalf("unexpected error: %q", got)
+	}
+}

internal/cmd/output_helpers.go

@@ -227,3 +227,41 @@ func printSessionStatus(resp *api.SessionResponse) error {
 
 	return nil
 }
+
+// executionFailureError builds the error for a failed page action.
+//
+// The API serializes failures twice: `exception` is a bare string rendered in
+// whatever ErrorConfig mode the server ran in (often the generic user-facing
+// sentence), while `exception_detail` carries the concrete error type, the
+// per-audience messages and the retry/notify flags. Prefer the structured
+// field so the CLI reports what actually went wrong, and fall back to the
+// legacy string for API builds that predate it.
+func executionFailureError(detail *api.SerializedError, exception *string, message string) error {
+	if detail != nil {
+		reason := detail.DevMessage
+		if reason == "" {
+			reason = detail.UserMessage
+		}
+		if reason == "" {
+			reason = message
+		}
+		if reason == "" {
+			return fmt.Errorf("%s", detail.ErrorType)
+		}
+		if detail.ErrorType != "" {
+			return fmt.Errorf("%s: %s", detail.ErrorType, reason)
+		}
+		return fmt.Errorf("%s", reason)
+	}
+
+	if exception != nil && *exception != "" {
+		if message != "" && *exception != message {
+			return fmt.Errorf("%s: %s", *exception, message)
+		}
+		return fmt.Errorf("%s", *exception)
+	}
+	if message != "" {
+		return fmt.Errorf("action failed: %s", message)
+	}
+	return fmt.Errorf("action failed")
+}

internal/cmd/page.go

@@ -55,19 +55,7 @@ func printExecuteResponse(resp *api.ApiExecutionResponse) error {
 	}
 
 	if !resp.Success {
-		// Build error message with available context
-		if resp.Exception != nil {
-			// Include exception and message if both present and different
-			if resp.Message != "" && *resp.Exception != resp.Message {
-				return fmt.Errorf("%s: %s", *resp.Exception, resp.Message)
-			}
-			return fmt.Errorf("%s", *resp.Exception)
-		}
-		// No exception - use message or generic fallback
-		if resp.Message != "" {
-			return fmt.Errorf("action failed: %s", resp.Message)
-		}
-		return fmt.Errorf("action failed")
+		return executionFailureError(resp.ExceptionDetail, resp.Exception, resp.Message)
 	}
 
 	// Print message
@@ -718,10 +706,15 @@ var pageEvalJsCmd = &cobra.Command{
 
 The JavaScript code is executed in the context of the page's main frame.
 
+The evaluated value is printed alone on stdout (objects and arrays as JSON, a JS
+null as "null"), so it pipes straight into jq or a shell variable; the status
+line goes to stderr. Use -o json for the full execution result.
+
 Examples:
   notte page eval-js "document.title"
   notte page eval-js "window.location.href"
-  notte page eval-js "document.querySelectorAll('a').length"`,
+  notte page eval-js "document.querySelectorAll('a').length"
+  notte page eval-js "JSON.stringify([...document.links].map(a => a.href))" | jq length`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPageEvalJs,
 }
@@ -765,21 +758,16 @@ func runPageEvalJs(cmd *cobra.Command, args []string) error {
 	}
 
 	if !result.Success {
-		if result.Exception != nil {
-			if result.Message != "" && *result.Exception != result.Message {
-				return fmt.Errorf("%s: %s", *result.Exception, result.Message)
-			}
-			return fmt.Errorf("%s", *result.Exception)
-		}
-		if result.Message != "" {
-			return fmt.Errorf("eval-js failed: %s", result.Message)
-		}
-		return fmt.Errorf("eval-js failed")
+		return executionFailureError(result.ExceptionDetail, result.Exception, result.Message)
 	}
 
-	fmt.Println(result.Message)
-	if result.Data != nil && result.Data.Markdown != "" {
-		fmt.Printf("Result:  %s\n", result.Data.Markdown)
+	// The evaluated value is the point of the command, so print it bare: it pipes
+	// into jq or a shell variable without post-processing, and a JS value that is
+	// legitimately empty still prints an (empty) line instead of vanishing behind
+	// a success banner. The status line goes to stderr so stdout stays the value.
+	_, _ = fmt.Fprintln(os.Stderr, result.Message)
+	if result.Data != nil {
+		fmt.Println(result.Data.Markdown)
 	}
 	return nil
 }