Updated schedule execution to return detailed webhook results

Necessary to provide granular user feedback when webhook delivery
fails while screenshot capture succeeds. Previously, the UI only
showed binary success/failure states.

Changes:
- Added WebhookResult type with status code, URL, and error details
- Refactored ScheduleExecutor to return webhook outcome separately
- Enhanced UI to show "Partial Success" when screenshot saves but
  webhook fails, with full error context in modal
- Added browser console logging for debugging webhook issues

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ikraamg

trmnl-ha/ha-trmnl/html/js/app.ts

@@ -28,6 +28,7 @@ import type {
   Schedule,
   CropRegion,
   ScheduleUpdate,
+  SendScheduleResponse,
 } from '../../types/domain.js'
 
 // =============================================================================
@@ -264,29 +265,18 @@ class App {
     const sendCommand = new SendSchedule()
     const result = await sendCommand.call(scheduleId)
 
-    if (result.success) {
-      button.textContent = '✓ Sent!'
-      button.style.backgroundColor = '#10b981'
-      button.style.opacity = '1'
+    // Log detailed result to browser console
+    this.#logSendResult(result)
 
-      await this.#confirmModal.alert({
-        title: '✓ Success!',
-        message: 'Screenshot captured and sent to webhook successfully!',
-        type: 'success',
-      })
-    } else {
-      console.error('Error sending webhook:', result.error)
+    // Determine overall status based on screenshot + webhook results
+    const { title, message, type, buttonText, buttonColor } =
+      this.#buildSendResultFeedback(result)
 
-      button.textContent = '✗ Failed'
-      button.style.backgroundColor = '#ef4444'
-      button.style.opacity = '1'
+    button.textContent = buttonText
+    button.style.backgroundColor = buttonColor
+    button.style.opacity = '1'
 
-      await this.#confirmModal.alert({
-        title: '✗ Error',
-        message: `Failed to send webhook: ${result.error ?? 'Unknown error'}`,
-        type: 'error',
-      })
-    }
+    await this.#confirmModal.alert({ title, message, type })
 
     // Reset button state if it still exists in DOM
     if (document.body.contains(button)) {
@@ -298,6 +288,97 @@ class App {
     }
   }
 
+  /** Logs send result to browser console for debugging */
+  #logSendResult(result: SendScheduleResponse): void {
+    const logPrefix = '[Send Now]'
+
+    if (!result.success) {
+      console.error(`${logPrefix} Screenshot capture failed:`, result.error)
+      return
+    }
+
+    console.log(`${logPrefix} Screenshot saved: ${result.savedPath}`)
+
+    if (!result.webhook) {
+      console.log(`${logPrefix} No webhook configured`)
+      return
+    }
+
+    const { webhook } = result
+    if (webhook.success) {
+      console.log(
+        `${logPrefix} Webhook success: ${webhook.statusCode} → ${webhook.url}`
+      )
+    } else {
+      console.error(
+        `${logPrefix} Webhook failed: ${webhook.error} → ${webhook.url}`
+      )
+    }
+  }
+
+  /** Builds user-facing feedback based on send result */
+  #buildSendResultFeedback(result: SendScheduleResponse): {
+    title: string
+    message: string
+    type: 'success' | 'error' | 'warning'
+    buttonText: string
+    buttonColor: string
+  } {
+    // Screenshot capture failed
+    if (!result.success) {
+      return {
+        title: 'Screenshot Failed',
+        message: `Failed to capture screenshot: ${
+          result.error ?? 'Unknown error'
+        }`,
+        type: 'error',
+        buttonText: 'Failed',
+        buttonColor: '#ef4444',
+      }
+    }
+
+    // No webhook configured - just screenshot saved
+    if (!result.webhook) {
+      return {
+        title: 'Screenshot Saved',
+        message: `Screenshot captured and saved to:\n${result.savedPath}`,
+        type: 'success',
+        buttonText: 'Saved',
+        buttonColor: '#10b981',
+      }
+    }
+
+    // Webhook was attempted
+    const { webhook } = result
+
+    if (webhook.success) {
+      return {
+        title: 'Success',
+        message:
+          `Screenshot captured and sent to webhook.\n\n` +
+          `Saved: ${result.savedPath}\n` +
+          `Webhook: ${webhook.statusCode} OK\n` +
+          `URL: ${webhook.url ?? 'N/A'}`,
+        type: 'success',
+        buttonText: 'Sent',
+        buttonColor: '#10b981',
+      }
+    }
+
+    // Webhook failed but screenshot was saved
+    return {
+      title: 'Partial Success',
+      message:
+        `Screenshot saved, but webhook delivery failed.\n\n` +
+        `Saved: ${result.savedPath}\n` +
+        `Error: ${webhook.error}\n` +
+        `URL: ${webhook.url ?? 'N/A'}`,
+      type: 'warning',
+      buttonText: 'Partial',
+      buttonColor: '#f59e0b',
+    }
+  }
+
   async updateScheduleFromForm(): Promise<void> {
     const schedule = this.#scheduleManager.activeSchedule
     if (!schedule) return

trmnl-ha/ha-trmnl/lib/http-router.ts

@@ -23,7 +23,11 @@ import {
 } from './scheduleStore.js'
 import { loadPresets } from '../devices.js'
 import type { BrowserFacade } from './browserFacade.js'
-import type { ScheduleInput, ScheduleUpdate } from '../types/domain.js'
+import type {
+  ScheduleInput,
+  ScheduleUpdate,
+  WebhookResult,
+} from '../types/domain.js'
 import { toJson } from './json.js'
 import { httpLogger } from './logger.js'
 
@@ -50,7 +54,7 @@ const MIME_TYPES: Record<string, string> = {
 interface Scheduler {
   executeNow(
     scheduleId: string
-  ): Promise<{ success: boolean; savedPath: string }>
+  ): Promise<{ success: boolean; savedPath: string; webhook?: WebhookResult }>
 }
 
 /**

trmnl-ha/ha-trmnl/lib/scheduler/schedule-executor.ts

@@ -20,7 +20,11 @@ import {
   isSchedulerNetworkError,
 } from '../../const.js'
 import { loadSchedules } from '../scheduleStore.js'
-import type { Schedule, ScreenshotParams } from '../../types/domain.js'
+import type {
+  Schedule,
+  ScreenshotParams,
+  WebhookResult,
+} from '../../types/domain.js'
 import { schedulerLogger } from '../logger.js'
 
 const log = schedulerLogger()
@@ -32,6 +36,7 @@ export type ScreenshotFunction = (params: ScreenshotParams) => Promise<Buffer>
 export interface ExecutionResult {
   success: boolean
   savedPath: string
+  webhook?: WebhookResult
 }
 
 /**
@@ -53,10 +58,23 @@ export class ScheduleExecutor {
 
     const result = await this.#executeWithRetry(schedule)
 
-    log.info`Completed: ${schedule.name} in ${Date.now() - startTime}ms`
+    this.#logResult(schedule.name, result, Date.now() - startTime)
     return result
   }
 
+  /** Logs execution result with full details */
+  #logResult(name: string, result: ExecutionResult, durationMs: number): void {
+    const webhookStatus = this.#formatWebhookStatus(result.webhook)
+    log.info`Completed: ${name} in ${durationMs}ms | saved: ${result.savedPath} | webhook: ${webhookStatus}`
+  }
+
+  /** Formats webhook status for logging */
+  #formatWebhookStatus(webhook: WebhookResult | undefined): string {
+    if (!webhook) return 'not configured'
+    if (webhook.success) return `${webhook.statusCode} OK → ${webhook.url}`
+    return `FAILED (${webhook.error}) → ${webhook.url}`
+  }
+
   /** Retry wrapper for network failures */
   async #executeWithRetry(schedule: Schedule): Promise<ExecutionResult> {
     for (let attempt = 1; attempt <= SCHEDULER_MAX_RETRIES; attempt++) {
@@ -75,13 +93,25 @@ export class ScheduleExecutor {
   async #executeOnce(schedule: Schedule): Promise<ExecutionResult> {
     const params = buildParams(schedule)
     const imageBuffer = await this.#screenshotFn(params)
-    const savedPath = await this.#saveAndCleanup(schedule, imageBuffer, params.format)
-    await this.#uploadIfConfigured(schedule, imageBuffer, params.format)
-    return { success: true, savedPath }
+    const savedPath = await this.#saveAndCleanup(
+      schedule,
+      imageBuffer,
+      params.format
+    )
+    const webhook = await this.#uploadIfConfigured(
+      schedule,
+      imageBuffer,
+      params.format
+    )
+    return { success: true, savedPath, webhook }
   }
 
   /** Saves screenshot and runs LRU cleanup */
-  async #saveAndCleanup(schedule: Schedule, imageBuffer: Buffer, format: string): Promise<string> {
+  async #saveAndCleanup(
+    schedule: Schedule,
+    imageBuffer: Buffer,
+    format: string
+  ): Promise<string> {
     const { outputPath } = saveScreenshot({
       outputDir: this.#outputDir,
       scheduleName: schedule.name,
@@ -91,31 +121,62 @@ export class ScheduleExecutor {
     log.info`Saved: ${outputPath}`
 
     const schedules = await loadSchedules()
-    const maxFiles = schedules.filter((s) => s.enabled).length * SCHEDULER_RETENTION_MULTIPLIER
+    const maxFiles =
+      schedules.filter((s) => s.enabled).length * SCHEDULER_RETENTION_MULTIPLIER
     const { deletedCount } = cleanupOldScreenshots({
       outputDir: this.#outputDir,
       maxFiles,
       filePattern: SCHEDULER_IMAGE_FILE_PATTERN,
     })
 
-    if (deletedCount > 0) log.debug`Cleanup: Deleted ${deletedCount} old file(s)`
+    if (deletedCount > 0)
+      log.debug`Cleanup: Deleted ${deletedCount} old file(s)`
     return outputPath
   }
 
-  /** Uploads to webhook if configured */
-  async #uploadIfConfigured(schedule: Schedule, imageBuffer: Buffer, format: string): Promise<void> {
-    if (!schedule.webhook_url) return
+  /** Uploads to webhook if configured, returns result for UI feedback */
+  async #uploadIfConfigured(
+    schedule: Schedule,
+    imageBuffer: Buffer,
+    format: string
+  ): Promise<WebhookResult | undefined> {
+    if (!schedule.webhook_url) return undefined
+
+    const webhookUrl = schedule.webhook_url
 
     try {
-      await uploadToWebhook({
-        webhookUrl: schedule.webhook_url,
+      const result = await uploadToWebhook({
+        webhookUrl,
         webhookHeaders: schedule.webhook_headers,
         imageBuffer,
         format: format as 'png' | 'jpeg' | 'bmp',
       })
+
+      log.info`Schedule "${schedule.name}" webhook success: ${result.status} ${result.statusText}`
+
+      return {
+        attempted: true,
+        success: true,
+        statusCode: result.status,
+        url: webhookUrl,
+      }
     } catch (err) {
-      // Error already logged by uploadToWebhook, just re-log for schedule context
-      log.error`Schedule "${schedule.name}" webhook failed: ${(err as Error).message}`
+      const errorMessage = (err as Error).message
+      log.error`Schedule "${schedule.name}" webhook failed: ${errorMessage}`
+
+      // Extract status code from error message if present (e.g., "HTTP 404: Not Found")
+      const statusMatch = errorMessage.match(/HTTP (\d+):/)
+      const statusCode = statusMatch?.[1]
+        ? parseInt(statusMatch[1], 10)
+        : undefined
+
+      return {
+        attempted: true,
+        success: false,
+        statusCode,
+        error: errorMessage,
+        url: webhookUrl,
+      }
     }
   }
 

trmnl-ha/ha-trmnl/types/domain.ts

@@ -207,14 +207,30 @@ export type ScheduleInput = Omit<Schedule, 'id' | 'createdAt' | 'updatedAt'>
 /** Schedule data for updates (all fields optional except id) */
 export type ScheduleUpdate = Partial<Omit<Schedule, 'id'>>
 
+/** Webhook execution result details */
+export interface WebhookResult {
+  /** Whether webhook was attempted */
+  attempted: boolean
+  /** Whether webhook succeeded */
+  success: boolean
+  /** HTTP status code from webhook (if attempted) */
+  statusCode?: number
+  /** Error message (if failed) */
+  error?: string
+  /** Webhook URL that was called */
+  url?: string
+}
+
 /** Response from triggering immediate schedule execution */
 export interface SendScheduleResponse {
-  /** Whether the execution was successful */
+  /** Whether the overall execution was successful (screenshot captured) */
   success: boolean
   /** Path where screenshot was saved (if successful) */
   savedPath?: string
-  /** Error message (if failed) */
+  /** Error message (if screenshot capture failed) */
   error?: string
+  /** Webhook execution details (if webhook was configured) */
+  webhook?: WebhookResult
 }
 
 // =============================================================================