wishforge-ide/tests/attachments.test.ts
eust-w 3a2296e9d7 ✨ Support image and file attachments on wishes
Wishes can now carry screenshots, designs, logs and documents: upload,
drag-and-drop, or paste into the goal/criteria boxes. The files are stored
as attachment records, written into the executor's workspace under a
Git-ignored directory, and pointed out to the agent in its prompt. People
fetch them back one at a time (images inline, everything else downloads)
with nosniff and a sandbox CSP.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-11-09 14:28:07 +08:00

150 lines
6.4 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { mkdtemp, readFile, mkdir, rm } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import {
ATTACHMENT_DIRECTORY,
attachmentFileName,
base64Size,
wishInput,
type Actor,
type Project,
} from '@wishforge/contracts';
import { BASELINE_BUNDLE, bundlePrompt } from '@wishforge/agent';
import { ControlPlane } from '../apps/api/src/domain/control-plane.js';
import { writeAttachments } from '../apps/worker/src/executor.js';
import { MemoryStore } from './helpers/memory-store.js';
// A wish may carry screenshots, designs and logs for the agent to look at.
const env = {
NODE_ENV: 'test',
WF_DISPATCH_TENANTS: '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' };
const worker: Actor = { ...owner, userId: 'worker', kind: 'worker' };
const png = Buffer.from('89504e470d0a1a0a0000000d49484452', 'hex').toString('base64');
let store: MemoryStore;
let project: Project;
beforeEach(async () => {
vi.stubGlobal('fetch', async (input: string | URL, init: RequestInit) => {
const body = JSON.parse(String(init.body));
if (new URL(String(input)).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');
project = await new ControlPlane(store, env).createProject(owner, { name: 'Todo App' });
});
afterEach(() => vi.unstubAllGlobals());
describe('wish attachments', () => {
it('keeps the files apart from the run, lists them on it, and gives the bytes to the executor only', async () => {
const control = new ControlPlane(store, env);
const { run_id } = await control.submit(
owner,
project.id,
{
goal: 'Make the login page look like the design',
acceptanceCriteria: ['Matches the screenshot'],
attachments: [
{ name: 'design.png', mediaType: 'image/png', data: png },
{ name: 'notes.txt', mediaType: 'text/plain', data: Buffer.from('左对齐').toString('base64') },
],
},
'attachments-0001',
);
const run = await control.run(owner, run_id);
expect(run.attachments).toEqual([
{ id: expect.any(String), name: 'design.png', mediaType: 'image/png', size: 16 },
{ id: expect.any(String), name: 'notes.txt', mediaType: 'text/plain', size: 9 },
]);
expect(JSON.stringify(run)).not.toContain(png);
const events = await control.events(owner, run_id);
expect(events[0]!.message).toContain('2 个附件');
const file = await control.attachment(owner, run_id, run.attachments![0]!.id);
expect(Buffer.from(file.data, 'base64').toString('hex')).toBe('89504e470d0a1a0a0000000d49484452');
await expect(control.attachment(owner, run_id, 'missing')).rejects.toMatchObject({ code: 'NOT_FOUND' });
const forWorker = await control.context(worker, run_id);
expect(forWorker.attachments.map(item => item.name)).toEqual(['design.png', 'notes.txt']);
expect(forWorker.attachments[0]!.data).toBe(png);
expect((await control.context(owner, run_id)).attachments).toEqual([]);
});
it('refuses files beyond the limits', async () => {
const control = new ControlPlane(store, env);
const big = Buffer.alloc(4 * 1024 * 1024).toString('base64');
await expect(
control.submit(
owner,
project.id,
{
goal: 'Too much to look at',
acceptanceCriteria: ['n/a'],
attachments: [1, 2, 3].map(n => ({ name: `${n}.bin`, data: big })),
},
'attachments-0002',
),
).rejects.toMatchObject({ code: 'ATTACHMENTS_TOO_LARGE' });
expect(() =>
wishInput.parse({
goal: 'x',
acceptanceCriteria: ['y'],
attachments: Array.from({ length: 9 }, () => ({ name: 'a.png', data: png })),
}),
).toThrow();
expect(() =>
wishInput.parse({ goal: 'x', acceptanceCriteria: ['y'], attachments: [{ name: 'a', data: 'not base64!' }] }),
).toThrow();
});
it('names files safely and counts base64 bytes', () => {
expect(attachmentFileName(0, '../../etc/passwd')).toBe('01-passwd');
expect(attachmentFileName(2, '.env')).toBe('03-env');
expect(attachmentFileName(9, '登录页 截图(1).png')).toBe('10-登录页 截图_1_.png');
expect(attachmentFileName(0, '')).toBe('01-file');
expect(base64Size(Buffer.from('abcd').toString('base64'))).toBe(4);
expect(base64Size(Buffer.from('abcde').toString('base64'))).toBe(5);
});
it('writes the files into an ignored workspace directory and points the prompt at them', async () => {
const workspace = await mkdtemp(path.join(os.tmpdir(), 'wf-attach-'));
try {
await mkdir(path.join(workspace, '.git', 'info'), { recursive: true });
const files = [{ id: 'a', name: 'design.png', mediaType: 'image/png', data: png }];
const written = await writeAttachments(workspace, files);
// A second round (a repair, a resume) writes them again without repeating the ignore rule.
await writeAttachments(workspace, files);
expect(written).toEqual([
{ path: `${ATTACHMENT_DIRECTORY}/01-design.png`, name: 'design.png', mediaType: 'image/png' },
]);
expect((await readFile(path.join(workspace, written[0]!.path))).toString('base64')).toBe(png);
expect(await readFile(path.join(workspace, '.git', 'info', 'exclude'), 'utf8')).toBe(
`/${ATTACHMENT_DIRECTORY}/\n`,
);
const prompt = bundlePrompt(BASELINE_BUNDLE, {
goal: 'Match the design',
acceptanceCriteria: ['Looks right'],
repairCount: 0,
attachments: written,
});
expect(prompt).toContain(`- ${ATTACHMENT_DIRECTORY}/01-design.png (image/png; uploaded as "design.png")`);
expect(prompt).toContain('view images with your file reading tool');
expect(bundlePrompt(BASELINE_BUNDLE, { goal: 'x', acceptanceCriteria: ['y'], repairCount: 0 })).not.toContain(
ATTACHMENT_DIRECTORY,
);
} finally {
await rm(workspace, { recursive: true, force: true });
}
});
});