patchwork-os 0.2.0-alpha.3 → 0.2.0-alpha.30

package/dist/bridge.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { WebSocket } from "ws";
+import { recordRecipeRun } from "./activationMetrics.js";
 import { ActivityLog } from "./activityLog.js";
 import { buildSummary } from "./analyticsAggregator.js";
 import { getAnalyticsPref } from "./analyticsPrefs.js";
@@ -11,21 +12,23 @@ import { getApprovalQueue } from "./approvalQueue.js";
 import { AutomationHooks, loadPolicy } from "./automation.js";
 import { loadOrCreateBridgeToken } from "./bridgeToken.js";
 import { repairBridgeToolsRulesIfStale } from "./bridgeToolsRules.js";
-import { createDriver } from "./claudeDriver.js";
 import { ClaudeOrchestrator } from "./claudeOrchestrator.js";
 import { CommitIssueLinkLog } from "./commitIssueLinkLog.js";
 import { DecisionTraceLog } from "./decisionTraceLog.js";
+import { createDriver } from "./drivers/index.js";
 import { ExtensionClient } from "./extensionClient.js";
 import { FileLock } from "./fileLock.js";
 import { buildEnforcementReminder } from "./instructionsUtils.js";
 import { LockFileManager } from "./lockfile.js";
 import { Logger } from "./logger.js";
 import { OAuthServerImpl } from "./oauth.js";
+import { loadConfig as loadPatchworkConfig, saveConfig as savePatchworkConfig, } from "./patchworkConfig.js";
 import { loadPlugins, loadPluginsFull } from "./pluginLoader.js";
 import { PluginWatcher } from "./pluginWatcher.js";
 import { probeAll } from "./probe.js";
+import { RecipeOrchestrator } from "./recipes/RecipeOrchestrator.js";
 import { RecipeScheduler } from "./recipes/scheduler.js";
-import { findWebhookRecipe, listInstalledRecipes, loadRecipePrompt, renderWebhookPrompt, saveRecipe, } from "./recipesHttp.js";
+import { findWebhookRecipe, findYamlRecipePath, listInstalledRecipes, loadRecipeContent, loadRecipePrompt, renderWebhookPrompt, saveRecipe, saveRecipeContent, } from "./recipesHttp.js";
 import { classifyTool } from "./riskTier.js";
 import { RecipeRunLog } from "./runLog.js";
 import { Server } from "./server.js";
@@ -114,6 +117,7 @@ export class Bridge {
     automationHooks = undefined;
     recipeScheduler = null;
     recipeRunLog = null;
+    recipeOrchestrator = null;
     commitIssueLinkLog = null;
     decisionTraceLog = null;
     /** Pre-computed digest of recent decisions, refreshed on each session connect. */
@@ -136,6 +140,7 @@ export class Bridge {
         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.bridgeConfigPath = config.configFilePath ?? undefined;
         if (config.issuerUrl) {
             this.oauthServer = new OAuthServerImpl(this.authToken, config.issuerUrl, {
                 configDir,
@@ -239,6 +244,8 @@ export class Bridge {
             transport.sessionId = sessionId;
             transport.setActivityLog(this.activityLog);
             transport.setToolRateLimit(this.config.toolRateLimit);
+            if (this.config.lazyTools)
+                transport.setLazyTools(true);
             if (this.server.approvalGate !== "off") {
                 this.logger.info(`[patchwork] approval gate active: ${this.server.approvalGate} tier(s) require dashboard approval`);
                 transport.setApprovalGate(async ({ toolName, params, sessionId }) => {
@@ -309,6 +316,7 @@ export class Bridge {
                 graceTimer: null,
                 connectedAt: Date.now(),
                 wsAlive: true,
+                remoteAddr: ws.remoteAddr,
             };
             ws.on("pong", () => {
                 session.wsAlive = true;
@@ -702,8 +710,19 @@ export class Bridge {
         this.logger.info(`Available linters: ${probeList(["tsc", "eslint", "pyright", "ruff", "cargo", "go", "biome"])}`);
         this.logger.info(`Available test runners: ${probeList(["vitest", "jest", "pytest", "cargo", "go"])}`);
         // 2. Initialize Claude driver and orchestrator (if configured)
-        if (this.config.claudeDriver !== "none") {
-            const driver = createDriver(this.config.claudeDriver, this.config.claudeBinary, this.config.antBinary, (msg) => this.logger.info(msg));
+        if (this.config.driver !== "none") {
+            const driver = createDriver(this.config.driver, {
+                binary: this.config.claudeBinary,
+                antBinary: this.config.antBinary,
+                bridgeMcp: this.config.driver === "gemini"
+                    ? () => this.port > 0
+                        ? {
+                            url: `http://127.0.0.1:${this.port}/mcp`,
+                            authToken: this.authToken,
+                        }
+                        : undefined
+                    : undefined,
+            }, (msg) => this.logger.info(msg));
             // Patchwork: enrichment link log is useful regardless of orchestrator.
             const patchworkDir = path.join(os.homedir(), ".patchwork");
             this.commitIssueLinkLog = new CommitIssueLinkLog({
@@ -763,17 +782,25 @@ export class Bridge {
                     },
                 });
                 this.logger.info(`[bridge] Claude driver: ${driver.name}`);
+                // Recipe orchestrator — owns in-flight dedup across all entry paths.
+                this.recipeOrchestrator = new RecipeOrchestrator({
+                    workdir: this.config.workspace,
+                });
                 // Patchwork: start cron-trigger scheduler once the orchestrator exists.
                 const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
                 this.recipeScheduler = new RecipeScheduler({
                     recipesDir,
-                    enqueue: (opts) => this.orchestrator.enqueue(opts),
+                    enqueue: (opts) => this.orchestrator?.enqueue(opts) ?? "",
+                    runYaml: async (name) => {
+                        const result = await this.server.runRecipeFn?.(name);
+                        if (result && !result.ok) {
+                            throw new Error(result.error ?? "unknown error");
+                        }
+                    },
                     logger: this.logger,
                 });
-                const scheduled = this.recipeScheduler.start();
-                if (scheduled.length > 0) {
-                    this.logger.info(`[patchwork] scheduled ${scheduled.length} cron recipe${scheduled.length === 1 ? "" : "s"}`);
-                }
+                // scheduler.start() deferred to after this.port is set (see below)
+                // so bridgeMcp callback has a valid port when first cron fires.
             }
         }
         if (this.config.automationEnabled) {
@@ -973,6 +1000,7 @@ export class Bridge {
             };
         };
         this.server.streamFn = (listener) => this.activityLog.subscribe(listener);
+        this.server.cancelTaskFn = (id) => this.orchestrator?.cancel(id, "user") ?? false;
         this.server.tasksFn = () => ({
             tasks: (this.orchestrator?.list() ?? []).map((t) => ({
                 taskId: t.id,
@@ -1003,10 +1031,43 @@ export class Bridge {
             const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
             return listInstalledRecipes(recipesDir);
         };
+        this.server.loadRecipeContentFn = (name) => {
+            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
+            return loadRecipeContent(recipesDir, name);
+        };
+        this.server.saveRecipeContentFn = (name, content) => {
+            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
+            return saveRecipeContent(recipesDir, name, content);
+        };
         this.server.saveRecipeFn = (draft) => {
             const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
             return saveRecipe(recipesDir, draft);
         };
+        this.server.setRecipeEnabledFn = (name, enabled) => {
+            try {
+                const cfg = loadPatchworkConfig();
+                const disabled = new Set(cfg.recipes?.disabled ??
+                    []);
+                if (enabled)
+                    disabled.delete(name);
+                else
+                    disabled.add(name);
+                savePatchworkConfig({
+                    ...cfg,
+                    recipes: {
+                        ...cfg.recipes,
+                        disabled: [...disabled],
+                    },
+                });
+                return { ok: true };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        };
         this.server.runsFn = (q) => {
             if (!this.recipeRunLog)
                 return [];
@@ -1022,14 +1083,28 @@ export class Bridge {
                 ...(q.after !== undefined && { after: q.after }),
             });
         };
-        this.server.sessionsFn = () => [...this.sessions.values()].map((s) => ({
-            id: s.id,
-            connectedAt: new Date(s.connectedAt).toISOString(),
-            openedFileCount: s.openedFiles.size,
-            pendingApprovals: getApprovalQueue()
-                .list()
-                .filter((a) => a.sessionId === s.id).length,
-        }));
+        this.server.runDetailFn = (seq) => {
+            if (!this.recipeRunLog)
+                return null;
+            return this.recipeRunLog.getBySeq(seq);
+        };
+        this.server.runPlanFn = async (recipeName) => {
+            const { runRecipeDryPlan } = await import("./commands/recipe.js");
+            return (await runRecipeDryPlan(recipeName));
+        };
+        this.server.sessionsFn = () => [...this.sessions.values()].map((s) => {
+            const tools = this.activityLog.querySessionTools(s.id, 1);
+            return {
+                id: s.id,
+                connectedAt: new Date(s.connectedAt).toISOString(),
+                openedFileCount: s.openedFiles.size,
+                pendingApprovals: getApprovalQueue()
+                    .list()
+                    .filter((a) => a.sessionId === s.id).length,
+                firstTool: tools[0]?.tool,
+                remoteAddr: s.remoteAddr,
+            };
+        });
         this.server.sessionDetailFn = (id) => {
             const s = this.sessions.get(id);
             const summary = s
@@ -1068,7 +1143,36 @@ export class Bridge {
             if (!match) {
                 return { ok: false, error: "not_found" };
             }
-            const loaded = loadRecipePrompt(recipesDir, match.name);
+            if (match.format === "yaml") {
+                let payloadText;
+                if (payload !== undefined) {
+                    try {
+                        payloadText = JSON.stringify(payload);
+                    }
+                    catch {
+                        payloadText = String(payload);
+                    }
+                    if (payloadText.length > 8_000) {
+                        payloadText = `${payloadText.slice(0, 8_000)}\n…[truncated]`;
+                    }
+                }
+                const seedContext = {
+                    hook_path: hookPath,
+                    webhook_path: hookPath,
+                    ...(payloadText !== undefined
+                        ? { payload: payloadText, webhook_payload: payloadText }
+                        : {}),
+                };
+                return this._fireYamlRecipe({
+                    filePath: match.filePath,
+                    name: match.name,
+                    taskIdPrefix: `yaml-webhook-${match.name}`,
+                    triggerSourceSuffix: `webhook:${match.name}`,
+                    logLabel: `webhook "${match.name}"`,
+                    seedContext,
+                });
+            }
+            const loaded = loadRecipePrompt(recipesDir, path.basename(match.filePath, path.extname(match.filePath)));
             if (!loaded) {
                 return { ok: false, error: "recipe_file_missing" };
             }
@@ -1086,7 +1190,7 @@ export class Bridge {
                 };
             }
         };
-        this.server.runRecipeFn = async (name) => {
+        this.server.runRecipeFn = async (name, vars) => {
             if (!this.orchestrator) {
                 return {
                     ok: false,
@@ -1094,26 +1198,45 @@ export class Bridge {
                 };
             }
             const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
+            // Try JSON recipe first (legacy path: enqueue prompt as a task).
             const loaded = loadRecipePrompt(recipesDir, name);
-            if (!loaded) {
-                return {
-                    ok: false,
-                    error: `Recipe "${name}" not found in ${recipesDir}`,
-                };
-            }
-            try {
-                const taskId = this.orchestrator.enqueue({
-                    prompt: loaded.prompt,
-                    triggerSource: `recipe:${name}`,
-                });
-                return { ok: true, taskId };
+            if (loaded) {
+                try {
+                    let prompt = loaded.prompt;
+                    if (vars && Object.keys(vars).length > 0) {
+                        const varLines = Object.entries(vars)
+                            .map(([k, v]) => `${k}=${v}`)
+                            .join("\n");
+                        prompt = `Variables:\n${varLines}\n\n${prompt}`;
+                    }
+                    const taskId = this.orchestrator.enqueue({
+                        prompt,
+                        triggerSource: `recipe:${name}`,
+                    });
+                    return { ok: true, taskId };
+                }
+                catch (err) {
+                    return {
+                        ok: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    };
+                }
             }
-            catch (err) {
+            // Fall through to YAML runner for .yaml/.yml recipes.
+            const ymlPath = findYamlRecipePath(recipesDir, name);
+            if (!ymlPath) {
                 return {
                     ok: false,
-                    error: err instanceof Error ? err.message : String(err),
+                    error: `Recipe "${name}" not found in ${recipesDir}`,
                 };
             }
+            return this._fireYamlRecipe({
+                filePath: ymlPath,
+                name,
+                taskIdPrefix: `yaml-recipe-${name}`,
+                triggerSourceSuffix: `recipe:${name}`,
+                logLabel: `"${name}"`,
+            });
         };
         this.server.readyFn = () => {
             // Count tools from the first active session (all sessions share the same tool set)
@@ -1156,7 +1279,10 @@ export class Bridge {
                     workspace: this.config.workspace,
                     approvalGate: this.server.approvalGate,
                     fullMode: this.config.fullMode,
-                    claudeDriver: this.config.claudeDriver,
+                    driver: this.config.driver,
+                    model: loadPatchworkConfig().model,
+                    localEndpoint: loadPatchworkConfig().localEndpoint,
+                    localModel: loadPatchworkConfig().localModel,
                     automationEnabled: this.config.automationEnabled,
                     port: this.port,
                     webhookUrl: this.server.approvalWebhookUrl ?? null,
@@ -1262,6 +1388,13 @@ export class Bridge {
             throw err;
         }
         this.port = port;
+        // 4a-deferred. Start recipe scheduler now that port is known (bridgeMcp needs a valid port).
+        if (this.recipeScheduler) {
+            const scheduled = this.recipeScheduler.start();
+            if (scheduled.length > 0) {
+                this.logger.info(`[patchwork] scheduled ${scheduled.length} cron recipe${scheduled.length === 1 ? "" : "s"}`);
+            }
+        }
         // 4b. Start WebSocket keepalive heartbeat (keeps MCP session alive during long idle periods)
         this._startWsHeartbeat();
         // 4c. Load persisted tasks from previous sessions (best-effort)
@@ -1392,6 +1525,63 @@ export class Bridge {
             })}`);
         }
     }
+    /**
+     * Load and fire a YAML recipe in the background via the orchestrator.
+     * Returns `{ ok, taskId, name? }` immediately; execution continues async.
+     * Both the webhook path and runRecipeFn use this to eliminate duplication.
+     */
+    async _fireYamlRecipe(opts) {
+        if (!this.recipeOrchestrator) {
+            return { ok: false, error: "recipe orchestrator unavailable" };
+        }
+        const orch = this.orchestrator;
+        const { buildChainedDeps, dispatchRecipe } = await import("./recipes/yamlRunner.js");
+        const claudeCodeFn = async (prompt) => {
+            const task = await orch.runAndWait({
+                prompt,
+                triggerSource: `${opts.triggerSourceSuffix}:agent`,
+                timeoutMs: 600_000,
+            });
+            return task.output ?? task.errorMessage ?? "";
+        };
+        const runnerDeps = { workdir: this.config.workspace, claudeCodeFn };
+        const chainedOptions = {
+            sourcePath: opts.filePath,
+            runLogDir: this.recipeRunLog
+                ? path.join(os.homedir(), ".patchwork")
+                : undefined,
+        };
+        const fireResult = await this.recipeOrchestrator
+            .fire({
+            filePath: opts.filePath,
+            name: opts.name,
+            triggerSource: opts.triggerSourceSuffix,
+            seedContext: opts.seedContext,
+            dispatchFn: async (recipe, _deps, seedContext) => {
+                const result = await dispatchRecipe(recipe, {
+                    ...runnerDeps,
+                    chainedDeps: buildChainedDeps(runnerDeps, claudeCodeFn),
+                    chainedOptions,
+                }, seedContext);
+                const steps = "stepsRun" in result
+                    ? result.stepsRun
+                    : (result.summary?.total ?? "?");
+                const succeeded = "stepsRun" in result ? !result.errorMessage : result.success;
+                if (succeeded)
+                    recordRecipeRun();
+                this.logger.info?.(`[recipe] ${opts.logLabel} finished: ${steps} steps`);
+                return result;
+            },
+        })
+            .catch((err) => {
+            this.logger.warn?.(`[recipe] ${opts.logLabel} error: ${err instanceof Error ? err.message : String(err)}`);
+            return {
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        });
+        return fireResult;
+    }
     /** Start the bridge-level WebSocket keepalive heartbeat. Idempotent. */
     _startWsHeartbeat() {
         if (this.wsHeartbeatInterval || this.config.wsPingIntervalMs === 0)
@@ -1458,7 +1648,7 @@ export class Bridge {
         if (this.checkpoint && this.port > 0) {
             try {
                 await Promise.race([
-                    Promise.resolve().then(() => this.checkpoint.write(this._buildCheckpoint(this.port))),
+                    Promise.resolve().then(() => this.checkpoint?.write(this._buildCheckpoint(this.port))),
                     new Promise((resolve) => setTimeout(resolve, 3000)),
                 ]);
             }