agent-relay 3.2.18 → 3.2.22

package/packages/sdk/package.json

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

package/packages/sdk/src/__tests__/resume-fallback.test.ts

@@ -0,0 +1,415 @@
+/**
+ * Tests for resuming workflow execution from cached step outputs when the JSONL
+ * run database is missing or unavailable.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  chmodSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import type { WorkflowDb } from '../workflows/runner.js';
+import type { RelayYamlConfig, WorkflowRunRow, WorkflowStepRow } from '../workflows/types.js';
+
+// ── Mock fetch ───────────────────────────────────────────────────────────────
+
+const mockFetch = vi.fn().mockResolvedValue({
+  ok: true,
+  json: () => Promise.resolve({ data: { api_key: 'rk_live_test', workspace_id: 'ws-test' } }),
+  text: () => Promise.resolve(''),
+});
+vi.stubGlobal('fetch', mockFetch);
+
+// ── Mock RelayCast SDK ───────────────────────────────────────────────────────
+
+const mockRelaycastAgent = {
+  send: vi.fn().mockResolvedValue(undefined),
+  heartbeat: vi.fn().mockResolvedValue(undefined),
+  channels: {
+    create: vi.fn().mockResolvedValue(undefined),
+    join: vi.fn().mockResolvedValue(undefined),
+    invite: vi.fn().mockResolvedValue(undefined),
+  },
+};
+
+const mockRelaycast = {
+  agents: {
+    register: vi.fn().mockResolvedValue({ token: 'token-1' }),
+  },
+  as: vi.fn().mockReturnValue(mockRelaycastAgent),
+};
+
+class MockRelayError extends Error {
+  code: string;
+  constructor(code: string, message: string, status = 400) {
+    super(message);
+    this.code = code;
+    this.name = 'RelayError';
+    (this as any).status = status;
+  }
+}
+
+vi.mock('@relaycast/sdk', () => ({
+  RelayCast: vi.fn().mockImplementation(() => mockRelaycast),
+  RelayError: MockRelayError,
+}));
+
+// ── Mock AgentRelay ──────────────────────────────────────────────────────────
+
+let waitForExitFn: (ms?: number) => Promise<'exited' | 'timeout' | 'released'>;
+
+const mockAgent = {
+  name: 'test-agent-abc',
+  get waitForExit() { return waitForExitFn; },
+  get waitForIdle() { return vi.fn().mockImplementation(() => new Promise(() => {})); },
+  release: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockHuman = {
+  name: 'WorkflowRunner',
+  sendMessage: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockRelayInstance = {
+  spawnPty: vi.fn().mockImplementation(async ({ name, task }: { name: string; task?: string }) => {
+    const stepComplete = task?.match(/STEP_COMPLETE:([^\n]+)/)?.[1]?.trim();
+    const isReview = task?.includes('REVIEW_DECISION: APPROVE or REJECT');
+    const output = isReview
+      ? 'REVIEW_DECISION: APPROVE\nREVIEW_REASON: looks good\n'
+      : stepComplete
+        ? `STEP_COMPLETE:${stepComplete}\n`
+        : 'STEP_COMPLETE:unknown\n';
+
+    queueMicrotask(() => {
+      if (typeof mockRelayInstance.onWorkerOutput === 'function') {
+        mockRelayInstance.onWorkerOutput({ name, chunk: output });
+      }
+    });
+
+    return { ...mockAgent, name };
+  }),
+  human: vi.fn().mockReturnValue(mockHuman),
+  shutdown: vi.fn().mockResolvedValue(undefined),
+  onBrokerStderr: vi.fn().mockReturnValue(() => {}),
+  onWorkerOutput: null as ((frame: { name: string; chunk: string }) => void) | null,
+  onMessageReceived: null as any,
+  onAgentSpawned: null as any,
+  onAgentReleased: null as any,
+  onAgentExited: null as any,
+  onAgentIdle: null as any,
+  onDeliveryUpdate: null as any,
+  listAgentsRaw: vi.fn().mockResolvedValue([]),
+};
+
+vi.mock('../relay.js', () => ({
+  AgentRelay: vi.fn().mockImplementation(() => mockRelayInstance),
+}));
+
+// Import after mocking
+const { WorkflowRunner } = await import('../workflows/runner.js');
+const { JsonFileWorkflowDb } = await import('../workflows/file-db.js');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeDb(): WorkflowDb {
+  const runs = new Map<string, WorkflowRunRow>();
+  const steps = new Map<string, WorkflowStepRow>();
+
+  return {
+    insertRun: vi.fn(async (run: WorkflowRunRow) => {
+      runs.set(run.id, { ...run });
+    }),
+    updateRun: vi.fn(async (id: string, patch: Partial<WorkflowRunRow>) => {
+      const existing = runs.get(id);
+      if (existing) runs.set(id, { ...existing, ...patch });
+    }),
+    getRun: vi.fn(async (id: string) => {
+      const run = runs.get(id);
+      return run ? { ...run } : null;
+    }),
+    insertStep: vi.fn(async (step: WorkflowStepRow) => {
+      steps.set(step.id, { ...step });
+    }),
+    updateStep: vi.fn(async (id: string, patch: Partial<WorkflowStepRow>) => {
+      const existing = steps.get(id);
+      if (existing) steps.set(id, { ...existing, ...patch });
+    }),
+    getStepsByRunId: vi.fn(async (runId: string) => {
+      return [...steps.values()].filter((s) => s.runId === runId);
+    }),
+  };
+}
+
+function makeResumeConfig(): RelayYamlConfig {
+  return {
+    version: '1',
+    name: 'test-resume-fallback',
+    swarm: { pattern: 'dag' },
+    agents: [
+      { name: 'agent-a', cli: 'claude' },
+    ],
+    workflows: [
+      {
+        name: 'default',
+        steps: [
+          { name: 'step-a', agent: 'agent-a', task: 'Do step A' },
+          { name: 'step-b', agent: 'agent-a', task: 'Do step B', dependsOn: ['step-a'] },
+          { name: 'step-c', agent: 'agent-a', task: 'Do step C', dependsOn: ['step-b'] },
+        ],
+      },
+    ],
+    trajectories: false,
+  };
+}
+
+function makeTemplateConfig(): RelayYamlConfig {
+  return {
+    version: '1',
+    name: 'test-resume-template',
+    swarm: { pattern: 'dag' },
+    agents: [
+      { name: 'agent-a', cli: 'claude' },
+    ],
+    workflows: [
+      {
+        name: 'default',
+        steps: [
+          { name: 'step-a', agent: 'agent-a', task: 'Generate input' },
+          {
+            name: 'step-b',
+            agent: 'agent-a',
+            task: 'Use cached value: {{steps.step-a.output}}',
+            dependsOn: ['step-a'],
+          },
+        ],
+      },
+    ],
+    trajectories: false,
+  };
+}
+
+function makeRunRow(runId: string, config: RelayYamlConfig, status: WorkflowRunRow['status'] = 'failed'): WorkflowRunRow {
+  const now = new Date().toISOString();
+  return {
+    id: runId,
+    workspaceId: 'ws-test',
+    workflowName: 'default',
+    pattern: config.swarm.pattern,
+    status,
+    config,
+    startedAt: now,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+function makeStepRow(
+  runId: string,
+  stepName: string,
+  task: string,
+  dependsOn: string[] = [],
+  status: WorkflowStepRow['status'] = 'pending',
+  output?: string
+): WorkflowStepRow {
+  const now = new Date().toISOString();
+  return {
+    id: `${runId}-${stepName}`,
+    runId,
+    stepName,
+    agentName: 'agent-a',
+    stepType: 'agent',
+    status,
+    task,
+    dependsOn,
+    output,
+    retryCount: 0,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: status !== 'pending' ? now : undefined,
+    completedAt: status === 'completed' ? now : undefined,
+  };
+}
+
+function writeCachedOutput(tmpDir: string, runId: string, stepName: string, output: string): void {
+  const outputDir = path.join(tmpDir, '.agent-relay', 'step-outputs', runId);
+  mkdirSync(outputDir, { recursive: true });
+  writeFileSync(path.join(outputDir, `${stepName}.md`), output);
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('resume fallback to step-output cache', () => {
+  let db: WorkflowDb;
+  let runner: InstanceType<typeof WorkflowRunner>;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    waitForExitFn = vi.fn().mockResolvedValue('exited');
+    mockRelayInstance.onWorkerOutput = null;
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'resume-fallback-'));
+    db = makeDb();
+    runner = new WorkflowRunner({ db, workspaceId: 'ws-test', cwd: tmpDir });
+  });
+
+  afterEach(() => {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('should reconstruct run from step-output cache when JSONL missing', async () => {
+    const runId = 'resume-cache-run';
+    const config = makeResumeConfig();
+    writeCachedOutput(tmpDir, runId, 'step-a', 'cached-a');
+    writeCachedOutput(tmpDir, runId, 'step-b', 'cached-b');
+
+    const events: Array<{ type: string; stepName?: string }> = [];
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await (runner as any).resume(runId, undefined, config);
+    expect(run.status, run.error).toBe('completed');
+
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).not.toContain('step-a');
+    expect(startedSteps).not.toContain('step-b');
+    expect(startedSteps).toContain('step-c');
+  });
+
+  it('should throw "not found" when neither JSONL nor cache exists', async () => {
+    const config = makeResumeConfig();
+
+    await expect((runner as any).resume('nonexistent-id', undefined, config)).rejects.toThrow('not found');
+  });
+
+  it('should prefer JSONL database over step-output cache', async () => {
+    const runId = 'resume-db-run';
+    const config = makeResumeConfig();
+    const dbPath = path.join(tmpDir, '.agent-relay', 'workflow-runs.jsonl');
+    const fileDb = new JsonFileWorkflowDb(dbPath);
+    const dbRunner = new WorkflowRunner({ db: fileDb, workspaceId: 'ws-test', cwd: tmpDir });
+
+    await fileDb.insertRun(makeRunRow(runId, config));
+    await fileDb.insertStep(makeStepRow(runId, 'step-a', 'Do step A', [], 'failed'));
+    await fileDb.insertStep(makeStepRow(runId, 'step-b', 'Do step B', ['step-a'], 'pending'));
+    await fileDb.insertStep(makeStepRow(runId, 'step-c', 'Do step C', ['step-b'], 'pending'));
+
+    writeCachedOutput(tmpDir, runId, 'step-a', 'cached-a-from-fallback');
+
+    const events: Array<{ type: string; stepName?: string }> = [];
+    dbRunner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await dbRunner.resume(runId);
+    expect(run.status, run.error).toBe('completed');
+
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).toContain('step-a');
+    expect(startedSteps).toContain('step-b');
+    expect(startedSteps).toContain('step-c');
+  });
+
+  it('should handle empty step-output directory gracefully', async () => {
+    const runId = 'resume-empty-cache';
+    const config = makeResumeConfig();
+    mkdirSync(path.join(tmpDir, '.agent-relay', 'step-outputs', runId), { recursive: true });
+
+    const events: Array<{ type: string; stepName?: string }> = [];
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await (runner as any).resume(runId, undefined, config);
+    expect(run.status, run.error).toBe('completed');
+
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).toContain('step-a');
+    expect(startedSteps).toContain('step-b');
+    expect(startedSteps).toContain('step-c');
+  });
+
+  it('should load cached output into step template variables', async () => {
+    const runId = 'resume-template-cache';
+    const config = makeTemplateConfig();
+    writeCachedOutput(tmpDir, runId, 'step-a', 'hello world');
+
+    const run = await (runner as any).resume(runId, undefined, config);
+    expect(run.status, run.error).toBe('completed');
+
+    const spawnedTasks = mockRelayInstance.spawnPty.mock.calls.map(
+      ([args]) => (args as { task?: string }).task ?? ''
+    );
+    expect(spawnedTasks.some((task) => task.includes('Use cached value: hello world'))).toBe(true);
+  });
+
+  it('should skip .report.json files when scanning step outputs', async () => {
+    const runId = 'resume-report-cache';
+    const config = makeResumeConfig();
+    const outputDir = path.join(tmpDir, '.agent-relay', 'step-outputs', runId);
+    mkdirSync(outputDir, { recursive: true });
+    writeFileSync(path.join(outputDir, 'step-a.md'), 'cached-a');
+    writeFileSync(path.join(outputDir, 'step-a.report.json'), '{"summary":"done"}');
+    writeFileSync(path.join(outputDir, 'step-b.report.json'), '{"summary":"metadata only"}');
+
+    const events: Array<{ type: string; stepName?: string }> = [];
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await (runner as any).resume(runId, undefined, config);
+    expect(run.status, run.error).toBe('completed');
+
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).not.toContain('step-a');
+    expect(startedSteps).toContain('step-b');
+    expect(startedSteps).toContain('step-c');
+  });
+});
+
+describe('file-db append diagnostics', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'file-db-warn-'));
+  });
+
+  afterEach(() => {
+    try {
+      chmodSync(path.join(tmpDir, 'readonly'), 0o755);
+    } catch {}
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('should warn once when append fails', async () => {
+    const readonlyDir = path.join(tmpDir, 'readonly');
+    mkdirSync(readonlyDir, { recursive: true });
+    chmodSync(readonlyDir, 0o555);
+
+    const dbPath = path.join(readonlyDir, 'workflow-runs.jsonl');
+    const fileDb = new JsonFileWorkflowDb(dbPath);
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const config = makeResumeConfig();
+
+    await fileDb.insertRun(makeRunRow('warn-run-1', config));
+    await fileDb.insertRun(makeRunRow('warn-run-2', config));
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+
+    warnSpy.mockRestore();
+  });
+});

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

@@ -642,8 +642,7 @@ agents:
       );
 
       expect(ownerAssignments).toContainEqual({ owner: 'relay-worker', specialist: 'relay-worker' });
-      expect(run.status).toBe('failed');
-      expect(run.error).toContain('verification failed');
+      expect(run.status, run.error).toBe('completed');
 
       const spawnCalls = (mockRelayInstance.spawnPty as any).mock.calls;
       expect(spawnCalls).toHaveLength(1);
@@ -652,6 +651,78 @@ agents:
       expect(spawnCalls[0][0].name).not.toContain('-review-');
     });
 
+    it('should spill oversized interactive tasks to a temp file before PTY spawn', async () => {
+      const tmpDir = mkdtempSync(path.join(os.tmpdir(), 'relay-pty-task-'));
+      const oversizedBytes = WorkflowRunner.PTY_TASK_ARG_SIZE_LIMIT + 1024;
+      let spawnedTask = '';
+      let taskFilePath = '';
+      let taskFileContents = '';
+      runner = new WorkflowRunner({ db, workspaceId: 'ws-test', cwd: tmpDir });
+
+      mockRelayInstance.spawnPty.mockImplementation(
+        async ({ name, task }: { name: string; task?: string }) => {
+          spawnedTask = task ?? '';
+          const match = spawnedTask.match(/TASK_FILE:(.+)\n/);
+          if (match) {
+            taskFilePath = match[1].trim();
+            taskFileContents = readFileSync(taskFilePath, 'utf-8');
+          }
+
+          const output = mockSpawnOutputs.shift() ?? 'LEAD_DONE\n';
+          queueMicrotask(() => {
+            if (typeof mockRelayInstance.onWorkerOutput === 'function') {
+              mockRelayInstance.onWorkerOutput({ name, chunk: output });
+            }
+          });
+
+          return { ...mockAgent, name };
+        }
+      );
+
+      try {
+        mockSpawnOutputs = ['LEAD_DONE\n'];
+
+        const run = await runner.execute(
+          makeConfig({
+            agents: [{ name: 'team-lead', cli: 'claude', role: 'Lead coordinator' }],
+            workflows: [
+              {
+                name: 'default',
+                steps: [
+                  {
+                    name: 'prepare',
+                    type: 'deterministic',
+                    command: `node -e "process.stdout.write('A'.repeat(${oversizedBytes}))"`,
+                  },
+                  {
+                    name: 'lead-step',
+                    agent: 'team-lead',
+                    dependsOn: ['prepare'],
+                    task: 'Review the injected context below and then print LEAD_DONE:\n{{steps.prepare.output}}\n/exit',
+                    verification: { type: 'exit_code', value: 0 },
+                  },
+                ],
+              },
+            ],
+          }),
+          'default'
+        );
+
+        expect(run.status, run.error).toBe('completed');
+        expect(spawnedTask).toContain('TASK_FILE:');
+        expect(spawnedTask).not.toContain('{{steps.prepare.output}}');
+        expect(Buffer.byteLength(spawnedTask, 'utf8')).toBeLessThan(2048);
+        expect(taskFilePath).toBeTruthy();
+        expect(Buffer.byteLength(taskFileContents, 'utf8')).toBeGreaterThan(
+          WorkflowRunner.PTY_TASK_ARG_SIZE_LIMIT
+        );
+        expect(taskFileContents).toContain('Review the injected context below');
+        expect(existsSync(taskFilePath)).toBe(false);
+      } finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
     it('should pass canonical bypass args to interactive codex PTY spawns', async () => {
       mockSpawnOutputs = [
         'LEAD_DONE\n',

package/packages/sdk/src/workflows/__tests__/e2big-and-verify.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from 'vitest';
+
+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('runVerification output_contains (token double-count fix)', () => {
+  function createRunner(): InstanceType<typeof WorkflowRunner> {
+    return new WorkflowRunner({ cwd: '/tmp/test' });
+  }
+
+  function runVerification(
+    runner: InstanceType<typeof WorkflowRunner>,
+    check: { type: 'output_contains'; value: string },
+    output: string,
+    stepName: string,
+    injectedTaskText?: string
+  ) {
+    return (runner as any).runVerification(check, output, stepName, injectedTaskText, {
+      allowFailure: true,
+    });
+  }
+
+  it('passes when token is in output and not in task injection', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      'Task completed. DONE',
+      'step1'
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  it('fails when token is missing from output entirely', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      'Task completed without the marker',
+      'step1'
+    );
+    expect(result.passed).toBe(false);
+    expect(result.error).toContain('does not contain "DONE"');
+  });
+
+  it('passes when token is in both task injection and agent output', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'REFLECTION_COMPLETE' },
+      'Your task: output REFLECTION_COMPLETE when done\n\nI have finished. REFLECTION_COMPLETE',
+      'step1',
+      'Your task: output REFLECTION_COMPLETE when done'
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  it('fails when token appears only in task injection (not produced by agent)', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'REFLECTION_COMPLETE' },
+      'Your task: output REFLECTION_COMPLETE when done\n\nI worked on it but forgot the marker.',
+      'step1',
+      'Your task: output REFLECTION_COMPLETE when done'
+    );
+    expect(result.passed).toBe(false);
+    expect(result.error).toContain('does not contain "REFLECTION_COMPLETE"');
+  });
+
+  it('handles token appearing multiple times in task injection', () => {
+    const runner = createRunner();
+    const taskText = 'Output DONE when done. Remember: DONE is required.';
+    const output = taskText + '\n\nAll work complete. DONE';
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      output,
+      'step1',
+      taskText
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  it('fails when token appears same number of times as in task injection', () => {
+    const runner = createRunner();
+    const taskText = 'Output DONE when done. Remember: DONE is required.';
+    const output = taskText + '\n\nAll work complete but no marker here.';
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      output,
+      'step1',
+      taskText
+    );
+    expect(result.passed).toBe(false);
+  });
+
+  it('handles empty token gracefully', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: '' },
+      'some output',
+      'step1'
+    );
+    expect(result.passed).toBe(false);
+  });
+});