work-ally 0.2.0-alpha.1

package/bridge/src/fake-runtime-client.ts

@@ -0,0 +1,505 @@
+import { EventEmitter } from 'node:events';
+import { randomId, sleep } from './utils.ts';
+import type { ApprovalRequest, ConnectionLifecycleEvent, RuntimeProgressMeta, RuntimeThreadStatus, RuntimeTurnResult, UserInputRequest } from './types.ts';
+
+type FakeApprovalDecision = 'accept' | 'acceptForSession' | 'decline' | 'cancel';
+
+interface FakeTurnOptions {
+  threadId: string;
+  prompt: string;
+  messageId: string;
+  onTurnStarted?: (turnId: string) => Promise<void> | void;
+  onProgress?: (text: string, meta?: RuntimeProgressMeta) => Promise<void> | void;
+  onThreadStatus?: (status: RuntimeThreadStatus, meta?: { threadId?: string | null; turnId?: string | null }) => Promise<void> | void;
+  onApproval?: (approval: ApprovalRequest) => Promise<void> | void;
+  onUserInput?: (request: UserInputRequest) => Promise<void> | void;
+}
+
+type FakeUserInputResponse = { answers: Record<string, { answers: string[] }> };
+type FakeElicitationResponse = { action: 'accept' | 'decline' | 'cancel'; content: unknown | null };
+
+
+export class FakeRuntimeClient {
+  private readonly approvalResolvers = new Map<string, (decision: FakeApprovalDecision) => void>();
+  private readonly emitter = new EventEmitter();
+  private readonly approvalThreadIds = new Map<string, string>();
+  private readonly interruptedTurns = new Set<string>();
+  private readonly threadStatuses = new Map<string, RuntimeThreadStatus>();
+  private readonly userInputResolvers = new Map<string, (response: FakeUserInputResponse | FakeElicitationResponse) => void>();
+  private readonly userInputThreadIds = new Map<string, string>();
+  private readonly pendingUserInputResponses = new Map<string, FakeUserInputResponse | FakeElicitationResponse>();
+  private readonly activeThreadTurns = new Map<string, string>();
+  private readonly turnPrompts = new Map<string, string[]>();
+  private readonly turnThreadIds = new Map<string, string>();
+
+  private setThreadStatus(threadId: string, status: RuntimeThreadStatus): RuntimeThreadStatus {
+    const normalized = {
+      type: status.type,
+      activeFlags: [...status.activeFlags],
+    } satisfies RuntimeThreadStatus;
+    this.threadStatuses.set(threadId, normalized);
+    return normalized;
+  }
+
+  onConnectionEvent(listener: (event: ConnectionLifecycleEvent) => void): void {
+    this.emitter.on('connectionLifecycle', listener);
+  }
+
+  onServerRequestResolved(listener: (event: { requestId: string | number; threadId: string | null; turnId: string | null }) => void): void {
+    this.emitter.on('serverRequestResolved', listener);
+  }
+
+  offServerRequestResolved(listener: (event: { requestId: string | number; threadId: string | null; turnId: string | null }) => void): void {
+    this.emitter.off('serverRequestResolved', listener);
+  }
+
+  offConnectionEvent(listener: (event: ConnectionLifecycleEvent) => void): void {
+    this.emitter.off('connectionLifecycle', listener);
+  }
+
+  emitConnectionEvent(event: ConnectionLifecycleEvent): void {
+    this.emitter.emit('connectionLifecycle', event);
+  }
+
+  emitServerRequestResolved(event: { requestId: string | number; threadId: string | null; turnId: string | null }): void {
+    this.emitter.emit('serverRequestResolved', event);
+  }
+
+
+  async healthcheck(): Promise<boolean> {
+    return true;
+  }
+
+  async startThread(_cwd?: string, _options?: unknown): Promise<{ id: string }> {
+    const id = randomId('thread');
+    this.setThreadStatus(id, { type: 'idle', activeFlags: [] });
+    return { id };
+  }
+
+  async resumeThread(threadId: string, _cwd?: string, _options?: unknown): Promise<{ id: string }> {
+    if (!this.threadStatuses.has(threadId)) {
+      this.setThreadStatus(threadId, { type: 'idle', activeFlags: [] });
+    }
+    return { id: threadId };
+  }
+
+  async readThreadStatus(threadId: string): Promise<RuntimeThreadStatus | null> {
+    return this.threadStatuses.get(threadId) || null;
+  }
+
+  async readThreadWithTurns(threadId: string): Promise<{ id: string; status: RuntimeThreadStatus | null; turns: any[] }> {
+    return {
+      id: threadId,
+      status: this.threadStatuses.get(threadId) || null,
+      turns: [],
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    return;
+  }
+
+  async interruptTurn(threadId: string, turnId: string): Promise<void> {
+    this.interruptedTurns.add(turnId);
+    if (this.activeThreadTurns.get(threadId) === turnId) {
+      this.activeThreadTurns.delete(threadId);
+      this.setThreadStatus(threadId, { type: 'idle', activeFlags: [] });
+    }
+    this.turnPrompts.delete(turnId);
+    this.turnThreadIds.delete(turnId);
+  }
+
+  async steerTurn(threadId: string, turnId: string, prompt: string): Promise<void> {
+    if (this.activeThreadTurns.get(threadId) !== turnId) {
+      throw new Error(`turn not active: ${turnId}`);
+    }
+    const prompts = this.turnPrompts.get(turnId) || [];
+    prompts.push(prompt);
+    this.turnPrompts.set(turnId, prompts);
+  }
+
+  async resolveApproval(requestId: string | number, decision: FakeApprovalDecision): Promise<void> {
+    const key = String(requestId);
+    const resolver = this.approvalResolvers.get(key);
+    const threadId = this.approvalThreadIds.get(key);
+    const turnId = threadId ? this.activeThreadTurns.get(threadId) || null : null;
+    if (threadId) {
+      this.setThreadStatus(threadId, { type: 'active', activeFlags: [] });
+      this.approvalThreadIds.delete(key);
+    }
+    this.emitter.emit('serverRequestResolved', { requestId, threadId: threadId || null, turnId });
+    if (resolver) {
+      this.approvalResolvers.delete(key);
+      resolver(decision);
+    }
+  }
+
+  async resolveUserInput(requestId: string | number, response: FakeUserInputResponse): Promise<void> {
+    const key = String(requestId);
+    const resolver = this.userInputResolvers.get(key);
+    const threadId = this.userInputThreadIds.get(key);
+    const turnId = threadId ? this.activeThreadTurns.get(threadId) || null : null;
+    if (threadId) {
+      this.setThreadStatus(threadId, { type: 'active', activeFlags: [] });
+      this.userInputThreadIds.delete(key);
+    }
+    this.emitter.emit('serverRequestResolved', { requestId, threadId: threadId || null, turnId });
+    if (resolver) {
+      this.userInputResolvers.delete(key);
+      resolver(response);
+      return;
+    }
+    this.pendingUserInputResponses.set(key, response);
+  }
+
+  async resolveElicitation(requestId: string | number, response: FakeElicitationResponse): Promise<void> {
+    const key = String(requestId);
+    const resolver = this.userInputResolvers.get(key);
+    const threadId = this.userInputThreadIds.get(key);
+    const turnId = threadId ? this.activeThreadTurns.get(threadId) || null : null;
+    if (threadId) {
+      this.setThreadStatus(threadId, { type: 'active', activeFlags: [] });
+      this.userInputThreadIds.delete(key);
+    }
+    this.emitter.emit('serverRequestResolved', { requestId, threadId: threadId || null, turnId });
+    if (resolver) {
+      this.userInputResolvers.delete(key);
+      resolver(response);
+      return;
+    }
+    this.pendingUserInputResponses.set(key, response);
+  }
+
+  private isInterrupted(turnId: string): boolean {
+    return this.interruptedTurns.has(turnId);
+  }
+
+  private async waitForApproval(approval: ApprovalRequest): Promise<FakeApprovalDecision> {
+    this.approvalThreadIds.set(String(approval.requestId), approval.threadId);
+    return new Promise<FakeApprovalDecision>((resolve) => {
+      this.approvalResolvers.set(String(approval.requestId), resolve);
+    });
+  }
+
+  private async waitForUserInput(request: UserInputRequest): Promise<FakeUserInputResponse | FakeElicitationResponse> {
+    const key = String(request.requestId);
+    this.userInputThreadIds.set(key, request.threadId);
+    const early = this.pendingUserInputResponses.get(key);
+    if (early) {
+      this.pendingUserInputResponses.delete(key);
+      return early;
+    }
+    return new Promise((resolve) => {
+      this.userInputResolvers.set(key, resolve);
+    });
+  }
+
+  async runTurn(options: FakeTurnOptions): Promise<RuntimeTurnResult> {
+    const turnId = randomId('turn');
+    this.activeThreadTurns.set(options.threadId, turnId);
+    this.turnPrompts.set(turnId, [options.prompt]);
+    this.turnThreadIds.set(turnId, options.threadId);
+    this.setThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+    await options.onTurnStarted?.(turnId);
+    await options.onProgress?.('正在处理...');
+
+    if (options.prompt.includes('[context-compaction]')) {
+      const itemId = 'item_context_compaction_1';
+      await options.onProgress?.('Codex 正在压缩当前会话上下文。', {
+        kind: 'context_compaction',
+        phase: null,
+        turnId,
+        itemId,
+      });
+      await options.onProgress?.('Codex 正在压缩当前会话上下文。', {
+        kind: 'context_compaction',
+        phase: null,
+        turnId,
+        itemId,
+      });
+    }
+
+    if (options.prompt.includes('[slow]')) {
+      await sleep(150);
+    } else {
+      await sleep(20);
+    }
+
+    if (this.isInterrupted(turnId)) {
+      this.activeThreadTurns.delete(options.threadId);
+      this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+      this.turnPrompts.delete(turnId);
+      this.turnThreadIds.delete(turnId);
+      return {
+        threadId: options.threadId,
+        turnId,
+        status: 'failed',
+        reply: '',
+        error: 'turn interrupted',
+      };
+    }
+
+    if (options.prompt.includes('[file-approval]')) {
+      const approval: ApprovalRequest = {
+        approvalId: randomId('approval'),
+        kind: 'file_change',
+        requestId: randomId('request'),
+        threadId: options.threadId,
+        turnId,
+        messageId: options.messageId,
+        reason: 'fake file-change approval gate',
+        grantRoot: '/workspace/docs',
+        cwd: '/workspace',
+      };
+      const waitingStatus = this.setThreadStatus(options.threadId, { type: 'active', activeFlags: ['waitingOnApproval'] });
+      await options.onThreadStatus?.(waitingStatus, { threadId: options.threadId, turnId });
+      await options.onApproval?.(approval);
+      const decision = await this.waitForApproval(approval);
+      if (decision === 'decline' || decision === 'cancel') {
+        this.activeThreadTurns.delete(options.threadId);
+        this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+        this.turnPrompts.delete(turnId);
+        this.turnThreadIds.delete(turnId);
+        return {
+          threadId: options.threadId,
+          turnId,
+          status: 'failed',
+          reply: '',
+          error: 'approval declined',
+        };
+      }
+      this.setThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+    }
+
+    if (options.prompt.includes('[approval]')) {
+      const approval: ApprovalRequest = {
+        approvalId: randomId('approval'),
+        kind: 'command',
+        requestId: randomId('request'),
+        threadId: options.threadId,
+        turnId,
+        messageId: options.messageId,
+        command: 'echo protected-action',
+        reason: 'fake approval gate',
+      };
+      const waitingStatus = this.setThreadStatus(options.threadId, { type: 'active', activeFlags: ['waitingOnApproval'] });
+      await options.onThreadStatus?.(waitingStatus, { threadId: options.threadId, turnId });
+      await options.onApproval?.(approval);
+      const decision = await this.waitForApproval(approval);
+      if (decision === 'decline' || decision === 'cancel') {
+        this.activeThreadTurns.delete(options.threadId);
+        this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+        this.turnPrompts.delete(turnId);
+        this.turnThreadIds.delete(turnId);
+        return {
+          threadId: options.threadId,
+          turnId,
+          status: 'failed',
+          reply: '',
+          error: 'approval declined',
+        };
+      }
+      this.setThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+    }
+
+    if (options.prompt.includes('[ask-user]')) {
+      const request: UserInputRequest = {
+        requestId: randomId('request_user_input'),
+        threadId: options.threadId,
+        turnId,
+        itemId: randomId('item'),
+        messageId: options.messageId,
+        questions: [
+          {
+            id: 'clarify_goal',
+            header: '补充目标',
+            question: '你希望我重点关注什么？',
+            options: [
+              { label: '摘要', description: '提取核心要点' },
+              { label: '改写', description: '直接给出改写稿' },
+            ],
+          },
+        ],
+      };
+      const waitingStatus = this.setThreadStatus(options.threadId, { type: 'active', activeFlags: ['waitingOnUserInput'] });
+      await options.onThreadStatus?.(waitingStatus, { threadId: options.threadId, turnId });
+      await options.onUserInput?.(request);
+      const response = await this.waitForUserInput(request) as FakeUserInputResponse;
+      const answer = response.answers.clarify_goal?.answers?.join(' / ') || '未提供答案';
+      this.setThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+      const reply = `fake runtime reply after user input: ${answer}`;
+      this.activeThreadTurns.delete(options.threadId);
+      this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+      this.turnPrompts.delete(turnId);
+      this.turnThreadIds.delete(turnId);
+      return {
+        threadId: options.threadId,
+        turnId,
+        status: 'completed',
+        reply,
+      };
+    }
+
+    if (options.prompt.includes('[mcp-elicitation]') || options.prompt.includes('[mcp-elicitation-github]')) {
+      const isGithub = options.prompt.includes('[mcp-elicitation-github]');
+      const request: UserInputRequest = {
+        requestId: randomId('request_user_input'),
+        threadId: options.threadId,
+        turnId,
+        itemId: null,
+        messageId: options.messageId,
+        kind: 'mcp_elicitation',
+        elicitation: {
+          serverName: isGithub ? 'github' : 'feishu',
+          mode: 'form',
+          message: isGithub
+            ? 'The github MCP server wants to run the tool "create-issue", which may modify data and access external systems. Allow this action?'
+            : 'The feishu MCP server wants to run the tool "fetch-doc", which may modify data and access external systems. Allow this action?',
+          requestedSchema: {
+            type: 'object',
+            properties: {
+              response: {
+                oneOf: [
+                  { const: 'approved', title: 'Approve this Session', description: 'Run the tool and remember this choice for this session.' },
+                  { const: 'approved_once', title: 'Approve Once', description: 'Run the tool and continue.' },
+                  { const: 'declined', title: 'Deny', description: 'Decline this tool call and continue.' },
+                  { const: 'cancelled', title: 'Cancel', description: 'Cancel this tool call.' },
+                ],
+              },
+            },
+          },
+        },
+        questions: [
+          {
+            id: 'response',
+            header: 'MCP 确认',
+            question: isGithub
+              ? 'The github MCP server wants to run the tool "create-issue", which may modify data and access external systems. Allow this action?'
+              : 'The feishu MCP server wants to run the tool "fetch-doc", which may modify data and access external systems. Allow this action?',
+            options: [
+              { label: 'Approve Once', description: 'Run the tool and continue.' },
+              { label: 'Approve this Session', description: 'Run the tool and remember this choice for this session.' },
+              { label: 'Deny', description: 'Decline this tool call and continue.' },
+              { label: 'Cancel', description: 'Cancel this tool call.' },
+            ],
+          },
+        ],
+      };
+      const waitingStatus = this.setThreadStatus(options.threadId, { type: 'active', activeFlags: ['waitingOnUserInput'] });
+      await options.onThreadStatus?.(waitingStatus, { threadId: options.threadId, turnId });
+      await options.onUserInput?.(request);
+      const response = await this.waitForUserInput(request) as FakeElicitationResponse;
+      this.setThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+      const selected = (response.content && typeof response.content === 'object' && !Array.isArray(response.content))
+        ? String((response.content as any).response || '')
+        : '';
+      if (response.action !== 'accept' || !['approved', 'approved_once', 'Approve this Session', 'Approve Once'].includes(selected)) {
+        this.activeThreadTurns.delete(options.threadId);
+        this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+        this.turnPrompts.delete(turnId);
+        this.turnThreadIds.delete(turnId);
+        return {
+          threadId: options.threadId,
+          turnId,
+          status: 'failed',
+          reply: '',
+          error: 'mcp elicitation declined',
+        };
+      }
+      const reply = 'fake runtime reply after MCP elicitation approval';
+      this.activeThreadTurns.delete(options.threadId);
+      this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+      this.turnPrompts.delete(turnId);
+      this.turnThreadIds.delete(turnId);
+      return {
+        threadId: options.threadId,
+        turnId,
+        status: 'completed',
+        reply,
+      };
+    }
+
+    if (options.prompt.includes('[mcp-tool-approval]') || options.prompt.includes('[mcp-tool-approval-github]')) {
+      const isGithub = options.prompt.includes('[mcp-tool-approval-github]');
+      const request: UserInputRequest = {
+        requestId: randomId('request_user_input'),
+        threadId: options.threadId,
+        turnId,
+        itemId: randomId('item'),
+        messageId: options.messageId,
+        questions: [
+          {
+            id: 'mcp_tool_call_approval_call_1',
+            header: 'Approve app tool call?',
+            question: isGithub
+              ? 'The github MCP server wants to run the tool "create-issue", which may modify data and access external systems. Allow this action?'
+              : 'The feishu MCP server wants to run the tool "fetch-doc", which may modify data and access external systems. Allow this action?',
+            options: [
+              { label: 'Approve Once', description: 'Run the tool and continue.' },
+              { label: 'Approve this Session', description: 'Run the tool and remember this choice for this session.' },
+              { label: 'Deny', description: 'Decline this tool call and continue.' },
+              { label: 'Cancel', description: 'Cancel this tool call' },
+            ],
+          },
+        ],
+      };
+      const waitingStatus = this.setThreadStatus(options.threadId, { type: 'active', activeFlags: ['waitingOnUserInput'] });
+      await options.onThreadStatus?.(waitingStatus, { threadId: options.threadId, turnId });
+      await options.onUserInput?.(request);
+      const response = await this.waitForUserInput(request) as FakeUserInputResponse;
+      const answer = response.answers.mcp_tool_call_approval_call_1?.answers?.[0] || '';
+      this.setThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+      if (answer !== 'Approve this Session' && answer !== 'Approve Once') {
+        this.activeThreadTurns.delete(options.threadId);
+        this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+        this.turnPrompts.delete(turnId);
+        this.turnThreadIds.delete(turnId);
+        return {
+          threadId: options.threadId,
+          turnId,
+          status: 'failed',
+          reply: '',
+          error: 'mcp tool call declined',
+        };
+      }
+      const reply = 'fake runtime reply after MCP tool approval';
+      this.activeThreadTurns.delete(options.threadId);
+      this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+      this.turnPrompts.delete(turnId);
+      this.turnThreadIds.delete(turnId);
+      return {
+        threadId: options.threadId,
+        turnId,
+        status: 'completed',
+        reply,
+      };
+    }
+
+    if (this.isInterrupted(turnId)) {
+      this.activeThreadTurns.delete(options.threadId);
+      this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+      this.turnPrompts.delete(turnId);
+      this.turnThreadIds.delete(turnId);
+      return {
+        threadId: options.threadId,
+        turnId,
+        status: 'failed',
+        reply: '',
+        error: 'turn interrupted',
+      };
+    }
+
+    const prompts = this.turnPrompts.get(turnId) || [options.prompt];
+    const reply = `fake runtime reply: ${prompts.join(' | ')}`;
+    this.activeThreadTurns.delete(options.threadId);
+    this.setThreadStatus(options.threadId, { type: 'idle', activeFlags: [] });
+    this.turnPrompts.delete(turnId);
+    this.turnThreadIds.delete(turnId);
+    return {
+      threadId: options.threadId,
+      turnId,
+      status: 'completed',
+      reply,
+    };
+  }
+}