commandmate 0.16.0 → 0.18.0

package/dist/server/src/lib/tasks/task-state-machine.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * TaskStatus state machine (Issue #1548, Phase 3-1).
+ *
+ * Pure and side-effect free: given a status and an event, it answers what the
+ * status becomes, or `null` when the event does not apply. Phase 2-1 let each
+ * firing point decide the next status for itself, which meant the rules lived in
+ * six places and agreed with each other only by coincidence. They live here now,
+ * and `applyTaskEvent` is the only thing allowed to act on the answer.
+ *
+ * This is a different layer from `SessionStatus`. SessionStatus is derived from
+ * screen-scraped terminal output — low level, volatile, recomputed every poll.
+ * TaskStatus is durable and only moves because something *happened*. A
+ * SessionStatus reading is at most one of the events that can cause a move; it
+ * never writes TaskStatus itself.
+ *
+ * Rejection is not an error. A prompt detected while a verification run is in
+ * flight is an ordinary race, not a bug, so `transitionTask` returns `null` and
+ * the caller records the attempt and moves on. Throwing would turn a race into
+ * a crashed poller.
+ *
+ * @module lib/tasks/task-state-machine
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_EVENTS = void 0;
+exports.transitionTask = transitionTask;
+exports.TASK_EVENTS = [
+    'message_sent',
+    'send_failed',
+    'prompt_detected',
+    'prompt_answered_auto',
+    'prompt_answered_human',
+    'agent_idle',
+    'verify_started',
+    'verify_passed',
+    'verify_failed',
+    'verify_not_started',
+    'cancel',
+];
+/**
+ * The status `current` becomes when `event` happens, or `null` if it does not
+ * apply.
+ *
+ * Both switches are exhaustive by `satisfies never`, so adding a TaskStatus or a
+ * TaskEvent fails the build here instead of silently defaulting to "rejected" —
+ * a new event that quietly transitions nothing is indistinguishable from one
+ * that is wired up wrong.
+ */
+function transitionTask(current, event) {
+    switch (current) {
+        case 'pending':
+            // Nothing has been sent yet, so nothing about the agent's behaviour can
+            // be true of this task.
+            switch (event) {
+                case 'message_sent':
+                    return 'running';
+                case 'send_failed':
+                    return 'failed';
+                case 'cancel':
+                    return 'cancelled';
+                case 'prompt_detected':
+                case 'prompt_answered_auto':
+                case 'prompt_answered_human':
+                case 'agent_idle':
+                case 'verify_started':
+                case 'verify_passed':
+                case 'verify_failed':
+                case 'verify_not_started':
+                    return null;
+                default:
+                    return assertNever(event);
+            }
+        case 'running':
+            switch (event) {
+                case 'prompt_detected':
+                    return 'waiting_input';
+                // The agent going quiet without a verification run is not a verdict.
+                // The status is held and only the event is recorded, so "it stopped
+                // producing output" stays visible without being mistaken for "done".
+                case 'agent_idle':
+                    return 'running';
+                case 'verify_started':
+                    return 'verifying';
+                case 'send_failed':
+                    return 'failed';
+                case 'cancel':
+                    return 'cancelled';
+                case 'message_sent':
+                case 'prompt_answered_auto':
+                case 'prompt_answered_human':
+                case 'verify_passed':
+                case 'verify_failed':
+                case 'verify_not_started':
+                    return null;
+                default:
+                    return assertNever(event);
+            }
+        case 'waiting_input':
+            switch (event) {
+                case 'prompt_answered_auto':
+                case 'prompt_answered_human':
+                    return 'running';
+                case 'agent_idle':
+                    return 'running';
+                case 'verify_started':
+                    return 'verifying';
+                case 'cancel':
+                    return 'cancelled';
+                case 'message_sent':
+                case 'send_failed':
+                case 'prompt_detected':
+                case 'verify_passed':
+                case 'verify_failed':
+                case 'verify_not_started':
+                    return null;
+                default:
+                    return assertNever(event);
+            }
+        case 'verifying':
+            // A run is in flight. Only that run's verdict — or an explicit cancel —
+            // moves the task, so a prompt or a send racing the gates cannot overwrite
+            // the outcome the gates are about to produce.
+            switch (event) {
+                case 'verify_passed':
+                    return 'succeeded';
+                case 'verify_failed':
+                    return 'failed';
+                case 'verify_not_started':
+                    return 'not_started';
+                case 'cancel':
+                    return 'cancelled';
+                case 'message_sent':
+                case 'send_failed':
+                case 'prompt_detected':
+                case 'prompt_answered_auto':
+                case 'prompt_answered_human':
+                case 'agent_idle':
+                case 'verify_started':
+                    return null;
+                default:
+                    return assertNever(event);
+            }
+        case 'failed':
+        case 'not_started':
+            // Not the end of the story. Re-instructing an agent whose work did not
+            // pass reopens the same task, and the number of times that happens is the
+            // fix-loop count Phase 4 Eval reports. Re-running the gates alone reopens
+            // it too — a task can fail on a flaky gate and pass on the retry.
+            switch (event) {
+                case 'message_sent':
+                    return 'running';
+                case 'verify_started':
+                    return 'verifying';
+                case 'cancel':
+                    return 'cancelled';
+                case 'send_failed':
+                case 'prompt_detected':
+                case 'prompt_answered_auto':
+                case 'prompt_answered_human':
+                case 'agent_idle':
+                case 'verify_passed':
+                case 'verify_failed':
+                case 'verify_not_started':
+                    return null;
+                default:
+                    return assertNever(event);
+            }
+        case 'succeeded':
+        case 'cancelled':
+            // Closed for good. `succeeded` in particular is a verdict a verification
+            // run produced; letting any later event walk it back would make "this
+            // task passed" a claim with no fixed meaning.
+            return null;
+        default:
+            return assertNever(current);
+    }
+}
+/** Compile-time exhaustiveness guard; unreachable at runtime. */
+function assertNever(value) {
+    const _exhaustive = value;
+    void _exhaustive;
+    return null;
+}

package/dist/server/src/lib/tasks/task-transition-service.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * The only writer of `tasks.status` (Issue #1548, Phase 3-1).
+ *
+ * `applyTaskEvent` reads the current status, asks the state machine what the
+ * event means, and — in one transaction — writes the new status and appends the
+ * event. Phase 2-1 had each firing point call `updateTaskStatus` with a status
+ * it chose itself; `updateTaskStatus` is no longer reachable from the
+ * `@/lib/db` barrel so that this is the only door.
+ *
+ * A rejected transition still writes a `task_events` row (`to_status = NULL`).
+ * The event happened; the machine declined to act on it. That distinction is
+ * what tells a wiring bug apart from a race, and it is invisible if rejected
+ * events are dropped.
+ *
+ * The UPDATE and the INSERT are one transaction because a status with no event
+ * behind it, or an event whose status never landed, would each make the log
+ * lie about the table it exists to explain. better-sqlite3 is synchronous, so a
+ * transaction here also serialises concurrent callers with no further work.
+ *
+ * @module lib/tasks/task-transition-service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTaskEvent = applyTaskEvent;
+exports.applyEventToActiveTask = applyEventToActiveTask;
+const tasks_db_1 = require("../../lib/db/tasks-db");
+const task_events_db_1 = require("../../lib/db/task-events-db");
+const logger_1 = require("../../lib/logger");
+const task_state_machine_1 = require("./task-state-machine");
+const logger = (0, logger_1.createLogger)('lib/tasks/task-transition-service');
+/**
+ * Apply `event` to a task.
+ *
+ * @param payload - Structured detail for the log. `runId` is also written to
+ *   `tasks.last_verification_run_id` on an accepted transition, so the task's
+ *   pointer to the run that last judged it and the event naming that run cannot
+ *   disagree.
+ * @returns null when the task does not exist — a deleted worktree takes its
+ *   tasks with it, and a poller still holding the id must not crash for it
+ */
+function applyTaskEvent(db, taskId, event, payload) {
+    const apply = db.transaction(() => {
+        const task = (0, tasks_db_1.getTask)(db, taskId);
+        if (!task) {
+            return null;
+        }
+        const fromStatus = task.status;
+        const toStatus = (0, task_state_machine_1.transitionTask)(fromStatus, event);
+        const now = Date.now();
+        const eventId = (0, task_events_db_1.insertTaskEvent)(db, {
+            taskId,
+            event,
+            fromStatus,
+            toStatus,
+            payload,
+            createdAt: now,
+        });
+        if (toStatus === null) {
+            return { task, fromStatus, toStatus: null, eventId };
+        }
+        const updated = (0, tasks_db_1.updateTaskStatus)(db, taskId, toStatus, payload?.runId === undefined ? {} : { lastVerificationRunId: payload.runId });
+        return { task: updated, fromStatus, toStatus, eventId };
+    });
+    const result = apply();
+    if (result === null) {
+        logger.warn('task-event-unknown-task', { taskId, event });
+    }
+    else if (result.toStatus === null) {
+        logger.warn('task-event-rejected', { taskId, event, fromStatus: result.fromStatus });
+    }
+    return result;
+}
+/**
+ * Raise `event` on whichever task is currently governing one agent instance.
+ *
+ * The no-op is the important case. Prompts, auto-answers and human replies
+ * happen constantly in sessions that were never sent a contract, and every
+ * firing point calls this unconditionally — so "no active task" has to mean
+ * "nothing happens", not "nothing to do, but raise something anyway". Anything
+ * else would make Phase 3-1 a behaviour change for contract-less use.
+ *
+ * Never throws: these callers are pollers and API routes whose real job is the
+ * message itself, and a task-log failure must not take that down with it.
+ *
+ * @param instanceId - Agent instance id; the tool id itself for the primary
+ * @returns The result, or null when no active task governs this instance
+ */
+function applyEventToActiveTask(db, worktreeId, cliToolId, instanceId, event, payload) {
+    try {
+        const task = (0, tasks_db_1.getActiveTaskForInstance)(db, worktreeId, cliToolId, instanceId);
+        if (!task) {
+            return null;
+        }
+        return applyTaskEvent(db, task.id, event, payload);
+    }
+    catch (error) {
+        logger.warn('task-event-failed', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            event,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}

package/dist/server/src/lib/verification/verification-reconciler.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Startup recovery for verification runs orphaned by a restart (Issue #1543).
+ *
+ * `verification_runs` is opened in `running` state and closed when the gates
+ * finish, so a run in flight when the process dies leaves a `running` row that
+ * nothing will ever close. Those rows are not merely stale: the per-worktree
+ * conflict check treats an open run as "verification in progress", so a single
+ * crash would lock that worktree out of verification permanently.
+ *
+ * Every run this finds is an orphan by construction — gate execution lives in
+ * process memory, so after a restart none of them is actually running. They are
+ * closed as `error` rather than `failed`: no gate reached a verdict about the
+ * work, which is exactly the distinction `error` encodes.
+ *
+ * Follows the shape of {@link reconcileAllAssistantExecutions}
+ * (`src/lib/assistant/non-interactive-execution-reconciler.ts`).
+ *
+ * @module lib/verification/verification-reconciler
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileOrphanVerificationRuns = reconcileOrphanVerificationRuns;
+const db_1 = require("../../lib/db");
+const RECONCILE_NOTE = '[reconciled after server restart: the runner process is gone]';
+/**
+ * Close every `running` verification run and its open gate results.
+ *
+ * @returns counts of what was closed, so startup can log a non-zero recovery
+ */
+function reconcileOrphanVerificationRuns(db) {
+    const report = { runs: 0, gates: 0 };
+    for (const run of (0, db_1.listRunningVerificationRuns)(db)) {
+        const detail = (0, db_1.getVerificationRun)(db, run.id);
+        for (const gate of detail?.gates ?? []) {
+            if (gate.status !== 'running')
+                continue;
+            (0, db_1.finishGateResult)(db, gate.id, {
+                status: 'error',
+                exitCode: null,
+                durationMs: null,
+                logTail: [gate.logTail, RECONCILE_NOTE].filter(Boolean).join('\n'),
+            });
+            report.gates += 1;
+        }
+        (0, db_1.finishVerificationRun)(db, run.id, 'error');
+        report.runs += 1;
+    }
+    return report;
+}

package/dist/server/src/types/sidebar.js

@@ -5,28 +5,15 @@
  * Types for sidebar components and branch status display
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deriveCliStatus = deriveCliStatus;
+exports.deriveCliStatus = void 0;
 exports.aggregateCliStatus = aggregateCliStatus;
 exports.formatCliStatusBreakdown = formatCliStatusBreakdown;
 exports.calculateHasUnread = calculateHasUnread;
 exports.toBranchItem = toBranchItem;
 const types_1 = require("../lib/cli-tools/types");
 const selected_agents_validator_1 = require("../lib/selected-agents-validator");
-/**
- * Derive BranchStatus from per-CLI tool session status flags.
- * Shared by sidebar (toBranchItem) and WorktreeDetailRefactored tab dots.
- */
-function deriveCliStatus(toolStatus) {
-    if (!toolStatus)
-        return 'idle';
-    if (toolStatus.isWaitingForResponse)
-        return 'waiting';
-    if (toolStatus.isProcessing)
-        return 'running';
-    if (toolStatus.isRunning)
-        return 'ready';
-    return 'idle';
-}
+const status_mapping_1 = require("../lib/session/status-mapping");
+Object.defineProperty(exports, "deriveCliStatus", { enumerable: true, get: function () { return status_mapping_1.deriveCliStatus; } });
 /**
  * Aggregate per-agent CLI statuses into a single representative BranchStatus
  * for the sidebar's single status indicator (Issue #867).
@@ -140,7 +127,7 @@ function deriveSidebarCliStatus(worktree) {
     if (!byInstance) {
         const agents = worktree.selectedAgents ?? selected_agents_validator_1.DEFAULT_SELECTED_AGENTS;
         for (const agent of agents) {
-            cliStatus[agent] = deriveCliStatus(worktree.sessionStatusByCli?.[agent]);
+            cliStatus[agent] = (0, status_mapping_1.deriveCliStatus)(worktree.sessionStatusByCli?.[agent]);
             cliStatusLabels[agent] = (0, types_1.getCliToolDisplayName)(agent);
         }
         return { cliStatus, cliStatusLabels };
@@ -152,7 +139,7 @@ function deriveSidebarCliStatus(worktree) {
     const rosterIds = new Set();
     for (const instance of roster) {
         rosterIds.add(instance.id);
-        cliStatus[instance.id] = deriveCliStatus(byInstance[instance.id]);
+        cliStatus[instance.id] = (0, status_mapping_1.deriveCliStatus)(byInstance[instance.id]);
         cliStatusLabels[instance.id] = (0, types_1.getInstanceLabel)(instance);
     }
     // Surface any RUNNING instance missing from the roster (e.g. a `claude`
@@ -161,7 +148,7 @@ function deriveSidebarCliStatus(worktree) {
     for (const [instanceId, status] of Object.entries(byInstance)) {
         if (rosterIds.has(instanceId))
             continue;
-        const derived = deriveCliStatus(status);
+        const derived = (0, status_mapping_1.deriveCliStatus)(status);
         if (derived === 'idle')
             continue;
         cliStatus[instanceId] = derived;
@@ -177,7 +164,7 @@ function deriveSidebarCliStatus(worktree) {
  */
 function toBranchItem(worktree) {
     // Issue #608: Derive top-level status from worktree session flags
-    const status = deriveCliStatus(worktree.isSessionRunning !== undefined
+    const status = (0, status_mapping_1.deriveCliStatus)(worktree.isSessionRunning !== undefined
         ? {
             isRunning: worktree.isSessionRunning ?? false,
             isWaitingForResponse: worktree.isWaitingForResponse ?? false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "A local control plane for agent CLIs — orchestration and visibility for Claude Code, Codex, Gemini CLI, and more across Git worktrees",
   "keywords": [
     "claude-code",
@@ -32,6 +32,7 @@
     ".next/",
     "!.next/cache",
     "public/",
+    "scripts/hooks/",
     ".env.example"
   ],
   "scripts": {
@@ -43,6 +44,7 @@
     "prepublishOnly": "npm run build:all",
     "start": "NODE_ENV=production node dist/server/server.js",
     "lint": "eslint src --ext .js,.jsx,.ts,.tsx",
+    "check:tracking": "./scripts/check-commandmate-tracking.sh",
     "test": "NODE_ENV=test vitest",
     "test:ui": "NODE_ENV=test vitest --ui",
     "test:coverage": "NODE_ENV=test vitest --coverage",
@@ -104,7 +106,8 @@
     "ws": "^8.18.3",
     "xterm": "^5.3.0",
     "xterm-addon-fit": "^0.8.0",
-    "xterm-addon-web-links": "^0.9.0"
+    "xterm-addon-web-links": "^0.9.0",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.56.1",

package/scripts/hooks/cmate-agent-event.sh

@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+#
+# cmate-agent-event.sh — post a structured agent lifecycle event to CommandMate.
+#
+# Wired into an agent CLI's own completion hook (Claude Code `Stop`, Codex
+# `notify`) so the server learns that a turn ended from the agent itself rather
+# than by reading the terminal. See docs/user-guide/agent-event-hooks.md.
+#
+# Written for bash 3.2 — the version macOS still ships — so no associative
+# arrays, `mapfile`, or `${var^^}`.
+#
+# Exits 0 even when the POST fails: a hook that breaks the agent's session
+# because the CommandMate server happens to be down is worse than a missed
+# event. Pass --strict to propagate the failure instead.
+
+set -u
+
+PROGRAM_NAME="cmate-agent-event.sh"
+
+usage() {
+  cat <<'USAGE'
+Usage: cmate-agent-event.sh [options] [JSON]
+
+Options:
+  --tool ID          Agent CLI id (default: $CM_AGENT_TOOL, else "claude")
+  --event EVENT      stop | notification | session_start (default: "stop")
+  --cwd PATH         Agent working directory (default: $CLAUDE_PROJECT_DIR, else $PWD)
+  --session-id ID    Opaque agent session id
+  --json JSON        Hook payload to read cwd/session/event from
+  --stdin-json       Read that payload from stdin instead
+  --url URL          Endpoint (default: http://$CM_HOST:$CM_PORT/api/hooks/agent-event)
+  --strict           Exit non-zero when the POST fails
+  -h, --help         Show this help
+
+Environment:
+  CM_HOST            Server host (default: 127.0.0.1)
+  CM_PORT            Server port (default: 3000)
+  CM_HOOK_URL        Full endpoint URL; overrides CM_HOST/CM_PORT
+  CM_AUTH_TOKEN      Sent as "Authorization: Bearer <token>" when set
+USAGE
+}
+
+die() {
+  printf '%s: %s\n' "$PROGRAM_NAME" "$1" >&2
+  exit 2
+}
+
+# Extract a flat JSON string field. Good enough for the small, machine-generated
+# payloads agent CLIs pass; anything richer belongs in the --cwd flag.
+json_string_field() {
+  printf '%s' "$1" | tr -d '\n' |
+    sed -n 's/.*"'"$2"'"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p'
+}
+
+# Escape a value for embedding in a JSON string literal.
+json_escape() {
+  printf '%s' "$1" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g'
+}
+
+# Map an agent's own event name onto the API vocabulary.
+map_event_name() {
+  case "$1" in
+    Stop|SubagentStop|agent-turn-complete) printf 'stop' ;;
+    Notification) printf 'notification' ;;
+    SessionStart) printf 'session_start' ;;
+    *) printf '' ;;
+  esac
+}
+
+TOOL="${CM_AGENT_TOOL:-claude}"
+EVENT=""
+CWD=""
+SESSION_ID=""
+HOOK_JSON=""
+READ_STDIN=0
+URL="${CM_HOOK_URL:-}"
+STRICT=0
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --tool) [ $# -ge 2 ] || die "--tool requires a value"; TOOL="$2"; shift 2 ;;
+    --event) [ $# -ge 2 ] || die "--event requires a value"; EVENT="$2"; shift 2 ;;
+    --cwd) [ $# -ge 2 ] || die "--cwd requires a value"; CWD="$2"; shift 2 ;;
+    --session-id) [ $# -ge 2 ] || die "--session-id requires a value"; SESSION_ID="$2"; shift 2 ;;
+    --json) [ $# -ge 2 ] || die "--json requires a value"; HOOK_JSON="$2"; shift 2 ;;
+    --url) [ $# -ge 2 ] || die "--url requires a value"; URL="$2"; shift 2 ;;
+    --stdin-json) READ_STDIN=1; shift ;;
+    --strict) STRICT=1; shift ;;
+    -h|--help) usage; exit 0 ;;
+    --) shift; break ;;
+    -*) die "unknown option: $1" ;;
+    # Codex passes its notify payload as a bare positional argument.
+    *) HOOK_JSON="$1"; shift ;;
+  esac
+done
+
+if [ "$READ_STDIN" -eq 1 ]; then
+  HOOK_JSON="$(cat)"
+fi
+
+if [ -n "$HOOK_JSON" ]; then
+  if [ -z "$EVENT" ]; then
+    JSON_EVENT="$(json_string_field "$HOOK_JSON" 'hook_event_name')"
+    if [ -z "$JSON_EVENT" ]; then
+      JSON_EVENT="$(json_string_field "$HOOK_JSON" 'type')"
+    fi
+    if [ -n "$JSON_EVENT" ]; then
+      EVENT="$(map_event_name "$JSON_EVENT")"
+      [ -n "$EVENT" ] || die "unrecognized hook event name: $JSON_EVENT"
+    fi
+  fi
+  if [ -z "$SESSION_ID" ]; then
+    SESSION_ID="$(json_string_field "$HOOK_JSON" 'session_id')"
+  fi
+  if [ -z "$SESSION_ID" ]; then
+    SESSION_ID="$(json_string_field "$HOOK_JSON" 'turn-id')"
+  fi
+fi
+
+[ -n "$EVENT" ] || EVENT="stop"
+
+case "$EVENT" in
+  stop|notification|session_start) ;;
+  *) die "--event must be one of: stop, notification, session_start (got \"$EVENT\")" ;;
+esac
+
+[ -n "$TOOL" ] || die "--tool must not be empty"
+
+if [ -z "$CWD" ]; then
+  CWD="${CM_AGENT_CWD:-}"
+fi
+if [ -z "$CWD" ]; then
+  CWD="${CLAUDE_PROJECT_DIR:-}"
+fi
+if [ -z "$CWD" ] && [ -n "$HOOK_JSON" ]; then
+  CWD="$(json_string_field "$HOOK_JSON" 'cwd')"
+fi
+if [ -z "$CWD" ]; then
+  CWD="$PWD"
+fi
+
+case "$CWD" in
+  /*) ;;
+  *) die "--cwd must be an absolute path (got \"$CWD\")" ;;
+esac
+
+if [ -z "$URL" ]; then
+  URL="http://${CM_HOST:-127.0.0.1}:${CM_PORT:-3000}/api/hooks/agent-event"
+fi
+
+BODY="{\"tool\":\"$(json_escape "$TOOL")\""
+BODY="$BODY,\"event\":\"$(json_escape "$EVENT")\""
+BODY="$BODY,\"cwd\":\"$(json_escape "$CWD")\""
+if [ -n "$SESSION_ID" ]; then
+  BODY="$BODY,\"sessionId\":\"$(json_escape "$SESSION_ID")\""
+fi
+BODY="$BODY}"
+
+# Token via --header rather than the command line of a subprocess: argv is world
+# readable in `ps` on most systems.
+set -- -fsS -X POST -H 'Content-Type: application/json' --max-time "${CM_HOOK_TIMEOUT:-5}"
+if [ -n "${CM_AUTH_TOKEN:-}" ]; then
+  set -- "$@" -H "Authorization: Bearer ${CM_AUTH_TOKEN}"
+fi
+set -- "$@" --data-binary "$BODY" "$URL"
+
+if curl "$@" >/dev/null; then
+  exit 0
+fi
+
+printf '%s: failed to POST %s to %s\n' "$PROGRAM_NAME" "$EVENT" "$URL" >&2
+if [ "$STRICT" -eq 1 ]; then
+  exit 1
+fi
+exit 0