patchwork-os 0.2.0-beta.9.canary.92 → 1.1.0-beta.1

package/dist/recipeRoutes.d.ts

@@ -29,6 +29,31 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { LintIssue } from "./recipes/validation.js";
 import type { RecipeDraft } from "./recipesHttp.js";
+import type { OutcomeStore } from "./workers/outcomeStore.js";
+/**
+ * #605 / B3-A: shape-validate AND sanitize the upstream templates payload
+ * before caching.
+ *
+ * The minimal contract used by the dashboard marketplace is `{recipes:
+ * Array}` (other fields are optional). A bare array is accepted too (legacy).
+ * Anything that fails that contract (an error page JSON, a tampered file with
+ * a flipped top-level key, a future GitHub schema change) is rejected so we
+ * don't serve garbage for 5 minutes to every dashboard client.
+ *
+ * B3-A SECURITY change: rather than reject the WHOLE payload when a single
+ * entry carries a malformed trust field, we SANITIZE each entry IN PLACE so
+ * one bad entry can't poison the registry for every client. For each entry:
+ *
+ *   - `risk_level` not in {low,medium,high}        → stripped (set undefined)
+ *   - `approval_behavior` not in the canonical set → stripped (set undefined)
+ *   - `downloads` not a finite number              → coerced if it parses to a
+ *                                                     finite number, else dropped
+ *
+ * Conservative by design: stripping an out-of-enum `risk_level` means the
+ * dashboard treats trust as UNKNOWN (which the default-deny gate renders as
+ * elevated), never silently as "low"/"safe".
+ */
+export declare function isWellFormedTemplatesPayload(raw: unknown): boolean;
 export declare function _resetGenerateRateLimitForTests(): void;
 export declare function _resetRepairRateLimitForTests(): void;
 export interface VarsValidationError {
@@ -54,6 +79,28 @@ export declare const RECIPE_ROUTE_BODY_CAPS: {
      * (256 KB matches the existing PUT/POST/lint caps).
      */
     readonly repair: number;
+    /**
+     * PATCH /recipes/:name — only `{ "enabled": true/false }` (≈ 15 bytes).
+     * 1 KB is 66× that maximum; 256 KB was a trivial DoS vector.
+     */
+    readonly toggle: number;
+    /**
+     * POST /outcomes — `{ issueUrl, disposition, recipeName?, workerClass? }`.
+     * A URL + short enum + two audit strings; 2 KB is generous.
+     */
+    readonly outcomes: number;
+    /**
+     * POST /traces/decision — `{ ref, problem, solution, workspace?, tags?,
+     * sessionId?, source? }`. problem/solution are each capped at 500 chars
+     * by DecisionTraceLog.record(); 8 KB covers that plus tags/metadata with
+     * headroom, matching the shape of the ctxSaveTrace MCP tool's inputs.
+     */
+    readonly decisionTrace: number;
+    /**
+     * POST /copilot/message — `{ text: string }`, a single chat-input line.
+     * 4 KB is generous for free text while blocking a pathological paste.
+     */
+    readonly copilotMessage: number;
 };
 /**
  * Read an HTTP request body up to `max` bytes. Returns the raw string or
@@ -102,6 +149,19 @@ export declare function readJsonBody<T = unknown>(req: IncomingMessage, max: num
  * until the client emits `end`, so the server returns the response cleanly.
  */
 export declare function respond413(res: ServerResponse, max: number): void;
+/**
+ * Fetch `startUrl` following HTTP redirects manually, re-validating every hop
+ * against the SSRF guard. Throws on a blocked host (private/loopback),
+ * unsupported protocol, malformed `Location`, or exceeding the hop cap.
+ * Returns the terminal (non-redirect) `Response`.
+ *
+ * `fetchImpl` is injectable for tests; defaults to the global `fetch`.
+ * `signal` is forwarded to every hop so the install timeout still applies.
+ */
+export declare function fetchFollowingRedirectsSafely(startUrl: string, opts?: {
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+}): Promise<Response>;
 export interface RecipeRouteDeps {
     setRecipeTrustFn: ((name: string, level: string) => {
         ok: boolean;
@@ -204,6 +264,39 @@ export interface RecipeRouteDeps {
         recipe?: string;
     }) => import("./recipes/judgeSummary.js").JudgeSummary) | null;
     runPlanFn: ((recipeName: string) => Promise<Record<string, unknown>>) | null;
+    /** What-If Preview: static counterfactual simulation for a recipe by name. */
+    simulateFn: ((recipeName: string) => Promise<Record<string, unknown>>) | null;
+    /** Read-only worker trust dial (shadow) — replays run + decision logs. */
+    workerShadowFn: (() => Promise<Record<string, unknown>>) | null;
+    /** Read-only query over the persisted Decision Record. Backs
+     *  GET /gate/decisions and `patchwork gate explain`. */
+    gateDecisionsFn: ((opts?: {
+        workerId?: string;
+        classKey?: string;
+        limit?: number;
+    }) => import("./workerGateDecisionLog.js").GateDecisionRecord[]) | null;
+    /** Record a Decision Record trace over HTTP. Backs POST /traces/decision —
+     *  the HTTP twin of the `ctxSaveTrace` MCP tool, same `DecisionTraceLog`
+     *  writer. Throws on invalid input; route maps that to 400. */
+    saveDecisionTraceFn: ((input: {
+        ref: string;
+        problem: string;
+        solution: string;
+        workspace?: string;
+        tags?: string[];
+        sessionId?: string;
+        source?: string;
+    }) => import("./decisionTraceLog.js").DecisionTrace) | null;
+    /** Operator outcome dispositions (~/.patchwork/outcome-log.jsonl). Backs
+     *  GET/POST /outcomes and mirrors `patchwork outcomes confirm|reject|list`.
+     *  A fresh store per call (cheap, disk-backed, last-writer-wins). The factory
+     *  ensures the log's parent dir exists so `upsert` can append. NEVER exposed
+     *  as a recipe step / MCP tool — a worker must not confirm its own filings. */
+    outcomeStoreFn: (() => OutcomeStore) | null;
+    /** The confirm queue — worker filings awaiting an operator disposition
+     *  (unknown / no record). Backs GET /outcomes/pending + `patchwork outcomes
+     *  pending`; a read-only join over the run log + outcome dispositions. */
+    pendingConfirmationsFn: (() => import("./workers/runWorkerShadow.js").PendingConfirmation[]) | null;
     runReplayFn: ((seq: number) => Promise<{
         ok: boolean;
         newSeq?: number;