@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/git-templates.js

@@ -44,6 +44,7 @@ import { selectGitWatchedRepos } from "../../db/repositories-store.js";
 import { existsSync, readFileSync } from "node:fs";
 import { createLogger, toSafeErrorMessage } from "../../logging.js";
 import { readJsonBody } from "../json-body.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const logger = createLogger("git-templates-api");
 const TEMPLATE_BODY_MAX_BYTES = 64 * 1024;
 const REPORT_BODY_MAX_BYTES = 4 * 1024;
@@ -56,9 +57,16 @@ export function createGitTemplatesRoutes(deps) {
     const app = new Hono();
     /* ── Editor ───────────────────────────────────────────────────────── */
     app.get("/git/templates/:kind", (c) => {
-        const kind = parseKind(c.req.param("kind"));
-        if (!kind)
-            return c.json({ error: "invalid_kind" }, 400);
+        const rawKind = c.req.param("kind");
+        const kind = parseKind(rawKind);
+        if (!kind) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("git_templates.invalid_kind", {
+                    field: "kind",
+                    received: rawKind,
+                }),
+            ]);
+        }
         try {
             const overridePath = templateFilePath(deps.config.dataDir, kind);
             const hasOverride = existsSync(overridePath);
@@ -80,19 +88,36 @@ export function createGitTemplatesRoutes(deps) {
         }
         catch (err) {
             logger.error({ kind, err }, "Failed to read git template");
-            return c.json({ error: "read_failed", message: toSafeErrorMessage(err) }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("git_templates.read_failed", {
+                    field: "kind",
+                    received: kind,
+                }),
+            ], { legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     app.put("/git/templates/:kind", async (c) => {
-        const kind = parseKind(c.req.param("kind"));
-        if (!kind)
-            return c.json({ error: "invalid_kind" }, 400);
+        const rawKind = c.req.param("kind");
+        const kind = parseKind(rawKind);
+        if (!kind) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("git_templates.invalid_kind", {
+                    field: "kind",
+                    received: rawKind,
+                }),
+            ]);
+        }
         const parsed = await readJsonBody(c, { maxBytes: TEMPLATE_BODY_MAX_BYTES });
         if (!parsed.ok)
             return parsed.response;
         const body = parsed.body;
         if (typeof body.content !== "string") {
-            return c.json({ error: "content_required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git_templates.content_required", {
+                    field: "content",
+                    received: typeof body.content,
+                }),
+            ]);
         }
         try {
             const result = writeTemplateBody(deps.config.dataDir, kind, body.content);
@@ -112,21 +137,36 @@ export function createGitTemplatesRoutes(deps) {
                branch stays as defense-in-depth in case the cap is later relaxed
                on either side. */
             if (code === "ETEMPLATE_BODY_TOO_LARGE") {
-                return c.json({
-                    error: "body_too_large",
-                    maxBytes: TEMPLATE_BODY_MAX_BYTES,
-                }, 413);
+                return respondWithAgentError(c, 413, [
+                    composeIssue("git_templates.body_too_large", {
+                        field: "content",
+                        received: `>${TEMPLATE_BODY_MAX_BYTES} bytes`,
+                        constraint: { type: "string", maximum: TEMPLATE_BODY_MAX_BYTES },
+                    }),
+                ], { legacyFields: { maxBytes: TEMPLATE_BODY_MAX_BYTES } });
             }
             /* c8 ignore stop */
             logger.error({ kind, err }, "Failed to write git template");
-            return c.json({ error: "write_failed", message: toSafeErrorMessage(err) }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("git_templates.write_failed", {
+                    field: "kind",
+                    received: kind,
+                }),
+            ], { legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     /* ── Apply (enqueue retemplate run) ───────────────────────────────── */
     app.post("/git/templates/:kind/apply", (c) => {
-        const kind = parseKind(c.req.param("kind"));
-        if (!kind)
-            return c.json({ error: "invalid_kind" }, 400);
+        const rawKind = c.req.param("kind");
+        const kind = parseKind(rawKind);
+        if (!kind) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("git_templates.invalid_kind", {
+                    field: "kind",
+                    received: rawKind,
+                }),
+            ]);
+        }
         const repos = normalizeGitWatchedRepos({
             gitWatchedRepos: selectGitWatchedRepos(deps.db),
         });
@@ -159,16 +199,32 @@ export function createGitTemplatesRoutes(deps) {
             });
         }
         if (result.reason === "in_progress") {
-            return c.json({
-                error: "in_progress",
-                scheduleId: result.detail.scheduleId,
-                correlationId: result.detail.correlationId ?? null,
-            }, 409);
+            return respondWithAgentError(c, 409, [
+                composeIssue("git_templates.in_progress", {
+                    field: "<server>",
+                    received: { scheduleId: result.detail.scheduleId },
+                }),
+            ], {
+                legacyFields: {
+                    scheduleId: result.detail.scheduleId,
+                    correlationId: result.detail.correlationId ?? null,
+                },
+            });
         }
         if (result.reason === "missing_template") {
-            return c.json({ error: "missing_template", kind }, 412);
+            return respondWithAgentError(c, 412, [
+                composeIssue("git_templates.missing_template", {
+                    field: "kind",
+                    received: kind,
+                }),
+            ], { legacyFields: { kind } });
         }
-        return c.json({ error: "no_targets", kind }, 422);
+        return respondWithAgentError(c, 422, [
+            composeIssue("git_templates.no_targets", {
+                field: "<server>",
+                received: { kind, targets: 0 },
+            }),
+        ], { legacyFields: { kind } });
     });
     /* ── Status surface ───────────────────────────────────────────────── */
     app.get("/git/templates/retemplate/status", (c) => {
@@ -182,11 +238,21 @@ export function createGitTemplatesRoutes(deps) {
             return parsed.response;
         const body = parsed.body;
         if (typeof body.slug !== "string" || !SLUG_PATTERN.test(body.slug)) {
-            return c.json({ error: "invalid_slug" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git_templates.invalid_slug", {
+                    field: "slug",
+                    received: body.slug,
+                }),
+            ]);
         }
         if (typeof body.status !== "string"
             || !VALID_REPORT_STATUSES.has(body.status)) {
-            return c.json({ error: "invalid_status" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git_templates.invalid_status", {
+                    field: "status",
+                    received: body.status,
+                }),
+            ]);
         }
         const slug = body.slug;
         const status = body.status;
@@ -207,12 +273,32 @@ export function createGitTemplatesRoutes(deps) {
                 : {}),
         });
         if (!persisted.ok) {
-            const code = persisted.reason === "no_active_run"
+            const reasonToCode = {
+                no_active_run: "git_templates.no_active_run",
+                correlation_mismatch: "git_templates.correlation_mismatch",
+            };
+            const registryCode = reasonToCode[persisted.reason] ?? "git_templates.slug_not_in_run";
+            const status = persisted.reason === "no_active_run"
                 ? 409
                 : persisted.reason === "correlation_mismatch"
                     ? 409
                     : 404;
-            return c.json({ error: persisted.reason }, code);
+            // `correlation_mismatch` is only returned by `persistPerFileStatus`
+            // when `options.correlationId !== undefined`, and the route only
+            // spreads `correlationId` into the persist call when
+            // `typeof body.correlationId === "string"`. So when we land here
+            // with `correlation_mismatch`, `body.correlationId` is guaranteed
+            // to be a string — no defensive fallback needed.
+            return respondWithAgentError(c, status, [
+                composeIssue(registryCode, {
+                    field: persisted.reason === "correlation_mismatch"
+                        ? "correlationId"
+                        : "slug",
+                    received: persisted.reason === "correlation_mismatch"
+                        ? body.correlationId
+                        : slug,
+                }),
+            ]);
         }
         // Per-file audit row — emitted only on terminal status so the audit
         // log shows exactly one row per file (Decision 8 §2: "Audit row per
@@ -273,4 +359,3 @@ export function createGitTemplatesRoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=git-templates.js.map

package/dist/api/routes/git.d.ts

@@ -31,4 +31,3 @@ export interface GitRouteDependencies {
  * Refs and hashes are sanitized to prevent shell injection.
  */
 export declare function createGitRoutes(deps: GitRouteDependencies): Hono;
-//# sourceMappingURL=git.d.ts.map

package/dist/api/routes/git.js

@@ -3,6 +3,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { resolveRepositoryIdentifier, selectGitRepoPaths, } from "../../db/repositories-store.js";
 import { createLogger, toSafeErrorMessage } from "../../logging.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const execFileAsync = promisify(execFile);
 const logger = createLogger("git-api");
 /**
@@ -59,39 +60,67 @@ export function createGitRoutes(deps) {
     }
     // GET /git/log — recent commit log
     app.get("/git/log", async (c) => {
-        const repo = resolveRepo(c.req.query("repo"));
+        const repoParam = c.req.query("repo");
+        const repo = resolveRepo(repoParam);
         if (!repo) {
-            return c.json({ error: "invalid or missing repo", allowed: listAllowed() }, 400);
-        }
-        const count = Math.min(Number(c.req.query("count") ?? "5"), 200);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git.invalid_repo", {
+                    field: "repo",
+                    received: repoParam ?? "<missing>",
+                }),
+            ], { legacyErrorCode: "invalid or missing repo", legacyFields: { allowed: listAllowed() } });
+        }
+        const countRaw = Number.parseInt(c.req.query("count") ?? "5", 10);
+        const count = Number.isFinite(countRaw) && countRaw >= 1
+            ? Math.min(countRaw, 200)
+            : 5;
+        // ASCII Unit Separator — git commit fields (subject/author) cannot contain it,
+        // so it's a safer delimiter than `|` which naturally appears in commit subjects.
+        const FS = "\x1f";
         try {
-            const { stdout } = await execFileAsync("git", ["log", "--format=%H|%h|%s|%an|%ar", `-${count}`], { cwd: repo, timeout: 10_000 });
+            const { stdout } = await execFileAsync("git", ["log", `--format=%H${FS}%h${FS}%s${FS}%an${FS}%ar`, `-${count}`], { cwd: repo, timeout: 10_000 });
             const commits = stdout
                 .trim()
                 .split("\n")
                 .filter(Boolean)
                 .map((line) => {
-                const [hash, short, subject, author, ago] = line.split("|");
+                const [hash, short, subject, author, ago] = line.split(FS);
                 return { hash, short, subject, author, ago };
             });
             return c.json({ commits });
         }
         catch (err) {
             logger.error({ err, repo }, "git log failed");
-            return c.json({ error: toSafeErrorMessage(err) }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("git.exec_failed", {
+                    field: "git log",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyErrorCode: toSafeErrorMessage(err) });
         }
     });
     // GET /git/diff — diff between refs
     app.get("/git/diff", async (c) => {
-        const repo = resolveRepo(c.req.query("repo"));
+        const repoParam = c.req.query("repo");
+        const repo = resolveRepo(repoParam);
         if (!repo) {
-            return c.json({ error: "invalid or missing repo" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git.invalid_repo", {
+                    field: "repo",
+                    received: repoParam ?? "<missing>",
+                }),
+            ], { legacyErrorCode: "invalid or missing repo" });
         }
         // Use || (not ??) so explicit ?ref= (empty string) falls back to default
         const ref = c.req.query("ref") || "HEAD~1..HEAD";
         // Sanitize ref — reject shell metacharacters and flag-like arguments
         if (/[;&|`$]/.test(ref) || ref.startsWith("-")) {
-            return c.json({ error: "invalid ref format" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git.invalid_ref", {
+                    field: "ref",
+                    received: ref,
+                }),
+            ], { legacyErrorCode: "invalid ref format" });
         }
         try {
             const { stdout } = await execFileAsync("git", ["diff", "--stat", "-p", ref], { cwd: repo, timeout: 10_000, maxBuffer: 200_000 });
@@ -99,18 +128,34 @@ export function createGitRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, repo, ref }, "git diff failed");
-            return c.json({ error: toSafeErrorMessage(err) }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("git.exec_failed", {
+                    field: "git diff",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyErrorCode: toSafeErrorMessage(err) });
         }
     });
     // GET /git/show — show a specific commit
     app.get("/git/show", async (c) => {
-        const repo = resolveRepo(c.req.query("repo"));
+        const repoParam = c.req.query("repo");
+        const repo = resolveRepo(repoParam);
         if (!repo) {
-            return c.json({ error: "invalid or missing repo" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git.invalid_repo", {
+                    field: "repo",
+                    received: repoParam ?? "<missing>",
+                }),
+            ], { legacyErrorCode: "invalid or missing repo" });
         }
         const hash = c.req.query("hash") || "HEAD";
         if (/[;&|`$]/.test(hash) || hash.startsWith("-")) {
-            return c.json({ error: "invalid hash format" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("git.invalid_hash", {
+                    field: "hash",
+                    received: hash,
+                }),
+            ], { legacyErrorCode: "invalid hash format" });
         }
         try {
             const { stdout } = await execFileAsync("git", ["show", "--stat", "--format=%H%n%s%n%b%n---", hash], { cwd: repo, timeout: 10_000, maxBuffer: 100_000 });
@@ -118,9 +163,13 @@ export function createGitRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, repo, hash }, "git show failed");
-            return c.json({ error: toSafeErrorMessage(err) }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("git.exec_failed", {
+                    field: "git show",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyErrorCode: toSafeErrorMessage(err) });
         }
     });
     return app;
 }
-//# sourceMappingURL=git.js.map

package/dist/api/routes/github.d.ts

@@ -31,4 +31,3 @@ export declare function createGitHubRoutes(deps: GitHubRouteDependencies): {
 };
 /** Verify GitHub webhook HMAC-SHA256 signature */
 export declare function verifySignature(payload: string, signature: string, secret: string): boolean;
-//# sourceMappingURL=github.d.ts.map

package/dist/api/routes/github.js

@@ -5,6 +5,7 @@ import { recordObservation } from "../../db/observations.js";
 import { getRepositoryByGithub, resolveRepositoryIdentifier, selectGithubRepoSlugs, } from "../../db/repositories-store.js";
 import { createLogger, toSafeErrorMessage } from "../../logging.js";
 import { readJsonBody } from "../json-body.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const logger = createLogger("github-api");
 /**
  * GitHub Webhook receiver + API proxy routes.
@@ -52,6 +53,11 @@ export function createGitHubRoutes(deps) {
             return null;
         if (octokit && cachedToken === githubToken)
             return octokit;
+        // No pending-promise coalescing: the only cost of a concurrent miss is one
+        // extra `new Octokit({...})` (the dynamic import is module-cached after
+        // the first call). Coalescing would also mean that a caller whose token
+        // was rotated mid-flight could receive an Octokit auth'd with the prior
+        // token — losing the cache-by-token guarantee this function provides.
         const { Octokit } = await import("@octokit/rest");
         octokit = new Octokit({ auth: githubToken });
         cachedToken = githubToken;
@@ -135,33 +141,63 @@ export function createGitHubRoutes(deps) {
             // peerAddr stays "unknown"
         }
         if (!globalRateLimiter.allow("global")) {
-            return c.json({ error: "rate_limited" }, 429);
+            return respondWithAgentError(c, 429, [
+                composeIssue("github.rate_limited", {
+                    field: "webhook",
+                    received: peerAddr,
+                }),
+            ]);
         }
         if (!perSourceRateLimiter.allow(peerAddr)) {
-            return c.json({ error: "rate_limited" }, 429);
+            return respondWithAgentError(c, 429, [
+                composeIssue("github.rate_limited", {
+                    field: "webhook",
+                    received: peerAddr,
+                }),
+            ]);
         }
         // Webhook secret is required — refuse to operate without signature verification
         const webhookSecret = await secretBroker.getGitHubWebhookSecret();
         if (!webhookSecret) {
-            return c.json({ error: "webhook_not_configured", message: "PA_GITHUB_WEBHOOK_SECRET must be set" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("github.webhook_not_configured", {
+                    field: "PA_GITHUB_WEBHOOK_SECRET",
+                    received: "<unset>",
+                }),
+            ], { legacyFields: { message: "PA_GITHUB_WEBHOOK_SECRET must be set" } });
         }
         // Read raw body for signature verification
         const rawBody = await c.req.text();
         const signature = c.req.header("x-hub-signature-256");
         if (!signature || !verifySignature(rawBody, signature, webhookSecret)) {
             logger.warn("GitHub webhook signature verification failed");
-            return c.json({ error: "invalid_signature" }, 401);
+            return respondWithAgentError(c, 401, [
+                composeIssue("github.invalid_signature", {
+                    field: "X-Hub-Signature-256",
+                    received: signature ?? "<missing>",
+                }),
+            ]);
         }
         const eventType = c.req.header("x-github-event");
         if (!eventType) {
-            return c.json({ error: "missing_event_type" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("github.missing_event_type", {
+                    field: "X-GitHub-Event",
+                    received: "<missing>",
+                }),
+            ]);
         }
         let payload;
         try {
             payload = JSON.parse(rawBody);
         }
         catch {
-            return c.json({ error: "invalid_json" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("github.invalid_json", {
+                    field: "body",
+                    received: "<invalid_json>",
+                }),
+            ]);
         }
         // Resolve `payload.repository.full_name` to a row id from the unified
         // store before emitting. Webhooks for repos not in the table are
@@ -206,8 +242,14 @@ export function createGitHubRoutes(deps) {
     // (still `{ repos: [{ name }, ...] }`); the names are now canonical.
     apiApp.get("/github/repos", async (c) => {
         const ok = await getOctokit();
-        if (!ok)
-            return c.json({ error: "github_not_configured" }, 503);
+        if (!ok) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("github.not_configured", {
+                    field: "githubToken",
+                    received: "<unset>",
+                }),
+            ]);
+        }
         const slugs = selectGithubRepoSlugs(db);
         return c.json({ repos: slugs.map((name) => ({ name })) });
     });
@@ -216,15 +258,26 @@ export function createGitHubRoutes(deps) {
     // or repositoryId=<row id | slug>.
     apiApp.get("/github/pulls", async (c) => {
         const ok = await getOctokit();
-        if (!ok)
-            return c.json({ error: "github_not_configured" }, 503);
+        if (!ok) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("github.not_configured", {
+                    field: "githubToken",
+                    received: "<unset>",
+                }),
+            ]);
+        }
         const target = resolveGithubApiTarget({
             owner: c.req.query("owner"),
             repo: c.req.query("repo"),
             repositoryId: c.req.query("repositoryId") ?? c.req.query("id"),
         });
         if (!target.ok) {
-            return c.json({ error: target.error, message: target.message }, target.status);
+            return respondWithAgentError(c, target.status, [
+                composeIssue(githubTargetCode(target.error), {
+                    field: "repo",
+                    received: target.message,
+                }),
+            ], { legacyErrorCode: target.error, legacyFields: { message: target.message } });
         }
         const state = (c.req.query("state") ?? "open");
         try {
@@ -250,20 +303,36 @@ export function createGitHubRoutes(deps) {
         }
         catch (err) {
             logger.error({ err }, "GitHub pulls fetch failed");
-            return c.json({ error: "github_api_error", message: toSafeErrorMessage(err) }, 502);
+            return respondWithAgentError(c, 502, [
+                composeIssue("github.api_error", {
+                    field: "octokit",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     // POST /github/pulls/comment — post a comment on a PR
     apiApp.post("/github/pulls/comment", async (c) => {
         const ok = await getOctokit();
-        if (!ok)
-            return c.json({ error: "github_not_configured" }, 503);
+        if (!ok) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("github.not_configured", {
+                    field: "githubToken",
+                    received: "<unset>",
+                }),
+            ]);
+        }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const { owner, repo, repositoryId, id, pull_number, comment } = parsedBody.body;
         if (!pull_number || !comment) {
-            return c.json({ error: "pull_number and comment are required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("github.pull_number_and_comment_required", {
+                    field: "body",
+                    received: { pull_number: pull_number ?? "<missing>", comment: comment ? "<set>" : "<missing>" },
+                }),
+            ]);
         }
         const target = resolveGithubApiTarget({
             owner,
@@ -271,7 +340,12 @@ export function createGitHubRoutes(deps) {
             repositoryId: repositoryId ?? id,
         });
         if (!target.ok) {
-            return c.json({ error: target.error, message: target.message }, target.status);
+            return respondWithAgentError(c, target.status, [
+                composeIssue(githubTargetCode(target.error), {
+                    field: "repo",
+                    received: target.message,
+                }),
+            ], { legacyErrorCode: target.error, legacyFields: { message: target.message } });
         }
         try {
             const { data } = await ok.issues.createComment({
@@ -284,12 +358,36 @@ export function createGitHubRoutes(deps) {
         }
         catch (err) {
             logger.error({ err }, "GitHub comment failed");
-            return c.json({ error: "github_api_error", message: toSafeErrorMessage(err) }, 502);
+            return respondWithAgentError(c, 502, [
+                composeIssue("github.api_error", {
+                    field: "octokit",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     return { webhookApp, apiApp };
 }
 // ─── Helpers ───
+/**
+ * Map a GitHubApiTarget failure tag to the agent-error registry code.
+ * Both 400 (`validation_error`) and 404 (`repository_not_*` / `github_side_required`)
+ * have dedicated entries with retry hints.
+ */
+function githubTargetCode(tag) {
+    switch (tag) {
+        case "repository_not_found":
+            return "github.repository_not_found";
+        case "repository_not_registered":
+            return "github.repository_not_registered";
+        case "github_side_required":
+            return "github.side_required";
+        case "validation_error":
+            return "github.validation_error";
+        default:
+            return "github.repository_not_found";
+    }
+}
 /** Verify GitHub webhook HMAC-SHA256 signature */
 export function verifySignature(payload, signature, secret) {
     const expected = `sha256=${createHmac("sha256", secret).update(payload).digest("hex")}`;
@@ -468,6 +566,7 @@ class RateLimiter {
     maxRequests;
     windowMs;
     windows = new Map();
+    lastSweepAt = 0;
     constructor(maxRequests, windowMs) {
         this.maxRequests = maxRequests;
         this.windowMs = windowMs;
@@ -475,24 +574,31 @@ class RateLimiter {
     allow(key) {
         const now = Date.now();
         const cutoff = now - this.windowMs;
+        // Periodic full sweep — bounds map size against the floods-of-unique-keys
+        // case where the old per-key cleanup never runs because each key never
+        // returns. Throttled to once per windowMs and only when the map has grown
+        // past the threshold, so steady-state per-request cost stays O(W).
+        if (this.windows.size > 1000 && now - this.lastSweepAt >= this.windowMs) {
+            this.lastSweepAt = now;
+            for (const [k, ts] of this.windows) {
+                while (ts.length > 0 && ts[0] < cutoff)
+                    ts.shift();
+                if (ts.length === 0)
+                    this.windows.delete(k);
+            }
+        }
         let timestamps = this.windows.get(key);
         if (!timestamps) {
             timestamps = [];
             this.windows.set(key, timestamps);
         }
-        // Remove expired timestamps
+        // Remove expired timestamps for this key
         while (timestamps.length > 0 && timestamps[0] < cutoff) {
             timestamps.shift();
         }
-        // Clean up empty entries to prevent memory leak from unique IPs
-        if (timestamps.length === 0 && this.windows.size > 1000) {
-            this.windows.delete(key);
-            return true;
-        }
         if (timestamps.length >= this.maxRequests)
             return false;
         timestamps.push(now);
         return true;
     }
 }
-//# sourceMappingURL=github.js.map

package/dist/api/routes/health.d.ts

@@ -1,4 +1,3 @@
 import { Hono } from "hono";
 import type { ApiDependencies } from "../server.js";
 export declare function createHealthRoutes(deps: ApiDependencies): Hono;
-//# sourceMappingURL=health.d.ts.map