feat(agents): 完成云智能体工作台与交互流程

tests/unit/cloud-agents-main.test.ts

@@ -1,15 +1,28 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, readFile, writeFile, rm, readdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { CloudAgentsModule } from '@electron/services/cloud-agents';
+import { EMPTY_CLOUD_CONFIGURATION } from '../../shared/cloud-agents';
 import { clearWorksSquareSession, storeWorksSquareSession } from '@electron/services/works-square-session';
 
+const desktop = vi.hoisted(() => ({ pick: vi.fn(), save: vi.fn(), show: vi.fn(), click: vi.fn() }));
+vi.mock('electron', () => ({
+  app: { getPath: () => '/tmp/cloud-agents-test', getVersion: () => 'test', isPackaged: false },
+  dialog: { showOpenDialog: desktop.pick, showSaveDialog: desktop.save },
+  Notification: class { static isSupported() { return true; } on = desktop.click; show = desktop.show; },
+  BrowserWindow: { getAllWindows: () => [] },
+}));
+
 const draft = {
   slug: 'ml-' + 'a'.repeat(32), name: '写作搭档', purpose: '帮助写作', system_prompt: '简明表达',
   draft_revision: 1, updated_at: '2026-09-10T00:00:00Z',
+  configuration: EMPTY_CLOUD_CONFIGURATION, published_version: null, enabled: true,
 };
 const input = { operation_id: '12345678-1234-1234-1234-123456789012', name: draft.name, purpose: draft.purpose };
 const json = (value: unknown, status = 200) => new Response(JSON.stringify(value), { status });
 const session = () => json({
-  access_token: 'yuxi-secret', token_type: 'bearer', scope: 'makelore-agent-drafts',
+  access_token: 'yuxi-secret', token_type: 'bearer', scope: 'makelore-agents',
   expires_at: Math.floor(Date.now() / 1000) + 120, api_base_url: 'https://agents.example.test',
 });
 function login(key = 'a'.repeat(64)) {
@@ -19,10 +32,119 @@ const instances: CloudAgentsModule[] = [];
 function moduleFor(fetchImpl: typeof fetch) {
   const module = new CloudAgentsModule(fetchImpl); instances.push(module); return module;
 }
-beforeEach(() => { clearWorksSquareSession(); login(); });
+beforeEach(() => { vi.clearAllMocks(); clearWorksSquareSession(); login(); });
 afterEach(() => { instances.splice(0).forEach((module) => module.dispose()); clearWorksSquareSession(); vi.useRealTimers(); });
 
 describe('Main cloud Agents boundary', () => {
+  it('reads upload bytes and writes downloaded bytes only through Main dialogs', async () => {
+    const directory = await mkdtemp(join(tmpdir(), 'makelore-cloud-files-'));
+    try {
+      const source = join(directory, 'material.txt'), destination = join(directory, 'result.txt');
+      await writeFile(source, 'local material');
+      desktop.pick.mockResolvedValue({ canceled: false, filePaths: [source] });
+      desktop.save.mockResolvedValue({ canceled: false, filePath: destination });
+      const transport = vi.fn().mockResolvedValueOnce(session()).mockResolvedValueOnce(json({
+        object_name: 'private-upload', file_name: 'material.txt', parse_supported: false, parse_methods: [],
+      })).mockResolvedValueOnce(new Response('cloud result'));
+      const module = moduleFor(transport);
+      expect((await module.upload())?.file_name).toBe('material.txt');
+      const payload = transport.mock.calls[1][1].body as FormData;
+      expect(await (payload.get('file') as File).text()).toBe('local material');
+      expect(await module.download({ thread_id: 'thread', path: '/mnt/user-data/projects/one/result.txt' })).toEqual({ saved: true });
+      expect(await readFile(destination, 'utf8')).toBe('cloud result');
+      expect((await readdir(directory)).sort()).toEqual(['material.txt', 'result.txt']);
+    } finally { await rm(directory, { recursive: true, force: true }); }
+  });
+
+  it('rejects an account switch while a file picker is open without reading or uploading it', async () => {
+    let finish!: (value: unknown) => void;
+    desktop.pick.mockImplementationOnce(() => new Promise(resolve => { finish = resolve; }));
+    const transport = vi.fn();
+    const upload = moduleFor(transport).upload();
+    const failure = expect(upload).rejects.toMatchObject({ code: 'account_changed' });
+    await vi.waitFor(() => expect(desktop.pick).toHaveBeenCalled());
+    login('b'.repeat(64));
+    finish({ canceled: false, filePaths: ['not-read.txt'] });
+    await failure;
+    expect(transport).not.toHaveBeenCalled();
+  });
+
+  it('notifies only a new unread terminal state and resets its baseline on account switch', async () => {
+    vi.useFakeTimers();
+    const transport = vi.fn().mockResolvedValueOnce(session()).mockResolvedValueOnce(json({ agents: [], next_cursor: null }))
+      .mockResolvedValueOnce(json({ threads: [{ run_id: 'one', status: 'running', unread: true }] }))
+      .mockResolvedValue(json({ threads: [{ run_id: 'one', status: 'completed', unread: true }] }));
+    const module = moduleFor(transport);
+    await module.list();
+    await vi.advanceTimersByTimeAsync(30000);
+    expect(desktop.show).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(30000);
+    expect(desktop.show).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(30000);
+    expect(desktop.show).toHaveBeenCalledTimes(1);
+    login('b'.repeat(64));
+    const calls = transport.mock.calls.length;
+    await vi.advanceTimersByTimeAsync(30000);
+    expect(transport).toHaveBeenCalledTimes(calls);
+  });
+
+  it('allowlists execution fields and preserves safe publication metadata', async () => {
+    const fetchImpl = vi.fn().mockResolvedValueOnce(session()).mockResolvedValueOnce(json({
+      request_id: 'request', thread_id: 'thread', run_id: 'run', status: 'pending', version: '4',
+      access_token: 'never-render', input_payload: { creator_id: 'private' },
+    }));
+    const module = moduleFor(fetchImpl);
+    const result = await module.execute({ operation: 'submit', input: {
+      slug: draft.slug, request_id: 'request', thread_id: 'thread', query: 'hello',
+      creator_id: 'forged', payer: 'caller', model: 'unauthorized', snapshot: {},
+    } });
+    expect(result).toEqual({ request_id: 'request', thread_id: 'thread', run_id: 'run', status: 'pending', version: '4' });
+    expect(JSON.parse(fetchImpl.mock.calls[1][1].body)).toEqual({ request_id: 'request', thread_id: 'thread', query: 'hello' });
+  });
+
+  it('uses the WS credential directly for the creator ledger and never exchanges it into Renderer data', async () => {
+    const fetchImpl = vi.fn().mockResolvedValueOnce(json({ unit: '词元点数', items: [], access_token: 'private' }));
+    const result = await moduleFor(fetchImpl).execute({ operation: 'costs', input: { slug: draft.slug } });
+    expect(result).toEqual({ unit: '词元点数', items: [] });
+    expect(fetchImpl.mock.calls[0][0]).toContain('/api/cloud-agents/costs?agent_slug=');
+    expect(fetchImpl.mock.calls[0][1].headers.Authorization).toBe('Bearer ws-secret');
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects arbitrary operation names and route traversal before any request', async () => {
+    const fetchImpl = vi.fn();
+    const module = moduleFor(fetchImpl);
+    await expect(module.execute({ operation: 'proxy', input: { url: 'https://evil.test' } })).rejects.toMatchObject({ status: 422 });
+    await expect(module.execute({ operation: 'run', input: { run_id: '../../admin' } })).rejects.toMatchObject({ status: 422 });
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('passes user validation failures as 422 without returning upstream text', async () => {
+    const fetchImpl = vi.fn().mockResolvedValueOnce(session()).mockResolvedValueOnce(json({ detail: [{ msg: 'raw credential' }] }, 422));
+    await expect(moduleFor(fetchImpl).execute({ operation: 'createSchedule', input: { slug: draft.slug } }))
+      .rejects.toMatchObject({ status: 422, code: 'invalid_input' });
+  });
+
+  it('cancels the active cloud stream immediately on account switch', async () => {
+    let streamController!: ReadableStreamDefaultController<Uint8Array>;
+    let transportSignal: AbortSignal | undefined;
+    const fetchImpl = vi.fn().mockResolvedValueOnce(session()).mockImplementationOnce((_url, init) => {
+      transportSignal = init.signal;
+      return Promise.resolve(new Response(new ReadableStream<Uint8Array>({
+        start(controller) {
+          streamController = controller;
+          init.signal.addEventListener('abort', () => controller.error(new Error('aborted')));
+        },
+      }), { headers: { 'Content-Type': 'text/event-stream' } }));
+    });
+    const iterator = moduleFor(fetchImpl).events('run-id', '0-0', new AbortController().signal);
+    const pending = iterator.next();
+    const failed = expect(pending).rejects.toBeDefined();
+    await vi.waitFor(() => expect(streamController).toBeDefined());
+    login('b'.repeat(64));
+    expect(transportSignal?.aborted).toBe(true);
+    await failed;
+  });
   it('keeps credentials in Main, projects the DTO and sends only creator-independent inputs', async () => {
     const fetchImpl = vi.fn().mockResolvedValueOnce(session())
       .mockResolvedValueOnce(json({ ...draft, access_token: 'do-not-project', owner: 'private' }))