Method waitForWorkspaceTurn

src/node/services/taskService.ts:4884–5008

(
    handleId: string,
    options: {
      timeoutMs?: number;
      abortSignal?: AbortSignal;
      requestingWorkspaceId: string;
      backgroundOnMessageQueued?: boolean;
    }
  )

  }

  async waitForWorkspaceTurn(
    handleId: string,
    options: {
      timeoutMs?: number;
      abortSignal?: AbortSignal;
      requestingWorkspaceId: string;
      backgroundOnMessageQueued?: boolean;
    }
  ): Promise<WorkspaceTurnWaitResult> {
    assert(handleId.length > 0, "waitForWorkspaceTurn: handleId must be non-empty");
    assert(
      options.requestingWorkspaceId.length > 0,
      "waitForWorkspaceTurn: requestingWorkspaceId must be non-empty"
    );
    const timeoutMs = options.timeoutMs ?? 120_000;
    assert(Number.isFinite(timeoutMs) && timeoutMs > 0, "waitForWorkspaceTurn: timeoutMs invalid");

    this.markTaskForegroundRelevant(handleId);

    return await new Promise<WorkspaceTurnWaitResult>((resolve, reject) => {
      let settled = false;
      let timer: ReturnType<typeof setTimeout> | null = null;
      let abortListener: (() => void) | null = null;
      let stopBlockingRequester: (() => void) | null = this.startForegroundAwait(
        options.requestingWorkspaceId
      );
      const shouldBackgroundOnQueuedMessage = options.backgroundOnMessageQueued ?? true;

      const cleanup = () => {
        if (settled) return;
        settled = true;
        if (timer) {
          clearTimeout(timer);
          timer = null;
        }
        if (abortListener) {
          options.abortSignal?.removeEventListener("abort", abortListener);
          abortListener = null;
        }
        if (waiterEntry.backgroundOnMessageQueued && waiterEntry.requestingWorkspaceId) {
          this.unregisterBackgroundableForegroundWaiter(
            waiterEntry.requestingWorkspaceId,
            waiterEntry
          );
        }
        const waiters = this.pendingWorkspaceTurnWaitersByHandleId.get(handleId) ?? [];
        const nextWaiters = waiters.filter((waiter) => waiter !== waiterEntry);
        if (nextWaiters.length === 0) {
          this.pendingWorkspaceTurnWaitersByHandleId.delete(handleId);
        } else {
          this.pendingWorkspaceTurnWaitersByHandleId.set(handleId, nextWaiters);
        }
        if (stopBlockingRequester) {
          try {
            stopBlockingRequester();
          } finally {
            stopBlockingRequester = null;
          }