clawchef 0.1.12 → 0.1.13

package/README.md

@@ -8,11 +8,12 @@ Recipe-driven OpenClaw environment orchestrator.
 - Accepts recipe input from local file/dir/archive and HTTP URL/archive.
 - Resolves `${var}` parameters from `--var`, environment, and defaults.
 - Auto-loads environment variables from `.env` in the current working directory.
+- `--verbose` prints step-level debug logs including executed commands and operation timing.
 - Supports loading env vars from a custom `.env` path/URL via `--dotenv-ref`.
 - Requires secrets to be injected via `--var` / `CLAWCHEF_VAR_*` (no inline secrets in recipe).
 - Prepares OpenClaw version (install or reuse).
 - When installed OpenClaw version mismatches recipe version, prompts: ignore / abort / force reinstall (silent mode auto-picks force reinstall).
-- Supports scoped execution via `--scope full|files|workspace`.
+- Supports scoped execution via `--scope full|stateful|files|workspace`.
 - `full` scope runs factory reset first (with confirmation prompt unless `-s/--silent` is used).
 - Factory reset includes removing local `~/.openclaw` directory.
 - If `openclaw` is missing, auto-installs the recipe version and skips factory reset.
@@ -105,10 +106,31 @@ Use it only in CI/non-interactive flows where destructive reset behavior is expe
 
 Keep existing OpenClaw state (skip reset and keep current version on mismatch):
 
+```bash
+clawchef cook recipes/sample.yaml --scope stateful
+```
+
+Sync only files and assets (`openclaw.root.assets/files` + `workspaces[].assets/files`) without touching version/reset/workspace/agent/channel/skills/conversations/gateway:
+
 ```bash
 clawchef cook recipes/sample.yaml --scope files
 ```
 
+Limit files-scope changes to relative paths only:
+
+```bash
+clawchef cook recipes/sample.yaml --scope files --file "README.md"
+clawchef cook recipes/sample.yaml --scope files --file "src/**" --file "docs/*.md"
+clawchef cook recipes/sample.yaml --scope files --file "workspace-product-designer/**"
+```
+
+`--file` is repeatable and only works with `--scope files`. Patterns can match any of:
+
+- file relative path (for example `README.md`, `src/**`)
+- workspace-prefixed path (for example `product-designer/**`)
+- default workspace-dir-prefixed path (for example `workspace-product-designer/**`)
+- root-prefixed path (`root/**`) for `openclaw.root.assets/files`
+
 Update only one workspace:
 
 ```bash
@@ -422,6 +444,36 @@ If `agent` is set and `account` is omitted, clawchef defaults `account` to the s
 `channels[].group_policy` currently supports `channel: "telegram"` only and is applied after `channels add` via `openclaw config set` so it is not overwritten by add-flow writes.
 If `channel: "telegram"` has `token: ""` or `bot_token: ""`, clawchef auto-disables that telegram account (`enabled=false`) and skips channel add/bind.
 
+## OpenClaw config patch
+
+Use `openclaw.config_patch` to apply a deep config patch to active OpenClaw config (same target used by `openclaw config set`).
+
+Merge behavior:
+
+- objects: merged recursively by setting nested keys
+- arrays: replaced as a whole
+- scalars: replaced
+
+Applied during `cook` after channel setup and before gateway start. Not applied in `--scope files`.
+
+```yaml
+openclaw:
+  version: "2026.3.2"
+  config_patch:
+    channels:
+      telegram:
+        accounts:
+          frontend-dev:
+            capabilities:
+              inlineButtons: "all"
+            groups:
+              "*":
+                requireMention: false
+                enabled: true
+            actions:
+              sendMessage: true
+```
+
 ## Workspace path behavior
 
 - `workspaces[].path` is optional.

package/dist/api.d.ts

@@ -3,6 +3,7 @@ import type { ScaffoldOptions, ScaffoldResult } from "./scaffold.js";
 export interface CookOptions {
     vars?: Record<string, string>;
     plugins?: string[];
+    filePatterns?: string[];
     dryRun?: boolean;
     allowMissing?: boolean;
     verbose?: boolean;

package/dist/api.js

@@ -8,6 +8,7 @@ import { scaffoldProject } from "./scaffold.js";
 import { recipeSchema } from "./schema.js";
 function normalizeCookOptions(options) {
     const plugins = Array.from(new Set((options.plugins ?? []).map((value) => value.trim()).filter((value) => value.length > 0)));
+    const filePatterns = Array.from(new Set((options.filePatterns ?? []).map((value) => value.trim()).filter((value) => value.length > 0)));
     const scope = options.scope ?? "full";
     const workspaceName = options.workspaceName?.trim() || undefined;
     if (scope === "workspace" && !workspaceName) {
@@ -16,9 +17,13 @@ function normalizeCookOptions(options) {
     if (scope !== "workspace" && workspaceName) {
         throw new ClawChefError("workspaceName is only allowed when scope=workspace");
     }
+    if (scope !== "files" && filePatterns.length > 0) {
+        throw new ClawChefError("filePatterns is only allowed when scope=files");
+    }
     return {
         vars: options.vars ?? {},
         plugins,
+        filePatterns,
         scope,
         workspaceName,
         gatewayMode: options.gatewayMode ?? "service",

package/dist/cli.js

@@ -41,6 +41,9 @@ function parseVarFlags(values) {
 function parsePluginFlags(values) {
     return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
+function parseFileFlags(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
 function readEnv(name) {
     const value = process.env[name];
     if (value === undefined) {
@@ -56,10 +59,10 @@ function parseProvider(value) {
     throw new ClawChefError(`Invalid --provider value: ${value}. Expected command, remote, or mock`);
 }
 function parseScope(value) {
-    if (value === "full" || value === "files" || value === "workspace") {
+    if (value === "full" || value === "stateful" || value === "files" || value === "workspace") {
         return value;
     }
-    throw new ClawChefError(`Invalid --scope value: ${value}. Expected full, files, or workspace`);
+    throw new ClawChefError(`Invalid --scope value: ${value}. Expected full, stateful, files, or workspace`);
 }
 function parseGatewayMode(value) {
     if (value === "service" || value === "run" || value === "none") {
@@ -105,7 +108,8 @@ export function buildCli() {
         .option("--allow-missing", "Allow unresolved template variables", false)
         .option("--verbose", "Verbose logging", false)
         .option("-s, --silent", "Skip reset confirmation prompt", false)
-        .option("--scope <scope>", "Run scope: full | files | workspace", "full")
+        .option("--scope <scope>", "Run scope: full | stateful | files | workspace", "full")
+        .option("--file <pattern>", "File pattern filter (only with --scope files, repeatable)", (v, p) => p.concat([v]), [])
         .option("--workspace <name>", "Workspace name (required when --scope workspace)")
         .option("--gateway-mode <mode>", "Gateway mode: service | run | none", "service")
         .option("--dotenv-ref <path-or-url>", "Load env vars from local file or HTTP URL")
@@ -127,6 +131,7 @@ export function buildCli() {
         const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
         const scope = parseScope(String(opts.scope ?? "full"));
         const gatewayMode = parseGatewayMode(String(opts.gatewayMode ?? "service"));
+        const filePatterns = parseFileFlags(opts.file);
         const workspaceName = opts.workspace?.trim() ? String(opts.workspace).trim() : undefined;
         if (scope === "workspace" && !workspaceName) {
             throw new ClawChefError("--scope workspace requires --workspace <name>");
@@ -134,9 +139,13 @@ export function buildCli() {
         if (scope !== "workspace" && workspaceName) {
             throw new ClawChefError("--workspace is only allowed when --scope workspace");
         }
+        if (scope !== "files" && filePatterns.length > 0) {
+            throw new ClawChefError("--file is only allowed when --scope files");
+        }
         const options = {
             vars: parseVarFlags(opts.var),
             plugins: parsePluginFlags(opts.plugin),
+            filePatterns,
             scope,
             workspaceName,
             gatewayMode,

package/dist/logger.d.ts

@@ -1,6 +1,7 @@
 export declare class Logger {
     private readonly verboseEnabled;
     constructor(verboseEnabled: boolean);
+    private timestamp;
     info(message: string): void;
     warn(message: string): void;
     debug(message: string): void;

package/dist/logger.js

@@ -3,15 +3,25 @@ export class Logger {
     constructor(verboseEnabled) {
         this.verboseEnabled = verboseEnabled;
     }
+    timestamp() {
+        const now = new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, "0");
+        const day = String(now.getDate()).padStart(2, "0");
+        const hours = String(now.getHours()).padStart(2, "0");
+        const minutes = String(now.getMinutes()).padStart(2, "0");
+        const seconds = String(now.getSeconds()).padStart(2, "0");
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+    }
     info(message) {
-        process.stdout.write(`[INFO] ${message}\n`);
+        process.stdout.write(`[${this.timestamp()}] [INFO] ${message}\n`);
     }
     warn(message) {
-        process.stdout.write(`[WARN] ${message}\n`);
+        process.stdout.write(`[${this.timestamp()}] [WARN] ${message}\n`);
     }
     debug(message) {
         if (this.verboseEnabled) {
-            process.stdout.write(`[DEBUG] ${message}\n`);
+            process.stdout.write(`[${this.timestamp()}] [DEBUG] ${message}\n`);
         }
     }
 }

package/dist/openclaw/command-provider.d.ts

@@ -1,13 +1,17 @@
 import type { AgentDef, ChannelDef, ConversationDef, GatewayMode, OpenClawSection } from "../types.js";
-import type { EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from "./provider.js";
+import type { ChannelAgentBinding, EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from "./provider.js";
 export declare class CommandOpenClawProvider implements OpenClawProvider {
     private readonly stagedMessages;
+    private readonly enabledChannelPlugins;
+    constructor(verboseEnabled?: boolean);
     ensureVersion(config: OpenClawSection, dryRun: boolean, silent: boolean, preserveExistingState: boolean): Promise<EnsureVersionResult>;
     factoryReset(config: OpenClawSection, dryRun: boolean): Promise<void>;
     installPlugin(config: OpenClawSection, pluginSpec: string, dryRun: boolean): Promise<void>;
     startGateway(config: OpenClawSection, mode: GatewayMode, dryRun: boolean): Promise<void>;
     createWorkspace(config: OpenClawSection, workspace: ResolvedWorkspaceDef, dryRun: boolean): Promise<void>;
     configureChannel(config: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void>;
+    applyConfigPatch(config: OpenClawSection, patch: Record<string, unknown>, dryRun: boolean): Promise<void>;
+    bindChannelAgents(config: OpenClawSection, bindingsInput: ChannelAgentBinding[], dryRun: boolean): Promise<void>;
     bindChannelAgent(config: OpenClawSection, channel: ChannelDef, agent: string, dryRun: boolean): Promise<void>;
     loginChannel(config: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void>;
     createAgent(config: OpenClawSection, agent: AgentDef, workspacePath: string, dryRun: boolean): Promise<void>;

package/dist/openclaw/command-provider.js

@@ -1,7 +1,7 @@
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
@@ -23,6 +23,23 @@ const DEFAULT_COMMANDS = {
     run_agent: "${bin} agent --local --agent ${agent} --message ${prompt_q} --json",
 };
 const SECRET_FLAG_RE = /(--[A-Za-z0-9-]*(?:api-key|token|password|secret)[A-Za-z0-9-]*\s+)(?:'[^']*'|"[^"]*"|\S+)/g;
+let TRACE_VERBOSE = false;
+function timestamp() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const seconds = String(now.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+function traceDebug(message) {
+    if (!TRACE_VERBOSE) {
+        return;
+    }
+    process.stdout.write(`[${timestamp()}] [DEBUG] ${message}\n`);
+}
 const AUTH_CHOICE_TO_LLM_FLAG = {
     "openai-api-key": "--openai-api-key",
     "anthropic-api-key": "--anthropic-api-key",
@@ -70,9 +87,13 @@ async function commandExists(bin) {
     }
 }
 async function runShell(command, dryRun, extraEnv) {
+    const sanitized = sanitizeCommand(command);
     if (dryRun) {
+        traceDebug(`CMD DRY-RUN: ${sanitized}`);
         return "";
     }
+    const startedAt = Date.now();
+    traceDebug(`CMD START: ${sanitized}`);
     return new Promise((resolve, reject) => {
         const child = spawn(command, {
             shell: true,
@@ -92,17 +113,23 @@ async function runShell(command, dryRun, extraEnv) {
         });
         child.on("close", (code) => {
             if (code === 0) {
+                traceDebug(`CMD DONE (${Date.now() - startedAt}ms): ${sanitized}`);
                 resolve(stdout.trim());
                 return;
             }
+            traceDebug(`CMD FAIL (${Date.now() - startedAt}ms) code=${String(code)}: ${sanitized}`);
             reject(new ClawChefError(`Command failed (${code}): ${sanitizeCommand(command)}\n${stderr.trim()}`));
         });
     });
 }
 async function runShellInteractive(command, dryRun) {
+    const sanitized = sanitizeCommand(command);
     if (dryRun) {
+        traceDebug(`CMD DRY-RUN (interactive): ${sanitized}`);
         return;
     }
+    const startedAt = Date.now();
+    traceDebug(`CMD START (interactive): ${sanitized}`);
     return new Promise((resolve, reject) => {
         const child = spawn(command, {
             shell: true,
@@ -114,9 +141,11 @@ async function runShellInteractive(command, dryRun) {
         });
         child.on("close", (code) => {
             if (code === 0) {
+                traceDebug(`CMD DONE (interactive, ${Date.now() - startedAt}ms): ${sanitized}`);
                 resolve();
                 return;
             }
+            traceDebug(`CMD FAIL (interactive, ${Date.now() - startedAt}ms) code=${String(code)}: ${sanitized}`);
             reject(new ClawChefError(`Command failed (${code}): ${sanitizeCommand(command)}`));
         });
     });
@@ -151,6 +180,158 @@ function shouldAutoDisableTelegramChannel(channel) {
     const emptyBotToken = channel.bot_token !== undefined && channel.bot_token.trim().length === 0;
     return emptyToken || emptyBotToken;
 }
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function splitConfigPath(pathExpression) {
+    const segments = [];
+    let token = "";
+    for (let i = 0; i < pathExpression.length; i += 1) {
+        const ch = pathExpression[i];
+        if (ch === ".") {
+            if (token) {
+                segments.push(token);
+                token = "";
+            }
+            continue;
+        }
+        if (ch === "[") {
+            if (token) {
+                segments.push(token);
+                token = "";
+            }
+            const end = pathExpression.indexOf("]", i + 1);
+            if (end < 0) {
+                throw new ClawChefError(`Invalid config path expression: ${pathExpression}`);
+            }
+            const bracketToken = pathExpression.slice(i + 1, end).trim();
+            if (!bracketToken) {
+                throw new ClawChefError(`Invalid empty bracket token in config path: ${pathExpression}`);
+            }
+            segments.push(bracketToken);
+            i = end;
+            continue;
+        }
+        token += ch;
+    }
+    if (token) {
+        segments.push(token);
+    }
+    if (segments.length === 0) {
+        throw new ClawChefError(`Invalid config path expression: ${pathExpression}`);
+    }
+    return segments;
+}
+function getConfigValue(root, pathExpression) {
+    const segments = splitConfigPath(pathExpression);
+    let cursor = root;
+    for (const segment of segments) {
+        if (!isPlainObject(cursor)) {
+            return undefined;
+        }
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+function setConfigValue(root, pathExpression, value) {
+    const segments = splitConfigPath(pathExpression);
+    let cursor = root;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+        const segment = segments[i];
+        const existing = cursor[segment];
+        if (isPlainObject(existing)) {
+            cursor = existing;
+            continue;
+        }
+        const next = {};
+        cursor[segment] = next;
+        cursor = next;
+    }
+    cursor[segments[segments.length - 1]] = value;
+}
+function deepMergeConfig(base, patch) {
+    if (!isPlainObject(patch)) {
+        return patch;
+    }
+    const baseObject = isPlainObject(base) ? base : {};
+    const result = {};
+    for (const [k, v] of Object.entries(baseObject)) {
+        result[k] = toJsonPatchValue(v, `base.${k}`);
+    }
+    for (const [k, v] of Object.entries(patch)) {
+        const current = result[k];
+        if (isPlainObject(v) && isPlainObject(current)) {
+            result[k] = deepMergeConfig(current, v);
+        }
+        else {
+            result[k] = v;
+        }
+    }
+    return result;
+}
+function configPath() {
+    const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    return path.join(homedir(), ".openclaw", "openclaw.json");
+}
+async function loadConfigJson(configFilePath) {
+    let raw;
+    try {
+        raw = await readFile(configFilePath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ClawChefError(`Failed to read OpenClaw config at ${configFilePath}: ${message}`);
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isPlainObject(parsed)) {
+            throw new ClawChefError(`OpenClaw config root must be an object: ${configFilePath}`);
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err instanceof ClawChefError) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ClawChefError(`Failed to parse OpenClaw config JSON at ${configFilePath}: ${message}`);
+    }
+}
+async function saveConfigJson(configFilePath, config, dryRun) {
+    if (dryRun) {
+        traceDebug(`CONFIG DRY-RUN write: ${configFilePath}`);
+        return;
+    }
+    const dir = path.dirname(configFilePath);
+    await mkdir(dir, { recursive: true });
+    const tempPath = `${configFilePath}.tmp-${process.pid}-${Date.now()}`;
+    const payload = `${JSON.stringify(config, null, 2)}\n`;
+    await writeFile(tempPath, payload, "utf8");
+    await rename(tempPath, configFilePath);
+    traceDebug(`CONFIG WRITE: ${configFilePath}`);
+}
+function toJsonPatchValue(value, pathLabel) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => toJsonPatchValue(item, `${pathLabel}[${index}]`));
+    }
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = toJsonPatchValue(v, `${pathLabel}.${k}`);
+        }
+        return out;
+    }
+    throw new ClawChefError(`openclaw.config_patch contains unsupported value at ${pathLabel}`);
+}
 async function chooseVersionMismatchAction(currentVersion, expectedVersion, silent) {
     if (silent) {
         return "force";
@@ -265,24 +446,21 @@ function isAccountLevelBinding(item, channel, account) {
         && match.teamId === undefined
         && match.roles === undefined);
 }
-function parseBindingsJson(raw) {
-    if (!raw.trim()) {
+function parseBindingsValue(value) {
+    if (value === undefined || value === null) {
         return [];
     }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed)) {
-            throw new ClawChefError("openclaw config bindings is not an array");
-        }
-        return parsed;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new ClawChefError(`Failed to parse openclaw bindings JSON: ${message}`);
+    if (!Array.isArray(value)) {
+        throw new ClawChefError("openclaw config bindings is not an array");
     }
+    return value;
 }
 export class CommandOpenClawProvider {
     stagedMessages = new Map();
+    enabledChannelPlugins = new Set();
+    constructor(verboseEnabled = false) {
+        TRACE_VERBOSE = verboseEnabled;
+    }
     async ensureVersion(config, dryRun, silent, preserveExistingState) {
         const bin = config.bin ?? "openclaw";
         const installPolicy = config.install ?? "auto";
@@ -418,14 +596,15 @@ export class CommandOpenClawProvider {
     }
     async configureChannel(config, channel, dryRun) {
         const bin = config.bin ?? "openclaw";
+        const cfgPath = configPath();
         if (shouldAutoDisableTelegramChannel(channel)) {
-            const enabledPath = telegramEnabledPath(channel.account);
-            const disableCmd = `${bin} config set ${shellQuote(enabledPath)} false --strict-json`;
-            await runShell(disableCmd, dryRun);
+            const openclawConfig = await loadConfigJson(cfgPath);
+            setConfigValue(openclawConfig, telegramEnabledPath(channel.account), false);
+            await saveConfigJson(cfgPath, openclawConfig, dryRun);
             return;
         }
         const enablePluginTemplate = config.commands?.enable_plugin;
-        if (enablePluginTemplate?.trim()) {
+        if (enablePluginTemplate?.trim() && !this.enabledChannelPlugins.has(channel.channel)) {
             const enablePluginCmd = fillTemplate(enablePluginTemplate, {
                 bin,
                 version: config.version,
@@ -435,6 +614,10 @@ export class CommandOpenClawProvider {
             if (enablePluginCmd.trim()) {
                 await runShell(enablePluginCmd, dryRun);
             }
+            this.enabledChannelPlugins.add(channel.channel);
+        }
+        else if (enablePluginTemplate?.trim()) {
+            traceDebug(`Skip plugin enable for channel=${channel.channel}; already enabled in this run`);
         }
         const flags = [
             "--channel",
@@ -475,11 +658,60 @@ export class CommandOpenClawProvider {
         const cmd = `${bin} channels add ${flags.join(" ")}`;
         await runShell(cmd, dryRun);
         if (channel.channel === "telegram" && channel.group_policy) {
-            const configPath = telegramGroupPolicyPath(channel.account);
-            const policyValue = JSON.stringify(channel.group_policy);
-            const setPolicyCmd = `${bin} config set ${shellQuote(configPath)} ${shellQuote(policyValue)} --strict-json`;
-            await runShell(setPolicyCmd, dryRun);
+            const openclawConfig = await loadConfigJson(cfgPath);
+            setConfigValue(openclawConfig, telegramGroupPolicyPath(channel.account), channel.group_policy);
+            await saveConfigJson(cfgPath, openclawConfig, dryRun);
+        }
+    }
+    async applyConfigPatch(config, patch, dryRun) {
+        const normalized = toJsonPatchValue(patch, "openclaw.config_patch");
+        if (!isPlainObject(normalized)) {
+            throw new ClawChefError("openclaw.config_patch must be an object");
+        }
+        const cfgPath = configPath();
+        const openclawConfig = await loadConfigJson(cfgPath);
+        const merged = deepMergeConfig(openclawConfig, normalized);
+        if (!isPlainObject(merged)) {
+            throw new ClawChefError("Merged OpenClaw config must be an object");
         }
+        await saveConfigJson(cfgPath, merged, dryRun);
+    }
+    async bindChannelAgents(config, bindingsInput, dryRun) {
+        if (bindingsInput.length === 0) {
+            return;
+        }
+        const customTemplate = config.commands?.bind_channel_agent;
+        if (customTemplate?.trim()) {
+            for (const binding of bindingsInput) {
+                await this.bindChannelAgent(config, binding.channel, binding.agent, dryRun);
+            }
+            return;
+        }
+        const cfgPath = configPath();
+        const openclawConfig = await loadConfigJson(cfgPath);
+        const bindings = parseBindingsValue(getConfigValue(openclawConfig, "bindings"));
+        for (const binding of bindingsInput) {
+            const account = binding.channel.account?.trim();
+            if (!account) {
+                throw new ClawChefError(`Channel ${binding.channel.channel} requires account for agent binding`);
+            }
+            const nextBinding = {
+                agentId: binding.agent,
+                match: {
+                    channel: binding.channel.channel,
+                    accountId: account,
+                },
+            };
+            const index = bindings.findIndex((item) => isAccountLevelBinding(item, binding.channel.channel, account));
+            if (index >= 0) {
+                bindings[index] = nextBinding;
+            }
+            else {
+                bindings.push(nextBinding);
+            }
+        }
+        setConfigValue(openclawConfig, "bindings", bindings);
+        await saveConfigJson(cfgPath, openclawConfig, dryRun);
     }
     async bindChannelAgent(config, channel, agent, dryRun) {
         const account = channel.account?.trim();
@@ -504,29 +736,7 @@ export class CommandOpenClawProvider {
             }
             return;
         }
-        if (dryRun) {
-            return;
-        }
-        const getCmd = `${bin} config get bindings --json 2>/dev/null || printf '[]'`;
-        const rawBindings = await runShell(getCmd, false);
-        const bindings = parseBindingsJson(rawBindings);
-        const nextBinding = {
-            agentId: agent,
-            match: {
-                channel: channel.channel,
-                accountId: account,
-            },
-        };
-        const index = bindings.findIndex((item) => isAccountLevelBinding(item, channel.channel, account));
-        if (index >= 0) {
-            bindings[index] = nextBinding;
-        }
-        else {
-            bindings.push(nextBinding);
-        }
-        const json = JSON.stringify(bindings);
-        const setCmd = `${bin} config set bindings ${shellQuote(json)} --json`;
-        await runShell(setCmd, false);
+        await this.bindChannelAgents(config, [{ channel, agent }], dryRun);
     }
     async loginChannel(config, channel, dryRun) {
         if (!channel.login) {

package/dist/openclaw/factory.js

@@ -7,7 +7,7 @@ export function createProvider(options) {
         return new MockOpenClawProvider();
     }
     if (provider === "remote") {
-        return new RemoteOpenClawProvider(options.remote);
+        return new RemoteOpenClawProvider(options.remote, options.verbose);
     }
-    return new CommandOpenClawProvider();
+    return new CommandOpenClawProvider(options.verbose);
 }

package/dist/openclaw/mock-provider.d.ts

@@ -8,6 +8,7 @@ export declare class MockOpenClawProvider implements OpenClawProvider {
     startGateway(_config: OpenClawSection, _mode: GatewayMode, _dryRun: boolean): Promise<void>;
     createWorkspace(_config: OpenClawSection, workspace: ResolvedWorkspaceDef, _dryRun: boolean): Promise<void>;
     configureChannel(_config: OpenClawSection, channel: ChannelDef, _dryRun: boolean): Promise<void>;
+    applyConfigPatch(_config: OpenClawSection, _patch: Record<string, unknown>, _dryRun: boolean): Promise<void>;
     bindChannelAgent(_config: OpenClawSection, _channel: ChannelDef, _agent: string, _dryRun: boolean): Promise<void>;
     loginChannel(_config: OpenClawSection, _channel: ChannelDef, _dryRun: boolean): Promise<void>;
     createAgent(_config: OpenClawSection, agent: AgentDef, _workspacePath: string, _dryRun: boolean): Promise<void>;

package/dist/openclaw/mock-provider.js

@@ -44,6 +44,9 @@ export class MockOpenClawProvider {
     async configureChannel(_config, channel, _dryRun) {
         this.state.channels.add(`${channel.channel}::${channel.account ?? "default"}`);
     }
+    async applyConfigPatch(_config, _patch, _dryRun) {
+        return;
+    }
     async bindChannelAgent(_config, _channel, _agent, _dryRun) {
         return;
     }