@co0ontty/wand 1.25.3 → 1.26.0

package/README.md

@@ -31,6 +31,18 @@ wand web
 
 安装完成后打开浏览器访问终端中提示的地址即可。
 
+### 升级
+
+推荐用同一条一键脚本升级（脚本会自动停掉正在运行的 wand 进程、清理 npm 改名残留再装最新版）：
+
+```bash
+bash <(curl -Ls https://raw.githubusercontent.com/co0ontty/wand/master/install.sh)
+```
+
+> 也可以直接在网页设置里点「更新」按钮，或在 TUI 模式按 `u`，wand 自己会调用同样的清理逻辑。Web 端点击更新后会自动重启服务，无需手动操作。
+
+如果以前装过 systemd 自启服务但还是 `Restart=on-failure`（v1.25.x 前的版本），重新进入 TUI 按一次 `i` 重装服务即可换成 `Restart=always`，自动更新后才能正确拉起新进程。
+
 ## 功能
 
 <p align="center">

package/dist/git-quick-commit.d.ts

@@ -1,4 +1,4 @@
-import { GitStatusResult, QuickCommitResult } from "./types.js";
+import { GitStatusResult, PushResult, QuickCommitResult, TagHeadResult } from "./types.js";
 export declare function getGitStatus(cwd: string): GitStatusResult;
 interface QuickCommitOptions {
     cwd: string;
@@ -20,5 +20,21 @@ export interface GenerateCommitMessageResult {
     suggestedTag?: string;
 }
 export declare function generateCommitMessageOnly(cwd: string, language: string): Promise<GenerateCommitMessageResult>;
+interface TagHeadOptions {
+    cwd: string;
+    language: string;
+    /** Explicit tag name. If empty and `autoTag` is true, ask Claude to generate one. */
+    tag?: string;
+    autoTag?: boolean;
+    /** Push only this tag to its upstream remote after creating it. */
+    push?: boolean;
+}
+export declare function runTagHead(opts: TagHeadOptions): Promise<TagHeadResult>;
+interface PushOptions {
+    cwd: string;
+    pushCommits?: boolean;
+    pushTags?: boolean;
+}
+export declare function runPush(opts: PushOptions): Promise<PushResult>;
 export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;
 export {};

package/dist/git-quick-commit.js

@@ -141,6 +141,86 @@ export function getGitStatus(cwd) {
     }
     const allEntries = parsePorcelainV2(porcelain);
     const files = allEntries.slice(0, MAX_FILE_ENTRIES);
+    // Upstream / ahead / behind ──────────────────────────────────────────
+    let hasUpstream = false;
+    let upstream;
+    let ahead;
+    let behind;
+    if (!initialCommit) {
+        try {
+            upstream = runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd) || undefined;
+            hasUpstream = !!upstream;
+        }
+        catch {
+            hasUpstream = false;
+        }
+        if (hasUpstream) {
+            try {
+                const counts = runGit(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], cwd);
+                const parts = counts.split(/\s+/).filter(Boolean);
+                if (parts.length === 2) {
+                    const b = Number.parseInt(parts[0], 10);
+                    const a = Number.parseInt(parts[1], 10);
+                    if (!Number.isNaN(a))
+                        ahead = a;
+                    if (!Number.isNaN(b))
+                        behind = b;
+                }
+            }
+            catch {
+                // ignore — keep counts undefined
+            }
+        }
+    }
+    // HEAD commit info ───────────────────────────────────────────────────
+    let lastCommit;
+    if (!initialCommit) {
+        try {
+            const raw = runGit(["log", "-1", "--pretty=format:%H%x09%h%x09%s"], cwd);
+            const parts = raw.split("\t");
+            if (parts.length >= 3) {
+                lastCommit = { hash: parts[0], shortHash: parts[1], subject: parts.slice(2).join("\t") };
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Unpushed tag count (best-effort; remote refs may not be fresh) ─────
+    let unpushedTagCount;
+    if (hasUpstream && upstream) {
+        const slashIdx = upstream.indexOf("/");
+        const remoteName = slashIdx > 0 ? upstream.slice(0, slashIdx) : "origin";
+        try {
+            const localTagsRaw = runGit(["for-each-ref", "--format=%(refname:short)", "refs/tags"], cwd);
+            const localTags = localTagsRaw.split(/\r?\n/).filter((t) => t.trim().length > 0);
+            if (localTags.length === 0) {
+                unpushedTagCount = 0;
+            }
+            else {
+                const remoteTagsRaw = runGit(["ls-remote", "--tags", remoteName], cwd, 3000);
+                const remoteTags = new Set();
+                for (const line of remoteTagsRaw.split(/\r?\n/)) {
+                    // format: <sha>\trefs/tags/<name>{^}? — strip annotated suffix
+                    const tabIdx = line.indexOf("\t");
+                    if (tabIdx === -1)
+                        continue;
+                    const ref = line.slice(tabIdx + 1).trim();
+                    if (!ref.startsWith("refs/tags/"))
+                        continue;
+                    let name = ref.slice("refs/tags/".length);
+                    if (name.endsWith("^{}"))
+                        name = name.slice(0, -3);
+                    if (name)
+                        remoteTags.add(name);
+                }
+                unpushedTagCount = localTags.filter((t) => !remoteTags.has(t)).length;
+            }
+        }
+        catch {
+            // remote unreachable — leave undefined so UI can hide the chip
+        }
+    }
     return {
         isGit: true,
         branch,
@@ -149,6 +229,12 @@ export function getGitStatus(cwd) {
         head,
         repoRoot,
         initialCommit,
+        hasUpstream,
+        upstream,
+        ahead,
+        behind,
+        lastCommit,
+        unpushedTagCount,
     };
 }
 export class QuickCommitError extends Error {
@@ -356,7 +442,165 @@ ${diff}`;
     }
     return suggested;
 }
-// ── Direct git operations ──
+/**
+ * Push current branch (with upstream auto-setup) and/or tags.
+ * Errors are returned via `error` so callers can present partial-success states.
+ */
+function doPush(cwd, pushCommits, pushTags) {
+    let pushedCommits = false;
+    let pushedTags = false;
+    let hasUpstream = false;
+    let pushRemote = "origin";
+    try {
+        runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
+        hasUpstream = true;
+        try {
+            const currentBranch = runGit(["branch", "--show-current"], cwd);
+            if (currentBranch) {
+                pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
+            }
+        }
+        catch {
+            pushRemote = "origin";
+        }
+    }
+    catch {
+        hasUpstream = false;
+    }
+    try {
+        if (pushCommits) {
+            if (hasUpstream) {
+                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            else {
+                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            pushedCommits = true;
+        }
+        if (pushTags) {
+            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
+            pushedTags = true;
+        }
+        return { pushedCommits, pushedTags };
+    }
+    catch (error) {
+        return { pushedCommits, pushedTags, error: getGitErrorMessage(error) };
+    }
+}
+export async function runTagHead(opts) {
+    const { cwd, language, tag, autoTag, push } = opts;
+    if (!cwd || !existsSync(cwd)) {
+        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+    }
+    let isInside;
+    try {
+        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+    }
+    if (isInside !== "true") {
+        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+    }
+    // Need an existing commit to tag
+    let headHash;
+    try {
+        headHash = runGit(["rev-parse", "HEAD"], cwd);
+    }
+    catch {
+        throw new QuickCommitError("仓库还没有任何 commit，无法打 tag。", "NO_COMMIT");
+    }
+    let tagName = (tag || "").trim();
+    if (!tagName && autoTag) {
+        // Reuse the post-commit generator — it inspects `git show HEAD` directly.
+        let headSubject = "";
+        try {
+            headSubject = runGit(["log", "-1", "--pretty=format:%s"], cwd);
+        }
+        catch {
+            headSubject = "";
+        }
+        tagName = await generateTagAfterCommit(cwd, language, headSubject || "");
+    }
+    if (!tagName) {
+        throw new QuickCommitError("请填写 tag 名称，或开启 AI 生成。", "EMPTY_TAG");
+    }
+    // Refuse to overwrite an existing tag — surface a clear error code.
+    try {
+        runGit(["rev-parse", "--verify", `refs/tags/${tagName}`], cwd);
+        throw new QuickCommitError(`tag \`${tagName}\` 已存在。`, "TAG_EXISTS");
+    }
+    catch (error) {
+        if (error instanceof QuickCommitError)
+            throw error;
+        // not found — good, proceed
+    }
+    try {
+        runGit(["tag", tagName], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
+    }
+    let pushed = false;
+    let pushError;
+    if (push) {
+        let pushRemote = "origin";
+        try {
+            const currentBranch = runGit(["branch", "--show-current"], cwd);
+            if (currentBranch) {
+                try {
+                    pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
+                }
+                catch {
+                    pushRemote = "origin";
+                }
+            }
+        }
+        catch {
+            pushRemote = "origin";
+        }
+        try {
+            // Push just this one tag — cheaper and more targeted than `--tags`.
+            runGit(["push", pushRemote, `refs/tags/${tagName}`], cwd, GIT_PUSH_TIMEOUT_MS);
+            pushed = true;
+        }
+        catch (error) {
+            pushError = getGitErrorMessage(error);
+        }
+    }
+    return {
+        ok: true,
+        tag: { name: tagName, commit: headHash.slice(0, 7) },
+        pushed,
+        pushError,
+    };
+}
+export async function runPush(opts) {
+    const { cwd, pushCommits = true, pushTags = false } = opts;
+    if (!cwd || !existsSync(cwd)) {
+        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+    }
+    if (!pushCommits && !pushTags) {
+        throw new QuickCommitError("没有要推送的内容。", "NOTHING_TO_PUSH");
+    }
+    let isInside;
+    try {
+        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+    }
+    if (isInside !== "true") {
+        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+    }
+    const outcome = doPush(cwd, pushCommits, pushTags);
+    return {
+        ok: !outcome.error,
+        pushedCommits: outcome.pushedCommits,
+        pushedTags: outcome.pushedTags,
+        error: outcome.error,
+    };
+}
 export async function runQuickCommit(opts) {
     const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
     if (!cwd || !existsSync(cwd)) {
@@ -435,37 +679,9 @@ export async function runQuickCommit(opts) {
     let pushed = false;
     let pushError;
     if (push) {
-        try {
-            let hasUpstream = false;
-            let pushRemote = "origin";
-            try {
-                runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-                hasUpstream = true;
-                try {
-                    const currentBranch = runGit(["branch", "--show-current"], cwd);
-                    if (currentBranch) {
-                        pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
-                    }
-                }
-                catch {
-                    pushRemote = "origin";
-                }
-            }
-            catch {
-                hasUpstream = false;
-            }
-            if (hasUpstream) {
-                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            else {
-                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
-            pushed = true;
-        }
-        catch (error) {
-            pushError = getGitErrorMessage(error);
-        }
+        const outcome = doPush(cwd, true, !!tagName);
+        pushed = outcome.pushedCommits && (tagName ? outcome.pushedTags : true);
+        pushError = outcome.error;
     }
     return {
         ok: true,

package/dist/npm-update-utils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * npm 全局更新通用辅助。
+ *
+ * 共用于 server.ts 的 /api/update / performAutoUpdate，以及 TUI 的 installUpdate。
+ *
+ * 解决的核心问题：当 wand 进程正在运行（systemd/launchd/nohup/直接前台都算）时，
+ * `npm install -g @co0ontty/wand@latest` 会把旧包目录 rename 成 `.wand-XXXXXX` 备份。
+ * 如果安装中途失败，这个备份目录会留下，之后每次 npm install 都会因为目标 dest 已存在
+ * 报 `ENOTEMPTY: directory not empty, rename ...`。
+ *
+ * 我们的策略：每次 npm install 之前先清掉 `@co0ontty/.wand-*` 残留目录；
+ * 如果第一次安装仍然撞上 ENOTEMPTY，清理后重试；再不行就 uninstall + force install。
+ */
+/**
+ * 解析当前 `npm root -g` 的目录。失败返回 null。
+ */
+export declare function getNpmGlobalRoot(): string | null;
+/**
+ * 清理上一次 npm install 失败留下的 `.wand-XXXXXX` 残留目录。
+ *
+ * 同步执行，best-effort：找不到 npm root、目录不存在、无权限删除等都不会抛错。
+ * 返回被清理的目录列表，方便调用方记录日志。
+ */
+export declare function cleanupNpmLeftovers(): {
+    removed: string[];
+    errors: string[];
+};
+/**
+ * 异步版本的全局安装：
+ * 1. 清理残留
+ * 2. `npm install -g <pkg>`
+ * 3. 撞上 ENOTEMPTY/EEXIST：再清一次 + 重试一次
+ * 4. 再不行：`npm uninstall -g <pkg-no-tag>` + `npm install -g --force <pkg>`
+ *
+ * @param pkg 包名带版本，例如 `@co0ontty/wand@latest`
+ * @param timeoutMs 单次 npm 调用超时
+ * @param log 可选 logger，用来把过程写入控制台或前端日志
+ */
+export declare function installPackageGloballyAsync(pkg: string, timeoutMs: number, log?: (line: string) => void): Promise<void>;
+/**
+ * 同步版本，给 TUI installUpdate 用。
+ *
+ * 返回值兼容 spawnSync：包含最后一次尝试的 stdout/stderr/status。
+ */
+export declare function installPackageGloballySync(pkg: string, timeoutMs: number): {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    attempts: string[];
+};
+export declare const NPM_UPDATE_PACKAGE_NAME = "@co0ontty/wand";

package/dist/npm-update-utils.js

@@ -0,0 +1,171 @@
+/**
+ * npm 全局更新通用辅助。
+ *
+ * 共用于 server.ts 的 /api/update / performAutoUpdate，以及 TUI 的 installUpdate。
+ *
+ * 解决的核心问题：当 wand 进程正在运行（systemd/launchd/nohup/直接前台都算）时，
+ * `npm install -g @co0ontty/wand@latest` 会把旧包目录 rename 成 `.wand-XXXXXX` 备份。
+ * 如果安装中途失败，这个备份目录会留下，之后每次 npm install 都会因为目标 dest 已存在
+ * 报 `ENOTEMPTY: directory not empty, rename ...`。
+ *
+ * 我们的策略：每次 npm install 之前先清掉 `@co0ontty/.wand-*` 残留目录；
+ * 如果第一次安装仍然撞上 ENOTEMPTY，清理后重试；再不行就 uninstall + force install。
+ */
+import { exec, spawnSync } from "node:child_process";
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+const PACKAGE_NAME = "@co0ontty/wand";
+const PACKAGE_SCOPE = "@co0ontty";
+const PACKAGE_BASENAME = "wand";
+/**
+ * 解析当前 `npm root -g` 的目录。失败返回 null。
+ */
+export function getNpmGlobalRoot() {
+    try {
+        const res = spawnSync("npm", ["root", "-g"], { encoding: "utf8", timeout: 10_000 });
+        if (res.status !== 0)
+            return null;
+        const out = (res.stdout || "").trim();
+        return out.length > 0 ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 清理上一次 npm install 失败留下的 `.wand-XXXXXX` 残留目录。
+ *
+ * 同步执行，best-effort：找不到 npm root、目录不存在、无权限删除等都不会抛错。
+ * 返回被清理的目录列表，方便调用方记录日志。
+ */
+export function cleanupNpmLeftovers() {
+    const removed = [];
+    const errors = [];
+    const root = getNpmGlobalRoot();
+    if (!root)
+        return { removed, errors };
+    const scopeDir = path.join(root, PACKAGE_SCOPE);
+    if (!existsSync(scopeDir))
+        return { removed, errors };
+    let entries;
+    try {
+        entries = readdirSync(scopeDir);
+    }
+    catch (err) {
+        errors.push(`readdir ${scopeDir}: ${err instanceof Error ? err.message : String(err)}`);
+        return { removed, errors };
+    }
+    // 残留目录形如 `.wand-PdFXStca`：以点开头 + 包基名 + 短横线 + 随机后缀
+    const leftoverPattern = new RegExp(`^\\.${PACKAGE_BASENAME}-[A-Za-z0-9]+$`);
+    for (const name of entries) {
+        if (!leftoverPattern.test(name))
+            continue;
+        const fullPath = path.join(scopeDir, name);
+        try {
+            // 仅清理目录，避免误删同名文件
+            if (!statSync(fullPath).isDirectory())
+                continue;
+            rmSync(fullPath, { recursive: true, force: true });
+            removed.push(fullPath);
+        }
+        catch (err) {
+            errors.push(`rm ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { removed, errors };
+}
+/**
+ * 异步版本的全局安装：
+ * 1. 清理残留
+ * 2. `npm install -g <pkg>`
+ * 3. 撞上 ENOTEMPTY/EEXIST：再清一次 + 重试一次
+ * 4. 再不行：`npm uninstall -g <pkg-no-tag>` + `npm install -g --force <pkg>`
+ *
+ * @param pkg 包名带版本，例如 `@co0ontty/wand@latest`
+ * @param timeoutMs 单次 npm 调用超时
+ * @param log 可选 logger，用来把过程写入控制台或前端日志
+ */
+export async function installPackageGloballyAsync(pkg, timeoutMs, log) {
+    const note = (line) => {
+        if (log)
+            log(line);
+    };
+    const cleanup = cleanupNpmLeftovers();
+    if (cleanup.removed.length > 0) {
+        note(`[wand] 清理 npm 残留目录: ${cleanup.removed.join(", ")}`);
+    }
+    try {
+        await execAsync(`npm install -g ${pkg}`, { timeout: timeoutMs });
+        return;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!/ENOTEMPTY|EEXIST/.test(msg)) {
+            throw error;
+        }
+        note(`[wand] npm install 遇到 ENOTEMPTY/EEXIST，清理后重试一次...`);
+    }
+    cleanupNpmLeftovers();
+    try {
+        await execAsync(`npm install -g ${pkg}`, { timeout: timeoutMs });
+        return;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!/ENOTEMPTY|EEXIST/.test(msg)) {
+            throw error;
+        }
+        note(`[wand] 重试仍失败，尝试先卸载再强制安装...`);
+    }
+    // 终极兜底：uninstall + force install
+    const baseName = pkg.replace(/@[^@/]*$/, ""); // strip @latest / @1.2.3
+    try {
+        await execAsync(`npm uninstall -g ${baseName}`, { timeout: timeoutMs });
+    }
+    catch {
+        /* 卸载失败也继续，下一步 --force 可能仍然能装上 */
+    }
+    cleanupNpmLeftovers();
+    await execAsync(`npm install -g --force ${pkg}`, { timeout: timeoutMs });
+}
+/**
+ * 同步版本，给 TUI installUpdate 用。
+ *
+ * 返回值兼容 spawnSync：包含最后一次尝试的 stdout/stderr/status。
+ */
+export function installPackageGloballySync(pkg, timeoutMs) {
+    const attempts = [];
+    const tryInstall = (extra) => {
+        const args = ["install", "-g", ...extra, pkg];
+        attempts.push(`npm ${args.join(" ")}`);
+        const r = spawnSync("npm", args, { encoding: "utf8", timeout: timeoutMs });
+        return {
+            status: r.status,
+            stdout: r.stdout || "",
+            stderr: r.stderr || "",
+        };
+    };
+    cleanupNpmLeftovers();
+    let res = tryInstall([]);
+    if (res.status === 0)
+        return { ...res, attempts };
+    const hitENOTEMPTY = (r) => /ENOTEMPTY|EEXIST/.test(r.stdout + r.stderr);
+    if (!hitENOTEMPTY(res))
+        return { ...res, attempts };
+    cleanupNpmLeftovers();
+    res = tryInstall([]);
+    if (res.status === 0)
+        return { ...res, attempts };
+    if (!hitENOTEMPTY(res))
+        return { ...res, attempts };
+    // 终极兜底
+    const baseName = pkg.replace(/@[^@/]*$/, "");
+    attempts.push(`npm uninstall -g ${baseName}`);
+    spawnSync("npm", ["uninstall", "-g", baseName], { encoding: "utf8", timeout: timeoutMs });
+    cleanupNpmLeftovers();
+    res = tryInstall(["--force"]);
+    return { ...res, attempts };
+}
+export const NPM_UPDATE_PACKAGE_NAME = PACKAGE_NAME;

package/dist/server-session-routes.js

@@ -1,7 +1,7 @@
 import express from "express";
 import { SessionInputError } from "./process-manager.js";
 import { checkSessionWorktreeMergeability, cleanupSessionWorktree, getWorktreeMergeErrorCode, mergeSessionWorktree, WorktreeMergeError } from "./git-worktree.js";
-import { getGitStatus, QuickCommitError, runQuickCommit, generateCommitMessageOnly } from "./git-quick-commit.js";
+import { getGitStatus, QuickCommitError, runQuickCommit, runTagHead, runPush, generateCommitMessageOnly, } from "./git-quick-commit.js";
 export function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
@@ -388,6 +388,63 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "生成 commit message 失败。") });
         }
     });
+    app.post("/api/sessions/:id/git/tag-head", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runTagHead({
+                cwd: snapshot.cwd,
+                language: config.language ?? "",
+                tag: typeof body.tag === "string" ? body.tag : undefined,
+                autoTag: !!body.autoTag,
+                push: !!body.push,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                const status = error.code === "TAG_EXISTS" ? 409 : 400;
+                res.status(status).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "打 tag 失败。") });
+        }
+    });
+    app.post("/api/sessions/:id/git/push", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runPush({
+                cwd: snapshot.cwd,
+                pushCommits: body.pushCommits !== false,
+                pushTags: !!body.pushTags,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                res.status(400).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "推送失败。") });
+        }
+    });
     app.post("/api/sessions/:id/worktree/cleanup", (req, res) => {
         try {
             const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));