agent-relay 3.2.10 → 3.2.12

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/sdk",
-  "version": "3.2.10",
+  "version": "3.2.12",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -102,7 +102,7 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@agent-relay/config": "3.2.10",
+    "@agent-relay/config": "3.2.12",
     "@relaycast/sdk": "^1.0.0",
     "@sinclair/typebox": "^0.34.48",
     "chalk": "^4.1.2",

package/packages/sdk/src/__tests__/workflow-runner.test.ts

@@ -995,10 +995,10 @@ agents:
       expect(args).toEqual(['-p', 'Analyze']);
     });
 
-    it('should build opencode command with --prompt flag', () => {
+    it('should build opencode command with run subcommand', () => {
       const { cmd, args } = WorkflowRunner.buildNonInteractiveCommand('opencode', 'Fix bug');
       expect(cmd).toBe('opencode');
-      expect(args).toEqual(['--prompt', 'Fix bug']);
+      expect(args).toEqual(['run', 'Fix bug']);
     });
 
     it('should build droid command with exec subcommand', () => {

package/packages/sdk/src/cli-registry.ts

@@ -0,0 +1,148 @@
+/**
+ * Consolidated CLI registry — single source of truth for all supported
+ * agent CLI metadata: binary names, non-interactive args, bypass flags,
+ * and well-known install paths.
+ *
+ * Consumers: runner.ts (buildNonInteractiveCommand, resolveCursorCli),
+ * spawn-from-env.ts (BYPASS_FLAGS), cli-resolver.ts (path resolution).
+ *
+ * NOTE: The Rust PTY spawner (src/pty.rs) maintains its own PATH fallback.
+ * When updating `COMMON_SEARCH_PATHS` here, also update the Rust fallback
+ * in `resolve_command_path()` at src/pty.rs:53-67.
+ */
+
+import type { AgentCli } from './workflows/types.js';
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export interface CliDefinition {
+  /** Binary name(s) to try, in order of preference */
+  binaries: string[];
+  /** Build non-interactive mode args for a one-shot task */
+  nonInteractiveArgs: (task: string, extraArgs?: string[]) => string[];
+  /** Bypass flag for auto-approve / unattended mode */
+  bypassFlag?: string;
+  /** Bypass flag aliases (alternative forms accepted by the CLI) */
+  bypassAliases?: string[];
+  /** Extra install paths to check beyond PATH (resolved relative to $HOME) */
+  searchPaths?: string[];
+}
+
+// ── Well-known install paths ───────────────────────────────────────────────
+
+/**
+ * Common install directories checked when PATH is empty or incomplete.
+ * Paths containing `~` are expanded at resolution time.
+ *
+ * Keep in sync with the Rust fallback in src/pty.rs `resolve_command_path()`.
+ */
+export const COMMON_SEARCH_PATHS = [
+  '~/.local/bin',
+  '~/.opencode/bin',
+  '~/.claude/local',
+  '/usr/local/bin',
+  '/usr/bin',
+  '/bin',
+  '/opt/homebrew/bin',
+];
+
+// ── Registry ───────────────────────────────────────────────────────────────
+
+const CLI_REGISTRY: Record<AgentCli, CliDefinition> = {
+  claude: {
+    binaries: ['claude'],
+    nonInteractiveArgs: (task, extra = []) => [
+      '-p',
+      '--dangerously-skip-permissions',
+      task,
+      ...extra,
+    ],
+    bypassFlag: '--dangerously-skip-permissions',
+    searchPaths: ['~/.claude/local'],
+  },
+  codex: {
+    binaries: ['codex'],
+    nonInteractiveArgs: (task, extra = []) => ['exec', task, ...extra],
+    bypassFlag: '--dangerously-bypass-approvals-and-sandbox',
+    bypassAliases: ['--full-auto'],
+    searchPaths: ['~/.local/bin'],
+  },
+  gemini: {
+    binaries: ['gemini'],
+    nonInteractiveArgs: (task, extra = []) => ['-p', task, ...extra],
+    bypassFlag: '--yolo',
+    bypassAliases: ['-y'],
+  },
+  opencode: {
+    binaries: ['opencode'],
+    nonInteractiveArgs: (task, extra = []) => ['run', task, ...extra],
+    searchPaths: ['~/.opencode/bin'],
+  },
+  droid: {
+    binaries: ['droid'],
+    nonInteractiveArgs: (task, extra = []) => ['exec', task, ...extra],
+  },
+  aider: {
+    binaries: ['aider'],
+    nonInteractiveArgs: (task, extra = []) => [
+      '--message',
+      task,
+      '--yes-always',
+      '--no-git',
+      ...extra,
+    ],
+  },
+  goose: {
+    binaries: ['goose'],
+    nonInteractiveArgs: (task, extra = []) => [
+      'run',
+      '--text',
+      task,
+      '--no-session',
+      ...extra,
+    ],
+  },
+  'cursor-agent': {
+    binaries: ['cursor-agent'],
+    nonInteractiveArgs: (task, extra = []) => [
+      '--force',
+      '-p',
+      task,
+      ...extra,
+    ],
+  },
+  agent: {
+    binaries: ['agent'],
+    nonInteractiveArgs: (task, extra = []) => [
+      '--force',
+      '-p',
+      task,
+      ...extra,
+    ],
+  },
+  cursor: {
+    binaries: ['cursor-agent', 'agent'],
+    nonInteractiveArgs: (task, extra = []) => [
+      '--force',
+      '-p',
+      task,
+      ...extra,
+    ],
+  },
+};
+
+/**
+ * Get the CLI definition for a given CLI identifier.
+ * Handles `cli:model` variants (e.g. `claude:opus`) by extracting the base CLI.
+ */
+export function getCliDefinition(cli: string): CliDefinition | undefined {
+  const baseCli = cli.includes(':') ? cli.split(':')[0] : cli;
+  return CLI_REGISTRY[baseCli as AgentCli];
+}
+
+/**
+ * Get the full registry (read-only).
+ */
+export function getCliRegistry(): Readonly<Record<AgentCli, CliDefinition>> {
+  return CLI_REGISTRY;
+}

package/packages/sdk/src/cli-resolver.ts

@@ -0,0 +1,155 @@
+/**
+ * CLI binary resolver — finds the actual binary path for a given agent CLI.
+ *
+ * Checks PATH first, then falls back to well-known install directories
+ * from the CLI registry. Results are memoized.
+ */
+
+import { execFile } from 'node:child_process';
+import { access, constants } from 'node:fs/promises';
+import { accessSync, constants as constantsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { promisify } from 'node:util';
+import type { AgentCli } from './workflows/types.js';
+import { getCliDefinition, COMMON_SEARCH_PATHS } from './cli-registry.js';
+
+const execFileAsync = promisify(execFile);
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export interface ResolvedCli {
+  /** The binary name that was found */
+  binary: string;
+  /** The full path to the binary */
+  path: string;
+}
+
+// ── Memoization ────────────────────────────────────────────────────────────
+
+// null sentinel means "looked up, not found" — avoids repeating expensive searches
+const resolveCache = new Map<string, ResolvedCli | null>();
+
+/**
+ * Clear the resolution cache. Useful for testing or after PATH changes.
+ */
+export function clearResolveCache(): void {
+  resolveCache.clear();
+}
+
+// ── Path expansion ─────────────────────────────────────────────────────────
+
+function expandHome(p: string): string {
+  if (p.startsWith('~/')) {
+    return join(homedir(), p.slice(2));
+  }
+  return p;
+}
+
+// ── Async resolver ─────────────────────────────────────────────────────────
+
+/**
+ * Resolve a CLI to its binary path. Checks PATH via `which`, then falls
+ * back to well-known install directories from the CLI registry.
+ *
+ * Results are memoized. Returns `undefined` if the binary cannot be found.
+ */
+export async function resolveCli(cli: AgentCli): Promise<ResolvedCli | undefined> {
+  if (resolveCache.has(cli)) {
+    return resolveCache.get(cli) ?? undefined;
+  }
+
+  const def = getCliDefinition(cli);
+  if (!def) return undefined;
+
+  for (const binary of def.binaries) {
+    // Try PATH first via `which`
+    try {
+      const { stdout } = await execFileAsync('which', [binary]);
+      const path = stdout.trim();
+      if (path) {
+        const result: ResolvedCli = { binary, path };
+        resolveCache.set(cli, result);
+        return result;
+      }
+    } catch {
+      // not in PATH
+    }
+
+    // Try well-known install directories (CLI-specific + common)
+    const searchDirs = [...(def.searchPaths ?? []), ...COMMON_SEARCH_PATHS];
+    const seen = new Set<string>();
+    for (const dir of searchDirs) {
+      const expanded = expandHome(dir);
+      if (seen.has(expanded)) continue;
+      seen.add(expanded);
+
+      const candidate = join(expanded, binary);
+      try {
+        await access(candidate, constants.X_OK);
+        const result: ResolvedCli = { binary, path: candidate };
+        resolveCache.set(cli, result);
+        return result;
+      } catch {
+        // not found here
+      }
+    }
+  }
+
+  resolveCache.set(cli, null);
+  return undefined;
+}
+
+// ── Sync resolver (for hot paths that can't be async) ──────────────────────
+
+/**
+ * Synchronous version of `resolveCli`. Uses `which` via execFileSync
+ * and synchronous fs.accessSync. Prefer the async version when possible.
+ */
+export function resolveCliSync(cli: AgentCli): ResolvedCli | undefined {
+  if (resolveCache.has(cli)) {
+    return resolveCache.get(cli) ?? undefined;
+  }
+
+  const def = getCliDefinition(cli);
+  if (!def) return undefined;
+
+  const { execFileSync } = require('node:child_process') as typeof import('node:child_process');
+
+  for (const binary of def.binaries) {
+    // Try PATH first via `which`
+    try {
+      const stdout = execFileSync('which', [binary], { stdio: ['pipe', 'pipe', 'ignore'] });
+      const path = stdout.toString().trim();
+      if (path) {
+        const result: ResolvedCli = { binary, path };
+        resolveCache.set(cli, result);
+        return result;
+      }
+    } catch {
+      // not in PATH
+    }
+
+    // Try well-known install directories
+    const searchDirs = [...(def.searchPaths ?? []), ...COMMON_SEARCH_PATHS];
+    const seen = new Set<string>();
+    for (const dir of searchDirs) {
+      const expanded = expandHome(dir);
+      if (seen.has(expanded)) continue;
+      seen.add(expanded);
+
+      const candidate = join(expanded, binary);
+      try {
+        accessSync(candidate, constantsSync.X_OK);
+        const result: ResolvedCli = { binary, path: candidate };
+        resolveCache.set(cli, result);
+        return result;
+      } catch {
+        // not found here
+      }
+    }
+  }
+
+  resolveCache.set(cli, null);
+  return undefined;
+}

package/packages/sdk/src/index.ts

@@ -11,3 +11,5 @@ export * from './shadow.js';
 export * from './relay-adapter.js';
 export * from './workflows/index.js';
 export * from './spawn-from-env.js';
+export * from './cli-registry.js';
+export * from './cli-resolver.js';

package/packages/sdk/src/spawn-from-env.ts

@@ -13,6 +13,7 @@
  */
 
 import { AgentRelay } from "./relay.js";
+import { getCliDefinition } from "./cli-registry.js";
 
 // ── Types ──────────────────────────────────────────────────────────────────
 
@@ -59,33 +60,21 @@ export interface SpawnFromEnvResult {
   exitCode?: number;
 }
 
-// ── Bypass Policy (SDK-owned, single source of truth) ──────────────────────
+// ── Bypass Policy (delegated to cli-registry) ──────────────────────────────
 
 type BypassFlagConfig = {
   flag: string;
   aliases?: string[];
 };
 
-/** SDK-owned bypass flag mapping. Cloud must NOT duplicate these. */
-const BYPASS_FLAGS: Record<string, BypassFlagConfig> = {
-  claude: { flag: "--dangerously-skip-permissions" },
-  codex: {
-    flag: "--dangerously-bypass-approvals-and-sandbox",
-    aliases: ["--full-auto"],
-  },
-  gemini: {
-    flag: "--yolo",
-    aliases: ["-y"],
-  },
-};
-
 /**
- * Resolve bypass flag config for a CLI.
+ * Resolve bypass flag config for a CLI from the consolidated registry.
  * Handles `claude:model` variants (e.g. `claude:opus`).
  */
 function getBypassFlagConfig(cli: string): BypassFlagConfig | undefined {
-  const baseCli = cli.includes(":") ? cli.split(":")[0] : cli;
-  return BYPASS_FLAGS[baseCli];
+  const def = getCliDefinition(cli);
+  if (!def?.bypassFlag) return undefined;
+  return { flag: def.bypassFlag, aliases: def.bypassAliases };
 }
 
 // ── Env Parsing ────────────────────────────────────────────────────────────

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

@@ -22,6 +22,7 @@ import type {
 } from './types.js';
 import { WorkflowRunner, type WorkflowEventListener, type VariableContext, type StepExecutor } from './runner.js';
 import { formatDryRunReport } from './dry-run-format.js';
+import { createDefaultEventLogger, type LogLevel } from './default-logger.js';
 
 // ── Option types for the builder API ────────────────────────────────────────
 
@@ -106,6 +107,10 @@ export interface WorkflowRunOptions {
   startFrom?: string;
   /** Previous run ID whose cached outputs are used with startFrom. */
   previousRunId?: string;
+  /** Console log verbosity: "verbose" | "normal" (default) | "quiet" | false (silent). */
+  logLevel?: LogLevel;
+  /** Renderer: "listr" for listr2 UI, "default" for console logger, false to disable. */
+  renderer?: 'listr' | 'default' | false;
 }
 
 // ── WorkflowBuilder ─────────────────────────────────────────────────────────
@@ -333,7 +338,11 @@ export class WorkflowBuilder {
     if (this._timeoutMs !== undefined) config.swarm.timeoutMs = this._timeoutMs;
     if (this._channel !== undefined) config.swarm.channel = this._channel;
     if (this._idleNudge !== undefined) config.swarm.idleNudge = this._idleNudge;
-    if (this._errorHandling !== undefined) config.errorHandling = this._errorHandling;
+    config.errorHandling = this._errorHandling ?? {
+      strategy: 'retry',
+      maxRetries: 2,
+      retryDelayMs: 10_000,
+    };
     if (this._coordination !== undefined) config.coordination = this._coordination;
     if (this._state !== undefined) config.state = this._state;
     if (this._trajectories !== undefined) config.trajectories = this._trajectories;
@@ -367,15 +376,23 @@ export class WorkflowBuilder {
       return report;
     }
 
+    // Wire up default console logger unless explicitly disabled
+    // renderer: "listr" owns the terminal — skip console logger to avoid garbled output
+    // renderer: false implies no output at all
+    const logLevel = options.renderer === 'listr' || options.renderer === false
+      ? false
+      : (options.logLevel ?? 'normal');
+    if (logLevel !== false) {
+      runner.on(createDefaultEventLogger(logLevel));
+    }
+
+    // Wire up user-provided event handler (additive — does not replace the default logger)
     if (options.onEvent) {
       runner.on(options.onEvent);
     }
 
     // Auto-detect RESUME_RUN_ID env var for resuming failed runs
     const resumeRunId = process.env.RESUME_RUN_ID;
-    if (resumeRunId) {
-      return runner.resume(resumeRunId, options.vars);
-    }
 
     const startFrom = this._startFrom ?? options.startFrom ?? process.env.START_FROM;
     const previousRunId = this._previousRunId ?? options.previousRunId ?? process.env.PREVIOUS_RUN_ID;
@@ -383,6 +400,29 @@ export class WorkflowBuilder {
       ? { startFrom, previousRunId }
       : undefined;
 
+    // If listr renderer requested, wire it up and run concurrently
+    // Must be set up BEFORE the resume check so resume runs also get event output
+    if (options.renderer === 'listr') {
+      const { createWorkflowRenderer } = await import('./listr-renderer.js');
+      const renderer = createWorkflowRenderer();
+      runner.on(renderer.onEvent);
+
+      const runPromise = resumeRunId
+        ? runner.resume(resumeRunId, options.vars)
+        : runner.execute(config, options.workflow, options.vars, executeOptions);
+
+      try {
+        const [result] = await Promise.all([runPromise, renderer.start()]);
+        return result;
+      } finally {
+        renderer.unmount();
+      }
+    }
+
+    if (resumeRunId) {
+      return runner.resume(resumeRunId, options.vars);
+    }
+
     return runner.execute(config, options.workflow, options.vars, executeOptions);
   }
 }

package/packages/sdk/src/workflows/collectors/opencode.ts

@@ -73,6 +73,32 @@ interface OpenCodePartData {
 function loadDatabaseConstructor(): DatabaseConstructor | null {
   try {
     return require('better-sqlite3') as DatabaseConstructor;
+  } catch {
+    // fall through
+  }
+
+  // Fall back to Node 22+ native node:sqlite (experimental)
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { DatabaseSync } = require('node:sqlite');
+    return function NativeSqliteWrapper(filename: string, options?: { readonly?: boolean; fileMustExist?: boolean }) {
+      const db = new DatabaseSync(filename, { open: true, readOnly: options?.readonly ?? false });
+      return {
+        prepare(sql: string) {
+          const stmt = db.prepare(sql);
+          return {
+            get<T>(params?: unknown): T | undefined {
+              return params != null ? stmt.get(params) as T | undefined : stmt.get() as T | undefined;
+            },
+            all<T>(params?: unknown): T[] {
+              return (params != null ? stmt.all(params) : stmt.all()) as T[];
+            },
+          };
+        },
+        pragma(source: string) { db.exec(`PRAGMA ${source}`); return undefined; },
+        close() { db.close(); },
+      };
+    } as unknown as DatabaseConstructor;
   } catch {
     return null;
   }

package/packages/sdk/src/workflows/default-logger.ts

@@ -0,0 +1,120 @@
+import chalk from 'chalk';
+import type { WorkflowEvent, WorkflowEventListener } from './runner.js';
+
+export type LogLevel = 'verbose' | 'normal' | 'quiet' | false;
+
+const noop: WorkflowEventListener = () => {};
+
+/**
+ * Create a default event logger that writes workflow progress to the console.
+ *
+ * @param level - Log verbosity: "verbose" | "normal" (default) | "quiet" | false (no-op)
+ */
+export function createDefaultEventLogger(level: LogLevel = 'normal'): WorkflowEventListener {
+  if (level === false) return noop;
+
+  return (event: WorkflowEvent) => {
+    switch (event.type) {
+      // ── Run lifecycle ──
+      case 'run:started':
+        if (level !== 'quiet') {
+          console.log(chalk.cyan(`[workflow] run ${event.runId.slice(0, 8)}...`));
+        }
+        break;
+
+      case 'run:completed':
+        console.log(chalk.green(`[workflow] completed`));
+        break;
+
+      case 'run:failed':
+        console.log(chalk.red(`[workflow] FAILED: ${event.error}`));
+        break;
+
+      case 'run:cancelled':
+        if (level !== 'quiet') {
+          console.log(chalk.yellow(`[workflow] cancelled`));
+        }
+        break;
+
+      // ── Step lifecycle ──
+      case 'step:started':
+        if (level !== 'quiet') {
+          console.log(chalk.blue(`  ● ${event.stepName} — started`));
+        }
+        break;
+
+      case 'step:completed':
+        if (level !== 'quiet') {
+          console.log(chalk.green(`  ✓ ${event.stepName} — completed`));
+        }
+        break;
+
+      case 'step:failed':
+        console.log(chalk.red(`  ✗ ${event.stepName} — FAILED: ${event.error}`));
+        break;
+
+      case 'step:skipped':
+        if (level !== 'quiet') {
+          console.log(chalk.gray(`  ○ ${event.stepName} — skipped`));
+        }
+        break;
+
+      case 'step:retrying':
+        if (level !== 'quiet') {
+          console.log(chalk.yellow(`  ↻ ${event.stepName} — retrying (attempt ${event.attempt})`));
+        }
+        break;
+
+      case 'step:nudged':
+        if (level !== 'quiet') {
+          console.log(chalk.yellow(`  ⚡ ${event.stepName} — nudged (${event.nudgeCount})`));
+        }
+        break;
+
+      case 'step:agent-report': {
+        if (level !== 'quiet') {
+          const r = event.report;
+          const parts: string[] = [];
+          if (r.model) parts.push(r.model);
+          if (r.cost != null) parts.push(`$${r.cost.toFixed(2)}`);
+          if (r.tokens) parts.push(`${r.tokens.input}+${r.tokens.output} tokens`);
+          parts.push(`${r.errors.length} errors`);
+          console.log(chalk.dim(`  📊 ${event.stepName} — ${parts.join(' · ')}`));
+        }
+        break;
+      }
+
+      // ── Broker-level events (verbose only) ──
+      case 'broker:event':
+        if (level === 'verbose') {
+          console.log(chalk.dim(`  [broker] ${JSON.stringify(event.event)}`));
+        }
+        break;
+
+      // ── Other events (verbose only) ──
+      case 'step:owner-assigned':
+        if (level === 'verbose') {
+          console.log(chalk.dim(`  ${event.stepName} — owner: ${event.ownerName}, specialist: ${event.specialistName}`));
+        }
+        break;
+
+      case 'step:review-completed':
+        if (level === 'verbose') {
+          console.log(chalk.dim(`  ${event.stepName} — review: ${event.decision} by ${event.reviewerName}`));
+        }
+        break;
+
+      case 'step:owner-timeout':
+        if (level !== 'quiet') {
+          console.log(chalk.yellow(`  ⏱ ${event.stepName} — owner timeout (${event.ownerName})`));
+        }
+        break;
+
+      case 'step:force-released':
+        if (level === 'verbose') {
+          console.log(chalk.dim(`  ${event.stepName} — force-released`));
+        }
+        break;
+    }
+  };
+}

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

@@ -25,3 +25,4 @@ export * from './templates.js';
 export { WorkflowTrajectory, type StepOutcome } from './trajectory.js';
 export { formatDryRunReport } from './dry-run-format.js';
 export { createWorkflowRenderer, type WorkflowRenderer } from './listr-renderer.js';
+export { createDefaultEventLogger } from './default-logger.js';