clawchef 0.1.6 → 0.1.8

package/dist/openclaw/provider.d.ts

@@ -6,12 +6,13 @@ export interface EnsureVersionResult {
     installedThisRun: boolean;
 }
 export interface OpenClawProvider {
-    ensureVersion(config: OpenClawSection, dryRun: boolean, silent: boolean, keepOpenClawState: boolean): Promise<EnsureVersionResult>;
+    ensureVersion(config: OpenClawSection, dryRun: boolean, silent: 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, workspace: string, filePath: string, content: string, overwrite: boolean | undefined, dryRun: boolean): Promise<void>;
     createAgent(config: OpenClawSection, agent: AgentDef, workspacePath: string, dryRun: boolean): Promise<void>;

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

@@ -5,12 +5,13 @@ export declare class RemoteOpenClawProvider implements OpenClawProvider {
     private readonly remoteConfig;
     constructor(remoteConfig: Partial<OpenClawRemoteConfig>);
     private perform;
-    ensureVersion(config: OpenClawSection, dryRun: boolean, _silent: boolean, _keepOpenClawState: boolean): Promise<EnsureVersionResult>;
+    ensureVersion(config: OpenClawSection, dryRun: boolean, _silent: 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, workspace: string, filePath: string, content: string, overwrite: boolean | undefined, dryRun: boolean): Promise<void>;
     createAgent(config: OpenClawSection, agent: AgentDef, workspacePath: string, dryRun: boolean): Promise<void>;

package/dist/openclaw/remote-provider.js

@@ -94,7 +94,7 @@ export class RemoteOpenClawProvider {
             clearTimeout(timeout);
         }
     }
-    async ensureVersion(config, dryRun, _silent, _keepOpenClawState) {
+    async ensureVersion(config, dryRun, _silent, _preserveExistingState) {
         const result = await this.perform(config, "ensure_version", {
             install: config.install,
         }, dryRun);
@@ -119,6 +119,13 @@ export class RemoteOpenClawProvider {
     async configureChannel(config, channel, dryRun) {
         await this.perform(config, "configure_channel", { channel }, dryRun);
     }
+    async bindChannelAgent(config, channel, agent, dryRun) {
+        await this.perform(config, "bind_channel_agent", {
+            channel: channel.channel,
+            account: channel.account,
+            agent,
+        }, dryRun);
+    }
     async loginChannel(config, channel, dryRun) {
         await this.perform(config, "login_channel", { channel }, dryRun);
     }

package/dist/orchestrator.js

@@ -22,6 +22,25 @@ function truncateForLog(text, maxLength = 500) {
     }
     return `${text.slice(0, maxLength)}... [truncated ${text.length - maxLength} chars]`;
 }
+function renderTemplateString(input, vars, allowMissing) {
+    return input.replace(/\$\{([^}]+)\}/g, (_match, rawKey) => {
+        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, name, configuredPath) {
     if (configuredPath?.trim()) {
         if (path.isAbsolute(configuredPath)) {
@@ -121,13 +140,14 @@ export async function runRecipe(recipe, recipeOrigin, options, logger) {
     const provider = createProvider(options);
     const remoteMode = options.provider === "remote";
     const workspacePaths = new Map();
+    const preserveExistingState = options.scope !== "full";
     logger.info(`Running recipe: ${recipe.name}`);
-    const versionResult = await provider.ensureVersion(recipe.openclaw, options.dryRun, options.silent, options.keepOpenClawState);
+    const versionResult = await provider.ensureVersion(recipe.openclaw, options.dryRun, options.silent, 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 {
@@ -195,68 +215,79 @@ export async function runRecipe(recipe, recipeOrigin, options, logger) {
         logger.info(`Agent created: ${agent.workspace}/${agent.name}`);
     }
     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);
+        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}`;
+                    }
                 }
-                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) {
+                    throw new ClawChefError(`File ${file.path} requires content, content_from, or source`);
                 }
+                await provider.materializeFile(recipe.openclaw, workspace.name, file.path, content, file.overwrite, options.dryRun);
+                logger.info(`File materialized: ${workspace.name}/${file.path}`);
+                continue;
             }
-            if (content === undefined && file.source) {
-                if (!options.dryRun) {
-                    content = await readTextFromRef(recipeOrigin, file.source);
+            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 {
-                    const resolved = resolveFileRef(recipeOrigin, file.source);
-                    content = `__dry_run_source__:${resolved.value}`;
+                else if (file.content !== undefined) {
+                    await writeFile(target, file.content, "utf8");
                 }
-            }
-            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;
-        }
-        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 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 {
-                    const content = await readBinaryFromRef(recipeOrigin, file.source);
-                    await writeFile(target, content);
+                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 ?? []) {
         for (const skill of agent.skills ?? []) {
@@ -295,14 +326,17 @@ export async function runRecipe(recipe, recipeOrigin, options, logger) {
     await provider.startGateway(recipe.openclaw, options.dryRun);
     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`);
+            throw new ClawChefError(`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");
 }

package/dist/recipe.js

@@ -8,23 +8,17 @@ import { recipeSchema } from "./schema.js";
 import { ClawChefError } from "./errors.js";
 import { deepResolveTemplates } from "./template.js";
 const AUTH_CHOICE_TO_FIELD = {
-    "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",
+    "openai-api-key": "llm_api_key",
+    "anthropic-api-key": "llm_api_key",
+    "openrouter-api-key": "llm_api_key",
+    "xai-api-key": "llm_api_key",
+    "gemini-api-key": "llm_api_key",
+    "ai-gateway-api-key": "llm_api_key",
+    "cloudflare-ai-gateway-api-key": "llm_api_key",
     token: "token",
 };
 const SECRET_BOOTSTRAP_FIELDS = [
-    "openai_api_key",
-    "anthropic_api_key",
-    "openrouter_api_key",
-    "xai_api_key",
-    "gemini_api_key",
-    "ai_gateway_api_key",
-    "cloudflare_ai_gateway_api_key",
+    "llm_api_key",
     "token",
 ];
 const ALLOWED_CHANNELS = new Set([
@@ -86,7 +80,7 @@ function assertNoInlineSecrets(recipe) {
         }
     }
 }
-function collectVars(recipe, cliVars) {
+function collectVars(recipe, cliVars, requiredKeys) {
     const vars = {};
     const params = recipe.params ?? {};
     for (const [envKey, envValue] of Object.entries(process.env)) {
@@ -114,7 +108,7 @@ function collectVars(recipe, cliVars) {
             vars[key] = def.default;
             continue;
         }
-        if (def.required) {
+        if (def.required && (requiredKeys === undefined || requiredKeys.has(key))) {
             throw new ClawChefError(`Parameter ${key} is required but was not provided via --var or environment`);
         }
     }
@@ -123,21 +117,51 @@ function collectVars(recipe, cliVars) {
     }
     return vars;
 }
+function projectRecipeForScope(recipe, options) {
+    if (options.scope !== "workspace") {
+        return recipe;
+    }
+    return {
+        ...recipe,
+        openclaw: {
+            ...recipe.openclaw,
+            bootstrap: undefined,
+        },
+        channels: [],
+        conversations: [],
+    };
+}
+function filterRecipeByWorkspaceName(recipe, workspaceName) {
+    const workspace = (recipe.workspaces ?? []).find((ws) => ws.name === workspaceName);
+    if (!workspace) {
+        throw new ClawChefError(`Workspace not found in recipe: ${workspaceName}`);
+    }
+    return {
+        ...recipe,
+        workspaces: [workspace],
+        agents: (recipe.agents ?? []).filter((agent) => agent.workspace === workspaceName),
+        conversations: (recipe.conversations ?? []).filter((conv) => conv.workspace === workspaceName),
+    };
+}
 function semanticValidate(recipe) {
     const ws = new Set((recipe.workspaces ?? []).map((w) => w.name));
+    const agentNameCounts = new Map();
     for (const workspace of recipe.workspaces ?? []) {
         if (workspace.assets !== undefined && !workspace.assets.trim()) {
             throw new ClawChefError(`Workspace ${workspace.name} has empty assets path`);
         }
     }
     for (const agent of recipe.agents ?? []) {
+        agentNameCounts.set(agent.name, (agentNameCounts.get(agent.name) ?? 0) + 1);
         if (!ws.has(agent.workspace)) {
             throw new ClawChefError(`Agent ${agent.name} references missing workspace: ${agent.workspace}`);
         }
     }
-    for (const file of recipe.files ?? []) {
-        if (!ws.has(file.workspace)) {
-            throw new ClawChefError(`File ${file.path} references missing workspace: ${file.workspace}`);
+    for (const workspace of recipe.workspaces ?? []) {
+        for (const file of workspace.files ?? []) {
+            if (!file.path.trim()) {
+                throw new ClawChefError(`Workspace ${workspace.name} has file with empty path`);
+            }
         }
     }
     const agents = new Set((recipe.agents ?? []).map((a) => `${a.workspace}::${a.name}`));
@@ -157,6 +181,18 @@ function semanticValidate(recipe) {
             (channel.login || channel.login_mode !== undefined || channel.login_account !== undefined)) {
             throw new ClawChefError("channels[] entry for telegram does not support login/login_mode/login_account. Configure token (or use_env/token_file), then start gateway.");
         }
+        if (channel.agent?.trim()) {
+            if (channel.channel !== "telegram") {
+                throw new ClawChefError(`channels[] entry for ${channel.channel} does not support agent binding. Use channel: telegram with agent.`);
+            }
+            const matched = agentNameCounts.get(channel.agent) ?? 0;
+            if (matched === 0) {
+                throw new ClawChefError(`channels[] entry references missing agent by name: ${channel.agent}`);
+            }
+            if (matched > 1) {
+                throw new ClawChefError(`channels[] entry references duplicate agent name: ${channel.agent}. Agent names must be unique for channel binding.`);
+            }
+        }
         const hasAuth = Boolean(channel.use_env) ||
             Boolean(channel.token?.trim()) ||
             Boolean(channel.token_file?.trim()) ||
@@ -609,16 +645,27 @@ export async function loadRecipe(recipePath, options) {
         if (!firstParse.success) {
             throw new ClawChefError(`Recipe format is invalid: ${firstParse.error.message}`);
         }
-        assertNoInlineSecrets(firstParse.data);
-        const vars = collectVars(firstParse.data, options.vars);
-        const rendered = deepResolveTemplates(firstParse.data, vars, options.allowMissing);
+        const projected = projectRecipeForScope(firstParse.data, options);
+        assertNoInlineSecrets(projected);
+        const requiredKeys = options.scope === "workspace" ? new Set() : undefined;
+        const vars = collectVars(projected, options.vars, requiredKeys);
+        const rendered = deepResolveTemplates(projected, vars, options.allowMissing);
         const secondParse = recipeSchema.safeParse(rendered);
         if (!secondParse.success) {
             throw new ClawChefError(`Recipe is invalid after parameter resolution: ${secondParse.error.message}`);
         }
-        semanticValidate(secondParse.data);
+        const scopedRecipe = (() => {
+            if (options.scope !== "workspace") {
+                return secondParse.data;
+            }
+            if (!options.workspaceName) {
+                throw new ClawChefError("scope=workspace requires a workspace name");
+            }
+            return filterRecipeByWorkspaceName(secondParse.data, options.workspaceName);
+        })();
+        semanticValidate(scopedRecipe);
         return {
-            recipe: secondParse.data,
+            recipe: scopedRecipe,
             origin: recipeRef.origin,
         };
     });