clawchef 0.1.6 → 0.1.8

package/src/recipe.ts

@@ -32,24 +32,18 @@ export interface LoadedRecipeText {
 }
 
 const AUTH_CHOICE_TO_FIELD: 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",
+  "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",
 ] as const;
 
@@ -124,7 +118,7 @@ function assertNoInlineSecrets(recipe: Recipe): void {
   }
 }
 
-function collectVars(recipe: Recipe, cliVars: Record<string, string>): Record<string, string> {
+function collectVars(recipe: Recipe, cliVars: Record<string, string>, requiredKeys?: Set<string>): Record<string, string> {
   const vars: Record<string, string> = {};
   const params = recipe.params ?? {};
 
@@ -155,7 +149,7 @@ function collectVars(recipe: Recipe, cliVars: Record<string, string>): Record<st
       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`);
     }
   }
@@ -167,21 +161,55 @@ function collectVars(recipe: Recipe, cliVars: Record<string, string>): Record<st
   return vars;
 }
 
+function projectRecipeForScope(recipe: Recipe, options: RunOptions): Recipe {
+  if (options.scope !== "workspace") {
+    return recipe;
+  }
+
+  return {
+    ...recipe,
+    openclaw: {
+      ...recipe.openclaw,
+      bootstrap: undefined,
+    },
+    channels: [],
+    conversations: [],
+  };
+}
+
+function filterRecipeByWorkspaceName(recipe: Recipe, workspaceName: string): Recipe {
+  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: Recipe): void {
   const ws = new Set((recipe.workspaces ?? []).map((w) => w.name));
+  const agentNameCounts = new Map<string, number>();
   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}`));
@@ -212,6 +240,23 @@ function semanticValidate(recipe: Recipe): void {
       );
     }
 
+    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()) ||
@@ -752,18 +797,31 @@ export async function loadRecipe(recipePath: string, options: RunOptions): Promi
       throw new ClawChefError(`Recipe format is invalid: ${firstParse.error.message}`);
     }
 
-    assertNoInlineSecrets(firstParse.data);
+    const projected = projectRecipeForScope(firstParse.data, options);
+
+    assertNoInlineSecrets(projected);
 
-    const vars = collectVars(firstParse.data, options.vars);
-    const rendered = deepResolveTemplates(firstParse.data, vars, options.allowMissing);
+    const requiredKeys = options.scope === "workspace" ? new Set<string>() : 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,
     };
   });

package/src/schema.ts

@@ -15,6 +15,7 @@ const openClawCommandsSchema = z
     factory_reset: z.string().optional(),
     start_gateway: z.string().optional(),
     enable_plugin: z.string().optional(),
+    bind_channel_agent: z.string().optional(),
     login_channel: z.string().optional(),
     create_workspace: z.string().optional(),
     create_agent: z.string().optional(),
@@ -39,13 +40,7 @@ const openClawBootstrapSchema = z
     skip_ui: z.boolean().optional(),
     skip_daemon: z.boolean().optional(),
     install_daemon: z.boolean().optional(),
-    openai_api_key: z.string().optional(),
-    anthropic_api_key: z.string().optional(),
-    openrouter_api_key: z.string().optional(),
-    xai_api_key: z.string().optional(),
-    gemini_api_key: z.string().optional(),
-    ai_gateway_api_key: z.string().optional(),
-    cloudflare_ai_gateway_api_key: z.string().optional(),
+    llm_api_key: z.string().optional(),
     cloudflare_ai_gateway_account_id: z.string().optional(),
     cloudflare_ai_gateway_gateway_id: z.string().optional(),
     token: z.string().optional(),
@@ -70,6 +65,22 @@ const workspaceSchema = z
     name: z.string().min(1),
     path: z.string().min(1).optional(),
     assets: z.string().min(1).optional(),
+    files: z
+      .array(
+        z
+          .object({
+            path: z.string().min(1),
+            content: z.string().optional(),
+            content_from: z.string().min(1).optional(),
+            source: z.string().optional(),
+            overwrite: z.boolean().optional(),
+          })
+          .strict()
+          .refine((v) => [v.content, v.content_from, v.source].filter((item) => item !== undefined).length === 1, {
+            message: "workspaces[].files[] requires exactly one of content, content_from, or source",
+          }),
+      )
+      .optional(),
   })
   .strict();
 
@@ -77,6 +88,7 @@ const channelSchema = z
   .object({
     channel: z.string().min(1),
     account: z.string().min(1).optional(),
+    agent: z.string().min(1).optional(),
     login: z.boolean().optional(),
     login_mode: z.enum(["interactive"]).optional(),
     login_account: z.string().min(1).optional(),
@@ -104,20 +116,6 @@ const agentSchema = z
   })
   .strict();
 
-const fileSchema = z
-  .object({
-    workspace: z.string().min(1),
-    path: z.string().min(1),
-    content: z.string().optional(),
-    content_from: z.string().min(1).optional(),
-    source: z.string().optional(),
-    overwrite: z.boolean().optional(),
-  })
-  .strict()
-  .refine((v) => [v.content, v.content_from, v.source].filter((item) => item !== undefined).length === 1, {
-    message: "files[] requires exactly one of content, content_from, or source",
-  });
-
 const conversationExpectSchema = z
   .object({
     contains: z.array(z.string()).optional(),
@@ -152,7 +150,6 @@ export const recipeSchema = z
     workspaces: z.array(workspaceSchema).optional(),
     channels: z.array(channelSchema).optional(),
     agents: z.array(agentSchema).optional(),
-    files: z.array(fileSchema).optional(),
     conversations: z.array(conversationSchema).optional(),
   })
   .strict();

package/src/types.ts

@@ -1,5 +1,6 @@
 export type InstallPolicy = "auto" | "always" | "never";
 export type OpenClawProvider = "command" | "mock" | "remote";
+export type RunScope = "full" | "files" | "workspace";
 
 export interface OpenClawRemoteConfig {
   base_url: string;
@@ -24,6 +25,7 @@ export interface OpenClawCommandOverrides {
   factory_reset?: string;
   start_gateway?: string;
   enable_plugin?: string;
+  bind_channel_agent?: string;
   login_channel?: string;
   create_workspace?: string;
   create_agent?: string;
@@ -46,13 +48,7 @@ export interface OpenClawBootstrap {
   skip_ui?: boolean;
   skip_daemon?: boolean;
   install_daemon?: boolean;
-  openai_api_key?: string;
-  anthropic_api_key?: string;
-  openrouter_api_key?: string;
-  xai_api_key?: string;
-  gemini_api_key?: string;
-  ai_gateway_api_key?: string;
-  cloudflare_ai_gateway_api_key?: string;
+  llm_api_key?: string;
   cloudflare_ai_gateway_account_id?: string;
   cloudflare_ai_gateway_gateway_id?: string;
   token?: string;
@@ -73,11 +69,13 @@ export interface WorkspaceDef {
   name: string;
   path?: string;
   assets?: string;
+  files?: WorkspaceFileDef[];
 }
 
 export interface ChannelDef {
   channel: string;
   account?: string;
+  agent?: string;
   login?: boolean;
   login_mode?: "interactive";
   login_account?: string;
@@ -102,8 +100,7 @@ export interface AgentDef {
   skills?: string[];
 }
 
-export interface FileDef {
-  workspace: string;
+export interface WorkspaceFileDef {
   path: string;
   content?: string;
   content_from?: string;
@@ -138,18 +135,18 @@ export interface Recipe {
   workspaces?: WorkspaceDef[];
   channels?: ChannelDef[];
   agents?: AgentDef[];
-  files?: FileDef[];
   conversations?: ConversationDef[];
 }
 
 export interface RunOptions {
   vars: Record<string, string>;
   plugins: string[];
+  scope: RunScope;
+  workspaceName?: string;
   dryRun: boolean;
   allowMissing: boolean;
   verbose: boolean;
   silent: boolean;
-  keepOpenClawState: boolean;
   provider: OpenClawProvider;
   remote: Partial<OpenClawRemoteConfig>;
 }