wishforge-ide/tests/workspace-git.test.ts
eust-w 0bcfbc13dd feat(ide): push IDE work to ide/ branches and merge it through a verified wish
People's changes now reach the target branch the same way the agent's do. The
IDE credential carries a ref prefix and the Git service runs a pre-receive hook
on every push that refuses updates outside it, so the IDE can push only
`ide/` branches; the platform's own integration is unaffected.

- A wish may name a source branch. The run starts from that branch's head, the
  agent builds on it, and verification, repair rounds, merging onto a moved
  target and conflict repair work as before. A missing branch makes the run
  wait (git_storage) until it is pushed.
- Release risk is now computed from the target branch before integration, not
  from where the run started: a migration committed on the source branch would
  otherwise have been missed and could have skipped approval.
- Clones work on `ide/work`; a plain `git push` publishes it.
- The console lists a project's IDE branches with a button to submit a wish
  that merges one, and the new-wish form has a starting-point field; MCP
  `submit_wish` accepts `sourceBranch`. The Git service lists branches under
  a prefix for this (`POST /refs`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 19:17:14 +08:00

186 lines
8.5 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { Actor, Project } from '@wishforge/contracts';
import { ControlPlane } from '../apps/api/src/domain/control-plane.js';
import { Services } from '../apps/api/src/http.js';
import { GitStorage } from '../apps/api/src/domain/git-storage.js';
import { MemoryStore } from './helpers/memory-store.js';
import { internalFetch } from './helpers/internal-fetch.js';
// FR-H2: an IDE workspace clones the project and pushes back with a short-lived credential
// the gateway asks for on behalf of the person whose session is open.
const devUser = '11111111-1111-4111-8111-111111111111';
const env = {
NODE_ENV: 'test',
WF_DISPATCH_TENANTS: 'demo',
WF_INTERNAL_TOKEN_KEY: 'internal-token-signing-key-for-tests-only',
WF_WORKER_TOKEN: 'coordinator-static-token-for-tests-only',
WF_DEV_AUTH_TOKEN: 'development-user-token-for-tests-only',
WF_WORKSPACE_GATEWAY_BASE: 'http://127.0.0.1:4400',
WF_WORKSPACE_GATEWAY_TOKEN: 'workspace-gateway-token-for-tests-only',
WF_WORKSPACE_GATEWAY_TENANT_ID: 'demo',
WF_GIT_SERVICE_URL: 'http://127.0.0.1:4504',
WF_GIT_ADMIN_TOKEN: 'git-admin-token-for-tests-only-0001',
};
const owner: Actor = { tenantId: 'demo', userId: 'owner', role: 'owner', kind: 'human' };
let store: MemoryStore;
let project: Project;
let gitCalls: { path: string; body: Record<string, unknown>; authorization: string }[];
let call: (route: string, body: unknown, token?: string) => Promise<Response>;
async function workspaceFor(projectId: string, id: string) {
await store.transaction('demo', tx =>
tx.put('workspace', {
id,
tenantId: 'demo',
version: 1,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
projectId,
status: 'ready',
upstreamUrl: 'http://127.0.0.1:4300/',
}),
);
}
beforeEach(async () => {
gitCalls = [];
vi.stubGlobal('fetch', async (input: string | URL, init: RequestInit) => {
const url = new URL(String(input));
const body = JSON.parse(String(init.body));
gitCalls.push({ path: url.pathname, body, authorization: (init.headers as Record<string, string>).Authorization });
if (url.pathname === '/repos')
return Response.json({
repositoryUrl: `https://git.test/git/${body.tenantId}/${body.projectId}.git`,
initialCommit: 'a'.repeat(40),
defaultBranch: 'main',
});
return Response.json({ token: 'payload.signature', expiresAt: new Date(Date.now() + 900_000).toISOString() });
});
store = new MemoryStore();
store.seed('demo');
await store.transaction('demo', tx => tx.putMembership({ userId: devUser, role: 'developer', active: true }));
const services = new Services(new ControlPlane(store, env));
project = await services.control.createProject(owner, { name: 'Todo App' });
await store.transaction('demo', async tx => {
const current = (await tx.get<Project>('project', project.id))!;
await tx.put('project', { ...current, memberIds: [...current.memberIds, devUser] });
});
await workspaceFor(project.id, 'workspace-1');
const fetcher = internalFetch(services);
call = (route, body, token = env.WF_WORKSPACE_GATEWAY_TOKEN) =>
fetcher(`http://127.0.0.1:4000/internal${route}`, {
method: 'POST',
headers: { authorization: `Bearer ${token}`, 'x-wishforge-tenant': 'demo', 'content-type': 'application/json' },
body: JSON.stringify(body),
});
});
afterEach(() => vi.unstubAllGlobals());
describe('IDE workspace repository access', () => {
it('names the session’s author from the sign-in, and only from it', async () => {
const first = await call('/workspaces/workspace-1/authorize', {
userToken: env.WF_DEV_AUTH_TOKEN,
operation: 'edit',
});
expect((await first.json()).data.author).toEqual({ name: 'Local Developer', email: 'developer@wishforge.invalid' });
const later = await call('/workspaces/workspace-1/authorize', { userId: devUser, operation: 'edit' });
expect((await later.json()).data.author).toBeUndefined();
});
it('mints a credential that may push ide/ branches of the project’s platform repository', async () => {
gitCalls = [];
const response = await call('/workspaces/workspace-1/git-credential', { userId: devUser });
expect(response.status).toBe(200);
expect((await response.json()).data).toEqual({
projectId: project.id,
projectName: 'Todo App',
repositoryUrl: `https://git.test/git/demo/${project.id}.git`,
branch: 'main',
token: 'payload.signature',
expiresAt: expect.any(String),
});
expect(gitCalls).toEqual([
{
path: '/tokens',
body: {
tenantId: 'demo',
projectId: project.id,
permission: 'write',
ttlSeconds: 900,
refPrefix: 'refs/heads/ide/',
},
authorization: `Bearer ${env.WF_GIT_ADMIN_TOKEN}`,
},
]);
});
it('refuses viewers, revoked members, other identities and malformed requests', async () => {
await store.transaction('demo', tx => tx.putMembership({ userId: devUser, role: 'viewer', active: true }));
expect((await call('/workspaces/workspace-1/git-credential', { userId: devUser })).status).toBe(403);
await store.transaction('demo', tx => tx.putMembership({ userId: devUser, role: 'developer', active: false }));
expect((await call('/workspaces/workspace-1/git-credential', { userId: devUser })).status).toBe(403);
await store.transaction('demo', tx => tx.putMembership({ userId: devUser, role: 'developer', active: true }));
expect(
(await call('/workspaces/workspace-1/git-credential', { userId: devUser }, env.WF_WORKER_TOKEN)).status,
).toBe(403);
expect((await call('/workspaces/workspace-1/git-credential', { userId: devUser, repositoryUrl: 'x' })).status).toBe(
400,
);
expect((await call('/workspaces/missing/git-credential', { userId: devUser })).status).toBe(404);
expect(gitCalls.filter(entry => entry.path === '/tokens')).toEqual([]);
});
it('does not clone an external repository into the workspace', async () => {
const external = await new Services(new ControlPlane(store, env)).control.createProject(owner, {
name: 'Imported',
repositoryUrl: 'https://github.com/example/imported.git',
});
await workspaceFor(external.id, 'workspace-2');
const response = await call('/workspaces/workspace-2/git-credential', { userId: 'owner' });
expect(response.status).toBe(409);
expect(await response.json()).toMatchObject({ error: { code: 'WORKSPACE_REPOSITORY_UNSUPPORTED' } });
});
});
describe('wishes that start from an IDE branch', () => {
it('lists the ide/ branches people pushed, for platform repositories only', async () => {
vi.stubGlobal('fetch', async (input: string | URL, init: RequestInit) => {
gitCalls.push({
path: new URL(String(input)).pathname,
body: JSON.parse(String(init.body)),
authorization: (init.headers as Record<string, string>).Authorization,
});
return Response.json({
branches: [{ name: 'ide/work', commit: 'b'.repeat(40), updatedAt: '2026-10-19T12:00:00+08:00' }],
});
});
gitCalls = [];
const git = new GitStorage(env);
expect(await git.ideBranches(project)).toEqual([
{ name: 'ide/work', commit: 'b'.repeat(40), updatedAt: '2026-10-19T12:00:00+08:00' },
]);
expect(gitCalls).toEqual([
{
path: '/refs',
body: { tenantId: 'demo', projectId: project.id, prefix: 'refs/heads/ide/' },
authorization: `Bearer ${env.WF_GIT_ADMIN_TOKEN}`,
},
]);
expect(await git.ideBranches({ ...project, repositoryStorage: 'external' })).toEqual([]);
});
it('records the branch on the run and refuses the target branch or the platform’s own branches', async () => {
const control = new Services(new ControlPlane(store, env)).control;
const submit = (sourceBranch: string, key: string) =>
control.submit(
owner,
project.id,
{ goal: 'Merge the IDE work', acceptanceCriteria: ['Checks pass'], sourceBranch },
key,
);
await expect(submit('main', 'source-branch-0001')).rejects.toMatchObject({ code: 'INVALID_SOURCE_BRANCH' });
await expect(submit('wishforge/run/abc', 'source-branch-0002')).rejects.toMatchObject({
code: 'INVALID_SOURCE_BRANCH',
});
await expect(submit('../main', 'source-branch-0003')).rejects.toThrow('A safe Git branch name is required');
const { run_id } = await submit('ide/work', 'source-branch-0004');
expect(await control.run(owner, run_id)).toMatchObject({ sourceBranch: 'ide/work' });
});
});