[Bug] Bitbucket async merge task is discarded before its result can be read #35906

import { mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";
import { pathToFileURL } from "node:url";
import { registerHooks } from "node:module";
import { execFileSync } from "node:child_process";

const scratch = mkdtempSync(path.join(tmpdir(), "bitbucket-repro-"));
let status = 2;
let hooks;
try {
  if (!process.argv[2]) throw new Error("Pass the T3 Code checkout as the argument.");
  const root = realpathSync(process.argv[2]);
  for (const name of ["home", "tmp", "config", "data", "state"]) mkdirSync(path.join(scratch, name));
  const env = { ...process.env, HOME: path.join(scratch, "home"), TMPDIR: path.join(scratch, "tmp"), XDG_CONFIG_HOME: path.join(scratch, "config"), XDG_DATA_HOME: path.join(scratch, "data"), XDG_STATE_HOME: path.join(scratch, "state"), T3CODE_HOME: path.join(scratch, "state"), GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null" };
  Object.assign(process.env, env);
  console.log(`Node ${process.version}; ${process.platform} ${process.arch}`);
  console.log(execFileSync("git", ["--version"], { env, encoding: "utf8" }).trim());
  console.log(`commit ${execFileSync("git", ["-C", root, "rev-parse", "HEAD"], { env, encoding: "utf8" }).trim()}`);
  console.log(`npm ${execFileSync("npm", ["--version"], { env, encoding: "utf8" }).trim()}`);
  execFileSync("npm", ["install", "--prefix", scratch, "--ignore-scripts", "--no-save", "--package-lock=false", "--no-audit", "--no-fund", "effect@4.1.3"], { env, stdio: "pipe" });
  const effectRoot = realpathSync(path.join(scratch, "node_modules/effect"));
  const effectPackage = JSON.parse(readFileSync(path.join(effectRoot, "package.json"), "utf8"));
  console.log(`Effect ${effectPackage.version}`);
  hooks = registerHooks({ resolve(specifier, context, next) {
    if (specifier === "effect" || specifier.startsWith("effect/")) {
      const subpath = specifier === "effect" ? "." : `./${specifier.slice(7)}`;
      const target = effectPackage.exports[subpath] ?? effectPackage.exports["./*"].replace("*", specifier.slice(7));
      return { url: pathToFileURL(path.join(effectRoot, target)).href, shortCircuit: true };
    }
    if (specifier.startsWith("@t3tools/")) {
      const [, name, ...rest] = specifier.split("/");
      const directory = path.join(root, "packages", name);
      const manifest = JSON.parse(readFileSync(path.join(directory, "package.json"), "utf8"));
      const target = manifest.exports[rest.length ? `./${rest.join("/")}` : "."];
      return { url: pathToFileURL(path.join(directory, typeof target === "string" ? target : target.import)).href, shortCircuit: true };
    }
    return next(specifier, context);
  } });
  const Effect = await import("effect/Effect");
  const Layer = await import("effect/Layer");
  const Result = await import("effect/Result");
  const ConfigProvider = await import("effect/ConfigProvider");
  const FileSystem = await import("effect/FileSystem");
  const { HttpClient, HttpClientResponse } = await import("effect/http");
  const { DEFAULT_SERVER_SETTINGS } = await import("@t3tools/contracts");
  const Host = await import("@t3tools/source-control-core/server/SourceControlHost");
  const Limits = await import("@t3tools/source-control-core/server/SourceControlRateLimit");
  const B = await import(pathToFileURL(path.join(root, "packages/source-control-bitbucket/src/server/BitbucketApi.ts")).href);
  const P = await import(pathToFileURL(path.join(root, "packages/source-control-bitbucket/src/server/BitbucketPullRequestApi.ts")).href);
  const base = "https://api.bitbucket.org/2.0/repositories/fixture/work/pullrequests/7";
  const task = `${base}/merge/task-status/fixture-task`;
  const merged = { id: 7, title: "Fixture PR", state: "MERGED", created_on: "2000-01-01T00:00:00Z", updated_on: "2000-01-01T00:00:00Z", source: { branch: { name: "feature" } }, destination: { branch: { name: "main" } }, links: { html: { href: "https://bitbucket.org/fixture/work/pull-requests/7" } } };
  async function run(asynchronous) {
    const calls = [];
    const client = HttpClient.make((request) => {
      calls.push(`${request.method} ${request.url}`);
      let response;
      if (request.method === "POST" && request.url === `${base}/merge`) {
        response = asynchronous ? new Response("", { status: 202, headers: { Location: task } }) : Response.json(merged);
      } else if (request.method === "GET" && request.url === task) {
        response = Response.json({ type: "error", error: { message: "Fixture merge rejected" } }, { status: 400 });
      } else throw new Error("Unexpected HTTP request in fixture.");
      return Effect.succeed(HttpClientResponse.fromWeb(request, response));
    });
    const layer = B.layer.pipe(
      Layer.provide(Limits.layer),
      Layer.provide(Layer.succeed(HttpClient.HttpClient, client)),
      Layer.provide(Layer.mock(FileSystem.FileSystem)({})),
      Layer.provide(Layer.mock(Host.SourceControlHost)({ settings: { get: Effect.succeed(DEFAULT_SERVER_SETTINGS), getWithSecrets: () => Effect.succeed(DEFAULT_SERVER_SETTINGS), update: () => Effect.die("Unexpected settings write") } })),
      Layer.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env: {} }))),
    );
    const outcome = await Effect.runPromise(Effect.gen(function* () {
      const api = yield* P.make;
      return yield* api.runAction({ repository: "fixture/work", number: 7, action: "merge" });
    }).pipe(Effect.provide(layer), Effect.result));
    return { outcome, calls };
  }
  const control = await run(false);
  if (!Result.isSuccess(control.outcome) || control.outcome.success?.state !== "merged") throw new Error("Synchronous merge control failed.");
  console.log("control: HTTP 200 returned state=merged");
  const observed = await run(true);
  console.log(`async: result=${observed.outcome._tag}; value=${Result.isSuccess(observed.outcome) ? String(observed.outcome.success) : observed.outcome.failure._tag}`);
  console.log(`async: task-status requests=${observed.calls.filter((call) => call === `GET ${task}`).length}`);
  console.log(`async: HTTP calls=${observed.calls.join(", ")}`);
  status = Result.isSuccess(observed.outcome) ? 1 : observed.calls.includes(`GET ${task}`) ? 0 : 2;
} catch (error) {
  console.log(`setup: ${error instanceof Error ? error.message.split("\n")[0] : "failed"}`);
} finally {
  hooks?.deregister();
  rmSync(scratch, { recursive: true, force: true });
}
console.log(status === 0 ? "RESULT: expected behavior" : status === 1 ? "RESULT: defect reproduced" : "RESULT: inconclusive");
process.exitCode = status;