clawchef 0.1.0 → 0.1.2

package/src/orchestrator.ts

@@ -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";
@@ -37,7 +37,9 @@ function resolveWorkspacePath(recipeOrigin: RecipeOrigin, name: string, configur
     }
     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: string): boolean {
@@ -87,6 +89,35 @@ async function readBinaryFromRef(recipeOrigin: RecipeOrigin, reference: string):
   return Buffer.from(bytes);
 }
 
+interface LocalAssetFile {
+  absolutePath: string;
+  relativePath: string;
+}
+
+async function collectLocalAssetFiles(rootDir: string, relDir = ""): Promise<LocalAssetFile[]> {
+  const currentDir = relDir ? path.join(rootDir, relDir) : rootDir;
+  const entries = await readdir(currentDir, { withFileTypes: true });
+  const out: LocalAssetFile[] = [];
+
+  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: RunOptions): Promise<boolean> {
   if (options.silent || options.dryRun) {
     return true;
@@ -131,6 +162,13 @@ export async function runRecipe(
     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);
@@ -139,6 +177,50 @@ export async function runRecipe(
     }
     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 ?? []) {

package/src/recipe.ts

@@ -169,6 +169,11 @@ function collectVars(recipe: Recipe, cliVars: Record<string, string>): Record<st
 
 function semanticValidate(recipe: Recipe): void {
   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}`);
@@ -198,6 +203,15 @@ function semanticValidate(recipe: Recipe): void {
       );
     }
 
+    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()) ||

package/src/scaffold.ts

@@ -0,0 +1,197 @@
+import path from "node:path";
+import { access, mkdir, readdir, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { ClawChefError } from "./errors.js";
+
+export interface ScaffoldOptions {
+  projectName?: string;
+}
+
+export interface ScaffoldResult {
+  targetDir: string;
+  projectName: string;
+}
+
+function normalizeProjectName(value: string): string {
+  const normalized = value
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_]+/g, "-")
+    .replace(/[^a-z0-9-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  if (!normalized) {
+    throw new ClawChefError("Project name is empty after normalization. Use letters, numbers, spaces, underscore, or dash.");
+  }
+  return normalized;
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDirectoryEmpty(targetDir: string): Promise<void> {
+  const exists = await pathExists(targetDir);
+  if (!exists) {
+    await mkdir(targetDir, { recursive: true });
+    return;
+  }
+  const entries = await readdir(targetDir);
+  if (entries.length > 0) {
+    throw new ClawChefError(`Target directory is not empty: ${targetDir}`);
+  }
+}
+
+function makePackageJson(projectName: string): string {
+  const content = {
+    name: `${projectName}-recipe`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      "test:recipe": "node --test test/recipe-smoke.test.mjs",
+      test: "node --test \"test/**/*.test.mjs\"",
+    },
+    devDependencies: {
+      "telegram-api-mock-server": "^0.1.5",
+    },
+  };
+  return `${JSON.stringify(content, null, 2)}\n`;
+}
+
+function makeRecipeYaml(projectName: string): string {
+  return `version: "1"
+name: "${projectName}"
+
+params:
+  openclaw_version:
+    default: "2026.2.9"
+  workspace_name:
+    default: "${projectName}"
+  agent_name:
+    default: "${projectName}"
+  agent_model:
+    default: "openai/gpt-4.1"
+  telegram_mock_api_key:
+    required: true
+
+openclaw:
+  bin: "openclaw"
+  version: "\${openclaw_version}"
+  install: "never"
+  plugins:
+    - "openclaw-telegram-mock-channel"
+
+workspaces:
+  - name: "\${workspace_name}"
+    assets: "./${projectName}-assets"
+
+agents:
+  - workspace: "\${workspace_name}"
+    name: "\${agent_name}"
+    model: "\${agent_model}"
+
+channels:
+  - channel: "telegram-mock"
+    account: "default"
+    token: "\${telegram_mock_api_key}"
+    extra_flags:
+      mock_bind: "127.0.0.1:18790"
+      mock_api_key: "\${telegram_mock_api_key}"
+      mode: "webhook"
+`;
+}
+
+function makeAgentsDoc(projectName: string): string {
+  return `# ${projectName}
+
+Project scaffold generated by clawchef.
+`;
+}
+
+function makeIdentityDoc(projectName: string): string {
+  return `# Identity
+
+You are the ${projectName} assistant.
+`;
+}
+
+function makeSoulDoc(): string {
+  return `# Soul
+
+Keep responses practical, concise, and action-oriented.
+`;
+}
+
+function makeToolsDoc(): string {
+  return `# Tools
+
+- Use available workspace files first.
+- Ask for missing secrets explicitly.
+`;
+}
+
+function makeSchedulingScript(): string {
+  return `#!/usr/bin/env node
+import process from "node:process";
+
+const message = process.argv.slice(2).join(" ").trim();
+if (!message) {
+  console.error("Usage: node scripts/scheduling.mjs <message>");
+  process.exit(1);
+}
+
+console.log("[scheduling] " + message);
+`;
+}
+
+function makeRecipeSmokeTest(): string {
+  return `import test from "node:test";
+import assert from "node:assert/strict";
+import { access } from "node:fs/promises";
+
+test("recipe scaffold files exist", async () => {
+  await access("src/recipe.yaml");
+  await access("package.json");
+  assert.ok(true);
+});
+`;
+}
+
+export async function scaffoldProject(targetDirArg?: string, options: ScaffoldOptions = {}): Promise<ScaffoldResult> {
+  const targetDir = path.resolve(targetDirArg?.trim() ? targetDirArg : process.cwd());
+  await ensureDirectoryEmpty(targetDir);
+
+  const defaultName = path.basename(targetDir);
+  const rawProjectName = options.projectName?.trim() || defaultName;
+  const projectName = normalizeProjectName(rawProjectName);
+
+  const srcDir = path.join(targetDir, "src");
+  const assetsDir = path.join(srcDir, `${projectName}-assets`);
+  const assetsScriptsDir = path.join(assetsDir, "scripts");
+  const testDir = path.join(targetDir, "test");
+
+  await mkdir(srcDir, { recursive: true });
+  await mkdir(assetsDir, { recursive: true });
+  await mkdir(assetsScriptsDir, { recursive: true });
+  await mkdir(testDir, { recursive: true });
+
+  await writeFile(path.join(targetDir, "package.json"), makePackageJson(projectName), "utf8");
+  await writeFile(path.join(srcDir, "recipe.yaml"), makeRecipeYaml(projectName), "utf8");
+  await writeFile(path.join(assetsDir, "AGENTS.md"), makeAgentsDoc(projectName), "utf8");
+  await writeFile(path.join(assetsDir, "IDENTITY.md"), makeIdentityDoc(projectName), "utf8");
+  await writeFile(path.join(assetsDir, "SOUL.md"), makeSoulDoc(), "utf8");
+  await writeFile(path.join(assetsDir, "TOOLS.md"), makeToolsDoc(), "utf8");
+  await writeFile(path.join(assetsScriptsDir, "scheduling.mjs"), makeSchedulingScript(), "utf8");
+  await writeFile(path.join(testDir, "recipe-smoke.test.mjs"), makeRecipeSmokeTest(), "utf8");
+
+  return {
+    targetDir,
+    projectName,
+  };
+}

package/src/schema.ts

@@ -11,6 +11,7 @@ const openClawCommandsSchema = z
     use_version: z.string().optional(),
     install_version: z.string().optional(),
     uninstall_version: z.string().optional(),
+    install_plugin: z.string().optional(),
     factory_reset: z.string().optional(),
     start_gateway: z.string().optional(),
     enable_plugin: z.string().optional(),
@@ -58,6 +59,7 @@ const openClawSchema = z
     bin: z.string().optional(),
     version: z.string(),
     install: z.enum(["auto", "always", "never"]).optional(),
+    plugins: z.array(z.string().min(1)).optional(),
     bootstrap: openClawBootstrapSchema.optional(),
     commands: openClawCommandsSchema.optional(),
   })
@@ -67,6 +69,7 @@ const workspaceSchema = z
   .object({
     name: z.string().min(1),
     path: z.string().min(1).optional(),
+    assets: z.string().min(1).optional(),
   })
   .strict();
 

package/src/types.ts

@@ -20,6 +20,7 @@ export interface OpenClawCommandOverrides {
   use_version?: string;
   install_version?: string;
   uninstall_version?: string;
+  install_plugin?: string;
   factory_reset?: string;
   start_gateway?: string;
   enable_plugin?: string;
@@ -63,6 +64,7 @@ export interface OpenClawSection {
   bin?: string;
   version: string;
   install?: InstallPolicy;
+  plugins?: string[];
   bootstrap?: OpenClawBootstrap;
   commands?: OpenClawCommandOverrides;
 }
@@ -70,6 +72,7 @@ export interface OpenClawSection {
 export interface WorkspaceDef {
   name: string;
   path?: string;
+  assets?: string;
 }
 
 export interface ChannelDef {
@@ -141,6 +144,7 @@ export interface Recipe {
 
 export interface RunOptions {
   vars: Record<string, string>;
+  plugins: string[];
   dryRun: boolean;
   allowMissing: boolean;
   verbose: boolean;