agent-relay 4.0.2 → 4.0.3

package/packages/sdk/src/provisioner/__tests__/token-factory.test.ts

@@ -0,0 +1,172 @@
+import assert from 'node:assert/strict';
+import { createHmac } from 'node:crypto';
+import test from 'node:test';
+
+import {
+  DEFAULT_ADMIN_AGENT_NAME,
+  DEFAULT_ADMIN_SCOPES,
+  DEFAULT_WORKFLOW_TOKEN_TTL_SECONDS,
+  WorkflowTokenFactory,
+  mintAgentToken,
+  type TokenClaims,
+} from '../token.js';
+
+interface JwtHeader {
+  alg: string;
+  typ: string;
+}
+
+function decodeJwtPart<T>(value: string): T {
+  return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')) as T;
+}
+
+function decodeJwt(token: string): { header: JwtHeader; payload: TokenClaims; signature: string } {
+  const [header, payload, signature] = token.split('.');
+  assert.ok(header);
+  assert.ok(payload);
+  assert.ok(signature);
+
+  return {
+    header: decodeJwtPart<JwtHeader>(header),
+    payload: decodeJwtPart<TokenClaims>(payload),
+    signature,
+  };
+}
+
+test('mintAgentToken returns a valid JWT', () => {
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: ['relayfile:fs:read:/src/index.ts'],
+  });
+
+  const parts = token.split('.');
+  const decoded = decodeJwt(token);
+
+  assert.equal(parts.length, 3);
+  assert.ok(parts.every((part) => /^[A-Za-z0-9_-]+$/u.test(part)));
+  assert.deepEqual(decoded.header, { alg: 'HS256', typ: 'JWT' });
+  assert.equal(decoded.payload.sub, 'agent_worker');
+});
+
+test('mintAgentToken payload contains agent_name, workspace, and scopes', () => {
+  const scopes = ['relayfile:fs:read:/src/index.ts', 'relayfile:fs:write:/src/index.ts'];
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'compiler',
+    workspace: 'workspace-abc',
+    scopes,
+  });
+
+  const { payload } = decodeJwt(token);
+
+  assert.equal(payload.agent_name, 'compiler');
+  assert.equal(payload.wks, 'workspace-abc');
+  assert.equal(payload.workspace_id, 'workspace-abc');
+  assert.deepEqual(payload.scopes, scopes);
+});
+
+test('mintAgentToken defaults expiry to 2 hours', () => {
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: [],
+  });
+
+  const { payload } = decodeJwt(token);
+
+  assert.equal(payload.exp - payload.iat, DEFAULT_WORKFLOW_TOKEN_TTL_SECONDS);
+  assert.equal(payload.exp - payload.iat, 2 * 60 * 60);
+});
+
+test('mintAgentToken applies a custom TTL', () => {
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: [],
+    ttlSeconds: 90,
+  });
+
+  const { payload } = decodeJwt(token);
+
+  assert.equal(payload.exp - payload.iat, 90);
+});
+
+test('WorkflowTokenFactory mintAdmin uses the default admin identity and scopes', () => {
+  const factory = new WorkflowTokenFactory('test-secret', 'workspace-admin');
+  const token = factory.mintAdmin();
+  const { payload } = decodeJwt(token);
+
+  assert.equal(payload.agent_name, DEFAULT_ADMIN_AGENT_NAME);
+  assert.equal(payload.wks, 'workspace-admin');
+  assert.deepEqual(payload.scopes, DEFAULT_ADMIN_SCOPES);
+});
+
+test('WorkflowTokenFactory getToken returns the token minted for an agent', () => {
+  const factory = new WorkflowTokenFactory('test-secret', 'workspace-123');
+  const token = factory.mintForAgent('builder', ['relayfile:fs:read:/src/index.ts']);
+
+  assert.equal(factory.getToken('builder'), token);
+});
+
+test('WorkflowTokenFactory uses its configured TTL when minting agent tokens', () => {
+  const factory = new WorkflowTokenFactory('test-secret', 'workspace-123', 45);
+  const token = factory.mintForAgent('builder', []);
+  const { payload } = decodeJwt(token);
+
+  assert.equal(payload.exp - payload.iat, 45);
+});
+
+test('mintAgentToken generates a unique JTI per token', () => {
+  const first = decodeJwt(
+    mintAgentToken({
+      secret: 'test-secret',
+      agentName: 'worker',
+      workspace: 'workspace-123',
+      scopes: [],
+    })
+  ).payload;
+  const second = decodeJwt(
+    mintAgentToken({
+      secret: 'test-secret',
+      agentName: 'worker',
+      workspace: 'workspace-123',
+      scopes: [],
+    })
+  ).payload;
+
+  assert.notEqual(first.jti, second.jti);
+  assert.match(first.jti, /^tok-\d+-/u);
+  assert.match(second.jti, /^tok-\d+-/u);
+});
+
+test('mintAgentToken includes the expected audience claims', () => {
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: [],
+  });
+
+  const { payload } = decodeJwt(token);
+
+  assert.deepEqual(payload.aud, ['relayauth', 'relayfile']);
+});
+
+test('mintAgentToken signs tokens with HMAC-SHA256', () => {
+  const secret = 'test-secret';
+  const token = mintAgentToken({
+    secret,
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: ['relayfile:fs:read:/src/index.ts'],
+  });
+
+  const [header, payload, signature] = token.split('.');
+  const expectedSignature = createHmac('sha256', secret).update(`${header}.${payload}`).digest('base64url');
+
+  assert.equal(signature, expectedSignature);
+});

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

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { DEFAULT_WORKFLOW_TOKEN_TTL_SECONDS, mintAgentToken, type TokenClaims } from '../token.js';
+
+function decodeJwtPayload(token: string): TokenClaims {
+  const [, payload] = token.split('.');
+  return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8')) as TokenClaims;
+}
+
+test('mintAgentToken returns a valid JWT', () => {
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: ['relayfile:fs:read:/src/index.ts'],
+  });
+
+  const parts = token.split('.');
+  assert.equal(parts.length, 3);
+  assert.ok(parts.every((part) => /^[A-Za-z0-9_-]+$/u.test(part)));
+});
+
+test('mintAgentToken payload contains agent_name, workspace, and scopes', () => {
+  const scopes = ['relayfile:fs:read:/src/index.ts', 'relayfile:fs:write:/src/index.ts'];
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'compiler',
+    workspace: 'workspace-abc',
+    scopes,
+  });
+
+  const payload = decodeJwtPayload(token);
+
+  assert.equal(payload.agent_name, 'compiler');
+  assert.equal(payload.wks, 'workspace-abc');
+  assert.equal(payload.workspace_id, 'workspace-abc');
+  assert.deepEqual(payload.scopes, scopes);
+});
+
+test('mintAgentToken defaults expiry to 2 hours', () => {
+  const token = mintAgentToken({
+    secret: 'test-secret',
+    agentName: 'worker',
+    workspace: 'workspace-123',
+    scopes: [],
+  });
+
+  const payload = decodeJwtPayload(token);
+
+  assert.equal(payload.exp - payload.iat, DEFAULT_WORKFLOW_TOKEN_TTL_SECONDS);
+  assert.equal(payload.exp - payload.iat, 2 * 60 * 60);
+});

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

@@ -0,0 +1,104 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export interface PermissionAuditEntry {
+  timestamp: string;
+  agentName: string;
+  action: string;
+  details: Record<string, unknown>;
+}
+
+type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+
+const DEFAULT_PERMISSION_AUDIT_RELATIVE_PATH = path.join('.agent-relay', 'permission-audit.json');
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function sanitizeJsonValue(value: unknown, key?: string): JsonValue {
+  if (key && key.toLowerCase().includes('token')) {
+    return '[redacted]';
+  }
+
+  if (
+    value === null ||
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
+  ) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeJsonValue(item));
+  }
+
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([entryKey, entryValue]) => [
+        entryKey,
+        sanitizeJsonValue(entryValue, entryKey),
+      ])
+    );
+  }
+
+  return String(value);
+}
+
+export function getDefaultPermissionAuditPath(projectDir: string): string {
+  return path.resolve(projectDir, DEFAULT_PERMISSION_AUDIT_RELATIVE_PATH);
+}
+
+export class PermissionAuditLog {
+  private readonly entries: PermissionAuditEntry[] = [];
+
+  log(entry: Omit<PermissionAuditEntry, 'timestamp'> & { timestamp?: string }): PermissionAuditEntry {
+    const storedEntry: PermissionAuditEntry = {
+      timestamp: entry.timestamp ?? new Date().toISOString(),
+      agentName: entry.agentName,
+      action: entry.action,
+      details: sanitizeJsonValue(entry.details) as Record<string, unknown>,
+    };
+
+    this.entries.push(storedEntry);
+    return storedEntry;
+  }
+
+  toJSON(): { entries: PermissionAuditEntry[] } {
+    return {
+      entries: this.entries.map((entry) => ({
+        timestamp: entry.timestamp,
+        agentName: entry.agentName,
+        action: entry.action,
+        details: { ...entry.details },
+      })),
+    };
+  }
+
+  async writeTo(filePath: string): Promise<void> {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(this.toJSON(), null, 2)}\n`, 'utf8');
+  }
+
+  summary(): string {
+    if (this.entries.length === 0) {
+      return 'Permission audit: 0 entries';
+    }
+
+    const actionCounts = new Map<string, number>();
+    const agentNames = new Set<string>();
+
+    for (const entry of this.entries) {
+      actionCounts.set(entry.action, (actionCounts.get(entry.action) ?? 0) + 1);
+      agentNames.add(entry.agentName);
+    }
+
+    const actionSummary = [...actionCounts.entries()]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([action, count]) => `${action}=${count}`)
+      .join(', ');
+
+    return `Permission audit: ${this.entries.length} entr${this.entries.length === 1 ? 'y' : 'ies'} across ${agentNames.size} agent${agentNames.size === 1 ? '' : 's'} (${actionSummary})`;
+  }
+}