// @vitest-environment node
import { mkdtemp, readFile, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { CodingTeacherService, type TeacherScope } from '../../electron/coding-teacher/service';
import { TeacherTopicStore } from '../../electron/coding-teacher/store';
import { compileTeacherContext, sourceContext } from '../../electron/coding-teacher/context';
import { streamTeacherReply } from '../../electron/coding-teacher/model-runner';
import { TeacherError } from '../../electron/coding-teacher/config-client';
import { consultationDefinition } from '../../electron/coding-teacher/consultation-role';
import {
  createCodingProjectStore,
  createMemoryCodingProjectStorage,
} from '../../electron/coding-projects/project-store';
import { CodingProjectService } from '../../electron/coding-projects/project-service';
import {
  ensureDefaultCodingAgent,
  createCodingProjectConfigV2,
} from '../../electron/coding-projects/project-config';
import { InMemoryConversationRuntime } from '../../electron/coding-runtime/in-memory-conversation-runtime';
import type { ConsultationRole, TeacherDefinition, TeacherSourceContext } from '../../shared/coding-teacher';
import type { ConversationSnapshot } from '../../shared/coding-conversation-contracts';
import { parseNianCodeDeepLinkUrl } from '../../electron/main/app-deep-link';

const definition: TeacherDefinition = {
  schema_version: 1,
  teacher_id: 'coding-teacher',
  name: '编程老师',
  description: '',
  avatar_id: 'avatar-01',
  welcome_message: '一起学编程',
  suggested_questions: ['为什么？'],
  system_prompt: '通过问题引导思考。',
  skills: [
    {
      id: 'explain',
      name: '讲解',
      description: '',
      enabled: true,
      instructions_markdown: '使用具体的小例子。',
    },
  ],
  model: { model_id: 'qwen', reasoning_choice: { mode: 'default' } },
  limits: { max_input_tokens: 8000, max_output_tokens: 1500 },
};
const context: TeacherSourceContext = {
  messages: [{ id: 'source-user', role: 'user', text: '创建计数器' }],
  cursor: { workerGeneration: 1, seq: 3 },
  capturedAt: '2026-09-22T00:00:00Z',
};
const roots: string[] = [];
const services: CodingTeacherService[] = [];
afterEach(async () => {
  await Promise.all(services.splice(0).map((service) => service.dispose()));
  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
});
async function fixture() {
  const root = await mkdtemp(path.join(tmpdir(), 'coding-teacher-'));
  roots.push(root);
  const projects = new CodingProjectService(
    createCodingProjectStore(createMemoryCodingProjectStorage())
  );
  const created = await projects.createProject({
    projectPath: path.join(root, 'project'),
    identity: { kind: 'create' },
  });
  const source = await projects
    .conversationStore(created.project.path)
    .create({
      agentId: created.config.defaultAgentId!,
      title: '源码会话',
      model: null,
      modelResolution: 'required',
    });
  const scope = { projectId: created.project.id, sourceId: source.id };
  let enabled = true,
    version = 1,
    accountCurrent = true;
  let finish: () => void = () => undefined;
  const run = vi.fn(async (_messages, signal: AbortSignal, onText: (text: string) => void) => {
    onText('计数器保存一个数字。');
    await new Promise<void>((resolve, reject) => {
      finish = resolve;
      signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
    });
    return { inputTokens: 20, outputTokens: 10 };
  });
  let account = {
    id: '11111111-1111-4111-8111-111111111111',
    binding: { accountKey: 'test', epoch: 1 },
  };
  const readSource = vi.fn(async (_scope: TeacherScope) => structuredClone(context));
  const prepareModel = vi.fn(async () => ({ inputLimit: 8000, run }));
  const service = new CodingTeacherService({
    projects,
    runtime: new InMemoryConversationRuntime(),
    userDataDir: root,
    account: async () => account,
    assertAccount: () => {
      if (!accountCurrent) throw new TeacherError(401, 'teacher_account_changed', '账号变化');
    },
    availability: async () => ({ enabled, published_version: version, revision: version }),
    version: async (_account, v) => ({
      version: v,
      payload: { ...definition, name: '老师 v' + v },
    }),
    preview: async (_account, revision) => {
      if (revision !== 2) throw new TeacherError(409, 'teacher_draft_changed', '草稿变化');
      return { draft_revision: revision, payload: definition };
    },
    readSource,
    prepareModel,
  });
  services.push(service);
  return {
    root,
    projects,
    created,
    scope,
    service,
    run,
    readSource,
    prepareModel,
    finish: () => finish(),
    disable: () => {
      enabled = false;
    },
    nextVersion: () => {
      version++;
    },
    switchAccount: () => {
      accountCurrent = false;
    },
    useOtherAccount: () => {
      account = {
        id: '99999999-9999-4999-8999-999999999999',
        binding: { accountKey: 'another-account', epoch: 2 },
      };
    },
  };
}
describe('cloud coding teacher', () => {
  it('persists a fixed version, deduplicates requests, and does not change coding metadata', async () => {
    const f = await fixture();
    const before = await readFile(
      path.join(f.created.project.path, '.makelore/conversations.json'),
      'utf8'
    );
    const topic = await f.service.create(f.scope);
    f.nextVersion();
    const next = await f.service.create(f.scope);
    expect(next.version).toBe(2);
    expect(topic.version).toBe(1);
    const input = { requestId: '22222222-2222-4222-8222-222222222222', text: '解释一下' };
    await f.service.send(f.scope, topic.id, input);
    await f.service.send(f.scope, topic.id, input);
    expect(f.run).toHaveBeenCalledOnce();
    await expect(
      f.service.send(f.scope, topic.id, { ...input, text: '不同问题' })
    ).rejects.toMatchObject({ code: 'teacher_request_conflict' });
    f.finish();
    await vi.waitFor(async () =>
      expect((await f.service.read(f.scope, topic.id)).requests[0].status).toBe('completed')
    );
    expect(
      await readFile(path.join(f.created.project.path, '.makelore/conversations.json'), 'utf8')
    ).toBe(before);
    expect((await f.service.list(f.scope)).items).toHaveLength(2);
  });
  it('honors disable for old topics while keeping readable history', async () => {
    const f = await fixture(),
      topic = await f.service.create(f.scope);
    f.disable();
    await expect(
      f.service.send(f.scope, topic.id, {
        requestId: '22222222-2222-4222-8222-222222222222',
        text: '问题',
      })
    ).rejects.toMatchObject({ code: 'teacher_disabled' });
    expect((await f.service.read(f.scope, topic.id)).version).toBe(1);
    expect(f.run).not.toHaveBeenCalled();
  });
  it('cancels partial replies and rejects another concurrent question', async () => {
    const f = await fixture(),
      topic = await f.service.create(f.scope),
      id = '22222222-2222-4222-8222-222222222222';
    await f.service.send(f.scope, topic.id, { requestId: id, text: '问题' });
    await expect(
      f.service.send(f.scope, topic.id, {
        requestId: '33333333-3333-4333-8333-333333333333',
        text: '另一个问题',
      })
    ).rejects.toMatchObject({ code: 'teacher_topic_busy' });
    await f.service.cancel(f.scope, topic.id, id);
    await vi.waitFor(async () =>
      expect((await f.service.read(f.scope, topic.id)).requests[0]).toMatchObject({
        status: 'cancelled',
        response: '计数器保存一个数字。',
      })
    );
  });
  it('retains interrupted requests on restart without submitting again', async () => {
    const f = await fixture(),
      topic = await f.service.create(f.scope),
      id = '22222222-2222-4222-8222-222222222222';
    await f.service.send(f.scope, topic.id, { requestId: id, text: '问题' });
    const store = new TeacherTopicStore(
      path.join(
        f.created.project.path,
        '.makelore/teacher-conversations',
        topic.accountId,
        f.scope.sourceId
      )
    );
    expect((await store.read(topic.id)).requests[0].status).toBe('interrupted');
    expect(f.run).toHaveBeenCalledOnce();
    await f.service.cancel(f.scope, topic.id, id);
  });
  it('checks exact preview revision and never reads project context for preview', async () => {
    const f = await fixture(),
      scope = { projectId: 'preview', sourceId: 'preview' };
    await expect(f.service.create(scope, 1, 'sample')).rejects.toMatchObject({
      code: 'teacher_draft_changed',
    });
    const topic = await f.service.create(scope, 2, '示例项目的计数器');
    await f.service.send(scope, topic.id, {
      requestId: '22222222-2222-4222-8222-222222222222',
      text: '怎么改进',
    });
    expect(JSON.stringify(f.run.mock.calls[0][0])).toContain('示例项目的计数器');
    expect(JSON.stringify(f.run.mock.calls[0][0])).not.toContain('创建计数器');
    f.finish();
  });
  it('rejects foreign message references before submitting a model request', async () => {
    const f = await fixture(),
      topic = await f.service.create(f.scope);
    await expect(
      f.service.send(f.scope, topic.id, {
        requestId: '22222222-2222-4222-8222-222222222222',
        text: '解释',
        references: [{ kind: 'message', messageId: 'another-source', text: '别的项目' }],
      })
    ).rejects.toMatchObject({ code: 'teacher_reference_invalid' });
    expect(f.run).not.toHaveBeenCalled();
  });
  it('cascades source deletion after cancelling its reply, without recreating files', async () => {
    const f = await fixture(),
      topic = await f.service.create(f.scope);
    await f.service.send(f.scope, topic.id, {
      requestId: '22222222-2222-4222-8222-222222222222',
      text: '问题',
    });
    await f.service.removeSource(f.scope.projectId, f.scope.sourceId);
    await expect(f.service.read(f.scope, topic.id)).rejects.toMatchObject({
      code: 'teacher_source_not_found',
    });
    await expect(
      readFile(
        path.join(
          f.created.project.path,
          '.makelore/teacher-conversations',
          topic.accountId,
          f.scope.sourceId,
          topic.id + '.json'
        )
      )
    ).rejects.toMatchObject({ code: 'ENOENT' });
  });
  it('fails account changes before dispatch', async () => {
    const f = await fixture(),
      topic = await f.service.create(f.scope);
    f.switchAccount();
    await f.service.send(f.scope, topic.id, {
      requestId: '22222222-2222-4222-8222-222222222222',
      text: '问题',
    });
    await vi.waitFor(async () =>
      expect((await f.service.read(f.scope, topic.id)).requests[0].status).toBe('failed')
    );
    expect(f.run).not.toHaveBeenCalled();
  });
});
describe('project teacher and friend consultations', () => {
  const requestId = '22222222-2222-4222-8222-222222222222';
  const nextRequestId = '33333333-3333-4333-8333-333333333333';
  const roles: ConsultationRole[] = ['teacher', 'friend'];

  it('keeps teacher and friend histories and personas separate without running on open', async () => {
    const f = await fixture();
    const teacherScope = { projectId: f.scope.projectId, sourceId: 'project', role: 'teacher' as const };
    const friendScope = { ...teacherScope, role: 'friend' as const };
    const teacher = await f.service.create(teacherScope);
    const friend = await f.service.create(friendScope);
    expect((await f.service.list(teacherScope)).items.map((item) => item.id)).toEqual([teacher.id]);
    expect((await f.service.list(friendScope)).items.map((item) => item.id)).toEqual([friend.id]);
    expect((await f.service.read(teacherScope, teacher.id)).role).toBe('teacher');
    const onSnapshot = vi.fn();
    const unsubscribe = await f.service.subscribe(friendScope, friend.id, onSnapshot);
    expect(onSnapshot).toHaveBeenCalledOnce();
    unsubscribe();
    expect(f.readSource).not.toHaveBeenCalled();
    expect(f.prepareModel).not.toHaveBeenCalled();
    expect(f.run).not.toHaveBeenCalled();
    await expect(f.service.read(friendScope, teacher.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
    await expect(f.service.read(teacherScope, friend.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });

    await f.service.send(teacherScope, teacher.id, { requestId, text: '我应该怎么想？' });
    await f.service.send(friendScope, friend.id, { requestId, text: '你有什么感受？' });
    const teacherPrompt = f.run.mock.calls[0][0][0].content;
    const friendPrompt = f.run.mock.calls[1][0][0].content;
    expect(teacherPrompt).toContain('引导思考');
    expect(teacherPrompt).toContain('使用具体的小例子');
    expect(friendPrompt).toContain('数字朋友');
    expect(friendPrompt).toContain('不要假装运行、试玩');
    expect(friendPrompt).not.toContain('使用具体的小例子');
    expect(friendPrompt).not.toContain('你是编程老师');
    expect(friend.definition.model).toEqual(teacher.definition.model);
    expect(friend.version).toBe(teacher.version);
    expect((await f.service.read(teacherScope, teacher.id)).requests[0].text).toBe('我应该怎么想？');
    expect((await f.service.read(friendScope, friend.id)).requests[0].text).toBe('你有什么感受？');
  });

  it('selects the current operation conversation per request and deduplicates retries by source', async () => {
    const f = await fixture();
    const scope = { projectId: f.scope.projectId, sourceId: 'project' };
    const other = await f.projects.conversationStore(f.created.project.path).create({
      agentId: f.created.config.defaultAgentId!, title: '另一个操作对话', model: null, modelResolution: 'required',
    });
    f.readSource.mockImplementation(async (selected) => ({
      ...context,
      messages: [{ id: selected.sourceId, role: 'user', text: selected.sourceId === f.scope.sourceId ? '第一段操作' : '第二段操作' }],
    }));
    const topic = await f.service.create(scope);
    const input = { requestId, text: '我这样理解对吗？', sourceConversationId: f.scope.sourceId };
    await Promise.all([f.service.send(scope, topic.id, input), f.service.send(scope, topic.id, input)]);
    expect(f.run).toHaveBeenCalledOnce();
    expect(f.readSource).toHaveBeenCalledWith({ ...scope, sourceId: f.scope.sourceId });
    await expect(f.service.send(scope, topic.id, { ...input, sourceConversationId: other.id }))
      .rejects.toMatchObject({ code: 'teacher_request_conflict' });
    let complete!: () => void;
    const completed = new Promise<void>((resolve) => { complete = resolve; });
    const unsubscribe = await f.service.subscribe(scope, topic.id, (snapshot) => {
      if (snapshot.requests[0].status === 'completed') complete();
    });
    f.finish();
    await completed;
    unsubscribe();
    await f.service.send(scope, topic.id, { ...input, requestId: nextRequestId, sourceConversationId: other.id });
    const latest = await f.service.read(scope, topic.id);
    expect(latest.requests.map((request) => request.sourceConversationId)).toEqual([f.scope.sourceId, other.id]);
    expect(latest.requests[1].includedSourceMessageIds).toEqual([other.id]);
    expect(JSON.stringify(f.run.mock.calls[1][0])).toContain('第二段操作');
    expect(JSON.stringify(f.run.mock.calls[1][0])).not.toContain('第一段操作');
    expect(latest.id).toBe(topic.id);
  });

  it.each(roles)('rejects cross-project sources and isolates %s topics by project and account', async (role) => {
    const f = await fixture();
    const scope = { projectId: f.scope.projectId, sourceId: 'project', role };
    const topic = await f.service.create(scope);
    const other = await f.projects.createProject({ projectPath: path.join(f.root, 'other-project'), identity: { kind: 'create' } });
    const foreign = await f.projects.conversationStore(other.project.path).create({
      agentId: other.config.defaultAgentId!, title: '外部对话', model: null, modelResolution: 'required',
    });
    await expect(f.service.send(scope, topic.id, { requestId, text: '帮我理解', sourceConversationId: foreign.id }))
      .rejects.toMatchObject({ code: 'teacher_source_not_found' });
    expect(f.readSource).not.toHaveBeenCalled();
    expect(f.prepareModel).not.toHaveBeenCalled();
    expect((await f.service.read(scope, topic.id)).requests).toEqual([]);
    const otherScope = { ...scope, projectId: other.project.id };
    expect((await f.service.list(otherScope)).items).toEqual([]);
    await expect(f.service.read(otherScope, topic.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
    f.useOtherAccount();
    expect((await f.service.list(scope)).items).toEqual([]);
    await expect(f.service.read(scope, topic.id)).rejects.toMatchObject({ code: 'teacher_topic_not_found' });
    expect(f.run).not.toHaveBeenCalled();
  });

  it.each(roles)('cancels an active %s reply when its operation source is deleted, preserving project history', async (role) => {
    const f = await fixture();
    const scope = { projectId: f.scope.projectId, sourceId: 'project', role };
    const topic = await f.service.create(scope);
    await f.service.send(scope, topic.id, { requestId, text: '问题', sourceConversationId: f.scope.sourceId });
    await f.service.removeSource(f.scope.projectId, f.scope.sourceId);
    const saved = await f.service.read(scope, topic.id);
    expect(saved.requests[0]).toMatchObject({ status: 'cancelled', response: '计数器保存一个数字。' });
    expect((await f.service.list(scope)).items.map((item) => item.id)).toEqual([topic.id]);
    await expect(f.service.send(scope, topic.id, { requestId: nextRequestId, text: '再问一次', sourceConversationId: f.scope.sourceId }))
      .rejects.toMatchObject({ code: 'teacher_source_not_found' });
    expect(f.run).toHaveBeenCalledOnce();
  });

  it.each(roles)('does not dispatch a preparing %s request after its source is deleted', async (role) => {
    const f = await fixture();
    const scope = { projectId: f.scope.projectId, sourceId: 'project', role };
    const topic = await f.service.create(scope);
    let releasePreparation!: () => void;
    f.prepareModel.mockImplementationOnce(async () => {
      await new Promise<void>((resolve) => { releasePreparation = resolve; });
      return { inputLimit: 8000, run: f.run };
    });
    const sending = f.service.send(scope, topic.id, { requestId, text: '问题', sourceConversationId: f.scope.sourceId });
    const rejected = expect(sending).rejects.toMatchObject({ code: 'teacher_source_not_found' });
    await vi.waitFor(() => expect(f.prepareModel).toHaveBeenCalledOnce());
    const deleting = f.service.removeSource(f.scope.projectId, f.scope.sourceId);
    await vi.waitFor(async () => expect(f.service.list(f.scope)).rejects.toMatchObject({ code: 'teacher_source_not_found' }));
    releasePreparation();
    await rejected;
    await deleting;
    expect(f.run).not.toHaveBeenCalled();
    expect((await f.service.read(scope, topic.id)).requests).toEqual([]);
  });

  it('settles a persisted project request as cancelled if deletion races its initial save', async () => {
    const f = await fixture();
    const scope = { projectId: f.scope.projectId, sourceId: 'project', role: 'friend' as const };
    const topic = await f.service.create(scope);
    let saved!: () => void;
    let releaseSave!: () => void;
    const savedToDisk = new Promise<void>((resolve) => { saved = resolve; });
    const allowSaveReturn = new Promise<void>((resolve) => { releaseSave = resolve; });
    const originalSave = TeacherTopicStore.prototype.save;
    const spy = vi.spyOn(TeacherTopicStore.prototype, 'save').mockImplementation(async function (value) {
      await originalSave.call(this, value);
      if (value.id === topic.id && value.requests[0]?.status === 'preparing') {
        saved();
        await allowSaveReturn;
      }
    });
    try {
      const sending = f.service.send(scope, topic.id, { requestId, text: '问题', sourceConversationId: f.scope.sourceId });
      await savedToDisk;
      const deleting = f.service.removeSource(f.scope.projectId, f.scope.sourceId);
      await vi.waitFor(async () => expect(f.service.list(f.scope)).rejects.toMatchObject({ code: 'teacher_source_not_found' }));
      releaseSave();
      await sending;
      await deleting;
      expect(f.run).not.toHaveBeenCalled();
      expect((await f.service.read(scope, topic.id)).requests[0].status).toBe('cancelled');
      const stored = JSON.parse(await readFile(path.join(
        f.created.project.path, '.makelore/friend-conversations', topic.accountId, 'project', topic.id + '.json'
      ), 'utf8'));
      expect(stored.requests[0].status).toBe('cancelled');
    } finally {
      releaseSave();
      spy.mockRestore();
    }
  });

  it('derives friend configuration without mutating published teacher prompts or skills', () => {
    const original = structuredClone(definition);
    const friend = consultationDefinition(definition, 'friend');
    expect(friend.teacher_id).toBe('coding-friend');
    expect(friend.skills).toEqual([]);
    expect(definition).toEqual(original);
    expect(consultationDefinition(definition, 'teacher')).toBe(definition);
  });
});

describe('teacher context and wire contract', () => {
  it('takes only complete user/assistant text and preserves the read cursor', () => {
    const snapshot = {
      nodes: [
        {
          kind: 'message',
          id: 'u',
          role: 'user',
          status: 'complete',
          blocks: [{ kind: 'text', status: 'complete', text: '用户问题' }],
        },
        {
          kind: 'message',
          id: 'a',
          role: 'assistant',
          status: 'complete',
          blocks: [
            { kind: 'thinking', status: 'complete', text: 'private' },
            { kind: 'text', status: 'complete', text: '完整回答' },
          ],
        },
        {
          kind: 'message',
          id: 'live',
          role: 'assistant',
          status: 'streaming',
          blocks: [{ kind: 'text', status: 'streaming', text: '未完成' }],
        },
        { kind: 'tool', id: 'tool', args: { password: 'secret' } },
      ],
      cursor: { workerGeneration: 2, seq: 10 },
    } as ConversationSnapshot;
    const selected = sourceContext(snapshot);
    expect(selected.messages.map((message) => message.text)).toEqual(['用户问题', '完整回答']);
    expect(selected.cursor).toEqual(snapshot.cursor);
  });
  it('trims old source messages but retains instructions, Skill, explicit quote and question', () => {
    const compiled = compileTeacherContext(
      definition,
      {
        ...context,
        messages: [{ id: 'old', role: 'user', text: 'old'.repeat(4000) }, ...context.messages],
      },
      [],
      '为什么这样？',
      [{ kind: 'code', text: 'count += 1' }],
      1200
    );
    const text = JSON.stringify(compiled.messages);
    expect(text).toContain('通过问题引导思考');
    expect(text).toContain('使用具体的小例子');
    expect(text).toContain('count += 1');
    expect(compiled.omittedMessages).toBe(1);
    expect(() => compileTeacherContext(definition, context, [], 'x'.repeat(9000), [])).toThrow(
      '超过上下文预算'
    );
  });
  it('sends no tools, ignores reasoning deltas, and requires a terminal stream', async () => {
    const text: string[] = [];
    const fake = vi.fn(
      async () =>
        new Response(
          'data: {"choices":[{"delta":{"reasoning_content":"hidden","content":"答案"}}]}\n\ndata: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":10,"completion_tokens":3}}\n\ndata: [DONE]\n\n'
        )
    );
    const usage = await streamTeacherReply(
      { base_url: 'https://gateway.test/v1', api_key: 'private' },
      'model',
      {},
      1500,
      [{ role: 'user', content: '问题' }],
      new AbortController().signal,
      (delta) => text.push(delta),
      fake
    );
    expect(text).toEqual(['答案']);
    expect(usage).toEqual({ inputTokens: 10, outputTokens: 3 });
    const input = fake.mock.calls[0] as unknown as [string, RequestInit];
    const body = JSON.parse(input[1].body as string);
    expect(body).not.toHaveProperty('tools');
    expect(input[0]).toBe('https://gateway.test/v1/chat/completions');
    await expect(
      streamTeacherReply(
        { base_url: 'https://gateway.test/v1', api_key: 'private' },
        'model',
        {},
        1500,
        [],
        new AbortController().signal,
        () => undefined,
        async () => new Response('data: {"choices":[{"delta":{"content":"半句"}}]}\n\n')
      )
    ).rejects.toMatchObject({ code: 'teacher_stream_interrupted' });
  });
  it('accepts only the exact credential-free preview link', () => {
    expect(
      parseNianCodeDeepLinkUrl('niancode://coding-teacher/preview?draft_revision=2')
    ).toMatchObject({ type: 'teacher-preview', draftRevision: 2 });
    expect(
      parseNianCodeDeepLinkUrl('niancode://coding-teacher/preview?draft_revision=2&token=x')
    ).toBeNull();
    expect(
      parseNianCodeDeepLinkUrl('niancode://coding-teacher/preview?draft_revision=0')
    ).toBeNull();
  });
  it('creates one default and preserves all legacy identities without reviving disabled Agents', () => {
    const base = createCodingProjectConfigV2();
    expect(base.agents).toHaveLength(1);
    expect(ensureDefaultCodingAgent(base)).toBe(base);
    const legacy = {
      ...base,
      defaultAgentId: undefined,
      agents: [
        { ...base.agents[0], id: 'old', enabled: false },
        { ...base.agents[0], id: 'existing', pinned: true },
      ],
    };
    const normalized = ensureDefaultCodingAgent(legacy);
    expect(normalized.defaultAgentId).toBe('existing');
    expect(normalized.agents).toEqual(legacy.agents);
    const disabled = ensureDefaultCodingAgent({ ...legacy, agents: [legacy.agents[0]] });
    expect(disabled.agents[0].enabled).toBe(false);
    expect(disabled.agents).toHaveLength(2);
  });
});
import {mkdir, writeFile} from 'node:fs/promises';
import {readCodingConversationHistory} from '../../electron/coding-projects/conversation-history';
import {getPiManagedPaths} from '../../electron/coding-runtime/pi/resource-loader';
it('reads only the durable active branch without starting a worker', async()=>{
  const f=await fixture();
  const metadata=(await f.projects.conversationStore(f.created.project.path).get(f.scope.sourceId))!;
  const folder=path.join(getPiManagedPaths(f.root).sessionsDir,f.scope.projectId);await mkdir(folder,{recursive:true});
  const entries=[
    {type:'session',id:'session'},
    {type:'message',id:'root',parentId:null,message:{role:'user',content:'开始学习'}},
    {type:'message',id:'abandoned',parentId:'root',message:{role:'user',content:'旧分支内容'}},
    {type:'message',id:'active',parentId:'root',message:{role:'user',content:'当前分支内容'}},
  ];
  await writeFile(path.join(folder,'session-test.jsonl'),entries.map(entry=>JSON.stringify(entry)).join('\n'));
  const snapshot=await readCodingConversationHistory(f.root,f.scope.projectId,{...metadata,sessionKey:'session-test'});
  expect(sourceContext(snapshot).messages.map(message=>message.text)).toEqual(['开始学习','当前分支内容']);
  expect(snapshot.worker.status).toBe('stopped');
});
import {createServer} from 'node:http';
import {handleCodingTeacherRoutes} from '../../electron/api/routes/coding-teacher';
import type {HostApiContext} from '../../electron/api/context';
it('serves topic acceptance and SSE snapshots without cancelling on stream close',async()=>{
  const f=await fixture();
  const server=createServer((req,res)=>{void handleCodingTeacherRoutes(req,res,new URL(req.url!,'http://localhost'),{codingProducts:{teacher:f.service}} as HostApiContext);});
  await new Promise<void>(resolve=>server.listen(0,'127.0.0.1',resolve));
  const address=server.address();if(!address||typeof address==='string')throw new Error('no address');
  const origin='http://127.0.0.1:'+address.port;
  const base=origin+'/api/coding/projects/'+f.scope.projectId+'/conversations/'+f.scope.sourceId+'/teacher-topics';
  try {
    const created=await fetch(base,{method:'POST',headers:{'Content-Type':'application/json'},body:'{}'});expect(created.status).toBe(201);
    const topic=await created.json();const requestId='22222222-2222-4222-8222-222222222222';
    const accepted=await fetch(base+'/'+topic.id+'/messages',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({requestId,text:'讲解一下'})});expect(accepted.status).toBe(202);
    const stream=await fetch(base+'/'+topic.id+'/events');expect(stream.headers.get('content-type')).toContain('text/event-stream');
    const reader=stream.body!.getReader();const chunk=await reader.read();expect(new TextDecoder().decode(chunk.value)).toContain('event: snapshot');await reader.cancel();
    expect((await f.service.read(f.scope,topic.id)).requests[0].status).toBe('running');
    const cancelled=await fetch(base+'/'+topic.id+'/requests/'+requestId+'/cancel',{method:'POST'});expect(cancelled.status).toBe(200);
    await vi.waitFor(async()=>expect((await f.service.read(f.scope,topic.id)).requests[0].status).toBe('cancelled'));
    expect((await fetch(origin+'/api/coding/teacher/config',{method:'POST'})).status).toBe(405);
  } finally {server.closeAllConnections();await new Promise<void>((resolve,reject)=>server.close(error=>error?reject(error):resolve()));}
});

it.each(['teacher', 'friend'] as const)('routes project-level %s config and topic messages without a source-scoped URL', async (role) => {
  const f = await fixture();
  const server = createServer((req, res) => {
    void handleCodingTeacherRoutes(req, res, new URL(req.url!, 'http://localhost'), {
      codingProducts: { teacher: f.service },
    } as HostApiContext);
  });
  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
  const address = server.address();
  if (!address || typeof address === 'string') throw new Error('no address');
  const origin = 'http://127.0.0.1:' + address.port;
  const base = `${origin}/api/coding/projects/${f.scope.projectId}/${role}-topics`;
  const post = (url: string, body = {}) => fetch(url, {
    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
  });
  try {
    const config = await fetch(`${origin}/api/coding/${role}/config`);
    expect(config.status).toBe(200);
    expect((await config.json()).definition.teacher_id).toBe('coding-' + role);
    expect((await post(`${origin}/api/coding/${role}/config`)).status).toBe(405);
    const created = await post(base);
    expect(created.status).toBe(201);
    const topic = await created.json();
    expect(topic).toMatchObject({ role, sourceConversationId: 'project', projectId: f.scope.projectId });
    const listed = await fetch(base);
    expect((await listed.json()).items.map((item: { id: string }) => item.id)).toEqual([topic.id]);
    expect((await fetch(`${base}/${topic.id}`)).status).toBe(200);
    expect(f.run).not.toHaveBeenCalled();
    const requestId = '22222222-2222-4222-8222-222222222222';
    const input = { requestId, text: '我想聊聊', sourceConversationId: f.scope.sourceId };
    expect((await post(`${base}/${topic.id}/messages`, input)).status).toBe(202);
    expect((await post(`${base}/${topic.id}/messages`, input)).status).toBe(202);
    expect(f.run).toHaveBeenCalledOnce();
    const accepted = await fetch(`${base}/${topic.id}`);
    expect((await accepted.json()).requests[0].sourceConversationId).toBe(f.scope.sourceId);
    expect((await post(`${base}/${topic.id}/requests/${requestId}/cancel`)).status).toBe(200);
    await vi.waitFor(async () => expect((await f.service.read({ projectId: f.scope.projectId, sourceId: 'project', role }, topic.id)).requests[0].status).toBe('cancelled'));
  } finally {
    server.closeAllConnections();
    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
  }
});