clawchef 0.1.6 → 0.1.8

package/recipes/sample.yaml

@@ -15,6 +15,12 @@ openclaw:
 
 workspaces:
   - name: "${project_name}"
+    files:
+      - path: "README.md"
+        overwrite: true
+        content: |
+          # ${project_name}
+          Generated by clawchef.
 
 channels:
   - channel: "telegram"
@@ -27,14 +33,6 @@ agents:
     model: "gpt-5.3-codex"
     skills: ["repo-explore", "code-review"]
 
-files:
-  - workspace: "${project_name}"
-    path: "README.md"
-    overwrite: true
-    content: |
-      # ${project_name}
-      Generated by clawchef.
-
 conversations:
   - workspace: "${project_name}"
     agent: "planner"

package/recipes/snippets/readme-template.md

@@ -1,3 +1,5 @@
-# content-from-demo
+# ${project_name}
 
 This content is loaded from a referenced file.
+
+Assigned agent: ${agent_name}

package/src/api.ts

@@ -6,7 +6,7 @@ import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
 import { scaffoldProject } from "./scaffold.js";
 import { recipeSchema } from "./schema.js";
-import type { OpenClawProvider, OpenClawRemoteConfig, RunOptions } from "./types.js";
+import type { OpenClawProvider, OpenClawRemoteConfig, RunOptions, RunScope } from "./types.js";
 import type { ScaffoldOptions, ScaffoldResult } from "./scaffold.js";
 
 export interface CookOptions {
@@ -16,6 +16,8 @@ export interface CookOptions {
   allowMissing?: boolean;
   verbose?: boolean;
   silent?: boolean;
+  scope?: RunScope;
+  workspaceName?: string;
   provider?: OpenClawProvider;
   remote?: Partial<OpenClawRemoteConfig>;
   envFile?: string;
@@ -24,14 +26,23 @@ 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 scope = options.scope ?? "full";
+  const workspaceName = options.workspaceName?.trim() || undefined;
+  if (scope === "workspace" && !workspaceName) {
+    throw new ClawChefError("scope=workspace requires workspaceName");
+  }
+  if (scope !== "workspace" && workspaceName) {
+    throw new ClawChefError("workspaceName is only allowed when scope=workspace");
+  }
   return {
     vars: options.vars ?? {},
     plugins,
+    scope,
+    workspaceName,
     dryRun: Boolean(options.dryRun),
     allowMissing: Boolean(options.allowMissing),
     verbose: Boolean(options.verbose),
     silent: options.silent ?? true,
-    keepOpenClawState: false,
     provider: options.provider ?? "command",
     remote: options.remote ?? {},
   };

package/src/cli.ts

@@ -6,12 +6,27 @@ import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
 import { recipeSchema } from "./schema.js";
 import { scaffoldProject } from "./scaffold.js";
-import type { RunOptions } from "./types.js";
+import type { RunOptions, RunScope } from "./types.js";
 import YAML from "js-yaml";
 import path from "node:path";
+import { readFileSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 
+function readPackageVersion(): string {
+  try {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const content = readFileSync(pkgPath, "utf8");
+    const parsed = JSON.parse(content) as { version?: string };
+    if (parsed.version?.trim()) {
+      return parsed.version;
+    }
+  } catch {
+    // ignore and use fallback
+  }
+  return "0.0.0";
+}
+
 function parseVarFlags(values: string[]): Record<string, string> {
   const out: Record<string, string> = {};
   for (const item of values) {
@@ -46,6 +61,13 @@ function parseProvider(value: string): "command" | "mock" | "remote" {
   throw new ClawChefError(`Invalid --provider value: ${value}. Expected command, remote, or mock`);
 }
 
+function parseScope(value: string): RunScope {
+  if (value === "full" || value === "files" || value === "workspace") {
+    return value;
+  }
+  throw new ClawChefError(`Invalid --scope value: ${value}. Expected full, files, or workspace`);
+}
+
 function parseOptionalInt(value: string | undefined, fieldName: string): number | undefined {
   if (value === undefined) {
     return undefined;
@@ -78,7 +100,7 @@ export function buildCli(): Command {
   program
     .name("clawchef")
     .description("Run OpenClaw environment recipes")
-    .version("0.1.6");
+    .version(readPackageVersion());
 
   program
     .command("cook")
@@ -88,7 +110,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("--keep-openclaw-state", "Preserve existing OpenClaw state (skip factory reset)", false)
+    .option("--scope <scope>", "Run scope: full | files | workspace", "full")
+    .option("--workspace <name>", "Workspace name (required when --scope workspace)")
     .option("--dotenv-ref <path-or-url>", "Load env vars from local file or HTTP URL")
     .option("--provider <provider>", "Execution provider: command | remote | mock")
     .option("--plugin <npm-spec>", "Preinstall plugin package (repeatable)", (v, p: string[]) => p.concat([v]), [])
@@ -106,14 +129,23 @@ export function buildCli(): Command {
       }
 
       const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
+      const scope = parseScope(String(opts.scope ?? "full"));
+      const workspaceName = opts.workspace?.trim() ? String(opts.workspace).trim() : undefined;
+      if (scope === "workspace" && !workspaceName) {
+        throw new ClawChefError("--scope workspace requires --workspace <name>");
+      }
+      if (scope !== "workspace" && workspaceName) {
+        throw new ClawChefError("--workspace is only allowed when --scope workspace");
+      }
       const options: RunOptions = {
         vars: parseVarFlags(opts.var),
         plugins: parsePluginFlags(opts.plugin),
+        scope,
+        workspaceName,
         dryRun: Boolean(opts.dryRun),
         allowMissing: Boolean(opts.allowMissing),
         verbose: Boolean(opts.verbose),
         silent: Boolean(opts.silent),
-        keepOpenClawState: Boolean(opts.keepOpenclawState),
         provider,
         remote: {
           base_url: opts.remoteBaseUrl ?? readEnv("CLAWCHEF_REMOTE_BASE_URL"),

package/src/openclaw/command-provider.ts

@@ -17,6 +17,7 @@ const DEFAULT_COMMANDS = {
   factory_reset: "${bin} reset --scope full --yes --non-interactive",
   start_gateway: "${bin} gateway start",
   enable_plugin: "",
+  bind_channel_agent: "",
   login_channel: "${bin} channels login --channel ${channel_q}${account_arg}",
   create_agent:
     "${bin} agents add ${agent} --workspace ${workspace_path} --model ${model} --non-interactive --json",
@@ -31,31 +32,51 @@ interface StagedMessage {
   content: string;
 }
 
+interface BindingItem {
+  agentId?: unknown;
+  match?: {
+    channel?: unknown;
+    accountId?: unknown;
+    peer?: unknown;
+    parentPeer?: unknown;
+    guildId?: unknown;
+    teamId?: unknown;
+    roles?: unknown;
+  };
+  [key: string]: unknown;
+}
+
 const SECRET_FLAG_RE =
   /(--[A-Za-z0-9-]*(?:api-key|token|password|secret)[A-Za-z0-9-]*\s+)(?:'[^']*'|"[^"]*"|\S+)/g;
 
 type BootstrapStringField =
-  | "openai_api_key"
-  | "anthropic_api_key"
-  | "openrouter_api_key"
-  | "xai_api_key"
-  | "gemini_api_key"
-  | "ai_gateway_api_key"
-  | "cloudflare_ai_gateway_api_key"
   | "cloudflare_ai_gateway_account_id"
   | "cloudflare_ai_gateway_gateway_id"
   | "token"
   | "token_provider"
   | "token_profile_id";
 
+const AUTH_CHOICE_TO_LLM_FLAG: Record<string, string> = {
+  "openai-api-key": "--openai-api-key",
+  "anthropic-api-key": "--anthropic-api-key",
+  "openrouter-api-key": "--openrouter-api-key",
+  "xai-api-key": "--xai-api-key",
+  "gemini-api-key": "--gemini-api-key",
+  "ai-gateway-api-key": "--ai-gateway-api-key",
+  "cloudflare-ai-gateway-api-key": "--cloudflare-ai-gateway-api-key",
+};
+
+const AUTH_CHOICE_TO_LLM_ENV: Record<string, string> = {
+  "openai-api-key": "OPENAI_API_KEY",
+  "anthropic-api-key": "ANTHROPIC_API_KEY",
+  "openrouter-api-key": "OPENROUTER_API_KEY",
+  "xai-api-key": "XAI_API_KEY",
+  "gemini-api-key": "GEMINI_API_KEY",
+  "ai-gateway-api-key": "AI_GATEWAY_API_KEY",
+  "cloudflare-ai-gateway-api-key": "CLOUDFLARE_AI_GATEWAY_API_KEY",
+};
+
 const BOOTSTRAP_STRING_FLAGS: Array<[BootstrapStringField, string]> = [
-  ["openai_api_key", "--openai-api-key"],
-  ["anthropic_api_key", "--anthropic-api-key"],
-  ["openrouter_api_key", "--openrouter-api-key"],
-  ["xai_api_key", "--xai-api-key"],
-  ["gemini_api_key", "--gemini-api-key"],
-  ["ai_gateway_api_key", "--ai-gateway-api-key"],
-  ["cloudflare_ai_gateway_api_key", "--cloudflare-ai-gateway-api-key"],
   ["cloudflare_ai_gateway_account_id", "--cloudflare-ai-gateway-account-id"],
   ["cloudflare_ai_gateway_gateway_id", "--cloudflare-ai-gateway-gateway-id"],
   ["token", "--token"],
@@ -239,6 +260,13 @@ function buildBootstrapCommand(bin: string, bootstrap: OpenClawBootstrap | undef
     flags.push("--no-install-daemon");
   }
 
+  if (cfg.llm_api_key?.trim()) {
+    const llmFlag = AUTH_CHOICE_TO_LLM_FLAG[cfg.auth_choice ?? ""];
+    if (llmFlag) {
+      flags.push(`${llmFlag} ${shellQuote(cfg.llm_api_key)}`);
+    }
+  }
+
   for (const [field, flag] of BOOTSTRAP_STRING_FLAGS) {
     const value = cfg[field];
     if (value && value.trim()) {
@@ -257,19 +285,49 @@ function bootstrapRuntimeEnv(bootstrap: OpenClawBootstrap | undefined): Record<s
   }
   const env: Record<string, string> = {};
 
-  if (bootstrap.openai_api_key) env.OPENAI_API_KEY = bootstrap.openai_api_key;
-  if (bootstrap.anthropic_api_key) env.ANTHROPIC_API_KEY = bootstrap.anthropic_api_key;
-  if (bootstrap.openrouter_api_key) env.OPENROUTER_API_KEY = bootstrap.openrouter_api_key;
-  if (bootstrap.xai_api_key) env.XAI_API_KEY = bootstrap.xai_api_key;
-  if (bootstrap.gemini_api_key) env.GEMINI_API_KEY = bootstrap.gemini_api_key;
-  if (bootstrap.ai_gateway_api_key) env.AI_GATEWAY_API_KEY = bootstrap.ai_gateway_api_key;
-  if (bootstrap.cloudflare_ai_gateway_api_key) {
-    env.CLOUDFLARE_AI_GATEWAY_API_KEY = bootstrap.cloudflare_ai_gateway_api_key;
+  if (bootstrap.llm_api_key?.trim()) {
+    const envKey = AUTH_CHOICE_TO_LLM_ENV[bootstrap.auth_choice ?? ""];
+    if (envKey) {
+      env[envKey] = bootstrap.llm_api_key;
+    }
   }
 
   return env;
 }
 
+function isAccountLevelBinding(item: BindingItem, channel: string, account: string): boolean {
+  const match = item.match;
+  if (!match || typeof match !== "object") {
+    return false;
+  }
+  if (match.channel !== channel || match.accountId !== account) {
+    return false;
+  }
+  return (
+    match.peer === undefined
+    && match.parentPeer === undefined
+    && match.guildId === undefined
+    && match.teamId === undefined
+    && match.roles === undefined
+  );
+}
+
+function parseBindingsJson(raw: string): BindingItem[] {
+  if (!raw.trim()) {
+    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}`);
+  }
+}
+
 export class CommandOpenClawProvider implements OpenClawProvider {
   private readonly stagedMessages = new Map<string, StagedMessage[]>();
 
@@ -277,7 +335,7 @@ export class CommandOpenClawProvider implements OpenClawProvider {
     config: OpenClawSection,
     dryRun: boolean,
     silent: boolean,
-    keepOpenClawState: boolean,
+    preserveExistingState: boolean,
   ): Promise<EnsureVersionResult> {
     const bin = config.bin ?? "openclaw";
     const installPolicy = config.install ?? "auto";
@@ -343,7 +401,7 @@ export class CommandOpenClawProvider implements OpenClawProvider {
       );
     }
 
-    if (keepOpenClawState) {
+    if (preserveExistingState) {
       return { installedThisRun: false };
     }
 
@@ -492,6 +550,58 @@ export class CommandOpenClawProvider implements OpenClawProvider {
     await runShell(cmd, dryRun);
   }
 
+  async bindChannelAgent(config: OpenClawSection, channel: ChannelDef, agent: string, dryRun: boolean): Promise<void> {
+    const account = channel.account?.trim();
+    if (!account) {
+      throw new ClawChefError(`Channel ${channel.channel} requires account for agent binding`);
+    }
+
+    const bin = config.bin ?? "openclaw";
+    const customTemplate = config.commands?.bind_channel_agent;
+    if (customTemplate?.trim()) {
+      const customCmd = fillTemplate(customTemplate, {
+        bin,
+        version: config.version,
+        channel: channel.channel,
+        channel_q: shellQuote(channel.channel),
+        account,
+        account_q: shellQuote(account),
+        agent,
+        agent_q: shellQuote(agent),
+      });
+      if (customCmd.trim()) {
+        await runShell(customCmd, dryRun);
+      }
+      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);
+  }
+
   async loginChannel(config: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void> {
     if (!channel.login) {
       return;

package/src/openclaw/mock-provider.ts

@@ -25,7 +25,7 @@ export class MockOpenClawProvider implements OpenClawProvider {
     config: OpenClawSection,
     _dryRun: boolean,
     _silent: boolean,
-    _keepOpenClawState: boolean,
+    _preserveExistingState: boolean,
   ): Promise<EnsureVersionResult> {
     const policy = config.install ?? "auto";
     const installed = this.state.installedVersions.has(config.version);
@@ -69,6 +69,15 @@ export class MockOpenClawProvider implements OpenClawProvider {
     this.state.channels.add(`${channel.channel}::${channel.account ?? "default"}`);
   }
 
+  async bindChannelAgent(
+    _config: OpenClawSection,
+    _channel: ChannelDef,
+    _agent: string,
+    _dryRun: boolean,
+  ): Promise<void> {
+    return;
+  }
+
   async loginChannel(_config: OpenClawSection, _channel: ChannelDef, _dryRun: boolean): Promise<void> {
     return;
   }

package/src/openclaw/provider.ts

@@ -11,13 +11,14 @@ export interface OpenClawProvider {
     config: OpenClawSection,
     dryRun: boolean,
     silent: boolean,
-    keepOpenClawState: boolean,
+    preserveExistingState: boolean,
   ): Promise<EnsureVersionResult>;
   installPlugin(config: OpenClawSection, pluginSpec: string, dryRun: boolean): Promise<void>;
   factoryReset(config: OpenClawSection, dryRun: boolean): Promise<void>;
   startGateway(config: OpenClawSection, dryRun: boolean): Promise<void>;
   createWorkspace(config: OpenClawSection, workspace: ResolvedWorkspaceDef, dryRun: boolean): Promise<void>;
   configureChannel(config: OpenClawSection, channel: ChannelDef, 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?(
     config: OpenClawSection,

package/src/openclaw/remote-provider.ts

@@ -145,7 +145,7 @@ export class RemoteOpenClawProvider implements OpenClawProvider {
     config: OpenClawSection,
     dryRun: boolean,
     _silent: boolean,
-    _keepOpenClawState: boolean,
+    _preserveExistingState: boolean,
   ): Promise<EnsureVersionResult> {
     const result = await this.perform(
       config,
@@ -188,6 +188,19 @@ export class RemoteOpenClawProvider implements OpenClawProvider {
     await this.perform(config, "configure_channel", { channel }, dryRun);
   }
 
+  async bindChannelAgent(config: OpenClawSection, channel: ChannelDef, agent: string, dryRun: boolean): Promise<void> {
+    await this.perform(
+      config,
+      "bind_channel_agent",
+      {
+        channel: channel.channel,
+        account: channel.account,
+        agent,
+      },
+      dryRun,
+    );
+  }
+
   async loginChannel(config: OpenClawSection, channel: ChannelDef, dryRun: boolean): Promise<void> {
     await this.perform(config, "login_channel", { channel }, dryRun);
   }

package/src/orchestrator.ts

@@ -27,6 +27,26 @@ function truncateForLog(text: string, maxLength = 500): string {
   return `${text.slice(0, maxLength)}... [truncated ${text.length - maxLength} chars]`;
 }
 
+function renderTemplateString(input: string, vars: Record<string, string>, allowMissing: boolean): string {
+  return input.replace(/\$\{([^}]+)\}/g, (_match, rawKey: string) => {
+    const key = String(rawKey).trim();
+    if (!key) {
+      return "";
+    }
+    if (Object.prototype.hasOwnProperty.call(vars, key)) {
+      return vars[key] ?? "";
+    }
+    const lowerKey = key.toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(vars, lowerKey)) {
+      return vars[lowerKey] ?? "";
+    }
+    if (allowMissing) {
+      return `\${${key}}`;
+    }
+    throw new ClawChefError(`Missing template variable in file content: ${key}`);
+  });
+}
+
 function resolveWorkspacePath(recipeOrigin: RecipeOrigin, name: string, configuredPath?: string): string {
   if (configuredPath?.trim()) {
     if (path.isAbsolute(configuredPath)) {
@@ -146,19 +166,20 @@ export async function runRecipe(
   const provider = createProvider(options);
   const remoteMode = options.provider === "remote";
   const workspacePaths = new Map<string, string>();
+  const preserveExistingState = options.scope !== "full";
 
   logger.info(`Running recipe: ${recipe.name}`);
   const versionResult = await provider.ensureVersion(
     recipe.openclaw,
     options.dryRun,
     options.silent,
-    options.keepOpenClawState,
+    preserveExistingState,
   );
   logger.info(`OpenClaw version ready: ${recipe.openclaw.version}`);
 
   if (versionResult.installedThisRun) {
     logger.info("OpenClaw was installed in this run; skipping factory reset");
-  } else if (options.keepOpenClawState) {
+  } else if (preserveExistingState) {
     logger.info("Keeping existing OpenClaw state; skipping factory reset");
   } else {
     const confirmed = await confirmFactoryReset(options);
@@ -240,67 +261,81 @@ export async function runRecipe(
   }
 
   for (const channel of recipe.channels ?? []) {
-    await provider.configureChannel(recipe.openclaw, channel, options.dryRun);
-    logger.info(`Channel configured: ${channel.channel}${channel.account ? `/${channel.account}` : ""}`);
+    const effectiveChannel = channel.agent?.trim() && !channel.account?.trim()
+      ? { ...channel, account: channel.agent.trim() }
+      : channel;
+
+    await provider.configureChannel(recipe.openclaw, effectiveChannel, options.dryRun);
+    logger.info(`Channel configured: ${effectiveChannel.channel}${effectiveChannel.account ? `/${effectiveChannel.account}` : ""}`);
+    if (effectiveChannel.agent?.trim()) {
+      await provider.bindChannelAgent(recipe.openclaw, effectiveChannel, effectiveChannel.agent, options.dryRun);
+      logger.info(
+        `Channel bound to agent: ${effectiveChannel.channel}${effectiveChannel.account ? `/${effectiveChannel.account}` : ""} -> ${effectiveChannel.agent}`,
+      );
+    }
   }
 
-  for (const file of recipe.files ?? []) {
-    const wsPath = workspacePaths.get(file.workspace);
+  for (const workspace of recipe.workspaces ?? []) {
+    const wsPath = workspacePaths.get(workspace.name);
     if (!wsPath) {
-      throw new ClawChefError(`File target workspace does not exist: ${file.workspace}`);
+      throw new ClawChefError(`Workspace does not exist for files: ${workspace.name}`);
     }
 
-    if (provider.materializeFile) {
-      let content = file.content;
-      if (content === undefined && file.content_from) {
-        if (!options.dryRun) {
-          content = await readTextFromRef(recipeOrigin, file.content_from);
-        } else {
-          const resolved = resolveFileRef(recipeOrigin, file.content_from);
-          content = `__dry_run_content_from__:${resolved.value}`;
+    for (const file of workspace.files ?? []) {
+      if (provider.materializeFile) {
+        let content = file.content;
+        if (content === undefined && file.content_from) {
+          if (!options.dryRun) {
+            const rawContent = await readTextFromRef(recipeOrigin, file.content_from);
+            content = renderTemplateString(rawContent, options.vars, options.allowMissing);
+          } else {
+            const resolved = resolveFileRef(recipeOrigin, file.content_from);
+            content = `__dry_run_content_from__:${resolved.value}`;
+          }
         }
-      }
-      if (content === undefined && file.source) {
-        if (!options.dryRun) {
-          content = await readTextFromRef(recipeOrigin, file.source);
-        } else {
-          const resolved = resolveFileRef(recipeOrigin, file.source);
-          content = `__dry_run_source__:${resolved.value}`;
+        if (content === undefined && file.source) {
+          if (!options.dryRun) {
+            content = await readTextFromRef(recipeOrigin, file.source);
+          } else {
+            const resolved = resolveFileRef(recipeOrigin, file.source);
+            content = `__dry_run_source__:${resolved.value}`;
+          }
+        }
+        if (content === undefined) {
+          throw new ClawChefError(`File ${file.path} requires content, content_from, or source`);
         }
-      }
-      if (content === undefined) {
-        throw new ClawChefError(`File ${file.path} requires content, content_from, or source`);
-      }
 
-      await provider.materializeFile(recipe.openclaw, file.workspace, file.path, content, file.overwrite, options.dryRun);
-      logger.info(`File materialized: ${file.workspace}/${file.path}`);
-      continue;
-    }
+        await provider.materializeFile(recipe.openclaw, workspace.name, file.path, content, file.overwrite, options.dryRun);
+        logger.info(`File materialized: ${workspace.name}/${file.path}`);
+        continue;
+      }
 
-    const target = path.resolve(wsPath, file.path);
-    const targetDir = path.dirname(target);
-
-    if (!options.dryRun) {
-      await mkdir(targetDir, { recursive: true });
-      const alreadyExists = await exists(target);
-      if (alreadyExists && file.overwrite === false) {
-        logger.warn(`Skipping existing file: ${target}`);
-      } else if (file.content !== undefined) {
-        await writeFile(target, file.content, "utf8");
-      } else if (file.content_from) {
-        const content = await readTextFromRef(recipeOrigin, file.content_from);
-        await writeFile(target, content, "utf8");
-      } else if (file.source) {
-        const resolved = resolveFileRef(recipeOrigin, file.source);
-        if (resolved.kind === "local") {
-          await copyFile(resolved.value, target);
-        } else {
-          const content = await readBinaryFromRef(recipeOrigin, file.source);
-          await writeFile(target, content);
+      const target = path.resolve(wsPath, file.path);
+      const targetDir = path.dirname(target);
+
+      if (!options.dryRun) {
+        await mkdir(targetDir, { recursive: true });
+        const alreadyExists = await exists(target);
+        if (alreadyExists && file.overwrite === false) {
+          logger.warn(`Skipping existing file: ${target}`);
+        } else if (file.content !== undefined) {
+          await writeFile(target, file.content, "utf8");
+        } else if (file.content_from) {
+          const rawContent = await readTextFromRef(recipeOrigin, file.content_from);
+          const content = renderTemplateString(rawContent, options.vars, options.allowMissing);
+          await writeFile(target, content, "utf8");
+        } else if (file.source) {
+          const resolved = resolveFileRef(recipeOrigin, file.source);
+          if (resolved.kind === "local") {
+            await copyFile(resolved.value, target);
+          } else {
+            const content = await readBinaryFromRef(recipeOrigin, file.source);
+            await writeFile(target, content);
+          }
         }
       }
+      logger.info(`File materialized: ${workspace.name}/${file.path}`);
     }
-    logger.info(`File materialized: ${file.workspace}/${file.path}`);
   }
 
   for (const agent of recipe.agents ?? []) {
@@ -344,16 +379,19 @@ export async function runRecipe(
   logger.info("Gateway started");
 
   for (const channel of recipe.channels ?? []) {
-    if (!channel.login) {
+    const effectiveChannel = channel.agent?.trim() && !channel.account?.trim()
+      ? { ...channel, account: channel.agent.trim() }
+      : channel;
+    if (!effectiveChannel.login) {
       continue;
     }
     if (!options.dryRun && !input.isTTY) {
       throw new ClawChefError(
-        `Channel login for ${channel.channel} requires an interactive terminal session`,
+        `Channel login for ${effectiveChannel.channel} requires an interactive terminal session`,
       );
     }
-    await provider.loginChannel(recipe.openclaw, channel, options.dryRun);
-    logger.info(`Channel login completed: ${channel.channel}${channel.account ? `/${channel.account}` : ""}`);
+    await provider.loginChannel(recipe.openclaw, effectiveChannel, options.dryRun);
+    logger.info(`Channel login completed: ${effectiveChannel.channel}${effectiveChannel.account ? `/${effectiveChannel.account}` : ""}`);
   }
 
   logger.info("Recipe execution completed");