clawchef 0.1.0 → 0.1.2

package/README.md

@@ -14,12 +14,13 @@ Recipe-driven OpenClaw environment orchestrator.
 - Always runs factory reset first (with confirmation prompt unless `-s/--silent` is used).
 - If `openclaw` is missing, auto-installs the recipe version and skips factory reset.
 - Starts OpenClaw gateway service after each recipe execution.
-- Creates workspaces and agents (default workspace path: `~/.openclaw/workspaces/<workspace-name>`).
+- Creates workspaces and agents (default workspace path: `~/.openclaw/workspace-<workspace-name>`).
+- Supports workspace-level assets copy via `workspaces[].assets`.
 - Materializes files into target workspaces.
 - Installs skills.
+- Supports plugin preinstall via `openclaw.plugins[]` and runtime `--plugin` flags.
 - Configures channels with `openclaw channels add`.
-- Enables channel plugins before channel configuration.
-- Supports interactive channel login at the end of execution (`channels[].login: true`).
+- Supports interactive channel login at the end of execution (`channels[].login: true`) for channels that expose login.
 - Supports remote HTTP orchestration via runtime flags (`--provider remote`) when OpenClaw is reachable via API.
 - Writes preset conversation messages.
 - Runs agent and validates reply output.
@@ -27,29 +28,27 @@ Recipe-driven OpenClaw environment orchestrator.
 ## Install and run
 
 ```bash
-npm install
-npm run build
-npm i -g .
+npm i -g clawchef
 clawchef cook recipes/sample.yaml
 ```
 
 Run recipe from URL:
 
 ```bash
-clawchef cook https://example.com/recipes/sample.yaml --provider remote -s
+clawchef cook https://example.com/recipes/sample.yaml --provider remote
 ```
 
 Run recipe from archive (default `recipe.yaml`):
 
 ```bash
-clawchef cook ./bundle.tgz --provider mock -s
+clawchef cook ./bundle.tgz --provider mock
 ```
 
 Run specific recipe in directory or archive:
 
 ```bash
-clawchef cook ./recipes-pack:team/recipe-prod.yaml --provider remote -s
-clawchef cook https://example.com/recipes-pack.zip:team/recipe-prod.yaml --provider remote -s
+clawchef cook ./recipes-pack:team/recipe-prod.yaml --provider remote
+clawchef cook https://example.com/recipes-pack.zip:team/recipe-prod.yaml --provider remote
 ```
 
 Dev mode:
@@ -61,13 +60,13 @@ clawchef cook recipes/sample.yaml --verbose
 Run sample with mock provider:
 
 ```bash
-clawchef cook recipes/sample.yaml --provider mock -s
+clawchef cook recipes/sample.yaml --provider mock
 ```
 
 Run `content_from` sample:
 
 ```bash
-clawchef cook recipes/content-from-sample.yaml --provider mock -s
+clawchef cook recipes/content-from-sample.yaml --provider mock
 ```
 
 Skip reset confirmation prompt:
@@ -76,6 +75,9 @@ Skip reset confirmation prompt:
 clawchef cook recipes/sample.yaml -s
 ```
 
+Warning: `-s/--silent` suppresses the factory-reset confirmation and auto-chooses force reinstall on version mismatch.
+Use it only in CI/non-interactive flows where destructive reset behavior is expected.
+
 From-zero OpenClaw bootstrap (recommended):
 
 ```bash
@@ -85,13 +87,19 @@ CLAWCHEF_VAR_OPENAI_API_KEY=sk-... clawchef cook recipes/openclaw-from-zero.yaml
 Telegram channel setup only:
 
 ```bash
-CLAWCHEF_VAR_TELEGRAM_BOT_TOKEN=123456:abc... clawchef cook recipes/openclaw-telegram.yaml -s
+CLAWCHEF_VAR_TELEGRAM_BOT_TOKEN=123456:abc... clawchef cook recipes/openclaw-telegram.yaml
 ```
 
 Telegram mock channel setup (for tests):
 
 ```bash
-CLAWCHEF_VAR_TELEGRAM_MOCK_API_KEY=test-key clawchef cook recipes/openclaw-telegram-mock.yaml -s
+CLAWCHEF_VAR_TELEGRAM_MOCK_API_KEY=test-key clawchef cook recipes/openclaw-telegram-mock.yaml
+```
+
+Install plugin only for this run:
+
+```bash
+clawchef cook recipes/openclaw-telegram-mock.yaml --plugin openclaw-telegram-mock-channel
 ```
 
 Remote HTTP orchestration:
@@ -99,7 +107,7 @@ Remote HTTP orchestration:
 ```bash
 CLAWCHEF_REMOTE_BASE_URL=https://remote-openclaw.example.com \
 CLAWCHEF_REMOTE_API_KEY=secret-token \
-clawchef cook recipes/openclaw-remote-http.yaml --provider remote -s --verbose
+clawchef cook recipes/openclaw-remote-http.yaml --provider remote --verbose
 ```
 
 Validate recipe structure only:
@@ -121,12 +129,32 @@ clawchef validate ./bundle.zip
 clawchef validate ./bundle.zip:custom/recipe.yaml
 ```
 
+Create a new recipe project scaffold:
+
+```bash
+clawchef scaffold
+clawchef scaffold ./my-recipe-project
+clawchef scaffold ./my-recipe-project --name meetingbot
+```
+
+`scaffold` prompts for project name (default: target directory name).
+
+Scaffold output:
+
+- `package.json` with `telegram-api-mock-server` in `devDependencies`
+- `src/recipe.yaml` with `telegram-mock` channel, plugin preinstall, and `workspaces[].assets`
+- `src/<project-name>-assets/{AGENTS.md,IDENTITY.md,SOUL.md,TOOLS.md}`
+- `src/<project-name>-assets/scripts/scheduling.mjs`
+- `test/recipe-smoke.test.mjs`
+
+By default scaffold only writes files; it does not run `npm install`.
+
 ## Node.js API
 
 You can call clawchef directly from Node.js (without invoking CLI commands).
 
 ```ts
-import { cook, validate } from "clawchef";
+import { cook, scaffold, validate } from "clawchef";
 
 await validate("recipes/sample.yaml");
 
@@ -137,21 +165,30 @@ await cook("recipes/sample.yaml", {
     openai_api_key: process.env.OPENAI_API_KEY ?? "",
   },
 });
+
+await scaffold("./my-recipe-project", {
+  projectName: "my-recipe-project",
+});
 ```
 
 `cook()` options:
 
 - `vars`: template variables (`Record<string, string>`)
+- `plugins`: plugin npm specs to preinstall for this run (`string[]`)
 - `provider`: `command | remote | mock`
 - `remote`: remote provider config (same fields as CLI remote flags)
 - `dryRun`, `allowMissing`, `verbose`
 - `silent` (default: `true` in Node API)
 - `loadDotEnvFromCwd` (default: `true`)
 
+Node API `silent: true` has the same risk as CLI `-s`: no reset confirmation and force reinstall on version mismatch.
+Set `silent: false` when you want an interactive safety prompt.
+
 Notes:
 
 - `validate()` throws on invalid recipe.
 - `cook()` throws on runtime/configuration errors.
+- `scaffold()` creates `package.json`, `src/recipe.yaml`, `src/<project-name>-assets`, and `test/`.
 
 ## Variable precedence
 
@@ -213,7 +250,7 @@ Request payload format (POST):
   "payload": {
     "workspace": {
       "name": "demo",
-      "path": "/home/runner/.openclaw/workspaces/demo"
+      "path": "/home/runner/.openclaw/workspace-demo"
     }
   }
 }
@@ -233,6 +270,7 @@ Expected response format:
 Supported operation values sent by clawchef:
 
 - `ensure_version`, `factory_reset`, `start_gateway`
+- `install_plugin`
 - `create_workspace`, `create_agent`, `materialize_file`, `install_skill`
 - `configure_channel`, `login_channel`
 - `run_agent`
@@ -258,6 +296,20 @@ Supported fields include:
 - setup toggles: `skip_channels`, `skip_skills`, `skip_health`, `skip_ui`, `skip_daemon`, `install_daemon`
 - auth/provider: `auth_choice`, `openai_api_key`, `anthropic_api_key`, `openrouter_api_key`, `xai_api_key`, `gemini_api_key`, `ai_gateway_api_key`, `cloudflare_ai_gateway_api_key`, `token`, `token_provider`, `token_profile_id`
 
+### Plugin preinstall
+
+Use `openclaw.plugins` to preinstall plugin packages before workspace/channel setup.
+
+Example:
+
+```yaml
+openclaw:
+  version: "2026.2.9"
+  plugins:
+    - "openclaw-telegram-mock-channel"
+    - "@scope/custom-channel-plugin@1.2.3"
+```
+
 When `openclaw.bootstrap` contains provider keys, `clawchef` also injects them into runtime env for `openclaw agent --local`.
 
 For `command` provider, default command templates are:
@@ -265,9 +317,9 @@ For `command` provider, default command templates are:
 - `use_version`: `${bin} --version`
 - `install_version`: `npm install -g openclaw@${version}`
 - `uninstall_version`: `npm uninstall -g openclaw`
+- `install_plugin`: `${bin} plugins install ${plugin_spec_q}`
 - `factory_reset`: `${bin} reset --scope full --yes --non-interactive`
 - `start_gateway`: `${bin} gateway start`
-- `enable_plugin`: `${bin} plugins enable ${channel_q}`
 - `login_channel`: `${bin} channels login --channel ${channel_q}${account_arg}`
 - `create_workspace`: generated from `openclaw.bootstrap` (override with `openclaw.commands.create_workspace`)
 - `create_agent`: `${bin} agents add ${agent} --workspace ${workspace_path} --model ${model} --non-interactive --json`
@@ -277,10 +329,14 @@ For `command` provider, default command templates are:
 
 You can override any command under `openclaw.commands` in recipe.
 
+By default, clawchef does not auto-run `openclaw plugins enable <channel>` during channel configuration.
+If you need custom enable behavior, set `openclaw.commands.enable_plugin` explicitly.
+
 ## Channels
 
 Use `channels[]` to configure accounts via `openclaw channels add`.
 If `login: true` is set, clawchef runs channel login at the end of `cook` (after gateway start).
+Telegram does not support `openclaw channels login`; do not set `login` for `channel: "telegram"`.
 
 Example:
 
@@ -289,7 +345,6 @@ channels:
   - channel: "telegram"
     token: "${telegram_bot_token}"
     account: "default"
-    login: true
 
   - channel: "slack"
     bot_token: "${slack_bot_token}"
@@ -308,54 +363,27 @@ Supported common fields:
 - optional: `account`, `name`, `token`, `token_file`, `use_env`, `bot_token`, `access_token`, `app_token`, `webhook_url`, `webhook_path`, `signal_number`, `password`, `login`, `login_mode`, `login_account`
 - advanced passthrough: `extra_flags` (`snake_case` keys become `--kebab-case` CLI flags)
 
-### Telegram mock channel (for recipe tests)
-
-Use `channel: "telegram-mock"` when you need to test Telegram-related recipe flows without connecting to the real Telegram network.
-
-`clawchef` treats `telegram-mock` like any other channel and passes mock-specific flags through `extra_flags`.
-
-Example:
-
-```yaml
-params:
-  telegram_mock_api_key:
-    required: true
-
-channels:
-  - channel: "telegram-mock"
-    account: "testbot"
-    token: "${telegram_mock_api_key}"
-    extra_flags:
-      mock_bind: "127.0.0.1:18790"
-      mock_api_key: "${telegram_mock_api_key}"
-      mode: "webhook"
-```
-
-Typical test setup:
-
-- Start OpenClaw with the telegram-mock plugin enabled.
-- Run `clawchef cook ...` to configure workspaces/agents/channels.
-- Use your external test program (HTTP API or Node.js SDK) to inject inbound mock messages and assert outbound events.
-
-Login fields:
-
-- `login: true` enables channel login step
-- `login_mode`: currently supports `interactive`
-- `login_account`: override account used for login (defaults to `account`)
-
-Security rules:
-
-- Do not inline secret values in `channels[]`.
-- Use `${var}` placeholders and inject values via `--var` / `CLAWCHEF_VAR_*`.
-
 ## Workspace path behavior
 
 - `workspaces[].path` is optional.
-- If omitted, clawchef uses `~/.openclaw/workspaces/<workspace-name>`.
+- If omitted, clawchef uses `~/.openclaw/workspace-<workspace-name>`.
+- `workspaces[].assets` is optional.
+- If `assets` is set, clawchef recursively copies files from that directory into the workspace root.
+- `assets` is resolved relative to the recipe file path (unless absolute path is given).
+- `files[]` runs after assets copy, so `files[]` can override copied asset files.
+- Direct URL recipes do not support `workspaces[].assets` (assets must resolve to a local directory).
 - If provided, relative paths are resolved from the recipe file directory.
 - For direct URL recipe files, relative workspace paths are resolved from the current working directory.
 - For directory/archive recipe references, relative workspace paths are resolved from the selected recipe file directory.
 
+Example:
+
+```yaml
+workspaces:
+  - name: "workspace-meeting"
+    assets: "./meetingbot-assets"
+```
+
 ## File content references
 
 In `files[]`, set exactly one of:

package/dist/api.d.ts

@@ -1,6 +1,8 @@
 import type { OpenClawProvider, OpenClawRemoteConfig } from "./types.js";
+import type { ScaffoldOptions, ScaffoldResult } from "./scaffold.js";
 export interface CookOptions {
     vars?: Record<string, string>;
+    plugins?: string[];
     dryRun?: boolean;
     allowMissing?: boolean;
     verbose?: boolean;
@@ -11,4 +13,6 @@ export interface CookOptions {
 }
 export declare function cook(recipeRef: string, options?: CookOptions): Promise<void>;
 export declare function validate(recipeRef: string): Promise<void>;
+export declare function scaffold(targetDir?: string, options?: ScaffoldOptions): Promise<ScaffoldResult>;
 export type { OpenClawProvider, OpenClawRemoteConfig };
+export type { ScaffoldOptions, ScaffoldResult };

package/dist/api.js

@@ -4,10 +4,13 @@ import { importDotEnvFromCwd } from "./env.js";
 import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
+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)));
     return {
         vars: options.vars ?? {},
+        plugins,
         dryRun: Boolean(options.dryRun),
         allowMissing: Boolean(options.allowMissing),
         verbose: Boolean(options.verbose),
@@ -47,3 +50,6 @@ export async function validate(recipeRef) {
         }
     }
 }
+export async function scaffold(targetDir, options = {}) {
+    return scaffoldProject(targetDir, options);
+}

package/dist/cli.js

@@ -4,7 +4,11 @@ import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
 import { recipeSchema } from "./schema.js";
+import { scaffoldProject } from "./scaffold.js";
 import YAML from "js-yaml";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
 function parseVarFlags(values) {
     const out = {};
     for (const item of values) {
@@ -18,6 +22,9 @@ function parseVarFlags(values) {
     }
     return out;
 }
+function parsePluginFlags(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) {
@@ -42,6 +49,20 @@ function parseOptionalInt(value, fieldName) {
     }
     return parsed;
 }
+async function promptProjectName(defaultValue) {
+    if (!input.isTTY) {
+        return defaultValue;
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(`Project name [${defaultValue}]: `);
+        const value = answer.trim();
+        return value || defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
 export function buildCli() {
     const program = new Command();
     program
@@ -57,6 +78,7 @@ export function buildCli() {
         .option("--verbose", "Verbose logging", false)
         .option("-s, --silent", "Skip reset confirmation prompt", false)
         .option("--provider <provider>", "Execution provider: command | remote | mock")
+        .option("--plugin <npm-spec>", "Preinstall plugin package (repeatable)", (v, p) => p.concat([v]), [])
         .option("--remote-base-url <url>", "Remote OpenClaw API base URL")
         .option("--remote-api-key <key>", "Remote OpenClaw API key")
         .option("--remote-api-header <header>", "Remote auth header name")
@@ -67,6 +89,7 @@ export function buildCli() {
         const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
         const options = {
             vars: parseVarFlags(opts.var),
+            plugins: parsePluginFlags(opts.plugin),
             dryRun: Boolean(opts.dryRun),
             allowMissing: Boolean(opts.allowMissing),
             verbose: Boolean(opts.verbose),
@@ -92,6 +115,19 @@ export function buildCli() {
             }
         }
     });
+    program
+        .command("scaffold")
+        .argument("[dir]", "Target directory (default: current directory)")
+        .option("--name <project-name>", "Project name (default: directory name)")
+        .action(async (dir, opts) => {
+        const resolvedDir = path.resolve(dir?.trim() ? dir : process.cwd());
+        const defaultName = path.basename(resolvedDir);
+        const projectName = opts.name?.trim() ? opts.name.trim() : await promptProjectName(defaultName);
+        const result = await scaffoldProject(resolvedDir, { projectName });
+        process.stdout.write(`Scaffold created at ${result.targetDir}\n`);
+        process.stdout.write(`Project name: ${result.projectName}\n`);
+        process.stdout.write("Next: run npm install\n");
+    });
     program
         .command("validate")
         .argument("<recipe>", "Recipe path/URL/dir/archive[:file]")

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

@@ -4,6 +4,7 @@ export declare class CommandOpenClawProvider implements OpenClawProvider {
     private readonly stagedMessages;
     ensureVersion(config: OpenClawSection, dryRun: boolean, silent: boolean): Promise<EnsureVersionResult>;
     factoryReset(config: OpenClawSection, dryRun: boolean): Promise<void>;
+    installPlugin(config: OpenClawSection, pluginSpec: string, 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>;

package/dist/openclaw/command-provider.js

@@ -10,9 +10,10 @@ const DEFAULT_COMMANDS = {
     use_version: "${bin} --version",
     install_version: "npm install -g openclaw@${version}",
     uninstall_version: "npm uninstall -g openclaw",
+    install_plugin: "${bin} plugins install ${plugin_spec_q}",
     factory_reset: "${bin} reset --scope full --yes --non-interactive",
     start_gateway: "${bin} gateway start",
-    enable_plugin: "${bin} plugins enable ${channel_q}",
+    enable_plugin: "",
     login_channel: "${bin} channels login --channel ${channel_q}${account_arg}",
     create_agent: "${bin} agents add ${agent} --workspace ${workspace_path} --model ${model} --non-interactive --json",
     install_skill: "${bin} skills check",
@@ -302,6 +303,23 @@ export class CommandOpenClawProvider {
         }
         await runShell(resetCmd, dryRun);
     }
+    async installPlugin(config, pluginSpec, dryRun) {
+        const trimmed = pluginSpec.trim();
+        if (!trimmed) {
+            return;
+        }
+        const bin = config.bin ?? "openclaw";
+        const cmd = commandFor(config, "install_plugin", {
+            bin,
+            version: config.version,
+            plugin_spec: trimmed,
+            plugin_spec_q: shellQuote(trimmed),
+        });
+        if (!cmd.trim()) {
+            return;
+        }
+        await runShell(cmd, dryRun);
+    }
     async startGateway(config, dryRun) {
         const bin = config.bin ?? "openclaw";
         const startCmd = commandFor(config, "start_gateway", { bin, version: config.version });
@@ -328,14 +346,17 @@ export class CommandOpenClawProvider {
     }
     async configureChannel(config, channel, dryRun) {
         const bin = config.bin ?? "openclaw";
-        const enablePluginCmd = commandFor(config, "enable_plugin", {
-            bin,
-            version: config.version,
-            channel: channel.channel,
-            channel_q: shellQuote(channel.channel),
-        });
-        if (enablePluginCmd.trim()) {
-            await runShell(enablePluginCmd, dryRun);
+        const enablePluginTemplate = config.commands?.enable_plugin;
+        if (enablePluginTemplate?.trim()) {
+            const enablePluginCmd = fillTemplate(enablePluginTemplate, {
+                bin,
+                version: config.version,
+                channel: channel.channel,
+                channel_q: shellQuote(channel.channel),
+            });
+            if (enablePluginCmd.trim()) {
+                await runShell(enablePluginCmd, dryRun);
+            }
         }
         const flags = [
             "--channel",

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

@@ -3,6 +3,7 @@ import type { EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from
 export declare class MockOpenClawProvider implements OpenClawProvider {
     private state;
     ensureVersion(config: OpenClawSection, _dryRun: boolean, _silent: 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>;

package/dist/openclaw/mock-provider.js

@@ -25,6 +25,9 @@ export class MockOpenClawProvider {
         this.state.currentVersion = config.version;
         return { installedThisRun };
     }
+    async installPlugin(_config, _pluginSpec, _dryRun) {
+        return;
+    }
     async factoryReset(_config, _dryRun) {
         this.state.workspaces.clear();
         this.state.channels.clear();

package/dist/openclaw/provider.d.ts

@@ -7,6 +7,7 @@ export interface EnsureVersionResult {
 }
 export interface OpenClawProvider {
     ensureVersion(config: OpenClawSection, dryRun: boolean, silent: 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>;

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

@@ -6,6 +6,7 @@ export declare class RemoteOpenClawProvider implements OpenClawProvider {
     constructor(remoteConfig: Partial<OpenClawRemoteConfig>);
     private perform;
     ensureVersion(config: OpenClawSection, dryRun: boolean, _silent: 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>;

package/dist/openclaw/remote-provider.js

@@ -102,6 +102,11 @@ export class RemoteOpenClawProvider {
             installedThisRun: Boolean(result.installed_this_run),
         };
     }
+    async installPlugin(config, pluginSpec, dryRun) {
+        await this.perform(config, "install_plugin", {
+            plugin_spec: pluginSpec,
+        }, dryRun);
+    }
     async factoryReset(config, dryRun) {
         await this.perform(config, "factory_reset", undefined, dryRun);
     }

package/dist/orchestrator.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { homedir } from "node:os";
-import { mkdir, access, copyFile, writeFile, readFile } from "node:fs/promises";
+import { mkdir, access, copyFile, writeFile, readFile, readdir, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
@@ -32,7 +32,9 @@ function resolveWorkspacePath(recipeOrigin, name, configuredPath) {
         }
         return path.resolve(configuredPath);
     }
-    return path.join(homedir(), ".openclaw", "workspaces", name);
+    const trimmedName = name.trim() || name;
+    const workspaceName = trimmedName.startsWith("workspace-") ? trimmedName : `workspace-${trimmedName}`;
+    return path.join(homedir(), ".openclaw", workspaceName);
 }
 function isHttpUrl(value) {
     try {
@@ -78,6 +80,27 @@ async function readBinaryFromRef(recipeOrigin, reference) {
     const bytes = await response.arrayBuffer();
     return Buffer.from(bytes);
 }
+async function collectLocalAssetFiles(rootDir, relDir = "") {
+    const currentDir = relDir ? path.join(rootDir, relDir) : rootDir;
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        const nextRel = relDir ? path.join(relDir, entry.name) : entry.name;
+        if (entry.isDirectory()) {
+            out.push(...await collectLocalAssetFiles(rootDir, nextRel));
+            continue;
+        }
+        if (entry.isFile()) {
+            out.push({
+                absolutePath: path.join(rootDir, nextRel),
+                relativePath: nextRel,
+            });
+            continue;
+        }
+        throw new ClawChefError(`Unsupported entry in assets directory: ${path.join(rootDir, nextRel)}`);
+    }
+    return out;
+}
 async function confirmFactoryReset(options) {
     if (options.silent || options.dryRun) {
         return true;
@@ -112,6 +135,12 @@ export async function runRecipe(recipe, recipeOrigin, options, logger) {
         await provider.factoryReset(recipe.openclaw, options.dryRun);
         logger.info("Factory reset completed");
     }
+    const pluginSpecs = Array.from(new Set([...(recipe.openclaw.plugins ?? []), ...options.plugins].map((v) => v.trim())))
+        .filter((v) => v.length > 0);
+    for (const pluginSpec of pluginSpecs) {
+        await provider.installPlugin(recipe.openclaw, pluginSpec, options.dryRun);
+        logger.info(`Plugin preinstalled: ${pluginSpec}`);
+    }
     for (const ws of recipe.workspaces ?? []) {
         const absPath = resolveWorkspacePath(recipeOrigin, ws.name, ws.path);
         workspacePaths.set(ws.name, absPath);
@@ -120,6 +149,39 @@ export async function runRecipe(recipe, recipeOrigin, options, logger) {
         }
         await provider.createWorkspace(recipe.openclaw, { ...ws, path: absPath }, options.dryRun);
         logger.info(`Workspace created: ${ws.name}`);
+        if (!ws.assets?.trim()) {
+            continue;
+        }
+        const resolvedAssets = resolveFileRef(recipeOrigin, ws.assets);
+        if (resolvedAssets.kind !== "local") {
+            throw new ClawChefError(`Workspace assets must resolve to a local directory: ${ws.assets}. Direct URL recipes cannot use workspaces[].assets.`);
+        }
+        let assetDirStat;
+        try {
+            assetDirStat = await stat(resolvedAssets.value);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new ClawChefError(`Workspace assets path is not accessible: ${resolvedAssets.value} (${message})`);
+        }
+        if (!assetDirStat.isDirectory()) {
+            throw new ClawChefError(`Workspace assets must be a directory: ${resolvedAssets.value}`);
+        }
+        const assetFiles = await collectLocalAssetFiles(resolvedAssets.value);
+        for (const assetFile of assetFiles) {
+            if (provider.materializeFile) {
+                const content = await readFile(assetFile.absolutePath, "utf8");
+                await provider.materializeFile(recipe.openclaw, ws.name, assetFile.relativePath, content, true, options.dryRun);
+            }
+            else {
+                const target = path.resolve(absPath, assetFile.relativePath);
+                if (!options.dryRun) {
+                    await mkdir(path.dirname(target), { recursive: true });
+                    await copyFile(assetFile.absolutePath, target);
+                }
+            }
+            logger.info(`Workspace asset copied: ${ws.name}/${assetFile.relativePath}`);
+        }
     }
     for (const agent of recipe.agents ?? []) {
         const workspacePath = workspacePaths.get(agent.workspace);

package/dist/recipe.js

@@ -125,6 +125,11 @@ function collectVars(recipe, cliVars) {
 }
 function semanticValidate(recipe) {
     const ws = new Set((recipe.workspaces ?? []).map((w) => w.name));
+    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 ?? []) {
         if (!ws.has(agent.workspace)) {
             throw new ClawChefError(`Agent ${agent.name} references missing workspace: ${agent.workspace}`);
@@ -148,6 +153,10 @@ function semanticValidate(recipe) {
         if (!ALLOWED_CHANNELS.has(channel.channel)) {
             throw new ClawChefError(`Unsupported channel: ${channel.channel}. Allowed: ${Array.from(ALLOWED_CHANNELS).join(", ")}`);
         }
+        if (channel.channel === "telegram" &&
+            (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.");
+        }
         const hasAuth = Boolean(channel.use_env) ||
             Boolean(channel.token?.trim()) ||
             Boolean(channel.token_file?.trim()) ||