Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

18.4 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';

import { AppServerClient, detectAuthInvalidationReason } from './client.js';
import type { Logger } from '../../../interfaces/logger.js';
import type { Transport, LineHandler, StderrHandler, CloseHandler } from './transport.js';
import { Method } from './protocol.js';

class FakeTransport implements Transport {
  readonly lines: string[] = [];
  private writeError: Error | null = null;
  private readonly lineHandlers = new Set<LineHandler>();
  private readonly stderrHandlers = new Set<StderrHandler>();
  private readonly closeHandlers = new Set<CloseHandler>();

  async writeLine(line: string): Promise<void> {
    this.lines.push(line);
    if (this.writeError) throw this.writeError;
  }

  onLine(handler: LineHandler): () => void {
    this.lineHandlers.add(handler);
    return () => this.lineHandlers.delete(handler);
  }

  onClose(handler: CloseHandler): () => void {
    this.closeHandlers.add(handler);
    return () => this.closeHandlers.delete(handler);
  }

  onStderr(handler: StderrHandler): () => void {
    this.stderrHandlers.add(handler);
    return () => this.stderrHandlers.delete(handler);
  }

  async close(reason = 'test close'): Promise<void> {
    for (const handler of this.closeHandlers) handler({ reason });
  }

  emitLine(value: unknown): void {
    const line = typeof value === 'string' ? value : JSON.stringify(value);
    for (const handler of this.lineHandlers) handler(line);
  }

  emitStderr(line: string): void {
    for (const handler of this.stderrHandlers) handler(line);
  }

  failWrites(error: Error): void {
    this.writeError = error;
  }
}

const logger: Logger = {
  trace: vi.fn(),
  debug: vi.fn(),
  info: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
  fatal: vi.fn(),
  child: () => logger,
};

describe('detectAuthInvalidationReason', () => {
  const revokedRateLimitsError = {
    code: -32603,
    message:
      'failed to fetch codex rate limits: GET https://chatgpt.com/backend-api/wham/usage failed: 401 Unauthorized; content-type=text/plain; body={"error":{"message":"Encountered invalidated oauth token for user, failing request","code":"token_revoked"},"status":401}',
  };
  const cloudAuthError = (message: string, data: Record<string, unknown> = {}) => ({
    code: -32000,
    message,
    data: {
      reason: 'cloudRequirements',
      errorCode: 'Auth',
      ...data,
    },
  });

  it('maps provider-specific reasons inside structured cloud auth errors', () => {
    expect(
      detectAuthInvalidationReason(
        cloudAuthError('Your session has ended. Please log in again. (app_session_terminated)'),
      ),
    ).toBe('app_session_terminated');
    expect(
      detectAuthInvalidationReason(
        cloudAuthError('Your authentication token has been invalidated. (token_invalidated)'),
      ),
    ).toBe('token_invalidated');
    expect(
      detectAuthInvalidationReason(cloudAuthError('auth error code: token_revoked')),
    ).toBe('token_revoked');
    expect(
      detectAuthInvalidationReason(cloudAuthError('OAuth refresh token was already used')),
    ).toBe('refresh_token_reused');
  });

  it('uses token_invalidated for a generic structured relogin requirement', () => {
    expect(
      detectAuthInvalidationReason(
        cloudAuthError('Cloud requirements rejected the request', {
          errorCode: undefined,
          action: 'relogin',
        }),
      ),
    ).toBe('token_invalidated');
  });

  it('maps structured cloudConfigBundle auth errors from config load failures', () => {
    // codex-rs app-server config_errors.rs: thread/resume 等在配置加载阶段撞
    // 鉴权失败时返回 -32600 + reason=cloudConfigBundle (detail 带 refresh 失败句)。
    expect(
      detectAuthInvalidationReason({
        code: -32600,
        message:
          'failed to load configuration: Your access token could not be refreshed because your refresh token was revoked. Please log out and sign in again.',
        data: {
          reason: 'cloudConfigBundle',
          errorCode: 'Auth',
          action: 'relogin',
          statusCode: 401,
          detail:
            'Your access token could not be refreshed because your refresh token was revoked. Please log out and sign in again.',
        },
      }),
    ).toBe('token_revoked');
    expect(
      detectAuthInvalidationReason({
        code: -32600,
        message: 'failed to load configuration: request failed',
        data: { reason: 'cloudConfigBundle', errorCode: 'Network' },
      }),
    ).toBeNull();
  });

  it('maps the text-only config-load token refresh failure without structured data', () => {
    expect(
      detectAuthInvalidationReason({
        code: -32600,
        message:
          'failed to load configuration: Your access token could not be refreshed because your refresh token was revoked. Please log out and sign in again.',
      }),
    ).toBe('token_revoked');
    expect(
      detectAuthInvalidationReason({
        code: -32600,
        message:
          'failed to load configuration: Your access token could not be refreshed because your refresh token has expired. Please log out and sign in again.',
      }),
    ).toBe('token_invalidated');
    expect(
      detectAuthInvalidationReason({
        code: -32600,
        message:
          'failed to load configuration: Your access token could not be refreshed because your refresh token was already used. Please log out and sign in again.',
      }),
    ).toBe('refresh_token_reused');
  });

  it('rejects config-load errors and bare refresh sentences that lack the paired signal', () => {
    // 非鉴权的配置加载失败: 不能清凭证。
    expect(
      detectAuthInvalidationReason({
        code: -32600,
        message: 'failed to load configuration: invalid TOML in config.toml',
      }),
    ).toBeNull();
    // 孤立句子没有 config-load 包装也没有结构化 provenance: 保持窄门。
    expect(
      detectAuthInvalidationReason({
        code: -32000,
        message:
          'Your access token could not be refreshed because your refresh token was revoked.',
      }),
    ).toBeNull();
  });

  it('rejects keyword matches without the structured cloud auth provenance', () => {
    expect(
      detectAuthInvalidationReason({
        code: -32000,
        message: 'tool output: source code mentions token_invalidated but no auth request failed',
      }),
    ).toBeNull();
    expect(
      detectAuthInvalidationReason({
        code: -32000,
        message: 'token_revoked',
        data: { reason: 'cloudRequirements', errorCode: 'Network' },
      }),
    ).toBeNull();
    expect(
      detectAuthInvalidationReason({
        code: -32000,
        message: 'refresh token was already used',
        data: { reason: 'toolExecution', errorCode: 'Auth', action: 'relogin' },
      }),
    ).toBeNull();
  });

  it('accepts an explicit 401 token error only for correlated account auth RPCs', () => {
    expect(
      detectAuthInvalidationReason(revokedRateLimitsError, Method.AccountRateLimitsRead),
    ).toBe('token_revoked');
    expect(
      detectAuthInvalidationReason(
        revokedRateLimitsError,
        Method.AccountRateLimitResetCreditConsume,
      ),
    ).toBe('token_revoked');
    expect(detectAuthInvalidationReason(revokedRateLimitsError, Method.ModelList)).toBeNull();
    expect(detectAuthInvalidationReason(revokedRateLimitsError)).toBeNull();
  });
});

describe('AppServerClient auth invalidation', () => {
  it('keeps stderr diagnostic-only even when it contains auth keywords', () => {
    const transport = new FakeTransport();
    const onAuthInvalidated = vi.fn();
    const client = new AppServerClient({
      createTransport: () => transport,
      logger,
      onAuthInvalidated,
    });
    client.start();

    transport.emitStderr('tool output: const code = "token_invalidated";');
    transport.emitStderr('app_session_terminated token_revoked refresh token was already used');

    expect(onAuthInvalidated).not.toHaveBeenCalled();
  });

  it('notifies once for correlated structured cloud auth response errors', async () => {
    const transport = new FakeTransport();
    const onAuthInvalidated = vi.fn();
    const client = new AppServerClient({
      createTransport: () => transport,
      logger,
      onAuthInvalidated,
    });
    client.start();

    const first = client.request('turn/start');
    const second = client.request('model/list');
    transport.emitLine({
      id: 1,
      error: {
        code: -32000,
        message: 'OAuth refresh token was already used',
        data: { reason: 'cloudRequirements', errorCode: 'Auth' },
      },
    });
    transport.emitLine({
      id: 2,
      error: {
        code: -32000,
        message: 'token_revoked',
        data: { reason: 'cloudRequirements', action: 'relogin' },
      },
    });

    await expect(first).rejects.toThrow(/refresh token was already used/i);
    await expect(second).rejects.toThrow(/token_revoked/i);
    expect(onAuthInvalidated).toHaveBeenCalledTimes(1);
    expect(onAuthInvalidated).toHaveBeenCalledWith('refresh_token_reused');
  });

  it('notifies for the account rate-limit 401 shape emitted by current codex-rs', async () => {
    const transport = new FakeTransport();
    const onAuthInvalidated = vi.fn();
    const client = new AppServerClient({
      createTransport: () => transport,
      logger,
      onAuthInvalidated,
    });
    client.start();

    const request = client.request(Method.AccountRateLimitsRead);
    transport.emitLine({
      id: 1,
      error: {
        code: -32603,
        message:
          'failed to fetch codex rate limits: GET https://chatgpt.com/backend-api/wham/usage failed: 401 Unauthorized; content-type=text/plain; body={"error":{"message":"Encountered invalidated oauth token for user, failing request","code":"token_revoked"},"status":401}',
      },
    });

    await expect(request).rejects.toThrow(/account\/rateLimits\/read.*401 Unauthorized/i);
    expect(onAuthInvalidated).toHaveBeenCalledTimes(1);
    expect(onAuthInvalidated).toHaveBeenCalledWith('token_revoked');
  });

  it('keeps auth correlation when an accepted write rejects before its response arrives', async () => {
    const transport = new FakeTransport();
    const onAuthInvalidated = vi.fn();
    const client = new AppServerClient({
      createTransport: () => transport,
      logger,
      onAuthInvalidated,
    });
    client.start();
    transport.failWrites(new Error('write callback failed after bytes were accepted'));

    const request = client.request('turn/start');
    await expect(request).rejects.toThrow(/write callback failed/i);
    expect(transport.lines).toHaveLength(1);

    transport.emitLine({
      id: 1,
      error: {
        code: -32000,
        message: 'token_revoked',
        data: { reason: 'cloudRequirements', errorCode: 'Auth' },
      },
    });

    expect(onAuthInvalidated).toHaveBeenCalledTimes(1);
    expect(onAuthInvalidated).toHaveBeenCalledWith('token_revoked');
  });

  it('does not trust structured auth errors for ids the client never issued', () => {
    const transport = new FakeTransport();
    const onAuthInvalidated = vi.fn();
    const client = new AppServerClient({
      createTransport: () => transport,
      logger,
      onAuthInvalidated,
    });
    client.start();

    transport.emitLine({
      id: 999,
      error: {
        code: -32000,
        message: 'token_invalidated',
        data: { reason: 'cloudRequirements', action: 'relogin' },
      },
    });

    expect(onAuthInvalidated).not.toHaveBeenCalled();
  });
});

describe('AppServerClient close completion', () => {
  it.each([false, true])('shares one close result without losing per-call error policy (failure=%s)', async (fails) => {
    const transport = new FakeTransport();
    let finish!: () => void;
    let fail!: (error: Error) => void;
    const completion = new Promise<void>((resolve, reject) => { finish = resolve; fail = reject; });
    const close = vi.spyOn(transport, 'close').mockImplementation(() => completion);
    const client = new AppServerClient({ createTransport: () => transport, logger });
    client.start();
    const requestFailure = expect(client.request('initialize')).rejects.toThrow('closed');
    const settled = vi.fn();
    const first = client.close().then(settled);
    const strict = client.close({ throwOnTransportError: true });
    const strictResult = fails
      ? expect(strict).rejects.toThrow('exit not confirmed')
      : expect(strict).resolves.toBeUndefined();
    await requestFailure;
    expect(settled).not.toHaveBeenCalled();
    expect(close).toHaveBeenCalledOnce();
    if (fails) fail(new Error('exit not confirmed'));
    else finish();
    await Promise.all([first, strictResult]);
    expect(close).toHaveBeenCalledOnce();
    if (fails) {
      await expect(client.close({ throwOnTransportError: true })).rejects.toThrow('exit not confirmed');
      expect(close).toHaveBeenCalledTimes(2);
      close.mockResolvedValue(undefined);
      await Promise.all([client.close(), client.close({ throwOnTransportError: true })]);
      expect(close).toHaveBeenCalledTimes(3);
      await expect(strict).rejects.toThrow('exit not confirmed');
    }
    await expect(client.close({ throwOnTransportError: true })).resolves.toBeUndefined();
    expect(close).toHaveBeenCalledTimes(fails ? 3 : 1);
    await expect(client.request('initialize')).rejects.toThrow('after close');
  });
});

describe('AppServerClient request timeout', () => {
  it('rejects and removes a pending request when the server stays connected without responding', async () => {
    vi.useFakeTimers();
    try {
      const transport = new FakeTransport();
      const client = new AppServerClient({
        createTransport: () => transport,
        logger,
      });
      client.start();

      const request = client.request(
        'thread/unsubscribe',
        { threadId: 'thread-1' },
        { timeoutMs: 25 },
      );
      const rejection = expect(request).rejects.toThrow(
        'codex app-server thread/unsubscribe timed out after 25ms',
      );
      await vi.advanceTimersByTimeAsync(25);

      await rejection;
      await expect(client.close()).resolves.toBeUndefined();
    } finally {
      vi.useRealTimers();
    }
  });

  describe('extendWhileProgress (#5764)', () => {
    function started() {
      const transport = new FakeTransport();
      const client = new AppServerClient({ createTransport: () => transport, logger });
      client.start();
      const lastId = () => (JSON.parse(transport.lines.at(-1)!) as { id: number }).id;
      return { transport, client, lastId };
    }

    it('keeps waiting past the base timeout while the link still has traffic', async () => {
      vi.useFakeTimers();
      try {
        const { transport, client, lastId } = started();
        let lastProgressAt: number | null = Date.now();
        const request = client.request('thread/start', {}, {
          timeoutMs: 50,
          extendWhileProgress: { lastProgressAt: () => lastProgressAt, idleMs: 30, maxMs: 1_000 },
        });
        for (let elapsed = 0; elapsed < 200; elapsed += 10) {
          lastProgressAt = Date.now();
          await vi.advanceTimersByTimeAsync(10);
        }
        transport.emitLine({ id: lastId(), result: { thread: { id: 't1' } } });
        await expect(request).resolves.toEqual({ thread: { id: 't1' } });
      } finally {
        vi.useRealTimers();
      }
    });

    it('times out once the link goes quiet and reports how long it waited and why', async () => {
      vi.useFakeTimers();
      try {
        const { client } = started();
        let lastProgressAt: number | null = Date.now();
        const request = client.request('thread/start', {}, {
          timeoutMs: 50,
          extendWhileProgress: {
            lastProgressAt: () => lastProgressAt,
            idleMs: 30,
            maxMs: 1_000,
            describe: () => 'execution environment answered 3/4 requests',
          },
        });
        const rejection = expect(request).rejects.toThrow(
          'codex app-server thread/start timed out after 100ms (execution environment answered 3/4 requests)',
        );
        // 往来持续到 70ms 后停止:50ms 时顺延,最后一次往来后 30ms(100ms)结束。
        for (let elapsed = 0; elapsed < 70; elapsed += 10) {
          lastProgressAt = Date.now() + 10;
          await vi.advanceTimersByTimeAsync(10);
        }
        await vi.advanceTimersByTimeAsync(30);
        await rejection;
      } finally {
        vi.useRealTimers();
      }
    });

    it('keeps the base timeout when there is no recent traffic, and stops at maxMs even if traffic continues', async () => {
      vi.useFakeTimers();
      try {
        const { client } = started();
        const quiet = client.request('thread/start', {}, {
          timeoutMs: 50,
          extendWhileProgress: { lastProgressAt: () => null, idleMs: 30, maxMs: 1_000 },
        });
        const quietRejection = expect(quiet).rejects.toThrow('codex app-server thread/start timed out after 50ms');
        await vi.advanceTimersByTimeAsync(50);
        await quietRejection;

        const busy = client.request('thread/start', {}, {
          timeoutMs: 50,
          extendWhileProgress: { lastProgressAt: () => Date.now(), idleMs: 30, maxMs: 200 },
        });
        const busyRejection = expect(busy).rejects.toThrow('codex app-server thread/start timed out after 200ms');
        await vi.advanceTimersByTimeAsync(200);
        await busyRejection;
      } finally {
        vi.useRealTimers();
      }
    });
  });
});

describe('AppServerClient server requests', () => {
  it('passes request id/method metadata to handlers and answers the original JSON-RPC request', async () => {
    const transport = new FakeTransport();
    const client = new AppServerClient({
      createTransport: () => transport,
      logger,
    });
    const handler = vi.fn(async (params, meta) => {
      expect(params).toEqual({ question: 'Pick one' });
      expect(meta).toEqual({ id: 'server-req-1', method: 'item/tool/requestUserInput' });
      return { answers: { q1: { answers: ['A'] } } };
    });

    client.setRequestHandler('item/tool/requestUserInput', handler);
    client.start();
    transport.emitLine({
      id: 'server-req-1',
      method: 'item/tool/requestUserInput',
      params: { question: 'Pick one' },
    });

    await vi.waitFor(() => {
      expect(transport.lines).toHaveLength(1);
    });
    expect(handler).toHaveBeenCalledTimes(1);
    expect(JSON.parse(transport.lines[0] ?? '')).toEqual({
      id: 'server-req-1',
      result: { answers: { q1: { answers: ['A'] } } },
    });
  });
});