Verification ran git inside the tree under test, kept no command output and treated every infrastructure fault as a test failure; repairs went through an executor lease the coordinator should not hold; and a project without delivery could never succeed. This reworks the worker execution path and the control-plane contracts it depends on. - Verification exports the exact commit to a directory without .git, installs dependencies (network allowed) and runs the protected commands under bubblewrap in kata mode or directly in host mode; evidence records exit code, duration, digest, a redacted output tail and the isolation used. Production rejects host evidence. A failed installation waits as infrastructure. - Waiting reasons are an enum with a redacted detail; dispatcher, GitHub and model-proxy states map onto it, and the console explains each one with a way out. - Repairs are requested by the coordinator through /internal/runs/:id/repair; the control plane derives the failure summary from the verifier's evidence and enforces the repair budget. Continuing after the budget is spent grants one more round; a new requirement revision starts a fresh budget. - Execution identities may only move a run within their own stages and only to running or waiting; success comes from integration evidence (no delivery configured) or deployment acceptance. The unused preview stage is gone. - Integration fast-forwards when the target has not moved, merges and re-verifies otherwise, retries when a push finds the target moved, and turns merge conflicts into a repair round that merges the current target for the agent to resolve. - Successful runs that needed a repair leave a project lesson; active lessons are injected into later prompts, and admins can list, add, disable and delete them. - Executor progress (messages, commands, file changes, plan updates) is stored as normalized events; previously agent messages were recorded as the literal word "output". Provider failures keep the work as a checkpoint and wait as provider_error instead of failing the run. - Workers declare WF_SANDBOX_MODE=host|kata (host refused in production), heartbeat with retries until the lease could have expired, and retry safe control-plane reads with backoff. - tests/local-loop.test.ts runs the loop end to end with real Git, the in-process control plane behind its internal routes and a scripted agent. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
341 lines
16 KiB
TypeScript
341 lines
16 KiB
TypeScript
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import { generateKeyPairSync, createPublicKey, verify } from 'node:crypto';
|
|
import { mkdtemp, rm, writeFile } from 'node:fs/promises';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import type { Actor, Run } from '@wishforge/contracts';
|
|
import { GitHubApp, operationMarker, type AppConfiguration } from '../packages/github/src/index.js';
|
|
import { GitHubIntegration } from '../apps/api/src/domain/github.js';
|
|
import { ControlPlane } from '../apps/api/src/domain/control-plane.js';
|
|
import { Connections } from '../apps/api/src/domain/connections.js';
|
|
import { MemoryStore } from './helpers/memory-store.js';
|
|
const owner: Actor = { tenantId: 'alpha', userId: 'owner', role: 'owner', kind: 'human' };
|
|
const worker: Actor = { ...owner, userId: 'worker', kind: 'worker' },
|
|
verifier: Actor = { ...owner, userId: 'verifier', kind: 'verifier' };
|
|
const head = 'a'.repeat(40),
|
|
base = 'b'.repeat(40),
|
|
final = 'c'.repeat(40);
|
|
let directory: string, privateKey: string, config: AppConfiguration, configFile: string;
|
|
const response = (value: unknown, status = 200) =>
|
|
new Response(JSON.stringify(value), { status, headers: { 'content-type': 'application/json' } });
|
|
beforeAll(async () => {
|
|
directory = await mkdtemp(path.join(os.tmpdir(), 'wishforge-github-test-'));
|
|
privateKey = generateKeyPairSync('rsa', { modulusLength: 2048 })
|
|
.privateKey.export({ format: 'pem', type: 'pkcs8' })
|
|
.toString();
|
|
await writeFile(path.join(directory, 'app.pem'), privateKey, { mode: 0o600 });
|
|
});
|
|
afterAll(async () => {
|
|
await rm(directory, { recursive: true, force: true });
|
|
});
|
|
beforeEach(async () => {
|
|
configFile = path.join(directory, `config-${Date.now()}-${Math.random()}.json`);
|
|
config = {
|
|
appId: '12345',
|
|
privateKeyFile: path.join(directory, 'app.pem'),
|
|
tenantInstallations: [
|
|
{
|
|
tenantId: 'alpha',
|
|
installationId: 9001,
|
|
repositories: [
|
|
{ owner: 'wishforge-fixture', name: 'catalog', repositoryId: 101, allowedBaseBranches: ['main'] },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
await writeFile(configFile, JSON.stringify(config));
|
|
});
|
|
function fixture() {
|
|
const calls: { route: string; method: string; body: any; authorization: string }[] = [];
|
|
const state = {
|
|
pr: undefined as any,
|
|
createTimeout: false,
|
|
mergeTimeout: false,
|
|
baseSha: base,
|
|
broadenToken: false,
|
|
mergePending: false,
|
|
};
|
|
const fetcher = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
|
|
const route = new URL(String(url)).pathname,
|
|
method = init?.method ?? 'GET',
|
|
body = init?.body ? JSON.parse(String(init.body)) : undefined;
|
|
const authorization = String((init?.headers as Record<string, string>)?.Authorization ?? '');
|
|
calls.push({ route, method, body, authorization });
|
|
if (route === '/app/installations/9001/access_tokens')
|
|
return response({
|
|
token: 'fixture-installation-token-opaque-long-value',
|
|
expires_at: new Date(Date.now() + 3600000).toISOString(),
|
|
permissions: {
|
|
contents: body.permissions.contents,
|
|
pull_requests: body.permissions.pull_requests,
|
|
metadata: 'read',
|
|
},
|
|
repositories: [
|
|
{ id: 101, full_name: 'wishforge-fixture/catalog' },
|
|
...(state.broadenToken ? [{ id: 102, full_name: 'wishforge-fixture/other' }] : []),
|
|
],
|
|
});
|
|
if (route.endsWith('/git/ref/heads/main')) return response({ object: { type: 'commit', sha: state.baseSha } });
|
|
if (route.includes('/git/ref/heads/')) return response({ object: { type: 'commit', sha: head } });
|
|
if (route.endsWith('/pulls') && method === 'GET') return response(state.pr ? [state.pr] : []);
|
|
if (route.endsWith('/pulls') && method === 'POST') {
|
|
state.pr = {
|
|
number: 7,
|
|
html_url: 'https://github.com/wishforge-fixture/catalog/pull/7',
|
|
state: 'open',
|
|
head: { ref: body.head, sha: head, repo: { id: 101 } },
|
|
base: { ref: body.base, sha: base, repo: { id: 101 } },
|
|
merged: false,
|
|
merged_at: null,
|
|
merge_commit_sha: 'd'.repeat(40),
|
|
draft: false,
|
|
mergeable: true,
|
|
mergeable_state: 'clean',
|
|
body: body.body,
|
|
};
|
|
if (state.createTimeout) throw new Error('fixture network timeout after creation');
|
|
return response(state.pr, 201);
|
|
}
|
|
if (route.endsWith('/merge-async') && method === 'PUT') {
|
|
if (!state.mergePending)
|
|
Object.assign(state.pr, {
|
|
state: 'closed',
|
|
merged: true,
|
|
merged_at: new Date().toISOString(),
|
|
merge_commit_sha: final,
|
|
});
|
|
if (state.mergeTimeout) throw new Error('fixture timeout after merge');
|
|
return response(
|
|
{ status: state.mergePending ? 'pending' : 'merged', details: { uuid: 'fixture-request-id', sha: final } },
|
|
state.mergePending ? 202 : 200,
|
|
);
|
|
}
|
|
if (route.endsWith('/pulls/7')) return response(state.pr);
|
|
throw new Error(`Unexpected fixture endpoint ${method} ${route}`);
|
|
}) as unknown as typeof fetch;
|
|
return { state, calls, app: new GitHubApp({ WF_GITHUB_APP_CONFIG_FILE: configFile }, fetcher), fetcher };
|
|
}
|
|
async function domain(f = fixture()) {
|
|
const db = new MemoryStore();
|
|
db.seed('alpha');
|
|
db.seed('beta');
|
|
const env = { NODE_ENV: 'test', WF_VAULT_KEY: 'a'.repeat(64), WF_GITHUB_APP_CONFIG_FILE: configFile };
|
|
const control = new ControlPlane(db, env);
|
|
const connections = new Connections(db, env);
|
|
await connections.create(owner, { provider: 'codex', label: 'fixture', apiKey: 'fixture-not-real' });
|
|
const project = await control.createProject(owner, {
|
|
name: 'Catalog',
|
|
repositoryUrl: 'https://github.com/wishforge-fixture/catalog.git',
|
|
});
|
|
const submitted = await control.submit(
|
|
owner,
|
|
project.id,
|
|
{ goal: 'Add catalog search', acceptanceCriteria: ['Search returns exact rows'] },
|
|
'github-test-submit',
|
|
);
|
|
await db.transaction('alpha', async tx => {
|
|
const run = (await tx.get<Run>('run', submitted.run_id))!;
|
|
run.verifiedCommit = head;
|
|
run.sourceCommit = head;
|
|
await tx.put('run', run);
|
|
});
|
|
const github = new GitHubIntegration(db, env, f.app);
|
|
const input = {
|
|
operationId: 'fixture-operation',
|
|
title: 'Add search',
|
|
body: 'Protected command checks passed.',
|
|
headBranch: `wishforge/${submitted.run_id}`,
|
|
baseBranch: 'main',
|
|
expectedHeadSha: head,
|
|
expectedBaseSha: base,
|
|
};
|
|
return { ...f, db, control, github, project, runId: submitted.run_id, input };
|
|
}
|
|
describe('GitHub App repository and credential contracts', () => {
|
|
it('uses operator tenant mapping, repository-only token permissions and a short RS256 App JWT', async () => {
|
|
const { app, calls } = fixture();
|
|
const scope = await app.scope('alpha', 'https://github.com/wishforge-fixture/catalog.git');
|
|
await app.token(scope, 'read');
|
|
await app.token(scope, 'write');
|
|
expect(calls[0].body).toEqual({ repository_ids: [101], permissions: { contents: 'read', pull_requests: 'read' } });
|
|
expect(calls[1].body.permissions.contents).toBe('write');
|
|
const jwt = calls[0].authorization.slice(7),
|
|
[encodedHeader, encodedBody, signature] = jwt.split('.');
|
|
const claims = JSON.parse(Buffer.from(encodedBody, 'base64url').toString());
|
|
expect(JSON.parse(Buffer.from(encodedHeader, 'base64url').toString()).alg).toBe('RS256');
|
|
expect(claims.exp - claims.iat).toBe(600);
|
|
expect(claims.iss).toBe('12345');
|
|
expect(
|
|
verify(
|
|
'RSA-SHA256',
|
|
Buffer.from(`${encodedHeader}.${encodedBody}`),
|
|
createPublicKey(privateKey),
|
|
Buffer.from(signature, 'base64url'),
|
|
),
|
|
).toBe(true);
|
|
await expect(app.scope('beta', 'https://github.com/wishforge-fixture/catalog')).rejects.toMatchObject({
|
|
code: 'GITHUB_REPOSITORY_DENIED',
|
|
});
|
|
await expect(app.scope('alpha', 'https://attacker.invalid/wishforge-fixture/catalog')).rejects.toMatchObject({
|
|
code: 'GITHUB_REPOSITORY_DENIED',
|
|
});
|
|
});
|
|
it('refuses broader token repository scope and altered API destination', async () => {
|
|
const f = fixture();
|
|
const scope = await f.app.scope('alpha', 'https://github.com/wishforge-fixture/catalog');
|
|
f.state.broadenToken = true;
|
|
await expect(f.app.token(scope, 'read')).rejects.toMatchObject({ code: 'GITHUB_TOKEN_SCOPE_INVALID' });
|
|
await expect(f.app.token({ ...scope, apiBaseUrl: 'https://attacker.invalid' }, 'read')).rejects.toMatchObject({
|
|
code: 'GITHUB_SCOPE_CHANGED',
|
|
});
|
|
});
|
|
it('reports explicit unconfigured status without consulting gh caches or sending requests', async () => {
|
|
const { db, project } = await domain();
|
|
expect(await new GitHubIntegration(db, {}).status(owner, project.id)).toMatchObject({
|
|
configured: false,
|
|
enabled: false,
|
|
reason: 'GITHUB_UNCONFIGURED',
|
|
});
|
|
});
|
|
it('only issues builder read access and verifier write access for the live owned lease', async () => {
|
|
const f = await domain();
|
|
const builderLease = await f.control.lease(worker, f.runId, 'builder');
|
|
await f.github.credential(worker, f.project, builderLease);
|
|
expect(f.calls.at(-1)!.body.permissions.contents).toBe('read');
|
|
await expect(f.github.credential(verifier, f.project, builderLease)).rejects.toMatchObject({
|
|
code: 'LEASE_IDENTITY_MISMATCH',
|
|
});
|
|
await f.control.releaseLease(worker, f.runId, builderLease.lease!.token);
|
|
const verifiedLease = await f.control.lease(verifier, f.runId, 'verifier');
|
|
expect(await f.github.credential(verifier, f.project, verifiedLease)).toMatchObject({ username: 'x-access-token' });
|
|
expect(f.calls.at(-1)!.body.permissions.contents).toBe('write');
|
|
});
|
|
});
|
|
describe('durable PR operations and final commit validation', () => {
|
|
it('exposes a lease-scoped verifier path that waits for approval and preserves the lease for final-SHA reverification', async () => {
|
|
const f = await domain();
|
|
const lease = await f.control.lease(verifier, f.runId, 'verifier');
|
|
await f.control.checkpoint(verifier, f.runId, { sourceCommit: head, baseCommit: base }, lease.lease!.token);
|
|
await expect(f.github.workerState(worker, f.runId, lease.lease!.token)).rejects.toMatchObject({
|
|
code: 'FORBIDDEN',
|
|
});
|
|
const state = await f.github.workerCreate(verifier, f.runId, {
|
|
leaseToken: lease.lease!.token,
|
|
candidateCommit: head,
|
|
expectedBaseCommit: base,
|
|
headBranch: `wishforge/${f.runId}/${head}`,
|
|
});
|
|
expect(state.operation?.expectedHeadSha).toBe(head);
|
|
expect(
|
|
(
|
|
await f.github.workerAdvance(verifier, f.runId, {
|
|
leaseToken: lease.lease!.token,
|
|
operationId: state.operation!.id,
|
|
})
|
|
).reason,
|
|
).toBe('github_merge_approval');
|
|
expect(f.calls.filter(call => call.method === 'PUT')).toHaveLength(0);
|
|
await f.github.authorizeMerge(owner, state.operation!.id, { expectedHeadSha: head, expectedBaseSha: base });
|
|
const mergedState = await f.github.workerAdvance(verifier, f.runId, {
|
|
leaseToken: lease.lease!.token,
|
|
operationId: state.operation!.id,
|
|
});
|
|
expect(mergedState.operation?.mergedCommitSha).toBe(final);
|
|
expect(await f.control.heartbeat(verifier, f.runId, lease.lease!.token)).toMatchObject({
|
|
status: 'running',
|
|
stage: 'verify',
|
|
sourceCommit: final,
|
|
});
|
|
expect((await f.control.run(owner, f.runId)).verifiedCommit).toBeUndefined();
|
|
});
|
|
it('rejects caller installation IDs and hides operations from nonmembers and other tenants', async () => {
|
|
const f = await domain();
|
|
await expect(f.github.createPullRequest(owner, f.runId, { ...f.input, installationId: 9002 })).rejects.toThrow();
|
|
const operation = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
await expect(
|
|
f.github.readPullRequest({ ...owner, userId: 'viewer', role: 'viewer' }, operation.id),
|
|
).rejects.toMatchObject({ code: 'NOT_FOUND' });
|
|
await expect(f.github.readPullRequest({ ...owner, tenantId: 'beta' }, operation.id)).rejects.toMatchObject({
|
|
code: 'NOT_FOUND',
|
|
});
|
|
});
|
|
it('reconciles an ambiguous create with one POST and marker/head/base identity', async () => {
|
|
const f = await domain();
|
|
f.state.createTimeout = true;
|
|
await expect(f.github.createPullRequest(owner, f.runId, f.input)).rejects.toMatchObject({
|
|
code: 'GITHUB_OUTCOME_UNKNOWN',
|
|
});
|
|
const reconciled = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
expect(reconciled).toMatchObject({ status: 'open', snapshot: { number: 7, mergeCommitSha: null } });
|
|
expect(f.calls.filter(c => c.method === 'POST' && c.route.endsWith('/pulls'))).toHaveLength(1);
|
|
expect(f.state.pr.body).toContain(operationMarker('alpha', f.runId, f.input.operationId));
|
|
});
|
|
it('does not resend an ambiguous create even if a follow-up listing is empty', async () => {
|
|
const f = await domain();
|
|
f.state.createTimeout = true;
|
|
await expect(f.github.createPullRequest(owner, f.runId, f.input)).rejects.toThrow();
|
|
f.state.pr = undefined;
|
|
expect((await f.github.createPullRequest(owner, f.runId, f.input)).status).toBe('unknown');
|
|
expect(f.calls.filter(c => c.method === 'POST' && c.route.endsWith('/pulls'))).toHaveLength(1);
|
|
});
|
|
it('blocks unapproved merge, binds human approval, uses no bypass and invalidates old source verification on final SHA change', async () => {
|
|
const f = await domain();
|
|
const operation = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
await expect(f.github.merge(owner, operation.id)).rejects.toMatchObject({ code: 'GITHUB_MERGE_NOT_AUTHORIZED' });
|
|
await expect(
|
|
f.github.authorizeMerge({ ...owner, kind: 'connector' }, operation.id, {
|
|
expectedHeadSha: head,
|
|
expectedBaseSha: base,
|
|
}),
|
|
).rejects.toMatchObject({ code: 'HUMAN_APPROVAL_REQUIRED' });
|
|
await f.github.authorizeMerge(owner, operation.id, { expectedHeadSha: head, expectedBaseSha: base });
|
|
expect(await f.github.merge(owner, operation.id)).toMatchObject({
|
|
status: 'reverification_required',
|
|
snapshot: { merged: true, mergeCommitSha: final },
|
|
});
|
|
const run = await f.control.run(owner, f.runId);
|
|
expect(run).toMatchObject({ status: 'waiting', waitingReason: 'github_review', sourceCommit: final });
|
|
expect(run.verifiedCommit).toBeUndefined();
|
|
expect(f.calls.find(c => c.method === 'PUT')!.body).toEqual({
|
|
sha: head,
|
|
merge_method: 'merge',
|
|
merge_action: 'default',
|
|
bypass_rules: false,
|
|
});
|
|
});
|
|
it('rejects a moving target branch without a merge request', async () => {
|
|
const f = await domain();
|
|
const operation = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
await f.github.authorizeMerge(owner, operation.id, { expectedHeadSha: head, expectedBaseSha: base });
|
|
f.state.baseSha = 'f'.repeat(40);
|
|
await expect(f.github.merge(owner, operation.id)).rejects.toMatchObject({ code: 'GITHUB_REF_CHANGED' });
|
|
expect(f.calls.filter(c => c.method === 'PUT')).toHaveLength(0);
|
|
});
|
|
it('reconciles a lost merge receipt and never issues a second merge', async () => {
|
|
const f = await domain();
|
|
const operation = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
await f.github.authorizeMerge(owner, operation.id, { expectedHeadSha: head, expectedBaseSha: base });
|
|
f.state.mergeTimeout = true;
|
|
await expect(f.github.merge(owner, operation.id)).rejects.toMatchObject({ code: 'GITHUB_OUTCOME_UNKNOWN' });
|
|
expect((await f.github.merge(owner, operation.id)).status).toBe('reverification_required');
|
|
expect(f.calls.filter(c => c.method === 'PUT')).toHaveLength(1);
|
|
});
|
|
it('does not confuse queued merges with delivery or resend pending requests', async () => {
|
|
const f = await domain();
|
|
const operation = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
await f.github.authorizeMerge(owner, operation.id, { expectedHeadSha: head, expectedBaseSha: base });
|
|
f.state.mergePending = true;
|
|
expect((await f.github.merge(owner, operation.id)).status).toBe('merge_pending');
|
|
await f.github.merge(owner, operation.id);
|
|
expect(f.calls.filter(c => c.method === 'PUT')).toHaveLength(1);
|
|
expect((await f.control.run(owner, f.runId)).status).not.toBe('succeeded');
|
|
});
|
|
it('permits explicit operator preauthorization without accepting a caller policy override', async () => {
|
|
config.tenantInstallations[0].repositories[0].allowAutomaticMerge = true;
|
|
await writeFile(configFile, JSON.stringify(config));
|
|
const f = await domain();
|
|
const operation = await f.github.createPullRequest(owner, f.runId, f.input);
|
|
expect((await f.github.merge(owner, operation.id)).status).toBe('reverification_required');
|
|
});
|
|
});
|