@r_masseater/ops-harbor 0.1.2 → 0.1.4

package/dist/cli.js

@@ -48,10 +48,317 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // ../../packages/ops-harbor-core/src/alerts.ts
+function inferCheckState(checks) {
+  if (checks.length === 0)
+    return "unknown";
+  let hasNeutral = false;
+  for (const check of checks) {
+    if (check.status !== "completed") {
+      return "pending";
+    }
+    const conclusion = (check.conclusion ?? "").toLowerCase();
+    if (["failure", "timed_out", "action_required", "cancelled"].includes(conclusion)) {
+      return "failure";
+    }
+    if (["neutral", "skipped"].includes(conclusion)) {
+      hasNeutral = true;
+    }
+  }
+  return hasNeutral ? "neutral" : "success";
+}
+function inferReviewState(reviews, reviewDecision) {
+  const normalizedDecision = (reviewDecision ?? "").toUpperCase();
+  if (normalizedDecision === "CHANGES_REQUESTED")
+    return "changes_requested";
+  if (normalizedDecision === "APPROVED")
+    return "approved";
+  const latest = reviews.toSorted((a, b) => b.submittedAt.localeCompare(a.submittedAt))[0];
+  return latest?.state ?? "none";
+}
+function inferMergeState(item) {
+  const state = item.mergeStateStatus.toUpperCase();
+  if (item.mergeable === "conflicting" || ["DIRTY", "CONFLICTING"].includes(state)) {
+    return "conflicting";
+  }
+  if (state === "BEHIND")
+    return "behind";
+  if (["BLOCKED", "DRAFT", "UNSTABLE"].includes(state))
+    return "blocked";
+  if (state === "CLEAN" || item.mergeable === "mergeable")
+    return "clean";
+  return "unknown";
+}
+function summarizeStatus(checks, reviews, item) {
+  const checkState = inferCheckState(checks);
+  const reviewState = inferReviewState(reviews, item.reviewDecision);
+  const mergeState = inferMergeState(item);
+  const overall = checkState === "unknown" && reviewState === "none" && mergeState === "unknown" ? "unknown" : checkState === "failure" || reviewState === "changes_requested" || mergeState !== "clean" && mergeState !== "unknown" ? "needs_attention" : checkState === "pending" ? "running" : "healthy";
+  return { overall, checkState, reviewState, mergeState };
+}
+function createAlert(type, severity, title, message, createdAt, source) {
+  return { type, severity, title, message, createdAt, source };
+}
+function deriveAlerts(item, recentEvents = []) {
+  const alerts = [];
+  const now = item.updatedAt;
+  if (item.statusSummary.checkState === "failure") {
+    alerts.push(createAlert("ci_failed", "critical", "CI failed", "One or more required checks failed on the latest head commit.", now, "state"));
+  }
+  if (item.statusSummary.mergeState === "conflicting") {
+    alerts.push(createAlert("conflicted", "critical", "Merge conflicts detected", `Branch ${item.headBranch} conflicts with ${item.baseBranch}.`, now, "state"));
+  }
+  if (item.statusSummary.mergeState === "behind") {
+    alerts.push(createAlert("base_behind", "warning", "Base branch moved ahead", `${item.headBranch} should be rebased or merged with ${item.baseBranch}.`, now, "state"));
+  }
+  if (item.statusSummary.reviewState === "changes_requested") {
+    alerts.push(createAlert("review_changes_requested", "critical", "Changes requested", "A reviewer requested follow-up changes on this work item.", now, "state"));
+  }
+  const reviewCommentEvent = recentEvents.filter((event) => event.type === "review_commented").toSorted((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+  if (reviewCommentEvent) {
+    alerts.push(createAlert("review_commented", "info", "Review comment received", reviewCommentEvent.message, reviewCommentEvent.createdAt, "event"));
+  }
+  const blockers = alerts.filter((alert) => alert.severity !== "info");
+  return { alerts, blockers };
+}
 function hasBlockingAlerts(item) {
   return item.alerts.some((alert) => alert.severity !== "info");
 }
 
+// ../../packages/ops-harbor-core/src/github.ts
+import { createSign } from "crypto";
+function toBase64Url(value) {
+  return Buffer.from(value).toString("base64").replaceAll("=", "").replaceAll("+", "-").replaceAll("/", "_");
+}
+function createAppJwt(appId, privateKeyPem) {
+  const now = Math.floor(Date.now() / 1000);
+  const header = { alg: "RS256", typ: "JWT" };
+  const payload = {
+    iat: now - 60,
+    exp: now + 9 * 60,
+    iss: appId
+  };
+  const encoded = `${toBase64Url(JSON.stringify(header))}.${toBase64Url(JSON.stringify(payload))}`;
+  const signer = createSign("RSA-SHA256");
+  signer.update(encoded);
+  const signature = signer.sign(privateKeyPem);
+  return `${encoded}.${toBase64Url(signature)}`;
+}
+async function createInstallationToken(config, installationId) {
+  const jwt = createAppJwt(config.githubAppId, config.githubPrivateKey);
+  const response = await fetch(`${config.githubApiUrl}/app/installations/${installationId}/access_tokens`, {
+    method: "POST",
+    headers: {
+      Accept: "application/vnd.github+json",
+      Authorization: `Bearer ${jwt}`,
+      "User-Agent": "ops-harbor"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create installation token: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.token;
+}
+async function graphqlRequest(config, installationId, query, variables) {
+  const token = await createInstallationToken(config, installationId);
+  const response = await fetch(`${config.githubApiUrl}/graphql`, {
+    method: "POST",
+    headers: {
+      Accept: "application/vnd.github+json",
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "User-Agent": "ops-harbor"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub GraphQL request failed: ${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (json.errors?.length) {
+    throw new Error(json.errors.map((error) => error.message).join("; "));
+  }
+  if (!json.data) {
+    throw new Error("GitHub GraphQL response did not contain data.");
+  }
+  return json.data;
+}
+function mapChecks(node) {
+  const contexts = node.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? [];
+  return contexts.map((context) => {
+    if (context.__typename === "CheckRun") {
+      return {
+        name: context.name,
+        status: context.status,
+        conclusion: context.conclusion,
+        url: context.detailsUrl ?? null,
+        startedAt: context.startedAt ?? null,
+        completedAt: context.completedAt ?? null
+      };
+    }
+    return {
+      name: context.context,
+      status: context.state === "PENDING" ? "pending" : "completed",
+      conclusion: context.state.toLowerCase(),
+      url: context.targetUrl ?? null,
+      startedAt: context.createdAt ?? null,
+      completedAt: context.createdAt ?? null
+    };
+  });
+}
+function mapReviews(node) {
+  return node.latestReviews.nodes.map((review) => ({
+    id: review.id,
+    state: review.state.toLowerCase(),
+    author: review.author?.login ?? "unknown",
+    submittedAt: review.submittedAt,
+    ...review.body ? { bodySnippet: review.body.slice(0, 240) } : {},
+    ...review.url ? { url: review.url } : {}
+  }));
+}
+function mapPullRequestNode(node, installationId) {
+  const checks = mapChecks(node);
+  const reviews = mapReviews(node);
+  const statusSummary = summarizeStatus(checks, reviews, {
+    mergeable: node.mergeable === "CONFLICTING" ? "conflicting" : node.mergeable === "MERGEABLE" ? "mergeable" : "unknown",
+    mergeStateStatus: node.mergeStateStatus,
+    reviewDecision: node.reviewDecision
+  });
+  return {
+    id: node.id,
+    provider: "github",
+    kind: "pull_request",
+    repository: node.repository.nameWithOwner,
+    number: node.number,
+    title: node.title,
+    url: node.url,
+    state: node.state.toLowerCase(),
+    author: node.author?.login ?? "unknown",
+    isDraft: node.isDraft,
+    headBranch: node.headRefName,
+    headSha: node.headRefOid,
+    baseBranch: node.baseRefName,
+    mergeable: node.mergeable === "CONFLICTING" ? "conflicting" : node.mergeable === "MERGEABLE" ? "mergeable" : "unknown",
+    mergeStateStatus: node.mergeStateStatus,
+    reviewDecision: node.reviewDecision,
+    statusSummary,
+    checks,
+    reviews,
+    alerts: [],
+    lastActivityAt: node.updatedAt,
+    updatedAt: node.updatedAt,
+    providerPayload: {
+      installationId,
+      repositoryUrl: node.repository.url
+    }
+  };
+}
+async function listAppInstallations(config) {
+  const jwt = createAppJwt(config.githubAppId, config.githubPrivateKey);
+  const installations = [];
+  for (let page = 1;; page += 1) {
+    const response = await fetch(`${config.githubApiUrl}/app/installations?per_page=100&page=${page}`, {
+      method: "GET",
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${jwt}`,
+        "User-Agent": "ops-harbor"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to list app installations: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const pageInstallations = Array.isArray(data) ? data : data.installations ?? [];
+    installations.push(...pageInstallations);
+    if (pageInstallations.length < 100) {
+      break;
+    }
+  }
+  return installations;
+}
+async function fetchOpenPullRequestsForAuthor(config, installationId, author, limit = 100) {
+  const items = [];
+  let cursor = null;
+  while (items.length < limit) {
+    const data = await graphqlRequest(config, installationId, SEARCH_QUERY, {
+      query: `is:pr is:open author:${author} archived:false`,
+      first: Math.min(50, limit - items.length),
+      after: cursor
+    });
+    items.push(...data.search.nodes.map((node) => mapPullRequestNode(node, installationId)));
+    if (!data.search.pageInfo.hasNextPage)
+      break;
+    cursor = data.search.pageInfo.endCursor;
+  }
+  return items;
+}
+var SEARCH_QUERY = `
+  query SearchPullRequests($query: String!, $first: Int!, $after: String) {
+    search(query: $query, type: ISSUE, first: $first, after: $after) {
+      pageInfo { hasNextPage endCursor }
+      nodes {
+        ... on PullRequest {
+          id
+          number
+          title
+          url
+          state
+          isDraft
+          mergeable
+          mergeStateStatus
+          reviewDecision
+          updatedAt
+          repository { nameWithOwner url }
+          author { login }
+          baseRefName
+          headRefName
+          headRefOid
+          latestReviews(first: 20) {
+            nodes {
+              id
+              state
+              body
+              submittedAt
+              url
+              author { login }
+            }
+          }
+          commits(last: 1) {
+            nodes {
+              commit {
+                statusCheckRollup {
+                  contexts(first: 50) {
+                    nodes {
+                      __typename
+                      ... on CheckRun {
+                        name
+                        status
+                        conclusion
+                        detailsUrl
+                        startedAt
+                        completedAt
+                      }
+                      ... on StatusContext {
+                        context
+                        state
+                        targetUrl
+                        createdAt
+                        description
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var init_github = () => {};
+
 // ../../packages/ops-harbor-core/src/db-helpers.ts
 function mapWorkItemsToAlertSummaries(workItems) {
   return workItems.map((item) => ({
@@ -152,9 +459,9 @@ var init_port_finder = () => {};
 
 // ../../packages/ops-harbor-core/src/sqlite.ts
 import { createRequire } from "module";
-import { resolve } from "path";
 function openSqliteDatabase(filename) {
-  const db = typeof Bun !== "undefined" ? new (requireFromModule("bun:sqlite")).Database(filename) : new (requireFromWorkingDirectory("better-sqlite3"))(filename);
+  const Ctor = overriddenCtor ?? createRequire(import.meta.url)("bun:sqlite").Database;
+  const db = new Ctor(filename);
   db.exec("PRAGMA journal_mode = WAL");
   return db;
 }
@@ -167,14 +474,12 @@ function parseJson(value, fallback) {
     return fallback;
   }
 }
-var requireFromModule, requireFromWorkingDirectory;
-var init_sqlite = __esm(() => {
-  requireFromModule = createRequire(import.meta.url);
-  requireFromWorkingDirectory = createRequire(resolve(process.cwd(), "package.json"));
-});
+var overriddenCtor;
+var init_sqlite = () => {};
 
 // ../../packages/ops-harbor-core/src/index.ts
 var init_src = __esm(() => {
+  init_github();
   init_filters();
   init_prompt();
   init_port_finder();
@@ -227,6 +532,15 @@ function ensureSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_local_runs_lookup ON automation_runs(work_item_id, finished_at DESC);
   `);
 }
+function upsertWorkItems(db, items) {
+  const tx = db.transaction(() => {
+    const stmt = db.prepare(`INSERT OR REPLACE INTO work_items (id, repository, state, updated_at, payload_json) VALUES (?, ?, ?, ?, ?)`);
+    for (const item of items) {
+      stmt.run(item.id, item.repository, item.state, item.updatedAt, JSON.stringify(item));
+    }
+  });
+  tx();
+}
 function replaceSnapshot(db, workItems, events) {
   const tx = db.transaction(() => {
     db.exec(`DELETE FROM work_items; DELETE FROM activity_events;`);
@@ -277,10 +591,10 @@ function listActivity(db, options = {}) {
 function listAlerts(db) {
   return mapWorkItemsToAlertSummaries(listWorkItems(db, { hasBlocker: true }));
 }
-function recordAutomationRun(db, run) {
+function recordAutomationRun(db, run2) {
   db.prepare(`INSERT OR REPLACE INTO automation_runs (
        id, work_item_id, repository, trigger_type, status, started_at, finished_at, summary
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(run.id, run.workItemId, run.repository, run.triggerType, run.status, run.startedAt, run.finishedAt, run.summary);
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(run2.id, run2.workItemId, run2.repository, run2.triggerType, run2.status, run2.startedAt, run2.finishedAt, run2.summary);
 }
 function listAutomationRuns(db, limit = 100) {
   return db.prepare(`SELECT
@@ -832,7 +1146,7 @@ var require_serve_static2 = __commonJS((exports, module) => {
   });
   module.exports = __toCommonJS(serve_static_exports);
   var import_promises2 = __require("fs/promises");
-  var import_node_path4 = __require("path");
+  var import_node_path3 = __require("path");
   var import_serve_static = require_serve_static();
   var serveStatic2 = (options) => {
     return async function serveStatic22(c, next) {
@@ -851,7 +1165,7 @@ var require_serve_static2 = __commonJS((exports, module) => {
       return (0, import_serve_static.serveStatic)({
         ...options,
         getContent,
-        join: import_node_path4.join,
+        join: import_node_path3.join,
         isDir
       })(c, next);
     };
@@ -1065,10 +1379,10 @@ var require_concurrent = __commonJS((exports, module) => {
       };
     }
     const pool = /* @__PURE__ */ new Set;
-    const run = async (fn, promise, resolve2) => {
+    const run2 = async (fn, promise, resolve) => {
       if (pool.size >= concurrency) {
-        promise ||= new Promise((r) => resolve2 = r);
-        setTimeout(() => run(fn, promise, resolve2));
+        promise ||= new Promise((r) => resolve = r);
+        setTimeout(() => run2(fn, promise, resolve));
         return promise;
       }
       const marker = {};
@@ -1079,14 +1393,14 @@ var require_concurrent = __commonJS((exports, module) => {
       } else {
         pool.delete(marker);
       }
-      if (resolve2) {
-        resolve2(result);
+      if (resolve) {
+        resolve(result);
         return promise;
       } else {
         return result;
       }
     };
-    return { run };
+    return { run: run2 };
   };
 });
 
@@ -1297,7 +1611,7 @@ var require_middleware = __commonJS((exports, module) => {
     ssgParams: () => ssgParams2
   });
   module.exports = __toCommonJS(middleware_exports);
-  var import_utils = require_utils2();
+  var import_utils3 = require_utils2();
   var SSG_CONTEXT = "HONO_SSG_CONTEXT";
   var X_HONO_DISABLE_SSG_HEADER_KEY2 = "x-hono-disable-ssg";
   var SSG_DISABLED_RESPONSE = (() => {
@@ -1311,7 +1625,7 @@ var require_middleware = __commonJS((exports, module) => {
     }
   })();
   var ssgParams2 = (params) => async (c, next) => {
-    if ((0, import_utils.isDynamicRoute)(c.req.path)) {
+    if ((0, import_utils3.isDynamicRoute)(c.req.path)) {
       c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
       return c.notFound();
     }
@@ -1496,10 +1810,10 @@ var require_html2 = __commonJS((exports, module) => {
   var html_exports = {};
   __export2(html_exports, {
     html: () => html,
-    raw: () => import_html2.raw
+    raw: () => import_html3.raw
   });
   module.exports = __toCommonJS(html_exports);
-  var import_html2 = require_html();
+  var import_html3 = require_html();
   var html = (strings, ...values) => {
     const buffer = [""];
     for (let i = 0, len = strings.length - 1;i < len; i++) {
@@ -1508,7 +1822,7 @@ var require_html2 = __commonJS((exports, module) => {
       for (let i2 = 0, len2 = children.length;i2 < len2; i2++) {
         const child = children[i2];
         if (typeof child === "string") {
-          (0, import_html2.escapeToBuffer)(child, buffer);
+          (0, import_html3.escapeToBuffer)(child, buffer);
         } else if (typeof child === "number") {
           buffer[0] += child;
         } else if (typeof child === "boolean" || child === null || child === undefined) {
@@ -1527,12 +1841,12 @@ var require_html2 = __commonJS((exports, module) => {
         } else if (child instanceof Promise) {
           buffer.unshift("", child);
         } else {
-          (0, import_html2.escapeToBuffer)(child.toString(), buffer);
+          (0, import_html3.escapeToBuffer)(child.toString(), buffer);
         }
       }
     }
     buffer[0] += strings.at(-1);
-    return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html2.raw)((0, import_html2.resolveCallbackSync)((0, import_html2.raw)(buffer[0], buffer.callbacks))) : (0, import_html2.raw)(buffer[0]) : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+    return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html3.raw)((0, import_html3.resolveCallbackSync)((0, import_html3.raw)(buffer[0], buffer.callbacks))) : (0, import_html3.raw)(buffer[0]) : (0, import_html3.stringBufferToString)(buffer, buffer.callbacks);
   };
 });
 
@@ -1561,7 +1875,7 @@ var require_plugins = __commonJS((exports, module) => {
     redirectPlugin: () => redirectPlugin2
   });
   module.exports = __toCommonJS(plugins_exports);
-  var import_html2 = require_html2();
+  var import_html3 = require_html2();
   var defaultPlugin2 = () => {
     return {
       afterResponseHook: (res) => {
@@ -1574,7 +1888,7 @@ var require_plugins = __commonJS((exports, module) => {
   };
   var REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
   var generateRedirectHtml = (location) => {
-    const content = import_html2.html`<!DOCTYPE html>
+    const content = import_html3.html`<!DOCTYPE html>
 <title>Redirecting to: ${location}</title>
 <meta http-equiv="refresh" content="0;url=${location}" />
 <meta name="robots" content="noindex" />
@@ -1636,27 +1950,27 @@ var require_ssg = __commonJS((exports, module) => {
     toSSG: () => toSSG2
   });
   module.exports = __toCommonJS(ssg_exports);
-  var import_utils = require_utils();
+  var import_utils3 = require_utils();
   var import_concurrent = require_concurrent();
   var import_mime = require_mime();
   var import_middleware = require_middleware();
   var import_plugins = require_plugins();
-  var import_utils2 = require_utils2();
+  var import_utils22 = require_utils2();
   var DEFAULT_CONCURRENCY = 2;
   var DEFAULT_CONTENT_TYPE = "text/plain";
   var DEFAULT_OUTPUT_DIR = "./static";
   var generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
     const extension = determineExtension(mimeType, extensionMap);
     if (routePath.endsWith(`.${extension}`)) {
-      return (0, import_utils2.joinPaths)(outDir, routePath);
+      return (0, import_utils22.joinPaths)(outDir, routePath);
     }
     if (routePath === "/") {
-      return (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
+      return (0, import_utils22.joinPaths)(outDir, `index.${extension}`);
     }
     if (routePath.endsWith("/")) {
-      return (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
+      return (0, import_utils22.joinPaths)(outDir, routePath, `index.${extension}`);
     }
-    return (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
+    return (0, import_utils22.joinPaths)(outDir, `${routePath}.${extension}`);
   };
   var parseResponseContent = async (response) => {
     const contentType = response.headers.get("Content-Type");
@@ -1732,7 +2046,7 @@ var require_ssg = __commonJS((exports, module) => {
   var fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
     const baseURL = "http://localhost";
     const pool = (0, import_concurrent.createPool)({ concurrency });
-    for (const route of (0, import_utils2.filterStaticGenerateRoutes)(app)) {
+    for (const route of (0, import_utils22.filterStaticGenerateRoutes)(app)) {
       const thisRouteBaseURL = new URL(route.path, baseURL).toString();
       let forGetInfoURLRequest = new Request(thisRouteBaseURL);
       yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
@@ -1747,7 +2061,7 @@ var require_ssg = __commonJS((exports, module) => {
           }
           await pool.run(() => app.fetch(forGetInfoURLRequest, { [import_middleware.SSG_CONTEXT]: true }));
           if (!forGetInfoURLRequest.ssgParams) {
-            if ((0, import_utils2.isDynamicRoute)(route.path)) {
+            if ((0, import_utils22.isDynamicRoute)(route.path)) {
               resolveGetInfo(undefined);
               return;
             }
@@ -1761,7 +2075,7 @@ var require_ssg = __commonJS((exports, module) => {
             for (const param of forGetInfoURLRequest.ssgParams) {
               yield new Promise(async (resolveReq, rejectReq) => {
                 try {
-                  const replacedUrlParam = (0, import_utils.replaceUrlParam)(route.path, param);
+                  const replacedUrlParam = (0, import_utils3.replaceUrlParam)(route.path, param);
                   let response = await pool.run(() => app.request(replacedUrlParam, requestInit, {
                     [import_middleware.SSG_CONTEXT]: true
                   }));
@@ -1804,7 +2118,7 @@ var require_ssg = __commonJS((exports, module) => {
     }
     const { routePath, content, mimeType } = awaitedData;
     const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
-    const dirPath = (0, import_utils2.dirname)(filePath);
+    const dirPath = (0, import_utils22.dirname)(filePath);
     if (!createdDirs.has(dirPath)) {
       await fsModule.mkdir(dirPath, { recursive: true });
       createdDirs.add(dirPath);
@@ -8779,7 +9093,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -8791,7 +9105,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -8869,7 +9183,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve3(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -9060,12 +9374,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve3, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -12050,7 +12364,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve3.call(this, root, ref);
+    let _sch = resolve2.call(this, root, ref);
     if (_sch === undefined) {
       const schema = (_a2 = root.localRefs) === null || _a2 === undefined ? undefined : _a2[ref];
       const { schemaId } = this.opts;
@@ -12077,7 +12391,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve3(root, ref) {
+  function resolve2(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -12607,7 +12921,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve3(baseURI, relativeURI, options) {
+  function resolve2(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -12835,7 +13149,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve3,
+    resolve: resolve2,
     resolveComponent,
     equal,
     serialize,
@@ -16218,12 +16532,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve3();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve3);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -18011,8 +18325,150 @@ var cors = (options) => {
   };
 };
 
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  aborted = false;
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder;
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        this.abort();
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {}
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + `
+`);
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    try {
+      await this.writer.close();
+    } catch {}
+    this.closed = true;
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    await body.pipeTo(this.writable, { preventClose: true });
+    this.writer = this.writable.getWriter();
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : undefined;
+  if (version === undefined) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join(`
+`);
+    for (const key of ["event", "id", "retry"]) {
+      if (message[key] && /[\r\n]/.test(message[key])) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join(`
+`) + `
+
+`;
+    await this.write(sseData);
+  }
+};
+var run = async (stream, cb, onError) => {
+  try {
+    await cb(stream);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream);
+      await stream.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap;
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream;
+  const stream = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
+  contextStash.set(stream.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream, cb, onError);
+  return c.newResponse(stream.responseReadable);
+};
+
 // src/server.ts
-import { join as join3, resolve as resolve2 } from "path";
+import { join as join3, resolve } from "path";
 
 // src/lib/automation.ts
 init_src();
@@ -18596,7 +19052,7 @@ function isTriggerDisabled(config, repository, workItem, trigger) {
 }
 function runCommand(command, args, options = {}) {
   const timeoutMs = options.timeoutMs ?? 300000;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: {
@@ -18631,7 +19087,7 @@ function runCommand(command, args, options = {}) {
     });
     child.on("close", (exitCode) => {
       clearTimeout(timeout);
-      resolve2({
+      resolve({
         exitCode: exitCode ?? 1,
         stdout: stdout.trim(),
         stderr: stderr.trim()
@@ -18787,7 +19243,7 @@ var cachedLogin = null;
 var cachedAt = 0;
 var inFlight = null;
 function runGhCommand(args) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn2("gh", args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -18801,7 +19257,7 @@ function runGhCommand(args) {
     });
     child.on("error", reject);
     child.on("close", (exitCode) => {
-      resolve2({
+      resolve({
         exitCode: exitCode ?? 1,
         stdout: stdout.trim(),
         stderr: stderr.trim()
@@ -18840,6 +19296,9 @@ var ConfigSchema = object({
   controlPlaneUrl: pipe(string(), minLength(1)),
   authorLogin: optional(string()),
   internalApiToken: optional(string()),
+  githubAppId: optional(pipe(string(), minLength(1))),
+  githubPrivateKey: optional(pipe(string(), minLength(1))),
+  githubApiUrl: optional(pipe(string(), minLength(1))),
   syncIntervalSeconds: number(),
   automationPollSeconds: number(),
   runner: optional(object({
@@ -18877,7 +19336,7 @@ var ConfigSchema = object({
 function defaultConfig() {
   return {
     controlPlaneUrl: "http://127.0.0.1:4130",
-    syncIntervalSeconds: 60,
+    syncIntervalSeconds: 300,
     automationPollSeconds: 20,
     repositories: [],
     pullRequestOverrides: []
@@ -18905,6 +19364,9 @@ function normalizeConfig(config) {
     syncIntervalSeconds: config.syncIntervalSeconds,
     automationPollSeconds: config.automationPollSeconds,
     ...config.internalApiToken ? { internalApiToken: config.internalApiToken } : {},
+    ...config.githubAppId ? { githubAppId: config.githubAppId } : {},
+    ...config.githubPrivateKey ? { githubPrivateKey: config.githubPrivateKey } : {},
+    ...config.githubApiUrl ? { githubApiUrl: config.githubApiUrl } : {},
     repositories: config.repositories.map((repository) => ({
       repository: repository.repository,
       path: repository.path,
@@ -18942,6 +19404,35 @@ function withDetectedAuthorLogin(config, detectedAuthorLogin) {
 // src/server.ts
 init_local_db();
 
+// src/lib/github-sync.ts
+init_src();
+init_local_db();
+function toGitHubAppConfig(config) {
+  if (!config.githubAppId || !config.githubPrivateKey) {
+    throw new Error("GitHub App is not configured. Set githubAppId and githubPrivateKey in config.");
+  }
+  return {
+    githubAppId: config.githubAppId,
+    githubPrivateKey: config.githubPrivateKey,
+    githubApiUrl: config.githubApiUrl ?? "https://api.github.com"
+  };
+}
+async function syncAuthorPrs(db, config) {
+  const appConfig = toGitHubAppConfig(config);
+  if (!config.authorLogin) {
+    throw new Error("authorLogin is not configured.");
+  }
+  const installations = await listAppInstallations(appConfig);
+  const allItems = await Promise.all(installations.map((inst) => fetchOpenPullRequestsForAuthor(appConfig, inst.id, config.authorLogin)));
+  const items = allItems.flat();
+  for (const item of items) {
+    const { alerts } = deriveAlerts(item);
+    item.alerts = alerts;
+  }
+  upsertWorkItems(db, items);
+  return { synchronized: items.length };
+}
+
 // src/lib/sync.ts
 init_local_db();
 async function syncFromControlPlane(db, config) {
@@ -18965,6 +19456,19 @@ async function syncFromControlPlane(db, config) {
 }
 
 // src/server.ts
+function createEventBus() {
+  const listeners = new Set;
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    broadcast(event, data) {
+      for (const listener of listeners)
+        listener(event, data);
+    }
+  };
+}
 function runExclusive(guard, fn) {
   if (guard.promise)
     return guard.promise;
@@ -18974,13 +19478,30 @@ function runExclusive(guard, fn) {
   return guard.promise;
 }
 function createLocalApp(db = openLocalDb()) {
+  const bus = createEventBus();
   const state = {
     db,
+    bus,
     syncGuard: { promise: null },
     workerGuard: { promise: null }
   };
   const app = new Hono2;
   app.use("/api/*", cors());
+  app.get("/api/events", (c) => {
+    return streamSSE(c, async (stream2) => {
+      const unsubscribe = bus.subscribe((event, data) => {
+        stream2.writeSSE({ event, data: JSON.stringify(data) });
+      });
+      const heartbeat = setInterval(() => {
+        stream2.writeSSE({ event: "heartbeat", data: "{}" });
+      }, 30000);
+      stream2.onAbort(() => {
+        clearInterval(heartbeat);
+        unsubscribe();
+      });
+      await new Promise(() => {});
+    });
+  });
   app.get("/api/health", (_c) => {
     return Response.json({ ok: true });
   });
@@ -19001,6 +19522,18 @@ function createLocalApp(db = openLocalDb()) {
       return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
     }
   });
+  app.post("/api/sync/author", async (c) => {
+    if (state.syncGuard.promise) {
+      return c.json({ error: "sync already in progress" }, 409);
+    }
+    try {
+      const config = await loadConfig();
+      const result = await runExclusive(state.syncGuard, () => syncAuthorPrs(state.db, config));
+      return c.json(result);
+    } catch (error) {
+      return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+    }
+  });
   app.get("/api/work-items", (c) => c.json(listWorkItems(state.db, parseWorkItemFilterFromQuery((key) => c.req.query(key)))));
   app.get("/api/work-items/:id", (c) => {
     const item = getWorkItem(state.db, c.req.param("id"));
@@ -19023,19 +19556,69 @@ function createLocalApp(db = openLocalDb()) {
   return app;
 }
 async function runSync(state, config) {
-  return runExclusive(state.syncGuard, async () => {
+  const result = await runExclusive(state.syncGuard, async () => {
     const currentConfig = config ?? await loadConfig();
     return syncFromControlPlane(state.db, currentConfig);
   });
+  state.bus.broadcast("sync_completed", {});
+  return result;
 }
 async function runWorker(state, config) {
-  return runExclusive(state.workerGuard, async () => {
+  const result = await runExclusive(state.workerGuard, async () => {
     const currentConfig = config ?? await loadConfig();
     return processNextAutomationJob(state.db, currentConfig, "ops-harbor-local");
   });
+  state.bus.broadcast("automation_completed", {});
+  return result;
 }
 function delay(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function subscribeToControlPlane(state) {
+  const connect = async () => {
+    try {
+      const config = await loadConfig();
+      const url = `${config.controlPlaneUrl}/api/events`;
+      const headers = { Accept: "text/event-stream" };
+      if (config.internalApiToken) {
+        headers["x-ops-harbor-token"] = config.internalApiToken;
+      }
+      const response = await fetch(url, { headers });
+      if (!response.ok || !response.body) {
+        throw new Error(`CP SSE connection failed: ${String(response.status)}`);
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder;
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() ?? "";
+        let currentEvent = "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            currentEvent = line.slice(7).trim();
+          } else if (line.startsWith("data: ") && currentEvent) {
+            if (currentEvent === "webhook_processed" || currentEvent === "sync_completed") {
+              runSync(state);
+            }
+            currentEvent = "";
+          } else if (line === "") {
+            currentEvent = "";
+          }
+        }
+      }
+    } catch (error) {
+      console.error("CP SSE error, reconnecting in 5s", error);
+    }
+    await delay(5000);
+    subscribeToControlPlane(state);
+  };
+  connect();
 }
 async function startBackgroundLoops(state) {
   const runSyncLoop = async () => {
@@ -19064,10 +19647,11 @@ async function startBackgroundLoops(state) {
   };
   runSyncLoop();
   runWorkerLoop();
+  subscribeToControlPlane(state);
 }
 function createServedApp() {
   const { serveStatic: serveStatic2 } = require_bun();
-  const distDir = import.meta.dir.endsWith("/src") ? resolve2(import.meta.dir, "../dist") : import.meta.dir;
+  const distDir = import.meta.dir.endsWith("/src") ? resolve(import.meta.dir, "../dist") : import.meta.dir;
   const clientDir = join3(distDir, "client");
   const app = createLocalApp();
   app.use("/*", serveStatic2({ root: clientDir }));