agent-relay-server 0.62.1 → 0.62.2

package/docs/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Relay API",
-    "version": "0.62.1",
+    "version": "0.62.2",
     "description": "Real-time message bus for inter-agent communication. Agent-first: this spec is designed for machine consumption — agents can self-discover the full API surface via GET /api/spec.",
     "license": {
       "name": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.62.1",
+  "version": "0.62.2",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",

package/src/branch-landed.ts

@@ -34,6 +34,12 @@ export interface BranchLandedInput {
    * `undefined` from older orchestrators that don't report it → message stays generic.
    */
   pushed?: boolean;
+  /**
+   * The land came in via a pull request — the subject's trailing `(#NNN)` is the PR
+   * number, not an issue. Forwarded to the issue-lifecycle hook so it doesn't mistake
+   * the PR number for an issue to close (#482).
+   */
+  prLand?: boolean;
 }
 
 /**
@@ -172,7 +178,7 @@ export function reconcileLandedWorkspace(ws: WorkspaceRecord, preview: Workspace
     metadata: { source: "server", maintenanceJobId: "workspace-conflict-scan", workspaceId: ws.id, fromStatus: ws.status, ...(sha ? { landedSha: sha } : {}) },
   });
   try {
-    notifyBranchLanded({ workspace: ws, mergedSha: sha, pushed: true });
+    notifyBranchLanded({ workspace: ws, mergedSha: sha, pushed: true, prLand: via === "pr" });
   } catch {
     // Notification is best-effort; the merged status + activity event still stand.
   }

package/src/db/schema.ts

@@ -677,7 +677,8 @@ export function initDb(path: string = "agent-relay.db"): Database {
     );
     CREATE INDEX IF NOT EXISTS idx_activity_operator ON activity_events(operator_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_activity_created ON activity_events(created_at);
-    CREATE INDEX IF NOT EXISTS idx_activity_agent ON activity_events(agent_id, created_at); CREATE INDEX IF NOT EXISTS idx_activity_issue ON activity_events(issue_ref_id, created_at); CREATE INDEX IF NOT EXISTS idx_activity_agent_issue ON activity_events(agent_id, issue_ref_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_activity_agent ON activity_events(agent_id, created_at);
+    -- issue_ref_id/issue_action indexes are created in applyMigrations() AFTER the ALTER — never inline here (#483: inline index over a not-yet-migrated column crashes initDb on existing DBs).
 
     CREATE TABLE IF NOT EXISTS channels (
       id TEXT PRIMARY KEY,

package/src/routes/commands.ts

@@ -250,6 +250,9 @@ export const patchCommand: Handler = async (req, params) => {
               subject: prLanded
                 ? cleanString(prLanded.subject, "params.prLanded.subject", { max: 200 })
                 : cleanString(command.result.subject, "result.subject", { max: 200 }),
+              // PR-land subjects carry a trailing `(#PR)` GitHub stamps on the squash — not an
+              // issue. Tell the lifecycle hook so it won't close the PR number as an issue (#482).
+              prLand: Boolean(prLanded),
               newBranch,
               pushed: prLanded ? true : typeof command.result.pushed === "boolean" ? command.result.pushed : undefined,
             });

package/src/services/issue-lifecycle.ts

@@ -22,6 +22,13 @@ export interface LandedIssueLifecycleInput {
   mergedSha?: string;
   subject?: string;
   source?: string;
+  /**
+   * The land happened via a pull request (the squash/merge subject carries a
+   * trailing `(#PR)` that GitHub appends — the PR number, NOT an issue). Bare-backlink
+   * parsing is suppressed in this mode so relay never mistakes the PR number for an
+   * issue to close; GitHub-native keywords + durable association still apply (#482).
+   */
+  prLand?: boolean;
 }
 
 export interface ReopenIssueLifecycleInput {
@@ -44,8 +51,10 @@ export interface IssueLifecycleOptions {
   log?: LogFn;
 }
 
+export type LandIssueRefSource = "association" | "commit" | "backlink";
+
 export type CloseIssueLifecycleResult =
-  | { issueRef: IssueRef; action: "closed"; source: "association" | "commit"; landKey: string }
+  | { issueRef: IssueRef; action: "closed"; source: LandIssueRefSource; landKey: string }
   | { issueRef: IssueRef; action: "skipped"; reason: "already-closed" | "already-processed"; landKey: string }
   | { issueRef: IssueRef; action: "failed"; error: string; landKey: string };
 
@@ -73,6 +82,51 @@ function defaultIssueRepo(): string | undefined {
   return process.env.AGENT_RELAY_DEFAULT_ISSUE_REPO || process.env.GITHUB_REPOSITORY || undefined;
 }
 
+/**
+ * `owner/repo` out of any git remote URL form: `git@github.com:owner/repo.git`,
+ * `https://github.com/owner/repo.git`, `ssh://git@host/owner/repo`, trailing slash/`.git`
+ * optional. Pure — exported for tests.
+ */
+export function parseOwnerRepoFromRemote(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  const match = url.trim().match(/[:/]([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?\/?$/);
+  return match?.[1];
+}
+
+let remoteRepoCache: Map<string, string | undefined> | undefined;
+
+function repoFromGitRemote(repoRoot: string | undefined): string | undefined {
+  if (!repoRoot) return undefined;
+  if (!remoteRepoCache) remoteRepoCache = new Map();
+  if (remoteRepoCache.has(repoRoot)) return remoteRepoCache.get(repoRoot);
+  let repo: string | undefined;
+  try {
+    const proc = Bun.spawnSync(["git", "-C", repoRoot, "remote", "get-url", "origin"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    if (proc.exitCode === 0) repo = parseOwnerRepoFromRemote(Buffer.from(proc.stdout).toString("utf8"));
+  } catch {
+    repo = undefined;
+  }
+  remoteRepoCache.set(repoRoot, repo);
+  return repo;
+}
+
+export function __resetRemoteRepoCacheForTests(): void {
+  remoteRepoCache = undefined;
+}
+
+/**
+ * The repo a bare `#NNN` in a land's commit subject resolves against. Derived per-workspace
+ * from its own git remote so a single relay serving many repos closes the RIGHT repo's issue;
+ * env (`AGENT_RELAY_DEFAULT_ISSUE_REPO`/`GITHUB_REPOSITORY`) is an override/fallback.
+ */
+function landDefaultRepo(workspace: LifecycleWorkspace): string | undefined {
+  return repoFromGitRemote(workspace.repoRoot) ?? defaultIssueRepo();
+}
+
 function cleanText(value: string | undefined): string | undefined {
   const cleaned = value?.trim();
   return cleaned || undefined;
@@ -116,33 +170,57 @@ const CLOSING_KEYWORD_RE = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+([^\n\
 const ISSUE_REF_AT_START_RE = /^(https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/issues\/[0-9]+(?:[/?#][^\s,)]*)?|[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+#[0-9]+|#[0-9]+)/;
 const REF_SEPARATOR_RE = /^(?:\s*,\s*|\s+(?:and|&)\s+)/i;
 
+// A run of issue refs ("#1, #2 and owner/repo#3") starting at the head of `segment`.
+// Bare refs resolve against `fallbackDefaultRepo`; unresolvable ones are skipped so a
+// land never fails here.
+function collectRefRun(segment: string, fallbackDefaultRepo: string | undefined, into: IssueRef[]): void {
+  let rest = segment;
+  while (rest.trim()) {
+    rest = rest.trimStart();
+    const refMatch = rest.match(ISSUE_REF_AT_START_RE);
+    if (!refMatch) break;
+    try {
+      into.push(resolveIssueRefFromString({ ref: refMatch[1]!, defaultRepo: fallbackDefaultRepo }));
+    } catch {
+      // Invalid or bare-without-default refs are ignored; the land itself must never fail here.
+    }
+    rest = rest.slice(refMatch[0].length);
+    const separator = rest.match(REF_SEPARATOR_RE);
+    if (!separator) break;
+    rest = rest.slice(separator[0].length);
+  }
+}
+
 export function parseClosingIssueRefs(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): IssueRef[] {
   if (!text) return [];
   const refs: IssueRef[] = [];
-  for (const match of text.matchAll(CLOSING_KEYWORD_RE)) {
-    let rest = match[1] ?? "";
-    while (rest.trim()) {
-      rest = rest.trimStart();
-      const refMatch = rest.match(ISSUE_REF_AT_START_RE);
-      if (!refMatch) break;
-      try {
-        refs.push(resolveIssueRefFromString({ ref: refMatch[1]!, defaultRepo: fallbackDefaultRepo }));
-      } catch {
-        // Invalid or bare-without-default refs are ignored; the land itself must never fail here.
-      }
-      rest = rest.slice(refMatch[0].length);
-      const separator = rest.match(REF_SEPARATOR_RE);
-      if (!separator) break;
-      rest = rest.slice(separator[0].length);
-    }
-  }
+  for (const match of text.matchAll(CLOSING_KEYWORD_RE)) collectRefRun(match[1] ?? "", fallbackDefaultRepo, refs);
+  return issueRefMap(refs);
+}
+
+// Parenthesized backlink groups: the trailing `(#NNN)` convention agents (and a squash merge)
+// stamp on a subject without a closing keyword. Non-issue parens (conventional-commit scopes
+// like `fix(tokens)`, notes like `(see also)`) carry no `#` and fall out.
+const BACKLINK_GROUP_RE = /\(([^()]*#[0-9]+[^()]*)\)/g;
+
+export function parseBacklinkIssueRefs(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): IssueRef[] {
+  if (!text) return [];
+  const refs: IssueRef[] = [];
+  for (const group of text.matchAll(BACKLINK_GROUP_RE)) collectRefRun(group[1] ?? "", fallbackDefaultRepo, refs);
   return issueRefMap(refs);
 }
 
-export function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): { source: "association" | "commit"; refs: IssueRef[] } {
+export function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): { source: LandIssueRefSource; refs: IssueRef[] } {
   const associated = associatedIssueRefs(input.workspace);
   if (associated.length > 0) return { source: "association", refs: associated };
-  return { source: "commit", refs: parseClosingIssueRefs(input.subject) };
+  const fallbackDefaultRepo = landDefaultRepo(input.workspace);
+  const keyworded = parseClosingIssueRefs(input.subject, fallbackDefaultRepo);
+  if (keyworded.length > 0) return { source: "commit", refs: keyworded };
+  // Bare `(#NNN)` is closing intent in relay-land mode (no PR), but the SAME shape is the
+  // PR number GitHub appends to a squash subject — never close that. Suppress on PR lands;
+  // those rely on GitHub-native keywords + durable association instead (#482).
+  if (input.prLand) return { source: "commit", refs: [] };
+  return { source: "backlink", refs: parseBacklinkIssueRefs(input.subject, fallbackDefaultRepo) };
 }
 
 function closeAuditComment(input: LandedIssueLifecycleInput): string {
@@ -152,7 +230,7 @@ function closeAuditComment(input: LandedIssueLifecycleInput): string {
 
 async function closeIssueRefForLand(
   issueRef: IssueRef,
-  source: "association" | "commit",
+  source: LandIssueRefSource,
   input: LandedIssueLifecycleInput,
   opts: IssueLifecycleOptions,
 ): Promise<CloseIssueLifecycleResult> {
@@ -237,7 +315,7 @@ async function reopenIssuesForRevert(input: LandedIssueLifecycleInput, opts: Iss
 }
 
 export async function handleLandedIssueLifecycle(input: LandedIssueLifecycleInput, opts: IssueLifecycleOptions = {}): Promise<{
-  source: "association" | "commit";
+  source: LandIssueRefSource;
   closed: CloseIssueLifecycleResult[];
   reopened: ReopenIssueLifecycleResult[];
   skipped: string[];