@goodtek/vibeops 2.4.3 → 2.5.0

package/dist/commands/task-sync.js

@@ -61,7 +61,7 @@ export async function taskSyncCommand(taskRef, options = {}) {
         log.info(`  · git fetch ${remote} --prune`);
         log.info(`  · git switch ${integrationBranch}`);
         log.info(`  · git pull --ff-only ${remote} ${integrationBranch}`);
-        log.info(`  · git branch ${options.force === true ? "-D" : "-d"} ${taskBranch}`);
+        log.info(`  · git branch -D ${taskBranch}`);
         if (options.noRemoteDelete !== true) {
             log.info(`  · git push ${remote} --delete ${taskBranch} (if exists)`);
         }
@@ -133,13 +133,15 @@ export async function taskSyncCommand(taskRef, options = {}) {
     log.ok(`Ready to sync — ${integrationBranch} contains the task commits.`);
     if (await gitBranchExists(cwd, taskBranch)) {
         try {
-            await gitDeleteBranch(cwd, taskBranch, { force: options.force === true });
+            // Guard verified integration contains the work — squash merges leave task/* SHAs
+            // off develop ancestry, so -D is required even without --force.
+            await gitDeleteBranch(cwd, taskBranch, { force: true });
             log.ok(`Deleted local branch ${taskBranch}`);
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             log.error(`Could not delete local ${taskBranch}: ${msg}`);
-            log.info(dim("Merge the MR into the integration branch first, or rerun with --force (discards unmerged branch)."));
+            log.info(dim("Merge the MR into the integration branch first, or rerun with --force (skip merge verification)."));
             process.exitCode = 1;
             return;
         }

package/dist/lib/git-host-cli.js

@@ -0,0 +1,115 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Run a CLI with inherited stdio (e.g. `gh auth login`). */
+export function runInteractiveCli(bin, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, [...args], { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+export function hostCliTool(host) {
+    return host === "gitlab" ? "glab" : "gh";
+}
+export async function commandExists(bin) {
+    try {
+        await execFileAsync(bin, ["--version"], { maxBuffer: 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGhAuth() {
+    try {
+        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGlabAuth() {
+    try {
+        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeHostCliAuth(host) {
+    const tool = hostCliTool(host);
+    if (!(await commandExists(tool)))
+        return "missing";
+    const ok = host === "gitlab" ? await probeGlabAuth() : await probeGhAuth();
+    return ok ? "ok" : "unauthenticated";
+}
+/** Install / login lines shared by init and ship/merge. */
+export function formatHostCliHint(host) {
+    if (host === "gitlab") {
+        return [
+            `Install glab: https://gitlab.com/gitlab-org/cli#installation`,
+            `  brew install glab`,
+            `Then: glab auth login`,
+        ];
+    }
+    return [
+        `Install gh: https://cli.github.com/`,
+        `  brew install gh`,
+        `Then: gh auth login`,
+    ];
+}
+export function formatHostCliMissingMessage(host, purpose) {
+    const tool = hostCliTool(host);
+    return `${tool} CLI is required to ${purpose}.`;
+}
+export async function probeBrew() {
+    return commandExists("brew");
+}
+export async function brewInstall(pkg) {
+    await execFileAsync("brew", ["install", pkg], {
+        maxBuffer: 16 * 1024 * 1024,
+    });
+}
+/** Parse `owner/repo`, HTTPS, or SSH GitHub/GitLab URLs. */
+export function parseOwnerRepo(input) {
+    const raw = input.trim();
+    if (raw.length === 0)
+        return null;
+    const slug = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
+    const fromSlug = slug.exec(raw);
+    if (fromSlug && !raw.includes(":") && !raw.includes("@")) {
+        return { owner: fromSlug[1], repo: fromSlug[2] };
+    }
+    const https = /^https?:\/\/(?:www\.)?(?:github\.com|gitlab\.com)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i.exec(raw);
+    if (https) {
+        return { owner: https[1], repo: https[2].replace(/\.git$/i, "") };
+    }
+    const ssh = /^(?:git@|ssh:\/\/git@)(?:github\.com|gitlab\.com)[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(raw);
+    if (ssh) {
+        return { owner: ssh[1], repo: ssh[2].replace(/\.git$/i, "") };
+    }
+    return null;
+}
+export function remoteUrlForHost(host, owner, repo) {
+    if (host === "gitlab") {
+        return `https://gitlab.com/${owner}/${repo}.git`;
+    }
+    return `https://github.com/${owner}/${repo}.git`;
+}
+export async function repoExistsOnHost(host, owner, repo) {
+    const slug = `${owner}/${repo}`;
+    try {
+        if (host === "gitlab") {
+            await execFileAsync("glab", ["repo", "view", slug], { maxBuffer: 1024 * 1024 });
+            return true;
+        }
+        await execFileAsync("gh", ["repo", "view", slug], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/git-remote.js

@@ -1,32 +1,14 @@
+import { basename } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { askInput } from "./inquirer-helpers.js";
+import { brewInstall, formatHostCliHint, formatHostCliMissingMessage, hostCliTool, parseOwnerRepo, probeBrew, probeHostCliAuth, remoteUrlForHost, repoExistsOnHost, runInteractiveCli, } from "./git-host-cli.js";
 import { detectGitHost } from "./git-host.js";
 import { gitRemoteUrl, runGit } from "./git.js";
-import { dim, log } from "./logger.js";
+import { askInput, askSelect, askYesNo } from "./inquirer-helpers.js";
+import { dim, log, yellow } from "./logger.js";
 const execFileAsync = promisify(execFile);
-async function probeGh() {
-    try {
-        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function probeGlab() {
-    try {
-        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function createGithubRepo(cwd, name) {
-    const { stdout } = await execFileAsync("gh", 
-    // gh requires an explicit visibility flag when non-interactive.
-    ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
+    const { stdout } = await execFileAsync("gh", ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
     const match = stdout.match(/https:\/\/github\.com\/[^\s]+/);
     if (match)
         return match[0].replace(/\.git$/, "") + ".git";
@@ -42,8 +24,135 @@ async function createGitlabRepo(cwd, name, defaultBranch) {
         return url;
     throw new Error("glab repo create finished but origin URL could not be read.");
 }
+async function addRemoteUrl(cwd, remote, url) {
+    const host = detectGitHost(url);
+    if (!host) {
+        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
+    }
+    await runGit(cwd, ["remote", "add", remote, url.trim()]);
+    return { remote, url: url.trim(), host };
+}
+async function resolveConnectUrl(host, input) {
+    const trimmed = input.trim();
+    const parsed = parseOwnerRepo(trimmed);
+    if (parsed) {
+        if (trimmed.startsWith("http") || trimmed.startsWith("git@") || trimmed.startsWith("ssh://")) {
+            return trimmed.endsWith(".git") ? trimmed : `${trimmed.replace(/\/$/, "")}.git`;
+        }
+        return remoteUrlForHost(host, parsed.owner, parsed.repo);
+    }
+    if (detectGitHost(trimmed)) {
+        return trimmed.endsWith(".git") ? trimmed : `${trimmed.replace(/\/$/, "")}.git`;
+    }
+    throw new Error(`Could not parse remote: ${trimmed}`);
+}
+async function repairMissingCli(host) {
+    const tool = hostCliTool(host);
+    const status = await probeHostCliAuth(host);
+    log.warn(status === "missing"
+        ? formatHostCliMissingMessage(host, "create a remote repository")
+        : `${tool} is installed but not logged in.`);
+    for (const line of formatHostCliHint(host)) {
+        log.info(dim(`  ${line}`));
+    }
+    const brewOk = status === "missing" ? await probeBrew() : false;
+    const choices = [
+        "I installed / logged in — retry",
+        ...(brewOk ? [`Run brew install ${tool}`] : []),
+        "Enter remote URL manually",
+        "Skip remote for now",
+    ];
+    // Loop so brew install / retry can re-prompt.
+    for (;;) {
+        const pick = await askSelect({
+            message: "How do you want to continue?",
+            nonInteractive: false,
+            choices,
+        });
+        if (pick === "I installed / logged in — retry") {
+            const again = await probeHostCliAuth(host);
+            if (again === "ok")
+                return "retry";
+            log.warn(again === "missing"
+                ? `${tool} still not found on PATH.`
+                : `${tool} still not authenticated. Run \`${tool} auth login\`.`);
+            continue;
+        }
+        if (pick.startsWith("Run brew install")) {
+            log.info(dim(`Running: brew install ${tool}`));
+            try {
+                await brewInstall(tool);
+                log.ok(`Installed ${tool}`);
+                log.info(dim(`Next: ${tool} auth login`));
+                const loginNow = await askYesNo({
+                    message: `Run \`${tool} auth login\` now?`,
+                    nonInteractive: false,
+                    defaultValue: true,
+                });
+                if (loginNow) {
+                    try {
+                        await runInteractiveCli(tool, ["auth", "login"]);
+                    }
+                    catch {
+                        /* user may cancel */
+                    }
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log.warn(`brew install failed: ${msg}`);
+            }
+            continue;
+        }
+        if (pick === "Enter remote URL manually")
+            return "manual";
+        return "skip";
+    }
+}
+async function connectExisting(cwd, remote, host) {
+    const input = await askInput({
+        message: "Repository URL or owner/repo",
+        nonInteractive: false,
+        required: true,
+    });
+    const url = await resolveConnectUrl(host, input);
+    const parsed = parseOwnerRepo(url) ?? parseOwnerRepo(input);
+    if (parsed && (await probeHostCliAuth(host)) === "ok") {
+        const exists = await repoExistsOnHost(host, parsed.owner, parsed.repo);
+        if (!exists) {
+            log.warn(yellow(`Could not verify ${parsed.owner}/${parsed.repo} on ${host} (missing or private). Continuing with remote add.`));
+        }
+    }
+    return addRemoteUrl(cwd, remote, url);
+}
+async function createOnHost(cwd, remote, host, defaultBranch) {
+    const folder = basename(cwd);
+    const label = host === "gitlab" ? "GitLab project path (group/project)" : "GitHub repository (owner/repo or name)";
+    const name = await askInput({
+        message: label,
+        nonInteractive: false,
+        required: true,
+        default: folder,
+    });
+    log.info(dim(`Creating ${host} repository via ${hostCliTool(host)}…`));
+    if (host === "gitlab") {
+        const url = await createGitlabRepo(cwd, name, defaultBranch);
+        // glab may name remote differently; ensure our remote name.
+        const current = await gitRemoteUrl(cwd, remote);
+        if (!current) {
+            const origin = await gitRemoteUrl(cwd, "origin");
+            if (origin && remote !== "origin") {
+                await runGit(cwd, ["remote", "rename", "origin", remote]);
+            }
+        }
+        return { remote, url, host };
+    }
+    const url = await createGithubRepo(cwd, name);
+    return { remote, url, host };
+}
 /**
- * Ensures `origin` (or named remote) exists. Interactive path can create via gh/glab or manual URL.
+ * Ensures `origin` (or named remote) exists.
+ * Interactive: ask host → create/connect; soft-gate when CLI missing.
  */
 export async function ensureOriginRemote(opts) {
     const remote = opts.remoteName ?? "origin";
@@ -59,8 +168,9 @@ export async function ensureOriginRemote(opts) {
         return { remote, url: existing, host };
     }
     if (opts.dryRun) {
-        log.info(dim(`would configure git remote ${remote}`));
-        return { remote, url: "(dry-run)", host: "github" };
+        const host = opts.preferredHost ?? "github";
+        log.info(dim(`would configure git remote ${remote} (${host})`));
+        return { remote, url: "(dry-run)", host };
     }
     if (opts.allowMissing) {
         return null;
@@ -69,40 +179,48 @@ export async function ensureOriginRemote(opts) {
         throw new Error(`Git remote "${remote}" is not configured. Add it with: git remote add ${remote} <url>`);
     }
     log.blank();
-    log.info("Remote origin is required for push and merge requests.");
-    const ghOk = await probeGh();
-    const glabOk = await probeGlab();
-    if (ghOk) {
-        const name = await askInput({
-            message: "GitHub repository name (owner/repo or name for gh to create)",
-            nonInteractive: false,
-            required: true,
-        });
-        log.info(dim("Creating GitHub repository via gh…"));
-        const url = await createGithubRepo(opts.cwd, name);
-        return { remote, url, host: "github" };
-    }
-    if (glabOk) {
-        const name = await askInput({
-            message: "GitLab project path (group/project)",
-            nonInteractive: false,
-            required: true,
-        });
-        log.info(dim("Creating GitLab project via glab…"));
-        const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
-            ? opts.defaultBranch
-            : "main";
-        const url = await createGitlabRepo(opts.cwd, name, defaultBranch);
-        return { remote, url, host: "gitlab" };
+    log.info("Remote setup — used later for pull requests / merge requests.");
+    const hostPick = await askSelect({
+        message: "Where will this project's remote live?",
+        nonInteractive: false,
+        choices: ["GitHub", "GitLab", "Skip for now (local only)"],
+        default: opts.preferredHost === "gitlab"
+            ? "GitLab"
+            : opts.preferredHost === "github"
+                ? "GitHub"
+                : undefined,
+    });
+    if (hostPick.startsWith("Skip")) {
+        log.warn("No git remote configured. task ship push/MR will fail until origin exists.");
+        log.info(dim(`  Later: git remote add ${remote} <url>`));
+        return null;
     }
-    const url = await askInput({
-        message: `Remote URL for ${remote} (https://github.com/… or https://gitlab.com/…)`,
+    const host = hostPick === "GitLab" ? "gitlab" : "github";
+    const mode = await askSelect({
+        message: "Set up the remote",
         nonInteractive: false,
-        required: true,
+        choices: ["Create a new repository", "Connect an existing repository"],
     });
-    await runGit(opts.cwd, ["remote", "add", remote, url.trim()]);
-    const host = detectGitHost(url);
-    if (!host)
-        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
-    return { remote, url: url.trim(), host };
+    if (mode.startsWith("Connect")) {
+        return connectExisting(opts.cwd, remote, host);
+    }
+    // Create path — requires authenticated CLI (soft gate).
+    for (;;) {
+        const auth = await probeHostCliAuth(host);
+        if (auth === "ok") {
+            const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
+                ? opts.defaultBranch
+                : "main";
+            return createOnHost(opts.cwd, remote, host, defaultBranch);
+        }
+        const action = await repairMissingCli(host);
+        if (action === "retry")
+            continue;
+        if (action === "manual") {
+            return connectExisting(opts.cwd, remote, host);
+        }
+        log.warn("No git remote configured. task ship push/MR will fail until origin exists.");
+        log.info(dim(`  Later: git remote add ${remote} <url>`));
+        return null;
+    }
 }

package/dist/lib/merge-request-readiness.js

@@ -0,0 +1,57 @@
+const ACTIVE_PIPELINE_STATUSES = new Set([
+    "pending",
+    "running",
+    "created",
+    "waiting_for_resource",
+    "preparing",
+]);
+const TERMINAL_PIPELINE_FAILURES = new Set(["failed", "canceled"]);
+function normalizePipelineStatus(raw) {
+    if (raw === null || raw === undefined || raw.trim().length === 0)
+        return "none";
+    const status = raw.trim().toLowerCase();
+    if (status === "success")
+        return "success";
+    if (status === "skipped")
+        return "skipped";
+    if (status === "failed")
+        return "failed";
+    if (status === "canceled" || status === "cancelled")
+        return "canceled";
+    if (ACTIVE_PIPELINE_STATUSES.has(status))
+        return "running";
+    return "unknown";
+}
+export function pipelineStatusFromHost(raw) {
+    return normalizePipelineStatus(raw);
+}
+export function isPipelineActive(status) {
+    return status === "running" || status === "pending";
+}
+/** True when the host reports the MR can be merged now (CI done or not required). */
+export function isMergeRequestReadyToMerge(readiness) {
+    if (readiness.state === "merged")
+        return true;
+    if (readiness.state !== "open")
+        return false;
+    if (readiness.hasConflicts === true)
+        return false;
+    const detailed = readiness.detailedMergeStatus?.trim().toLowerCase() ?? "";
+    if (detailed === "conflict" ||
+        detailed === "not_approved" ||
+        detailed === "draft_status" ||
+        detailed === "ci_still_running" ||
+        detailed === "checking" ||
+        detailed === "not_open" ||
+        detailed === "discussions_not_resolved" ||
+        detailed === "need_rebase" ||
+        detailed === "blocked_status") {
+        return false;
+    }
+    if (TERMINAL_PIPELINE_FAILURES.has(readiness.pipelineStatus))
+        return false;
+    if (isPipelineActive(readiness.pipelineStatus))
+        return false;
+    const mergeStatus = readiness.mergeStatus?.trim().toLowerCase() ?? "";
+    return mergeStatus === "can_be_merged" || detailed === "mergeable";
+}

package/dist/lib/pr-create.js

@@ -1,7 +1,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mergeRequestLabel } from "./git-host.js";
-import { log } from "./logger.js";
+import { isMergeRequestReadyToMerge, isPipelineActive, pipelineStatusFromHost, } from "./merge-request-readiness.js";
+import { dim, log } from "./logger.js";
 const execFileAsync = promisify(execFile);
 async function ghPrCreate(opts) {
     const { stdout } = await execFileAsync("gh", [
@@ -64,6 +65,7 @@ export async function probeMergeRequestCli(host) {
         return false;
     }
 }
+export { isMergeRequestReadyToMerge, isPipelineActive };
 function normalizeGhMergeRequestState(raw) {
     const state = raw.trim().toUpperCase();
     if (state === "MERGED")
@@ -202,15 +204,35 @@ export async function getMergeRequestDetails(cwd, host, url) {
                 mergedAt: parsed.merged_at ?? null,
                 mergeCommitSha: parsed.merge_commit_sha ?? null,
                 squashCommitSha: parsed.squash_commit_sha ?? null,
+                mergeStatus: parsed.merge_status ?? null,
+                detailedMergeStatus: parsed.detailed_merge_status ?? null,
+                pipelineStatus: pipelineStatusFromHost(parsed.head_pipeline?.status),
+                hasConflicts: parsed.has_conflicts ?? null,
             };
         }
-        const { stdout } = await execFileAsync("gh", ["pr", "view", ref, "--json", "state,mergedAt,mergeCommit"], { cwd, maxBuffer: 1024 * 1024 });
+        const { stdout } = await execFileAsync("gh", ["pr", "view", ref, "--json", "state,mergedAt,mergeCommit,mergeable,statusCheckRollup"], { cwd, maxBuffer: 1024 * 1024 });
         const parsed = JSON.parse(stdout.trim());
+        const checks = parsed.statusCheckRollup ?? [];
+        let pipelineStatus = "none";
+        if (checks.some((c) => (c.state ?? "").toUpperCase() === "PENDING")) {
+            pipelineStatus = "running";
+        }
+        else if (checks.some((c) => (c.state ?? "").toUpperCase() === "FAILURE")) {
+            pipelineStatus = "failed";
+        }
+        else if (checks.length > 0) {
+            pipelineStatus = "success";
+        }
+        const mergeable = parsed.mergeable?.trim().toUpperCase() ?? "";
         return {
             state: normalizeGhMergeRequestState(parsed.state ?? ""),
             mergedAt: parsed.mergedAt ?? null,
             mergeCommitSha: parsed.mergeCommit?.oid ?? null,
             squashCommitSha: null,
+            mergeStatus: mergeable === "MERGEABLE" ? "can_be_merged" : mergeable.toLowerCase(),
+            detailedMergeStatus: mergeable.toLowerCase(),
+            pipelineStatus,
+            hasConflicts: mergeable === "CONFLICTING" ? true : mergeable === "MERGEABLE" ? false : null,
         };
     }
     catch {
@@ -231,6 +253,42 @@ export async function waitForMergeRequestMerged(cwd, host, url, options = {}) {
     }
     return false;
 }
+function mergeRequestReadinessFromDetails(details) {
+    if (details === null)
+        return null;
+    return {
+        state: details.state,
+        mergeStatus: details.mergeStatus,
+        detailedMergeStatus: details.detailedMergeStatus,
+        pipelineStatus: details.pipelineStatus,
+        hasConflicts: details.hasConflicts,
+    };
+}
+/** Poll until MR/PR CI finished and host reports mergeable (or already merged). */
+export async function waitForMergeRequestReadyToMerge(cwd, host, url, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 900_000;
+    const intervalMs = options.intervalMs ?? 5_000;
+    const deadline = Date.now() + timeoutMs;
+    const label = mergeRequestLabel(host);
+    let loggedWait = false;
+    while (Date.now() < deadline) {
+        const details = await getMergeRequestDetails(cwd, host, url);
+        const readiness = mergeRequestReadinessFromDetails(details);
+        if (readiness !== null && isMergeRequestReadyToMerge(readiness)) {
+            return true;
+        }
+        if (!loggedWait) {
+            log.info(dim(`Waiting for ${label} pipeline / merge checks…`));
+            loggedWait = true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return false;
+}
+function isMergeHttp405(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return msg.includes("405") || msg.toLowerCase().includes("method not allowed");
+}
 export async function closeMergeRequest(opts) {
     const ref = prRefFromUrl(opts.url);
     const label = mergeRequestLabel(opts.host);
@@ -254,10 +312,19 @@ export async function mergeMergeRequest(opts) {
     const ref = prRefFromUrl(opts.url);
     const method = opts.method ?? "squash";
     const label = mergeRequestLabel(opts.host);
+    if (opts.waitForCi === true && opts.dryRun !== true) {
+        const ready = await waitForMergeRequestReadyToMerge(opts.cwd, opts.host, opts.url);
+        if (!ready) {
+            throw new Error(`${label} is not ready to merge yet (pipeline running, checks pending, or timeout).`);
+        }
+    }
+    const details = await getMergeRequestDetails(opts.cwd, opts.host, opts.url);
+    const readiness = mergeRequestReadinessFromDetails(details);
+    const pipelineActive = readiness !== null ? isPipelineActive(readiness.pipelineStatus) : false;
     if (opts.dryRun === true) {
         if (opts.host === "gitlab") {
-            const immediate = opts.immediate !== false;
-            const flags = immediate ? " --auto-merge=false" : "";
+            const immediate = opts.immediate !== false && !pipelineActive;
+            const flags = immediate ? " --auto-merge=false" : " (auto-merge when pipeline succeeds)";
             const methodFlag = method === "squash" ? " --squash" : method === "rebase" ? " --rebase" : "";
             log.info(`would ${label} merge ${ref} (glab mr merge${flags}${methodFlag})`);
         }
@@ -267,22 +334,46 @@ export async function mergeMergeRequest(opts) {
         return;
     }
     if (opts.host === "gitlab") {
-        const args = ["mr", "merge", ref];
-        if (opts.immediate !== false) {
+        await mergeGitLabMergeRequest({
+            cwd: opts.cwd,
+            ref,
+            method,
+            immediate: opts.immediate !== false && !pipelineActive,
+        });
+        return;
+    }
+    const args = ["pr", "merge", ref, `--${method}`];
+    await execFileAsync("gh", args, { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+}
+async function mergeGitLabMergeRequest(input) {
+    const attempt = async (immediate) => {
+        const args = ["mr", "merge", input.ref];
+        if (immediate) {
             args.push("--auto-merge=false");
         }
-        if (method === "squash") {
+        if (input.method === "squash") {
             args.push("--squash");
         }
-        else if (method === "rebase") {
+        else if (input.method === "rebase") {
             args.push("--rebase");
         }
         await execFileAsync("glab", args, {
-            cwd: opts.cwd,
+            cwd: input.cwd,
             maxBuffer: 4 * 1024 * 1024,
         });
-        return;
+    };
+    try {
+        await attempt(input.immediate);
+    }
+    catch (error) {
+        if (!input.immediate && isMergeHttp405(error)) {
+            await attempt(false);
+            return;
+        }
+        if (input.immediate && isMergeHttp405(error)) {
+            await attempt(false);
+            return;
+        }
+        throw error;
     }
-    const args = ["pr", "merge", ref, `--${method}`];
-    await execFileAsync("gh", args, { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
 }