work-ally 0.2.0-alpha.1

package/bridge/src/receiver.ts

@@ -0,0 +1,329 @@
+import path from 'node:path';
+import { formatCommandApprovalRulesStatusLines, loadCommandApprovalRules, type CommandApprovalRuleset } from './approval-rules.ts';
+import type { ChannelAdapter, OutboundEnvelope } from './channel-types.ts';
+import { errorDetailsFromUnknown } from './receiver-helpers.ts';
+import { replayHiddenApprovalNotice, replayHiddenPendingUserInput, runtimeWaitingStateFor, waitingStateFor } from './receiver-human-gate.ts';
+import { isActiveTurnStale, runtimeRecoveryKindFor } from './receiver-recovery.ts';
+import { handleControlCommand } from './receiver-control.ts';
+import { handleInboundPreflight } from './receiver-inbound-preflight.ts';
+import { prepareInboundThreadStart } from './receiver-thread-start.ts';
+import type { WorkAllyConfig } from './config.ts';
+import { parseApprovalReply, parseControlCommand } from './router.ts';
+import { logInfo, logWarn } from './logger.ts';
+import { clearBridgeDeliveryIssue, describeChannelDeliveryIssue, isNonFatalChannelDeliveryError, recordBridgeDeliveryIssue } from './channel-delivery.ts';
+import type { SessionStore } from './session-store.ts';
+import { executeInboundTurn } from './receiver-turn-execution.ts';
+import { createRuntimeRecoveryRegistry, readCurrentRuntimeThreadStatus } from './receiver-runtime-state.ts';
+import { steerActiveTurn } from './receiver-turn-steer.ts';
+import { createReceiverSupportActions } from './receiver-support-actions.ts';
+import { HandoffService } from './handoff-service.ts';
+import { ensureLinkedWorkSessionForThread, syncLinkedWorkSessionThread } from './receiver-work-session.ts';
+import { syncThreadConversationById } from './thread-sync.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+import type {
+  ConnectionLifecycleEvent,
+  ConversationRef,
+  InboundMessage,
+  RuntimeThreadStatus,
+  SessionMeta,
+  ServerRequestResolvedEvent,
+  RuntimeProgressMeta,
+  RuntimeTurnResult,
+  UserInputRequest,
+} from './types.ts';
+
+interface RuntimeLike {
+  startThread(cwd: string): Promise<{ id: string }>;
+  resumeThread(threadId: string, cwd: string): Promise<{ id: string }>;
+  runTurn(options: {
+    threadId: string;
+    prompt: string;
+    messageId: string;
+    cwd: 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: any) => Promise<void> | void;
+    onUserInput?: (request: UserInputRequest) => Promise<void> | void;
+    approvalPolicy?: 'untrusted' | 'on-failure' | 'on-request' | 'never';
+    sandboxPolicy?: unknown;
+  }): Promise<RuntimeTurnResult>;
+  resolveApproval(requestId: string | number, decision: 'accept' | 'acceptForSession' | 'decline' | 'cancel'): Promise<void>;
+  resolveUserInput(requestId: string | number, response: { answers: Record<string, { answers: string[] }> }): Promise<void>;
+  resolveElicitation(
+    requestId: string | number,
+    response: { action: 'accept' | 'decline' | 'cancel'; content: unknown | null },
+  ): Promise<void>;
+  steerTurn?(threadId: string, turnId: string, prompt: string): Promise<void>;
+  interruptTurn(threadId: string, turnId: string): Promise<void>;
+  readThreadStatus(threadId: string): Promise<RuntimeThreadStatus | null>;
+  readThreadWithTurns?(threadId: string): Promise<{ id: string; status: RuntimeThreadStatus | null; turns: any[] }>;
+  recoverTurnResult?(threadId: string, turnId: string, options?: { timeoutMs?: number; pollMs?: number }): Promise<RuntimeTurnResult | null>;
+  onConnectionEvent?(listener: (event: ConnectionLifecycleEvent) => void): void;
+  offConnectionEvent?(listener: (event: ConnectionLifecycleEvent) => void): void;
+  onServerRequestResolved?(listener: (event: ServerRequestResolvedEvent) => void): void;
+  offServerRequestResolved?(listener: (event: ServerRequestResolvedEvent) => void): void;
+}
+
+export class Receiver {
+  private readonly config: WorkAllyConfig;
+  private readonly channel: ChannelAdapter;
+  private readonly sessionStore: SessionStore;
+  private readonly runtime: RuntimeLike;
+  private readonly workSessionStore: WorkSessionStore;
+  private readonly handoffService: HandoffService;
+  private readonly connectionLifecycleListener: (event: ConnectionLifecycleEvent) => void;
+  private readonly serverRequestResolvedListener: (event: ServerRequestResolvedEvent) => void;
+  private readonly suppressedInterruptedTurnIds = new Set<string>();
+  private connectionLifecycleQueue: Promise<void> = Promise.resolve();
+  private readonly runtimeRecovery: ReturnType<typeof createRuntimeRecoveryRegistry>;
+  private readonly userRequestedStopTurnIds = new Set<string>();
+  private readonly approvalNoticeTimers = new Map<string, NodeJS.Timeout>();
+  private readonly commandApprovalRules: CommandApprovalRuleset;
+  private readonly support: ReturnType<typeof createReceiverSupportActions>;
+
+  constructor(
+    config: WorkAllyConfig,
+    channel: ChannelAdapter,
+    sessionStore: SessionStore,
+    runtimeOrLegacyArchive: RuntimeLike,
+    runtimeOrWorkSessionStore?: RuntimeLike | WorkSessionStore,
+    workSessionStoreMaybe?: WorkSessionStore,
+  ) {
+    const runtime = runtimeOrWorkSessionStore && typeof (runtimeOrWorkSessionStore as RuntimeLike).startThread === 'function'
+      ? runtimeOrWorkSessionStore as RuntimeLike
+      : runtimeOrLegacyArchive;
+    const workSessionStore = runtimeOrWorkSessionStore && typeof (runtimeOrWorkSessionStore as RuntimeLike).startThread === 'function'
+      ? workSessionStoreMaybe
+      : runtimeOrWorkSessionStore as WorkSessionStore | undefined;
+
+    this.config = config;
+    this.channel = channel;
+    this.sessionStore = sessionStore;
+    this.runtime = runtime;
+    this.workSessionStore = workSessionStore || new WorkSessionStore(this.config.paths.workSessionsDir || path.join(this.config.paths.runtimeDir, 'work-sessions'));
+    this.handoffService = new HandoffService(this.config, this.workSessionStore);
+    this.runtimeRecovery = createRuntimeRecoveryRegistry(this.sessionStore);
+    this.commandApprovalRules = loadCommandApprovalRules({
+      assistantCodexHome: this.assistantCodexHome(),
+    });
+    this.support = createReceiverSupportActions({
+      config: this.config,
+      sessionStore: this.sessionStore,
+      runtime: this.runtime,
+      runtimeRecovery: this.runtimeRecovery,
+      approvalNoticeTimers: this.approvalNoticeTimers,
+      commandApprovalRules: this.commandApprovalRules,
+      send: this.send.bind(this),
+    });
+
+    this.connectionLifecycleListener = (event) => {
+      this.connectionLifecycleQueue = this.connectionLifecycleQueue
+        .catch(() => undefined)
+        .then(() => this.support.handleConnectionLifecycle(event))
+        .catch((error) => {
+          logWarn('receiver', 'connection_lifecycle_notice_failed', {
+            source: event.source,
+            state: event.state,
+            error: errorDetailsFromUnknown(error),
+          });
+        });
+    };
+    this.serverRequestResolvedListener = (event) => {
+      void this.support.handleServerRequestResolved(event);
+    };
+    this.runtime.onConnectionEvent?.(this.connectionLifecycleListener);
+    this.runtime.onServerRequestResolved?.(this.serverRequestResolvedListener);
+    this.channel.onConnectionEvent?.(this.connectionLifecycleListener);
+  }
+
+  private assistantName(): string {
+    return String(this.config.assistant?.name || 'native').trim() || 'native';
+  }
+
+  private assistantCodexHome(): string | null {
+    const codexHome = String(this.config.assistant?.codexHome || '').trim();
+    return codexHome || null;
+  }
+
+  private async send(
+    outbound: OutboundEnvelope,
+    extra: Record<string, unknown> = {},
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean> {
+    try {
+      await this.channel.send(outbound);
+      clearBridgeDeliveryIssue(this.config.paths.runtimeDir);
+      if (delivery?.trackTurnId) {
+        this.sessionStore.markTurnDelivery(outbound.conversationRef, delivery.trackTurnId, 'delivered');
+      }
+      if (outbound.type === 'final_reply') {
+        const session = this.sessionStore.getSession(outbound.conversationRef);
+        if (session?.threadId && typeof this.runtime.readThreadWithTurns === 'function') {
+          syncThreadConversationById(this.config, this.runtime, session.threadId).catch((error) => {
+            logWarn('receiver', 'thread_sync_after_reply_failed', {
+              threadId: session.threadId,
+              conversationId: outbound.conversationRef.conversationId,
+              error: errorDetailsFromUnknown(error),
+            });
+          });
+        }
+      }
+      return true;
+    } catch (error) {
+      if (isNonFatalChannelDeliveryError(error)) {
+        recordBridgeDeliveryIssue(this.config.paths.runtimeDir, error);
+        logWarn('receiver', 'channel_delivery_unavailable', {
+          conversationId: outbound.conversationRef.conversationId,
+          envelopeType: outbound.type,
+          ...describeChannelDeliveryIssue(error),
+        });
+        if (delivery?.trackTurnId) {
+          this.sessionStore.markTurnDelivery(outbound.conversationRef, delivery.trackTurnId, 'delivery_unavailable');
+        }
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  private async handleControl(message: InboundMessage): Promise<boolean> {
+    const command = parseControlCommand(message.text) || parseApprovalReply(message.text, message.replyToText);
+    if (!command) {
+      return false;
+    }
+
+    return handleControlCommand({
+      config: this.config,
+      runtime: this.runtime,
+      sessionStore: this.sessionStore,
+      workSessionStore: this.workSessionStore,
+      handoffService: this.handoffService,
+      send: this.send.bind(this),
+      assistantName: this.assistantName(),
+      assistantCodexHome: this.assistantCodexHome(),
+      commandApprovalRulesStatusLines: formatCommandApprovalRulesStatusLines(this.commandApprovalRules),
+      noteUserRequestedStop: (turnId) => this.userRequestedStopTurnIds.add(turnId),
+    }, {
+      message,
+      command,
+      session: this.sessionStore.ensureSession(message.conversationRef),
+    });
+  }
+
+  async redeliverPendingFinalReplies(conversationRef: InboundMessage['conversationRef']): Promise<number> {
+    return this.support.redeliverPendingFinalReplies(conversationRef);
+  }
+
+  async handleInbound(message: InboundMessage): Promise<void> {
+    logInfo('receiver', 'inbound_received', {
+      messageId: message.messageId,
+      conversationId: message.conversationRef.conversationId,
+      userId: message.conversationRef.userId,
+      textPreview: message.text.slice(0, 120),
+      isControl: Boolean(parseControlCommand(message.text)),
+    });
+    this.sessionStore.noteInboundObserved(message.conversationRef, message.messageId);
+
+    const receipt = this.sessionStore.noteInboundReceipt(message.conversationRef, message.messageId);
+    if (receipt.status === 'duplicate_completed') {
+      logWarn('receiver', 'inbound_duplicate_completed', {
+        messageId: message.messageId,
+        conversationId: message.conversationRef.conversationId,
+      });
+      return;
+    }
+    if (receipt.status === 'duplicate_superseded') {
+      logWarn('receiver', 'inbound_duplicate_superseded', {
+        messageId: message.messageId,
+        conversationId: message.conversationRef.conversationId,
+      });
+      return;
+    }
+    if (receipt.status === 'duplicate_processing') {
+      logWarn('receiver', 'inbound_duplicate_processing', {
+        messageId: message.messageId,
+        conversationId: message.conversationRef.conversationId,
+      });
+      return;
+    }
+
+    let shouldCompleteReceipt = false;
+    try {
+      if (await this.handleControl(message)) {
+        shouldCompleteReceipt = true;
+        return;
+      }
+
+      const preflight = await handleInboundPreflight({
+        sessionStore: this.sessionStore,
+        send: this.send.bind(this),
+        maybeResumePendingUserInput: (inbound) => this.support.maybeResumePendingUserInput(inbound),
+        replayHiddenPendingApproval: (ref, threadId, turnId) => replayHiddenApprovalNotice({
+          sessionStore: this.sessionStore,
+          send: this.send.bind(this),
+          approvalBoundaryReason: (approval) => this.support.approvalBoundaryReason(approval),
+        }, ref, threadId, turnId),
+        replayHiddenPendingUserInput: (ref, threadId, turnId) => replayHiddenPendingUserInput({
+          sessionStore: this.sessionStore,
+          send: this.send.bind(this),
+        }, ref, threadId, turnId),
+        redeliverPendingTurnResult: (ref, turnId) => this.support.redeliverPendingTurnResult(ref, turnId),
+        currentRuntimeThreadStatus: (session) => readCurrentRuntimeThreadStatus({ runtime: this.runtime }, session),
+        waitingStateFor: (session) => waitingStateFor(session),
+        runtimeWaitingStateFor: (runtimeStatus) => runtimeWaitingStateFor(runtimeStatus),
+        runtimeRecoveryKindFor: (text) => runtimeRecoveryKindFor(text),
+        maybeHandleWaitingApprovalShortcut: (inbound, session) => this.support.maybeHandleWaitingApprovalShortcut(inbound, session),
+        isActiveTurnStale: (runtimeStatus) => isActiveTurnStale(runtimeStatus),
+        clearRuntimeRecovery: (ref) => this.runtimeRecovery.clear(ref),
+        steerActiveTurn: (inbound, session, runtimeWaitingState) => steerActiveTurn({
+          sessionStore: this.sessionStore,
+          runtime: this.runtime,
+          send: this.send.bind(this),
+          reactEmoji: this.config.feishu.reactEmoji,
+        }, inbound, session, runtimeWaitingState),
+      }, message);
+      if (preflight.kind === 'handled') {
+        shouldCompleteReceipt = true;
+        return;
+      }
+
+      const session = preflight.session;
+
+      const thread = await prepareInboundThreadStart({
+        config: this.config,
+        runtime: this.runtime,
+        sessionStore: this.sessionStore,
+        send: this.send.bind(this),
+        clearRuntimeRecovery: (ref) => this.runtimeRecovery.clear(ref),
+      }, message);
+      ensureLinkedWorkSessionForThread({
+        assistantName: this.assistantName(),
+        assistantCodexHome: this.assistantCodexHome(),
+        workspaceRoot: this.config.workspaceRoot,
+        workSessionStore: this.workSessionStore,
+      }, message.conversationRef, thread.id);
+
+      shouldCompleteReceipt = await executeInboundTurn({
+        config: this.config,
+        sessionStore: this.sessionStore,
+        runtime: this.runtime,
+        runtimeRecovery: this.runtimeRecovery,
+        support: this.support,
+        send: this.send.bind(this),
+        userRequestedStopTurnIds: this.userRequestedStopTurnIds,
+        suppressedInterruptedTurnIds: this.suppressedInterruptedTurnIds,
+      }, {
+        message,
+        fallbackSession: session,
+        threadId: thread.id,
+      });
+    } finally {
+      if (shouldCompleteReceipt) {
+        this.sessionStore.completeInboundReceipt(message.conversationRef, message.messageId);
+      } else {
+        this.sessionStore.clearInboundReceipt(message.conversationRef, message.messageId);
+      }
+    }
+  }
+}

package/bridge/src/router.ts

@@ -0,0 +1,62 @@
+export type ControlCommand =
+  | { type: 'new' }
+  | { type: 'takeover'; threadHandle: string | null }
+  | { type: 'threads' }
+  | { type: 'codex' }
+  | { type: 'status' }
+  | { type: 'codex_configure' }
+  | { type: 'stop' }
+  | { type: 'approve'; approvalId: string }
+  | { type: 'deny'; approvalId: string }
+  | null;
+
+export function parseControlCommand(input: string): ControlCommand {
+  const trimmed = input.trim();
+  if (trimmed === '/new') return { type: 'new' };
+  const takeover = trimmed.match(/^\/takeover(?:\s+([a-z0-9][a-z0-9-]{2,31}))?$/i);
+  if (takeover) return { type: 'takeover', threadHandle: takeover[1] ? takeover[1].toLowerCase() : null };
+  if (trimmed === '/threads') return { type: 'threads' };
+  if (trimmed === '/codex') return { type: 'codex' };
+  if (trimmed === '/status') return { type: 'status' };
+  if (trimmed === '/codex-configure') return { type: 'codex_configure' };
+  if (trimmed === '/stop') return { type: 'stop' };
+  const approve = trimmed.match(/^\/approve\s+([\w.-]+)$/);
+  if (approve) return { type: 'approve', approvalId: approve[1] };
+  const deny = trimmed.match(/^\/deny\s+([\w.-]+)$/);
+  if (deny) return { type: 'deny', approvalId: deny[1] };
+  return null;
+}
+
+export function parseApprovalShortcut(input: string): 'approve' | 'deny' | null {
+  const trimmed = input.trim();
+  if (trimmed === 'OK' || trimmed === '同意') return 'approve';
+  if (trimmed === 'NO' || trimmed === '拒绝') return 'deny';
+  return null;
+}
+
+const APPROVAL_ID_RE = /审批编号：([\w.-]+)|approval_id:\s*([\w.-]+)/i;
+const APPROVE_WORDS = new Set(['同意', '批准', '允许', 'approve', 'approved', 'yes', 'y', 'ok', '好的', '可以', '✅', '👍', '👌']);
+const DENY_WORDS = new Set(['拒绝', '不同意', '驳回', 'deny', 'decline', 'declined', 'reject', 'rejected', 'no', 'n', '❌', '👎']);
+
+function normalizeDecision(input: string): string {
+  return input.trim().replace(/[。．.!！?？,，、\s]+$/g, '').toLowerCase();
+}
+
+export function parseApprovalReply(input: string, replyToText?: string | null): { type: 'approve' | 'deny'; approvalId: string } | null {
+  const match = String(replyToText || '').match(APPROVAL_ID_RE);
+  const approvalId = match?.[1] || match?.[2] || '';
+  if (!approvalId) {
+    return null;
+  }
+  const normalized = normalizeDecision(input);
+  if (!normalized) {
+    return null;
+  }
+  if (APPROVE_WORDS.has(normalized)) {
+    return { type: 'approve', approvalId };
+  }
+  if (DENY_WORDS.has(normalized)) {
+    return { type: 'deny', approvalId };
+  }
+  return null;
+}

package/bridge/src/runtime-client-agent-messages.ts

@@ -0,0 +1,150 @@
+import { logInfo } from './logger.ts';
+import { isContextCompactionType, normalizeAgentMessagePhase, type AgentMessagePhase, type JsonRpcMessage } from './runtime-client-protocol.ts';
+import type { RuntimeProgressMeta, RuntimeThreadStatus, RuntimeTurnResult } from './types.ts';
+
+export interface AgentMessageState {
+  order: number;
+  phase: AgentMessagePhase;
+  buffer: string;
+  completedText: string | null;
+  progressSentText: string | null;
+}
+
+export interface RuntimeTurnState {
+  threadId: string;
+  agentMessages: Map<string, AgentMessageState>;
+  nextAgentMessageOrder: number;
+  onProgress?: (text: string, meta?: RuntimeProgressMeta) => Promise<void> | void;
+  onThreadStatus?: (status: RuntimeThreadStatus, meta?: { threadId?: string | null; turnId?: string | null }) => Promise<void> | void;
+  completedEventResult: RuntimeTurnResult | null;
+  emittedContextCompactionKeys: Set<string>;
+  resolve: (value: RuntimeTurnResult) => void;
+  reject: (error: unknown) => void;
+}
+
+function ensureAgentMessageState(
+  turnStates: Map<string, RuntimeTurnState>,
+  turnId: string,
+  itemId: string,
+): AgentMessageState | null {
+  const turn = turnStates.get(turnId);
+  if (!turn || !itemId) {
+    return null;
+  }
+  let item = turn.agentMessages.get(itemId);
+  if (!item) {
+    item = {
+      order: turn.nextAgentMessageOrder++,
+      phase: 'unknown',
+      buffer: '',
+      completedText: null,
+      progressSentText: null,
+    };
+    turn.agentMessages.set(itemId, item);
+  }
+  return item;
+}
+
+export function noteAgentMessageItem(
+  turnStates: Map<string, RuntimeTurnState>,
+  turnId: string,
+  item: any,
+): void {
+  if (!item || item.type !== 'agentMessage' || typeof item.id !== 'string') {
+    return;
+  }
+  const state = ensureAgentMessageState(turnStates, turnId, item.id);
+  if (!state) {
+    return;
+  }
+  const phase = normalizeAgentMessagePhase(item.phase);
+  if (phase !== 'unknown' || state.phase === 'unknown') {
+    state.phase = phase;
+  }
+  if (typeof item.text === 'string') {
+    state.completedText = item.text;
+  }
+}
+
+export function consumeCompletedAgentMessageProgress(
+  turnStates: Map<string, RuntimeTurnState>,
+  turnId: string,
+  itemId: string,
+): { text: string; phase: AgentMessagePhase } | null {
+  const item = ensureAgentMessageState(turnStates, turnId, itemId);
+  if (!item) {
+    return null;
+  }
+  const text = String(item.completedText ?? item.buffer ?? '').trim();
+  if (!text) {
+    return null;
+  }
+  if (item.progressSentText === text) {
+    return null;
+  }
+  item.progressSentText = text;
+  return { text, phase: item.phase };
+}
+
+export function buildReplyFromThreadItems(items: Array<any>): string {
+  return items
+    .filter((item) => item?.type === 'agentMessage')
+    .map((item, index) => ({
+      order: index,
+      phase: normalizeAgentMessagePhase(item.phase),
+      text: typeof item.text === 'string' ? item.text : '',
+    }))
+    .sort((left, right) => left.order - right.order)
+    .filter((item) => item.phase !== 'commentary')
+    .map((item) => item.text)
+    .filter((item) => Boolean(item))
+    .join('');
+}
+
+export function observeContextCompactionEvent(
+  turnStates: Map<string, RuntimeTurnState>,
+  msg: JsonRpcMessage,
+  emitContextCompactionProgress: (turnId: string, itemId: string) => void,
+): boolean {
+  if (!msg.method) {
+    return false;
+  }
+  const params = msg.params || {};
+  const threadId = typeof params.threadId === 'string' ? params.threadId : null;
+  const turnId = typeof params.turnId === 'string' ? params.turnId : null;
+  if (!turnId || !turnStates.has(turnId)) {
+    return false;
+  }
+
+  if (msg.method === 'thread/compacted') {
+    const fallbackItemId = typeof params.itemId === 'string' ? params.itemId : 'thread_compacted';
+    logInfo('runtime', 'thread_compacted_event', {
+      threadId,
+      turnId,
+      itemId: fallbackItemId,
+    });
+    emitContextCompactionProgress(turnId, fallbackItemId);
+    return true;
+  }
+
+  if (msg.method !== 'item/started' && msg.method !== 'item/updated' && msg.method !== 'item/completed') {
+    return false;
+  }
+
+  const item = params.item;
+  const itemId = typeof params.itemId === 'string'
+    ? params.itemId
+    : (item && typeof item.id === 'string' ? item.id : null);
+  if (!itemId || !isContextCompactionType(item?.type)) {
+    return false;
+  }
+
+  logInfo('runtime', 'context_compaction_event', {
+    method: msg.method,
+    threadId,
+    turnId,
+    itemId,
+  });
+  emitContextCompactionProgress(turnId, itemId);
+  return true;
+}