patchrelay 0.26.0 → 0.29.1

package/dist/issue-query-service.js

@@ -1,10 +1,14 @@
+import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
 import { safeJsonParse } from "./utils.js";
 export class IssueQueryService {
+    config;
     db;
     codex;
     runStatusProvider;
-    constructor(db, codex, runStatusProvider) {
+    constructor(config, db, codex, runStatusProvider) {
+        this.config = config;
         this.db = db;
         this.codex = codex;
         this.runStatusProvider = runStatusProvider;
@@ -13,6 +17,7 @@ export class IssueQueryService {
         const result = this.db.getIssueOverview(issueKey);
         if (!result)
             return undefined;
+        const issueRecord = this.db.getIssueByKey(issueKey);
         const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
         const activeRun = activeStatus?.run ?? result.activeRun;
         const latestRun = this.db.getLatestRunForIssue(result.issue.projectId, result.issue.linearIssueId);
@@ -25,6 +30,7 @@ export class IssueQueryService {
         }
         return {
             ...result,
+            issue: issueRecord ? { ...result.issue, queueProtocol: this.buildQueueProtocol(issueRecord.projectId, issueRecord) } : result.issue,
             ...(activeRun ? { activeRun } : {}),
             ...(latestRun ? { latestRun } : {}),
             ...(liveThread ? { liveThread } : {}),
@@ -97,6 +103,7 @@ export class IssueQueryService {
                 ciRepairAttempts: fullIssue?.ciRepairAttempts ?? 0,
                 queueRepairAttempts: fullIssue?.queueRepairAttempts ?? 0,
                 reviewFixAttempts: fullIssue?.reviewFixAttempts ?? 0,
+                ...(fullIssue ? { queueProtocol: this.buildQueueProtocol(fullIssue.projectId, fullIssue) } : {}),
             },
             runs,
             feedEvents,
@@ -127,13 +134,39 @@ export class IssueQueryService {
                 ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
                 ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
                 ...(issueRecord ? { ciRepairAttempts: issueRecord.ciRepairAttempts, queueRepairAttempts: issueRecord.queueRepairAttempts } : {}),
+                ...(issueRecord ? { queueProtocol: this.buildQueueProtocol(issueRecord.projectId, issueRecord) } : {}),
             },
             ...(overview.activeRun ? { activeRun: overview.activeRun } : {}),
             ...(overview.latestRun ? { latestRun: overview.latestRun } : {}),
             ...(overview.liveThread ? { liveThread: overview.liveThread } : {}),
             ...(latestRunReport ? { latestReportSummary: extractStageSummary(latestRunReport) } : {}),
+            feedEvents: this.db.operatorFeed.list({ issueKey, limit: 500 }),
+            activeRunId: issueRecord?.activeRunId ?? null,
             runs: report?.runs ?? [],
             generatedAt: new Date().toISOString(),
         };
     }
+    buildQueueProtocol(projectId, issue) {
+        const project = this.config.projects.find((entry) => entry.id === projectId);
+        const protocol = resolveMergeQueueProtocol(project);
+        const queueIncident = issue.lastQueueIncidentJson
+            ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
+            : undefined;
+        return {
+            repoFullName: protocol.repoFullName,
+            baseBranch: protocol.baseBranch,
+            admissionLabel: protocol.admissionLabel,
+            evictionCheckName: protocol.evictionCheckName,
+            prNumber: issue.prNumber ?? null,
+            lastFailureSource: issue.lastGitHubFailureSource ?? null,
+            lastFailureCheckName: issue.lastGitHubFailureCheckName ?? null,
+            lastFailureCheckUrl: issue.lastGitHubFailureCheckUrl ?? null,
+            lastFailureAt: issue.lastGitHubFailureAt ?? null,
+            lastQueueSignalAt: issue.lastQueueSignalAt ?? null,
+            lastIncidentId: queueIncident?.incidentId ?? null,
+            lastIncidentUrl: queueIncident?.incidentUrl ?? null,
+            lastIncidentFailureClass: queueIncident?.incidentContext?.failureClass ?? null,
+            lastIncidentSummary: queueIncident?.incidentSummary ?? null,
+        };
+    }
 }

package/dist/linear-client.js

@@ -269,6 +269,58 @@ export class LinearGraphqlClient {
             ...(response.viewer?.name ? { actorName: response.viewer.name } : {}),
         };
     }
+    async getWorkspaceCatalog() {
+        const response = await this.request(`
+      query PatchRelayWorkspaceCatalog {
+        organization {
+          id
+          name
+          urlKey
+        }
+        viewer {
+          id
+          name
+        }
+        teams {
+          nodes {
+            id
+            key
+            name
+          }
+        }
+        projects {
+          nodes {
+            id
+            name
+            teams {
+              nodes {
+                id
+              }
+            }
+          }
+        }
+      }
+      `, {});
+        return {
+            workspace: {
+                ...(response.organization?.id ? { workspaceId: response.organization.id } : {}),
+                ...(response.organization?.name ? { workspaceName: response.organization.name } : {}),
+                ...(response.organization?.urlKey ? { workspaceKey: response.organization.urlKey } : {}),
+                ...(response.viewer?.id ? { actorId: response.viewer.id } : {}),
+                ...(response.viewer?.name ? { actorName: response.viewer.name } : {}),
+            },
+            teams: (response.teams?.nodes ?? []).map((team) => ({
+                id: team.id,
+                ...(team.key ? { key: team.key } : {}),
+                ...(team.name ? { name: team.name } : {}),
+            })),
+            projects: (response.projects?.nodes ?? []).map((project) => ({
+                id: project.id,
+                ...(project.name ? { name: project.name } : {}),
+                teamIds: (project.teams?.nodes ?? []).map((team) => team.id),
+            })),
+        };
+    }
     async request(query, variables) {
         const response = await fetch(this.options.graphqlUrl, {
             method: "POST",
@@ -349,34 +401,37 @@ export class DatabaseBackedLinearClientProvider {
     async forProject(projectId) {
         const link = this.db.linearInstallations.getProjectInstallation(projectId);
         if (link) {
-            const installation = this.db.linearInstallations.getLinearInstallation(link.installationId);
-            if (!installation) {
-                return undefined;
-            }
-            const encryptionKey = this.config.linear.tokenEncryptionKey;
-            let accessToken = decryptSecret(installation.accessTokenCiphertext, encryptionKey);
-            const refreshToken = installation.refreshTokenCiphertext
-                ? decryptSecret(installation.refreshTokenCiphertext, encryptionKey)
-                : undefined;
-            if (shouldRefreshToken(installation.expiresAt) && refreshToken) {
-                const refreshed = await refreshLinearOAuthToken(this.config, refreshToken);
-                accessToken = refreshed.accessToken;
-                this.db.linearInstallations.updateLinearInstallationTokens(installation.id, {
-                    accessTokenCiphertext: encryptSecret(refreshed.accessToken, encryptionKey),
-                    ...(refreshed.refreshToken
-                        ? { refreshTokenCiphertext: encryptSecret(refreshed.refreshToken, encryptionKey) }
-                        : {}),
-                    scopesJson: JSON.stringify(refreshed.scopes),
-                    ...(refreshed.expiresAt ? { expiresAt: refreshed.expiresAt } : {}),
-                });
-            }
-            return new LinearGraphqlClient({
-                accessToken,
-                graphqlUrl: this.config.linear.graphqlUrl,
-            }, this.logger);
+            return await this.forInstallationId(link.installationId);
         }
         return undefined;
     }
+    async forInstallationId(installationId) {
+        const installation = this.db.linearInstallations.getLinearInstallation(installationId);
+        if (!installation) {
+            return undefined;
+        }
+        const encryptionKey = this.config.linear.tokenEncryptionKey;
+        let accessToken = decryptSecret(installation.accessTokenCiphertext, encryptionKey);
+        const refreshToken = installation.refreshTokenCiphertext
+            ? decryptSecret(installation.refreshTokenCiphertext, encryptionKey)
+            : undefined;
+        if (shouldRefreshToken(installation.expiresAt) && refreshToken) {
+            const refreshed = await refreshLinearOAuthToken(this.config, refreshToken);
+            accessToken = refreshed.accessToken;
+            this.db.linearInstallations.updateLinearInstallationTokens(installation.id, {
+                accessTokenCiphertext: encryptSecret(refreshed.accessToken, encryptionKey),
+                ...(refreshed.refreshToken
+                    ? { refreshTokenCiphertext: encryptSecret(refreshed.refreshToken, encryptionKey) }
+                    : {}),
+                scopesJson: JSON.stringify(refreshed.scopes),
+                ...(refreshed.expiresAt ? { expiresAt: refreshed.expiresAt } : {}),
+            });
+        }
+        return new LinearGraphqlClient({
+            accessToken,
+            graphqlUrl: this.config.linear.graphqlUrl,
+        }, this.logger);
+    }
 }
 function shouldRefreshToken(expiresAt) {
     if (!expiresAt) {

package/dist/merge-queue-incident.js

@@ -0,0 +1,104 @@
+import { safeJsonParse } from "./utils.js";
+export function buildQueueRepairContextFromEvent(event) {
+    const payload = parseQueueEvictionPayload(event.checkOutputText);
+    const incidentUrl = event.checkDetailsUrl ?? payload?.incidentUrl;
+    return {
+        failureReason: "queue_eviction",
+        ...(event.checkName ? { checkName: event.checkName } : {}),
+        ...(event.checkUrl ? { checkUrl: event.checkUrl } : {}),
+        ...(payload?.incidentId ? { incidentId: payload.incidentId } : {}),
+        ...(incidentUrl ? { incidentUrl } : {}),
+        ...(event.checkOutputTitle ? { incidentTitle: event.checkOutputTitle } : {}),
+        ...(event.checkOutputSummary ? { incidentSummary: event.checkOutputSummary } : {}),
+        ...(payload?.incidentContext ? { incidentContext: payload.incidentContext } : {}),
+    };
+}
+export function parseStoredQueueRepairContext(json) {
+    if (!json)
+        return undefined;
+    const parsed = safeJsonParse(json);
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    if (parsed.failureReason !== "queue_eviction")
+        return undefined;
+    const incidentContext = normalizeIncidentContext(parsed.incidentContext);
+    return {
+        failureReason: "queue_eviction",
+        ...(typeof parsed.checkName === "string" ? { checkName: parsed.checkName } : {}),
+        ...(typeof parsed.checkUrl === "string" ? { checkUrl: parsed.checkUrl } : {}),
+        ...(typeof parsed.incidentId === "string" ? { incidentId: parsed.incidentId } : {}),
+        ...(typeof parsed.incidentUrl === "string" ? { incidentUrl: parsed.incidentUrl } : {}),
+        ...(typeof parsed.incidentTitle === "string" ? { incidentTitle: parsed.incidentTitle } : {}),
+        ...(typeof parsed.incidentSummary === "string" ? { incidentSummary: parsed.incidentSummary } : {}),
+        ...(incidentContext ? { incidentContext } : {}),
+    };
+}
+function parseQueueEvictionPayload(text) {
+    if (!text)
+        return undefined;
+    const parsed = safeJsonParse(text);
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    const incidentContext = normalizeIncidentContext(parsed.incidentContext ?? parsed);
+    if (!incidentContext && typeof parsed.incidentId !== "string" && typeof parsed.incidentUrl !== "string") {
+        return undefined;
+    }
+    return {
+        ...(typeof parsed.incidentId === "string" ? { incidentId: parsed.incidentId } : {}),
+        ...(typeof parsed.incidentUrl === "string" ? { incidentUrl: parsed.incidentUrl } : {}),
+        ...(incidentContext ? { incidentContext } : {}),
+    };
+}
+function normalizeIncidentContext(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const failedChecks = Array.isArray(record.failedChecks)
+        ? record.failedChecks
+            .filter((entry) => entry && typeof entry === "object")
+            .map((entry) => {
+            const check = entry;
+            if (typeof check.name !== "string" || typeof check.conclusion !== "string")
+                return undefined;
+            return {
+                name: check.name,
+                conclusion: check.conclusion,
+                ...(typeof check.url === "string" ? { url: check.url } : {}),
+            };
+        })
+            .filter((entry) => Boolean(entry))
+        : undefined;
+    const retryHistory = Array.isArray(record.retryHistory)
+        ? record.retryHistory
+            .filter((entry) => entry && typeof entry === "object")
+            .map((entry) => {
+            const retry = entry;
+            if (typeof retry.at !== "string" || typeof retry.baseSha !== "string" || typeof retry.outcome !== "string") {
+                return undefined;
+            }
+            return {
+                at: retry.at,
+                baseSha: retry.baseSha,
+                outcome: retry.outcome,
+            };
+        })
+            .filter((entry) => Boolean(entry))
+        : undefined;
+    const conflictFiles = Array.isArray(record.conflictFiles)
+        ? record.conflictFiles.filter((entry) => typeof entry === "string")
+        : undefined;
+    const normalized = {
+        ...(typeof record.version === "number" ? { version: record.version } : {}),
+        ...(typeof record.failureClass === "string" ? { failureClass: record.failureClass } : {}),
+        ...(typeof record.baseSha === "string" ? { baseSha: record.baseSha } : {}),
+        ...(typeof record.prHeadSha === "string" ? { prHeadSha: record.prHeadSha } : {}),
+        ...(typeof record.queuePosition === "number" ? { queuePosition: record.queuePosition } : {}),
+        ...(typeof record.baseBranch === "string" ? { baseBranch: record.baseBranch } : {}),
+        ...(typeof record.branch === "string" ? { branch: record.branch } : {}),
+        ...(typeof record.issueKey === "string" || record.issueKey === null ? { issueKey: record.issueKey } : {}),
+        ...(conflictFiles?.length ? { conflictFiles } : {}),
+        ...(failedChecks?.length ? { failedChecks } : {}),
+        ...(retryHistory?.length ? { retryHistory } : {}),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}

package/dist/merge-queue-protocol.js

@@ -0,0 +1,54 @@
+import { execCommand } from "./utils.js";
+export const DEFAULT_MERGE_QUEUE_LABEL = "queue";
+export const DEFAULT_MERGE_QUEUE_CHECK_NAME = "merge-steward/queue";
+export function resolveMergeQueueProtocol(project) {
+    return {
+        repoFullName: project?.github?.repoFullName,
+        baseBranch: project?.github?.baseBranch,
+        admissionLabel: project?.github?.mergeQueueLabel ?? DEFAULT_MERGE_QUEUE_LABEL,
+        evictionCheckName: project?.github?.mergeQueueCheckName ?? DEFAULT_MERGE_QUEUE_CHECK_NAME,
+    };
+}
+export async function requestMergeQueueAdmission(params) {
+    const { issue, protocol, logger, feed } = params;
+    if (!protocol.repoFullName || !issue.prNumber)
+        return;
+    feed?.publish({
+        level: "info",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: "awaiting_queue",
+        status: "queue_label_requested",
+        summary: `Queue hand-off requested via label "${protocol.admissionLabel}" on PR #${issue.prNumber}`,
+    });
+    try {
+        await execCommand("gh", [
+            "pr", "edit", String(issue.prNumber),
+            "--repo", protocol.repoFullName,
+            "--add-label", protocol.admissionLabel,
+        ], { timeoutMs: 15_000 });
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: "awaiting_queue",
+            status: "queue_label_applied",
+            summary: `Queue label "${protocol.admissionLabel}" applied to PR #${issue.prNumber}`,
+        });
+    }
+    catch (error) {
+        logger.warn({ issueKey: issue.issueKey, err: error }, "Failed to add merge queue label");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: "awaiting_queue",
+            status: "queue_label_failed",
+            summary: `Queue hand-off failed while adding label "${protocol.admissionLabel}" to PR #${issue.prNumber}`,
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/preflight.js

@@ -1,6 +1,7 @@
 import { accessSync, constants, existsSync, mkdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { runPatchRelayMigrations } from "./db/migrations.js";
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { SqliteConnection } from "./db/shared.js";
 import { execCommand } from "./utils.js";
 export async function runPreflight(config, options) {
@@ -56,11 +57,12 @@ export async function runPreflight(config, options) {
     checks.push(...checkDatabaseHealth(config));
     checks.push(...checkPath("logging", path.dirname(config.logging.filePath), "directory", { createIfMissing: true, writable: true }));
     if (config.projects.length === 0) {
-        checks.push(warn("projects", "No projects are configured yet; add one with `patchrelay project apply <id> <repo-path>` before connecting Linear"));
+        checks.push(warn("projects", "No repos are configured yet; connect a Linear workspace with `patchrelay linear connect` and then link a GitHub repo with `patchrelay repo link <owner/repo> --workspace <workspace> --team <team>`"));
     }
     for (const project of config.projects) {
         checks.push(...checkPath(`project:${project.id}:repo`, project.repoPath, "directory", { writable: true }));
         checks.push(...checkPath(`project:${project.id}:worktrees`, project.worktreeRoot, "directory", { createIfMissing: true, writable: true }));
+        checks.push(...checkGitHubProtocol(project, config.server.publicBaseUrl));
         // Workflow file checks removed — factory state machine replaces workflow definitions
     }
     checks.push(await checkExecutable("git", config.runner.gitBin));
@@ -272,6 +274,31 @@ function checkOAuthRedirectUri(config) {
         return [fail("linear_oauth", `Invalid linear.oauth.redirect_uri: ${formatError(error)}`)];
     }
 }
+function checkGitHubProtocol(project, publicBaseUrl) {
+    const protocol = resolveMergeQueueProtocol(project);
+    const scope = `project:${project.id}:github_protocol`;
+    if (!protocol.repoFullName) {
+        return [
+            warn(scope, "GitHub repo is not configured; PR state tracking, queue hand-off, and queue repair automation are disabled for this project"),
+        ];
+    }
+    const checks = [
+        pass(scope, `GitHub protocol configured for ${protocol.repoFullName} (label "${protocol.admissionLabel}", eviction check "${protocol.evictionCheckName}")`),
+    ];
+    if (!publicBaseUrl) {
+        checks.push(warn(scope, "PatchRelay public base URL is not configured; public operator/session links will be incomplete"));
+    }
+    if (!protocol.baseBranch) {
+        checks.push(warn(scope, "GitHub base branch is not configured; defaults may diverge from the target repository"));
+    }
+    if (!protocol.admissionLabel.trim()) {
+        checks.push(fail(scope, "Merge queue admission label must not be empty"));
+    }
+    if (!protocol.evictionCheckName.trim()) {
+        checks.push(fail(scope, "Merge queue eviction check name must not be empty"));
+    }
+    return checks;
+}
 function isLoopbackHost(host) {
     return host === "127.0.0.1" || host === "::1" || host === "localhost";
 }

package/dist/repository-linking.js

@@ -0,0 +1,42 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { execCommand } from "./utils.js";
+export function normalizeGitHubRepo(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("GitHub repo is required.");
+    }
+    const withoutProtocol = trimmed
+        .replace(/^https?:\/\/github\.com\//i, "")
+        .replace(/^git@github\.com:/i, "")
+        .replace(/\.git$/i, "")
+        .replace(/^github\.com\//i, "")
+        .replace(/^\/+|\/+$/g, "");
+    const parts = withoutProtocol.split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        throw new Error(`Invalid GitHub repo: ${input}`);
+    }
+    return `${parts[0]}/${parts[1]}`;
+}
+export function defaultLocalRepoPath(reposRoot, githubRepo) {
+    const repoName = githubRepo.split("/").pop();
+    if (!repoName) {
+        throw new Error(`Invalid GitHub repo: ${githubRepo}`);
+    }
+    return path.join(reposRoot, repoName);
+}
+export async function ensureLocalRepository(params) {
+    const githubRepo = normalizeGitHubRepo(params.githubRepo);
+    const localPath = path.resolve(params.localPath);
+    const originUrl = `https://github.com/${githubRepo}.git`;
+    if (!existsSync(localPath)) {
+        await execCommand(params.config.runner.gitBin, ["clone", originUrl, localPath], { timeoutMs: 300_000 });
+        return { reused: false, localPath, originUrl };
+    }
+    const remote = await execCommand(params.config.runner.gitBin, ["-C", localPath, "remote", "get-url", "origin"], { timeoutMs: 10_000 });
+    const existingRepo = normalizeGitHubRepo(remote.stdout.trim());
+    if (existingRepo !== githubRepo) {
+        throw new Error(`Existing repo at ${localPath} points to ${existingRepo}, not ${githubRepo}`);
+    }
+    return { reused: true, localPath, originUrl };
+}