patchwork-os 0.2.0-beta.1 → 0.2.0-beta.10.canary.95

package/dist/bridge.js

@@ -16,7 +16,7 @@ import { CommitIssueLinkLog } from "./commitIssueLinkLog.js";
 import { DecisionTraceLog } from "./decisionTraceLog.js";
 import { createDriver } from "./drivers/index.js";
 import { ExtensionClient } from "./extensionClient.js";
-import { lockKillSwitchEnv } from "./featureFlags.js";
+import { lockKillSwitchEnv, watchFlags } from "./featureFlags.js";
 import { FileLock } from "./fileLock.js";
 import { buildEnforcementReminder } from "./instructionsUtils.js";
 import { LockFileManager } from "./lockfile.js";
@@ -28,6 +28,8 @@ import { PluginWatcher } from "./pluginWatcher.js";
 import { isPreToolUseHookRegistered } from "./preToolUseHook.js";
 import { probeAll } from "./probe.js";
 import { RecipeOrchestration } from "./recipeOrchestration.js";
+import { haltSummaryToPrometheus, summariseHalts, } from "./recipes/haltCategory.js";
+import { judgeSummaryToPrometheus, summariseJudgments, } from "./recipes/judgeSummary.js";
 import { warnAboutLegacyPermissionsSidecars } from "./recipes/migrationWarnings.js";
 import { RecipeOrchestrator } from "./recipes/RecipeOrchestrator.js";
 import { classifyTool } from "./riskTier.js";
@@ -45,6 +47,7 @@ import { buildRecentTracesDigest } from "./tools/recentTracesDigest.js";
 import { resolveFilePath } from "./tools/utils.js";
 import { McpTransport } from "./transport.js";
 import { PACKAGE_VERSION } from "./version.js";
+import { wireHaltPushDispatch } from "./wireHaltPushDispatch.js";
 const SHUTDOWN_TIMEOUT_MS = 5000;
 let globalHandlersRegistered = false;
 /** Collect the union of openedFiles across all sessions in a checkpoint. */
@@ -143,8 +146,9 @@ export class Bridge {
         this.lockFile = new LockFileManager(this.logger);
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
         this.authToken = config.fixedToken ?? loadOrCreateBridgeToken(configDir);
-        this.server = new Server(this.authToken, this.logger, config.corsOrigins);
+        this.server = new Server(this.authToken, this.logger, config.corsOrigins, undefined, config.trustedProxies);
         this.server.bridgeConfigPath = config.configFilePath ?? undefined;
+        this.server.webhookSecret = config.webhookSecret ?? null;
         if (config.issuerUrl) {
             this.oauthServer = new OAuthServerImpl(this.authToken, config.issuerUrl, {
                 configDir,
@@ -245,7 +249,11 @@ export class Bridge {
             }
             // ─────────────────────────────────────────────────────────────────────
             // Reject connections beyond capacity (grace-period sessions don't count)
-            const activeSessionCount = [...this.sessions.values()].filter((s) => !s.graceTimer).length;
+            let activeSessionCount = 0;
+            for (const s of this.sessions.values()) {
+                if (!s.graceTimer)
+                    activeSessionCount++;
+            }
             if (activeSessionCount >= this.config.maxSessions) {
                 this.logger.warn(`Session capacity reached (${this.config.maxSessions} active). Rejecting connection.`);
                 ws.close(1013, "Bridge at capacity");
@@ -493,10 +501,15 @@ export class Bridge {
             // Detect false→true transition (session started)
             if (!this._lastDebugSessionActive && state.hasActiveSession) {
                 const breakpoints = state.breakpoints ?? [];
+                let enabledBreakpoints = 0;
+                for (const b of breakpoints) {
+                    if (b.enabled)
+                        enabledBreakpoints++;
+                }
                 this.automationHooks?.handleDebugSessionStart({
                     sessionName: state.sessionName ?? "unknown",
                     sessionType: state.sessionType ?? "unknown",
-                    breakpointCount: breakpoints.filter((b) => b.enabled).length,
+                    breakpointCount: enabledBreakpoints,
                     activeFile: breakpoints[0]?.file ?? "",
                 });
             }
@@ -534,8 +547,14 @@ export class Bridge {
             let warnings = 0;
             const errorFiles = [];
             for (const [file, diags] of this.extensionClient.latestDiagnostics) {
-                const e = diags.filter((d) => d.severity === "error").length;
-                const w = diags.filter((d) => d.severity === "warning").length;
+                let e = 0;
+                let w = 0;
+                for (const d of diags) {
+                    if (d.severity === "error")
+                        e++;
+                    else if (d.severity === "warning")
+                        w++;
+                }
                 errors += e;
                 warnings += w;
                 if (e > 0)
@@ -580,6 +599,8 @@ export class Bridge {
     }
     /** Write a periodic auto-snapshot while sessions are active (every 5 minutes). */
     _periodicSnapshotTimer = null;
+    /** Cleanup handle for `watchFlags()` — set in start(), invoked in stop(). */
+    _stopFlagsWatch = null;
     _startPeriodicSnapshots() {
         if (this._periodicSnapshotTimer)
             return;
@@ -721,6 +742,10 @@ export class Bridge {
         // recipe steps mutating `process.env.PATCHWORK_FLAG_*` cannot disable an
         // active emergency stop. Closes MED-2 from the 2026-04-28 audit.
         lockKillSwitchEnv();
+        // 0a-bis. Watch flags.json for cross-process changes — picks up CLI
+        // fallback writes and sibling-bridge updates in a multi-bridge fleet.
+        // v2-S1 + v2-B2 from issue #422.
+        this._stopFlagsWatch = watchFlags();
         // 0b. Auto-repair .claude/rules/bridge-tools.md if stale (present but missing the
         // current version sentinel). Older package versions write stale files that may
         // lack new tool substitution rules. Repair is silent on success; falls back to
@@ -849,17 +874,35 @@ export class Bridge {
                 });
                 // scheduler.start() deferred to after this.port is set (see below)
                 // so bridgeMcp callback has a valid port when first cron fires.
+                //
+                // Hot-reload: re-prime the scheduler whenever the recipe set
+                // changes on disk (install / save / delete). RecipeScheduler.start()
+                // is idempotent (calls this.stop() first) and reads the recipes
+                // directory fresh, so calling it again cleanly picks up the new
+                // file. Stored as a callback on the Server so route handlers can
+                // fire it post-success without owning a reference to the scheduler.
+                this.server.onRecipesChangedFn = () => {
+                    if (!this.recipeScheduler)
+                        return;
+                    try {
+                        const scheduled = this.recipeScheduler.start();
+                        this.logger.info(`[patchwork] scheduler re-primed after recipe change · ${scheduled.length} cron recipe${scheduled.length === 1 ? "" : "s"} active`);
+                    }
+                    catch (err) {
+                        this.logger.warn?.(`[patchwork] scheduler restart failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                };
             }
         }
         if (this.config.automationEnabled) {
             if (!this.orchestrator) {
-                throw new Error("--automation requires --claude-driver != none");
+                throw new Error("--automation requires --driver != none");
             }
             if (!this.config.automationPolicyPath) {
                 throw new Error("--automation requires --automation-policy <path>");
             }
             const policy = loadPolicy(this.config.automationPolicyPath);
-            this.automationHooks = new AutomationHooks(policy, this.orchestrator, (msg) => this.logger.info(msg), this.extensionClient, this.config.workspace);
+            this.automationHooks = new AutomationHooks(policy, this.orchestrator, (msg) => this.logger.info(msg), this.extensionClient, this.config.workspace, this.config.automationAllowPrivateWebhooks);
             this.logger.info(`[bridge] Automation enabled (policy: ${this.config.automationPolicyPath})`);
         }
         // 3. Wire up /health endpoint data and /metrics
@@ -885,10 +928,37 @@ export class Bridge {
                 tokens: this.tokenUsageTracker.getTotals(),
             };
         };
-        this.server.metricsFn = () => this.activityLog.toPrometheus({
-            rateLimitRejected: this.activityLog.getRateLimitRejections(),
-            extensionDisconnects: this.extensionDisconnectCount,
-        });
+        this.server.metricsFn = () => {
+            const base = this.activityLog.toPrometheus({
+                rateLimitRejected: this.activityLog.getRateLimitRejections(),
+                extensionDisconnects: this.extensionDisconnectCount,
+            });
+            // Append per-category halt gauges from the runLog so users with
+            // their own Prometheus stack can dashboard halts without using
+            // Patchwork's UI. Reads everything currently in the in-memory ring
+            // (bounded by runLog memoryCap); rotation may cause the values to
+            // decrease, so we expose this as a `gauge` rather than a `counter`.
+            // Composes #441/#444/#447 — same data shape as /runs/halt-summary
+            // and `patchwork halts`, surfaced through the existing /metrics
+            // route.
+            let haltLines = [];
+            let judgeLines = [];
+            try {
+                if (this.recipeRunLog) {
+                    const runs = this.recipeRunLog.query({ limit: 500 });
+                    haltLines = haltSummaryToPrometheus(summariseHalts(runs));
+                    // PR3b — judge verdicts are a separate channel from halts
+                    // (augment-only invariant; see judgeVerdict.ts). Same window,
+                    // same fail-open posture.
+                    judgeLines = judgeSummaryToPrometheus(summariseJudgments(runs));
+                }
+            }
+            catch {
+                /* fail-open: prometheus must never break on log read */
+            }
+            const extras = [...haltLines, ...judgeLines];
+            return extras.length > 0 ? `${base}\n${extras.join("\n")}\n` : base;
+        };
         this.server.perfDataFn = () => {
             const windowMs = 60 * 60_000; // 1h window for dashboard
             const windowedS = this.activityLog.windowedStats(windowMs);
@@ -899,10 +969,11 @@ export class Bridge {
                 totalCalls += s.count;
                 totalErrors += s.errors;
             }
-            const p95Values = Object.values(allPercentiles).map((p) => p.p95);
-            const overallP95Ms = p95Values.length > 0 ? Math.max(...p95Values) : 0;
+            let overallP95Ms = 0;
             const perTool = {};
             for (const [tool, pct] of Object.entries(allPercentiles)) {
+                if (pct.p95 > overallP95Ms)
+                    overallP95Ms = pct.p95;
                 const ws = windowedS[tool];
                 perTool[tool] = {
                     p50: pct.p50,
@@ -1011,14 +1082,16 @@ export class Bridge {
             // Count automation tasks (isAutomationTask) created within the window.
             // These originate from automation hooks (onFileSave, onGitCommit, etc.)
             // and accurately represent "hooks fired" rather than session lifecycle events.
-            const hooksLast24h = this.orchestrator
-                ? this.orchestrator
-                    .list()
-                    .filter((t) => t.isAutomationTask && t.createdAt > cutoff).length
-                : 0;
-            const recentAutomationTasks = this.orchestrator
-                ? this.orchestrator
-                    .list()
+            const allTasks = this.orchestrator ? this.orchestrator.list() : null;
+            let hooksLast24h = 0;
+            if (allTasks) {
+                for (const t of allTasks) {
+                    if (t.isAutomationTask && t.createdAt > cutoff)
+                        hooksLast24h++;
+                }
+            }
+            const recentAutomationTasks = allTasks
+                ? allTasks
                     .sort((a, b) => b.createdAt - a.createdAt)
                     .slice(0, 20)
                     .map((t) => ({
@@ -1049,6 +1122,23 @@ export class Bridge {
             };
         };
         this.server.streamFn = (listener) => this.activityLog.subscribe(listener);
+        // v2-I8 (#422): broadcast kind:"kill-switch" SSE when state changes.
+        // The activityLog subscriber list fans out to all open /stream clients.
+        this.server.broadcastKillSwitchEventFn = (engaged, reason) => {
+            for (const listener of this.activityLog.getListeners()) {
+                try {
+                    listener("kill-switch", {
+                        id: 0,
+                        timestamp: new Date().toISOString(),
+                        event: engaged ? "engage" : "release",
+                        metadata: { engaged, ...(reason ? { reason } : {}) },
+                    });
+                }
+                catch {
+                    /* listener must not crash broadcast */
+                }
+            }
+        };
         this.server.cancelTaskFn = (id) => this.orchestrator?.cancel(id, "user") ?? false;
         // Wire `/sessions` for the dashboard's Sessions page. The same Map is
         // already iterated by `statusFn` for the bridge-status payload — exposing
@@ -1080,6 +1170,24 @@ export class Bridge {
             }
             return out;
         };
+        this.server.restartCheckFn = () => {
+            let totalSessions = 0;
+            let totalInFlight = 0;
+            const busySessions = [];
+            for (const [sid, session] of this.sessions) {
+                totalSessions++;
+                const stats = session.transport.getStats();
+                if (stats.activeToolCalls > 0) {
+                    totalInFlight += stats.activeToolCalls;
+                    busySessions.push(`${sid.slice(0, 8)} (${stats.activeToolCalls} tool${stats.activeToolCalls === 1 ? "" : "s"}: ${stats.inFlightTools.join(", ")})`);
+                }
+            }
+            return {
+                totalSessions,
+                inFlightCalls: totalInFlight,
+                busySessions,
+            };
+        };
         this.server.tasksFn = () => ({
             tasks: (this.orchestrator?.list() ?? []).map((t) => ({
                 taskId: t.id,
@@ -1121,9 +1229,33 @@ export class Bridge {
         // ~/.patchwork/config.json's enableTimeOfDayAnomaly field.
         this.server.enableTimeOfDayAnomaly =
             this.config.enableTimeOfDayAnomaly ?? false;
+        // Push / ntfy config — previously only set by /settings and lost on
+        // restart. Now restored from ~/.patchwork/config.json on boot so the
+        // mobile-oversight phone path survives a bridge bounce.
+        this.server.pushServiceUrl = this.config.pushServiceUrl ?? undefined;
+        this.server.pushServiceToken = this.config.pushServiceToken ?? undefined;
+        this.server.pushServiceBaseUrl =
+            this.config.pushServiceBaseUrl ?? undefined;
+        this.server.ntfyTopic = this.config.ntfyTopic ?? undefined;
+        this.server.ntfyServer = this.config.ntfyServer ?? undefined;
+        // Wire recipe-halt → Web Push dispatch. The listener reads
+        // pushServiceUrl/Token via getter each fire, so config edits
+        // through /settings take effect without a restart. Push request
+        // is fire-and-forget; runner is never blocked on a relay outage.
+        wireHaltPushDispatch({
+            activityLog: this.activityLog,
+            getPushConfig: () => {
+                const url = this.server.pushServiceUrl;
+                const token = this.server.pushServiceToken;
+                if (!url || !token)
+                    return null;
+                return { url, token };
+            },
+            logger: this.logger,
+        });
         this.server.readyFn = () => {
             // Count tools from the first active session (all sessions share the same tool set)
-            const anySession = [...this.sessions.values()][0];
+            const anySession = this.sessions.values().next().value;
             const toolCount = anySession?.transport.toolCount ?? 0;
             return {
                 ready: this.ready,
@@ -1131,6 +1263,30 @@ export class Bridge {
                 extensionConnected: this.extensionClient.isConnected(),
             };
         };
+        // Wire kill-switch audit-trace emit to decisionTraceLog. State
+        // transitions become DecisionTrace entries with tags=["kill-switch",
+        // "engage"|"release", "actor:http"]; query via ctxQueryTraces. See
+        // step 5 of #422.
+        if (this.decisionTraceLog) {
+            const traceLog = this.decisionTraceLog;
+            const workspace = this.config.workspace;
+            this.server.recordKillSwitchTraceFn = (event) => {
+                const direction = event.engaged ? "engage" : "release";
+                const isoTs = new Date(event.ts).toISOString();
+                try {
+                    traceLog.record({
+                        ref: "kill-switch.writes",
+                        problem: event.reason ?? direction,
+                        solution: `${event.engaged ? "ENGAGED" : "RELEASED"} at ${isoTs}`,
+                        workspace,
+                        tags: ["kill-switch", direction, "actor:http"],
+                    });
+                }
+                catch (err) {
+                    this.logger.warn(`[kill-switch] failed to record audit trace: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            };
+        }
         this.server.statusFn = () => {
             let sessionsInGrace = 0;
             const sessionList = [];
@@ -1179,6 +1335,8 @@ export class Bridge {
                         pushServiceUrl: this.server.pushServiceUrl ?? null,
                         pushServiceToken: this.server.pushServiceToken ? "***" : null,
                         pushServiceBaseUrl: this.server.pushServiceBaseUrl ?? null,
+                        ntfyTopic: this.server.ntfyTopic ?? null,
+                        ntfyServer: this.server.ntfyServer ?? null,
                     };
                 })(),
             };
@@ -1240,7 +1398,7 @@ export class Bridge {
             if (result === null) {
                 return {
                     ok: false,
-                    error: "launchQuickTask not registered — requires --claude-driver subprocess",
+                    error: "launchQuickTask not registered — requires --driver subprocess",
                 };
             }
             const r = result;
@@ -1380,6 +1538,16 @@ export class Bridge {
         // All process-level signal handlers are guarded by globalHandlersRegistered so
         // that repeated start() calls (e.g. in tests or --watch restarts) don't
         // accumulate process.once listeners and trigger MaxListenersExceededWarning.
+        // Wire server callbacks so /restart and /shutdown invoke the bridge's
+        // shutdown sequence directly. This is the only path that works on
+        // Windows, where `process.kill(pid, 'SIGTERM')` is TerminateProcess
+        // and registered handlers never fire.
+        this.server.restartKillFn = () => {
+            void shutdown("SIGTERM", 143);
+        };
+        this.server.shutdownFn = () => {
+            void shutdown("SIGTERM", 0);
+        };
         if (!globalHandlersRegistered) {
             globalHandlersRegistered = true;
             process.once("SIGINT", () => shutdown("SIGINT", 130));
@@ -1477,6 +1645,15 @@ export class Bridge {
         this.stopped = true;
         this.logger.info("Shutting down...");
         this._stopPeriodicSnapshots();
+        if (this._stopFlagsWatch) {
+            try {
+                this._stopFlagsWatch();
+            }
+            catch {
+                /* ignore */
+            }
+            this._stopFlagsWatch = null;
+        }
         this.tokenUsageTracker.stop();
         this.automationHooks?.destroy();
         this.recipeScheduler?.stop();
@@ -1521,7 +1698,7 @@ export class Bridge {
         }
         // Clean up all active sessions (cleanupSession skips the extension notification
         // during shutdown because this.stopped is already true)
-        for (const id of [...this.sessions.keys()]) {
+        for (const id of this.sessions.keys()) {
             this.cleanupSession(id);
         }
         const shutdownErrorPart = totalErrors > 0