agent-relay 4.0.2 → 4.0.4

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

@@ -77,13 +77,7 @@ const mockHuman = {
   sendMessage: vi.fn().mockResolvedValue(undefined),
 };
 
-const defaultSpawnPtyImplementation = async ({
-  name,
-  task,
-}: {
-  name: string;
-  task?: string;
-}) => {
+const defaultSpawnPtyImplementation = async ({ name, task }: { name: string; task?: string }) => {
   const queued = mockSpawnOutputs.shift();
   const stepComplete = task?.match(/STEP_COMPLETE:([^\n]+)/)?.[1]?.trim();
   const isReview = task?.includes('REVIEW_DECISION: APPROVE or REJECT');
@@ -578,10 +572,7 @@ agents:
     });
 
     it('should apply verification fallback for self-owned interactive steps', async () => {
-      mockSpawnOutputs = [
-        'LEAD_DONE\n',
-        'REVIEW_DECISION: APPROVE\nREVIEW_REASON: verified\n',
-      ];
+      mockSpawnOutputs = ['LEAD_DONE\n', 'REVIEW_DECISION: APPROVE\nREVIEW_REASON: verified\n'];
 
       const run = await runner.execute(
         makeConfig({
@@ -724,10 +715,7 @@ agents:
     });
 
     it('should pass canonical bypass args to interactive codex PTY spawns', async () => {
-      mockSpawnOutputs = [
-        'LEAD_DONE\n',
-        'REVIEW_DECISION: APPROVE\nREVIEW_REASON: verified\n',
-      ];
+      mockSpawnOutputs = ['LEAD_DONE\n', 'REVIEW_DECISION: APPROVE\nREVIEW_REASON: verified\n'];
 
       const run = await runner.execute(
         makeConfig({
@@ -877,44 +865,40 @@ agents:
       const workerRelease = vi.fn().mockResolvedValue(undefined);
       const ownerRelease = vi.fn().mockResolvedValue(undefined);
 
-      mockRelayInstance.spawnPty.mockImplementation(async ({
-        name,
-        task,
-      }: {
-        name: string;
-        task?: string;
-      }) => {
-        const isOwner = name.includes('-owner-');
-        const output = isOwner ? 'owner checking\n' : 'worker finished\n';
-
-        queueMicrotask(() => {
-          if (typeof mockRelayInstance.onWorkerOutput === 'function') {
-            mockRelayInstance.onWorkerOutput({ name, chunk: output });
+      mockRelayInstance.spawnPty.mockImplementation(
+        async ({ name, task }: { name: string; task?: string }) => {
+          const isOwner = name.includes('-owner-');
+          const output = isOwner ? 'owner checking\n' : 'worker finished\n';
+
+          queueMicrotask(() => {
+            if (typeof mockRelayInstance.onWorkerOutput === 'function') {
+              mockRelayInstance.onWorkerOutput({ name, chunk: output });
+            }
+          });
+
+          if (isOwner) {
+            return {
+              name,
+              waitForExit: vi.fn().mockImplementation(async () => {
+                await Promise.resolve();
+                return 'timeout';
+              }),
+              waitForIdle: vi.fn().mockResolvedValue('timeout'),
+              release: ownerRelease,
+            };
           }
-        });
 
-        if (isOwner) {
           return {
             name,
             waitForExit: vi.fn().mockImplementation(async () => {
-              await Promise.resolve();
-              return 'timeout';
+              await workerRelease();
+              return 'released';
             }),
-            waitForIdle: vi.fn().mockResolvedValue('timeout'),
-            release: ownerRelease,
+            waitForIdle: vi.fn().mockImplementation(() => never()),
+            release: workerRelease,
           };
         }
-
-        return {
-          name,
-          waitForExit: vi.fn().mockImplementation(async () => {
-            await workerRelease();
-            return 'released';
-          }),
-          waitForIdle: vi.fn().mockImplementation(() => never()),
-          release: workerRelease,
-        };
-      });
+      );
 
       const run = await runner.execute(makeSupervisedConfig(), 'default');
 
@@ -1150,6 +1134,54 @@ agents:
       expect(agentB?.stepCount).toBe(1);
     });
 
+    it('should include resolved permissions without provisioning tokens', () => {
+      const tmpDir = mkdtempSync(path.join(os.tmpdir(), 'workflow-dry-run-perms-'));
+      try {
+        writeFileSync(path.join(tmpDir, 'readme.md'), '# readme\n');
+        writeFileSync(path.join(tmpDir, 'notes.txt'), 'notes\n');
+        writeFileSync(path.join(tmpDir, '.agentreadonly'), 'readme.md\n');
+
+        const dryRunRunner = new WorkflowRunner({ db, workspaceId: 'ws-test', cwd: tmpDir });
+        const report = dryRunRunner.dryRun(
+          makeConfig({
+            agents: [
+              {
+                name: 'agent-a',
+                cli: 'claude',
+                permissions: {
+                  access: 'readonly',
+                  files: {
+                    write: ['notes.txt'],
+                  },
+                  scopes: ['relay:custom'],
+                },
+              },
+              { name: 'agent-b', cli: 'claude' },
+            ],
+          })
+        );
+
+        const agentA = report.permissions?.find((entry) => entry.agent === 'agent-a');
+        const agentB = report.permissions?.find((entry) => entry.agent === 'agent-b');
+
+        expect(agentA?.agent).toBe('agent-a');
+        expect(agentA?.access).toBe('readonly');
+        expect(agentA?.writePaths).toBe(1);
+        expect(agentA?.denyPaths).toBe(0);
+        expect(agentA?.readPaths).toBeGreaterThanOrEqual(1);
+        expect(agentA?.source).toBe('yaml');
+        expect(agentA?.scopes).toBeGreaterThan(1);
+
+        expect(agentB).toMatchObject({
+          agent: 'agent-b',
+          access: 'readwrite',
+          source: 'preset',
+        });
+      } finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
     it('should warn when step references unknown agent', () => {
       const config = makeConfig({
         workflows: [

package/packages/sdk/src/client.ts

@@ -26,6 +26,7 @@ import type {
 } from './protocol.js';
 import type {
   AgentTransport,
+  SpawnHeadlessInput,
   SpawnPtyInput,
   SpawnProviderInput,
   SendMessageInput,
@@ -313,6 +314,7 @@ export class AgentRelayClient {
         channels: input.channels ?? [],
         cwd: input.cwd,
         team: input.team,
+        agentToken: input.agentToken,
         shadowOf: input.shadowOf,
         shadowMode: input.shadowMode,
         continueFrom: input.continueFrom,
@@ -342,6 +344,7 @@ export class AgentRelayClient {
         channels: input.channels ?? [],
         cwd: input.cwd,
         team: input.team,
+        agentToken: input.agentToken,
         shadowOf: input.shadowOf,
         shadowMode: input.shadowMode,
         continueFrom: input.continueFrom,
@@ -353,14 +356,7 @@ export class AgentRelayClient {
     });
   }
 
-  async spawnHeadless(input: {
-    name: string;
-    provider: HeadlessProvider;
-    args?: string[];
-    channels?: string[];
-    task?: string;
-    skipRelayPrompt?: boolean;
-  }): Promise<{ name: string; runtime: AgentRuntime }> {
+  async spawnHeadless(input: SpawnHeadlessInput): Promise<{ name: string; runtime: AgentRuntime }> {
     return this.spawnProvider({ ...input, transport: 'headless' });
   }
 

package/packages/sdk/src/provisioner/__tests__/audit.test.ts

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { provisionWorkflowAgents } from '../index.js';
+
+async function createWorkspace(): Promise<{ dir: string; cleanup: () => Promise<void> }> {
+  const dir = await mkdtemp(path.join(tmpdir(), 'relay-provisioner-audit-'));
+  await mkdir(path.join(dir, 'src'), { recursive: true });
+  await writeFile(path.join(dir, 'src', 'index.ts'), 'export const value = 1;\n');
+
+  return {
+    dir,
+    cleanup: () => rm(dir, { recursive: true, force: true }),
+  };
+}
+
+test('provisionWorkflowAgents writes a permission audit without token values', async () => {
+  const workspace = await createWorkspace();
+
+  try {
+    const result = await provisionWorkflowAgents({
+      secret: 'test-secret',
+      workspace: 'audit-workspace',
+      projectDir: workspace.dir,
+      relayfileBaseUrl: 'http://127.0.0.1:8080',
+      agents: {
+        worker: {
+          access: 'readonly',
+        },
+      },
+      skipSeeding: true,
+      skipMount: true,
+    });
+
+    const auditPath = path.join(workspace.dir, '.agent-relay', 'permission-audit.json');
+    const auditRaw = await readFile(auditPath, 'utf8');
+    const auditJson = JSON.parse(auditRaw) as {
+      entries: Array<{
+        agentName: string;
+        action: string;
+        details: Record<string, unknown>;
+      }>;
+    };
+
+    assert.ok(auditJson.entries.length >= 3);
+    assert.deepEqual(
+      auditJson.entries.map((entry) => `${entry.agentName}:${entry.action}`),
+      ['worker:resolve', 'worker:mint', 'relay-admin:mint']
+    );
+    assert.equal(
+      auditJson.entries[1]?.details.jwtPath,
+      path.join(workspace.dir, '.relay', 'tokens', 'worker.jwt')
+    );
+    assert.ok(!auditRaw.includes(result.agents.worker.token));
+    assert.ok(!auditRaw.includes(result.adminToken));
+  } finally {
+    await workspace.cleanup();
+  }
+});

package/packages/sdk/src/provisioner/__tests__/compiler.test.ts

@@ -0,0 +1,369 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { compileAgentScopes, globToScopes } from '../compiler.js';
+
+async function createWorkspace(
+  files: Record<string, string>
+): Promise<{ dir: string; cleanup: () => Promise<void> }> {
+  const dir = await mkdtemp(path.join(tmpdir(), 'relay-provisioner-compiler-'));
+
+  for (const [relativePath, content] of Object.entries(files)) {
+    const filePath = path.join(dir, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content);
+  }
+
+  return {
+    dir,
+    cleanup: () => rm(dir, { recursive: true, force: true }),
+  };
+}
+
+test('compileAgentScopes applies explicit file permissions', async () => {
+  const workspace = await createWorkspace({
+    'docs/guide.md': '# guide\n',
+    'src/index.ts': 'export const value = 1;\n',
+    'secrets.env': 'TOP_SECRET=1\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'builder',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'restricted',
+        inherit: false,
+        files: {
+          read: ['docs/**'],
+          write: ['src/**'],
+          deny: ['secrets.env'],
+        },
+      },
+    });
+
+    assert.deepEqual(compiled.readonlyPaths, ['docs/guide.md']);
+    assert.deepEqual(compiled.readwritePaths, ['src/index.ts']);
+    assert.deepEqual(compiled.deniedPaths, ['secrets.env']);
+    assert.deepEqual(compiled.scopes, [
+      'relayfile:fs:read:/docs/guide.md',
+      'relayfile:fs:read:/src/index.ts',
+      'relayfile:fs:write:/src/index.ts',
+    ]);
+    assert.deepEqual(compiled.sources, [
+      {
+        type: 'yaml',
+        label: 'permissions.files',
+        ruleCount: 3,
+      },
+    ]);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes honors the readonly preset', async () => {
+  const workspace = await createWorkspace({
+    'docs/guide.md': '# guide\n',
+    'src/index.ts': 'export const value = 1;\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'reader',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'readonly',
+      },
+    });
+
+    assert.equal(compiled.effectiveAccess, 'readonly');
+    assert.deepEqual(compiled.readonlyPaths, ['docs/guide.md', 'src/index.ts']);
+    assert.deepEqual(compiled.readwritePaths, []);
+    assert.deepEqual(compiled.deniedPaths, []);
+    assert.deepEqual(compiled.readonlyPatterns, ['**']);
+    assert.deepEqual(compiled.readwritePatterns, []);
+    assert.deepEqual(compiled.scopes, [
+      'relayfile:fs:read:/docs/guide.md',
+      'relayfile:fs:read:/src/index.ts',
+    ]);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes honors the readwrite preset', async () => {
+  const workspace = await createWorkspace({
+    'docs/guide.md': '# guide\n',
+    'src/index.ts': 'export const value = 1;\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'writer',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'readwrite',
+      },
+    });
+
+    assert.equal(compiled.effectiveAccess, 'readwrite');
+    assert.deepEqual(compiled.readonlyPaths, []);
+    assert.deepEqual(compiled.readwritePaths, ['docs/guide.md', 'src/index.ts']);
+    assert.deepEqual(compiled.deniedPaths, []);
+    assert.deepEqual(compiled.readwritePatterns, ['**']);
+    assert.deepEqual(compiled.scopes, [
+      'relayfile:fs:read:/docs/guide.md',
+      'relayfile:fs:read:/src/index.ts',
+      'relayfile:fs:write:/docs/guide.md',
+      'relayfile:fs:write:/src/index.ts',
+    ]);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes applies deny patterns last', async () => {
+  const workspace = await createWorkspace({
+    'docs/private.md': '# private\n',
+    'docs/public.md': '# public\n',
+    'secrets.env': 'TOP_SECRET=1\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'writer',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'full',
+        files: {
+          deny: ['docs/private.md', 'secrets.env'],
+        },
+      },
+    });
+
+    assert.equal(compiled.inherited, false);
+    assert.deepEqual(compiled.readonlyPaths, []);
+    assert.deepEqual(compiled.readwritePaths, ['docs/public.md']);
+    assert.deepEqual(compiled.deniedPaths, ['docs/private.md', 'secrets.env']);
+    assert.deepEqual(compiled.deniedPatterns, ['docs/private.md', 'secrets.env']);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes ignores dotfiles when inherit is false', async () => {
+  const workspace = await createWorkspace({
+    '.agentignore': 'blocked.txt\n',
+    '.agentreadonly': 'locked.txt\n',
+    'blocked.txt': 'blocked\n',
+    'locked.txt': 'locked\n',
+    'open.txt': 'open\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'writer',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'readwrite',
+        inherit: false,
+      },
+    });
+
+    assert.equal(compiled.inherited, false);
+    assert.deepEqual(compiled.sources, [
+      {
+        type: 'preset',
+        label: 'access: readwrite',
+        ruleCount: 2,
+      },
+    ]);
+    assert.deepEqual(compiled.readonlyPaths, []);
+    assert.deepEqual(compiled.readwritePaths, [
+      '.agentignore',
+      '.agentreadonly',
+      'blocked.txt',
+      'locked.txt',
+      'open.txt',
+    ]);
+    assert.deepEqual(compiled.deniedPaths, []);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes loads dotfiles when inherit is true', async () => {
+  const workspace = await createWorkspace({
+    '.agentignore': 'blocked.txt\n',
+    '.agentreadonly': 'locked.txt\n',
+    'blocked.txt': 'blocked\n',
+    'locked.txt': 'locked\n',
+    'open.txt': 'open\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'writer',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'readwrite',
+      },
+    });
+
+    assert.equal(compiled.inherited, true);
+    assert.deepEqual(compiled.sources, [
+      {
+        type: 'dotfile',
+        label: 'dotfiles',
+        ruleCount: 2,
+      },
+      {
+        type: 'preset',
+        label: 'access: readwrite',
+        ruleCount: 2,
+      },
+    ]);
+    assert.deepEqual(compiled.readonlyPaths, ['locked.txt']);
+    assert.deepEqual(compiled.readwritePaths, ['.agentignore', '.agentreadonly', 'open.txt']);
+    assert.deepEqual(compiled.deniedPaths, ['blocked.txt']);
+    assert.deepEqual(compiled.readonlyPatterns, ['locked.txt']);
+    assert.deepEqual(compiled.deniedPatterns, ['blocked.txt']);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes appends raw scopes', async () => {
+  const workspace = await createWorkspace({
+    'src/index.ts': 'export const value = 1;\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'scoped',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'restricted',
+        inherit: false,
+        scopes: ['relay:custom:deploy', 'relay:custom:audit', 'relay:custom:deploy'],
+      },
+    });
+
+    assert.deepEqual(compiled.readonlyPaths, []);
+    assert.deepEqual(compiled.readwritePaths, []);
+    assert.deepEqual(compiled.deniedPaths, ['src/index.ts']);
+    assert.deepEqual(compiled.scopes, ['relay:custom:deploy', 'relay:custom:audit']);
+    assert.deepEqual(compiled.summary, {
+      readonly: 0,
+      readwrite: 0,
+      denied: 1,
+      customScopes: 2,
+    });
+    assert.deepEqual(compiled.sources, [
+      {
+        type: 'scope',
+        label: 'permissions.scopes',
+        ruleCount: 2,
+      },
+    ]);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes lets YAML rules override dotfiles', async () => {
+  const workspace = await createWorkspace({
+    '.agentignore': 'blocked.txt\n',
+    '.agentreadonly': 'locked.txt\n',
+    'blocked.txt': 'blocked\n',
+    'locked.txt': 'locked\n',
+    'plain.txt': 'plain\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'override-agent',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {
+        access: 'restricted',
+        files: {
+          read: ['blocked.txt'],
+          write: ['locked.txt'],
+        },
+      },
+    });
+
+    assert.deepEqual(compiled.readonlyPaths, ['blocked.txt']);
+    assert.deepEqual(compiled.readwritePaths, ['locked.txt']);
+    assert.deepEqual(compiled.deniedPaths, ['.agentignore', '.agentreadonly', 'plain.txt']);
+    assert.deepEqual(compiled.scopes, [
+      'relayfile:fs:read:/blocked.txt',
+      'relayfile:fs:read:/locked.txt',
+      'relayfile:fs:write:/locked.txt',
+    ]);
+    assert.deepEqual(compiled.sources, [
+      {
+        type: 'dotfile',
+        label: 'dotfiles',
+        ruleCount: 2,
+      },
+      {
+        type: 'yaml',
+        label: 'permissions.files',
+        ruleCount: 2,
+      },
+    ]);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('compileAgentScopes defaults empty permissions to inherited readwrite access', async () => {
+  const workspace = await createWorkspace({
+    'docs/guide.md': '# guide\n',
+    'src/index.ts': 'export const value = 1;\n',
+  });
+
+  try {
+    const compiled = compileAgentScopes({
+      agentName: 'defaulted',
+      workspace: 'relay-test',
+      projectDir: workspace.dir,
+      permissions: {},
+    });
+
+    assert.equal(compiled.effectiveAccess, 'readwrite');
+    assert.equal(compiled.inherited, true);
+    assert.deepEqual(compiled.readonlyPaths, []);
+    assert.deepEqual(compiled.readwritePaths, ['docs/guide.md', 'src/index.ts']);
+    assert.deepEqual(compiled.deniedPaths, []);
+    assert.deepEqual(compiled.sources, [
+      {
+        type: 'preset',
+        label: 'access: readwrite',
+        ruleCount: 2,
+      },
+    ]);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test('globToScopes normalizes and de-duplicates globs', () => {
+  assert.deepEqual(globToScopes(['src\\index.ts', './docs/**', '/docs/**', '', ' src/index.ts '], 'write'), [
+    'relayfile:fs:write:/src/index.ts',
+    'relayfile:fs:write:/docs/**',
+  ]);
+});

package/packages/sdk/src/provisioner/__tests__/presets.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { defaultPermissionsForPreset, expandAccessPreset } from '../compiler.js';
+
+describe('expandAccessPreset', () => {
+  it.each([
+    ['readonly', { read: ['**'], write: [], deny: [] }],
+    ['restricted', { read: [], write: [], deny: [] }],
+    ['full', { read: ['**'], write: ['**'], deny: [] }],
+    ['readwrite', { read: ['**'], write: ['**'], deny: [] }],
+  ] as const)('expands %s', (preset, expected) => {
+    expect(expandAccessPreset(preset)).toEqual(expected);
+  });
+});
+
+describe('defaultPermissionsForPreset', () => {
+  it.each([
+    ['lead', { access: 'full' }],
+    ['worker', { access: 'readwrite' }],
+    ['reviewer', { access: 'readonly' }],
+    ['analyst', { access: 'readonly' }],
+  ] as const)('maps %s to the expected default permissions', (preset, expected) => {
+    expect(defaultPermissionsForPreset(preset)).toEqual(expected);
+  });
+});