patchrelay 0.26.0 → 0.29.1

package/dist/cli/commands/project.js

@@ -1,146 +0,0 @@
-import { loadConfig } from "../../config.js";
-import { installServiceUnits, upsertProjectInConfig } from "../../install.js";
-import { hasHelpFlag, parseCsvFlag } from "../args.js";
-import { runConnectFlow, parseTimeoutSeconds } from "../connect-flow.js";
-import { CliUsageError } from "../errors.js";
-import { formatJson } from "../formatters/json.js";
-import { projectHelpText } from "../help.js";
-import { writeOutput } from "../output.js";
-import { installServiceCommands, tryManageService } from "../service-commands.js";
-export async function handleProjectCommand(params) {
-    if (hasHelpFlag(params.parsed)) {
-        writeOutput(params.stdout, `${projectHelpText()}\n`);
-        return 0;
-    }
-    if (params.commandArgs.length === 0) {
-        throw new CliUsageError("patchrelay project requires a subcommand.", "project");
-    }
-    const subcommand = params.commandArgs[0];
-    if (subcommand !== "apply") {
-        throw new CliUsageError(`Unknown project command: ${subcommand}`, "project");
-    }
-    const projectId = params.commandArgs[1];
-    const repoPath = params.commandArgs[2];
-    if (!projectId || !repoPath) {
-        throw new CliUsageError("patchrelay project apply requires <id> and <repo-path>.", "project");
-    }
-    const result = await upsertProjectInConfig({
-        id: projectId,
-        repoPath,
-        issueKeyPrefixes: parseCsvFlag(params.parsed.flags.get("issue-prefix")),
-        linearTeamIds: parseCsvFlag(params.parsed.flags.get("team-id")),
-    });
-    const serviceUnits = await installServiceUnits();
-    const noConnect = params.parsed.flags.get("no-connect") === true;
-    const lines = [
-        `Config file: ${result.configPath}`,
-        `${result.status === "created" ? "Created" : result.status === "updated" ? "Updated" : "Verified"} project ${result.project.id} for ${result.project.repoPath}`,
-        result.project.issueKeyPrefixes.length > 0 ? `Issue key prefixes: ${result.project.issueKeyPrefixes.join(", ")}` : undefined,
-        result.project.linearTeamIds.length > 0 ? `Linear team ids: ${result.project.linearTeamIds.join(", ")}` : undefined,
-        `Service unit: ${serviceUnits.unitPath} (${serviceUnits.serviceStatus})`,
-        `Watcher unit: ${serviceUnits.pathUnitPath} (${serviceUnits.pathStatus})`,
-    ].filter(Boolean);
-    let fullConfig;
-    try {
-        fullConfig = loadConfig(undefined, { profile: "doctor" });
-    }
-    catch (error) {
-        if (params.json) {
-            writeOutput(params.stdout, formatJson({
-                ...result,
-                serviceUnits,
-                readiness: {
-                    ok: false,
-                    error: error instanceof Error ? error.message : String(error),
-                },
-                connect: {
-                    attempted: false,
-                    skipped: "missing_env",
-                },
-            }));
-            return 0;
-        }
-        lines.push(`Linear connect was skipped: ${error instanceof Error ? error.message : String(error)}`);
-        lines.push("Finish the required env vars and rerun `patchrelay project apply`.");
-        writeOutput(params.stdout, `${lines.join("\n")}\n`);
-        return 0;
-    }
-    const { runPreflight } = await import("../../preflight.js");
-    const report = await runPreflight(fullConfig, { skipServiceCheck: true });
-    const failedChecks = report.checks.filter((check) => check.status === "fail");
-    if (failedChecks.length > 0) {
-        if (params.json) {
-            writeOutput(params.stdout, formatJson({
-                ...result,
-                serviceUnits,
-                readiness: report,
-                connect: {
-                    attempted: false,
-                    skipped: "preflight_failed",
-                },
-            }));
-            return 0;
-        }
-        lines.push("Linear connect was skipped because PatchRelay is not ready yet:");
-        lines.push(...failedChecks.map((check) => `- [${check.scope}] ${check.message}`));
-        lines.push("Fix the failures above and rerun `patchrelay project apply`.");
-        writeOutput(params.stdout, `${lines.join("\n")}\n`);
-        return 0;
-    }
-    const serviceState = await tryManageService(params.runInteractive, installServiceCommands());
-    if (!serviceState.ok) {
-        throw new Error(`Project was saved, but PatchRelay could not be reloaded: ${serviceState.error}`);
-    }
-    const cliData = params.options?.data ?? (await createCliOperatorDataAccess(fullConfig));
-    try {
-        if (params.json) {
-            const connectResult = noConnect ? undefined : await cliData.connect(projectId);
-            writeOutput(params.stdout, formatJson({
-                ...result,
-                serviceUnits,
-                readiness: report,
-                serviceReloaded: true,
-                ...(noConnect
-                    ? {
-                        connect: {
-                            attempted: false,
-                            skipped: "no_connect",
-                        },
-                    }
-                    : {
-                        connect: {
-                            attempted: true,
-                            result: connectResult,
-                        },
-                    }),
-            }));
-            return 0;
-        }
-        if (noConnect) {
-            lines.push("Project saved and PatchRelay was reloaded.");
-            lines.push(`Next: patchrelay connect --project ${result.project.id}`);
-            writeOutput(params.stdout, `${lines.join("\n")}\n`);
-            return 0;
-        }
-        writeOutput(params.stdout, `${lines.join("\n")}\n`);
-        return await runConnectFlow({
-            config: fullConfig,
-            data: cliData,
-            stdout: params.stdout,
-            noOpen: params.parsed.flags.get("no-open") === true,
-            timeoutSeconds: parseTimeoutSeconds(params.parsed.flags.get("timeout"), "project apply"),
-            projectId,
-            ...(params.options?.openExternal ? { openExternal: params.options.openExternal } : {}),
-            ...(params.options?.connectPollIntervalMs !== undefined ? { connectPollIntervalMs: params.options.connectPollIntervalMs } : {}),
-        });
-    }
-    finally {
-        if (!params.options?.data) {
-            cliData.close();
-        }
-    }
-}
-async function createCliOperatorDataAccess(config) {
-    const { CliOperatorApiClient } = await import("../operator-client.js");
-    return new CliOperatorApiClient(config);
-}

package/dist/merge-queue.js

@@ -1,200 +0,0 @@
-import { buildMergePrepActivity, buildMergePrepEscalationActivity } from "./linear-session-reporting.js";
-import { execCommand } from "./utils.js";
-const DEFAULT_MERGE_PREP_BUDGET = 3;
-/**
- * Merge queue steward — keeps PatchRelay-managed PR branches up to date
- * with the base branch via rebase and enables auto-merge so GitHub merges
- * when CI passes. Uses rebase (not merge) to maintain linear history.
- *
- * Serialization: all calls are routed through the issue queue, and
- * prepareForMerge checks front-of-queue before acting. The issue processor
- * in service.ts checks pendingRunType before pendingMergePrep, so repair
- * runs always take priority over merge prep.
- */
-export class MergeQueue {
-    config;
-    db;
-    enqueueIssue;
-    logger;
-    feed;
-    onLinearActivity;
-    constructor(config, db, enqueueIssue, logger, feed, onLinearActivity) {
-        this.config = config;
-        this.db = db;
-        this.enqueueIssue = enqueueIssue;
-        this.logger = logger;
-        this.feed = feed;
-        this.onLinearActivity = onLinearActivity;
-    }
-    /**
-     * Prepare the front-of-queue issue for merge:
-     * 1. Enable auto-merge
-     * 2. Rebase the branch onto latest base
-     * 3. Force-push (triggers CI; auto-merge fires when CI passes)
-     *
-     * On conflict: abort rebase, transition to repairing_queue, enqueue queue_repair.
-     * On transient failure: leave pendingMergePrep set so the next event retries.
-     */
-    async prepareForMerge(issue, project) {
-        // Only prepare the front-of-queue issue for this project
-        const queue = this.db.listIssuesByState(project.id, "awaiting_queue");
-        const front = queue.find((i) => i.activeRunId === undefined && i.pendingRunType === undefined);
-        if (!front || front.id !== issue.id) {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
-            return;
-        }
-        if (!issue.worktreePath || !issue.prNumber) {
-            this.logger.warn({ issueKey: issue.issueKey }, "Merge prep skipped: missing worktree or PR number");
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
-            return;
-        }
-        // Retry budget — escalate after repeated infrastructure failures
-        const attempts = issue.mergePrepAttempts + 1;
-        this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, mergePrepAttempts: attempts });
-        if (attempts > DEFAULT_MERGE_PREP_BUDGET) {
-            this.logger.warn({ issueKey: issue.issueKey, attempts }, "Merge prep budget exhausted, escalating");
-            this.db.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                factoryState: "escalated",
-                pendingMergePrep: false,
-            });
-            this.feed?.publish({
-                level: "error",
-                kind: "workflow",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                stage: "awaiting_queue",
-                status: "escalated",
-                summary: `Merge prep failed ${attempts - 1} times — escalating for human help`,
-            });
-            this.onLinearActivity?.(issue, buildMergePrepEscalationActivity(attempts - 1));
-            return;
-        }
-        const repoFullName = project.github?.repoFullName;
-        const baseBranch = project.github?.baseBranch ?? "main";
-        const gitBin = this.config.runner.gitBin;
-        // Enable auto-merge (idempotent)
-        const autoMergeOk = repoFullName ? await this.enableAutoMerge(issue, repoFullName) : false;
-        if (autoMergeOk) {
-            this.onLinearActivity?.(issue, buildMergePrepActivity("auto_merge"), { ephemeral: true });
-        }
-        // Fetch latest base branch
-        const fetchResult = await execCommand(gitBin, ["-C", issue.worktreePath, "fetch", "origin", baseBranch], {
-            timeoutMs: 60_000,
-        });
-        if (fetchResult.exitCode !== 0) {
-            // Transient failure — leave pendingMergePrep set so the next event retries.
-            this.logger.warn({ issueKey: issue.issueKey, stderr: fetchResult.stderr?.slice(0, 300) }, "Merge prep: fetch failed, will retry on next event");
-            this.onLinearActivity?.(issue, buildMergePrepActivity("fetch_retry"), { ephemeral: true });
-            return;
-        }
-        // Check if rebase is needed: is HEAD already on top of origin/baseBranch?
-        const mergeBaseResult = await execCommand(gitBin, ["-C", issue.worktreePath, "merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"], {
-            timeoutMs: 10_000,
-        });
-        if (mergeBaseResult.exitCode === 0) {
-            this.logger.debug({ issueKey: issue.issueKey }, "Merge prep: branch already up to date");
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false, mergePrepAttempts: 0 });
-            if (!autoMergeOk) {
-                this.feed?.publish({
-                    level: "warn",
-                    kind: "workflow",
-                    issueKey: issue.issueKey,
-                    projectId: issue.projectId,
-                    stage: "awaiting_queue",
-                    status: "blocked",
-                    summary: "Branch up to date but auto-merge not enabled — check gh auth and repo settings",
-                });
-                this.onLinearActivity?.(issue, buildMergePrepActivity("blocked"));
-            }
-            return;
-        }
-        // Rebase onto latest base branch (clean linear history, no merge commits)
-        const rebaseResult = await execCommand(gitBin, ["-C", issue.worktreePath, "rebase", `origin/${baseBranch}`], {
-            timeoutMs: 120_000,
-        });
-        if (rebaseResult.exitCode !== 0) {
-            // Conflict — abort and trigger queue_repair
-            await execCommand(gitBin, ["-C", issue.worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
-            this.logger.info({ issueKey: issue.issueKey }, "Merge prep: rebase conflict detected, triggering queue repair");
-            this.db.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                factoryState: "repairing_queue",
-                pendingRunType: "queue_repair",
-                pendingRunContextJson: JSON.stringify({ failureReason: "rebase_conflict" }),
-                pendingMergePrep: false,
-            });
-            this.enqueueIssue(issue.projectId, issue.linearIssueId);
-            this.feed?.publish({
-                level: "warn",
-                kind: "workflow",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                stage: "repairing_queue",
-                status: "conflict",
-                summary: `Rebase conflict with ${baseBranch} — queue repair enqueued`,
-            });
-            this.onLinearActivity?.(issue, buildMergePrepActivity("conflict"));
-            return;
-        }
-        // Push the rebased branch (force-with-lease to protect against concurrent changes)
-        const pushResult = await execCommand(gitBin, ["-C", issue.worktreePath, "push", "--force-with-lease"], {
-            timeoutMs: 60_000,
-        });
-        if (pushResult.exitCode !== 0) {
-            // Push failed — leave pendingMergePrep set so the next event retries.
-            this.logger.warn({ issueKey: issue.issueKey, stderr: pushResult.stderr?.slice(0, 300) }, "Merge prep: push failed, will retry on next event");
-            this.onLinearActivity?.(issue, buildMergePrepActivity("push_retry"), { ephemeral: true });
-            return;
-        }
-        this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Merge prep: rebased and pushed");
-        this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false, mergePrepAttempts: 0 });
-        this.feed?.publish({
-            level: "info",
-            kind: "workflow",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: "awaiting_queue",
-            status: "prepared",
-            summary: `Branch rebased onto latest ${baseBranch} — CI will run`,
-        });
-        this.onLinearActivity?.(issue, buildMergePrepActivity("branch_update", baseBranch), { ephemeral: true });
-    }
-    /**
-     * Seed the merge queue on startup: for each project, ensure the front-of-queue
-     * issue has pendingMergePrep set. Catches issues that entered awaiting_queue
-     * but whose merge prep was never triggered or was lost to a crash/restart.
-     */
-    seedOnStartup() {
-        for (const project of this.config.projects) {
-            this.advanceQueue(project.id);
-        }
-    }
-    /**
-     * Advance the queue: find the next awaiting_queue issue and prepare it.
-     * Called when a PR merges (pr_merged event) and on startup.
-     */
-    advanceQueue(projectId) {
-        const queue = this.db.listIssuesByState(projectId, "awaiting_queue");
-        const next = queue.find((i) => i.activeRunId === undefined && i.pendingRunType === undefined && !i.pendingMergePrep);
-        if (!next)
-            return;
-        this.logger.info({ issueKey: next.issueKey, projectId }, "Advancing merge queue");
-        this.db.upsertIssue({ projectId: next.projectId, linearIssueId: next.linearIssueId, pendingMergePrep: true });
-        this.enqueueIssue(next.projectId, next.linearIssueId);
-    }
-    /** Returns true if auto-merge was successfully enabled (or already enabled). */
-    async enableAutoMerge(issue, repoFullName) {
-        // Uses the host's existing gh auth — same credentials Codex uses to create PRs.
-        const result = await execCommand("gh", ["pr", "merge", String(issue.prNumber), "--repo", repoFullName, "--auto", "--squash"], {
-            timeoutMs: 30_000,
-        });
-        if (result.exitCode !== 0) {
-            this.logger.warn({ issueKey: issue.issueKey, stderr: result.stderr?.slice(0, 200) }, "Merge prep: auto-merge enablement failed");
-            return false;
-        }
-        return true;
-    }
-}

package/infra/patchrelay-reload.service

@@ -1,6 +0,0 @@
-[Unit]
-Description=PatchRelay reload helper
-
-[Service]
-Type=oneshot
-ExecStart=/usr/bin/env systemctl reload-or-restart patchrelay.service

package/infra/patchrelay.path

@@ -1,13 +0,0 @@
-[Unit]
-Description=Watch PatchRelay config and env changes
-
-[Path]
-Unit=patchrelay-reload.service
-PathChanged=/home/your-user/.config/patchrelay/runtime.env
-PathChanged=/home/your-user/.config/patchrelay/service.env
-PathChanged=/home/your-user/.config/patchrelay/patchrelay.json
-TriggerLimitIntervalSec=5
-TriggerLimitBurst=1
-
-[Install]
-WantedBy=multi-user.target