@mndrk/agx 2.4.4 → 2.4.6

package/cloud-runtime/standalone/apps/local/lib/github-link-resolver.ts

@@ -0,0 +1,65 @@
+import type { PrLinkSource, TrackerTargetType } from "./github-types";
+
+export const ID_PATTERN = /(?<![A-Za-z0-9])[A-Z]+-\d+(?![A-Za-z0-9])/;
+const ID_PATTERN_GLOBAL = new RegExp(ID_PATTERN, "g");
+
+export interface ExtractedId {
+  id: string;
+  source: Exclude<PrLinkSource, "manual">;
+}
+
+export interface PrLinkInput {
+  headRef: string;
+  title: string;
+  body: string;
+}
+
+export function extractTrackerIds(input: PrLinkInput): ExtractedId[] {
+  const out: ExtractedId[] = [];
+  const seen = new Set<string>();
+  const fields: Array<[string, ExtractedId["source"]]> = [
+    [input.headRef, "branch"],
+    [input.title, "title"],
+    [input.body, "body"],
+  ];
+  for (const [text, source] of fields) {
+    const matches = text.match(ID_PATTERN_GLOBAL) ?? [];
+    for (const raw of matches) {
+      const id = raw.toUpperCase();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      out.push({ id, source });
+    }
+  }
+  return out;
+}
+
+export type TrackerResolver = (
+  id: string,
+) => Promise<{ targetType: TrackerTargetType; targetId: string } | null>;
+
+export interface ResolvedPrLink {
+  targetType: TrackerTargetType;
+  targetId: string;
+  linkSource: Exclude<PrLinkSource, "manual">;
+}
+
+export async function resolvePrLink(
+  input: PrLinkInput,
+  resolvers: TrackerResolver[],
+): Promise<ResolvedPrLink | null> {
+  const ids = extractTrackerIds(input);
+  for (const extracted of ids) {
+    for (const resolver of resolvers) {
+      const match = await resolver(extracted.id);
+      if (match) {
+        return {
+          targetType: match.targetType,
+          targetId: match.targetId,
+          linkSource: extracted.source,
+        };
+      }
+    }
+  }
+  return null;
+}

package/cloud-runtime/standalone/apps/local/lib/github-oauth-sessions.ts

@@ -0,0 +1,55 @@
+import crypto from "node:crypto";
+
+interface OAuthSession {
+  projectId: string;
+  createdAt: number;
+}
+
+const TTL_MS = 10 * 60 * 1000;
+
+const sessions = new Map<string, OAuthSession>();
+
+function prune(now: number): void {
+  for (const [key, session] of sessions) {
+    if (now - session.createdAt > TTL_MS) {
+      sessions.delete(key);
+    }
+  }
+}
+
+export function createOAuthSession(projectId: string): string {
+  const now = Date.now();
+  prune(now);
+  const token = crypto.randomBytes(16).toString("hex");
+  sessions.set(token, { projectId, createdAt: now });
+  return token;
+}
+
+export function consumeOAuthSession(token: string): OAuthSession | null {
+  const now = Date.now();
+  prune(now);
+  const session = sessions.get(token);
+  if (!session) return null;
+  if (now - session.createdAt > TTL_MS) {
+    sessions.delete(token);
+    return null;
+  }
+  sessions.delete(token);
+  return session;
+}
+
+export function peekOAuthSession(token: string): OAuthSession | null {
+  const now = Date.now();
+  prune(now);
+  const session = sessions.get(token);
+  if (!session) return null;
+  if (now - session.createdAt > TTL_MS) {
+    sessions.delete(token);
+    return null;
+  }
+  return session;
+}
+
+export function __clearOAuthSessionsForTest(): void {
+  sessions.clear();
+}

package/cloud-runtime/standalone/apps/local/lib/github-pr-context.ts

@@ -0,0 +1,125 @@
+import { GithubClient } from "./github-client";
+import { loadGithubTokens } from "./github-token-store";
+import {
+  getGithubPr,
+  listPrComments,
+  upsertPrComments,
+} from "./github-pr-store";
+import { listPrFiles, upsertPrFiles } from "./github-pr-files-store";
+import { logger } from "./logger";
+import type { GithubPr, GithubPrComment, GithubPrFile } from "./github-types";
+
+const MAX_PATCH_CHARS = 1500;
+const MAX_FILES = 50;
+const MAX_COMMENTS = 50;
+const FRESH_MS = 10 * 60 * 1000;
+
+function parseRepoId(repoId: string): { owner: string; name: string } | null {
+  const [owner, name] = repoId.split("/");
+  if (!owner || !name) return null;
+  return { owner, name };
+}
+
+export function formatPrContext(
+  pr: GithubPr,
+  comments: GithubPrComment[],
+  files: GithubPrFile[],
+): string {
+  const sections: string[] = [];
+  sections.push(
+    [
+      `PR CONTEXT — ${pr.id}`,
+      `Title: ${pr.title}`,
+      `Author: ${pr.authorLogin || "unknown"}`,
+      `State: ${pr.state}${pr.draft ? " (draft)" : ""}`,
+      `Branch: ${pr.headRef} → ${pr.baseRef}`,
+      `URL: ${pr.url}`,
+    ].join("\n"),
+  );
+  sections.push(`DESCRIPTION\n${pr.body?.trim() || "(no description)"}`);
+
+  if (comments.length > 0) {
+    const shown = comments.slice(-MAX_COMMENTS);
+    const lines = shown.map((c) => {
+      const loc =
+        c.kind === "review_comment" && c.path
+          ? ` [${c.path}${c.line != null ? `:${c.line}` : ""}]`
+          : "";
+      return `- @${c.authorLogin || "unknown"}${loc}: ${c.body?.trim() || ""}`;
+    });
+    sections.push(`COMMENTS (${comments.length})\n${lines.join("\n")}`);
+  }
+
+  if (files.length > 0) {
+    const shown = files.slice(0, MAX_FILES);
+    const lines = shown.map((f) => {
+      const header = `- ${f.path} [${f.status}] +${f.additions}/-${f.deletions}`;
+      if (!f.patch) return header;
+      const patch =
+        f.patch.length > MAX_PATCH_CHARS
+          ? f.patch.slice(0, MAX_PATCH_CHARS) + "\n…(truncated)"
+          : f.patch;
+      return `${header}\n\`\`\`diff\n${patch}\n\`\`\``;
+    });
+    const more =
+      files.length > MAX_FILES ? `\n…and ${files.length - MAX_FILES} more files` : "";
+    sections.push(`FILES CHANGED (${files.length})\n${lines.join("\n")}${more}`);
+  }
+
+  return sections.join("\n\n");
+}
+
+export interface PrContextResult {
+  pr: GithubPr;
+  context: string;
+  counts: { comments: number; files: number };
+}
+
+/**
+ * Loads a PR with its comments and files, refreshing from GitHub when the
+ * cached data is stale or missing. Returns null if the PR is unknown.
+ */
+export async function ensurePrContext(
+  projectId: string,
+  prId: string,
+  opts: { refresh?: boolean } = {},
+): Promise<PrContextResult | null> {
+  const pr = getGithubPr(prId);
+  if (!pr) return null;
+
+  let comments = listPrComments(prId);
+  let files = listPrFiles(prId);
+
+  const commentsStale =
+    comments.length === 0 ||
+    comments.some((c) => Date.now() - (c.updatedAt || 0) > FRESH_MS);
+  const filesStale =
+    files.length === 0 ||
+    files.some((f) => Date.now() - f.lastSyncedAt > FRESH_MS);
+
+  if (opts.refresh || commentsStale || filesStale) {
+    const tokens = loadGithubTokens(projectId);
+    const repo = parseRepoId(pr.repoId);
+    if (tokens && repo) {
+      const client = new GithubClient({ tokens });
+      try {
+        const [freshComments, freshFiles] = await Promise.all([
+          client.listPullRequestComments({ ...repo, number: pr.number }),
+          client.listPullRequestFiles({ ...repo, number: pr.number }),
+        ]);
+        upsertPrComments(freshComments);
+        upsertPrFiles(freshFiles);
+        comments = listPrComments(prId);
+        files = listPrFiles(prId);
+      } catch (err) {
+        logger.error("pr context fetch failed", logger.formatError(err));
+      }
+    }
+  }
+
+  return {
+    pr,
+    context: formatPrContext(pr, comments, files),
+    counts: { comments: comments.length, files: files.length },
+  };
+}

package/cloud-runtime/standalone/apps/local/lib/github-pr-files-store.ts

@@ -0,0 +1,59 @@
+import type { GithubPrFile } from "./github-types";
+import { withGithubDatabase } from "./github-db";
+
+function rowToFile(row: Record<string, unknown>): GithubPrFile {
+  return {
+    prId: String(row.pr_id),
+    path: String(row.path),
+    status: String(row.status),
+    additions: Number(row.additions),
+    deletions: Number(row.deletions),
+    changes: Number(row.changes),
+    patch: (row.patch as string | null) ?? null,
+    lastSyncedAt: Number(row.last_synced_at),
+  };
+}
+
+export function upsertPrFiles(files: GithubPrFile[]): void {
+  if (files.length === 0) return;
+  withGithubDatabase((db) => {
+    const stmt = db.prepare(
+      `INSERT INTO github_pr_files (pr_id, path, status, additions, deletions, changes, patch, last_synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(pr_id, path) DO UPDATE SET
+         status = excluded.status,
+         additions = excluded.additions,
+         deletions = excluded.deletions,
+         changes = excluded.changes,
+         patch = excluded.patch,
+         last_synced_at = excluded.last_synced_at`,
+    );
+    for (const f of files) {
+      stmt.run(
+        f.prId,
+        f.path,
+        f.status,
+        f.additions,
+        f.deletions,
+        f.changes,
+        f.patch,
+        f.lastSyncedAt,
+      );
+    }
+  });
+}
+
+export function listPrFiles(prId: string): GithubPrFile[] {
+  return withGithubDatabase((db) => {
+    const rows = db
+      .prepare(`SELECT * FROM github_pr_files WHERE pr_id = ? ORDER BY path ASC`)
+      .all(prId) as Record<string, unknown>[];
+    return rows.map(rowToFile);
+  });
+}
+
+export function deletePrFiles(prId: string): void {
+  withGithubDatabase((db) => {
+    db.prepare(`DELETE FROM github_pr_files WHERE pr_id = ?`).run(prId);
+  });
+}

package/cloud-runtime/standalone/apps/local/lib/github-pr-store.ts

@@ -0,0 +1,250 @@
+import type {
+  GithubPr,
+  GithubPrComment,
+  GithubReviewer,
+  PrLink,
+  PrLinkSource,
+  TrackerTargetType,
+} from "./github-types";
+import { withGithubDatabase } from "./github-db";
+
+function parseJsonArray<T>(v: unknown, fallback: T[]): T[] {
+  if (typeof v !== "string" || v.length === 0) return fallback;
+  try {
+    const parsed = JSON.parse(v);
+    return Array.isArray(parsed) ? (parsed as T[]) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function rowToPr(row: Record<string, unknown>): GithubPr {
+  return {
+    id: String(row.id),
+    repoId: String(row.repo_id),
+    number: Number(row.number),
+    title: String(row.title),
+    body: String(row.body),
+    state: row.state as GithubPr["state"],
+    draft: Number(row.draft) === 1,
+    authorLogin: String(row.author_login),
+    headRef: String(row.head_ref),
+    headSha: String(row.head_sha),
+    baseRef: String(row.base_ref),
+    url: String(row.url),
+    ciStatus: (row.ci_status as GithubPr["ciStatus"]) ?? null,
+    reviewDecision: (row.review_decision as GithubPr["reviewDecision"]) ?? null,
+    assignees: parseJsonArray<string>(row.assignees_json, []),
+    reviewers: parseJsonArray<GithubReviewer>(row.reviewers_json, []),
+    labels: parseJsonArray<string>(row.labels_json, []),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    mergedAt: row.merged_at == null ? null : Number(row.merged_at),
+    closedAt: row.closed_at == null ? null : Number(row.closed_at),
+    lastSyncedAt: Number(row.last_synced_at),
+  };
+}
+
+export function upsertGithubPr(pr: GithubPr): void {
+  withGithubDatabase((db) => {
+    db.prepare(
+      `INSERT INTO github_prs (id, repo_id, number, title, body, state, draft, author_login, head_ref, head_sha, base_ref, url, ci_status, review_decision, assignees_json, reviewers_json, labels_json, created_at, updated_at, merged_at, closed_at, last_synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         title = excluded.title,
+         body = excluded.body,
+         state = excluded.state,
+         draft = excluded.draft,
+         author_login = excluded.author_login,
+         head_ref = excluded.head_ref,
+         head_sha = excluded.head_sha,
+         base_ref = excluded.base_ref,
+         url = excluded.url,
+         ci_status = excluded.ci_status,
+         review_decision = excluded.review_decision,
+         assignees_json = excluded.assignees_json,
+         reviewers_json = excluded.reviewers_json,
+         labels_json = excluded.labels_json,
+         updated_at = excluded.updated_at,
+         merged_at = excluded.merged_at,
+         closed_at = excluded.closed_at,
+         last_synced_at = excluded.last_synced_at`,
+    ).run(
+      pr.id,
+      pr.repoId,
+      pr.number,
+      pr.title,
+      pr.body,
+      pr.state,
+      pr.draft ? 1 : 0,
+      pr.authorLogin,
+      pr.headRef,
+      pr.headSha,
+      pr.baseRef,
+      pr.url,
+      pr.ciStatus,
+      pr.reviewDecision,
+      JSON.stringify(pr.assignees),
+      JSON.stringify(pr.reviewers),
+      JSON.stringify(pr.labels),
+      pr.createdAt,
+      pr.updatedAt,
+      pr.mergedAt,
+      pr.closedAt,
+      pr.lastSyncedAt,
+    );
+  });
+}
+
+export function getGithubPr(id: string): GithubPr | null {
+  return withGithubDatabase((db) => {
+    const row = db.prepare(`SELECT * FROM github_prs WHERE id = ?`).get(id) as
+      | Record<string, unknown>
+      | undefined;
+    return row ? rowToPr(row) : null;
+  });
+}
+
+export interface ListGithubPrsInput {
+  repoId?: string;
+  state?: GithubPr["state"];
+  limit?: number;
+}
+
+export function listGithubPrs(input: ListGithubPrsInput = {}): GithubPr[] {
+  return withGithubDatabase((db) => {
+    const clauses: string[] = [];
+    const params: (string | number | null)[] = [];
+    if (input.repoId) {
+      clauses.push("repo_id = ?");
+      params.push(input.repoId);
+    }
+    if (input.state) {
+      clauses.push("state = ?");
+      params.push(input.state);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const limit = input.limit && input.limit > 0 ? `LIMIT ${Math.min(input.limit, 500)}` : "LIMIT 500";
+    const rows = db
+      .prepare(`SELECT * FROM github_prs ${where} ORDER BY updated_at DESC ${limit}`)
+      .all(...params) as Record<string, unknown>[];
+    return rows.map(rowToPr);
+  });
+}
+
+export function deleteGithubPr(id: string): void {
+  withGithubDatabase((db) => {
+    db.prepare(`DELETE FROM pr_links WHERE pr_id = ?`).run(id);
+    db.prepare(`DELETE FROM github_pr_comments WHERE pr_id = ?`).run(id);
+    db.prepare(`DELETE FROM github_prs WHERE id = ?`).run(id);
+  });
+}
+
+export interface UpsertPrLinkInput {
+  prId: string;
+  targetType: TrackerTargetType;
+  targetId: string;
+  linkSource: PrLinkSource;
+}
+
+function rowToLink(row: Record<string, unknown>): PrLink {
+  return {
+    prId: String(row.pr_id),
+    targetType: row.target_type as TrackerTargetType,
+    targetId: String(row.target_id),
+    linkSource: row.link_source as PrLinkSource,
+    createdAt: Number(row.created_at),
+  };
+}
+
+export function upsertPrLink(input: UpsertPrLinkInput): void {
+  const now = Date.now();
+  withGithubDatabase((db) => {
+    db.prepare(
+      `INSERT INTO pr_links (pr_id, target_type, target_id, link_source, created_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(pr_id, target_type, target_id) DO UPDATE SET
+         link_source = excluded.link_source`,
+    ).run(input.prId, input.targetType, input.targetId, input.linkSource, now);
+  });
+}
+
+export function listPrLinksForPr(prId: string): PrLink[] {
+  return withGithubDatabase((db) => {
+    const rows = db
+      .prepare(`SELECT * FROM pr_links WHERE pr_id = ? ORDER BY created_at ASC`)
+      .all(prId) as Record<string, unknown>[];
+    return rows.map(rowToLink);
+  });
+}
+
+export function listPrLinksForTarget(
+  targetType: TrackerTargetType,
+  targetId: string,
+): PrLink[] {
+  return withGithubDatabase((db) => {
+    const rows = db
+      .prepare(
+        `SELECT * FROM pr_links WHERE target_type = ? AND target_id = ? ORDER BY created_at ASC`,
+      )
+      .all(targetType, targetId) as Record<string, unknown>[];
+    return rows.map(rowToLink);
+  });
+}
+
+export function deletePrLink(
+  prId: string,
+  targetType: TrackerTargetType,
+  targetId: string,
+): void {
+  withGithubDatabase((db) => {
+    db.prepare(
+      `DELETE FROM pr_links WHERE pr_id = ? AND target_type = ? AND target_id = ?`,
+    ).run(prId, targetType, targetId);
+  });
+}
+
+export function deleteAutoPrLinks(prId: string): void {
+  withGithubDatabase((db) => {
+    db.prepare(`DELETE FROM pr_links WHERE pr_id = ? AND link_source != 'manual'`).run(prId);
+  });
+}
+
+function rowToComment(row: Record<string, unknown>): GithubPrComment {
+  return {
+    id: String(row.id),
+    prId: String(row.pr_id),
+    kind: row.kind as GithubPrComment["kind"],
+    authorLogin: String(row.author_login),
+    body: String(row.body),
+    path: (row.path as string | null) ?? null,
+    line: row.line == null ? null : Number(row.line),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+  };
+}
+
+export function upsertPrComments(comments: GithubPrComment[]): void {
+  if (comments.length === 0) return;
+  withGithubDatabase((db) => {
+    const stmt = db.prepare(
+      `INSERT INTO github_pr_comments (id, pr_id, kind, author_login, body, path, line, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         body = excluded.body,
+         updated_at = excluded.updated_at`,
+    );
+    for (const c of comments) {
+      stmt.run(c.id, c.prId, c.kind, c.authorLogin, c.body, c.path, c.line, c.createdAt, c.updatedAt);
+    }
+  });
+}
+
+export function listPrComments(prId: string): GithubPrComment[] {
+  return withGithubDatabase((db) => {
+    const rows = db
+      .prepare(`SELECT * FROM github_pr_comments WHERE pr_id = ? ORDER BY created_at ASC`)
+      .all(prId) as Record<string, unknown>[];
+    return rows.map(rowToComment);
+  });
+}

package/cloud-runtime/standalone/apps/local/lib/github-prs.ts

@@ -0,0 +1,67 @@
+import { GithubClient } from "./github-client";
+import {
+  upsertGithubPr,
+  deleteAutoPrLinks,
+  upsertPrLink,
+} from "./github-pr-store";
+import { upsertGithubIssue } from "./github-issue-store";
+import { markRepoSynced } from "./github-repo-store";
+import { resolvePrLink, type TrackerResolver } from "./github-link-resolver";
+import type { GithubPr } from "./github-types";
+
+export interface SyncRepoInput {
+  repoId: string;
+  client: Pick<GithubClient, "listPullRequests"> &
+    Partial<Pick<GithubClient, "enrichPrStatus" | "listIssues">>;
+  resolvers: TrackerResolver[];
+  /** When true, skip the AGX_GITHUB_ENABLED env gate (user-initiated sync). */
+  force?: boolean;
+  /** When true, also fetch and upsert issues. Defaults to false for back-compat. */
+  includeIssues?: boolean;
+}
+
+function isEnabled(): boolean {
+  return process.env.AGX_GITHUB_ENABLED === "1";
+}
+
+function parseRepoId(repoId: string): { owner: string; name: string } {
+  const [owner, name] = repoId.split("/");
+  if (!owner || !name) throw new Error(`invalid repoId ${repoId}`);
+  return { owner, name };
+}
+
+export async function syncRepo(input: SyncRepoInput): Promise<void> {
+  if (!input.force && !isEnabled()) return;
+  const { owner, name } = parseRepoId(input.repoId);
+  const prs = await input.client.listPullRequests({ owner, name });
+  const enrich = input.client.enrichPrStatus?.bind(input.client);
+  for (const pr of prs) {
+    const enriched = enrich ? await enrich(pr) : pr;
+    await upsertAndResolve(enriched, input.resolvers);
+  }
+  if (input.includeIssues && input.client.listIssues) {
+    const issues = await input.client.listIssues({ owner, name });
+    for (const issue of issues) upsertGithubIssue(issue);
+  }
+  markRepoSynced(input.repoId, Date.now());
+}
+
+async function upsertAndResolve(
+  pr: GithubPr,
+  resolvers: TrackerResolver[],
+): Promise<void> {
+  upsertGithubPr(pr);
+  const resolved = await resolvePrLink(
+    { headRef: pr.headRef, title: pr.title, body: pr.body },
+    resolvers,
+  );
+  deleteAutoPrLinks(pr.id);
+  if (resolved) {
+    upsertPrLink({
+      prId: pr.id,
+      targetType: resolved.targetType,
+      targetId: resolved.targetId,
+      linkSource: resolved.linkSource,
+    });
+  }
+}

package/cloud-runtime/standalone/apps/local/lib/github-repo-store.ts

@@ -0,0 +1,63 @@
+import type { GithubRepo } from "./github-types";
+import { withGithubDatabase } from "./github-db";
+
+export interface UpsertGithubRepoInput {
+  owner: string;
+  name: string;
+  defaultBranch: string | null;
+  private: boolean;
+}
+
+function rowToRepo(row: Record<string, unknown>): GithubRepo {
+  return {
+    id: String(row.id),
+    owner: String(row.owner),
+    name: String(row.name),
+    defaultBranch: (row.default_branch as string | null) ?? null,
+    private: Number(row.private) === 1,
+    accessRevoked: Number(row.access_revoked) === 1,
+    addedAt: Number(row.added_at),
+    lastSyncedAt: row.last_synced_at == null ? null : Number(row.last_synced_at),
+  };
+}
+
+export function upsertGithubRepo(input: UpsertGithubRepoInput): GithubRepo {
+  const id = `${input.owner}/${input.name}`;
+  const now = Date.now();
+  return withGithubDatabase((db) => {
+    db.prepare(
+      `INSERT INTO github_repos (id, owner, name, default_branch, private, access_revoked, added_at, last_synced_at)
+       VALUES (?, ?, ?, ?, ?, 0, ?, NULL)
+       ON CONFLICT(id) DO UPDATE SET
+         default_branch = excluded.default_branch,
+         private = excluded.private`,
+    ).run(id, input.owner, input.name, input.defaultBranch, input.private ? 1 : 0, now);
+    const row = db.prepare(`SELECT * FROM github_repos WHERE id = ?`).get(id) as Record<string, unknown>;
+    return rowToRepo(row);
+  });
+}
+
+export function listGithubRepos(): GithubRepo[] {
+  return withGithubDatabase((db) => {
+    const rows = db.prepare(`SELECT * FROM github_repos ORDER BY id ASC`).all() as Record<string, unknown>[];
+    return rows.map(rowToRepo);
+  });
+}
+
+export function removeGithubRepo(id: string): void {
+  withGithubDatabase((db) => {
+    db.prepare(`DELETE FROM github_repos WHERE id = ?`).run(id);
+  });
+}
+
+export function markRepoSynced(id: string, syncedAt: number): void {
+  withGithubDatabase((db) => {
+    db.prepare(`UPDATE github_repos SET last_synced_at = ? WHERE id = ?`).run(syncedAt, id);
+  });
+}
+
+export function markRepoAccessRevoked(id: string, revoked: boolean): void {
+  withGithubDatabase((db) => {
+    db.prepare(`UPDATE github_repos SET access_revoked = ? WHERE id = ?`).run(revoked ? 1 : 0, id);
+  });
+}