feat(cli, vscode): Support bash command execution for Pochi workflows (#554)

* feat: Support bash command execution for Pochi workflows

- Add new bash command execution functionality for workflows
- Parse allowed-tools from workflow frontmatter as raw strings
- Extract and validate bash commands from workflow content
- Execute validated commands with proper abort signal handling
- Integrate bash command execution into live chat kit
- Update workflow prompt generation to include allowed-tools attribute
- Add micromatch dependency for pattern matching

* update

* update

* update

* update

* update: workflow utils

* update

* update

* update: cli

* update

* update

* update: createBashOutputsReminder

* update: remove executeWorkflowBashCommands

* update

* update: onOverrideMessages

* revert workflows.mdx

Author: liangfung

packages/cli/src/on-override-messages.ts

@@ -0,0 +1,60 @@
+import { exec } from "node:child_process";
+import { prompts } from "@getpochi/common";
+import { extractWorkflowBashCommands } from "@getpochi/common/message-utils";
+import type { UIMessage } from "ai";
+
+export function createOnOverrideMessages(cwd: string) {
+  return async function onOverrideMessages({
+    messages,
+  }: { messages: UIMessage[] }) {
+    const lastMessage = messages.at(-1);
+    if (lastMessage?.role === "user") {
+      await appendWorkflowBashOutputs(cwd, lastMessage);
+    }
+  };
+}
+
+async function appendWorkflowBashOutputs(cwd: string, message: UIMessage) {
+  if (message.role !== "user") return;
+
+  const commands = extractWorkflowBashCommands(message);
+  if (!commands.length) return [];
+
+  const bashCommandResults: {
+    command: string;
+    output: string;
+    error?: string;
+  }[] = [];
+  for (const command of commands) {
+    try {
+      const { output, error } = await executeBashCommand(cwd, command);
+      bashCommandResults.push({ command, output, error });
+    } catch (e) {
+      const error = e instanceof Error ? e.message : String(e);
+      bashCommandResults.push({ command, output: "", error });
+      // The AbortError is a specific error that should stop the whole process.
+      if (e instanceof Error && e.name === "AbortError") {
+        break;
+      }
+    }
+  }
+
+  if (bashCommandResults.length) {
+    prompts.injectBashOutputs(message, bashCommandResults);
+  }
+}
+
+function executeBashCommand(
+  cwd: string,
+  command: string,
+): Promise<{ output: string; error?: string }> {
+  return new Promise((resolve) => {
+    exec(command, { cwd }, (error, stdout, stderr) => {
+      if (error) {
+        resolve({ output: stdout, error: stderr || error.message });
+      } else {
+        resolve({ output: stdout });
+      }
+    });
+  });
+}

packages/cli/src/task-runner.ts

@@ -27,6 +27,7 @@ import type z from "zod/v4";
 import { readEnvironment } from "./lib/read-environment";
 import { StepCount } from "./lib/step-count";
 import { Chat } from "./livekit";
+import { createOnOverrideMessages } from "./on-override-messages";
 import { executeToolCall } from "./tools";
 import type { ToolCallOptions } from "./types";
 
@@ -144,6 +145,7 @@ export class TaskRunner {
       isSubTask: options.isSubTask,
       customAgent: options.customAgent,
       outputSchema: options.outputSchema,
+      onOverrideMessages: createOnOverrideMessages(this.cwd),
       getters: {
         getLLM: () => options.llm,
         getEnvironment: async () => ({

packages/common/src/base/prompts/index.ts

@@ -1,6 +1,7 @@
 import { createCompactPrompt } from "./compact";
 import { createEnvironmentPrompt, injectEnvironment } from "./environment";
 import { generateTitle } from "./generate-title";
+import { injectBashOutputs } from "./inject-bash-outputs";
 import { createSystemPrompt } from "./system";
 
 export const prompts = {
@@ -16,6 +17,7 @@ export const prompts = {
   parseInlineCompact,
   generateTitle,
   workflow: createWorkflowPrompt,
+  injectBashOutputs,
 };
 
 function createSystemReminder(content: string) {

packages/common/src/base/prompts/inject-bash-outputs.ts

@@ -0,0 +1,43 @@
+import type { TextUIPart, UIMessage } from "ai";
+import { prompts } from "./index";
+
+export function injectBashOutputs(
+  message: UIMessage,
+  outputs: {
+    command: string;
+    output: string;
+    error?: string | undefined;
+  }[],
+) {
+  const bashCommandOutputs = outputs.map(({ command, output, error }) => {
+    let result = `$ ${command}`;
+    if (output) {
+      result += `\n${output}`;
+    }
+    if (error) {
+      result += `\nERROR: ${error}`;
+    }
+    return result;
+  });
+
+  const reminderPart = {
+    type: "text",
+    text: prompts.createSystemReminder(
+      `Bash command outputs:\n${bashCommandOutputs.join("\n\n")}`,
+    ),
+  } satisfies TextUIPart;
+
+  const workflowPartIndex = message.parts.findIndex(isWorkflowTextPart);
+  const indexToInsert = workflowPartIndex === -1 ? 0 : workflowPartIndex;
+  message.parts = [
+    ...message.parts.slice(0, indexToInsert),
+    reminderPart,
+    ...message.parts.slice(indexToInsert),
+  ];
+}
+
+function isWorkflowTextPart(part: UIMessage["parts"][number]) {
+  return (
+    part.type === "text" && /<workflow[^>]*>(.*?)<\/workflow>/gs.test(part.text)
+  );
+}

packages/common/src/message-utils/__tests__/workflow.test.ts

@@ -0,0 +1,88 @@
+import type { UIMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import { extractWorkflowBashCommands } from "../workflow";
+
+describe("extractWorkflowBashCommands", () => {
+  it("should extract bash commands from a workflow", () => {
+    const message: UIMessage = {
+      id: "1",
+      role: "user",
+      parts: [
+        {
+          type: "text",
+          text: `<workflow id="test-workflow" path=".pochi/workflows/test.md">
+## Context
+- Current git status: !\`git status\`
+- Current git diff (staged and unstaged changes): !\`git diff HEAD\`
+## Task
+Create a git commit.
+</workflow>`,
+        },
+      ],
+    };
+
+    const commands = extractWorkflowBashCommands(message);
+
+    expect(commands).toEqual(["git status", "git diff HEAD"]);
+  });
+
+  it("should handle messages with no workflows", () => {
+    const message: UIMessage = {
+      id: "1",
+      role: "user",
+      parts: [
+        {
+          type: "text",
+          text: "This is a regular message with no workflows.",
+        },
+      ],
+    };
+
+    const commands = extractWorkflowBashCommands(message);
+
+    expect(commands).toEqual([]);
+  });
+
+  it("should handle workflows with no bash commands", () => {
+    const message: UIMessage = {
+      id: "1",
+      role: "user",
+      parts: [
+        {
+          type: "text",
+          text: `<workflow id="test-workflow" path=".pochi/workflows/test.md">
+This workflow has no bash commands.
+</workflow>`,
+        },
+      ],
+    };
+
+    const commands = extractWorkflowBashCommands(message);
+
+    expect(commands).toEqual([]);
+  });
+
+  it("should handle multiple workflow parts", () => {
+    const message: UIMessage = {
+      id: "1",
+      role: "user",
+      parts: [
+        {
+          type: "text",
+          text: `<workflow>First command: !\`command1\`</workflow>`,
+        },
+        {
+          type: "text",
+          text: "Some text in between",
+        },
+        {
+          type: "text",
+          text: `<workflow>Second command: !\`command2\`</workflow>`,
+        },
+      ],
+    };
+
+    const commands = extractWorkflowBashCommands(message);
+    expect(commands).toEqual(["command1", "command2"]);
+  });
+});

packages/common/src/message-utils/index.ts

@@ -8,3 +8,4 @@ export {
   isAssistantMessageWithOutputError,
 } from "./assistant-message";
 export { mergeTodos, findTodos } from "./todo";
+export { extractWorkflowBashCommands } from "./workflow";

packages/common/src/message-utils/workflow.ts

@@ -0,0 +1,45 @@
+import type { UIMessage } from "ai";
+
+/**
+ * Extracts bash commands from a markdown string and returns the list of commands.
+ *
+ * @param content The markdown content to parse.
+ * @returns An array of bash commands.
+ */
+function extractBashCommands(content: string): string[] {
+  const commands: string[] = [];
+  const commandRegex = /!\`(.+?)\`/g;
+
+  let match: RegExpExecArray | null;
+  // biome-ignore lint/suspicious/noAssignInExpressions: off
+  while ((match = commandRegex.exec(content)) !== null) {
+    const actualCommand = match[1].trim();
+    if (actualCommand) {
+      commands.push(actualCommand);
+    }
+  }
+
+  return commands;
+}
+
+const tag = "workflow";
+const workflowRegex = new RegExp(`<${tag}([^>]*)>(.*?)<\/${tag}>`, "gs");
+
+export function extractWorkflowBashCommands(message: UIMessage): string[] {
+  const workflowContents: string[] = [];
+
+  for (const part of message.parts) {
+    if (part.type === "text") {
+      const matches = part.text.matchAll(workflowRegex);
+      for (const match of matches) {
+        const content = match[2];
+        workflowContents.push(content);
+      }
+    }
+  }
+  let commands: string[] = [];
+  for (const x of workflowContents) {
+    commands = commands.concat(extractBashCommands(x));
+  }
+  return commands;
+}

packages/common/src/vscode-webui-bridge/webview-stub.ts

@@ -68,6 +68,12 @@ const VSCodeHostStub = {
   ): Promise<unknown> => {
     return Promise.resolve(undefined);
   },
+  executeBashCommand: (
+    _command: string,
+    _abortSignal: ThreadAbortSignalSerialization,
+  ): Promise<{ output: string; error?: string }> => {
+    return Promise.resolve({} as { output: string; error?: string });
+  },
   listFilesInWorkspace: (): Promise<{ filepath: string; isDir: boolean }[]> => {
     return Promise.resolve([{ filepath: "test", isDir: false }]);
   },

packages/common/src/vscode-webui-bridge/webview.ts

@@ -156,6 +156,11 @@ export interface VSCodeHostApi {
 
   readCustomAgents(): Promise<ThreadSignalSerialization<CustomAgentFile[]>>;
 
+  executeBashCommand: (
+    command: string,
+    abortSignal: ThreadAbortSignalSerialization,
+  ) => Promise<{ output: string; error?: string }>;
+
   readMinionId(): Promise<string | null>;
 
   /**

packages/livekit/src/chat/live-chat-kit.ts

@@ -34,6 +34,7 @@ export type LiveChatKitOptions<T> = {
 
   onOverrideMessages?: (options: {
     messages: Message[];
+    abortSignal: AbortSignal;
   }) => void | Promise<void>;
 
   customAgent?: CustomAgent;
@@ -128,7 +129,7 @@ export class LiveChatKit<
         }
       }
       if (onOverrideMessages) {
-        await onOverrideMessages({ messages });
+        await onOverrideMessages({ messages, abortSignal });
       }
     };