clawchef 0.1.11 → 0.1.13

package/src/api.ts

@@ -12,6 +12,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;
@@ -27,6 +28,9 @@ export interface CookOptions {
 
 function normalizeCookOptions(options: CookOptions): RunOptions {
   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) {
@@ -35,9 +39,13 @@ function normalizeCookOptions(options: CookOptions): RunOptions {
   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/src/cli.ts

@@ -45,6 +45,10 @@ function parsePluginFlags(values: string[]): string[] {
   return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
 
+function parseFileFlags(values: string[]): string[] {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+
 function readEnv(name: string): string | undefined {
   const value = process.env[name];
   if (value === undefined) {
@@ -62,10 +66,10 @@ function parseProvider(value: string): "command" | "mock" | "remote" {
 }
 
 function parseScope(value: string): RunScope {
-  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: string): GatewayMode {
@@ -117,7 +121,8 @@ export function buildCli(): Command {
     .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: string[]) => 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")
@@ -139,6 +144,7 @@ export function buildCli(): Command {
       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>");
@@ -146,9 +152,13 @@ export function buildCli(): Command {
       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: RunOptions = {
         vars: parseVarFlags(opts.var),
         plugins: parsePluginFlags(opts.plugin),
+        filePatterns,
         scope,
         workspaceName,
         gatewayMode,

package/src/logger.ts

@@ -1,17 +1,28 @@
 export class Logger {
   constructor(private readonly verboseEnabled: boolean) {}
 
+  private timestamp(): string {
+    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: string): void {
-    process.stdout.write(`[INFO] ${message}\n`);
+    process.stdout.write(`[${this.timestamp()}] [INFO] ${message}\n`);
   }
 
   warn(message: string): void {
-    process.stdout.write(`[WARN] ${message}\n`);
+    process.stdout.write(`[${this.timestamp()}] [WARN] ${message}\n`);
   }
 
   debug(message: string): void {
     if (this.verboseEnabled) {
-      process.stdout.write(`[DEBUG] ${message}\n`);
+      process.stdout.write(`[${this.timestamp()}] [DEBUG] ${message}\n`);
     }
   }
 }

package/src/openclaw/command-provider.ts

@@ -1,13 +1,13 @@
 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";
 import { ClawChefError } from "../errors.js";
 import type { AgentDef, ChannelDef, ConversationDef, GatewayMode, OpenClawBootstrap, OpenClawSection } from "../types.js";
-import type { EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from "./provider.js";
+import type { ChannelAgentBinding, EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from "./provider.js";
 
 const DEFAULT_COMMANDS = {
   use_version: "${bin} --version",
@@ -50,6 +50,26 @@ interface BindingItem {
 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(): string {
+  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: string): void {
+  if (!TRACE_VERBOSE) {
+    return;
+  }
+  process.stdout.write(`[${timestamp()}] [DEBUG] ${message}\n`);
+}
+
 type BootstrapStringField =
   | "cloudflare_ai_gateway_account_id"
   | "cloudflare_ai_gateway_gateway_id"
@@ -111,10 +131,15 @@ async function commandExists(bin: string): Promise<boolean> {
 }
 
 async function runShell(command: string, dryRun: boolean, extraEnv?: Record<string, string>): Promise<string> {
+  const sanitized = sanitizeCommand(command);
   if (dryRun) {
+    traceDebug(`CMD DRY-RUN: ${sanitized}`);
     return "";
   }
 
+  const startedAt = Date.now();
+  traceDebug(`CMD START: ${sanitized}`);
+
   return new Promise<string>((resolve, reject) => {
     const child = spawn(command, {
       shell: true,
@@ -135,19 +160,26 @@ async function runShell(command: string, dryRun: boolean, extraEnv?: Record<stri
     });
     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: string, dryRun: boolean): Promise<void> {
+  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<void>((resolve, reject) => {
     const child = spawn(command, {
       shell: true,
@@ -160,9 +192,11 @@ async function runShellInteractive(command: string, dryRun: boolean): Promise<vo
     });
     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)}`));
     });
   });
@@ -186,8 +220,196 @@ function telegramGroupPolicyPath(account: string | undefined): string {
   return `channels.telegram.accounts[${trimmed}].groupPolicy`;
 }
 
+function telegramEnabledPath(account: string | undefined): string {
+  const trimmed = account?.trim();
+  if (!trimmed) {
+    return "channels.telegram.enabled";
+  }
+  return `channels.telegram.accounts[${trimmed}].enabled`;
+}
+
+function shouldAutoDisableTelegramChannel(channel: ChannelDef): boolean {
+  if (channel.channel !== "telegram") {
+    return false;
+  }
+  const emptyToken = channel.token !== undefined && channel.token.trim().length === 0;
+  const emptyBotToken = channel.bot_token !== undefined && channel.bot_token.trim().length === 0;
+  return emptyToken || emptyBotToken;
+}
+
 type VersionMismatchChoice = "ignore" | "abort" | "force";
 
+type JsonPatchValue = null | boolean | number | string | JsonPatchValue[] | { [key: string]: JsonPatchValue };
+type ConfigJson = { [key: string]: unknown };
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function splitConfigPath(pathExpression: string): string[] {
+  const segments: string[] = [];
+  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: unknown, pathExpression: string): unknown {
+  const segments = splitConfigPath(pathExpression);
+  let cursor: unknown = root;
+  for (const segment of segments) {
+    if (!isPlainObject(cursor)) {
+      return undefined;
+    }
+    cursor = (cursor as Record<string, unknown>)[segment];
+  }
+  return cursor;
+}
+
+function setConfigValue(root: ConfigJson, pathExpression: string, value: unknown): void {
+  const segments = splitConfigPath(pathExpression);
+  let cursor: Record<string, unknown> = 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: Record<string, unknown> = {};
+    cursor[segment] = next;
+    cursor = next;
+  }
+
+  cursor[segments[segments.length - 1]] = value;
+}
+
+function deepMergeConfig(base: unknown, patch: JsonPatchValue): JsonPatchValue {
+  if (!isPlainObject(patch)) {
+    return patch;
+  }
+
+  const baseObject = isPlainObject(base) ? base : {};
+  const result: Record<string, JsonPatchValue> = {};
+
+  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(): string {
+  const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  return path.join(homedir(), ".openclaw", "openclaw.json");
+}
+
+async function loadConfigJson(configFilePath: string): Promise<ConfigJson> {
+  let raw: string;
+  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) as unknown;
+    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: string, config: ConfigJson, dryRun: boolean): Promise<void> {
+  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: unknown, pathLabel: string): JsonPatchValue {
+  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: { [key: string]: JsonPatchValue } = {};
+    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: string,
   expectedVersion: string,
@@ -321,24 +543,23 @@ function isAccountLevelBinding(item: BindingItem, channel: string, account: stri
   );
 }
 
-function parseBindingsJson(raw: string): BindingItem[] {
-  if (!raw.trim()) {
+function parseBindingsValue(value: unknown): BindingItem[] {
+  if (value === undefined || value === null) {
     return [];
   }
-  try {
-    const parsed = JSON.parse(raw) as unknown;
-    if (!Array.isArray(parsed)) {
-      throw new ClawChefError("openclaw config bindings is not an array");
-    }
-    return parsed as BindingItem[];
-  } 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 as BindingItem[];
 }
 
 export class CommandOpenClawProvider implements OpenClawProvider {
   private readonly stagedMessages = new Map<string, StagedMessage[]>();
+  private readonly enabledChannelPlugins = new Set<string>();
+
+  constructor(verboseEnabled = false) {
+    TRACE_VERBOSE = verboseEnabled;
+  }
 
   async ensureVersion(
     config: OpenClawSection,
@@ -510,8 +731,17 @@ export class CommandOpenClawProvider implements OpenClawProvider {
 
   async configureChannel(config: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void> {
     const bin = config.bin ?? "openclaw";
+    const cfgPath = configPath();
+
+    if (shouldAutoDisableTelegramChannel(channel)) {
+      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,
@@ -521,6 +751,9 @@ export class CommandOpenClawProvider implements OpenClawProvider {
       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: string[] = [
@@ -568,13 +801,70 @@ export class CommandOpenClawProvider implements OpenClawProvider {
     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: OpenClawSection, patch: Record<string, unknown>, dryRun: boolean): Promise<void> {
+    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: OpenClawSection, bindingsInput: ChannelAgentBinding[], dryRun: boolean): Promise<void> {
+    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: BindingItem = {
+        agentId: binding.agent,
+        match: {
+          channel: binding.channel.channel,
+          accountId: account,
+        },
+      };
+
+      const index = bindings.findIndex((item: BindingItem) => 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: OpenClawSection, channel: ChannelDef, agent: string, dryRun: boolean): Promise<void> {
     const account = channel.account?.trim();
     if (!account) {
@@ -600,31 +890,7 @@ export class CommandOpenClawProvider implements OpenClawProvider {
       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: BindingItem = {
-      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: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void> {

package/src/openclaw/factory.ts

@@ -10,7 +10,7 @@ export function createProvider(options: RunOptions): OpenClawProvider {
     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/src/openclaw/mock-provider.ts

@@ -69,6 +69,10 @@ export class MockOpenClawProvider implements OpenClawProvider {
     this.state.channels.add(`${channel.channel}::${channel.account ?? "default"}`);
   }
 
+  async applyConfigPatch(_config: OpenClawSection, _patch: Record<string, unknown>, _dryRun: boolean): Promise<void> {
+    return;
+  }
+
   async bindChannelAgent(
     _config: OpenClawSection,
     _channel: ChannelDef,

package/src/openclaw/provider.ts

@@ -6,6 +6,11 @@ export interface EnsureVersionResult {
   installedThisRun: boolean;
 }
 
+export interface ChannelAgentBinding {
+  channel: ChannelDef;
+  agent: string;
+}
+
 export interface OpenClawProvider {
   ensureVersion(
     config: OpenClawSection,
@@ -18,6 +23,8 @@ export interface 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>;
+  bindChannelAgents?(config: OpenClawSection, bindings: 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>;
   materializeFile?(