co-maintainer 0.4.0-beta.1

package/dist/src/server/pages/repo_settings.js

@@ -0,0 +1,127 @@
+import { html, layout, repoNav, skSlot, text } from "./layout.js";
+export function renderRepoSettings(username, repo, config) {
+    const name = repo.full_name;
+    const skip = repo.skip_drafts && repo.skip_bots
+        ? "both"
+        : repo.skip_drafts
+            ? "drafts"
+            : repo.skip_bots
+                ? "bots"
+                : "none";
+    return html(layout({
+        title: `Settings · ${name}`,
+        username,
+        body: `<div class="wrap side">
+  ${repoNav(name, "settings")}
+  <div>
+    <div class="crumbs"><a href="/">Repositories</a> /
+      <a href="/repos/${text(name)}">${text(name)}</a> / Settings</div>
+    <div class="pagehead"><div><h1>Settings</h1></div></div>
+    <div class="card" data-async>
+      ${skSlot()}
+      <div class="hd"><h2>Automatic review</h2></div>
+      <div class="bd">
+        <div style="display:flex;align-items:center;gap:14px;margin-bottom:22px">
+          <button class="tg${repo.auto_review === 1 ? " on" : ""}" id="auto"></button>
+          <div>Review pull requests as they are pushed</div>
+        </div>
+        <div class="field">
+          <label>Skip</label>
+          <select id="skip">
+            <option value="both"${skip === "both" ? " selected" : ""}>Drafts and bot pull requests</option>
+            <option value="drafts"${skip === "drafts" ? " selected" : ""}>Drafts only</option>
+            <option value="bots"${skip === "bots" ? " selected" : ""}>Bots only</option>
+            <option value="none"${skip === "none" ? " selected" : ""}>Nothing</option>
+          </select>
+        </div>
+        <div class="field">
+          <label>Review</label>
+          <select id="scope">
+            <option value="whole-pr"${repo.review_scope !== "incremental" ? " selected" : ""}>The whole pull request every time</option>
+            <option value="incremental"${repo.review_scope === "incremental" ? " selected" : ""}>Only what changed since the last review</option>
+          </select>
+          <div class="hint">Reviewing only new changes costs less on long-running pull requests.</div>
+        </div>
+        <div style="display:flex;align-items:center;gap:14px;margin-top:22px">
+          <button class="tg${repo.use_codegraph === 1 ? " on" : ""}" id="codegraph"></button>
+          <div>Let the review query the codebase's call graph (codegraph)</div>
+        </div>
+        <div class="hint">Slower and costs more tokens per review, try it before turning it on everywhere.</div>
+      </div>
+      <div class="ft"><button class="primary" id="save-auto">Save</button></div>
+    </div>
+    <div class="card" data-async>
+      ${skSlot()}
+      <div class="hd"><h2>How this repository is analyzed</h2></div>
+      <div class="bd">
+        <p class="muted" style="margin:0 0 18px">Used when the knowledge is rebuilt. Leave blank to use your account defaults.</p>
+        <div class="two">
+          <div class="field"><label>Months of pull requests</label>
+            <input id="months" value="${text(config.maxPrMonths ?? "")}"></div>
+          <div class="field"><label>Commits</label>
+            <input id="commits" value="${text(config.maxCommits ?? "")}"></div>
+          <div class="field"><label>Max lines per pull request</label>
+            <input id="lines" value="${text(config.maxPullRequestChangeLines ?? "")}"></div>
+          <div class="field"><label>Max comments per pull request</label>
+            <input id="comments" value="${text(config.maxComments ?? "")}"></div>
+        </div>
+      </div>
+      <div class="ft"><button class="primary" id="save-init">Save</button></div>
+    </div>
+    <div class="card" data-async>
+      ${skSlot()}
+      <div class="hd"><h2>Remove</h2></div>
+      <div class="bd" style="display:flex;align-items:center;gap:16px">
+        <div class="txt">Stop reviewing this repository. Review history is kept.</div>
+        <button id="remove" style="margin-left:auto;color:var(--red)">Remove repository</button>
+      </div>
+    </div>
+  </div>
+</div>
+<script>
+var repo = ${JSON.stringify(name)};
+function save(btn, body) {
+  run(btn, btn.closest("[data-async]"), async function() {
+    await api("PATCH", "/api/repos/" + repo, body);
+    location.reload();
+  });
+}
+document.getElementById("save-auto").addEventListener("click", function() {
+  var skip = document.getElementById("skip").value;
+  save(this, {
+    autoReview: document.getElementById("auto").classList.contains("on"),
+    skipDrafts: skip === "both" || skip === "drafts",
+    skipBots: skip === "both" || skip === "bots",
+    reviewScope: document.getElementById("scope").value,
+    useCodegraph: document.getElementById("codegraph").classList.contains("on")
+  });
+});
+document.getElementById("auto").addEventListener("click", function() {
+  this.classList.toggle("on");
+});
+document.getElementById("codegraph").addEventListener("click", function() {
+  this.classList.toggle("on");
+});
+document.getElementById("save-init").addEventListener("click", function() {
+  var num = function(id) {
+    var v = document.getElementById(id).value.trim();
+    return v === "" ? null : Number(v);
+  };
+  save(this, {
+    maxPrMonths: num("months"),
+    maxCommits: num("commits"),
+    maxPullRequestChangeLines: num("lines"),
+    maxComments: num("comments")
+  });
+});
+document.getElementById("remove").addEventListener("click", function() {
+  if (!confirm("Stop reviewing this repository?")) return;
+  var btn = this;
+  run(btn, btn.closest("[data-async]"), async function() {
+    await api("DELETE", "/api/repos/" + repo);
+    location.href = "/";
+  });
+});
+</script>`,
+    }));
+}

package/dist/src/server/pages/router.d.ts

@@ -0,0 +1,17 @@
+import type { AuthMethods } from "../auth.ts";
+export type PageDeps = {
+    password: string;
+    webhookUrl?: string;
+    secureCookie?: boolean;
+    githubApp?: {
+        appId: string;
+        privateKeyPem: string;
+    };
+    auth?: AuthMethods;
+    githubOAuth?: {
+        clientId: string;
+        clientSecret: string;
+        allowedUser: string;
+    };
+};
+export declare function handlePageRequest(request: Request, deps: PageDeps, ip: string): Promise<Response | undefined>;

package/dist/src/server/pages/router.js

@@ -0,0 +1,312 @@
+import { clearOauthStateCookieHeader, clearSessionCookieHeader, createSession, login, logout, oauthStateCookieHeader, randomToken, readOauthState, readSessionToken, sessionCookieHeader, verifySession, } from "../auth.js";
+import { githubAuthorizeUrl, githubLoginFromCode } from "../../github/oauth.js";
+import { handleClient, handleLogo, handleStyles } from "../assets.js";
+import { readConfig } from "../../config.js";
+import { activityFeed, listReposForHome, prDetail, repoKnowledge, RepoNotFound, repoOverview, repoPulls, repoRemoteReviews, runningJobs, skippedDeliveries, statsForRange, } from "../../services/dashboard.js";
+import { money } from "./layout.js";
+import { renderHome, renderLogin } from "./home.js";
+import { renderSetup } from "./setup.js";
+import { renderAddRepo } from "./add_repo.js";
+import { renderRepo } from "./repo.js";
+import { renderRepoPulls } from "./repo_prs.js";
+import { renderRepoRemote } from "./repo_remote.js";
+import { renderPr } from "./pr.js";
+import { renderKnowledge } from "./knowledge.js";
+import { renderRepoSettings } from "./repo_settings.js";
+import { renderActivity, renderJob } from "./activity.js";
+import { renderAnalytics } from "./analytics.js";
+import { renderSettings } from "./settings.js";
+import { getRepo } from "../../store/repos.js";
+import { getJob } from "../../store/jobs.js";
+import { getLogsSince } from "../../services/jobs.js";
+import { listInstallationsWithRepos } from "../../github/app.js";
+const REPO = /^\/repos\/([^/]+)\/([^/]+)(?:\/(pulls|knowledge|settings)(?:\/(\d+))?)?$/;
+export async function handlePageRequest(request, deps, ip) {
+    const url = new URL(request.url);
+    if (url.pathname === "/styles.css" && request.method === "GET") {
+        return await handleStyles();
+    }
+    if (url.pathname === "/client.js" && request.method === "GET") {
+        return await handleClient();
+    }
+    if (url.pathname === "/logo.png" && request.method === "GET") {
+        return await handleLogo();
+    }
+    if (url.pathname === "/dashboard") {
+        return Response.redirect(`${url.origin}/`, 303);
+    }
+    const auth = deps.auth ?? { password: true, github: false };
+    if (url.pathname === "/login" && request.method === "GET") {
+        const session = await sessionOf(request);
+        if (session)
+            return Response.redirect(`${url.origin}/`, 303);
+        return renderLogin({
+            next: safeNext(url.searchParams.get("next")),
+            error: url.searchParams.get("error") ?? undefined,
+            showPassword: auth.password,
+            showGithub: auth.github,
+        });
+    }
+    if (url.pathname === "/login" && request.method === "POST") {
+        return await handleLoginForm(request, deps, ip, auth);
+    }
+    if (url.pathname === "/auth/github" && request.method === "GET") {
+        if (!auth.github || !deps.githubOAuth) {
+            return new Response("GitHub sign-in is not enabled.", { status: 404 });
+        }
+        const next = safeNext(url.searchParams.get("next"));
+        const state = randomToken();
+        const authorizeUrl = githubAuthorizeUrl(deps.githubOAuth.clientId, `${url.origin}/auth/github/callback`, state);
+        return new Response(null, {
+            status: 303,
+            headers: {
+                location: authorizeUrl,
+                "set-cookie": oauthStateCookieHeader(state, next, Boolean(deps.secureCookie)),
+            },
+        });
+    }
+    if (url.pathname === "/auth/github/callback" && request.method === "GET") {
+        if (!auth.github || !deps.githubOAuth) {
+            return new Response("GitHub sign-in is not enabled.", { status: 404 });
+        }
+        return await handleGithubCallback(request, url, deps.githubOAuth, deps);
+    }
+    if (url.pathname === "/logout" && request.method === "POST") {
+        const token = readSessionToken(request);
+        if (token)
+            await logout(token);
+        return new Response(null, {
+            status: 303,
+            headers: {
+                location: "/login",
+                "set-cookie": clearSessionCookieHeader(Boolean(deps.secureCookie)),
+            },
+        });
+    }
+    const session = await sessionOf(request);
+    if (!session) {
+        if (isPagePath(url.pathname)) {
+            const next = encodeURIComponent(url.pathname + url.search);
+            return Response.redirect(`${url.origin}/login?next=${next}`, 303);
+        }
+        return undefined;
+    }
+    const username = session.username;
+    try {
+        if (url.pathname === "/" && request.method === "GET") {
+            return renderHome(username, listReposForHome().map(toHomeRow));
+        }
+        if (url.pathname === "/setup" && request.method === "GET") {
+            const config = readConfig();
+            return renderSetup(username, {
+                ai: Boolean(config.ai && config.ai !== "none" && config.token),
+                github: Boolean(config.auth === "gh" || (config.auth === "pat" && config.githubPat)),
+                app: Boolean(config.githubAppId && config.githubAppPrivateKey),
+            });
+        }
+        if (url.pathname === "/repos/new" && request.method === "GET") {
+            return renderAddRepo(username, await repoPicker(deps.githubApp));
+        }
+        if (url.pathname === "/activity" && request.method === "GET") {
+            const page = Number(url.searchParams.get("page") ?? 1);
+            return renderActivity(username, runningJobs(), activityFeed(page, 20), skippedDeliveries());
+        }
+        const jobMatch = /^\/activity\/([^/]+)$/.exec(url.pathname);
+        if (jobMatch && request.method === "GET") {
+            const job = getJob(jobMatch[1]);
+            if (!job)
+                return new Response("not found", { status: 404 });
+            return renderJob(username, job, getLogsSince(job.id));
+        }
+        if (url.pathname === "/analytics" && request.method === "GET") {
+            const range = url.searchParams.get("range") ?? "30d";
+            return renderAnalytics(username, range, statsForRange(range));
+        }
+        if (url.pathname === "/settings" && request.method === "GET") {
+            const config = readConfig();
+            return renderSettings(username, config, config.webhookUrl || deps.webhookUrl || "");
+        }
+        const match = REPO.exec(url.pathname);
+        if (match && request.method === "GET") {
+            const fullName = `${decodeURIComponent(match[1])}/${decodeURIComponent(match[2])}`;
+            const row = requireRepo(fullName);
+            const sub = match[3];
+            const pr = match[4] ? Number(match[4]) : undefined;
+            if (!sub)
+                return renderRepo(username, repoOverview(fullName));
+            if (sub === "pulls" && pr) {
+                return renderPr(username, fullName, prDetail(fullName, pr));
+            }
+            if (sub === "pulls") {
+                const page = Number(url.searchParams.get("page") ?? 1);
+                return renderRepoPulls(username, fullName, repoPulls(fullName, page, 20));
+            }
+            if (sub === "remote") {
+                return renderRepoRemote(username, fullName, repoRemoteReviews(fullName));
+            }
+            if (sub === "knowledge") {
+                return renderKnowledge(username, await repoKnowledge(fullName), url.searchParams.get("view") ?? undefined);
+            }
+            if (sub === "settings") {
+                const config = readConfig();
+                return renderRepoSettings(username, row, config.repos?.[fullName] ?? {});
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof RepoNotFound) {
+            return new Response("not found", { status: 404 });
+        }
+        throw error;
+    }
+    return undefined;
+}
+function toHomeRow(item) {
+    const job = item.latestJob;
+    let statusKind = "ok";
+    let status = "Active";
+    if (job && (job.status === "running" || job.status === "queued")) {
+        statusKind = "run";
+        status = "Setting up";
+    }
+    else if (job?.status === "failed" && !item.repo.knowledge_built_at) {
+        statusKind = "err";
+        status = "Setup failed";
+    }
+    let knowledge = "Not built";
+    let knowledgeAt;
+    if (item.repo.knowledge_built_at) {
+        knowledge =
+            (item.drift?.prs_since ?? 0) > 0 ? "Needs update" : "Up to date";
+        knowledgeAt = item.repo.knowledge_built_at;
+    }
+    return {
+        fullName: item.repo.full_name,
+        statusKind,
+        status,
+        knowledge,
+        knowledgeAt,
+        autoOn: item.repo.auto_review === 1,
+        reviews: String(item.stats.reviews),
+        cost: money(item.stats.cost),
+    };
+}
+function requireRepo(fullName) {
+    const row = getRepo(fullName);
+    if (!row || row.active !== 1)
+        throw new RepoNotFound(fullName);
+    return row;
+}
+async function repoPicker(githubApp) {
+    if (!githubApp) {
+        return {
+            repos: [],
+            error: "Configure the GitHub App in Settings first.",
+        };
+    }
+    try {
+        const installations = await listInstallationsWithRepos(githubApp.appId, githubApp.privateKeyPem);
+        return {
+            repos: installations.flatMap(({ installation, repos }) => repos
+                .filter((repo) => repo.fullName)
+                .map((repo) => ({
+                fullName: repo.fullName,
+                account: installation.account?.login ?? "unknown",
+                alreadyActive: Boolean(getRepo(repo.fullName)?.active),
+            }))),
+        };
+    }
+    catch (error) {
+        console.error("[dashboard] Could not list repositories from GitHub:", error instanceof Error ? (error.stack ?? error.message) : String(error));
+        return {
+            repos: [],
+            error: "Could not list repositories from GitHub.",
+        };
+    }
+}
+function isPagePath(pathname) {
+    return (pathname === "/" ||
+        pathname === "/setup" ||
+        pathname === "/activity" ||
+        pathname.startsWith("/activity/") ||
+        pathname === "/analytics" ||
+        pathname === "/settings" ||
+        pathname === "/repos/new" ||
+        pathname.startsWith("/repos/"));
+}
+async function sessionOf(request) {
+    const token = readSessionToken(request);
+    if (!token)
+        return undefined;
+    return await verifySession(token);
+}
+function safeNext(value) {
+    if (!value || !value.startsWith("/") || value.startsWith("//"))
+        return "/";
+    return value;
+}
+async function handleLoginForm(request, deps, ip, auth) {
+    const form = await request.formData();
+    const password = String(form.get("password") ?? "");
+    const next = safeNext(String(form.get("next") ?? "/"));
+    if (!auth.password) {
+        return renderLogin({
+            next,
+            error: "Password sign-in is disabled.",
+            showPassword: auth.password,
+            showGithub: auth.github,
+        });
+    }
+    const result = await login(password, deps.password, ip);
+    if (!result) {
+        return renderLogin({
+            next,
+            error: "Wrong password.",
+            showPassword: auth.password,
+            showGithub: auth.github,
+        });
+    }
+    return new Response(null, {
+        status: 303,
+        headers: {
+            location: next,
+            "set-cookie": sessionCookieHeader(result.token, Boolean(deps.secureCookie)),
+        },
+    });
+}
+/** `state` round-trips through an HttpOnly cookie set by `/auth/github`
+ * (see `oauthStateCookieHeader`), not server memory — comparing it against
+ * the query param is what stops a forged callback from creating a session. */
+async function handleGithubCallback(request, url, githubOAuth, deps) {
+    const clearState = clearOauthStateCookieHeader(Boolean(deps.secureCookie));
+    const fail = (message) => new Response(null, {
+        status: 303,
+        headers: {
+            location: `${url.origin}/login?error=${encodeURIComponent(message)}`,
+            "set-cookie": clearState,
+        },
+    });
+    const saved = readOauthState(request);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (!saved || !code || !state || saved.state !== state) {
+        return fail("GitHub sign-in failed.");
+    }
+    const login = await githubLoginFromCode({
+        clientId: githubOAuth.clientId,
+        clientSecret: githubOAuth.clientSecret,
+        code,
+        redirectUri: `${url.origin}/auth/github/callback`,
+    });
+    if (!login || login.toLowerCase() !== githubOAuth.allowedUser.toLowerCase()) {
+        return fail("This GitHub account is not allowed to sign in.");
+    }
+    const result = await createSession();
+    return new Response(null, {
+        status: 303,
+        headers: {
+            location: saved.next,
+            "set-cookie": sessionCookieHeader(result.token, Boolean(deps.secureCookie)),
+        },
+    });
+}

package/dist/src/server/pages/settings.d.ts

@@ -0,0 +1,2 @@
+import type { UserConfig } from "../../config.ts";
+export declare function renderSettings(username: string, config: UserConfig, webhookUrl: string): Response;