co-maintainer 0.5.1-beta.3 → 0.5.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Murat Kirazkaya
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Murat Kirazkaya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "co-maintainer",
-    "version": "0.5.1-beta.3",
+    "version": "0.5.1",
     "description": "An imitator of yours, A PR review tool like co-maintainer.",
     "keywords": [
         "ai",

package/dist/src/ai/anthropic.d.ts

@@ -19,8 +19,8 @@
  *
  * `cache_control` is set on the system prompt, which every review sends as the
  * same guide prefix. Anthropic caches the longest stable prefix, so the
- * guides are billed at the cached rate from the second review on and the
- * `cache_read_input_tokens` count shows up in the usage log.
+ * guides are billed at the cached rate from the second review on. The cached
+ * tokens are counted in `tokensIn` with the rest of the input.
  *
  * ponytail: this talks to Messages without streaming. The original design
  * called for the SDK's `stream()` + `finalMessage()` helper for large `max_tokens` (a single

package/dist/src/ai/anthropic.js

@@ -26,8 +26,7 @@ export function anthropicError(model, status, body) {
     if (status === 401 || status === 403) {
         return new CliError("anthropic_unauthorized", "Anthropic rejected the API key.", "Set a new one with co-maintainer set --token=...", EXIT_USAGE);
     }
-    if ((status === 400 || status === 404) &&
-        (type === "not_found_error" || /model/i.test(detail))) {
+    if ((status === 400 || status === 404) && type === "not_found_error") {
         return new CliError("anthropic_unknown_model", `Anthropic does not know the model ${model}.`, "Pick one at https://docs.anthropic.com/en/docs/about-claude/models and set it with co-maintainer set --high-model=...", EXIT_USAGE);
     }
     return new CliError("anthropic_failed", `Anthropic failed with ${status}${detail ? `: ${detail}` : "."}`, undefined, EXIT_RUNTIME);
@@ -201,7 +200,11 @@ export function parseMessagesBody(json, model) {
     return {
         text: texts.join(""),
         ...(toolCalls.length ? { toolCalls } : {}),
-        tokensIn: Number(usage?.input_tokens ?? 0),
+        // Tokens read from or written to the prompt cache are input too, and with
+        // the guides cached they are most of it.
+        tokensIn: Number(usage?.input_tokens ?? 0) +
+            Number(usage?.cache_read_input_tokens ?? 0) +
+            Number(usage?.cache_creation_input_tokens ?? 0),
         tokensOut: Number(usage?.output_tokens ?? 0),
         // Anthropic reports only token counts, never a dollar cost, so this is
         // always unknown (`costReasonText`'s "provider_did_not_report").

package/dist/src/ai/openai.js

@@ -22,7 +22,9 @@ export function openAiError(model, status, body) {
     if (status === 401) {
         return new CliError("openai_unauthorized", "OpenAI rejected the API key.", "Set a new one with co-maintainer set --token=...", EXIT_USAGE);
     }
-    if (status === 400 && (code === "model_not_found" || /model/i.test(detail))) {
+    // Only the code says the model is unknown. Other 400s mention "model" too,
+    // a context that is too long or a setting this model does not take.
+    if ((status === 400 || status === 404) && code === "model_not_found") {
         return new CliError("openai_unknown_model", `OpenAI does not know the model ${model}.`, "Pick one at https://platform.openai.com/docs/models and set it with co-maintainer set --high-model=...", EXIT_USAGE);
     }
     return new CliError("openai_failed", `OpenAI failed with ${status}${detail ? `: ${detail}` : "."}`, undefined, EXIT_RUNTIME);

package/dist/src/cli/args.js

@@ -1,4 +1,4 @@
-import { prepareConfig } from "../config.js";
+import { prepareConfig, savedTokenFor } from "../config.js";
 import { getEnv } from "../util/runtime.js";
 import { askLine } from "./prompt.js";
 import { die } from "./error.js";
@@ -211,7 +211,7 @@ export async function parseArgs(args) {
     let aiToken = text("token") ??
         env("CO_MAINTAINER_TOKEN") ??
         providerKeyEnv(ai, env) ??
-        config.token;
+        savedTokenFor(config, ai);
     // The OPENROUTER_ names would hand an OpenRouter model id to another
     // provider, so they only count when OpenRouter is the one running.
     const openRouterModelEnv = (name) => ai === "openrouter" ? env(name) : undefined;

package/dist/src/cli/commands/config.d.ts

@@ -37,7 +37,7 @@ export declare function resolveField(name: string): string;
  * `defaults` are nested maps, not settings, so they are not listed.
  * `satisfies` makes this the type's own vocabulary: a name that is not a
  * `UserConfig` key is a compile error rather than a silently undefined read. */
-export declare const KNOWN_FIELDS: readonly ["auth", "ai", "lowModel", "highModel", "token", "githubPat", "githubAppId", "githubAppPrivateKey", "githubAppPrivateKeyPath", "githubWebhookSecret", "webhookUrl", "githubOAuthClientId", "githubOAuthClientSecret", "githubOAuthAllowedUser", "passwordAuthDisabled", "githubAuthEnabled", "dashboardPasswordHash", "maxConcurrentJobs", "reviewBlocking", "remoteHost", "remoteToken", "remoteNoticeShownFor", "remoteSyncTimeoutSeconds", "maxConcurrentRemoteReviewsPerToken", "remoteToolOutputMaxChars", "remoteByok", "remoteByokDefault", "reviewPolicy"];
+export declare const KNOWN_FIELDS: readonly ["auth", "ai", "lowModel", "highModel", "token", "githubPat", "githubAppId", "githubAppPrivateKey", "githubAppPrivateKeyPath", "githubWebhookSecret", "webhookUrl", "githubOAuthClientId", "githubOAuthClientSecret", "githubOAuthAllowedUser", "passwordAuthDisabled", "githubAuthEnabled", "dashboardPasswordHash", "maxConcurrentJobs", "reviewBlocking", "remoteHost", "remoteToken", "remoteNoticeShownFor", "remoteSyncTimeoutSeconds", "maxConcurrentRemoteReviewsPerToken", "remoteToolOutputMaxChars", "remoteByok", "remoteByokDefault", "remoteByokPolicy", "reviewPolicy"];
 /** `co-maintainer config <sub> ...`. `set` is handled by runSet, which this
  * command delegates to so there is one implementation of the write rules. */
 export declare function runConfig(args: string[]): Promise<void>;

package/dist/src/cli/commands/config.js

@@ -49,6 +49,7 @@ export const ENV_BY_FIELD = {
     remoteHost: ["CM_REMOTE_HOST"],
     remoteToken: ["CM_REMOTE_TOKEN"],
     reviewBlocking: ["CO_MAINTAINER_REVIEW_BLOCKING"],
+    remoteByokPolicy: ["CM_REMOTE_BYOK_POLICY"],
 };
 /** Renders one field for people. A secret is masked; the password hash, which
  * nobody can use, only reports whether it is set. */
@@ -156,6 +157,7 @@ export const KNOWN_FIELDS = [
     "remoteToolOutputMaxChars",
     "remoteByok",
     "remoteByokDefault",
+    "remoteByokPolicy",
     "reviewPolicy",
 ];
 /** `co-maintainer config <sub> ...`. `set` is handled by runSet, which this

package/dist/src/cli/commands/set.js

@@ -1,4 +1,4 @@
-import { readConfig, configPath, writeUserConfig } from "../../config.js";
+import { readConfig, configPath, savedKeyProvider, writeUserConfig, } from "../../config.js";
 import { hashPassword, passwordProblem } from "../../util/password.js";
 import { readTextFile } from "../../util/runtime.js";
 import { verifyAnthropic, verifyOpenAi, verifyOpenRouter, } from "../../ai/verify.js";
@@ -266,7 +266,16 @@ export async function runSet(args) {
     const effective = (field) => field in patch ? patch[field] : before[field];
     const effectiveAi = effective("ai");
     const effectiveToken = effective("token");
-    const effectiveHighModel = effective("highModel");
+    // The saved key and model belong to the saved provider. A switch without a
+    // new key would hand the old provider's key to the new one.
+    const previousAi = savedKeyProvider(before);
+    const switching = typeof patch.ai === "string" &&
+        patch.ai !== "none" &&
+        patch.ai !== previousAi;
+    if (switching && !("token" in patch) && before.token) {
+        die(`The saved key is for ${previousAi}. Pass --token= with the ${String(patch.ai)} key to switch providers.`);
+    }
+    const effectiveHighModel = switching && !("highModel" in patch) ? undefined : effective("highModel");
     const verifiers = {
         openrouter: verifyOpenRouter,
         openai: verifyOpenAi,

package/dist/src/cli/review_github.js

@@ -121,8 +121,9 @@ export function emitGithubOutput(input) {
  * printed on stderr, and the runner reads workflow commands from stderr too.
  * A line that would start one is given a prefix so it stays plain text. */
 export function neutralizeCommands(text) {
+    // The runner also ends a line at a bare carriage return.
     return text
-        .split("\n")
+        .split(/\r\n|\r|\n/)
         .map((line) => (line.trimStart().startsWith("::") ? `[log] ${line}` : line))
         .join("\n");
 }

package/dist/src/config.d.ts

@@ -93,10 +93,6 @@ export type UserConfig = {
     repos?: Record<string, RepoConfig>;
 };
 export type ByokPolicy = "off" | "allow" | "require";
-/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
- * overrides the saved config, so a hosted server cannot be talked out of its
- * policy by a config edit. An unset or unreadable value falls back to the
- * config, then to `off`. */
 /** The provider's own key variable. It is read only when that provider runs,
  * so a key meant for one provider is never sent to another. */
 export declare function providerKeyEnv(ai: string, env?: (name: string) => string | undefined): string | undefined;
@@ -105,8 +101,19 @@ export declare function providerKeyEnv(ai: string, env?: (name: string) => strin
  * then the saved key. Without this a server started with the key in its
  * environment reported AI as not configured and failed every job. */
 export declare function resolvedAiToken(config: Pick<UserConfig, "ai" | "token">, ai?: string | undefined): string | undefined;
+/** The provider the saved key belongs to. A config from before providers
+ * were saved holds an OpenRouter key, and so does one where AI was switched
+ * off, which the dashboard writes for such a config. */
+export declare function savedKeyProvider(config: Pick<UserConfig, "ai">): string;
+/** The saved key belongs to the saved provider, so a run on any other
+ * provider never receives it. */
+export declare function savedTokenFor(config: Pick<UserConfig, "ai" | "token">, ai: string): string | undefined;
 /** True when a provider is chosen and a key reaches it from anywhere. */
 export declare function aiConfigured(config: Pick<UserConfig, "ai" | "token">): boolean;
+/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
+ * overrides the saved config, so a hosted server cannot be talked out of its
+ * policy by a config edit. An unset or unreadable value falls back to the
+ * config, then to `off`. */
 export declare function remoteByokPolicy(config?: Pick<UserConfig, "remoteByokPolicy">): ByokPolicy;
 /** Platform/env injection keeps the OS branches testable: the
  * migration's `"windows"` vs `"win32"` trap is invisible otherwise. */

package/dist/src/config.js

@@ -1,8 +1,4 @@
 import { chmod, currentPlatform, getEnv, isNotFound, mkdir, readTextFileSync, setEnv, writeTextFile, } from "./util/runtime.js";
-/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
- * overrides the saved config, so a hosted server cannot be talked out of its
- * policy by a config edit. An unset or unreadable value falls back to the
- * config, then to `off`. */
 /** The provider's own key variable. It is read only when that provider runs,
  * so a key meant for one provider is never sent to another. */
 export function providerKeyEnv(ai, env = getEnv) {
@@ -20,12 +16,27 @@ export function providerKeyEnv(ai, env = getEnv) {
 export function resolvedAiToken(config, ai = config.ai) {
     return (getEnv("CO_MAINTAINER_TOKEN") ??
         (ai ? providerKeyEnv(ai) : undefined) ??
-        config.token);
+        savedTokenFor(config, ai ?? "openrouter"));
+}
+/** The provider the saved key belongs to. A config from before providers
+ * were saved holds an OpenRouter key, and so does one where AI was switched
+ * off, which the dashboard writes for such a config. */
+export function savedKeyProvider(config) {
+    return config.ai && config.ai !== "none" ? config.ai : "openrouter";
+}
+/** The saved key belongs to the saved provider, so a run on any other
+ * provider never receives it. */
+export function savedTokenFor(config, ai) {
+    return savedKeyProvider(config) === ai ? config.token : undefined;
 }
 /** True when a provider is chosen and a key reaches it from anywhere. */
 export function aiConfigured(config) {
     return Boolean(config.ai && config.ai !== "none" && resolvedAiToken(config));
 }
+/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
+ * overrides the saved config, so a hosted server cannot be talked out of its
+ * policy by a config edit. An unset or unreadable value falls back to the
+ * config, then to `off`. */
 export function remoteByokPolicy(config = readConfig()) {
     // An env value that is not one of the three known policies is treated as
     // unreadable and falls back to the config, so a typo cannot silently turn a

package/dist/src/server/api/settings.js

@@ -1,6 +1,6 @@
 import { errorResponse } from "../errors.js";
 import { readConfig, resolveAppPrivateKey, writeUserConfig, } from "../../config.js";
-import { aiConfigured } from "../../config.js";
+import { aiConfigured, savedKeyProvider, } from "../../config.js";
 import { testAppAccess, testGithubAccess } from "../../services/credentials.js";
 import { checkPassword, readSessionToken, revokeOtherSessions, } from "../auth.js";
 import { passwordProblem } from "../../util/password.js";
@@ -99,6 +99,21 @@ export async function handleSettingsRoute(request, url, webhookUrl, passwords, i
         text("githubOAuthClientId");
         text("githubOAuthClientSecret");
         text("githubOAuthAllowedUser");
+        const previousAi = savedKeyProvider(current);
+        if (patch.ai &&
+            patch.ai !== "none" &&
+            patch.ai !== previousAi &&
+            !patch.token &&
+            current.token) {
+            return errorResponse(422, "key_for_other_provider", `The saved key is for ${previousAi}. Enter the ${patch.ai} key to switch providers.`);
+        }
+        if ("remoteByokPolicy" in body) {
+            const policy = body.remoteByokPolicy;
+            if (policy !== "off" && policy !== "allow" && policy !== "require") {
+                return errorResponse(422, "invalid_setting", "remoteByokPolicy must be off, allow or require");
+            }
+            patch.remoteByokPolicy = policy;
+        }
         if (typeof body.passwordAuthDisabled === "boolean") {
             patch.passwordAuthDisabled = body.passwordAuthDisabled;
         }

package/dist/src/services/remote_review.js

@@ -250,7 +250,12 @@ export function registerRemoteReviewHandler() {
                     .filter((name) => typeof name === "string" && name));
                 const useCodegraph = allowed.size > 0;
                 const options = reviewOptionsForRepo(job.repo, useCodegraph, byokKey);
-                if (!options.aiToken || options.ai === "none") {
+                // A BYOK client brings a key but not models, so a server with no
+                // models cannot run its review either.
+                if (!options.aiToken ||
+                    options.ai === "none" ||
+                    !options.lowModel ||
+                    !options.highModel) {
                     throw new Error("server AI is not configured for remote review");
                 }
                 const billed = byokKey !== undefined ? "byok" : "server";
@@ -319,7 +324,12 @@ export function registerRemoteReviewHandler() {
                     codegraph: { state: result.codegraphState },
                     summary: summaryCounts(findings, blockingMode),
                     findings: findings.map((row) => toJsonFinding(row, blockingMode)),
-                    usage: { tokensIn, tokensOut, ...costUsage(costTally) },
+                    usage: {
+                        tokensIn,
+                        tokensOut,
+                        ...costUsage(costTally),
+                        billedTo: billed,
+                    },
                     remote: { jobId: job.id, reviewId, clientVersion: VERSION },
                 });
                 setReviewStatus(reviewId, "done", {
@@ -377,12 +387,9 @@ export function registerRemoteReviewHandler() {
                 dropByokKey(job.id);
                 if (!completed) {
                     // Reached on failure and on the aborted early return above.
-                    if (signal.aborted) {
-                        setReviewStatus(reviewId, "aborted");
-                    }
-                    else {
-                        setReviewStatus(reviewId, "failed");
-                    }
+                    setReviewStatus(reviewId, signal.aborted ? "aborted" : "failed", {
+                        billed_to: billedTo,
+                    });
                     deleteRemoteReviewInput(job.id);
                     closeRemoteSession(job.id);
                 }

package/dist/src/services/review.js

@@ -21,6 +21,7 @@ import { getReviewByJobId, insertReview, latestPostedReview, setReviewScope, set
 import { insertFinding, listCarryableFindingsForReview, listFindingsForPr, listFindingsForReview, setFindingPosted, } from "../store/findings.js";
 import { getOrCreatePrSubject, getSubjectRevision, parseRevisionFiles, parseVisiblePaths, saveSubjectRevision, } from "../store/subjects.js";
 import { enqueue, registerHandler } from "./jobs.js";
+import { requestedReviewBlocked } from "./webhook.js";
 import { getEnv } from "../util/runtime.js";
 const ACCESS_DENIED_BODY = "The App does not have access to review this pull request.";
 export function humanCopy(text) {
@@ -460,6 +461,14 @@ async function runReviewJobCore(job, log, client, ai) {
     }
     const options = reviewOptions(job.repo, job.pr_number);
     const args = JSON.parse(job.args || "{}");
+    const pr = await github.request(`repos/${job.repo}/pulls/${job.pr_number}`);
+    if (args.trigger === "request-comment" && !existing) {
+        const blocked = requestedReviewBlocked(job.repo, pr);
+        if (blocked) {
+            log("info", `the review request was not run: ${blocked}`);
+            return;
+        }
+    }
     // A maintainer asked for this review by label or comment: acknowledge it.
     // Best effort, a missing reaction must never fail the review itself.
     if (args.requestReaction && !existing) {
@@ -470,7 +479,6 @@ async function runReviewJobCore(job, log, client, ai) {
             log("info", `could not react to the review request: ${String(error)}`);
         }
     }
-    const pr = await github.request(`repos/${job.repo}/pulls/${job.pr_number}`);
     const headSha = String(pr.head?.sha ?? "");
     const mergeBase = String(pr.base?.sha ?? "");
     let scope = args.scope === "incremental" ? "incremental" : "whole-pr";

package/dist/src/services/webhook.d.ts

@@ -18,6 +18,12 @@ export type WebhookResult = {
     prNumber?: number;
     jobId?: string;
 };
+/** A comment request is decided from the issue payload, which says nothing
+ * about the fork, the target branch or the size. The review job asks again
+ * with the pull request it fetched, so a comment can never get past the size
+ * cap or a rule that a label request would hit. Returns why the review must
+ * not run, or undefined. */
+export declare function requestedReviewBlocked(repo: string, pr: Record<string, unknown>): string | undefined;
 export declare function maybeEnqueueReview(input: {
     repo: string;
     prNumber: number;

package/dist/src/services/webhook.js

@@ -99,6 +99,30 @@ function pullRequestFacts(pr, repo) {
         targetBranch: asString(asRecord(pr?.base)?.ref),
     };
 }
+/** A comment request is decided from the issue payload, which says nothing
+ * about the fork, the target branch or the size. The review job asks again
+ * with the pull request it fetched, so a comment can never get past the size
+ * cap or a rule that a label request would hit. Returns why the review must
+ * not run, or undefined. */
+export function requestedReviewBlocked(repo, pr) {
+    const row = getRepo(repo);
+    if (!row || row.active !== 1)
+        return "repo-not-active";
+    const config = readConfig();
+    const maxDiffLines = config.repos?.[repo]?.maxPullRequestChangeLines ??
+        config.defaults?.maxPullRequestChangeLines;
+    const changedLines = (asNumber(pr.additions) ?? 0) + (asNumber(pr.deletions) ?? 0);
+    if (maxDiffLines !== undefined && changedLines > maxDiffLines) {
+        return "diff-too-large";
+    }
+    const decision = evaluatePolicy(policyForRepo(row), {
+        ...pullRequestFacts(pr, repo),
+        draft: asBool(pr.draft),
+        bot: isBot(asRecord(pr.user)),
+        changedLines,
+    });
+    return decision.action === "skip" ? decision.reason : undefined;
+}
 export function maybeEnqueueReview(input) {
     const row = getRepo(input.repo);
     if (!row || row.active !== 1) {

package/dist/src/store/backup.js

@@ -7,7 +7,13 @@
  * version only. Data written after the upgrade is lost by design. */
 import { Database } from "./sqlite.js";
 import { CliError, EXIT_USAGE } from "../cli/error.js";
-import { isNotFound, mkdir, readFile, readTextFile, remove, rename, stat, writeFile, writeTextFile, } from "../util/runtime.js";
+import { chmod, isNotFound, mkdir, readFile, readTextFile, remove, rename, stat, writeFile, writeTextFile, } from "../util/runtime.js";
+// config.json holds the AI key, the PAT and the App key, so a copy of it is as
+// private as the original. Windows has no POSIX modes.
+async function writePrivate(path, data) {
+    await writeFile(path, data);
+    await chmod(path, 0o600).catch(() => { });
+}
 const slot = (paths) => `${paths.root}/previous`;
 export const rolledBackDir = (paths) => `${paths.root}/rolled-back`;
 async function exists(path) {
@@ -37,6 +43,7 @@ export async function takeBackup(paths, versions) {
     const temp = `${slot(paths)}.tmp`;
     await remove(temp, { recursive: true }).catch(() => { });
     await mkdir(temp, { recursive: true });
+    await chmod(temp, 0o700).catch(() => { });
     const files = ["app.db"];
     copyDatabase(paths.appDb, `${temp}/app.db`);
     if (await exists(paths.cacheDb)) {
@@ -44,7 +51,7 @@ export async function takeBackup(paths, versions) {
         files.push("cache.db");
     }
     if (await exists(paths.config)) {
-        await writeFile(`${temp}/config.json`, await readFile(paths.config));
+        await writePrivate(`${temp}/config.json`, await readFile(paths.config));
         files.push("config.json");
     }
     const manifest = {
@@ -144,7 +151,7 @@ export async function restoreBackup(paths) {
         "config.json": paths.config,
     };
     for (const file of manifest.files) {
-        await writeFile(destinations[file], await readFile(`${slot(paths)}/${file}`));
+        await writePrivate(destinations[file], await readFile(`${slot(paths)}/${file}`));
     }
     // The version marker must match the data again, or the next upgrade would
     // record the wrong version to go back to.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "co-maintainer",
-  "version": "0.5.1-beta.3",
+  "version": "0.5.1",
   "description": "An imitator of yours, A PR review tool like co-maintainer.",
   "keywords": [
     "ai",

package/dist/src/ai/hetzner.d.ts

@@ -1,16 +0,0 @@
-import type { AiProvider, AiRequest, AiResponse } from "../types.ts";
-declare const sleep: (milliseconds: number) => Promise<void>;
-export declare class HetznerProvider implements AiProvider {
-    readonly supportsTools = false;
-    private readonly endpoint;
-    private readonly apiKey;
-    private readonly model;
-    private readonly sleeper;
-    private nextRequest;
-    private spacing;
-    constructor(apiKey: string, model: string, endpoint?: string, sleeper?: typeof sleep);
-    complete(request: AiRequest): Promise<AiResponse>;
-    private waitForQuota;
-    private jitter;
-}
-export {};

package/dist/src/ai/hetzner.js

@@ -1,69 +0,0 @@
-import { chatBody, parseChatResponse } from "./provider.js";
-const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-export class HetznerProvider {
-    supportsTools = false;
-    endpoint;
-    apiKey;
-    model;
-    sleeper;
-    nextRequest = 0;
-    spacing = 8_000;
-    constructor(apiKey, model, endpoint = "https://inference.hetzner.com/api/v1/chat/completions", sleeper = sleep) {
-        if (!apiKey)
-            throw new Error("Hetzner requires HETZNER_API_KEY");
-        if (!model)
-            throw new Error("Hetzner requires HETZNER_MODEL");
-        this.apiKey = apiKey;
-        this.model = model;
-        this.sleeper = sleeper;
-        this.endpoint = endpoint;
-    }
-    async complete(request) {
-        let attempt = 0;
-        for (;;) {
-            attempt++;
-            await this.waitForQuota();
-            const response = await fetch(this.endpoint, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(chatBody(this.model, request)),
-            });
-            this.nextRequest = Date.now() + this.spacing;
-            if (response.ok) {
-                this.spacing = Math.max(8_000, this.spacing * 0.9);
-                return parseChatResponse((await response.json()), "hetzner", this.model);
-            }
-            if ([401, 403, 404].includes(response.status)) {
-                throw new Error(`Hetzner fatal ${response.status}: ${await response.text()}`);
-            }
-            if (response.status === 429) {
-                this.spacing = Math.min(180_000, this.spacing * 1.5);
-                const wait = this.jitter(this.spacing);
-                console.log(`[ai] hetzner 429 on attempt ${attempt}; retrying in ${Math.round(wait / 1000)}s`);
-                await this.sleeper(wait);
-                continue;
-            }
-            if (response.status >= 500 || response.status === 408) {
-                const wait = this.jitter(Math.min(180_000, this.spacing * 1.5));
-                console.log(`[ai] hetzner ${response.status} on attempt ${attempt}; retrying in ${Math.round(wait / 1000)}s`);
-                await this.sleeper(wait);
-                continue;
-            }
-            throw new Error(`Hetzner ${response.status}: ${await response.text()}`);
-        }
-    }
-    async waitForQuota() {
-        const wait = this.nextRequest - Date.now();
-        if (wait > 0) {
-            const jittered = this.jitter(wait);
-            console.log(`[ai] hetzner quota spacing, waiting ${Math.round(jittered / 1000)}s`);
-            await this.sleeper(jittered);
-        }
-    }
-    jitter(milliseconds) {
-        return Math.max(250, Math.round(milliseconds * (0.8 + Math.random() * 0.4)));
-    }
-}