@jiggai/recipes 0.4.69 → 0.4.71

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "recipes",
   "name": "Recipes",
   "description": "Markdown recipes that scaffold agents and teams (workspace-local).",
-  "version": "0.4.69",
+  "version": "0.4.71",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiggai/recipes",
-  "version": "0.4.69",
+  "version": "0.4.71",
   "description": "ClawRecipes plugin for OpenClaw (markdown recipes -> scaffold agents/teams)",
   "main": "index.ts",
   "type": "commonjs",

package/src/lib/recipes-config.ts

@@ -2,34 +2,49 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { upsertAgentInConfig, type AgentConfigSnippet } from "./agent-config";
 import { stableStringify } from "./stable-stringify";
 
-/** Runtime API shape for config access (plugin SDK may not expose types). */
+/**
+ * Runtime API shape for config access. Mirrors the modern surface
+ * (`current` + `replaceConfigFile`) so we don't trigger the
+ * `runtime-config-load-write` deprecation warning that the legacy
+ * `loadConfig` / `writeConfigFile` helpers emit.
+ */
 interface OpenClawRuntimeConfig {
-  loadConfig?: () => { cfg?: unknown } | unknown;
-  writeConfigFile?: (cfg: unknown) => Promise<void>;
+  current?: () => unknown;
+  replaceConfigFile?: (params: {
+    nextConfig: unknown;
+    afterWrite: { mode: "auto" } | { mode: "restart"; reason: string } | { mode: "none"; reason: string };
+  }) => Promise<unknown>;
 }
 
 /**
  * Load OpenClaw config via runtime API.
+ * Returns a deep clone of the runtime snapshot so callers may mutate it
+ * before persisting via {@link writeOpenClawConfig}; the runtime's own
+ * snapshot from `current()` is `DeepReadonly` and must not be mutated.
  * @param api - OpenClaw plugin API
- * @returns Config object (mutable)
- * @throws If loadConfig fails
+ * @returns Config object (mutable copy)
+ * @throws If the runtime config API is unavailable
  */
 export async function loadOpenClawConfig(api: OpenClawPluginApi): Promise<Record<string, unknown>> {
   const runtime = api.runtime as { config?: OpenClawRuntimeConfig };
-  const current = runtime.config?.loadConfig?.();
-  if (!current) throw new Error("Failed to load config via api.runtime.config.loadConfig()");
-  const cfgObj = (current as { cfg?: unknown }).cfg ?? current;
-  return cfgObj as Record<string, unknown>;
+  const snapshot = runtime.config?.current?.();
+  if (!snapshot) throw new Error("Failed to load config via api.runtime.config.current()");
+  return JSON.parse(JSON.stringify(snapshot)) as Record<string, unknown>;
 }
 
 /**
- * Write OpenClaw config via runtime API.
+ * Persist a full OpenClaw config replacement via the runtime API.
+ * Uses `afterWrite: { mode: "auto" }` to let the gateway choose between
+ * hot-reload and restart, matching the legacy `writeConfigFile` default.
  * @param api - OpenClaw plugin API
  * @param cfgObj - Config object to write
  */
 export async function writeOpenClawConfig(api: OpenClawPluginApi, cfgObj: Record<string, unknown>): Promise<void> {
   const runtime = api.runtime as { config?: OpenClawRuntimeConfig };
-  await runtime.config?.writeConfigFile?.(cfgObj);
+  await runtime.config?.replaceConfigFile?.({
+    nextConfig: cfgObj,
+    afterWrite: { mode: "auto" },
+  });
 }
 
 export type BindingMatch = {

package/src/lib/workflows/workflow-node-executor.ts

@@ -305,16 +305,59 @@ export async function executeWorkflowNodes(opts: {
         `- openclaw recipes workflows resume --team-id ${teamId} --run-id ${runId}`,
       ].join('\n');
 
-      await toolsInvoke<ToolTextResult>(api, {
-        tool: 'message',
-        args: {
-          action: 'send',
-          channel,
-          target,
-          ...(accountId ? { accountId } : {}),
-          message: msg,
-        },
-      });
+      // Deliver the approval prompt. Wrap in try/catch + Telegram bot-API
+      // fallback because OpenClaw 2026.4.26's gateway has been observed to
+      // return "Tool not available: message" from /tools/invoke even though
+      // the channel itself is healthy. The approval.json file is durable
+      // either way, so we never fail the run on delivery error — operators
+      // can still approve via the kitchen UI or `openclaw recipes workflows
+      // approve` CLI when this falls through.
+      let approvalDelivered = false;
+      try {
+        await toolsInvoke<ToolTextResult>(api, {
+          tool: 'message',
+          args: {
+            action: 'send',
+            channel,
+            target,
+            ...(accountId ? { accountId } : {}),
+            message: msg,
+          },
+        });
+        approvalDelivered = true;
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.warn(`[workflow] tools.invoke('message') failed for run ${runId} on node ${node.id}: ${errMsg}`);
+        if (channel === 'telegram') {
+          try {
+            const cfg = await loadOpenClawConfig(api);
+            const tgToken = (cfg as { channels?: { telegram?: { botToken?: string } } })
+              .channels?.telegram?.botToken;
+            if (tgToken) {
+              const tgRes = await fetch(`https://api.telegram.org/bot${tgToken}/sendMessage`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ chat_id: target, text: msg }),
+              });
+              if (tgRes.ok) {
+                approvalDelivered = true;
+                console.log(`[workflow] approval delivered via direct telegram bot API for run ${runId}`);
+              } else {
+                const tgBody = await tgRes.text().catch(() => '');
+                console.error(`[workflow] telegram fallback failed (${tgRes.status}) for run ${runId}: ${tgBody}`);
+              }
+            } else {
+              console.error(`[workflow] telegram fallback skipped for run ${runId}: missing channels.telegram.botToken in openclaw config`);
+            }
+          } catch (fbErr) {
+            const fbMsg = fbErr instanceof Error ? fbErr.message : String(fbErr);
+            console.error(`[workflow] telegram fallback threw for run ${runId}: ${fbMsg}`);
+          }
+        }
+        if (!approvalDelivered) {
+          console.warn(`[workflow] approval message not delivered for run ${runId}; approve via kitchen UI or CLI`);
+        }
+      }
 
       const waitingTs = new Date().toISOString();
       await appendRunLog(runLogPath, (cur) => ({