agent-relay 3.2.8 → 3.2.10

package/packages/sdk/src/workflows/__tests__/step-cwd.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from 'vitest';
+import path from 'node:path';
+
+vi.mock('@relaycast/sdk', () => ({
+  RelayCast: vi.fn(),
+  RelayError: class RelayError extends Error {},
+}));
+
+vi.mock('../../relay.js', () => ({
+  AgentRelay: vi.fn(),
+}));
+
+const { WorkflowRunner } = await import('../runner.js');
+
+describe('WorkflowRunner step cwd resolution', () => {
+  it('prefers step.cwd over agent.cwd and runner cwd', () => {
+    const runnerRoot = '/runner-root';
+    const runner = new WorkflowRunner({ cwd: runnerRoot });
+
+    const resolved = (runner as any).resolveEffectiveCwd(
+      { name: 'generate', agent: 'worker', task: 'Generate', cwd: 'steps/generate' },
+      { name: 'worker', cli: 'claude', cwd: 'agents/worker' },
+    );
+
+    expect(resolved).toBe(path.resolve(runnerRoot, 'steps/generate'));
+  });
+
+  it('respects step.cwd for deterministic steps', () => {
+    const runnerRoot = '/runner-root';
+    const runner = new WorkflowRunner({ cwd: runnerRoot });
+
+    const resolved = (runner as any).resolveEffectiveCwd({
+      name: 'scaffold',
+      type: 'deterministic',
+      command: 'mkdir -p out',
+      cwd: 'deterministic/setup',
+    });
+
+    expect(resolved).toBe(path.resolve(runnerRoot, 'deterministic/setup'));
+  });
+
+  it('falls back through step.cwd to step.workdir to agent.cwd to runner.cwd', () => {
+    const runnerRoot = '/runner-root';
+    const namedPath = '/named/workdir';
+    const runner = new WorkflowRunner({ cwd: runnerRoot });
+    (runner as any).resolvedPaths.set('generated', namedPath);
+
+    const agentDef = { name: 'worker', cli: 'claude', cwd: 'agents/worker' } as const;
+
+    expect(
+      (runner as any).resolveEffectiveCwd(
+        { name: 's1', agent: 'worker', task: 'Do work', cwd: 'steps/explicit', workdir: 'generated' },
+        agentDef,
+      ),
+    ).toBe(path.resolve(runnerRoot, 'steps/explicit'));
+
+    expect(
+      (runner as any).resolveEffectiveCwd(
+        { name: 's2', agent: 'worker', task: 'Do work', workdir: 'generated' },
+        agentDef,
+      ),
+    ).toBe(namedPath);
+
+    expect(
+      (runner as any).resolveEffectiveCwd({ name: 's3', agent: 'worker', task: 'Do work' }, agentDef),
+    ).toBe(path.resolve(runnerRoot, 'agents/worker'));
+
+    expect(
+      (runner as any).resolveEffectiveCwd({ name: 's4', type: 'deterministic', command: 'pwd' }),
+    ).toBe(runnerRoot);
+  });
+});

package/packages/sdk/src/workflows/builder.ts

@@ -47,6 +47,7 @@ export interface AgentOptions {
 export interface AgentStepOptions {
   agent: string;
   task: string;
+  cwd?: string;
   dependsOn?: string[];
   verification?: VerificationCheck;
   timeoutMs?: number;
@@ -57,6 +58,7 @@ export interface AgentStepOptions {
 export interface DeterministicStepOptions {
   type: 'deterministic';
   command: string;
+  cwd?: string;
   /** Capture stdout as step output for downstream steps. Default: true. */
   captureOutput?: boolean;
   /** Fail if command exit code is non-zero. Default: true. */
@@ -256,6 +258,7 @@ export class WorkflowBuilder {
       }
       step.type = 'deterministic';
       step.command = options.command;
+      if (options.cwd !== undefined) step.cwd = options.cwd;
       if (options.captureOutput !== undefined) step.captureOutput = options.captureOutput;
       if (options.failOnError !== undefined) step.failOnError = options.failOnError;
       if (options.dependsOn !== undefined) step.dependsOn = options.dependsOn;
@@ -280,6 +283,7 @@ export class WorkflowBuilder {
       }
       step.agent = agentOpts.agent;
       step.task = agentOpts.task;
+      if (agentOpts.cwd !== undefined) step.cwd = agentOpts.cwd;
       if (agentOpts.dependsOn !== undefined) step.dependsOn = agentOpts.dependsOn;
       if (agentOpts.verification !== undefined) step.verification = agentOpts.verification;
       if (agentOpts.timeoutMs !== undefined) step.timeoutMs = agentOpts.timeoutMs;

package/packages/sdk/src/workflows/cli-session-collector.ts

@@ -0,0 +1,58 @@
+import type { AgentCli } from './types.js';
+import { ClaudeCodeCollector } from './collectors/claude.js';
+import { CodexCollector } from './collectors/codex.js';
+import { OpenCodeCollector } from './collectors/opencode.js';
+
+export interface CliSessionReport {
+  cli: AgentCli;
+  sessionId: string | null;
+  model: string | null;
+  provider: string | null;
+  durationMs: number | null;
+  cost: number | null;
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+  } | null;
+  turns: number;
+  toolCalls: { name: string; count: number }[];
+  errors: { turn: number; text: string }[];
+  finalStatus: 'completed' | 'failed' | 'unknown';
+  summary: string | null;
+  raw?: object;
+}
+
+export interface CliSessionQuery {
+  cli: AgentCli;
+  cwd: string;
+  startedAt: number;
+  completedAt: number;
+}
+
+export interface CliSessionCollector {
+  canCollect(): boolean;
+  collect(query: CliSessionQuery): Promise<CliSessionReport | null>;
+}
+
+export function createCollector(cli: AgentCli): CliSessionCollector | null {
+  switch (cli) {
+    case 'opencode':
+      return new OpenCodeCollector();
+    case 'claude':
+      return new ClaudeCodeCollector();
+    case 'codex':
+      return new CodexCollector();
+    default:
+      return null;
+  }
+}
+
+export async function collectCliSession(query: CliSessionQuery): Promise<CliSessionReport | null> {
+  const collector = createCollector(query.cli);
+  if (!collector || !collector.canCollect()) {
+    return null;
+  }
+
+  return collector.collect(query);
+}

package/packages/sdk/src/workflows/cli.ts

@@ -10,6 +10,8 @@
  */
 
 import path from 'node:path';
+import chalk from 'chalk';
+
 import type { WorkflowEvent } from './runner.js';
 import { WorkflowRunner } from './runner.js';
 import { JsonFileWorkflowDb } from './file-db.js';
@@ -41,43 +43,261 @@ Examples:
   );
 }
 
-function formatEvent(event: WorkflowEvent): string {
-  switch (event.type) {
-    case 'run:started':
-      return `[run] started (${event.runId})`;
-    case 'run:completed':
-      return `[run] completed`;
-    case 'run:failed':
-      return `[run] failed: ${event.error}`;
-    case 'run:cancelled':
-      return `[run] cancelled`;
-    case 'step:started':
-      return `[step] ${event.stepName} started`;
-    case 'step:owner-assigned':
-      return `[step] ${event.stepName} owner=${event.ownerName} specialist=${event.specialistName}`;
-    case 'step:completed':
-      return `[step] ${event.stepName} completed`;
-    case 'step:review-completed':
-      return `[step] ${event.stepName} review ${event.decision} by ${event.reviewerName}`;
-    case 'step:owner-timeout':
-      return `[step] ${event.stepName} owner ${event.ownerName} timed out`;
-    case 'step:failed':
-      return `[step] ${event.stepName} failed: ${event.error}`;
-    case 'step:skipped':
-      return `[step] ${event.stepName} skipped`;
-    case 'step:retrying':
-      return `[step] ${event.stepName} retrying (attempt ${event.attempt})`;
-    case 'step:nudged':
-      return `[step] ${event.stepName} nudged (nudge #${event.nudgeCount})`;
-    case 'step:force-released':
-      return `[step] ${event.stepName} force-released`;
-    case 'broker:event':
-      return `[broker] ${event.event.kind}`;
-    default: {
-      const _exhaustive: never = event;
-      return `[unknown event] ${(_exhaustive as WorkflowEvent).type}`;
+type RunnerConfig = Awaited<ReturnType<WorkflowRunner['parseYamlFile']>>;
+
+type RunnerResult = Awaited<ReturnType<WorkflowRunner['execute']>>;
+
+type ExecuteOptions = {
+  startFrom: string;
+  previousRunId?: string;
+};
+
+interface RenderableTask {
+  output?: string;
+  title: string;
+}
+
+interface StepHandle {
+  resolve: () => void;
+  reject: (error: Error) => void;
+  setOutput: (text: string) => void;
+  markSkipped: () => void;
+}
+
+// Filter [broker] and [workflow HH:MM] noise while listr owns the terminal,
+// but let the observer URL and channel name through.
+function installOutputFilter(): () => void {
+  const orig = console.log.bind(console);
+  console.log = (...args: unknown[]) => {
+    const str = String(args[0] ?? '');
+    if (str.includes('Observer:') || str.includes('agentrelay.dev') || str.includes('Channel: wf-')) {
+      orig(...args);
+      return;
     }
-  }
+    if (/\[broker\]/.test(str) || /\[workflow\s+\d{2}:\d{2}\]/.test(str)) return;
+    orig(...args);
+  };
+  return () => { console.log = orig; };
+}
+
+async function runWithListr(
+  runner: WorkflowRunner,
+  config: RunnerConfig,
+  workflowName: string | undefined,
+  executeOptions: ExecuteOptions | undefined,
+): Promise<RunnerResult> {
+  const stepHandles = new Map<string, StepHandle>();
+  const restoreConsole = installOutputFilter();
+
+  let resolveWorkflow!: () => void;
+  let rejectWorkflow!: (error: Error) => void;
+  const workflowDone = new Promise<void>((resolve, reject) => {
+    resolveWorkflow = resolve;
+    rejectWorkflow = reject;
+  });
+  workflowDone.catch(() => {});
+
+  let setHeader: (text: string) => void = () => {};
+
+  const { Listr } = await import('listr2');
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const listr = new (Listr as any)(
+    [
+      {
+        title: chalk.dim('Workflow starting...'),
+        task: async (_ctx: unknown, task: any): Promise<void> => {
+          setHeader = (text: string): void => {
+            task.title = text;
+          };
+          await workflowDone;
+        },
+      },
+    ],
+    {
+      concurrent: true,
+      renderer: process.stdout.isTTY ? 'default' : 'verbose',
+      rendererOptions: {
+        collapseErrors: false,
+        showErrorMessage: true,
+      },
+    },
+  );
+
+  runner.on((event: WorkflowEvent) => {
+    switch (event.type) {
+      case 'run:started': {
+        setHeader(chalk.dim(`[workflow] run ${event.runId.slice(0, 8)}...`));
+        break;
+      }
+
+      case 'step:started': {
+        let resolveStep!: () => void;
+        let rejectStep!: (error: Error) => void;
+        let taskRef: RenderableTask | null = null;
+        let skipped = false;
+
+        const done = new Promise<void>((resolve, reject) => {
+          resolveStep = resolve;
+          rejectStep = reject;
+        });
+        done.catch(() => {});
+
+        stepHandles.set(event.stepName, {
+          resolve: resolveStep,
+          reject: rejectStep,
+          setOutput: (text: string) => {
+            if (taskRef) {
+              taskRef.output = text;
+            }
+          },
+          markSkipped: () => {
+            skipped = true;
+            if (taskRef) {
+              taskRef.title = chalk.dim(`${event.stepName} (skipped)`);
+            }
+          },
+        });
+
+        listr.add({
+          title: chalk.white(event.stepName),
+          task: async (_ctx: unknown, task: any): Promise<void> => {
+            taskRef = task as RenderableTask;
+            if (skipped) {
+              taskRef.title = chalk.dim(`${event.stepName} (skipped)`);
+            }
+            await done;
+          },
+          rendererOptions: {
+            persistentOutput: true,
+          },
+        });
+        break;
+      }
+
+      case 'step:owner-assigned': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(
+            chalk.dim(`> Owner: ${event.ownerName}`) +
+              (event.specialistName ? chalk.dim(` - specialist: ${event.specialistName}`) : '')
+          );
+        }
+        break;
+      }
+
+      case 'step:retrying': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(chalk.yellow(`Retrying (attempt ${event.attempt})`));
+        }
+        break;
+      }
+
+      case 'step:nudged': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(chalk.dim(`> Nudge #${event.nudgeCount}`));
+        }
+        break;
+      }
+
+      case 'step:force-released': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(chalk.yellow('> Force-released'));
+        }
+        break;
+      }
+
+      case 'step:review-completed': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(chalk.dim(`> Review: ${event.decision} by ${event.reviewerName}`));
+        }
+        break;
+      }
+
+      case 'step:owner-timeout': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(chalk.red(`> Owner ${event.ownerName} timed out`));
+        }
+        break;
+      }
+
+      case 'step:agent-report': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          const model = event.report.model ? `:${event.report.model}` : '';
+          handle.setOutput(chalk.dim(`> Report collected (${event.report.cli}${model})`));
+        }
+        break;
+      }
+
+      case 'step:completed': {
+        stepHandles.get(event.stepName)?.resolve();
+        break;
+      }
+
+      case 'step:skipped': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.markSkipped();
+          handle.resolve();
+        } else {
+          // Step was skipped without ever being started (downstream of a failure).
+          // Add an already-resolved task so it shows in the listr output.
+          listr.add({
+            title: chalk.dim(`${event.stepName} (skipped)`),
+            task: async (): Promise<void> => {},
+            rendererOptions: { persistentOutput: true },
+          });
+        }
+        break;
+      }
+
+      case 'step:failed': {
+        stepHandles.get(event.stepName)?.reject(new Error(event.error ?? 'Step failed'));
+        break;
+      }
+
+      case 'run:completed': {
+        setHeader(chalk.green('Workflow completed'));
+        resolveWorkflow();
+        break;
+      }
+
+      case 'run:failed': {
+        setHeader(chalk.red(`Workflow failed: ${event.error}`));
+        rejectWorkflow(new Error(event.error ?? 'Workflow failed'));
+        break;
+      }
+
+      case 'run:cancelled': {
+        setHeader(chalk.yellow('Workflow cancelled'));
+        resolveWorkflow();
+        break;
+      }
+
+      case 'broker:event':
+        break;
+
+      default: {
+        const _exhaustive: never = event;
+        void _exhaustive;
+      }
+    }
+  });
+
+  const [result] = await Promise.all([
+    runner.execute(config, workflowName, undefined, executeOptions),
+    listr.run().catch(() => {
+      // Step failures are already represented in runner result.
+    }),
+  ]);
+
+  restoreConsole();
+  return result;
 }
 
 async function main(): Promise<void> {
@@ -96,6 +316,7 @@ async function main(): Promise<void> {
       `[workflow] warning: cannot write to ${dbPath} — run state will not be persisted (--resume unavailable)`
     );
   }
+
   const runner = new WorkflowRunner({ db: fileDb });
   let shuttingDown = false;
   const shutdown = async (signal: string): Promise<void> => {
@@ -113,17 +334,37 @@ async function main(): Promise<void> {
   if (resumeIdx !== -1) {
     const runId = args[resumeIdx + 1];
     if (!runId) {
-      console.error('Error: --resume requires a run ID');
+      console.error(chalk.red('Error: --resume requires a run ID'));
       process.exit(1);
     }
-    console.log(`Resuming run ${runId}...`);
-    runner.on((event) => console.log(formatEvent(event)));
+
+    console.log(chalk.dim(`Resuming run ${runId}...`));
+    runner.on((event: WorkflowEvent) => {
+      const ts = new Date().toISOString().slice(11, 19);
+      switch (event.type) {
+        case 'step:started':
+          console.log(chalk.dim(`[${ts}]`), chalk.white(event.stepName), chalk.dim('started'));
+          break;
+        case 'step:completed':
+          console.log(chalk.dim(`[${ts}]`), chalk.green('✔'), event.stepName);
+          break;
+        case 'step:failed':
+          console.log(chalk.dim(`[${ts}]`), chalk.red('✗'), event.stepName, chalk.red(event.error ?? ''));
+          break;
+        case 'step:skipped':
+          console.log(chalk.dim(`[${ts}]`), chalk.dim('⊘'), chalk.dim(event.stepName));
+          break;
+        default:
+          break;
+      }
+    });
     const result = await runner.resume(runId);
+
     if (result.status === 'completed') {
-      console.log(`\nWorkflow completed successfully.`);
+      console.log(chalk.green('\nWorkflow completed successfully.'));
       process.exit(0);
     } else {
-      console.error(`\nWorkflow ${result.status}${result.error ? `: ${result.error}` : ''}`);
+      console.error(chalk.red(`\nWorkflow ${result.status}${result.error ? `: ${result.error}` : ''}`));
       process.exit(1);
     }
     return;
@@ -151,18 +392,17 @@ async function main(): Promise<void> {
   }
 
   const isValidate = args.includes('--validate');
-
-  console.log(`Running workflow from ${yamlPath}...`);
-
   const isDryRun = !!process.env.DRY_RUN;
 
   const config = await runner.parseYamlFile(yamlPath);
+
   if (isValidate) {
     const { validateWorkflow, formatValidationReport } = await import('./validator.js');
     const issues = validateWorkflow(config);
     console.log(formatValidationReport(issues, yamlPath));
-    process.exit(issues.some((i) => i.severity === 'error') ? 1 : 0);
+    process.exit(issues.some((issue) => issue.severity === 'error') ? 1 : 0);
   }
+
   if (isDryRun) {
     const { formatDryRunReport } = await import('./dry-run-format.js');
     const report = runner.dryRun(config, workflowName);
@@ -170,20 +410,19 @@ async function main(): Promise<void> {
     process.exit(report.valid ? 0 : 1);
   }
 
-  runner.on((event) => console.log(formatEvent(event)));
   const executeOptions = startFromStep ? { startFrom: startFromStep, previousRunId } : undefined;
-  const result = await runner.execute(config, workflowName, undefined, executeOptions);
+  const result = await runWithListr(runner, config, workflowName, executeOptions);
 
   if (result.status === 'completed') {
-    console.log(`\nWorkflow completed successfully.`);
+    console.log(chalk.green('\nWorkflow completed successfully.'));
     process.exit(0);
   } else {
-    console.error(`\nWorkflow ${result.status}${result.error ? `: ${result.error}` : ''}`);
+    console.error(chalk.red(`\nWorkflow ${result.status}${result.error ? `: ${result.error}` : ''}`));
     process.exit(1);
   }
 }
 
 main().catch((err: Error) => {
-  console.error(`Error: ${err.message}`);
+  console.error(chalk.red(`Error: ${err.message}`));
   process.exit(1);
 });