@co0ontty/wand 4.57.0 → 4.58.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "d240da17b4bfee37b304e0a51c90506979357d8c",
-  "builtAt": "2026-09-10T04:56:25.817Z",
-  "version": "4.57.0",
+  "commit": "3ab96a356a555f419adb4ec4c5cba63dfd170a5c",
+  "builtAt": "2026-09-11T13:51:01.381Z",
+  "version": "4.58.0",
   "channel": "stable"
 }

package/dist/ensure-node-pty-helper.d.ts

@@ -6,5 +6,4 @@ export interface SpawnHelperRepair {
 /** Repair one spawn-helper file. Exported for tests. */
 export declare function repairSpawnHelperFile(vendorPath: string): SpawnHelperRepair;
 export declare function ensureNodePtyHelperExecutable(): void;
-export declare function resetNodePtyHelperStateForTests(): void;
 export declare function describePtySpawnFailure(error: unknown): string;

package/dist/ensure-node-pty-helper.js

@@ -141,11 +141,6 @@ export function ensureNodePtyHelperExecutable() {
         }
     }
 }
-export function resetNodePtyHelperStateForTests() {
-    cachedVendorHelperPath = null;
-    patchedVendorHelperPath = null;
-    patchedExecutableHelperPath = null;
-}
 export function describePtySpawnFailure(error) {
     const message = getErrorMessage(error, "无法启动终端。");
     if (/posix_spawnp failed/i.test(message)) {

package/dist/git-quick-commit.js

@@ -618,29 +618,33 @@ export async function callConfiguredAiText(prompt, cwd, language, opts) {
     }
     return callCliAiText(prompt, cwd, language, opts);
 }
-async function collectStagedDiff(cwd) {
-    let diff;
-    try {
-        diff = await runGitAsync(["diff", "--cached", "--submodule=log"], cwd, 5000);
-    }
-    catch {
-        diff = "";
-    }
-    if (!diff) {
+/** Read the unstaged + staged tree without touching the index. */
+async function collectWorkingTreeDiff(cwd) {
+    const candidates = [
+        [["diff", "HEAD", "--submodule=log"], 5000],
+        [["diff", "--cached", "--submodule=log"], 5000],
+        [["diff", "HEAD", "--name-only"], 3000],
+    ];
+    let diff = "";
+    for (const [args, timeout] of candidates) {
         try {
-            diff = await runGitAsync(["diff", "--cached", "--name-only"], cwd, 3000);
+            diff = await runGitAsync(args, cwd, timeout);
         }
         catch {
-            diff = "(no diff available)";
+            diff = "";
         }
+        if (diff)
+            break;
     }
+    if (!diff)
+        diff = "(no diff available)";
     if (diff.length > MAX_DIFF_FOR_AI) {
         diff = diff.slice(0, MAX_DIFF_FOR_AI) + "\n\n... (diff truncated) ...";
     }
     return diff;
 }
 async function generateCommitMessage(cwd, language, ai = {}) {
-    const diff = await collectStagedDiff(cwd);
+    const diff = await collectWorkingTreeDiff(cwd);
     const lang = language.trim() || "中文";
     const prompt = `阅读以下 git diff，用${lang}写一条简洁的 commit message。要求：祈使句，不超过 50 字，描述「做了什么」。只输出 message 本身，不要引号、不要 Markdown 格式、不要任何额外说明。\n\n${diff}`;
     const raw = await callConfiguredAiText(prompt, cwd, language, ai);
@@ -678,7 +682,7 @@ function sanitizeSuggestedTag(value) {
     return cleaned;
 }
 async function generateCommitMessageWithTag(cwd, language, ai = {}) {
-    const diff = await collectStagedDiff(cwd);
+    const diff = await collectWorkingTreeDiff(cwd);
     let latestTag;
     try {
         latestTag = await runGitAsync(["describe", "--tags", "--abbrev=0"], cwd) || undefined;
@@ -721,12 +725,7 @@ export async function generateCommitMessageOnly(cwd, language, ai = {}) {
     if (!cwd || !existsSync(cwd)) {
         throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
     }
-    try {
-        await runGitAsync(["add", "-A"], cwd, 5000);
-    }
-    catch {
-        // best-effort staging so the diff is complete
-    }
+    // Read the working tree as-is. Generating a message must not stage files.
     return generateCommitMessageWithTag(cwd, language, ai);
 }
 /**

package/dist/github-connector.d.ts

@@ -1,6 +1,7 @@
 import type { WandStorage } from "./storage.js";
 export declare const GITHUB_PROVIDER = "github";
 export declare const GITHUB_API_URL = "https://api.github.com";
+export declare const GITHUB_REQUEST_TIMEOUT_MS = 15000;
 export interface GithubConnectorStatus {
     provider: "github";
     connected: boolean;
@@ -14,9 +15,14 @@ export interface GithubApiResponse<T> {
     data: T;
     headers: Headers;
 }
-export declare function getGithubApiUrl(storage: WandStorage): string;
+export interface GithubRequestOptions {
+    token?: string;
+    apiUrl?: string;
+    timeoutMs?: number;
+}
 export declare function getGithubConnectorStatus(storage: WandStorage): GithubConnectorStatus;
-export declare function githubRequest<T = unknown>(storage: WandStorage, pathname: string, init?: RequestInit): Promise<GithubApiResponse<T>>;
-export declare function connectGithub(storage: WandStorage, token: string, apiUrl?: string): Promise<GithubConnectorStatus>;
-export declare function githubStatusWithScopes(storage: WandStorage, scopes?: string[]): GithubConnectorStatus;
-export declare function jsonBody(value: unknown): string;
+export declare function githubRequest<T = unknown>(storage: WandStorage, pathname: string, init?: RequestInit, options?: GithubRequestOptions): Promise<GithubApiResponse<T>>;
+export declare function connectGithub(storage: WandStorage, token: string, apiUrl?: string, options?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<GithubConnectorStatus>;

package/dist/github-connector.js

@@ -1,5 +1,8 @@
 export const GITHUB_PROVIDER = "github";
 export const GITHUB_API_URL = "https://api.github.com";
+export const GITHUB_REQUEST_TIMEOUT_MS = 15_000;
+let connectEpoch = 0;
+let connectAbort = null;
 function normalizeApiUrl(value) {
     const raw = typeof value === "string" && value.trim() ? value.trim() : GITHUB_API_URL;
     let parsed;
@@ -17,9 +20,6 @@ function normalizeApiUrl(value) {
     }
     return parsed.toString().replace(/\/$/, "");
 }
-export function getGithubApiUrl(storage) {
-    return normalizeApiUrl(storage.getConnectorMeta(GITHUB_PROVIDER)?.apiUrl || GITHUB_API_URL);
-}
 export function getGithubConnectorStatus(storage) {
     const meta = storage.getConnectorMeta(GITHUB_PROVIDER);
     const token = storage.getConnectorToken(GITHUB_PROVIDER);
@@ -45,15 +45,52 @@ function apiPath(pathname) {
     }
     return pathname;
 }
-export async function githubRequest(storage, pathname, init = {}) {
+function requestTimeoutError() {
+    const error = new Error("GitHub API 请求超时。");
+    error.status = 504;
+    return error;
+}
+/** Reject when the timeout fires, even if a transport resolves after aborting. */
+function timeoutRejection(timeout) {
+    return new Promise((_resolve, reject) => {
+        if (timeout.aborted) {
+            reject(requestTimeoutError());
+            return;
+        }
+        timeout.addEventListener("abort", () => reject(requestTimeoutError()), { once: true });
+    });
+}
+function snapshotConnector(storage) {
+    return {
+        meta: storage.getConnectorMeta(GITHUB_PROVIDER),
+        token: storage.getConnectorToken(GITHUB_PROVIDER),
+    };
+}
+export async function githubRequest(storage, pathname, init = {}, options) {
+    const token = options?.token?.trim() || connectorToken(storage);
+    const apiUrl = normalizeApiUrl(options?.apiUrl ?? storage.getConnectorMeta(GITHUB_PROVIDER)?.apiUrl ?? GITHUB_API_URL);
     const headers = new Headers(init.headers);
     headers.set("Accept", "application/vnd.github+json");
     headers.set("X-GitHub-Api-Version", "2022-11-28");
     headers.set("User-Agent", "wand-github-connector");
-    headers.set("Authorization", `Bearer ${connectorToken(storage)}`);
+    headers.set("Authorization", `Bearer ${token}`);
     if (init.body !== undefined && !headers.has("Content-Type"))
         headers.set("Content-Type", "application/json");
-    const response = await fetch(`${getGithubApiUrl(storage)}${apiPath(pathname)}`, { ...init, headers });
+    const timeoutMs = options?.timeoutMs ?? GITHUB_REQUEST_TIMEOUT_MS;
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signal = init.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+    let response;
+    try {
+        response = await Promise.race([
+            fetch(`${apiUrl}${apiPath(pathname)}`, { ...init, headers, signal }),
+            timeoutRejection(timeout),
+        ]);
+    }
+    catch (error) {
+        if (timeout.aborted && !init.signal?.aborted)
+            throw requestTimeoutError();
+        throw error;
+    }
     const raw = await response.text();
     let data = null;
     try {
@@ -66,52 +103,87 @@ export async function githubRequest(storage, pathname, init = {}) {
         const message = data && typeof data === "object" && "message" in data && typeof data.message === "string"
             ? data.message
             : `GitHub API 请求失败（${response.status}）。`;
-        const error = new Error(message);
-        error.status = response.status;
-        throw error;
+        const requestError = new Error(message);
+        requestError.status = response.status;
+        throw requestError;
     }
     return { data: data, headers: response.headers };
 }
-export async function connectGithub(storage, token, apiUrl) {
+function parseScopes(headers) {
+    return (headers.get("x-oauth-scopes") || "")
+        .split(",")
+        .map((scope) => scope.trim())
+        .filter(Boolean);
+}
+function restoreConnector(storage, snapshot) {
+    if (snapshot.meta?.connectedAt && snapshot.token) {
+        storage.saveConnector(GITHUB_PROVIDER, {
+            token: snapshot.token,
+            apiUrl: snapshot.meta.apiUrl,
+            username: snapshot.meta.username,
+            markConnected: true,
+        });
+        return;
+    }
+    storage.deleteConnector(GITHUB_PROVIDER);
+}
+/** Undo this attempt's own connector write, without clobbering a newer connect. */
+function rollbackOwnConnectWrite(storage, attempt) {
+    if (attempt.epoch !== connectEpoch || !attempt.wrote)
+        return;
+    const current = snapshotConnector(storage);
+    const wroteThisAttempt = current.token === attempt.token && current.meta?.apiUrl === attempt.apiUrl;
+    if (!wroteThisAttempt)
+        return;
+    restoreConnector(storage, attempt.previous);
+}
+export async function connectGithub(storage, token, apiUrl, options) {
     const normalizedToken = token.trim();
     if (!normalizedToken)
         throw new Error("GitHub Token 不能为空。");
     const targetApiUrl = normalizeApiUrl(apiUrl);
-    const previous = storage.getConnectorMeta(GITHUB_PROVIDER);
-    const previousToken = storage.getConnectorToken(GITHUB_PROVIDER);
-    storage.saveConnector(GITHUB_PROVIDER, { token: normalizedToken, apiUrl: targetApiUrl, markConnected: false });
+    const previous = snapshotConnector(storage);
+    const epoch = ++connectEpoch;
+    connectAbort?.abort();
+    const abort = new AbortController();
+    connectAbort = abort;
+    const signal = options?.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;
+    let wrote = false;
     try {
-        const profile = await githubRequest(storage, "/user");
+        const profile = await githubRequest(storage, "/user", { signal }, {
+            token: normalizedToken,
+            apiUrl: targetApiUrl,
+            timeoutMs: options?.timeoutMs,
+        });
         const username = typeof profile.data.login === "string" ? profile.data.login : "";
         if (!username)
             throw new Error("GitHub 返回的账号信息无效。");
-        const scopes = (profile.headers.get("x-oauth-scopes") || "")
-            .split(",").map((scope) => scope.trim()).filter(Boolean);
+        if (epoch !== connectEpoch)
+            throw new Error("GitHub 连接请求已过期。");
+        const scopes = parseScopes(profile.headers);
         const meta = storage.saveConnector(GITHUB_PROVIDER, {
+            token: normalizedToken,
             apiUrl: targetApiUrl,
             username,
             markConnected: true,
         });
+        wrote = true;
+        if (epoch !== connectEpoch)
+            throw new Error("GitHub 连接请求已过期。");
         return { ...getGithubConnectorStatus(storage), ...meta, provider: "github", connected: true, scopes };
     }
     catch (error) {
-        if (previous?.connectedAt && previousToken) {
-            storage.saveConnector(GITHUB_PROVIDER, {
-                token: previousToken,
-                apiUrl: previous.apiUrl,
-                username: previous.username,
-                markConnected: true,
-            });
-        }
-        else {
-            storage.deleteConnector(GITHUB_PROVIDER);
-        }
+        rollbackOwnConnectWrite(storage, {
+            epoch,
+            token: normalizedToken,
+            apiUrl: targetApiUrl,
+            wrote,
+            previous,
+        });
         throw error;
     }
-}
-export function githubStatusWithScopes(storage, scopes = []) {
-    return { ...getGithubConnectorStatus(storage), scopes };
-}
-export function jsonBody(value) {
-    return JSON.stringify(value);
+    finally {
+        if (connectAbort === abort)
+            connectAbort = null;
+    }
 }

package/dist/missions.d.ts

@@ -20,7 +20,7 @@ export declare class Missions {
     markInboxRead(sessionId?: string): void;
     diff(missionId: string, attemptId: string): MissionDiff;
     addReviewComment(missionId: string, attemptId: string, input: CreateReviewCommentInput): MissionReviewComment;
-    sendReview(missionId: string, attemptId: string, commentIds?: string[]): MissionReviewComment[];
+    sendReview(missionId: string, attemptId: string, commentIds?: string[]): Promise<MissionReviewComment[]>;
     resolveReview(missionId: string, attemptId: string, commentIds: string[]): MissionReviewComment[];
     archive(id: string): MissionDetails;
     private dispatchAttempt;

package/dist/missions.js

@@ -241,7 +241,7 @@ export class Missions {
         this.storage.saveMissionReviewComment(comment);
         return comment;
     }
-    sendReview(missionId, attemptId, commentIds) {
+    async sendReview(missionId, attemptId, commentIds) {
         const attempt = this.requireAttempt(missionId, attemptId);
         if (!attempt.sessionId)
             throw new Error("这个 attempt 没有关联会话。");
@@ -252,11 +252,24 @@ export class Missions {
         const session = this.structured.get(attempt.sessionId);
         if (!session)
             throw new Error("任务会话当前不可用。");
-        const completion = this.structured.sendMessage(attempt.sessionId, reviewPrompt(selected));
-        completion.catch((error) => {
+        const commentIdsToSend = selected.map((comment) => comment.id);
+        const accepted = this.structured.sendMessage(attempt.sessionId, reviewPrompt(selected));
+        // sendMessage settles after the whole turn. Treat microtask acceptance as
+        // "queued or started"; a synchronous/microtask rejection stays pending.
+        try {
+            await Promise.race([
+                accepted,
+                new Promise((resolve) => setImmediate(resolve)),
+            ]);
+        }
+        catch (error) {
             console.error(`[Missions] Review dispatch failed for ${attempt.id}:`, error);
+            throw error;
+        }
+        accepted.catch((error) => {
+            console.error(`[Missions] Review execution failed for ${attempt.id}:`, error);
         });
-        this.storage.updateMissionReviewStatus(selected.map((comment) => comment.id), "sent");
+        this.storage.updateMissionReviewStatus(commentIdsToSend, "sent");
         this.storage.saveMissionAttempt({ ...attempt, state: "working", updatedAt: nowIso() });
         this.refreshMissionStatus(missionId);
         return this.storage.listMissionReviewComments(missionId, attemptId);

package/dist/server-file-routes.js

@@ -129,7 +129,7 @@ export function registerFileRoutes(app, deps) {
                     size: fileStat.size,
                     mime,
                 };
-                res.json(payload);
+                res.json({ ...payload, mtime: fileStat.mtime.toISOString() });
                 return;
             }
             if (fileStat.size > MAX_TEXT_PREVIEW_SIZE) {
@@ -152,7 +152,7 @@ export function registerFileRoutes(app, deps) {
                 lang: getLanguageFromExt(ext, filePath),
                 content,
             };
-            res.json(payload);
+            res.json({ ...payload, mtime: fileStat.mtime.toISOString() });
         }
         catch (error) {
             res.status(400).json({ error: getErrorMessage(error, "Failed to read file") });
@@ -196,6 +196,16 @@ export function registerFileRoutes(app, deps) {
                 res.status(415).json({ error: "仅支持编辑文本类文件。" });
                 return;
             }
+            if (fileChangedSince(body.expectedMtime, body.expectedSize, fileStat)) {
+                res.status(409).json({
+                    error: "文件已被外部修改。",
+                    errorCode: "FILE_CHANGED",
+                    path: resolvedPath,
+                    size: fileStat.size,
+                    mtime: fileStat.mtime.toISOString(),
+                });
+                return;
+            }
             const tmpPath = path.join(path.dirname(resolvedPath), `.${baseName}.wand-tmp-${crypto.randomBytes(6).toString("hex")}`);
             try {
                 await writeFile(tmpPath, content, { encoding: "utf-8", mode: fileStat.mode & 0o777 });
@@ -732,6 +742,37 @@ const RAW_MAX_BYTES_BY_KIND = {
     audio: 200 * 1024 * 1024,
     binary: 50 * 1024 * 1024,
 };
+/** Compare an optional client baseline (mtime and/or size) against the live file. */
+function fileChangedSince(expectedMtime, expectedSize, actual) {
+    const mtime = parseExpectedMtime(expectedMtime);
+    if (mtime && !mtimeEquals(mtime, actual.mtime))
+        return true;
+    const size = parseExpectedSize(expectedSize);
+    return size !== undefined && size !== actual.size;
+}
+function parseExpectedMtime(value) {
+    if (typeof value === "string")
+        return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+        return new Date(value).toISOString();
+    return "";
+}
+function parseExpectedSize(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function mtimeEquals(expected, actual) {
+    if (expected === actual.toISOString())
+        return true;
+    const parsed = Date.parse(expected);
+    return Number.isFinite(parsed) && parsed === actual.getTime();
+}
 function classifyFile(ext, baseName) {
     const lowerExt = ext.toLowerCase();
     const lowerBase = baseName.toLowerCase();

package/dist/server-github-routes.js

@@ -1,5 +1,5 @@
 import { asyncRoute } from "./express-async.js";
-import { connectGithub, githubRequest, githubStatusWithScopes, jsonBody, } from "./github-connector.js";
+import { connectGithub, getGithubConnectorStatus, githubRequest, } from "./github-connector.js";
 import { getErrorMessage } from "./error-utils.js";
 function stringQuery(value, fallback = "") {
     return typeof value === "string" ? value.trim() : fallback;
@@ -8,6 +8,22 @@ function integerQuery(value, fallback, min, max) {
     const parsed = Number(stringQuery(value));
     return Number.isInteger(parsed) && parsed >= min && parsed <= max ? parsed : fallback;
 }
+function githubListQuery(reqQuery, defaults = {}) {
+    const query = new URLSearchParams();
+    if (defaults.state)
+        query.set("state", stringQuery(reqQuery.state, defaults.state));
+    if (stringQuery(reqQuery.labels))
+        query.set("labels", stringQuery(reqQuery.labels));
+    const sort = stringQuery(reqQuery.sort, defaults.sort ?? "");
+    const direction = stringQuery(reqQuery.direction, defaults.direction ?? "");
+    if (sort)
+        query.set("sort", sort);
+    if (direction)
+        query.set("direction", direction);
+    query.set("per_page", String(integerQuery(reqQuery.per_page, 30, 1, 100)));
+    query.set("page", String(integerQuery(reqQuery.page, 1, 1, 10_000)));
+    return query;
+}
 function repoPath(req) {
     const owner = req.params.owner?.trim();
     const repo = req.params.repo?.trim();
@@ -39,11 +55,19 @@ function publicError(error) {
         : 400;
     return { status: status >= 400 && status < 600 ? status : 500, message: getErrorMessage(error, "GitHub 操作失败。") };
 }
+function sendGithubError(res, error, remapAuth = false) {
+    const result = publicError(error);
+    const status = remapAuth && (result.status === 401 || result.status === 403) ? 400 : result.status;
+    res.status(status).json({ error: result.message });
+}
+async function githubJson(storage, pathname, init = {}) {
+    return (await githubRequest(storage, pathname, init)).data;
+}
 export function registerGithubRoutes(app, deps) {
     const { storage, requireAdmin, sessions } = deps;
     app.get("/api/connectors/github", requireAdmin, (_req, res) => {
         res.set("Cache-Control", "no-store");
-        res.json(githubStatusWithScopes(storage));
+        res.json(getGithubConnectorStatus(storage));
     });
     app.post("/api/connectors/github", requireAdmin, asyncRoute(async (req, res) => {
         try {
@@ -54,8 +78,7 @@ export function registerGithubRoutes(app, deps) {
             res.json(await connectGithub(storage, token, apiUrl));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status === 401 || result.status === 403 ? 400 : result.status).json({ error: result.message });
+            sendGithubError(res, error, true);
         }
     }));
     app.delete("/api/connectors/github", requireAdmin, (_req, res) => {
@@ -69,8 +92,7 @@ export function registerGithubRoutes(app, deps) {
             res.json({ bindings });
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     });
     app.post("/api/github/repos/:owner/:repo/issues/:number/bindings", requireAdmin, (req, res) => {
@@ -84,8 +106,7 @@ export function registerGithubRoutes(app, deps) {
             res.status(201).json({ ok: true, sessionId });
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     });
     app.delete("/api/github/repos/:owner/:repo/issues/:number/bindings/:sessionId", requireAdmin, (req, res) => {
@@ -94,17 +115,15 @@ export function registerGithubRoutes(app, deps) {
             res.json({ ok: true });
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     });
     app.get("/api/github/user", requireAdmin, asyncRoute(async (_req, res) => {
         try {
-            res.json((await githubRequest(storage, "/user")).data);
+            res.json(await githubJson(storage, "/user"));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.get("/api/github/repos", requireAdmin, asyncRoute(async (req, res) => {
@@ -124,39 +143,27 @@ export function registerGithubRoutes(app, deps) {
             query.set("per_page", String(integerQuery(req.query.per_page, 30, 1, 100)));
             query.set("page", String(integerQuery(req.query.page, 1, 1, 10_000)));
             const suffix = query.toString();
-            res.json((await githubRequest(storage, `/user/repos?${suffix}`)).data);
+            res.json(await githubJson(storage, `/user/repos?${suffix}`));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.get("/api/github/repos/:owner/:repo", requireAdmin, asyncRoute(async (req, res) => {
         try {
-            res.json((await githubRequest(storage, repoPath(req))).data);
+            res.json(await githubJson(storage, repoPath(req)));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.get("/api/github/repos/:owner/:repo/issues", requireAdmin, asyncRoute(async (req, res) => {
         try {
-            const query = new URLSearchParams();
-            query.set("state", stringQuery(req.query.state, "open"));
-            if (stringQuery(req.query.labels))
-                query.set("labels", stringQuery(req.query.labels));
-            if (stringQuery(req.query.sort))
-                query.set("sort", stringQuery(req.query.sort));
-            if (stringQuery(req.query.direction))
-                query.set("direction", stringQuery(req.query.direction));
-            query.set("per_page", String(integerQuery(req.query.per_page, 30, 1, 100)));
-            query.set("page", String(integerQuery(req.query.page, 1, 1, 10_000)));
-            res.json((await githubRequest(storage, `${repoPath(req)}/issues?${query}`)).data);
+            const query = githubListQuery(req.query, { state: "open" });
+            res.json(await githubJson(storage, `${repoPath(req)}/issues?${query}`));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.post("/api/github/repos/:owner/:repo/issues", requireAdmin, asyncRoute(async (req, res) => {
@@ -167,11 +174,10 @@ export function registerGithubRoutes(app, deps) {
                 if (body[key] !== undefined)
                     payload[key] = body[key];
             }
-            res.status(201).json((await githubRequest(storage, `${repoPath(req)}/issues`, { method: "POST", body: jsonBody(payload) })).data);
+            res.status(201).json(await githubJson(storage, `${repoPath(req)}/issues`, { method: "POST", body: JSON.stringify(payload) }));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.patch("/api/github/repos/:owner/:repo/issues/:number", requireAdmin, asyncRoute(async (req, res) => {
@@ -184,37 +190,29 @@ export function registerGithubRoutes(app, deps) {
             }
             if (!Object.keys(payload).length)
                 throw new Error("没有可更新的 Issue 字段。");
-            res.json((await githubRequest(storage, `${repoPath(req)}/issues/${issueNumber(req)}`, { method: "PATCH", body: jsonBody(payload) })).data);
+            res.json(await githubJson(storage, `${repoPath(req)}/issues/${issueNumber(req)}`, { method: "PATCH", body: JSON.stringify(payload) }));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.post("/api/github/repos/:owner/:repo/issues/:number/comments", requireAdmin, asyncRoute(async (req, res) => {
         try {
             const body = validateObjectBody(req.body);
             const payload = { body: requiredString(body, "body") };
-            res.status(201).json((await githubRequest(storage, `${repoPath(req)}/issues/${issueNumber(req)}/comments`, { method: "POST", body: jsonBody(payload) })).data);
+            res.status(201).json(await githubJson(storage, `${repoPath(req)}/issues/${issueNumber(req)}/comments`, { method: "POST", body: JSON.stringify(payload) }));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.get("/api/github/repos/:owner/:repo/pulls", requireAdmin, asyncRoute(async (req, res) => {
         try {
-            const query = new URLSearchParams();
-            query.set("state", stringQuery(req.query.state, "open"));
-            query.set("sort", stringQuery(req.query.sort, "created"));
-            query.set("direction", stringQuery(req.query.direction, "desc"));
-            query.set("per_page", String(integerQuery(req.query.per_page, 30, 1, 100)));
-            query.set("page", String(integerQuery(req.query.page, 1, 1, 10_000)));
-            res.json((await githubRequest(storage, `${repoPath(req)}/pulls?${query}`)).data);
+            const query = githubListQuery(req.query, { state: "open", sort: "created", direction: "desc" });
+            res.json(await githubJson(storage, `${repoPath(req)}/pulls?${query}`));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
     app.post("/api/github/repos/:owner/:repo/pulls", requireAdmin, asyncRoute(async (req, res) => {
@@ -229,11 +227,10 @@ export function registerGithubRoutes(app, deps) {
                 if (body[key] !== undefined)
                     payload[key] = body[key];
             }
-            res.status(201).json((await githubRequest(storage, `${repoPath(req)}/pulls`, { method: "POST", body: jsonBody(payload) })).data);
+            res.status(201).json(await githubJson(storage, `${repoPath(req)}/pulls`, { method: "POST", body: JSON.stringify(payload) }));
         }
         catch (error) {
-            const result = publicError(error);
-            res.status(result.status).json({ error: result.message });
+            sendGithubError(res, error);
         }
     }));
 }