clawchef 0.1.7 → 0.1.9

package/src/cli.ts

@@ -6,7 +6,7 @@ import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
 import { recipeSchema } from "./schema.js";
 import { scaffoldProject } from "./scaffold.js";
-import type { RunOptions, RunScope } from "./types.js";
+import type { GatewayMode, RunOptions, RunScope } from "./types.js";
 import YAML from "js-yaml";
 import path from "node:path";
 import { readFileSync } from "node:fs";
@@ -68,6 +68,13 @@ function parseScope(value: string): RunScope {
   throw new ClawChefError(`Invalid --scope value: ${value}. Expected full, files, or workspace`);
 }
 
+function parseGatewayMode(value: string): GatewayMode {
+  if (value === "service" || value === "run" || value === "none") {
+    return value;
+  }
+  throw new ClawChefError(`Invalid --gateway-mode value: ${value}. Expected service, run, or none`);
+}
+
 function parseOptionalInt(value: string | undefined, fieldName: string): number | undefined {
   if (value === undefined) {
     return undefined;
@@ -112,6 +119,7 @@ export function buildCli(): Command {
     .option("-s, --silent", "Skip reset confirmation prompt", false)
     .option("--scope <scope>", "Run scope: full | files | workspace", "full")
     .option("--workspace <name>", "Workspace name (required when --scope workspace)")
+    .option("--gateway-mode <mode>", "Gateway mode: service | run | none", "service")
     .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]), [])
@@ -130,6 +138,7 @@ export function buildCli(): Command {
 
       const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
       const scope = parseScope(String(opts.scope ?? "full"));
+      const gatewayMode = parseGatewayMode(String(opts.gatewayMode ?? "service"));
       const workspaceName = opts.workspace?.trim() ? String(opts.workspace).trim() : undefined;
       if (scope === "workspace" && !workspaceName) {
         throw new ClawChefError("--scope workspace requires --workspace <name>");
@@ -142,6 +151,7 @@ export function buildCli(): Command {
         plugins: parsePluginFlags(opts.plugin),
         scope,
         workspaceName,
+        gatewayMode,
         dryRun: Boolean(opts.dryRun),
         allowMissing: Boolean(opts.allowMissing),
         verbose: Boolean(opts.verbose),

package/src/openclaw/command-provider.ts

@@ -6,7 +6,7 @@ import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { ClawChefError } from "../errors.js";
-import type { AgentDef, ChannelDef, ConversationDef, OpenClawBootstrap, OpenClawSection } from "../types.js";
+import type { AgentDef, ChannelDef, ConversationDef, GatewayMode, OpenClawBootstrap, OpenClawSection } from "../types.js";
 import type { EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from "./provider.js";
 
 const DEFAULT_COMMANDS = {
@@ -16,7 +16,9 @@ const DEFAULT_COMMANDS = {
   install_plugin: "${bin} plugins install ${plugin_spec_q}",
   factory_reset: "${bin} reset --scope full --yes --non-interactive",
   start_gateway: "${bin} gateway start",
+  run_gateway: "${bin} gateway run",
   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,6 +33,20 @@ 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;
 
@@ -280,6 +296,39 @@ function bootstrapRuntimeEnv(bootstrap: OpenClawBootstrap | undefined): Record<s
   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[]>();
 
@@ -416,9 +465,14 @@ export class CommandOpenClawProvider implements OpenClawProvider {
     await runShell(cmd, dryRun);
   }
 
-  async startGateway(config: OpenClawSection, dryRun: boolean): Promise<void> {
+  async startGateway(config: OpenClawSection, mode: GatewayMode, dryRun: boolean): Promise<void> {
+    if (mode === "none") {
+      return;
+    }
+
     const bin = config.bin ?? "openclaw";
-    const startCmd = commandFor(config, "start_gateway", { bin, version: config.version });
+    const key = mode === "run" ? "run_gateway" : "start_gateway";
+    const startCmd = commandFor(config, key, { bin, version: config.version });
     if (!startCmd.trim()) {
       return;
     }
@@ -502,6 +556,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

@@ -1,4 +1,4 @@
-import type { AgentDef, ChannelDef, ConversationDef, OpenClawSection } from "../types.js";
+import type { AgentDef, ChannelDef, ConversationDef, GatewayMode, OpenClawSection } from "../types.js";
 import type { EnsureVersionResult, OpenClawProvider, ResolvedWorkspaceDef } from "./provider.js";
 
 interface MockState {
@@ -57,7 +57,7 @@ export class MockOpenClawProvider implements OpenClawProvider {
     this.state.messages.clear();
   }
 
-  async startGateway(_config: OpenClawSection, _dryRun: boolean): Promise<void> {
+  async startGateway(_config: OpenClawSection, _mode: GatewayMode, _dryRun: boolean): Promise<void> {
     return;
   }
 
@@ -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

@@ -1,4 +1,4 @@
-import type { AgentDef, ChannelDef, ConversationDef, OpenClawSection, WorkspaceDef } from "../types.js";
+import type { AgentDef, ChannelDef, ConversationDef, GatewayMode, OpenClawSection, WorkspaceDef } from "../types.js";
 
 export type ResolvedWorkspaceDef = WorkspaceDef & { path: string };
 
@@ -15,9 +15,10 @@ export interface OpenClawProvider {
   ): 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>;
+  startGateway(config: OpenClawSection, mode: GatewayMode, 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

@@ -3,6 +3,7 @@ import type {
   AgentDef,
   ChannelDef,
   ConversationDef,
+  GatewayMode,
   OpenClawRemoteConfig,
   OpenClawSection,
 } from "../types.js";
@@ -176,8 +177,11 @@ export class RemoteOpenClawProvider implements OpenClawProvider {
     await this.perform(config, "factory_reset", undefined, dryRun);
   }
 
-  async startGateway(config: OpenClawSection, dryRun: boolean): Promise<void> {
-    await this.perform(config, "start_gateway", undefined, dryRun);
+  async startGateway(config: OpenClawSection, mode: GatewayMode, dryRun: boolean): Promise<void> {
+    if (mode === "none") {
+      return;
+    }
+    await this.perform(config, "start_gateway", { mode }, dryRun);
   }
 
   async createWorkspace(config: OpenClawSection, workspace: ResolvedWorkspaceDef, dryRun: boolean): Promise<void> {
@@ -188,6 +192,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

@@ -62,6 +62,19 @@ function resolveWorkspacePath(recipeOrigin: RecipeOrigin, name: string, configur
   return path.join(homedir(), ".openclaw", workspaceName);
 }
 
+function resolveOpenClawRootPath(recipeOrigin: RecipeOrigin, configuredPath?: string): string {
+  if (configuredPath?.trim()) {
+    if (path.isAbsolute(configuredPath)) {
+      return configuredPath;
+    }
+    if (recipeOrigin.kind === "local") {
+      return path.resolve(recipeOrigin.recipeDir, configuredPath);
+    }
+    return path.resolve(configuredPath);
+  }
+  return path.join(homedir(), ".openclaw");
+}
+
 function isHttpUrl(value: string): boolean {
   try {
     const url = new URL(value);
@@ -197,6 +210,76 @@ export async function runRecipe(
     logger.info(`Plugin preinstalled: ${pluginSpec}`);
   }
 
+  const root = recipe.openclaw.root;
+  if (root && (root.assets?.trim() || (root.files?.length ?? 0) > 0)) {
+    if (remoteMode) {
+      throw new ClawChefError("openclaw.root assets/files are not supported with --provider remote");
+    }
+
+    const openclawRootPath = resolveOpenClawRootPath(recipeOrigin, root.path);
+    if (!options.dryRun) {
+      await mkdir(openclawRootPath, { recursive: true });
+    }
+
+    if (root.assets?.trim()) {
+      const resolvedAssets = resolveFileRef(recipeOrigin, root.assets);
+      if (resolvedAssets.kind !== "local") {
+        throw new ClawChefError(
+          `openclaw.root.assets must resolve to a local directory: ${root.assets}. Direct URL recipes cannot use openclaw.root.assets.`,
+        );
+      }
+
+      let assetDirStat;
+      try {
+        assetDirStat = await stat(resolvedAssets.value);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ClawChefError(`openclaw.root.assets path is not accessible: ${resolvedAssets.value} (${message})`);
+      }
+      if (!assetDirStat.isDirectory()) {
+        throw new ClawChefError(`openclaw.root.assets must be a directory: ${resolvedAssets.value}`);
+      }
+
+      const assetFiles = await collectLocalAssetFiles(resolvedAssets.value);
+      for (const assetFile of assetFiles) {
+        const target = path.resolve(openclawRootPath, assetFile.relativePath);
+        if (!options.dryRun) {
+          await mkdir(path.dirname(target), { recursive: true });
+          await copyFile(assetFile.absolutePath, target);
+        }
+        logger.info(`OpenClaw root asset copied: ${assetFile.relativePath}`);
+      }
+    }
+
+    for (const file of root.files ?? []) {
+      const target = path.resolve(openclawRootPath, 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(`OpenClaw root file materialized: ${file.path}`);
+    }
+  }
+
   for (const ws of recipe.workspaces ?? []) {
     const absPath = resolveWorkspacePath(recipeOrigin, ws.name, ws.path);
     workspacePaths.set(ws.name, absPath);
@@ -261,8 +344,18 @@ 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 workspace of recipe.workspaces ?? []) {
@@ -365,20 +458,27 @@ export async function runRecipe(
     logger.info(`Preset messages sent: ${conv.workspace}/${conv.agent}`);
   }
 
-  await provider.startGateway(recipe.openclaw, options.dryRun);
-  logger.info("Gateway started");
+  await provider.startGateway(recipe.openclaw, options.gatewayMode, options.dryRun);
+  if (options.gatewayMode === "none") {
+    logger.info("Gateway start skipped by gateway mode: none");
+  } else {
+    logger.info(`Gateway started (${options.gatewayMode})`);
+  }
 
   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");

package/src/recipe.ts

@@ -193,12 +193,26 @@ function filterRecipeByWorkspaceName(recipe: Recipe, workspaceName: string): Rec
 
 function semanticValidate(recipe: Recipe): void {
   const ws = new Set((recipe.workspaces ?? []).map((w) => w.name));
+  const agentNameCounts = new Map<string, number>();
+  const root = recipe.openclaw.root;
+  if (root?.path !== undefined && !root.path.trim()) {
+    throw new ClawChefError("openclaw.root.path cannot be empty");
+  }
+  if (root?.assets !== undefined && !root.assets.trim()) {
+    throw new ClawChefError("openclaw.root.assets cannot be empty");
+  }
+  for (const file of root?.files ?? []) {
+    if (!file.path.trim()) {
+      throw new ClawChefError("openclaw.root.files[] has file with empty path");
+    }
+  }
   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}`);
     }
@@ -238,6 +252,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()) ||

package/src/schema.ts

@@ -14,7 +14,9 @@ const openClawCommandsSchema = z
     install_plugin: z.string().optional(),
     factory_reset: z.string().optional(),
     start_gateway: z.string().optional(),
+    run_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(),
@@ -48,12 +50,34 @@ const openClawBootstrapSchema = z
   })
   .strict();
 
+const rootFileSchema = 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: "openclaw.root.files[] requires exactly one of content, content_from, or source",
+  });
+
+const openClawRootSchema = z
+  .object({
+    path: z.string().min(1).optional(),
+    assets: z.string().min(1).optional(),
+    files: z.array(rootFileSchema).optional(),
+  })
+  .strict();
+
 const openClawSchema = z
   .object({
     bin: z.string().optional(),
     version: z.string(),
     install: z.enum(["auto", "always", "never"]).optional(),
     plugins: z.array(z.string().min(1)).optional(),
+    root: openClawRootSchema.optional(),
     bootstrap: openClawBootstrapSchema.optional(),
     commands: openClawCommandsSchema.optional(),
   })
@@ -87,6 +111,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(),

package/src/types.ts

@@ -1,6 +1,7 @@
 export type InstallPolicy = "auto" | "always" | "never";
 export type OpenClawProvider = "command" | "mock" | "remote";
 export type RunScope = "full" | "files" | "workspace";
+export type GatewayMode = "service" | "run" | "none";
 
 export interface OpenClawRemoteConfig {
   base_url: string;
@@ -24,7 +25,9 @@ export interface OpenClawCommandOverrides {
   install_plugin?: string;
   factory_reset?: string;
   start_gateway?: string;
+  run_gateway?: string;
   enable_plugin?: string;
+  bind_channel_agent?: string;
   login_channel?: string;
   create_workspace?: string;
   create_agent?: string;
@@ -60,10 +63,17 @@ export interface OpenClawSection {
   version: string;
   install?: InstallPolicy;
   plugins?: string[];
+  root?: OpenClawRootDef;
   bootstrap?: OpenClawBootstrap;
   commands?: OpenClawCommandOverrides;
 }
 
+export interface OpenClawRootDef {
+  path?: string;
+  assets?: string;
+  files?: WorkspaceFileDef[];
+}
+
 export interface WorkspaceDef {
   name: string;
   path?: string;
@@ -74,6 +84,7 @@ export interface WorkspaceDef {
 export interface ChannelDef {
   channel: string;
   account?: string;
+  agent?: string;
   login?: boolean;
   login_mode?: "interactive";
   login_account?: string;
@@ -141,6 +152,7 @@ export interface RunOptions {
   plugins: string[];
   scope: RunScope;
   workspaceName?: string;
+  gatewayMode: GatewayMode;
   dryRun: boolean;
   allowMissing: boolean;
   verbose: boolean;