dsh-git-branch-manage 1.0.6 → 1.0.7

package/lib/client.js

@@ -129,6 +129,8 @@ window.__ModuleLoader__.load({
 		const ROUTE_COMMIT_FILES = `${ROUTE_PREFIX}/commit-files`;
 		/** POST ROUTE_PREFIX/tag — create a tag at an existing commit. */
 		const ROUTE_TAG = `${ROUTE_PREFIX}/tag`;
+		/** POST ROUTE_PREFIX/tag-push — push ONE existing local tag to its remote. */
+		const ROUTE_TAG_PUSH = `${ROUTE_PREFIX}/tag-push`;
 		/** POST ROUTE_PREFIX/ai-commit-message — one-shot LLM commit message from
 		* the staged diff (mounted only where the host provides the llm service). */
 		const ROUTE_AI_COMMIT_MESSAGE = `${ROUTE_PREFIX}/ai-commit-message`;
@@ -433,6 +435,18 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/**
+		* Push ONE local tag to its remote (the host resolves which remote). Unlike
+		* {@link requestPush}, which sends the current branch alone.
+		* @param repoPath - absolute directory inside the repository.
+		* @param name - an existing local tag name (verified host-side).
+		*/
+		function requestPushTag(repoPath, name) {
+			return post(ROUTE_TAG_PUSH, {
+				repoPath,
+				name
+			});
+		}
+		/**
 		* Generate a commit message from the checkout's diff with the requesting
 		* session's own model (a one-shot host llm call).
 		* @param body - the repo path plus the session's model selection and an
@@ -3635,6 +3649,14 @@ window.__ModuleLoader__.load({
 			return badges;
 		}
 		/**
+		* The TAG names one commit's decoration carries, in decoration order — the
+		* per-tag publish targets the commit menu offers. Built on
+		* {@link classifyRefs} so "what counts as a tag" has exactly one definition.
+		*/
+		function commitTags(refs) {
+			return classifyRefs(refs).filter((badge) => badge.kind === "tag").map((badge) => badge.text);
+		}
+		/**
 		* Split the working-tree rows into the two panel groups. Untracked files
 		* render in the unstaged group as `?` (git add still stages them); an
 		* unmerged conflict renders in the unstaged group as `U` unchecked (git add
@@ -4772,8 +4794,11 @@ window.__ModuleLoader__.load({
 		* author, and the absolute commit time. CLICKING a row expands the commit's
 		* changed files INLINE below it (exactly one open at a time), loading them on
 		* first open; RIGHT-CLICKING it opens the commit menu (copy hash, copy
-		* subject, new branch here, tag here), which is where the history card's two
-		* writing verbs live.
+		* subject, new branch here, tag here, and — for every tag the commit already
+		* carries — push that tag), which is where the history card's writing verbs
+		* live. Pushing a tag is offered per EXISTING tag rather than folded into the
+		* branch push: `git push` sends the branch alone, so a tag on an
+		* already-pushed commit would otherwise have no way out of the local repo.
 		*
 		* The head carries the three filters the card asks for, in this order —
 		* author, branch (a ref to pin the walk on, or every ref), and a time window
@@ -4941,7 +4966,7 @@ window.__ModuleLoader__.load({
 			return `${commit.subject} · ${commit.authorName} <${commit.authorEmail}> · ${absolute} · ${commit.short}`;
 		}
 		function HistorySection(props) {
-			const { t, commits, loaded, loadError, loading, hasMore, loadingMore, expanded, filesByHash, filters, branches, busy, onLoadMore, onToggle, onFilters, onCreateBranch, onCreateTag, pushToast } = props;
+			const { t, commits, loaded, loadError, loading, hasMore, loadingMore, expanded, filesByHash, filters, branches, busy, onLoadMore, onToggle, onFilters, onCreateBranch, onCreateTag, onPushTag, pushToast } = props;
 			const [menu, setMenu] = (0, react.useState)(null);
 			const [dialog, setDialog] = (0, react.useState)(null);
 			const [draft, setDraft] = (0, react.useState)("");
@@ -5103,6 +5128,8 @@ window.__ModuleLoader__.load({
 				})
 			}, commit.hash));
 			const dialogTitle = dialog === null ? "" : dialog.kind === "branch" ? t("createFlyAskFrom", { branch: dialog.commit.short }) : t("panel.tagTitle");
+			/** Tags the right-clicked commit carries: one publish item each. */
+			const menuTags = menu === null ? [] : commitTags(menu.commit.refs);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 				className: `${GitHistoryPanel_module_default.section} ${GitHistoryPanel_module_default.sectionFill} ${GitHistoryPanel_module_default.sectionHistory}`,
 				"aria-label": t("panel.history"),
@@ -5177,7 +5204,18 @@ window.__ModuleLoader__.load({
 								disabled: busy,
 								onClick: () => openDialog("tag", menu.commit),
 								children: t("panel.branchTag")
-							})
+							}),
+							menuTags.map((tag) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: GitHistoryPanel_module_default.menuItem,
+								role: "menuitem",
+								disabled: busy,
+								onClick: () => {
+									setMenu(null);
+									onPushTag(tag);
+								},
+								children: t("panel.tagPush", { tag })
+							}, tag))
 						]
 					}) : null,
 					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_deepseek_ai_dsh_client_ui_primitives.Modal, {
@@ -5871,6 +5909,28 @@ window.__ModuleLoader__.load({
 				runGuarded,
 				t
 			]);
+			/** Publish ONE local tag. Its own verb, apart from the branch push: `git
+			* push` sends the branch alone, so a tag made on an already-pushed commit
+			* would otherwise never reach the remote. Deliberately no refetch: tags are
+			* local refs and a remote tag changes nothing the panel can see. */
+			const onPushTag = (0, react.useCallback)((name) => {
+				runGuarded(async () => {
+					const result = await requestPushTag(cwd, name);
+					if (!result.ok) throw new Error(result.error);
+					pushToast(result.pushed ? t("panel.tagPushDone", {
+						tag: result.tag,
+						remote: result.remote
+					}) : t("panel.tagPushUpToDate", {
+						tag: result.tag,
+						remote: result.remote
+					}), "success");
+				});
+			}, [
+				cwd,
+				pushToast,
+				runGuarded,
+				t
+			]);
 			const onToggleCommit = (0, react.useCallback)((hash) => {
 				if (expanded === hash) {
 					setExpanded(null);
@@ -6001,6 +6061,7 @@ window.__ModuleLoader__.load({
 						onFilters: onHistoryFilters,
 						onCreateBranch: onCreate,
 						onCreateTag,
+						onPushTag,
 						pushToast
 					})
 				]
@@ -7389,6 +7450,9 @@ window.__ModuleLoader__.load({
 			"panel.tagName": "Tag name",
 			"panel.tagMessage": "Message (optional)",
 			"panel.tagDone": "Tagged {tag}",
+			"panel.tagPush": "Push tag {tag}",
+			"panel.tagPushDone": "Pushed tag {tag} to {remote}",
+			"panel.tagPushUpToDate": "Tag {tag} is already on {remote}",
 			"panel.noCommits": "This repository has no commits yet",
 			"panel.noMatches": "No matching commits",
 			"panel.loadMore": "Load more",
@@ -7607,6 +7671,9 @@ window.__ModuleLoader__.load({
 			"panel.tagName": "标签名称",
 			"panel.tagMessage": "消息（可选）",
 			"panel.tagDone": "已标记 {tag}",
+			"panel.tagPush": "推送标签 {tag}",
+			"panel.tagPushDone": "已推送标签 {tag} 到 {remote}",
+			"panel.tagPushUpToDate": "标签 {tag} 已存在于 {remote}",
 			"panel.noCommits": "仓库还没有提交",
 			"panel.noMatches": "没有匹配的提交",
 			"panel.loadMore": "加载更多",

package/lib/git.d.ts

@@ -301,6 +301,57 @@ export interface PushOutcome {
  * push-specific diagnostic is preserved; in that case `pushed` is false.
  */
 export declare function pushBranch(exec: Exec, cwd: string): Promise<PushOutcome>;
+/** Every LOCAL tag name of the repository, in git's own sort order. */
+export declare function listTagNames(exec: Exec, cwd: string): Promise<string[]>;
+/** Where a one-off push should go, or why no remote could be picked. */
+export type PushRemoteChoice = {
+    readonly ok: true;
+    readonly remote: string;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * Pick the remote ONE tag push goes to, in fallback order: the checked-out
+ * branch's upstream remote, `remote.pushDefault`, then the only remote there
+ * is. Ambiguity is reported instead of guessed — a tag pushed to the wrong
+ * remote is a published mistake, not an inconvenience.
+ * @param exec - executor seam.
+ * @param cwd - directory whose checked-out branch supplies the upstream.
+ * @returns the remote name, or the caller-side reason none could be chosen.
+ */
+export declare function resolvePushRemote(exec: Exec, cwd: string): Promise<PushRemoteChoice>;
+/** Outcome of {@link pushTag}: the tag, where it went, and whether it moved. */
+export interface TagPushOutcome {
+    tag: string;
+    remote: string;
+    pushed: boolean;
+}
+/**
+ * Push ONE existing local tag to `remote` (`git push <remote>
+ * refs/tags/<name>:refs/tags/<name>`) — the publish step a tag needs and a
+ * branch push never performs: `git push` sends the current branch alone, so a
+ * tag made on an already-pushed commit is invisible to the remote.
+ *
+ * The tag must already exist locally (the route verifies it against
+ * {@link listTagNames}); a remote that already carries the SAME tag object is
+ * reported as `pushed: false` without running the push at all. The refspec
+ * always names both sides explicitly, so no configured push refspec (a mirror,
+ * a `push.default=upstream` branch) can widen what a menu click publishes, and
+ * tags are never deleted or overwritten: `--force` is deliberately absent, and
+ * a remote tag pointing somewhere else makes git refuse (mapped to 400).
+ *
+ * The cn-accelerate rewrite is never injected here (no {@link accelArgs}
+ * parameter exists, like {@link pushBranch}): a mirror has no `receive-pack` —
+ * and the pre-push probe must see the very remote the push targets, or the
+ * `pushed` flag would compare two different servers.
+ * @param exec - executor seam.
+ * @param cwd - any directory inside the repository (tag refs are shared).
+ * @param name - an existing local tag name.
+ * @param remote - the remote to publish to (see {@link resolvePushRemote}).
+ * @returns the tag, the remote, and whether the push had to run.
+ */
+export declare function pushTag(exec: Exec, cwd: string, name: string, remote: string): Promise<TagPushOutcome>;
 /** Guard for route inputs: a non-empty absolute directory path. */
 export declare function isAbsoluteDir(value: string): boolean;
 /** Pre-delete facts of one worktree directory, for the remove-confirm dialog. */

package/lib/git.js

@@ -574,6 +574,73 @@ export async function pushBranch(exec, cwd) {
     const branch = (await gitMaybe(exec, cwd, ['branch', '--show-current']))?.trim() ?? '';
     return { branch, pushed: before !== undefined && after !== undefined && before.trim() !== after.trim() };
 }
+/** Every LOCAL tag name of the repository, in git's own sort order. */
+export async function listTagNames(exec, cwd) {
+    const text = await git(exec, cwd, ['for-each-ref', 'refs/tags', '--format=%(refname:short)']);
+    return text.split('\n').map(line => line.trim()).filter(line => line !== '');
+}
+/**
+ * Pick the remote ONE tag push goes to, in fallback order: the checked-out
+ * branch's upstream remote, `remote.pushDefault`, then the only remote there
+ * is. Ambiguity is reported instead of guessed — a tag pushed to the wrong
+ * remote is a published mistake, not an inconvenience.
+ * @param exec - executor seam.
+ * @param cwd - directory whose checked-out branch supplies the upstream.
+ * @returns the remote name, or the caller-side reason none could be chosen.
+ */
+export async function resolvePushRemote(exec, cwd) {
+    const upstream = (await gitMaybe(exec, cwd, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']))?.trim() ?? '';
+    const slash = upstream.indexOf('/');
+    if (slash > 0)
+        return { ok: true, remote: upstream.slice(0, slash) };
+    const pushDefault = (await gitMaybe(exec, cwd, ['config', '--get', 'remote.pushDefault']))?.trim() ?? '';
+    if (pushDefault !== '')
+        return { ok: true, remote: pushDefault };
+    const remotes = ((await gitMaybe(exec, cwd, ['remote'])) ?? '')
+        .split('\n').map(line => line.trim()).filter(line => line !== '');
+    const only = remotes.length === 1 ? remotes[0] : undefined;
+    if (only !== undefined)
+        return { ok: true, remote: only };
+    return { ok: false, message: remotes.length === 0
+            ? 'no remote to push the tag to: the current branch has no upstream and the repository has none either'
+            : `multiple remotes (${remotes.join(', ')}) and the current branch has no upstream: set one, or git config remote.pushDefault <name>` };
+}
+/**
+ * Push ONE existing local tag to `remote` (`git push <remote>
+ * refs/tags/<name>:refs/tags/<name>`) — the publish step a tag needs and a
+ * branch push never performs: `git push` sends the current branch alone, so a
+ * tag made on an already-pushed commit is invisible to the remote.
+ *
+ * The tag must already exist locally (the route verifies it against
+ * {@link listTagNames}); a remote that already carries the SAME tag object is
+ * reported as `pushed: false` without running the push at all. The refspec
+ * always names both sides explicitly, so no configured push refspec (a mirror,
+ * a `push.default=upstream` branch) can widen what a menu click publishes, and
+ * tags are never deleted or overwritten: `--force` is deliberately absent, and
+ * a remote tag pointing somewhere else makes git refuse (mapped to 400).
+ *
+ * The cn-accelerate rewrite is never injected here (no {@link accelArgs}
+ * parameter exists, like {@link pushBranch}): a mirror has no `receive-pack` —
+ * and the pre-push probe must see the very remote the push targets, or the
+ * `pushed` flag would compare two different servers.
+ * @param exec - executor seam.
+ * @param cwd - any directory inside the repository (tag refs are shared).
+ * @param name - an existing local tag name.
+ * @param remote - the remote to publish to (see {@link resolvePushRemote}).
+ * @returns the tag, the remote, and whether the push had to run.
+ */
+export async function pushTag(exec, cwd, name, remote) {
+    const ref = `refs/tags/${name}`;
+    const local = (await git(exec, cwd, ['rev-parse', '--verify', ref])).trim();
+    const listed = await gitMaybe(exec, cwd, ['ls-remote', '--refs', remote, ref], NETWORK_TIMEOUT_MS);
+    const present = (listed ?? '').split('\n')
+        .map(line => line.trim().split(/\s+/)[0] ?? '')
+        .includes(local);
+    if (present)
+        return { tag: name, remote, pushed: false };
+    await git(exec, cwd, ['push', remote, `${ref}:${ref}`], NETWORK_TIMEOUT_MS);
+    return { tag: name, remote, pushed: true };
+}
 /** Guard for route inputs: a non-empty absolute directory path. */
 export function isAbsoluteDir(value) {
     return value.trim() !== '' && isAbsolute(value);

package/lib/index.js

@@ -9,9 +9,9 @@ import { homedir } from 'node:os';
 import z from '@deepseek-ai/schemastery';
 import { childProcessExec } from './git.js';
 import { ACCEL_DEFAULT_URL, accelerateUrlError } from './normalize.js';
-import { handleAiCommitMessage, handleChanges, handleCommit, handleCommitFiles, handleCreateBranch, handleCreateTag, handleCreateWorktree, handleDeleteBranch, handleEnsureDirectory, handleFetch, handleGroupWorktrees, handleInspectWorktree, handleLog, handlePathExists, handlePurgeDirectory, handleRemoveWorktree, handleRenameBranch, handleStage, handleStatus, handleSwitch, handleUpdate, handlePush, handleWorktreesAll, } from './routes.js';
+import { handleAiCommitMessage, handleChanges, handleCommit, handleCommitFiles, handleCreateBranch, handleCreateTag, handleCreateWorktree, handleDeleteBranch, handleEnsureDirectory, handleFetch, handleGroupWorktrees, handleInspectWorktree, handleLog, handlePathExists, handlePurgeDirectory, handlePushTag, handleRemoveWorktree, handleRenameBranch, handleStage, handleStatus, handleSwitch, handleUpdate, handlePush, handleWorktreesAll, } from './routes.js';
 import { validateRootDir } from './settings.js';
-import { ROUTE_AI_COMMIT_MESSAGE, ROUTE_BRANCH, ROUTE_BRANCH_DELETE, ROUTE_BRANCH_RENAME, ROUTE_CHANGES, ROUTE_COMMIT, ROUTE_COMMIT_FILES, ROUTE_ENSURE_DIRECTORY, ROUTE_EXISTS, ROUTE_FETCH, ROUTE_GROUP, ROUTE_INSPECT, ROUTE_LOG, ROUTE_PUSH, ROUTE_PURGE, ROUTE_REMOVE, ROUTE_STAGE, ROUTE_STATUS, ROUTE_SWITCH, ROUTE_TAG, ROUTE_UPDATE, ROUTE_WORKTREE, ROUTE_WORKTREES_ALL } from './wire.js';
+import { ROUTE_AI_COMMIT_MESSAGE, ROUTE_BRANCH, ROUTE_BRANCH_DELETE, ROUTE_BRANCH_RENAME, ROUTE_CHANGES, ROUTE_COMMIT, ROUTE_COMMIT_FILES, ROUTE_ENSURE_DIRECTORY, ROUTE_EXISTS, ROUTE_FETCH, ROUTE_GROUP, ROUTE_INSPECT, ROUTE_LOG, ROUTE_PUSH, ROUTE_PURGE, ROUTE_REMOVE, ROUTE_STAGE, ROUTE_STATUS, ROUTE_SWITCH, ROUTE_TAG, ROUTE_TAG_PUSH, ROUTE_UPDATE, ROUTE_WORKTREE, ROUTE_WORKTREES_ALL } from './wire.js';
 export const name = 'dsh-git-branch';
 export const inject = [];
 /** Largest accepted request body (bytes) — these payloads are a few strings. */
@@ -228,6 +228,7 @@ export function apply(ctx, config = {}) {
         postRoute(ROUTE_LOG, 'log', handleLog);
         postRoute(ROUTE_COMMIT_FILES, 'commit-files', handleCommitFiles);
         postRoute(ROUTE_TAG, 'tag', handleCreateTag);
+        postRoute(ROUTE_TAG_PUSH, 'tag-push', handlePushTag);
         // The AI commit-message route exists only where the host tree provides
         // the dsh-llm service: the injection resolves once the service is up and
         // never fires without it, so an llm-less deployment answers 404 and the

package/lib/routes.d.ts

@@ -4,7 +4,7 @@
  */
 import { type CopyFilesSeams } from './copy-files.js';
 import { type DirExists, type ExcludeSeams, type Exec } from './git.js';
-import type { AiCommitMessageResult, ChangesResult, CommitFilesResult, CommitResult, CreateBranchResult, CreateTagResult, CreateWorktreeResult, EnsureDirectoryResult, FetchResult, GroupWorkspacesResult, InspectWorktreeResult, LogResult, PathExistsResult, PurgeDirectoryResult, RemoveWorktreeResult, RepoStatus, RouteError, StageResult, SwitchResult, UpdateResult, WorktreesAllResult } from './wire.js';
+import type { AiCommitMessageResult, ChangesResult, CommitFilesResult, CommitResult, CreateBranchResult, CreateTagResult, CreateWorktreeResult, EnsureDirectoryResult, FetchResult, GroupWorkspacesResult, InspectWorktreeResult, LogResult, PathExistsResult, PurgeDirectoryResult, PushTagResult, RemoveWorktreeResult, RepoStatus, RouteError, StageResult, SwitchResult, UpdateResult, WorktreesAllResult } from './wire.js';
 /** Everything the handlers need from the host half. */
 export interface RouteDeps {
     exec: Exec;
@@ -50,7 +50,7 @@ export declare function fsMkdirRecursive(path: string): Promise<void>;
 /** One route outcome: HTTP status plus the JSON body. */
 export interface RouteOutcome {
     status: number;
-    body: RepoStatus | CreateWorktreeResult | SwitchResult | CreateBranchResult | FetchResult | UpdateResult | GroupWorkspacesResult | InspectWorktreeResult | RemoveWorktreeResult | PathExistsResult | EnsureDirectoryResult | WorktreesAllResult | PurgeDirectoryResult | ChangesResult | StageResult | CommitResult | LogResult | CommitFilesResult | CreateTagResult | AiCommitMessageResult | RouteError;
+    body: RepoStatus | CreateWorktreeResult | SwitchResult | CreateBranchResult | FetchResult | UpdateResult | GroupWorkspacesResult | InspectWorktreeResult | RemoveWorktreeResult | PathExistsResult | EnsureDirectoryResult | WorktreesAllResult | PurgeDirectoryResult | ChangesResult | StageResult | CommitResult | LogResult | CommitFilesResult | CreateTagResult | PushTagResult | AiCommitMessageResult | RouteError;
 }
 /**
  * POST /group — git belonging facts for a batch of workspace directories.
@@ -293,6 +293,21 @@ export declare function handleLog(deps: RouteDeps, body: unknown): Promise<Route
  * @param body - parsed request body: `{ repoPath, name, target?, message? }`.
  */
 export declare function handleCreateTag(deps: RouteDeps, body: unknown): Promise<RouteOutcome>;
+/**
+ * POST /tag-push — publish ONE existing local tag to a remote. Separate from
+ * `POST /push` on purpose: a branch push sends the branch alone, so a tag on
+ * an already-pushed commit needs its own verb.
+ *
+ * The name must match a LOCAL tag this repository actually has (checked
+ * against `for-each-ref refs/tags`), so no free string ever reaches git as a
+ * flag or a refspec; the remote is resolved server-side and an ambiguous
+ * choice is 400. A remote that already carries the same tag object answers
+ * `pushed: false` (nothing was sent); a diverged remote tag is git's own
+ * refusal, mapped to 400 by {@link gitFailure} — never forced.
+ * @param deps - host dependencies.
+ * @param body - parsed request body: `{ repoPath, name }`.
+ */
+export declare function handlePushTag(deps: RouteDeps, body: unknown): Promise<RouteOutcome>;
 /**
  * POST /commit-files — the files one commit of the queried checkout changed.
  * The hash is verified server-side; unknown revisions answer 400.

package/lib/routes.js

@@ -5,7 +5,7 @@
 import { basename, dirname, join, resolve } from 'node:path';
 import { mkdir, readdir, rm, stat } from 'node:fs/promises';
 import { runPostCreateCopy } from './copy-files.js';
-import { appendWorktreeExclude, fsExcludeSeams, GitError, addWorktree, addWorktreeCutout, collectAiDiff, commitFiles, commitIndex, createBranch, createTag, cutoutBranchName, deleteBranch, fetchAll, fsDirExists, inspectWorktree, isAbsoluteDir, isStageablePath, logHistory, probeRepo, probeWorkspaceGit, removeWorktree, renameBranch, resolveBranch, pushBranch, stagePaths, switchBranch, updateBranch, workingChanges } from './git.js';
+import { appendWorktreeExclude, fsExcludeSeams, GitError, addWorktree, addWorktreeCutout, collectAiDiff, commitFiles, commitIndex, createBranch, createTag, cutoutBranchName, deleteBranch, fetchAll, fsDirExists, inspectWorktree, isAbsoluteDir, isStageablePath, listTagNames, logHistory, probeRepo, probeWorkspaceGit, pushTag, removeWorktree, renameBranch, resolveBranch, resolvePushRemote, pushBranch, stagePaths, switchBranch, updateBranch, workingChanges } from './git.js';
 import { ACCEL_DEFAULT_URL, accelerateUrlError, isAbsoluteConfigPath, normalizeAccelerateUrl, sanitizeBranchDir } from './normalize.js';
 import { resolveRootDir } from './settings.js';
 import { COMMIT_MESSAGE_LIMIT } from './wire.js';
@@ -1009,6 +1009,8 @@ export const LOG_LIMIT_MAX = 200;
 /** Bound for the author filter and the tag annotation (characters). */
 const LOG_AUTHOR_LIMIT = 200;
 const TAG_MESSAGE_LIMIT = 5000;
+/** Bound for one tag NAME (characters), shared by create and push. */
+const TAG_NAME_LIMIT = 300;
 /**
  * POST /log — one page of the queried checkout's history. The optional `ref`
  * is verified server-side (`rev-parse --verify`), an unborn checkout answers
@@ -1087,8 +1089,8 @@ export async function handleCreateTag(deps, body) {
     // A leading dash would ride `git tag` as a flag — reject before the exec.
     if (name.startsWith('-'))
         return fail(400, '"name" must not start with "-"');
-    if (name.length > 300)
-        return fail(400, '"name" must be at most 300 characters');
+    if (name.length > TAG_NAME_LIMIT)
+        return fail(400, `"name" must be at most ${String(TAG_NAME_LIMIT)} characters`);
     // The target lands on `git tag <name> <target>` verbatim: restrict it to the
     // object id shape the history card sends rather than trusting a free string.
     if (target !== undefined && !/^[0-9a-fA-F]{4,64}$/.test(target)) {
@@ -1113,6 +1115,57 @@ export async function handleCreateTag(deps, body) {
         return fail(500, error instanceof Error ? error.message : String(error));
     }
 }
+/**
+ * POST /tag-push — publish ONE existing local tag to a remote. Separate from
+ * `POST /push` on purpose: a branch push sends the branch alone, so a tag on
+ * an already-pushed commit needs its own verb.
+ *
+ * The name must match a LOCAL tag this repository actually has (checked
+ * against `for-each-ref refs/tags`), so no free string ever reaches git as a
+ * flag or a refspec; the remote is resolved server-side and an ambiguous
+ * choice is 400. A remote that already carries the same tag object answers
+ * `pushed: false` (nothing was sent); a diverged remote tag is git's own
+ * refusal, mapped to 400 by {@link gitFailure} — never forced.
+ * @param deps - host dependencies.
+ * @param body - parsed request body: `{ repoPath, name }`.
+ */
+export async function handlePushTag(deps, body) {
+    const parsed = readBody(body, ['repoPath', 'name']);
+    if (isOutcome(parsed))
+        return parsed;
+    const { repoPath, name } = parsed;
+    if (!isAbsoluteDir(repoPath))
+        return fail(400, '"repoPath" must be an absolute directory');
+    if (name.trim() === '')
+        return fail(400, '"name" must be non-empty');
+    // A leading dash would ride `git push` as a flag — reject before the exec.
+    if (name.startsWith('-'))
+        return fail(400, '"name" must not start with "-"');
+    if (name.length > TAG_NAME_LIMIT)
+        return fail(400, `"name" must be at most ${String(TAG_NAME_LIMIT)} characters`);
+    try {
+        const facts = await probeRepo(deps.exec, repoPath, deps.dirExists);
+        if (facts === undefined)
+            return fail(400, `"${repoPath}" is not inside a git repository`);
+        // The push runs at the queried directory's own toplevel, so the remote is
+        // the one ITS checked-out branch tracks (a linked worktree publishes the
+        // remote its own branch knows); tags themselves are repository-wide.
+        const tags = await listTagNames(deps.exec, facts.toplevel);
+        if (!tags.includes(name))
+            return fail(400, `"${name}" is not a local tag`);
+        const choice = await resolvePushRemote(deps.exec, facts.toplevel);
+        if (!choice.ok)
+            return fail(400, choice.message);
+        const result = await pushTag(deps.exec, facts.toplevel, name, choice.remote);
+        const body = result;
+        return { status: 200, body };
+    }
+    catch (error) {
+        if (error instanceof GitError)
+            return gitFailure(error);
+        return fail(500, error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * POST /commit-files — the files one commit of the queried checkout changed.
  * The hash is verified server-side; unknown revisions answer 400.

package/lib/wire.d.ts

@@ -55,6 +55,8 @@ export declare const ROUTE_LOG = "/plugin/git-worktree/log";
 export declare const ROUTE_COMMIT_FILES = "/plugin/git-worktree/commit-files";
 /** POST ROUTE_PREFIX/tag — create a tag at an existing commit. */
 export declare const ROUTE_TAG = "/plugin/git-worktree/tag";
+/** POST ROUTE_PREFIX/tag-push — push ONE existing local tag to its remote. */
+export declare const ROUTE_TAG_PUSH = "/plugin/git-worktree/tag-push";
 /** POST ROUTE_PREFIX/ai-commit-message — one-shot LLM commit message from
  * the staged diff (mounted only where the host provides the llm service). */
 export declare const ROUTE_AI_COMMIT_MESSAGE = "/plugin/git-worktree/ai-commit-message";
@@ -508,6 +510,23 @@ export interface CreateTagResult {
     /** The commit hash the tag points at. */
     hash: string;
 }
+/** POST tag-push request body. */
+export interface PushTagBody {
+    /** Any directory inside the repository (tag refs are repository-wide). */
+    repoPath: string;
+    /** An EXISTING local tag name, verified server-side before any push. */
+    name: string;
+}
+/** POST tag-push response body. */
+export interface PushTagResult {
+    /** The tag that was the subject of the push. */
+    tag: string;
+    /** The remote the tag was pushed to (resolved server-side). */
+    remote: string;
+    /** False when the remote already carried this exact tag object — nothing
+     * was sent. True once the push command actually ran. */
+    pushed: boolean;
+}
 /** One file row of POST commit-files. */
 export interface CommitFileEntry {
     /** New path, relative to the repository root. */

package/lib/wire.js

@@ -55,6 +55,8 @@ export const ROUTE_LOG = `${ROUTE_PREFIX}/log`;
 export const ROUTE_COMMIT_FILES = `${ROUTE_PREFIX}/commit-files`;
 /** POST ROUTE_PREFIX/tag — create a tag at an existing commit. */
 export const ROUTE_TAG = `${ROUTE_PREFIX}/tag`;
+/** POST ROUTE_PREFIX/tag-push — push ONE existing local tag to its remote. */
+export const ROUTE_TAG_PUSH = `${ROUTE_PREFIX}/tag-push`;
 /** POST ROUTE_PREFIX/ai-commit-message — one-shot LLM commit message from
  * the staged diff (mounted only where the host provides the llm service). */
 export const ROUTE_AI_COMMIT_MESSAGE = `${ROUTE_PREFIX}/ai-commit-message`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-git-branch-manage",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "提供 git 分支与 worktree 管理：输入框工具栏显示当前分支、可原地切换；支持 IDEA 风格分支选择器、远程分支检出、右键操作菜单（新建/重命名/删除/复制）、推送与更新当前分支，以及把分支隔离到独立 worktree 工作区，并管理其创建与删除。",
   "keywords": [
     "dsh",