@chainingintention/pi-web-cn 2.0.0 → 2.202610.1

package/dist/pi-web-plugins/git/browser/pi-web-plugin.js

@@ -1,10 +1,34 @@
 // Generated from pi-web-plugins/git/browser/pi-web-plugin.ts. Do not edit directly.
+import { setTranslator } from "./i18n.js";
 import { createGitBrowserContributions } from "./git-panel.js";
+const stylesheetIntegrationCapability = {
+    pluginId: "pi-web", id: "stylesheet-integration", version: 1,
+    parse: (value) => {
+        if (!isStylesheetIntegration(value)) {
+            throw new Error("Invalid PI WEB stylesheet integration capability v1");
+        }
+        return value;
+    },
+};
+function isStylesheetIntegration(value) {
+    return typeof value === "object" && value !== null
+        && "registerRoot" in value && typeof value.registerRoot === "function"
+        && "subscribe" in value && typeof value.subscribe === "function"
+        && "createController" in value && typeof value.createController === "function";
+}
 const plugin = {
-    apiVersion: 2,
+    apiVersion: 4,
     name: "Git",
-    activate: ({ pluginId, runtimePluginId, html, svg }) => ({
-        contributions: createGitBrowserContributions(pluginId, runtimePluginId ?? pluginId, html, svg),
-    }),
+    requires: [stylesheetIntegrationCapability],
+    activate: ({ pluginId, runtimePluginId, html, svg, translate }) => {
+        setTranslator(translate);
+        let stylesheetIntegration;
+        return {
+            start: ({ capabilities }) => {
+                stylesheetIntegration = capabilities.resolve(stylesheetIntegrationCapability);
+            },
+            contributions: createGitBrowserContributions(pluginId, runtimePluginId, html, svg, () => stylesheetIntegration),
+        };
+    },
 };
 export default plugin;

package/dist/pi-web-plugins/git/git-backend.js

@@ -1,38 +1,58 @@
 // Generated from pi-web-plugins/git/git-backend.ts. Do not edit directly.
+import { t } from "./i18n.js";
 import { createHash } from "node:crypto";
 import { realpath } from "node:fs/promises";
+import { GitStatusCache } from "./gitStatusCache.js";
 import { isAbsolute, join, relative, sep } from "node:path";
 import { GIT_DIFF_OPERATION, GIT_STATUS_OPERATION, } from "./browser/git-contract.js";
 export { GIT_DIFF_OPERATION, GIT_STATUS_OPERATION } from "./browser/git-contract.js";
 const GIT_COMMAND_TIMEOUT_MS = 10_000;
+const statusCaches = new WeakMap();
 const GIT_LOCAL_ENV_VARS = Object.freeze([
     "GIT_ALTERNATE_OBJECT_DIRECTORIES",
     "GIT_COMMON_DIR",
+    "GIT_CONFIG",
+    "GIT_CONFIG_COUNT",
+    "GIT_CONFIG_PARAMETERS",
     "GIT_DIR",
+    "GIT_GRAFT_FILE",
+    "GIT_IMPLICIT_WORK_TREE",
     "GIT_INDEX_FILE",
+    "GIT_NO_REPLACE_OBJECTS",
     "GIT_OBJECT_DIRECTORY",
     "GIT_PREFIX",
     "GIT_QUARANTINE_PATH",
+    "GIT_REPLACE_REF_BASE",
+    "GIT_SHALLOW_FILE",
     "GIT_WORK_TREE",
 ]);
-/** Dispatch the Git-owned status/diff schema through the provider's public request seam. */
+/** Dispatch the Git status/diff schema through the package peer request seam. */
 export async function requestGitBackend(activationContext, request) {
     const runGit = createGitRunner(activationContext, request.signal);
     if (request.operation === GIT_STATUS_OPERATION) {
         requireStatusInput(request.input);
-        return statusProviderResponse(await gitStatusWithRunner(runGit, request.workspace.path));
+        let cache = statusCaches.get(activationContext);
+        if (cache === undefined) {
+            cache = new GitStatusCache((cwd, signal) => gitStatus(activationContext, cwd, signal));
+            statusCaches.set(activationContext, cache);
+        }
+        const key = JSON.stringify([request.project.id, request.project.path, request.workspace.id, request.workspace.path, request.workspace.provider]);
+        return statusPeerResponse(await cache.get(key, request.workspace.path, request.signal, request.input !== null));
     }
     if (request.operation === GIT_DIFF_OPERATION) {
-        return diffProviderResponse(await gitDiffWithRunner(runGit, request.workspace.path, parseDiffInput(request.input)));
+        return diffPeerResponse(await gitDiffWithRunner(runGit, request.workspace.path, parseDiffInput(request.input)));
     }
     throw new Error(`Unsupported Git workspace backend operation: ${request.operation}`);
 }
+export async function gitStatus(context, cwd, signal) {
+    return gitStatusWithRunner(createGitRunner(context, signal), cwd);
+}
 async function gitStatusWithRunner(runGit, cwd) {
     const result = await runGit(cwd, ["status", "--porcelain=v2", "--branch", "--untracked-files=all", "-z"]);
     if (result.code !== 0)
-        return { isGitRepo: false, hash: hash(result.stdout + result.stderr), files: [], submodules: [] };
-    const parsed = parseStatus(result.stdout, { deferSubmodules: true });
-    return expandSubmodules(runGit, cwd, parsed, result.stdout);
+        return { isGitRepo: false, hash: hash(result.stdout + result.stderr), files: [], submodules: [], ...(result.truncated ? { truncated: true } : {}) };
+    const parsed = parseStatus(result.truncated ? result.stdout.slice(0, result.stdout.lastIndexOf("\0") + 1) : result.stdout, { deferSubmodules: true });
+    return expandSubmodules(runGit, await gitWorktreeRoot(runGit, cwd), parsed, result.stdout, result.truncated);
 }
 /**
  * Merge each dirty submodule's own changes into the flat file list. A moved
@@ -41,7 +61,7 @@ async function gitStatusWithRunner(runGit, cwd) {
  * entries under `<submodule>/<inner path>`. A plain `-dirty` pointer (commit
  * unchanged) is intentionally not surfaced as a pointer entry.
  */
-async function expandSubmodules(runGit, cwd, parsed, topRaw) {
+async function expandSubmodules(runGit, cwd, parsed, topRaw, topTruncated) {
     // Fan out concurrently — one `git status` per dirty submodule plus one
     // `git rev-parse` per unstaged pointer move — then concatenate in input
     // order so the file list and hash are identical to a serial pass.
@@ -55,10 +75,12 @@ async function expandSubmodules(runGit, cwd, parsed, topRaw) {
     const files = [...parsed.files];
     const dirtySubmodulePaths = [];
     let extraForHash = "";
+    let truncated = topTruncated;
     for (const part of expanded) {
         dirtySubmodulePaths.push(part.path);
         files.push(...part.files);
         extraForHash += part.extraForHash;
+        truncated ||= part.truncated;
     }
     return {
         isGitRepo: true,
@@ -69,12 +91,14 @@ async function expandSubmodules(runGit, cwd, parsed, topRaw) {
         ...(parsed.behind === undefined ? {} : { behind: parsed.behind }),
         files,
         submodules: dirtySubmodulePaths,
+        ...(truncated ? { truncated: true } : {}),
     };
 }
 /** Expand one dirty submodule: the pointer entry first, then its inner files. */
 async function expandSubmodule(runGit, sub, location) {
     const files = [];
     let extraForHash = "";
+    let truncated = false;
     if (sub.commitChanged) {
         files.push({
             path: sub.path,
@@ -86,9 +110,10 @@ async function expandSubmodule(runGit, sub, location) {
     }
     if ((sub.hasModifiedContent || sub.hasUntrackedContent) && location !== undefined) {
         const inner = await runGit(location.cwd, ["status", "--porcelain=v2", "--untracked-files=all", "-z"]);
+        truncated = inner.truncated;
         if (inner.code === 0) {
             extraForHash = `\0${sub.path}\0${inner.stdout}`;
-            const innerFiles = parseStatus(inner.stdout, { deferSubmodules: false }).files;
+            const innerFiles = parseStatus(inner.truncated ? inner.stdout.slice(0, inner.stdout.lastIndexOf("\0") + 1) : inner.stdout, { deferSubmodules: false }).files;
             for (const file of innerFiles) {
                 files.push({
                     ...file,
@@ -99,7 +124,7 @@ async function expandSubmodule(runGit, sub, location) {
         }
         // non-zero exit: uninitialized / unreadable submodule — skip silently
     }
-    return { files, extraForHash };
+    return { files, extraForHash, truncated };
 }
 async function resolveSubmoduleToCommit(runGit, cwd, sub) {
     // Staged pointer moves already expose the new commit as the index OID; an
@@ -111,11 +136,16 @@ async function resolveSubmoduleToCommit(runGit, cwd, sub) {
     const resolved = head.stdout.trim();
     return head.code === 0 && resolved !== "" ? resolved : sub.indexOid;
 }
+export async function gitDiff(context, cwd, options, signal) {
+    return gitDiffWithRunner(createGitRunner(context, signal), cwd, options);
+}
 async function gitDiffWithRunner(runGit, cwd, options) {
     const staged = options.staged === true;
     let path;
     if (options.path !== undefined && options.path !== "")
         path = normalizeRelativePath(options.path);
+    // Diff/status paths belong to the repository, not a folder project's session cwd.
+    cwd = await gitWorktreeRoot(runGit, cwd);
     if (path !== undefined) {
         const owner = await submoduleForPath(runGit, cwd, path);
         if (owner !== undefined)
@@ -128,11 +158,11 @@ async function gitDiffWithRunner(runGit, cwd, options) {
         args.push("--", path);
     const result = await runGit(cwd, args);
     if (result.code !== 0)
-        throw new Error(result.stderr.trim() || "git diff 执行失败");
+        throw new Error(result.stderr.trim() || t("ui.main.0a7b52df3fee", "git diff failed"));
     if (!staged && path !== undefined && result.stdout === "" && await isUntracked(runGit, cwd, path)) {
         const untracked = await runGit(cwd, ["diff", "--no-ext-diff", "--color=never", "--no-index", "/dev/null", "--", path]);
         if (untracked.code !== 0 && untracked.code !== 1)
-            throw new Error(untracked.stderr.trim() || "git diff 执行失败");
+            throw new Error(untracked.stderr.trim() || t("ui.main.0a7b52df3fee", "git diff failed"));
         return { path, staged, hash: hash(untracked.stdout), diff: untracked.stdout, truncated: untracked.truncated };
     }
     return { ...(path === undefined ? {} : { path }), staged, hash: hash(result.stdout), diff: result.stdout, truncated: result.truncated };
@@ -152,15 +182,24 @@ async function submoduleDiff(runGit, owner, path, staged) {
     args.push("--", rel);
     const result = await runGit(subCwd, args);
     if (result.code !== 0)
-        throw new Error(result.stderr.trim() || "git diff 执行失败");
+        throw new Error(result.stderr.trim() || t("ui.main.0a7b52df3fee", "git diff failed"));
     if (!staged && result.stdout === "" && await isUntracked(runGit, subCwd, rel)) {
         const untracked = await runGit(subCwd, ["diff", "--no-ext-diff", "--color=never", "--no-index", "/dev/null", "--", rel]);
         if (untracked.code !== 0 && untracked.code !== 1)
-            throw new Error(untracked.stderr.trim() || "git diff 执行失败");
+            throw new Error(untracked.stderr.trim() || t("ui.main.0a7b52df3fee", "git diff failed"));
         return { path, staged, hash: hash(untracked.stdout), diff: untracked.stdout, truncated: untracked.truncated };
     }
     return { path, staged, hash: hash(result.stdout), diff: result.stdout, truncated: result.truncated };
 }
+async function gitWorktreeRoot(runGit, cwd) {
+    const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    if (result.code !== 0)
+        throw new Error(result.stderr.trim() || t("git.cwdRootUnavailable", "Cannot resolve Git worktree root"));
+    const root = result.stdout.replace(/\r?\n$/u, "");
+    if (!isAbsolute(root))
+        throw new Error(t("git.cwdRootInvalid", "Git returned an invalid worktree root"));
+    return root;
+}
 async function isUntracked(runGit, cwd, path) {
     const result = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z", "--", path]);
     return result.code === 0 && result.stdout.split("\0").includes(path);
@@ -345,7 +384,7 @@ function displayFromCommit(headOid) {
 function hash(value) {
     return createHash("sha1").update(value).digest("hex");
 }
-function statusProviderResponse(status) {
+function statusPeerResponse(status) {
     return {
         isGitRepo: status.isGitRepo,
         hash: status.hash,
@@ -362,9 +401,10 @@ function statusProviderResponse(status) {
             ...(file.submoduleToCommit === undefined ? {} : { submoduleToCommit: file.submoduleToCommit }),
         })),
         submodules: status.submodules,
+        ...(status.truncated === true ? { truncated: true } : {}),
     };
 }
-function diffProviderResponse(diff) {
+function diffPeerResponse(diff) {
     return {
         ...(diff.path === undefined ? {} : { path: diff.path }),
         staged: diff.staged,
@@ -397,21 +437,21 @@ function commandResult(result, args) {
     };
 }
 function requireStatusInput(input) {
-    if (input !== null)
-        throw new Error("Git 状态输入必须为 null");
+    if (input !== null && !(isRecord(input) && input["refresh"] === true && Object.keys(input).length === 1))
+        throw new Error(t("ui.main.ec33070a9080", "Git status input must be null or a refresh object"));
 }
 function parseDiffInput(input) {
     if (!isRecord(input))
-        throw new Error("Git 差异输入必须是对象");
+        throw new Error(t("ui.main.4ae7ff3e02c0", "Git diff input must be an object"));
     const unsupported = Object.keys(input).find((key) => key !== "path" && key !== "staged");
     if (unsupported !== undefined)
-        throw new Error(`Git 差异输入包含不支持的字段：${unsupported}`);
+        throw new Error(t("ui.main.629f180b2bba", "Git diff input contains an unsupported field: {arg0}", { arg0: unsupported }));
     const path = input["path"];
     const staged = input["staged"];
     if (path !== undefined && typeof path !== "string")
-        throw new Error("Git 差异输入的 path 必须是字符串");
+        throw new Error(t("ui.main.f1d20e0c6fa6", "Git diff input path must be a string"));
     if (staged !== undefined && typeof staged !== "boolean")
-        throw new Error("Git 差异输入的 staged 必须是布尔值");
+        throw new Error(t("ui.main.bebd7c4f895a", "Git diff input staged must be a boolean"));
     return {
         ...(path === undefined ? {} : { path }),
         ...(staged === undefined ? {} : { staged }),

package/dist/pi-web-plugins/git/gitStatusCache.js

@@ -0,0 +1,48 @@
+// Generated from pi-web-plugins/git/gitStatusCache.ts. Do not edit directly.
+/** Completed snapshots are shared; cancellable scans belong to their exact invocation signal. */
+export class GitStatusCache {
+    scan;
+    now;
+    entries = new Map();
+    constructor(scan, now = Date.now) {
+        this.scan = scan;
+        this.now = now;
+    }
+    get(key, cwd, signal, force = false) {
+        signal.throwIfAborted();
+        const entry = this.entries.get(key) ?? { expires: 0, generation: 0, pending: new Map() };
+        const pending = entry.pending.get(signal);
+        if (pending !== undefined)
+            return pending;
+        if (!force && entry.value !== undefined && entry.expires > this.now())
+            return Promise.resolve(entry.value);
+        this.entries.set(key, entry);
+        if (force)
+            delete entry.value;
+        const generation = ++entry.generation;
+        const request = Promise.resolve().then(() => this.scan(cwd, signal)).then((status) => {
+            signal.throwIfAborted();
+            if (entry.generation === generation) {
+                if (status.isGitRepo) {
+                    entry.value = status;
+                    entry.expires = this.now() + 2000;
+                }
+                else
+                    delete entry.value;
+            }
+            return status;
+        }).catch((error) => {
+            if (entry.generation === generation)
+                delete entry.value;
+            throw error;
+        }).finally(() => {
+            entry.pending.delete(signal);
+            for (const [oldKey, old] of this.entries) {
+                if (old.pending.size === 0 && (old.value === undefined || old.expires <= this.now()))
+                    this.entries.delete(oldKey);
+            }
+        });
+        entry.pending.set(signal, request);
+        return request;
+    }
+}

package/dist/pi-web-plugins/git/i18n.js

@@ -0,0 +1,7 @@
+// Generated from pi-web-plugins/git/i18n.ts. Do not edit directly.
+let translate;
+export function setTranslator(value) {
+    translate = value;
+}
+export const t = (key, fallback, params) => translate?.(key, fallback, params)
+    ?? fallback.replace(/\{([A-Za-z0-9_]+)\}/g, (match, name) => String(params?.[name] ?? match));

package/dist/pi-web-plugins/git/package.json

@@ -6,6 +6,7 @@
     "plugins": [
       {
         "id": "git",
+        "browserRoot": "browser",
         "module": "browser/pi-web-plugin.js",
         "serverModule": "server-plugin.js",
         "machineSpecific": true

package/dist/pi-web-plugins/git/server-plugin.js

@@ -1,47 +1,68 @@
 // Generated from pi-web-plugins/git/server-plugin.ts. Do not edit directly.
+import { t, setTranslator } from "./i18n.js";
 import { basename, resolve } from "node:path";
 import { requestGitBackend } from "./git-backend.js";
+import { createWorkspaceDiscoveryHooks } from "./workspaceDiscoveryHooks.js";
 const GIT_LOCAL_ENV_VARS = Object.freeze([
     "GIT_ALTERNATE_OBJECT_DIRECTORIES",
     "GIT_COMMON_DIR",
+    "GIT_CONFIG",
+    "GIT_CONFIG_COUNT",
+    "GIT_CONFIG_PARAMETERS",
     "GIT_DIR",
+    "GIT_GRAFT_FILE",
+    "GIT_IMPLICIT_WORK_TREE",
     "GIT_INDEX_FILE",
+    "GIT_NO_REPLACE_OBJECTS",
     "GIT_OBJECT_DIRECTORY",
     "GIT_PREFIX",
     "GIT_QUARANTINE_PATH",
+    "GIT_REPLACE_REF_BASE",
+    "GIT_SHALLOW_FILE",
     "GIT_WORK_TREE",
 ]);
 const plugin = {
-    apiVersion: 1,
+    apiVersion: 3,
     name: "Git",
     activate(context) {
-        return { workspaceProvider: createGitWorkspaceProvider(context) };
+        setTranslator(context.translate);
+        return {
+            workspaceProvider: createGitWorkspaceProvider(context, process.env["PI_WEB_INSTANCE_NAMESPACE"] ?? ""),
+            peer: { request: (request) => requestGitBackend(context, request) },
+        };
     },
 };
 export default plugin;
-export function createGitWorkspaceProvider(context) {
+export function createGitWorkspaceProvider(context, instanceNamespace = "") {
     return Object.freeze({
         fallback: true,
+        integration: createWorkspaceDiscoveryHooks(context, (cwd, args, signal) => runGit(context, cwd, args, signal), process.execPath, instanceNamespace),
         async probe(project, signal) {
             const result = await runGit(context, project.path, ["rev-parse", "--is-inside-work-tree"], signal);
             if (result.signal !== null)
-                throw new Error(`git repository probe ended from signal ${result.signal}`);
+                throw new Error(t("ui.main.8919cbc9c0bd", "Git repository probe ended with signal {arg0}", { arg0: result.signal }));
             if (result.exitCode !== 0)
                 return "pass";
-            return result.stdout.trim() === "true" ? "claim" : "pass";
+            if (result.stdout.trim() !== "true")
+                return "pass";
+            const root = await requireGit(runGit(context, project.path, ["rev-parse", "--show-toplevel"], signal), t("ui.main.49c35c822771", "resolve the Git worktree root"));
+            if (root.stdout.trim() === "")
+                throw new Error(t("ui.main.f1639c9e2fd7", "Git returned an empty worktree root"));
+            // A folder project keeps its cwd; only checkout roots own worktree discovery.
+            return resolve(root.stdout.trim()) === resolve(project.path) ? "claim" : "pass";
         },
         async list(project, signal) {
-            const rootResult = await requireGit(runGit(context, project.path, ["rev-parse", "--show-toplevel"], signal), "解析 Git 工作树根目录");
+            const rootResult = await requireGit(runGit(context, project.path, ["rev-parse", "--show-toplevel"], signal), t("ui.main.49c35c822771", "resolve the Git worktree root"));
             const mainRootOutput = rootResult.stdout.trim();
             if (mainRootOutput === "")
-                throw new Error("Git 返回了空的工作树根目录");
+                throw new Error(t("ui.main.f1639c9e2fd7", "Git returned an empty worktree root"));
             const mainRoot = resolve(mainRootOutput);
-            const commonDirectoryResult = await requireGit(runGit(context, project.path, ["rev-parse", "--git-common-dir"], signal), "resolve the Git common directory");
+            const commonDirectoryResult = await requireGit(runGit(context, project.path, ["rev-parse", "--git-common-dir"], signal), t("ui.main.d59fce8c03cf", "resolve the Git common directory"));
             const commonDirectoryOutput = commonDirectoryResult.stdout.trim();
             if (commonDirectoryOutput === "")
-                throw new Error("Git 返回了空的公共目录");
+                throw new Error(t("ui.main.8d51c7fbda53", "Git returned an empty common directory"));
             const commonDirectory = resolve(project.path, commonDirectoryOutput);
-            const listResult = await requireGit(runGit(context, project.path, ["worktree", "list", "--porcelain", "-z"], signal), "列出 Git 工作树");
+            const listResult = await requireGit(runGit(context, project.path, ["worktree", "list", "--porcelain", "-z"], signal), t("ui.main.09734cee0f68", "list Git worktrees"));
             const worktrees = parseGitWorktreeList(listResult.stdout)
                 .filter((worktree) => worktree.bare !== true)
                 .map((worktree) => {
@@ -60,7 +81,7 @@ export function createGitWorkspaceProvider(context) {
             if (selectable.length === 0)
                 return [singleGitWorkspace(project)];
             return selectable.map(({ worktree, path, isMain }) => {
-                const label = worktree.branch ?? (worktree.detached === true ? "游离 HEAD" : basename(worktree.path) || worktree.path);
+                const label = worktree.branch ?? (worktree.detached === true ? t("ui.workspaceGitPanel.detachedHead", "Detached HEAD") : basename(worktree.path) || worktree.path);
                 return {
                     key: path,
                     path,
@@ -80,22 +101,21 @@ export function createGitWorkspaceProvider(context) {
                 };
             });
         },
-        request: (request) => requestGitBackend(context, request),
         async prepareRemove({ project, workspace, signal }) {
             const privatePath = gitPrivateWorktreePath(workspace);
             if (resolve(privatePath) !== workspace.path) {
-                throw new Error("Git 工作区删除数据与当前工作区路径不再匹配");
+                throw new Error(t("ui.main.ee323b371b28", "Git workspace removal data no longer matches the current workspace path"));
             }
-            const listResult = await requireGit(runGit(context, project.path, ["worktree", "list", "--porcelain", "-z"], signal), "删除前验证 Git 工作树");
+            const listResult = await requireGit(runGit(context, project.path, ["worktree", "list", "--porcelain", "-z"], signal), t("ui.main.67b7774d37e3", "validate the Git worktree before removal"));
             const current = parseGitWorktreeList(listResult.stdout)
                 .find((worktree) => resolve(worktree.path) === workspace.path);
             if (current === undefined || current.prunable === true) {
-                throw new Error("Git 工作树已不可用于删除");
+                throw new Error(t("ui.main.2eaaec45ffc2", "Git worktree is no longer available for removal"));
             }
             if (current.bare === true)
-                throw new Error("裸 Git 仓库不能作为链接工作树删除");
+                throw new Error(t("ui.main.e316bd0c1e32", "A bare Git workspace cannot be removed as a linked worktree"));
             return {
-                title: `删除工作区：${workspace.label}`,
+                title: t("ui.shared.168f8f19045c", "Delete workspace: {workspace}", { workspace: workspace.label }),
                 command: `git worktree remove ${shellQuote(workspace.path)}`,
             };
         },
@@ -137,18 +157,18 @@ function singleGitWorkspace(project) {
 }
 function gitRemovalPresentation(label, path) {
     return {
-        actionLabel: "删除工作区",
-        confirmation: `删除工作区 ${label}？\n\n此操作将运行 git worktree remove 并删除：\n${path}\n\n不会删除对应的 Git 分支。`,
+        actionLabel: t("client.actions.delete.workspace.1bca7e", "Delete workspace"),
+        confirmation: t("ui.main.8e2b2416adcd", "Delete workspace {arg0}?\n\nThis runs git worktree remove and deletes:\n{arg1}\n\nThe corresponding Git branch will not be deleted.", { arg0: label, arg1: path }),
     };
 }
 function gitPrivateWorktreePath(workspace) {
     const data = workspace.data;
     if (typeof data !== "object" || data === null || Array.isArray(data)) {
-        throw new Error("Git 工作区删除数据不可用");
+        throw new Error(t("ui.main.b6c981521483", "Git workspace removal data is unavailable"));
     }
     const path = Reflect.get(data, "worktreePath");
     if (typeof path !== "string" || path === "")
-        throw new Error("用于删除的 Git 工作树路径不可用");
+        throw new Error(t("ui.main.2f42169d50eb", "Git worktree path is unavailable for removal"));
     return path;
 }
 function shellQuote(value) {
@@ -159,10 +179,11 @@ async function runGit(context, cwd, args, signal) {
         file: "git",
         args: ["-C", cwd, ...args],
         unsetEnv: GIT_LOCAL_ENV_VARS,
+        timeoutMs: 10_000,
         signal,
     });
     if (result.stdoutTruncated || result.stderrTruncated) {
-        throw new Error(`git ${args.join(" ")} exceeded the host output limit`);
+        throw new Error(t("ui.main.f1dbb26bf138", "git {arg0} exceeded the host output limit", { arg0: args.join(" ") }));
     }
     return result;
 }
@@ -171,6 +192,6 @@ async function requireGit(resultPromise, action) {
     if (result.signal === null && result.exitCode === 0)
         return result;
     const detail = result.stderr.trim();
-    const outcome = result.signal === null ? `exit ${String(result.exitCode)}` : `signal ${result.signal}`;
-    throw new Error(`Unable to ${action} (${outcome})${detail === "" ? "" : `: ${detail}`}`);
+    const outcome = result.signal === null ? t("client.shellMessages.exit.code.2beadf", "Exit code {value1}", { value1: String(result.exitCode) }) : t("ui.main.c008196ee907", "signal {arg0}", { arg0: result.signal });
+    throw new Error(t("ui.main.0def9a625382", "Could not {arg0} ({arg1}){arg2}", { arg0: action, arg1: outcome, arg2: detail === "" ? "" : `：${detail}` }));
 }

package/dist/pi-web-plugins/git/workspace-discovery-notify.cjs

@@ -0,0 +1,14 @@
+// Packaged with PI WEB: best-effort discovery hint, never Git authority.
+const { spawnSync } = require("node:child_process");
+const [notification, ...args] = process.argv.slice(2);
+
+// Initial worktree checkout has a null previous OID and branch flag 1.
+// --no-checkout skips this hook; ordinary catalog access still discovers it.
+if (args.length === 3 && /^(?:0{40}|0{64})$/.test(args[0]) && args[2] === "1") {
+  try {
+    const command = JSON.parse(notification);
+    if (Array.isArray(command) && command.length > 0 && command.every((value) => typeof value === "string")) {
+      spawnSync(command[0], command.slice(1), { stdio: "ignore", timeout: 2000, killSignal: "SIGKILL" });
+    }
+  } catch { /* Invalid arguments, missing commands, and daemon failures must not affect Git. */ }
+}