work-ally 0.2.0-alpha.1

package/bridge/src/receiver-control.ts

@@ -0,0 +1,83 @@
+import type { WorkAllyConfig } from './config.ts';
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { HandoffService } from './handoff-service.ts';
+import type { ControlCommand } from './router.ts';
+import type { SessionStore } from './session-store.ts';
+import { handleCoreControlCommand } from './receiver-control-core.ts';
+import { handleWorkSessionControlCommand } from './receiver-control-work-session.ts';
+import { activeWorkSessionFor, resolveDeliveryConversationKey, syncLinkedWorkSessionThread } from './receiver-work-session.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+import type { InboundMessage, RuntimeThreadStatus, SessionMeta } from './types.ts';
+
+interface ControlRuntimeLike {
+  startThread(cwd: string): Promise<{ id: string }>;
+  resumeThread(threadId: string, cwd: string): Promise<{ id: string }>;
+  readThreadStatus(threadId: string): Promise<RuntimeThreadStatus | null>;
+  resolveApproval(requestId: string | number, decision: 'accept' | 'acceptForSession' | 'decline' | 'cancel'): Promise<void>;
+  interruptTurn(threadId: string, turnId: string): Promise<void>;
+}
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface HandleControlDeps {
+  config: WorkAllyConfig;
+  runtime: ControlRuntimeLike;
+  sessionStore: SessionStore;
+  workSessionStore: WorkSessionStore;
+  handoffService: HandoffService;
+  send: SendLike;
+  assistantName: string;
+  assistantCodexHome: string | null;
+  commandApprovalRulesStatusLines: string[];
+  noteUserRequestedStop(turnId: string): void;
+}
+
+interface HandleControlArgs {
+  message: InboundMessage;
+  command: NonNullable<ControlCommand>;
+  session: SessionMeta;
+}
+
+export async function handleControlCommand(
+  deps: HandleControlDeps,
+  args: HandleControlArgs,
+): Promise<boolean> {
+  const workSessionDeps = {
+    assistantName: deps.assistantName,
+    workSessionStore: deps.workSessionStore,
+  };
+  const workSessionArgs = {
+    ...args,
+    linkedWorkSession: activeWorkSessionFor(workSessionDeps, args.message.conversationRef),
+  };
+
+  if (await handleWorkSessionControlCommand({
+    config: deps.config,
+    runtime: deps.runtime,
+    sessionStore: deps.sessionStore,
+    workSessionStore: deps.workSessionStore,
+    handoffService: deps.handoffService,
+    send: deps.send,
+    assistantName: deps.assistantName,
+    assistantCodexHome: deps.assistantCodexHome,
+    resolveDeliveryConversationKey,
+    syncLinkedWorkSessionThread: (ref, runtimeThreadId) => syncLinkedWorkSessionThread(workSessionDeps, ref, runtimeThreadId),
+  }, workSessionArgs)) {
+    return true;
+  }
+
+  return handleCoreControlCommand({
+    config: deps.config,
+    runtime: deps.runtime,
+    sessionStore: deps.sessionStore,
+    send: deps.send,
+    commandApprovalRulesStatusLines: deps.commandApprovalRulesStatusLines,
+    noteUserRequestedStop: deps.noteUserRequestedStop,
+  }, args);
+}

package/bridge/src/receiver-delivery.ts

@@ -0,0 +1,136 @@
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { SessionStore } from './session-store.ts';
+import { finalReplySourceKey, payloadDigest } from './receiver-helpers.ts';
+import { completionWithoutReplyStatusMessage, redeliveredPreviousTurnPrefixMessage, runtimeFinalStateRecoveryRequiredMessage, runtimeInfrastructureErrorMessage, systemNoticeMessage } from './translator.ts';
+import type { ConversationRef } from './types.ts';
+
+interface DeliveryDeps {
+  sessionStore: SessionStore;
+}
+
+interface RedeliveryDeps extends DeliveryDeps {
+  send(
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface TurnResultRedeliveryDeps extends RedeliveryDeps {
+  isRuntimeInfrastructureError(text: string): boolean;
+  normalizeErrorReplyText(text: string): string;
+}
+
+export function recordPendingFinalReplyDelivery(
+  deps: DeliveryDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string,
+  text: string,
+): string {
+  const sourceKey = finalReplySourceKey(threadId, turnId);
+  deps.sessionStore.recordOutboundDelivery(conversationRef, {
+    sourceKey,
+    threadId,
+    turnId,
+    conversationRef,
+    envelopeType: 'final_reply',
+    payloadText: text,
+    payloadDigest: payloadDigest(text),
+    createdAt: new Date().toISOString(),
+    status: 'pending',
+    deliveredAt: null,
+  });
+  return sourceKey;
+}
+
+export function markFinalReplyDelivered(
+  deps: DeliveryDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string,
+): void {
+  deps.sessionStore.markOutboundDelivered(conversationRef, finalReplySourceKey(threadId, turnId));
+}
+
+export async function redeliverPendingFinalReplies(
+  deps: RedeliveryDeps,
+  conversationRef: ConversationRef,
+): Promise<number> {
+  const pending = deps.sessionStore.listPendingOutboundDeliveries(conversationRef)
+    .filter((record) => record.envelopeType === 'final_reply');
+  let delivered = 0;
+  for (const record of pending) {
+    const ok = await deps.send({
+      type: 'final_reply',
+      conversationRef,
+      text: record.payloadText,
+    }, {
+      source: 'startup_redeliver_final_reply',
+      thread_id: record.threadId,
+      turn_id: record.turnId,
+      source_key: record.sourceKey,
+    }, { trackTurnId: record.turnId });
+    if (!ok) {
+      continue;
+    }
+    deps.sessionStore.markOutboundDelivered(conversationRef, record.sourceKey);
+    delivered += 1;
+  }
+  return delivered;
+}
+
+export async function redeliverPendingTurnResult(
+  deps: TurnResultRedeliveryDeps,
+  conversationRef: ConversationRef,
+  ledgerTurnId: string,
+): Promise<boolean> {
+  const ledger = deps.sessionStore.getTurnLedger(conversationRef, ledgerTurnId);
+  if (!ledger || ledger.deliveryStatus !== 'delivery_unavailable') {
+    return false;
+  }
+  const turn = deps.sessionStore.getTurnRecord(conversationRef, ledgerTurnId);
+  if (!turn) {
+    return false;
+  }
+
+  const replyText = String(turn.reply || '').trim();
+  const userRequestedStop = turn.error === 'user requested stop';
+  const interruptedWithoutReply = !replyText && (
+    turn.status === 'interrupted'
+    || turn.error === 'turn interrupted'
+    || userRequestedStop
+  );
+  const isCompleted = turn.status === 'completed';
+  const text = isCompleted
+    ? (replyText ? `${redeliveredPreviousTurnPrefixMessage()}\n\n${turn.reply}` : completionWithoutReplyStatusMessage())
+    : interruptedWithoutReply
+      ? (userRequestedStop
+        ? '当前任务已停止。'
+        : deps.isRuntimeInfrastructureError(turn.error || '')
+          ? systemNoticeMessage(runtimeInfrastructureErrorMessage())
+          : systemNoticeMessage(runtimeFinalStateRecoveryRequiredMessage()))
+      : deps.normalizeErrorReplyText(turn.error || '处理失败。');
+  const type = isCompleted
+    ? (replyText ? 'final_reply' : 'status_reply')
+    : interruptedWithoutReply
+      ? (userRequestedStop ? 'status_reply' : 'error_reply')
+      : 'error_reply';
+
+  const delivered = await deps.send({
+    type,
+    conversationRef,
+    text,
+  }, {
+    source: 'redeliver_previous_turn_result',
+    thread_id: turn.threadId,
+    turn_id: turn.turnId,
+    original_delivery_status: ledger.deliveryStatus,
+    original_turn_status: turn.status,
+  }, { trackTurnId: turn.turnId });
+
+  if (!delivered) {
+    return false;
+  }
+  return true;
+}

package/bridge/src/receiver-helpers.ts

@@ -0,0 +1,96 @@
+import crypto from 'node:crypto';
+import type { PendingUserInputRecord } from './types.ts';
+
+export const LOCAL_APPROVAL_COMMAND_RE = /^(git\s+(?:status|diff)(?:\s+.*)?|git\s+add(?:\s+.*)?|git\s+commit\b(?:\s+.*)?|npm\s+(?:test|run\s+test(?::[\w-]+)?)(?:\s+--.*)?|node\s+--test\b(?:\s+.*)?|bash\s+tests\/shell\/[\w.-]+\.sh\b(?:\s+.*)?|bash\s+-n\s+ally\.sh\b|ally\s+(?:status|logs\b.*)|cmake\s+(?:-S\b.*\s-B\b.*|--build\b.*)|ctest\b(?:\s+.*)?|pytest\b(?:\s+.*)?|cargo\s+(?:test|check)\b(?:\s+.*)?|flutter\s+analyze\b(?:\s+.*)?|dart\s+test\b(?:\s+.*)?)$/i;
+export const HIGH_RISK_APPROVAL_COMMAND_RE = /(git\s+push\b|ally\s+release\b|rm\s+-rf\b|git\s+reset\b|git\s+checkout\s+--\b|deploy\b|publish\b|kubectl\b|terraform\b|scp\b|shutdown\b|reboot\b)/i;
+export const TURN_RECOVERY_VISIBILITY_DELAY_MS = 1500;
+export const APPROVAL_BATCH_WINDOW_MS = 10;
+
+export function compactPreview(text: string, limit = 160): string {
+  const compact = text.replace(/\s+/g, ' ').trim();
+  if (compact.length <= limit) {
+    return compact;
+  }
+  return `${compact.slice(0, limit)}…`;
+}
+
+export function finalReplySourceKey(threadId: string, turnId: string): string {
+  return `final_reply:${threadId}:${turnId}`;
+}
+
+export function payloadDigest(text: string): string {
+  return crypto.createHash('sha1').update(text).digest('hex');
+}
+
+export function errorMessageFromUnknown(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message || '处理失败。';
+  }
+  if (typeof error === 'string') {
+    return error.trim() || '处理失败。';
+  }
+  if (error && typeof error === 'object') {
+    const message = typeof (error as { message?: unknown }).message === 'string'
+      ? String((error as { message?: string }).message).trim()
+      : '';
+    if (message) {
+      return message;
+    }
+  }
+  return '处理失败。';
+}
+
+export function errorDetailsFromUnknown(error: unknown): string {
+  if (error instanceof Error) {
+    return error.stack || error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error && typeof error === 'object') {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  return String(error);
+}
+
+export function parseUserInputReply(request: PendingUserInputRecord, text: string): Record<string, { answers: string[] }> {
+  const trimmed = text.trim();
+  const questions = request.questions || [];
+  if (questions.length === 0) {
+    return {};
+  }
+
+  if (questions.length === 1) {
+    return {
+      [questions[0].id]: {
+        answers: trimmed ? [trimmed] : [],
+      },
+    };
+  }
+
+  const answers: Record<string, { answers: string[] }> = {};
+  const lines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (const line of lines) {
+    const match = line.match(/^([A-Za-z0-9_.-]+)\s*[:：]\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const [, questionId, answer] = match;
+    if (!questions.some((question) => question.id === questionId)) {
+      continue;
+    }
+    answers[questionId] = { answers: [answer.trim()] };
+  }
+
+  if (Object.keys(answers).length === 0) {
+    for (const question of questions) {
+      answers[question.id] = { answers: trimmed ? [trimmed] : [] };
+    }
+  }
+
+  return answers;
+}

package/bridge/src/receiver-human-gate.ts

@@ -0,0 +1,333 @@
+import type { OutboundEnvelope } from './channel-types.ts';
+import { compactPreview, parseUserInputReply } from './receiver-helpers.ts';
+import { parseApprovalShortcut } from './router.ts';
+import { buildElicitationResponseFromReply } from './runtime-user-input.ts';
+import type { SessionStore } from './session-store.ts';
+import { approvalMessage, batchedApprovalMessage, systemNoticeMessage, userInputMessage, waitingApprovalFollowUpMessage, waitingApprovalStatusMessage, waitingUserInputStatusMessage } from './translator.ts';
+import type { ApprovalRecord, ConversationRef, InboundMessage, RuntimeThreadStatus, SessionMeta } from './types.ts';
+
+export type WaitingState = 'approval' | 'user_input' | null;
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface RuntimeLike {
+  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>;
+}
+
+interface FlushApprovalNoticeDeps {
+  sessionStore: SessionStore;
+  send: SendLike;
+  approvalBoundaryReason(approval: Pick<ApprovalRecord, 'kind' | 'grantRoot' | 'cwd' | 'command'>): string;
+}
+
+interface ResolveVisibleApprovalsDeps {
+  sessionStore: SessionStore;
+  runtime: Pick<RuntimeLike, 'resolveApproval'>;
+  send: SendLike;
+}
+
+interface WaitingApprovalShortcutDeps extends ResolveVisibleApprovalsDeps {
+  reactEmoji?: string | null;
+}
+
+interface ResumePendingUserInputDeps {
+  sessionStore: SessionStore;
+  runtime: Pick<RuntimeLike, 'resolveUserInput' | 'resolveElicitation'>;
+  send: SendLike;
+  reactEmoji?: string | null;
+}
+
+interface ReplayHiddenApprovalDeps extends FlushApprovalNoticeDeps {}
+
+interface ReplayHiddenUserInputDeps {
+  sessionStore: SessionStore;
+  send: SendLike;
+}
+
+export function waitingStateFor(session: SessionMeta): WaitingState {
+  if (session.pendingApprovalIds.length > 0) {
+    return 'approval';
+  }
+  if (session.pendingUserInputRequestId) {
+    return 'user_input';
+  }
+  return null;
+}
+
+export function runtimeWaitingStateFor(status: RuntimeThreadStatus | null | undefined): WaitingState {
+  if (status?.activeFlags.includes('waitingOnApproval')) {
+    return 'approval';
+  }
+  if (status?.activeFlags.includes('waitingOnUserInput')) {
+    return 'user_input';
+  }
+  return null;
+}
+
+function approvalPayloadsFor(
+  approvals: ApprovalRecord[],
+  approvalBoundaryReason: FlushApprovalNoticeDeps['approvalBoundaryReason'],
+) {
+  return approvals.map((approval) => ({
+    ...approval,
+    boundaryReason: approvalBoundaryReason(approval),
+  }));
+}
+
+export async function flushApprovalNotice(
+  deps: FlushApprovalNoticeDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string,
+  noticeState: { sent: boolean },
+): Promise<void> {
+  const session = deps.sessionStore.getSession(conversationRef);
+  if (!session || !session.activeTurnId || session.activeTurnId !== turnId) {
+    return;
+  }
+  const pendingApprovals = deps.sessionStore.listPendingApprovals(conversationRef)
+    .filter((approval) => approval.turnId === turnId);
+  if (!pendingApprovals.length) {
+    return;
+  }
+
+  const approvalPayloads = approvalPayloadsFor(pendingApprovals, deps.approvalBoundaryReason);
+  const delivered = await deps.send({
+    type: 'approval_requested',
+    conversationRef,
+    approval: approvalPayloads[0],
+    text: approvalPayloads.length > 1
+      ? batchedApprovalMessage(approvalPayloads)
+      : approvalMessage(approvalPayloads[0]),
+  }, {
+    source: 'approval_requested',
+    thread_id: threadId,
+    turn_id: turnId,
+    approval_id: approvalPayloads[0].approvalId,
+    approval_count: approvalPayloads.length,
+  });
+  if (!delivered) {
+    return;
+  }
+
+  for (const approval of pendingApprovals) {
+    deps.sessionStore.markApprovalVisible(conversationRef, approval.approvalId);
+  }
+  if (noticeState.sent) {
+    return;
+  }
+  noticeState.sent = true;
+  await deps.send({
+    type: 'status_reply',
+    conversationRef,
+    text: waitingApprovalStatusMessage(),
+  }, {
+    source: 'waiting_approval',
+    thread_id: threadId,
+    turn_id: turnId,
+    approval_id: approvalPayloads[0].approvalId,
+    approval_count: approvalPayloads.length,
+  });
+}
+
+export async function replayHiddenApprovalNotice(
+  deps: ReplayHiddenApprovalDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string,
+): Promise<boolean> {
+  const hiddenApprovals = deps.sessionStore.listHiddenPendingApprovals(conversationRef, turnId);
+  if (!hiddenApprovals.length) {
+    return false;
+  }
+
+  const approvalPayloads = approvalPayloadsFor(hiddenApprovals, deps.approvalBoundaryReason);
+  const delivered = await deps.send({
+    type: 'approval_requested',
+    conversationRef,
+    approval: approvalPayloads[0],
+    text: approvalPayloads.length > 1
+      ? batchedApprovalMessage(approvalPayloads)
+      : approvalMessage(approvalPayloads[0]),
+  }, {
+    source: 'approval_requested_replay',
+    thread_id: threadId,
+    turn_id: turnId,
+    approval_id: approvalPayloads[0].approvalId,
+    approval_count: approvalPayloads.length,
+  });
+  if (!delivered) {
+    return true;
+  }
+
+  for (const approval of hiddenApprovals) {
+    deps.sessionStore.markApprovalVisible(conversationRef, approval.approvalId);
+  }
+  await deps.send({
+    type: 'status_reply',
+    conversationRef,
+    text: waitingApprovalStatusMessage(),
+  }, {
+    source: 'waiting_approval_replay',
+    thread_id: threadId,
+    turn_id: turnId,
+    approval_id: approvalPayloads[0].approvalId,
+    approval_count: approvalPayloads.length,
+  });
+  return true;
+}
+
+export async function replayHiddenPendingUserInput(
+  deps: ReplayHiddenUserInputDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string,
+): Promise<boolean> {
+  const hiddenPending = deps.sessionStore.findHiddenPendingUserInput(conversationRef, turnId);
+  if (!hiddenPending) {
+    return false;
+  }
+
+  const delivered = await deps.send({
+    type: 'user_input_requested',
+    conversationRef,
+    request: hiddenPending,
+    text: userInputMessage(hiddenPending),
+  }, {
+    source: 'user_input_requested_replay',
+    thread_id: threadId,
+    turn_id: turnId,
+    request_id: hiddenPending.requestId,
+  });
+  if (!delivered) {
+    return true;
+  }
+
+  const visiblePending = deps.sessionStore.markPendingUserInputVisible(conversationRef, hiddenPending.requestId) || hiddenPending;
+  await deps.send({
+    type: 'status_reply',
+    conversationRef,
+    text: waitingUserInputStatusMessage(visiblePending),
+  }, {
+    source: 'waiting_user_input_replay',
+    thread_id: threadId,
+    turn_id: turnId,
+    request_id: hiddenPending.requestId,
+  });
+  return true;
+}
+
+export async function resolveVisibleApprovals(
+  deps: ResolveVisibleApprovalsDeps,
+  conversationRef: ConversationRef,
+  approvalIds: string[],
+  decision: 'approve' | 'deny',
+): Promise<{ resolved: number }> {
+  const runtimeDecision = decision === 'approve' ? 'accept' : 'decline';
+  const resolvedStatus = decision === 'approve' ? 'accepted' : 'declined';
+  let resolved = 0;
+
+  for (const approvalId of approvalIds) {
+    const match = deps.sessionStore.findApproval(approvalId);
+    if (!match || match.approval.status !== 'pending') {
+      continue;
+    }
+    await deps.runtime.resolveApproval(match.approval.requestId, runtimeDecision);
+    deps.sessionStore.resolveApproval(match.meta.conversationRef, approvalId, resolvedStatus);
+    resolved += 1;
+  }
+
+  if (resolved > 0) {
+    await deps.send({
+      type: 'status_reply',
+      conversationRef,
+      text: decision === 'approve' ? `已提交同意，共处理 ${resolved} 项审批。` : `已提交拒绝，共处理 ${resolved} 项审批。`,
+    });
+  }
+
+  return { resolved };
+}
+
+export async function maybeHandleWaitingApprovalShortcut(
+  deps: WaitingApprovalShortcutDeps,
+  message: InboundMessage,
+  session: SessionMeta,
+): Promise<boolean> {
+  if (!session.pendingApprovalIds.length) {
+    return false;
+  }
+
+  const decision = parseApprovalShortcut(message.text);
+  if (!decision) {
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: systemNoticeMessage(waitingApprovalFollowUpMessage()),
+    }, {
+      source: 'waiting_user_follow_up',
+      thread_id: session.threadId,
+      turn_id: session.activeTurnId,
+      waiting_state: 'approval',
+      message_id: message.messageId,
+    });
+    return true;
+  }
+
+  await deps.send({
+    type: 'ack_received',
+    conversationRef: message.conversationRef,
+    messageId: message.messageId,
+    emoji: deps.reactEmoji || undefined,
+  });
+  await resolveVisibleApprovals(deps, message.conversationRef, [...session.pendingApprovalIds], decision);
+  deps.sessionStore.completeInboundReceipt(message.conversationRef, message.messageId);
+  return true;
+}
+
+export async function maybeResumePendingUserInput(
+  deps: ResumePendingUserInputDeps,
+  message: InboundMessage,
+): Promise<boolean> {
+  const pending = deps.sessionStore.getPendingUserInput(message.conversationRef);
+  if (!pending) {
+    return false;
+  }
+
+  const answers = parseUserInputReply(pending, message.text);
+  await deps.send({
+    type: 'ack_received',
+    conversationRef: message.conversationRef,
+    messageId: message.messageId,
+    emoji: deps.reactEmoji || undefined,
+  });
+
+  let submittedPayload: unknown;
+  if (pending.kind === 'mcp_elicitation') {
+    const elicitationResponse = buildElicitationResponseFromReply(pending, message.text) || {
+      action: 'accept' as const,
+      content: null,
+    };
+    await deps.runtime.resolveElicitation(pending.requestId, elicitationResponse);
+    submittedPayload = elicitationResponse;
+  } else {
+    await deps.runtime.resolveUserInput(pending.requestId, { answers });
+    submittedPayload = { answers };
+  }
+
+  deps.sessionStore.clearPendingUserInput(message.conversationRef, {
+    answerPreview: compactPreview(message.text),
+  });
+  deps.sessionStore.completeInboundReceipt(message.conversationRef, message.messageId);
+  return true;
+}