source-code-mgmt 1.13.0 → 1.15.1

package/lib/index.js

@@ -21,8 +21,8 @@ import {
   existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync,
   readdirSync, statSync, openSync, readSync, closeSync,
 } from 'node:fs'
-import { join, dirname } from 'node:path'
-import { homedir } from 'node:os'
+import { join, dirname, isAbsolute, resolve } from 'node:path'
+import { homedir, tmpdir } from 'node:os'
 
 import { AsyncLocalStorage } from 'node:async_hooks'
 import { fileURLToPath } from 'node:url'
@@ -30,7 +30,7 @@ import { fileURLToPath } from 'node:url'
 // ---------- i18n: host messages follow the client’s language (?lang= query param, per request) ----------
 const HOST_EN = {"尚未配置 Gitee 私人令牌（请打开 ③ 代码管理输入令牌）":"No Gitee personal token configured (enter one in ③ Code Management)","Gitee API 请求失败（需要 curl）":"Gitee API request failed (curl required)","not a git repository（尚未 git init，可用「新建仓库并推送」初始化为 git 仓库并上传）":"not a git repository (run \"Create repo & push\" to init one and upload)","超过 GitHub 100MB 单文件限制（${}），已被 .gitignore 的 \"${}\" 排除":"Exceeds GitHub's 100MB file limit (${}) — already excluded by .gitignore entry \"${}\"","超过 GitHub 100MB 单文件限制（${}），${} 所在的一级目录「${}」整体忽略（该文件夹为一整体）":"Exceeds GitHub's 100MB file limit (${}) — the whole first-level folder \"${}\" of ${} is ignored (the folder is one unit)","超过 GitHub 100MB 单文件限制（${}），已忽略单个文件「${}」":"Exceeds GitHub's 100MB file limit (${}) — the file \"${}\" was ignored individually","尚未配置远程仓库 origin，请使用「新建仓库」创建远程仓库。":"No origin remote configured — use \"Create repo\" to create a remote repo.","not a git repository（尚未 git init，无法拉取）":"not a git repository (no git init yet — cannot pull)","尚未配置远程仓库 origin，无法拉取。":"No origin remote configured — cannot pull.","拉取存在冲突：本地有未合并改动或与远程冲突，请手动 git pull 处理合并。":"Pull conflicts: you have unmerged local changes or conflicts with the remote — resolve them manually with git pull.","git pull 失败":"git pull failed","not a git repository（尚未 git init）":"not a git repository (run git init first)","拉取并推送失败：合并存在冲突，请手动解决后重试。":"Pull-and-push failed: merge conflicts — resolve them manually and retry.","pull --rebase 失败":"pull --rebase failed","push 失败":"push failed","push --force 失败":"push --force failed","强制拉取存在冲突，请手动处理。":"Force-pull conflicts — handle them manually.","git pull --force 失败":"git pull --force failed","缺少仓库名称":"Repo name required","仓库名称包含非法字符（仅允许字母、数字、点、下划线、横线）":"Repo name contains invalid characters (only letters, digits, dots, underscores, dashes)","git add 失败：${}":"git add failed: ${}","需要先配置 Gitee 私人令牌":"Configure the Gitee personal token first","Gitee 创建仓库失败":"Failed to create the Gitee repo","缺少文件路径":"File path required","无法识别当前分支":"Cannot determine the current branch","尚未配置远程仓库 origin，无法对齐。":"No origin remote configured — cannot align.","git fetch 失败":"git fetch failed","git reset --hard 失败":"git reset --hard failed","git init 失败":"git init failed","git add 失败":"git add failed","git reset 失败":"git reset failed","提交信息不能为空":"Commit message cannot be empty","没有已暂存（staged）的改动可提交":"Nothing staged to commit","git commit 失败":"git commit failed","缺少分支名":"Branch name required","切换分支失败":"Failed to switch branch","git log 失败":"git log failed","缺少 commit hash":"Commit hash required","revert 失败（可能有冲突，请手动处理）":"revert failed (possible conflicts — handle manually)","cherry-pick 失败（可能有冲突，请手动处理）":"cherry-pick failed (possible conflicts — handle manually)","读取提交 diff 失败":"Failed to read the commit diff","未知工具：":"Unknown tool: ","未找到可用的包管理器（":"No usable package manager found (","）。请手动安装。":"). Please install manually.","安装成功":"Installed successfully","安装失败":"Installation failed","$dlg.Description = '选择本地目录';":"$dlg.Description = 'Choose a local folder';","Gitee 修改可见性失败":"Failed to change Gitee visibility","需要先登录 GitHub CLI（gh）":"Log in to the GitHub CLI (gh) first","修改可见性失败：${}":"Failed to change visibility: ${}","gh repo edit 失败":"gh repo edit failed","缺少目录路径":"Folder path required","未选择目录":"No folder selected","目录不存在或不是文件夹：":"Folder does not exist or is not a directory: ","令牌不能为空":"Token cannot be empty","Gitee 令牌无效，请检查（需有 projects 权限）":"Invalid Gitee token — check it (needs projects permission)"};
 const requestLangStore = new AsyncLocalStorage();
-// 新增板块（④克隆 / ⑤PR / ⑥npm）的 host 英文消息，追加进 HOST_EN。
+// 新增板块（④克隆 / ⑤npm）的 host 英文消息，追加进 HOST_EN。
 Object.assign(HOST_EN, {
   "LLM 服务不可用（未加载 llm 服务）": "LLM service unavailable (llm service not loaded)",
   "未找到默认模型配置（agent-default-model）": "No default model config found (agent-default-model)",
@@ -76,6 +76,17 @@ Object.assign(HOST_EN, {
   "创建分支失败（上游分支可能不存在，请检查规则 baseBranch）": "Failed to create branch (upstream base may not exist — check the rule's baseBranch)",
   "已打开终端窗口，请完成 npm login 后回到面板点「重新检查」": "A terminal window has been opened — complete npm login, then click \"Re-check\" in the panel",
   "未找到可用终端，请手动在目标目录运行：": "No usable terminal found — run this manually in the target directory: ",
+  "需要管理员密码（当前 sudo 需要密码，无法在面板内自动执行），请在终端手动执行：": "Admin password required (sudo prompts for a password here, so the panel cannot run it) — run this manually in a terminal: ",
+  "已触发安装，请按系统提示完成，然后点「重新检查」": "Installation started — follow the system prompt, then click \"Re-check\"",
+  "查询最新版本…": "Fetching latest version…",
+  "下载 gh 安装包…": "Downloading gh…",
+  "解压…": "Extracting…",
+  "安装到 ~/.local/bin…": "Installing to ~/.local/bin…",
+  "清理临时文件…": "Cleaning up…",
+  "执行安装命令：": "Running install command: ",
+  "用户级安装失败，改用系统包管理器安装…": "User-level install failed — falling back to the system package manager…",
+  "需要管理员密码，改用以下手动命令：": "Admin password required — run this manually: ",
+  "配置源是镜像，发布将使用官方源：": "Configured registry is a mirror — publishing will use the official registry: ",
   "规则文件获取失败：": "Failed to fetch rules file: ",
   "规则文件读取失败：": "Failed to read rules file: ",
   "找不到规则文件：": "Rules file not found: ",
@@ -135,7 +146,7 @@ const SSH = resolveBin('ssh', 'DSH_SCM_SSH')
 const SSH_KEYGEN = resolveBin('ssh-keygen', 'DSH_SCM_SSH_KEYGEN')
 /** Resolved path to curl (used to call the Gitee OpenAPI). */
 const CURL = resolveBin('curl', 'DSH_SCM_CURL')
-/** Resolved path to npm (used by the ⑥ publish-npm section). */
+/** Resolved path to npm (used by the ⑤ publish-npm section). */
 const NPM = resolveBin('npm', 'DSH_SCM_NPM')
 
 /**
@@ -238,6 +249,12 @@ function resolveBin(name, envVar) {
   // 1) PATH hit is the most portable answer.
   const onPath = findOnPath(name)
   if (onPath) return onPath
+  // 1.5) Linux/macOS 用户级安装目录：免 sudo 安装的 gh（本插件的「一键安装」落点）
+  //      也会装到这里，即使 ~/.local/bin 不在 shell PATH 中，模块加载时也能解析到。
+  if (!IS_WIN) {
+    const userBin = probePrefix(join(homedir(), '.local', 'bin'), name)
+    if (userBin) return userBin
+  }
   // 2) Windows: git bundles ssh / ssh-keygen.
   if (IS_WIN) {
     for (const prefix of windowsGitPrefixes()) {
@@ -382,6 +399,231 @@ function run(cmd, args, opts = {}) {
   }
 }
 
+/**
+ * 流式执行一条命令（spawn）：stdout/stderr 分块实时回调 onChunk，
+ * 进程退出后 resolve { ok, code, stdout, stderr }。用于一键安装的进度展示。
+ */
+function runLive(cmd, args, opts = {}) {
+  const { onChunk, timeout = 300_000 } = opts
+  const env = { ...process.env, ...(opts.env ?? {}) }
+  return new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    let timer = null
+    let child
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      if (timer !== null) clearTimeout(timer)
+      resolve(value)
+    }
+    try {
+      child = spawn(cmd, args, { env, stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch (error) {
+      finish({ ok: false, code: 1, stdout: '', stderr: String(error?.message ?? error) })
+      return
+    }
+    timer = timeout > 0 ? setTimeout(() => { try { child.kill('SIGKILL') } catch {} }, timeout) : null
+    const push = (buf, stream) => {
+      const text = buf.toString('utf8')
+      if (stream === 'out') stdout += text
+      else stderr += text
+      if (onChunk) { try { onChunk(text, stream) } catch {} }
+    }
+    child.stdout?.on('data', (b) => push(b, 'out'))
+    child.stderr?.on('data', (b) => push(b, 'err'))
+    child.on('error', (error) => {
+      finish({ ok: false, code: 1, stdout, stderr: stderr || String(error?.message ?? error) })
+    })
+    child.on('close', (code) => {
+      finish({ ok: code === 0, code: code ?? 1, stdout, stderr })
+    })
+  })
+}
+
+// ---------------------------------------------------------------------------
+// 一键重启 dsh（机制同 dsh-update / dsh-market）：detached helper 接管后按原命令
+// 拉起替换进程，本进程随后退出。Windows 走 PowerShell 隐藏窗口；POSIX 走 detached spawn。
+// ---------------------------------------------------------------------------
+
+/** The real Node executable (Android-safe argv0 preference), for spawning. */
+function nodeExecutable(argv0 = process.argv0, execPath = process.execPath) {
+  if (argv0 !== undefined && argv0 !== '' && isAbsolute(argv0) && existsSync(argv0)) return argv0
+  return execPath
+}
+
+/** Whether a bare `dsh` name must go through a shell (Windows .cmd shim). */
+const winCmdShim = process.platform === 'win32'
+
+/** The exact boot invocation the detached restart helper replays. */
+function restartLaunch() {
+  const entry = process.argv[1]
+  if (entry !== undefined && entry !== '') {
+    // Absolute paths are required: source launches pass a relative entry,
+    // which the child resolves against its OWN cwd and dies with
+    // MODULE_NOT_FOUND. cwd near the entry keeps execArgv imports (tsx/esm)
+    // resolvable on source launches. Launching node + the very same entry is
+    // the most faithful restart and does NOT depend on `dsh` being on PATH
+    // (macOS/Linux bins often live inside node_modules behind pnpm/npx).
+    const abs = resolve(entry)
+    return { file: nodeExecutable(), args: [...process.execArgv, abs, ...process.argv.slice(2)], cwd: dirname(abs), viaShell: false }
+  }
+  return { file: 'dsh', args: process.argv.slice(2), cwd: undefined, viaShell: winCmdShim }
+}
+
+/** The process supervisor running this host, when one can be identified.
+ *  systemd only, and only when this process is the unit's OWN main process
+ *  (ppid === 1): INVOCATION_ID alone is inherited by every descendant. */
+function detectedSupervisor(env = process.env, ppid = process.ppid) {
+  const set = (name) => (env[name] ?? '') !== ''
+  if ((set('INVOCATION_ID') || set('JOURNAL_STREAM')) && ppid === 1) return 'systemd'
+  return null
+}
+
+/** Self-restart is enabled by default, disabled by an explicit env or by a
+ *  detected supervisor (which owns restarts). */
+function restartAllowed() {
+  const flag = process.env.DSH_SCM_RESTART
+  if (flag !== undefined && flag !== '') return flag !== '0' && flag !== 'false'
+  return detectedSupervisor() === null
+}
+
+/** The port this process serves, read off the request that asked to restart. */
+function servingPort(request) {
+  const host = request.headers.host
+  if (host === undefined) return null
+  const match = /:(\d{1,5})$/u.exec(host)
+  if (match === null) return null
+  const port = Number(match[1])
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null
+}
+
+/** Whether a process-control request came directly from this host's loopback
+ *  peer (stricter than isLoopbackRequest: also rejects proxied requests). */
+function trustedRestartRequest(request) {
+  const address = request.socket && request.socket.remoteAddress
+  if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') return false
+  if (request.headers.forwarded !== undefined
+    || request.headers['x-forwarded-for'] !== undefined
+    || request.headers['x-real-ip'] !== undefined) return false
+  const origin = request.headers.origin
+  const host = request.headers.host
+  if (origin === undefined || host === undefined) return false
+  try {
+    const parsed = new URL(origin)
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host === host
+  } catch {
+    return false
+  }
+}
+
+/** Platform-correct spawn for the replacement host. POSIX keeps the plain
+ *  detached spawn; Windows relaunches through a hidden PowerShell window
+ *  (detached:true would break the PowerShell -> node handle chain, Node #51018). */
+function respawnInvocation(launch, platform = process.platform) {
+  if (platform !== 'win32') {
+    return { file: launch.file, args: launch.args, viaShell: launch.viaShell, detached: true, windowsHide: false }
+  }
+  const quote = (part) => `'${String(part).replace(/'/g, "''")}'`
+  const file = launch.viaShell && !/\.(?:cmd|bat)$/iu.test(launch.file) ? `${launch.file}.cmd` : launch.file
+  return {
+    file: 'powershell.exe',
+    args: ['-NoProfile', '-WindowStyle', 'Hidden', '-Command',
+      [`& ${quote(file)}`, ...launch.args.map(quote)].join(' ')],
+    viaShell: false,
+    detached: false,
+    windowsHide: true,
+  }
+}
+
+/** Source for the detached helper that outlives this process and brings the
+ *  replacement up: wait for the port to go quiet (checked by CONNECTING, so
+ *  the probe never holds the port), start the replacement, then CHECK that
+ *  something came up and write a diagnosis when it did not. */
+function restartHelperSource(spawned, launch, logs, port) {
+  return [
+    "const { spawn } = require('node:child_process')",
+    "const fs = require('node:fs')",
+    "const net = require('node:net')",
+    `const file = ${JSON.stringify(spawned.file)}`,
+    `const args = ${JSON.stringify(spawned.args)}`,
+    `const cwd = ${JSON.stringify(launch.cwd)}`,
+    `const viaShell = ${JSON.stringify(spawned.viaShell)}`,
+    `const detached = ${JSON.stringify(spawned.detached)}`,
+    `const windowsHide = ${JSON.stringify(spawned.windowsHide ?? false)}`,
+    `const logOut = ${JSON.stringify(logs.out)}`,
+    `const logErr = ${JSON.stringify(logs.err)}`,
+    `const port = ${JSON.stringify(port)}`,
+    'const sleep = (ms) => new Promise(r => setTimeout(r, ms))',
+    'const note = (line) => { try { fs.appendFileSync(logErr, `[source-code-mgmt] ${line}\n`) } catch {} }',
+    'const listening = () => new Promise((resolve) => {',
+    '  const probe = net.connect({ host: "127.0.0.1", port })',
+    '  const done = (value) => { probe.destroy(); resolve(value) }',
+    '  probe.on("connect", () => done(true))',
+    '  probe.on("error", () => done(false))',
+    '  setTimeout(() => done(false), 500)',
+    '})',
+    'const main = async () => {',
+    '  if (port) {',
+    '    const until = Date.now() + 30000',
+    '    while (Date.now() < until && await listening()) await sleep(250)',
+    '    if (await listening()) note(`port ${port} was still in use after 30s; starting anyway`)',
+    '  } else {',
+    '    await sleep(1500)',
+    '  }',
+    '  let child',
+    '  try {',
+    '    const out = fs.openSync(logOut, "a")',
+    '    const err = fs.openSync(logErr, "a")',
+    '    child = spawn(file, args, { cwd, detached, windowsHide, stdio: ["ignore", out, err], env: process.env, shell: viaShell })',
+    '    child.on("error", (error) => note(`could not start the replacement: ${error && error.message ? error.message : error}`))',
+    '    child.unref()',
+    '  } catch (error) {',
+    '    note(`could not start the replacement: ${error && error.message ? error.message : error}`)',
+    '    return',
+    '  }',
+    "  if (!port) { await sleep(3000); return }",
+    '  const upBy = Date.now() + 20000',
+    '  while (Date.now() < upBy && !(await listening())) await sleep(500)',
+    '  if (!(await listening())) note(`the replacement did not bind port ${port} within 20s — see the output log beside this one`)',
+    '}',
+    'main()',
+  ].join('\n')
+}
+
+/** One-shot restart latch: 防止手动点击与安装后重启重复调度 helper（两个 helper
+ *  会同抢端口）。 */
+let restartScheduled = false
+
+/** Relaunch this exact dsh entry after a detached handoff, then stop this
+ *  process. The helper outlives us (detached + unref), waits for our port to
+ *  be released before starting the replacement, and logs under tmpdir.
+ *  Returns null when a restart is already scheduled. */
+function scheduleRestart(port = null) {
+  if (restartScheduled) return null
+  restartScheduled = true
+  const launch = restartLaunch()
+  const spawned = respawnInvocation(launch)
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  const logOut = join(tmpdir(), `dsh-scm-restart-${stamp}.out.log`)
+  const logErr = join(tmpdir(), `dsh-scm-restart-${stamp}.err.log`)
+  try {
+    const helper = spawn(nodeExecutable(), ['-e', restartHelperSource(spawned, launch, { out: logOut, err: logErr }, port)], {
+      detached: true,
+      stdio: 'ignore',
+      env: process.env,
+    })
+    helper.unref()
+    setTimeout(() => process.kill(process.pid, 'SIGTERM'), 500)
+    return { pid: process.pid, helperPid: helper.pid, logOut, logErr }
+  } catch (error) {
+    // helper 拉起失败（如 EMFILE）：解除 latch 并重新抛出，避免重启能力永久失效。
+    restartScheduled = false
+    throw error
+  }
+}
+
 /**
  * Decode a path as printed by git. With core.quotepath ON (the default) git
  * prints paths containing non-ASCII bytes / special characters as a
@@ -456,6 +698,12 @@ function checkEnv() {
       path: SSH,
       sshKeygen: SSH_KEYGEN,
     },
+    // 平台自适应的可复制安装命令（与「一键安装」走同一逻辑；无可用方式时为 null）。
+    installHints: {
+      git: installCommand('git')?.label ?? null,
+      gh: installCommand('gh')?.label ?? null,
+      ssh: installCommand('ssh')?.label ?? null,
+    },
   }
 }
 
@@ -1772,6 +2020,103 @@ function commitDiffFlow(dir, hash) {
 // 工具安装（① 环境检查缺工具时的一键安装）——best-effort：按可用包管理器自动选取命令。
 // ---------------------------------------------------------------------------
 
+/** GitHub CLI Release 资产名（Linux/macOS）：gh_<版本>_<os>_<arch>.tar.gz */
+function ghReleaseAsset(platform, arch) {
+  const osName = platform === 'darwin' ? 'macOS' : 'linux'
+  const archName = arch === 'x64' ? 'amd64' : arch === 'arm64' ? 'arm64' : arch
+  return { osName, archName }
+}
+
+/**
+ * 免 sudo 用户级安装 GitHub CLI 的单行脚本（Linux / macOS）：
+ * 解析官方最新版本号 → 下载对应平台/架构 tarball → 解压 → 把 bin/gh 装到
+ * ~/.local/bin/gh（目录不存在则创建）→ 清理临时文件。全程不要求 root。
+ * @returns {string} 可直接 `sh -c` 执行 / 复制给用户的脚本。
+ */
+function ghUserLevelScript() {
+  const { osName, archName } = ghReleaseAsset(process.platform, process.arch)
+  const localBin = join(homedir(), '.local', 'bin')
+  // 注意：VER 是脚本内的 shell 变量，用 \${VER} 转义避免被 JS 模板字面量展开。
+  return [
+    'VER=$(curl -fsSL https://api.github.com/repos/cli/cli/releases/latest | sed -n \'s/.*"tag_name": *"v\\([^"]*\\)".*/\\1/p\')',
+    'VER=${VER#v}',
+    `mkdir -p "${localBin}"`,
+    `curl -fsSL "https://github.com/cli/cli/releases/download/v\${VER}/gh_\${VER}_${osName}_${archName}.tar.gz" -o /tmp/gh-scm.tgz`,
+    'tar -xzf /tmp/gh-scm.tgz -C /tmp',
+    `install -m 755 "/tmp/gh_\${VER}_${osName}_${archName}/bin/gh" "${localBin}/gh"`,
+    'rm -rf /tmp/gh-scm.tgz "/tmp/gh_${VER}_' + osName + '_' + archName + '"',
+  ].join(' && ')
+}
+
+/**
+ * gh 用户级安装的分步脚本（每步独立执行，供「一键安装」进度逐条展示）。
+ * 与 ghUserLevelScript()（复制用单行版）保持同源逻辑；版本号经 /tmp/gh-scm-ver 传递。
+ * @returns {Array<{label: string, cmd: string}>}
+ */
+function ghUserLevelSteps() {
+  const { osName, archName } = ghReleaseAsset(process.platform, process.arch)
+  const localBin = join(homedir(), '.local', 'bin')
+  const verFile = '/tmp/gh-scm-ver'
+  const fetchVer = 'VER=$(curl -fsSL https://api.github.com/repos/cli/cli/releases/latest | sed -n \'s/.*"tag_name": *"v\\([^"]*\\)".*/\\1/p\'); [ -n "$VER" ] || exit 1; printf \'%s\' "${VER#v}" > ' + verFile
+  const readVer = 'VER=$(cat ' + verFile + ')'
+  return [
+    { label: tr('查询最新版本…'), cmd: fetchVer },
+    { label: tr('下载 gh 安装包…'), cmd: readVer + ' && curl -fsSL "https://github.com/cli/cli/releases/download/v${VER}/gh_${VER}_' + osName + '_' + archName + '.tar.gz" -o /tmp/gh-scm.tgz' },
+    { label: tr('解压…'), cmd: 'tar -xzf /tmp/gh-scm.tgz -C /tmp' },
+    { label: tr('安装到 ~/.local/bin…'), cmd: readVer + ' && mkdir -p "' + localBin + '" && install -m 755 "/tmp/gh_${VER}_' + osName + '_' + archName + '/bin/gh" "' + localBin + '/gh"' },
+    { label: tr('清理临时文件…'), cmd: 'rm -rf /tmp/gh-scm.tgz ' + verFile + ' /tmp/gh_*_' + osName + '_' + archName },
+  ]
+}
+
+/** 安装后即时复查工具是否真的可用（不依赖模块加载时缓存的历史解析结果）。 */
+function toolInstalled(t) {
+  if (t === 'gh') {
+    // 用户级安装落点优先复查；不在 PATH 时也能发现。
+    if (!IS_WIN) {
+      const userGh = probePrefix(join(homedir(), '.local', 'bin'), 'gh')
+      if (userGh && isFile(userGh)) return true
+    }
+    return run('gh', ['--version']).ok
+  }
+  // git / ssh：直接按当前 PATH 实测（系统包管理器安装后即可发现，无需重启 host）。
+  if (t === 'git') return run('git', ['--version']).ok
+  if (t === 'ssh') return run('ssh', ['-V']).ok
+  return false
+}
+
+/**
+ * sudo 是否免密可用（`sudo -n true` 非交互探测）。
+ * 需要密码的 sudo 在面板内无法自动输入，返回 false 以走用户级安装或手动指引。
+ * @returns {boolean} 已是 root 或 sudo 免密可用时为 true。
+ */
+function canSudo() {
+  if (IS_WIN) return false
+  if (typeof process.getuid === 'function' && process.getuid() === 0) return true
+  return run('sudo', ['-n', 'true'], { timeout: 5_000 }).ok
+}
+
+/** 某个绝对目录是否就在 PATH 里（尾斜杠归一化比较）。 */
+function isInPath(dir) {
+  const target = dir.length > 0 && dir[dir.length - 1] !== '/' ? dir + '/' : dir
+  return pathDirs().some((p) => {
+    const norm = p.length > 0 && p[p.length - 1] !== '/' ? p + '/' : p
+    return norm === target
+  })
+}
+
+/**
+ * 工具装好后，当前 host 进程的检测是否要等重启才生效：
+ * - 模块加载时已解析到具体路径（PATH 命中或 DSH_SCM_* 显式覆盖）→ 立即可用，无需重启；
+ * - 模块加载时解析失败（bare name 兜底）且用户级落点 ~/.local/bin 又不在 PATH
+ *   → env 检测要等重启后经 ~/.local/bin 探测才翻新，此时提示用户重启。
+ * @param {'git'|'gh'|'ssh'} t
+ */
+function restartNeededFor(t) {
+  if (t !== 'gh') return false
+  if (GH !== 'gh') return false
+  return !isInPath(join(homedir(), '.local', 'bin'))
+}
+
 /**
  * Whether a command exists (probe `--version`; for shell scripts use `command -v`).
  * @param {string} bin - bare command name.
@@ -1784,11 +2129,10 @@ function binExists(bin) {
 }
 
 /**
- * Build the install command to run for `tool` on this machine, or null when no
- * usable package manager is available. Returns arrays usable with `run`.
+ * 仅按系统包管理器选择安装命令（不含 gh 的用户级路径）。
  * @param {'git'|'gh'|'ssh'} tool
  */
-function installCommand(tool) {
+function installCommandSystem(tool) {
   if (IS_WIN) {
     // SSH 客户端：Windows 内置可选功能（需管理员），走 powershell。
     if (tool === 'ssh') {
@@ -1809,57 +2153,127 @@ function installCommand(tool) {
   if (process.platform === 'darwin') {
     const pkg = tool === 'git' ? 'git' : tool === 'gh' ? 'gh' : 'openssh'
     if (binExists('brew')) return { bin: 'brew', args: ['install', pkg], label: 'brew install ' + pkg }
+    // macOS 无 brew：git/ssh 走 Xcode 命令行工具（系统自带安装，含 git 与 ssh）。
+    if (tool === 'git' || tool === 'ssh') {
+      return { bin: 'sh', args: ['-c', 'xcode-select --install'], label: 'xcode-select --install', started: true }
+    }
     return null
   }
   // Linux：按可用包管理器选择。安装需 root，用 sudo（非交互 -n，避免挂起等待密码；已是 root 则直接跑）。
+  // needsSudo 标记供上层探测：sudo 需要密码时改走手动指引，避免静默失败。
   const pkg = tool === 'git' ? 'git' : tool === 'gh' ? 'gh' : 'openssh-client'
   const isRoot = typeof process.getuid === 'function' && process.getuid() === 0
   const sudo = !isRoot && binExists('sudo') ? 'sudo -n ' : ''
+  const tag = sudo === '' ? {} : { needsSudo: true }
   if (binExists('apt-get')) {
-    return { bin: 'sh', args: ['-c', sudo + 'apt-get install -y ' + pkg], label: 'sudo apt-get install -y ' + pkg }
+    return { bin: 'sh', args: ['-c', sudo + 'apt-get install -y ' + pkg], label: 'sudo apt-get install -y ' + pkg, ...tag }
   }
   if (binExists('dnf')) {
-    return { bin: 'sh', args: ['-c', sudo + 'dnf install -y ' + pkg], label: 'sudo dnf install -y ' + pkg }
+    return { bin: 'sh', args: ['-c', sudo + 'dnf install -y ' + pkg], label: 'sudo dnf install -y ' + pkg, ...tag }
   }
   if (binExists('pacman')) {
-    return { bin: 'sh', args: ['-c', sudo + 'pacman -S --noconfirm ' + pkg], label: 'sudo pacman -S ' + pkg }
+    return { bin: 'sh', args: ['-c', sudo + 'pacman -S --noconfirm ' + pkg], label: 'sudo pacman -S ' + pkg, ...tag }
   }
   return null
 }
 
 /**
- * Install a missing tool (git / gh / ssh) using the best available package
- * manager. Best-effort: reports the command it ran and its output.
+ * Build the install command to run for `tool` on this machine, or null when no
+ * usable package manager is available. Returns arrays usable with `run`.
+ * @param {'git'|'gh'|'ssh'} tool
+ */
+function installCommand(tool) {
+  // Linux/macOS 的 GitHub CLI：优先免 sudo 用户级安装（官方二进制 → ~/.local/bin）。
+  if (tool === 'gh' && !IS_WIN) {
+    return { bin: 'sh', args: ['-c', ghUserLevelScript()], label: ghUserLevelScript(), userLevel: true }
+  }
+  return installCommandSystem(tool)
+}
+
+/**
+ * Install a missing tool (git / gh / ssh). GitHub CLI on Linux/macOS installs
+ * user-level (no sudo, official binary → ~/.local/bin); git/ssh keep the
+ * system package manager. Best-effort: reports the command it ran and output.
  * @param {string} tool - 'git' | 'gh' | 'ssh'.
+ * @param {(evt: object) => void} [emit] - 进度事件回调（{type:'step',label} / {type:'out',text}），
+ *   由流式路由逐行转发给浏览器端弹窗。
  */
-function installToolFlow(tool) {
+async function installToolFlow(tool, emit) {
   const t = String(tool || '').trim().toLowerCase()
   if (t !== 'git' && t !== 'gh' && t !== 'ssh') return { ok: false, error: tr('未知工具：') + tool }
-  // 已安装就直接返回，不重复安装。
-  const present = t === 'git' ? (GIT && GIT !== 'git')
-    : t === 'gh' ? (GH && GH !== 'gh')
-    : (SSH && SSH !== 'ssh' && SSH !== 'ssh.exe')
-  if (present) return { ok: true, alreadyInstalled: true, tool: t }
+  const say = (obj) => { if (emit) { try { emit(obj) } catch {} } }
+  // 已安装就直接返回，不重复安装（实测复查，不依赖模块加载时的缓存）。
+  if (toolInstalled(t)) return { ok: true, alreadyInstalled: true, tool: t }
+
+  // Linux/macOS 的 gh：免 sudo 用户级安装优先；失败再退回系统包管理器。
+  if (t === 'gh' && !IS_WIN) {
+    const steps = ghUserLevelSteps()
+    let lastOut = ''
+    let failed = false
+    for (const step of steps) {
+      say({ type: 'step', label: step.label })
+      const r = await runLive('sh', ['-c', step.cmd], { timeout: 300_000, onChunk: (text) => say({ type: 'out', text }) })
+      lastOut = (r.stdout + '\n' + r.stderr).trim()
+      if (!r.ok) { failed = true; break }
+    }
+    if (!failed && toolInstalled('gh')) {
+      return {
+        ok: true,
+        tool: t,
+        command: 'GitHub CLI',
+        output: lastOut || tr('安装成功'),
+        userLevel: true,
+        path: join(homedir(), '.local', 'bin', 'gh'),
+        restartNeeded: restartNeededFor('gh'),
+      }
+    }
+    // 用户级安装失败 → 退回系统包管理器（并说明原因）。
+    const fallback = installCommandSystem(t)
+    if (fallback) {
+      // 回退命令需要 sudo 但 sudo 要密码时，同样改走手动指引。
+      if (fallback.needsSudo && !canSudo()) {
+        say({ type: 'step', label: tr('需要管理员密码，改用以下手动命令：') })
+        return { ok: false, tool: t, error: tr('需要管理员密码（当前 sudo 需要密码，无法在面板内自动执行），请在终端手动执行：') + fallback.label, command: fallback.label, manual: true }
+      }
+      say({ type: 'step', label: tr('用户级安装失败，改用系统包管理器安装…') })
+      const fr = await runLive(fallback.bin, fallback.args, { timeout: 300_000, onChunk: (text) => say({ type: 'out', text }) })
+      const fout = (fr.stdout + '\n' + fr.stderr).trim()
+      const fok = toolInstalled('gh')
+      return { ok: fok, tool: t, command: fallback.label, output: fout || (fok ? tr('安装成功') : tr('安装失败')), restartNeeded: restartNeededFor('gh') }
+    }
+    return { ok: false, error: tr('未找到可用的包管理器（') + 'apt-get / dnf / pacman' + tr('）。请手动安装。'), tool: t }
+  }
 
   const cmd = installCommand(t)
   if (!cmd) {
-    return { ok: false, error: tr('未找到可用的包管理器（') + (IS_WIN ? 'winget / choco / scoop' : process.platform === 'darwin' ? 'brew' : 'apt-get / dnf / pacman') + tr('）。请手动安装。'), tool: t }
+    return { ok: false, error: tr('未找到可用的包管理器（') + (IS_WIN ? 'winget / choco / scoop' : process.platform === 'darwin' ? 'brew / Xcode CLT' : 'apt-get / dnf / pacman') + tr('）。请手动安装。'), tool: t }
   }
-  const r = run(cmd.bin, cmd.args, { timeout: 300_000 })
+  // 需要 sudo 但 sudo 要密码：不执行（-n 必然失败），直接给出手动命令与原因。
+  if (cmd.needsSudo && !canSudo()) {
+    say({ type: 'step', label: tr('需要管理员密码，改用以下手动命令：') })
+    return { ok: false, tool: t, error: tr('需要管理员密码（当前 sudo 需要密码，无法在面板内自动执行），请在终端手动执行：') + cmd.label, command: cmd.label, manual: true }
+  }
+  say({ type: 'step', label: tr('执行安装命令：') + cmd.label })
+  const r = await runLive(cmd.bin, cmd.args, { timeout: 300_000, onChunk: (text) => say({ type: 'out', text }) })
   const output = (r.stdout + '\n' + r.stderr).trim()
+  // 启动型安装（如 macOS xcode-select）：安装是系统弹窗异步完成的，返回「已触发」指引。
+  if (cmd.started) {
+    return { ok: false, started: true, tool: t, command: cmd.label, error: tr('已触发安装，请按系统提示完成，然后点「重新检查」') }
+  }
   // 安装后复查是否已装上。
-  const ok = r.ok && (t === 'git' ? (GIT && GIT !== 'git') : t === 'gh' ? (GH && GH !== 'gh') : !(SSH === 'ssh' || SSH === 'ssh.exe'))
+  const ok = toolInstalled(t)
   return {
     ok,
     tool: t,
     command: cmd.label,
     output: output || (ok ? tr('安装成功') : tr('安装失败')),
     needElevation: IS_WIN && t === 'ssh',
+    restartNeeded: ok ? restartNeededFor(t) : false,
   }
 }
 
 // ---------------------------------------------------------------------------
-// ④ 克隆远程仓库 / ⑤ 提交 PR / ⑥ 发布 npm 包 —— host 逻辑
+// ④ 克隆远程仓库 / ⑤ 发布 npm 包 —— host 逻辑
 // ---------------------------------------------------------------------------
 
 // ---------- LLM 辅助：用 DSH 的 llm 服务 + 默认模型（当前对话/默认模型） ----------
@@ -1946,27 +2360,11 @@ function cloneHomeDir() {
   return homedir()
 }
 
-/** 默认克隆位置（⑤⑥ 等板块的工作目录兜底）：DSH 默认工作区。 */
+/** 默认克隆位置（⑤ 等板块的工作目录兜底）：DSH 默认工作区。 */
 function cloneDefaultDir() {
   return resolveDefaultDir(process.cwd())
 }
 
-/**
- * 从仓库 URL / SSH 地址 / owner/repo 解析平台、owner、repo。
- * @param {string} raw - https://github.com/owner/repo | git@github.com:owner/repo.git | owner/repo
- * @returns {{provider:'github'|'gitee', owner:string, repo:string}|{}}
- */
-function parseRepoUrl(raw) {
-  const url = String(raw || '').trim()
-  if (!url) return {}
-  const gh = /github\.com[/:]([^/\s?#]+)\/([^/\s?#]+)/i.exec(url)
-  if (gh) return { provider: 'github', owner: gh[1], repo: gh[2].replace(/\.git$/i, '') }
-  const gt = /gitee\.com[/:]([^/\s?#]+)\/([^/\s?#]+)/i.exec(url)
-  if (gt) return { provider: 'gitee', owner: gt[1], repo: gt[2].replace(/\.git$/i, '') }
-  const bare = /^([\w.-]+)\/([\w.-]+)$/.exec(url)
-  if (bare) return { provider: 'github', owner: bare[1], repo: bare[2].replace(/\.git$/i, '') }
-  return {}
-}
 
 /** 某仓库名在 baseDir 下是否已有同名 git 仓库（含 baseDir 本身就是同名仓库的情形，
  *  如工作区 C:\Users\xxx\workspace 即对应仓库 workspace）。 */
@@ -2087,618 +2485,21 @@ function cloneFlow(url, dest, name) {
   return { ok: true, dir: full, name: repoName }
 }
 
-// ---------- ⑤ 提交 PR（Pull Request） ----------
-
-/** 用户填写的 PR 目标仓库列表（记录到 ~/.dsh/storages，不写入插件目录）。 */
-function prTargetsFile() {
-  return join(homedir(), '.dsh', 'storages', 'source-code-mgmt-pr-targets.json')
-}
-function readPrTargets() {
-  try {
-    const f = prTargetsFile()
-    if (!existsSync(f)) return []
-    const data = JSON.parse(readFileSync(f, 'utf8'))
-    return Array.isArray(data) ? data : []
-  } catch { return [] }
-}
-function savePrTarget(url) {
-  const { provider, owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return readPrTargets()
-  const list = readPrTargets()
-  const clean = list.filter((t) => String(t.url || '').trim().toLowerCase() !== String(url).trim().toLowerCase())
-  clean.unshift({ url: String(url).trim(), provider, owner, repo, addedAt: new Date().toISOString() })
-  try {
-    const f = prTargetsFile()
-    mkdirSync(dirname(f), { recursive: true })
-    writeFileSync(f, JSON.stringify(clean.slice(0, 50), null, 2), 'utf8')
-  } catch { /* ignore */ }
-  return clean
-}
-function removePrTarget(url) {
-  const list = readPrTargets().filter((t) => String(t.url || '').trim().toLowerCase() !== String(url || '').trim().toLowerCase())
-  try {
-    const f = prTargetsFile()
-    mkdirSync(dirname(f), { recursive: true })
-    writeFileSync(f, JSON.stringify(list, null, 2), 'utf8')
-  } catch { /* ignore */ }
-  return list
-}
-
-/** 插件根目录（用于存放 AI 思考出的 PR 规则缓存）。 */
-function pluginRoot() {
-  return dirname(dirname(fileURLToPath(import.meta.url)))
-}
-function prRulesDir() {
-  return join(pluginRoot(), 'rules')
-}
-function prRulePath(owner, repo) {
-  return join(prRulesDir(), owner + '__' + repo + '.json')
-}
-function readPrRule(owner, repo) {
-  try {
-    const p = prRulePath(owner, repo)
-    if (!existsSync(p)) return undefined
-    const data = JSON.parse(readFileSync(p, 'utf8'))
-    return data && typeof data === 'object' ? data : undefined
-  } catch { return undefined }
-}
-function writePrRule(owner, repo, rule) {
-  try {
-    mkdirSync(prRulesDir(), { recursive: true })
-    writeFileSync(prRulePath(owner, repo), JSON.stringify(rule, null, 2), 'utf8')
-    return true
-  } catch { return false }
-}
-
-/** 从 { 到 } 尽量提取 JSON（AI 可能包裹 markdown 代码块）。 */
-function parseJsonLoose(text) {
-  const s = String(text || '').trim()
-  try { return JSON.parse(s) } catch { /* continue */ }
-  const start = s.indexOf('{')
-  const end = s.lastIndexOf('}')
-  if (start === -1 || end <= start) return null
-  try { return JSON.parse(s.slice(start, end + 1)) } catch { return null }
-}
-
-/** 读取 GitHub 仓库内某文件的文本内容（gh api），失败返回 undefined。 */
-function ghFileText(owner, repo, path) {
-  const r = run(GH, ['api', 'repos/' + owner + '/' + repo + '/contents/' + path, '--jq', '.content'], { timeout: 30_000 })
-  if (!r.ok) return undefined
-  try {
-    const b64 = r.stdout.trim()
-    if (!b64) return undefined
-    return Buffer.from(b64, 'base64').toString('utf8')
-  } catch { return undefined }
-}
-
-/** 抓取目标仓库的关键文档（README / CONTRIBUTING / PR 模板 / package.json scripts），供 AI 分析 PR 规则。 */
-async function gatherRepoDocs(provider, owner, repo) {
-  const docs = {}
-  const candidates = [
-    'README.md', 'CONTRIBUTING.md', '.github/CONTRIBUTING.md',
-    '.github/PULL_REQUEST_TEMPLATE.md', '.github/pull_request_template.md', 'package.json',
-  ]
-  for (const c of candidates) {
-    if (provider === 'gitee') {
-      const api = giteeApi('GET', 'repos/' + owner + '/' + repo + '/contents/' + c)
-      if (api.ok && api.data && typeof api.data.content === 'string') {
-        try { docs[c] = Buffer.from(api.data.content, 'base64').toString('utf8') } catch {}
-      }
-    } else {
-      const txt = ghFileText(owner, repo, c)
-      if (txt !== undefined) docs[c] = txt
-    }
-  }
-  return docs
-}
-
-/** AI 思考 PR 规则的 system 提示词：要求输出结构化 JSON（步骤数组）。 */
-const PR_RULE_SYSTEM = [
-  '你是一个开源仓库 PR 流程分析器。用户要往一个 GitHub/Gitee 仓库提交 Pull Request（提交内容通常是「把某个 DSH 插件收录进该仓库的插件列表 / 或按该仓库规则提交一份变更」）。',
-  '请先分析该仓库的 PR 规则（基于 README / CONTRIBUTING / PR 模板 / package.json scripts），然后输出一个 JSON（不要任何多余文字、不要 markdown 代码块，直接输出 JSON 对象）：',
-  '{',
-  '  "baseBranch": "上游默认分支，如 main 或 master",',
-  '  "entryFilePath": "新增条目文件的相对路径（若适用；如 data/plugins/owner__repo.yml），否则 null",',
-  '  "entryTemplate": "条目文件的内容模板（含占位符，如 {NAME} {DESCRIPTION}），若适用；否则 null",',
-  '  "regenerateCommands": ["重生成 README 的命令数组（如 [\\"node\\", \\"scripts/generate-readme.mjs\\"]），没有则为 []"],',
-  '  "prTitle": "PR 标题建议，如 Add owner/repo",',
-  '  "prBodyHint": "PR 描述应包含的要点（中文一句话概括）",',
-  '  "steps": [',
-  '    { "type": "ensure-fork" },',
-  '    { "type": "clone-fork" },',
-  '    { "type": "add-upstream" },',
-  '    { "type": "fetch-upstream" },',
-  '    { "type": "branch", "name": "add-<插件名>" },',
-  '    { "type": "write-entry" },',
-  '    { "type": "regenerate-readme" },',
-  '    { "type": "commit", "message": "Add owner/repo" },',
-  '    { "type": "push" },',
-  '    { "type": "create-pr" }',
-  '  ]',
-  '}',
-  '要求：steps 按真实执行顺序排列，只包含上面列出的 type；不确定的字段给 null 或空数组，不要编造。',
-].join('\n')
-
-/**
- * 用户已提供规则（手动文本或规则文件）时的 system 提示词：忠实整理为结构化 JSON，
- * 不额外抓取仓库文档、不编造——精简提示词以节省 token。
- */
-const PR_RULE_SYSTEM_USER = [
-  '你是一个开源仓库 PR 流程规则整理器。用户已直接提供该仓库的 PR 规则（手写文本或规则文件，如 README / CONTRIBUTING）。',
-  '请把用户提供的规则忠实整理成下面的 JSON（不要任何多余文字、不要 markdown 代码块，直接输出 JSON 对象）：',
-  '{',
-  '  "baseBranch": "上游默认分支，如 main 或 master",',
-  '  "entryFilePath": "新增条目文件的相对路径（若适用；如 data/plugins/owner__repo.yml），否则 null",',
-  '  "entryTemplate": "条目文件的内容模板（含占位符，如 {NAME} {DESCRIPTION}），若适用；否则 null",',
-  '  "regenerateCommands": ["重生成 README 的命令数组（如 [\\"node\\", \\"scripts/generate-readme.mjs\\"]），没有则为 []"],',
-  '  "prTitle": "PR 标题建议，如 Add owner/repo",',
-  '  "prBodyHint": "PR 描述应包含的要点（中文一句话概括）",',
-  '  "steps": [',
-  '    { "type": "ensure-fork" },',
-  '    { "type": "clone-fork" },',
-  '    { "type": "add-upstream" },',
-  '    { "type": "fetch-upstream" },',
-  '    { "type": "branch", "name": "add-<插件名>" },',
-  '    { "type": "write-entry" },',
-  '    { "type": "regenerate-readme" },',
-  '    { "type": "commit", "message": "Add owner/repo" },',
-  '    { "type": "push" },',
-  '    { "type": "create-pr" }',
-  '  ]',
-  '}',
-  '要求：steps 按真实执行顺序排列，只包含上面列出的 type；只依据用户提供的规则整理，不要额外假设、不要编造用户没提到的字段。',
-].join('\n')
-
-/**
- * 解析用户提供的规则来源：ruleText（手写文本）或 ruleFile（本地路径 / http(s) URL）。
- * @param {string} [ruleText] - 用户手动填写的 PR 规则文本。
- * @param {string} [ruleFile] - 规则文件路径或 URL（如某仓库 README）。
- * @returns {Promise<{text?:string, error?:string}>} 读取到的文本或错误。
- */
-async function resolveRuleInput(ruleText, ruleFile) {
-  const text = String(ruleText || '').trim()
-  if (text) return { text }
-  const file = String(ruleFile || '').trim()
-  if (!file) return {}
-  if (/^https?:\/\//i.test(file)) {
-    // 远程 URL：优先 Node 全局 fetch，失败回退 curl。
-    try {
-      if (typeof fetch === 'function') {
-        const ctrl = new AbortController()
-        const timer = setTimeout(() => ctrl.abort(), 20000)
-        try {
-          const resp = await fetch(file, { redirect: 'follow', signal: ctrl.signal })
-          if (resp.ok) {
-            const body = await resp.text()
-            if (body) return { text: body }
-          }
-        } finally { clearTimeout(timer) }
-      }
-    } catch { /* 继续尝试 curl */ }
-    const r = run('curl', ['-sL', '--max-time', '20', file], { timeout: 30000 })
-    if (r.ok && r.stdout) return { text: r.stdout }
-    return { error: tr('规则文件获取失败：') + file }
-  }
-  if (existsSync(file)) {
-    try { return { text: readFileSync(file, 'utf8') } }
-    catch (e) { return { error: tr('规则文件读取失败：') + String((e && e.message) || e) } }
-  }
-  return { error: tr('找不到规则文件：') + file }
-}
-
-/**
- * 分析某仓库的 PR 规则：命中插件目录 rules/ 缓存则直接返回；否则抓取仓库文档（或用户提供的
- * 规则文本/文件）→ LLM 思考 → 保存缓存。
- * @param {*} ctx - cordis context。
- * @param {{url: string, force?: boolean, ruleText?: string, ruleFile?: string}} input -
- *   目标仓库 URL；force=true 忽略缓存重新分析；ruleText/ruleFile 为用户提供的规则来源（可选）。
- */
-async function prAnalyzeFlow(ctx, { url, force, ruleText, ruleFile }) {
-  const { provider, owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return { ok: false, error: tr('无法识别仓库地址：') + String(url || '') }
-  // 用户提供了规则（文本或文件）→ 视为新的分析输入，忽略缓存直接分析。
-  const hasUserInput = !!String(ruleText || '').trim() || !!String(ruleFile || '').trim()
-  if (!force && !hasUserInput) {
-    const cached = readPrRule(owner, repo)
-    if (cached) return { ok: true, cached: true, provider, owner, repo, rule: cached }
-  }
-  let userRule = ''
-  if (hasUserInput) {
-    const r = await resolveRuleInput(ruleText, ruleFile)
-    if (r.error) return { ok: false, error: r.error }
-    userRule = String(r.text || '').trim()
-    if (!userRule) return { ok: false, error: tr('未获取到规则内容（文件为空或无法读取）') }
-  }
-  let system, messages, docSources
-  if (userRule) {
-    system = PR_RULE_SYSTEM_USER
-    messages = [{
-      role: 'user',
-      text: '目标仓库：' + provider + ' ' + owner + '/' + repo + '\n\n用户提供的该仓库 PR 规则（请忠实整理，不要编造）：\n' + userRule.slice(0, 20000),
-    }]
-    docSources = []
-  } else {
-    const docs = await gatherRepoDocs(provider, owner, repo)
-    system = PR_RULE_SYSTEM
-    messages = [{
-      role: 'user',
-      text: '目标仓库：' + provider + ' ' + owner + '/' + repo + '\n\n仓库关键文档（尽力抓取，可能不全）：\n'
-        + (Object.keys(docs).length ? JSON.stringify(docs, null, 2).slice(0, 12000) : '(无可用文档)'),
-    }]
-    docSources = Object.keys(docs)
-  }
-  const res = await llmComplete(ctx, { system, messages, maxTokens: 3000, temperature: 0.3 })
-  if (!res.ok) return res
-  const rule = parseJsonLoose(res.text)
-  if (!rule || typeof rule !== 'object') return { ok: false, error: tr('AI 未输出有效规则') }
-  if (!Array.isArray(rule.steps)) rule.steps = []
-  rule.owner = owner; rule.repo = repo; rule.provider = provider
-  rule.generatedAt = new Date().toISOString()
-  rule.model = res.model
-  rule.docSources = docSources
-  if (userRule) rule.userProvided = true
-  writePrRule(owner, repo, rule)
-  return { ok: true, cached: false, provider, owner, repo, rule, model: res.model }
-}
-
-/**
- * 用 AI 生成 PR 内容（标题 + 描述 + 条目文件内容）。生成后由用户在 UI 里修改，不直接提交。
- * 当规则自带 entryTemplate 且插件信息齐全时，直接按模板本地填充（零 AI 消耗、可编辑）；
- * 否则调用 LLM 生成。
- * @param {*} ctx - cordis context。
- * @param {{url: string, rule?: object, pluginInfo?: object}} input
- */
-async function prGenerateFlow(ctx, { url, rule, pluginInfo }) {
-  const { owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return { ok: false, error: tr('无法识别仓库地址：') + String(url || '') }
-  const info = (pluginInfo && typeof pluginInfo === 'object') ? pluginInfo : {}
-  const vars = { owner, repo, info }
-
-  // 模板直填路径：规则带 entryTemplate 时按 {VAR} 占位符本地生成（零 AI，仍可编辑）。
-  if (rule && typeof rule.entryTemplate === 'string' && rule.entryTemplate !== '') {
-    const entry = fillPrTemplate(rule.entryTemplate, vars)
-    const title = fillPrTemplate(String(rule.prTitle || 'Add {NAME}'), vars) || ('Add ' + owner + '/' + repo)
-    const body = fillPrTemplate(String(rule.prBodyHint || ''), vars)
-    return {
-      ok: true,
-      title,
-      body,
-      entry,
-      fromTemplate: true,
-      provider: rule.provider || undefined,
-      model: rule.model || 'template',
-    }
-  }
 
-  const system = [
-    '你是 PR 内容生成助手。下面给出目标仓库的 PR 规则与用户要提交的插件信息，请生成三样内容并输出 JSON：',
-    '{ "title": "PR 标题", "body": "PR 描述（markdown，说明改动内容、已满足的前置条件）", "entry": "条目文件内容（若规则有 entryFilePath/entryTemplate 则按模板生成；否则 null）" }',
-    '直接输出 JSON，不要 markdown 代码块，不要多余文字。',
-  ].join('\n')
-  const messages = [{
-    role: 'user',
-    text: '目标仓库规则：\n' + JSON.stringify(rule || {}, null, 2) + '\n\n用户要提交的插件信息：\n' + JSON.stringify(info, null, 2),
-  }]
-  const res = await llmComplete(ctx, { system, messages, maxTokens: 3000, temperature: 0.5 })
-  if (!res.ok) return res
-  const parsed = parseJsonLoose(res.text)
-  if (!parsed || typeof parsed !== 'object') return { ok: false, error: tr('AI 输出无法解析') }
-  return {
-    ok: true,
-    title: String(parsed.title || ''),
-    body: String(parsed.body || ''),
-    entry: parsed.entry == null ? null : String(parsed.entry),
-    provider: res.provider,
-    model: res.model,
-  }
-}
-
-/** 当前分支名（git rev-parse --abbrev-ref HEAD），失败回退 'main'。 */
-function currentBranch(dir) {
-  const r = run(GIT, ['-C', dir, 'rev-parse', '--abbrev-ref', 'HEAD'])
-  return r.ok && r.stdout.trim() && r.stdout.trim() !== 'HEAD' ? r.stdout.trim() : 'main'
-}
-
-/**
- * 校验 PR 规则里的条目文件路径：必须是仓库内相对路径，且解析后不得逃出 cloneDir
- * （防路径穿越 —— 规则来自 AI/缓存，可能被恶意仓库文档诱导出 "../.." 路径）。
- * @param {string} cloneDir - fork 克隆目录。
- * @param {string} p - 规则给出的 entryFilePath。
- * @returns {boolean} 安全则 true。
- */
-function safeEntryPath(cloneDir, p) {
-  if (typeof p !== 'string' || p === '') return false
-  // 绝对路径（Windows 盘符 / POSIX 根 / 反斜杠）一律拒绝。
-  if (/^([a-zA-Z]:[\\/]|\/|\\)/.test(p)) return false
-  // 任何 .. 段（含 \..\、/../、..\ 前缀、../ 前缀）一律拒绝。
-  if (/(^|[\\/])\.\.([\\/]|$)/.test(p)) return false
-  const root = join(cloneDir, p)
-  const base = cloneDir.replace(/[\\/]+$/, '')
-  return root === base || root.startsWith(base + '\\') || root.startsWith(base + '/')
-}
-
-/**
- * 校验 PR 规则里的重生成命令：只允许常见构建/脚本命令 + 纯参数，拒绝绝对路径、
- * 环境变量展开、shell 元字符、重定向与明显危险的命令名。命令本身仍是数组传递
- * （execFileSync 不经过 shell），此校验是纵深防御，防止 AI 规则注入恶意命令。
- * @param {string[]} cmds - [bin, ...args]
- * @returns {boolean}
- */
-const SAFE_REGENERATE_BINS = new Set([
-  'node', 'npm', 'npx', 'pnpm', 'yarn', 'bun',
-  'python', 'python3', 'py',
-  'make', 'cmake',
-  'sh', 'bash', 'zsh',
-  'ruby', 'perl', 'php',
-  'dotnet', 'go', 'cargo', 'rustc',
-  'git', 'awk', 'sed', 'grep', 'cat',
-])
-// 参数不允许 shell 元字符 / 重定向 / 命令替换。命令名已由白名单约束（不经 shell，
-// 数组传递），此处只拦会被 shell 语义扩展、可能被后续误用的字符。
-const SHELL_META_PATTERN = /[|&;<>`$]/
-function safeRegenerateCommand(cmds) {
-  // 兼容两种形态：单条 [bin, ...args] 或多条 [[bin,...],[bin,...]]（顺序执行）。
-  const list = (Array.isArray(cmds) && cmds.length > 0 && Array.isArray(cmds[0])) ? cmds : [cmds]
-  for (const c of list) {
-    if (!Array.isArray(c) || c.length === 0) return false
-    const bin = String(c[0] || '').trim()
-    if (bin === '') return false
-    // 命令名必须是裸名称（不含路径分隔符），且在白名单内。
-    if (/[\\/]/.test(bin)) return false
-    if (!SAFE_REGENERATE_BINS.has(bin)) return false
-    // 参数不允许 shell 元字符 / 重定向。
-    for (let i = 1; i < c.length; i++) {
-      const a = String(c[i] ?? '')
-      if (SHELL_META_PATTERN.test(a)) return false
-    }
-  }
-  return true
-}
-
-/**
- * 用 {VAR} 占位符填充规则模板（OWNER/REPO/NAME/CATEGORY/DESC_EN/DESC_ZH）。
- * @param {string} tpl
- * @param {{owner:string,repo:string,info:object}} vars
- */
-function fillPrTemplate(tpl, vars) {
-  const map = {
-    OWNER: vars.owner,
-    REPO: vars.repo,
-    NAME: String(vars.info && vars.info.name ? vars.info.name : vars.owner + '/' + vars.repo),
-    CATEGORY: String(vars.info && vars.info.category ? vars.info.category : ''),
-    DESC_EN: String(vars.info && vars.info.descriptionEn ? vars.info.descriptionEn : ''),
-    DESC_ZH: String(vars.info && vars.info.descriptionZh ? vars.info.descriptionZh : ''),
-  }
-  return String(tpl ?? '').replace(/\{(OWNER|REPO|NAME|CATEGORY|DESC_EN|DESC_ZH)\}/g, (_, k) => map[k] ?? '')
-}
-
-/**
- * 预置规则：awesome-dsh-plugin 插件收录 PR（依据 提示词.md §2 流程）。
- * 写入插件目录 rules/awesome-dsh-plugin__awesome-dsh-plugin.json；已存在则不覆盖
- * （用户/AI 更新过的规则优先）。
- */
-const PRESET_PR_RULES = [{
-  owner: 'awesome-dsh-plugin',
-  repo: 'awesome-dsh-plugin',
-  rule: {
-    provider: 'github',
-    owner: 'awesome-dsh-plugin',
-    repo: 'awesome-dsh-plugin',
-    baseBranch: 'main',
-    entryFilePath: 'data/plugins/{OWNER}__{REPO}.yml',
-    entryTemplate: [
-      'url: https://github.com/{OWNER}/{REPO}',
-      'name: {NAME}',
-      'category: {CATEGORY}',
-      'description:',
-      "  en: '{DESC_EN}'",
-      "  zh: '{DESC_ZH}'",
-      '',
-    ].join('\n'),
-    regenerateCommands: [['npm', 'ci'], ['node', 'scripts/generate-readme.mjs']],
-    prTitle: 'Add {NAME}',
-    prBodyHint: '新增条目文件 data/plugins/{OWNER}__{REPO}.yml；已运行重生成命令更新 README；仓库已满足 dsh.bundle 声明、满 1 天、提交数 ≥10、dsh-plugin topic；描述已对照源码核实。',
-    steps: [
-      { type: 'ensure-fork' },
-      { type: 'clone-fork' },
-      { type: 'add-upstream' },
-      { type: 'fetch-upstream' },
-      { type: 'branch', name: 'add-{REPO}' },
-      { type: 'write-entry' },
-      { type: 'regenerate-readme' },
-      { type: 'commit', message: 'Add {NAME}' },
-      { type: 'push' },
-      { type: 'create-pr' },
-    ],
-    preset: true,
-    generatedAt: '2026-09 (preset)',
-    model: 'preset',
-  },
-}]
-
-/** 启动时把预置规则写入插件目录 rules/（仅当对应文件不存在）。 */
-function seedPresetPrRules() {
-  for (const p of PRESET_PR_RULES) {
-    if (readPrRule(p.owner, p.repo)) continue
-    writePrRule(p.owner, p.repo, p.rule)
-  }
-}
-
-/**
- * 按规则执行 PR：fork → 克隆 fork → 加 upstream → 拉取 → 建分支 → 写条目 → 重生成 README →
- * 提交 → 推送 → 开 PR（GitHub 走 gh，Gitee 走 OpenAPI）。
- * @param {*} ctx - cordis context。
- * @param {{url: string, workdir?: string, rule?: object, entryContent?: string, title?: string, body?: string, base?: string}} input
- */
-async function prExecuteFlow(ctx, { url, workdir, rule, entryContent, title, body, base }) {
-  const { provider, owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return { ok: false, error: tr('无法识别仓库地址：') + String(url || '') }
-  const steps = rule && Array.isArray(rule.steps) ? rule.steps : []
-  if (steps.length === 0) return { ok: false, error: tr('没有可用的 PR 步骤（请先让 AI 分析规则）') }
-  const work = String(workdir || '').trim() || cloneDefaultDir()
-  const cloneDir = join(work, repo)
-  const upstreamUrl = provider === 'gitee'
-    ? 'https://gitee.com/' + owner + '/' + repo + '.git'
-    : 'https://github.com/' + owner + '/' + repo + '.git'
-  const baseBranch = base || (rule && rule.baseBranch) || 'main'
-  const logs = []
-  const stepRun = (label, cmd, args, opts = {}) => {
-    const r = run(cmd, args, { ...opts, timeout: opts.timeout ?? 300_000, cwd: opts.cwd || cloneDir, env: { ...process.env, GIT_SSH: WORKING_SSH, ...(opts.env || {}) } })
-    logs.push({ label, ok: r.ok, output: ((r.stdout || '') + (r.stderr || '')).trim() })
-    return r
-  }
-  for (const s of steps) {
-    const type = s && typeof s === 'object' ? String(s.type || '') : String(s || '')
-    switch (type) {
-      case 'ensure-fork': {
-        if (provider === 'gitee') {
-          const o = giteeOwner()
-          if (!o) return { ok: false, logs, error: tr('需要先配置 Gitee 私人令牌') }
-          const api = giteeApi('POST', 'repos/' + owner + '/' + repo + '/forks')
-          logs.push({ label: tr('确保 fork'), ok: api.ok || giteeApiFailed(api.data) === false, output: (api.error || tr('已 fork 或 fork 已存在')) })
-        } else {
-          const fr = run(GH, ['repo', 'fork', owner + '/' + repo, '--remote=false'], { timeout: 120_000, env: { GIT_SSH: WORKING_SSH } })
-          const blob = ((fr.stdout || '') + (fr.stderr || '')).trim()
-          // gh repo fork 在 fork 已存在时以非零退出并提示 "already exists"，视为成功；
-          // 其他失败（网络/权限）才记为失败。
-          const already = /already exists/i.test(blob)
-          logs.push({ label: tr('确保 fork'), ok: fr.ok || already, output: blob || tr('已 fork 或 fork 已存在') })
-        }
-        break
-      }
-      case 'clone-fork': {
-        if (existsSync(cloneDir) && existsSync(join(cloneDir, '.git'))) {
-          logs.push({ label: tr('克隆 fork'), ok: true, output: tr('已存在本地副本：') + cloneDir })
-        } else {
-          const me = provider === 'gitee' ? (giteeOwner() || owner) : (ghOwner() || owner)
-          const forkUrl = provider === 'gitee'
-            ? ('git@gitee.com:' + me + '/' + repo + '.git')
-            : ('git@github.com:' + me + '/' + repo + '.git')
-          const r = run(GIT, ['clone', forkUrl, cloneDir], { timeout: 600_000, env: { GIT_SSH: WORKING_SSH } })
-          logs.push({ label: tr('克隆 fork'), ok: r.ok, output: ((r.stdout || '') + (r.stderr || '')).trim() || tr('已克隆到 ') + cloneDir })
-          if (!r.ok) return { ok: false, logs, error: tr('克隆 fork 失败') }
-        }
-        break
-      }
-      case 'add-upstream': {
-        let r = stepRun(tr('添加上游'), GIT, ['remote', 'add', 'upstream', upstreamUrl])
-        if (!r.ok) r = stepRun(tr('添加上游'), GIT, ['remote', 'set-url', 'upstream', upstreamUrl])
-        logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || upstreamUrl
-        break
-      }
-      case 'fetch-upstream': {
-        const r = stepRun(tr('拉取上游'), GIT, ['fetch', 'upstream'], { timeout: 120_000 })
-        if (!r.ok) logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('拉取失败')
-        break
-      }
-      case 'branch': {
-        const raw = (s && s.name) || ('add-' + repo)
-        const b = fillPrTemplate(String(raw), { owner, repo, info: {} })
-        const r = stepRun(tr('新建分支'), GIT, ['checkout', '-B', b, 'upstream/' + baseBranch])
-        if (!r.ok) {
-          logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('创建分支失败')
-          // 分支创建失败必须中止：后续 write-entry/commit/push 会在错误的当前分支上
-          // 继续（例如推送到 fork 默认分支），可能造成非预期提交。
-          return { ok: false, logs, error: tr('创建分支失败（上游分支可能不存在，请检查规则 baseBranch）') }
-        }
-        break
-      }
-      case 'write-entry': {
-        const p = fillPrTemplate(String((s && s.path) || (rule && rule.entryFilePath) || '').trim(), { owner, repo, info: {} })
-        if (!p) { logs.push({ label: tr('写入条目'), ok: false, output: tr('缺少条目文件路径') }); break }
-        // 防路径穿越：条目路径必须安全落在 cloneDir 内（规则来自 AI/缓存，可能被诱导）。
-        if (!safeEntryPath(cloneDir, p)) {
-          logs.push({ label: tr('写入条目'), ok: false, output: tr('条目文件路径不安全（已拦截）') + ': ' + p })
-          return { ok: false, logs, error: tr('条目文件路径不安全（已拦截）') }
-        }
-        try {
-          mkdirSync(dirname(join(cloneDir, p)), { recursive: true })
-          writeFileSync(join(cloneDir, p), entryContent || '', 'utf8')
-          logs.push({ label: tr('写入条目'), ok: true, output: p })
-        } catch (e) { logs.push({ label: tr('写入条目'), ok: false, output: String(e) }) }
-        break
-      }
-      case 'regenerate-readme': {
-        const raw = (Array.isArray(s && s.commands) ? s.commands : (rule && rule.regenerateCommands)) || []
-        // 兼容两种形态：单条 [bin, ...args] 或多条 [[bin,...],[bin,...]]（顺序执行）。
-        const cmds = (Array.isArray(raw) && raw.length > 0 && Array.isArray(raw[0])) ? raw : [raw]
-        if (cmds.length > 0) {
-          // 防恶意规则：只允许白名单构建命令 + 安全参数（AI 规则可能注入任意命令）。
-          if (!safeRegenerateCommand(cmds)) {
-            logs.push({ label: tr('重生成 README'), ok: false, output: tr('重生成命令不安全（已拦截）') + ': ' + String(cmds[0] && cmds[0][0] || '') })
-            return { ok: false, logs, error: tr('重生成命令不安全（已拦截）') }
-          }
-          let failed = false
-          for (const c of cmds) {
-            const r = stepRun(tr('重生成 README'), c[0], c.slice(1), { timeout: 180_000 })
-            if (!r.ok) { logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('执行失败'); failed = true; break }
-          }
-          if (failed) return { ok: false, logs, error: tr('执行失败') }
-        } else {
-          logs.push({ label: tr('重生成 README'), ok: true, output: tr('无命令，跳过') })
-        }
-        break
-      }
-      case 'commit': {
-        run(GIT, ['-C', cloneDir, 'add', '-A'])
-        const ident = run(GIT, ['-C', cloneDir, 'config', 'user.email'])
-        if (!ident.ok) {
-          run(GIT, ['-C', cloneDir, 'config', 'user.name', 'DSH User'])
-          run(GIT, ['-C', cloneDir, 'config', 'user.email', 'dsh@localhost'])
-        }
-        const msg = fillPrTemplate(String((s && s.message) || '').trim(), { owner, repo, info: {} }) || ('Add ' + owner + '/' + repo)
-        const r = run(GIT, ['-C', cloneDir, 'commit', '-m', msg], { timeout: 60_000 })
-        logs.push({ label: tr('提交'), ok: r.ok || /nothing to commit|no changes added/i.test(((r.stdout || '') + (r.stderr || ''))), output: ((r.stdout || '') + (r.stderr || '')).trim() || tr('已提交') })
-        break
-      }
-      case 'push': {
-        const r = stepRun(tr('推送'), GIT, ['push', '-u', 'origin', currentBranch(cloneDir)], { timeout: 180_000 })
-        if (!r.ok) {
-          logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('推送失败')
-          return { ok: false, logs, error: tr('推送失败') }
-        }
-        break
-      }
-      case 'create-pr': {
-        const titleTxt = String(title || '').trim()
-          || fillPrTemplate(String((s && s.title) || (rule && rule.prTitle) || ''), { owner, repo, info: {} })
-          || ('Add ' + owner + '/' + repo)
-        const bodyTxt = String(body || '').trim()
-        const branchName = currentBranch(cloneDir)
-        if (provider === 'gitee') {
-          const tok = readGiteeToken()
-          const o = giteeOwner()
-          if (!o || !tok) return { ok: false, logs, error: tr('需要先配置 Gitee 私人令牌') }
-          const api = giteeApi('POST', 'repos/' + owner + '/' + repo + '/pulls', { title: titleTxt, head: o + ':' + branchName, base: baseBranch, body: bodyTxt || undefined }, tok)
-          const urlM = api.ok && api.data && typeof api.data.html_url === 'string' ? api.data.html_url : undefined
-          logs.push({ label: tr('创建 PR'), ok: api.ok, output: urlM || (api.error || (api.data && api.data.message) || tr('创建 PR 失败')) })
-          return { ok: api.ok, logs, prUrl: urlM, error: api.ok ? undefined : (api.error || (api.data && api.data.message) || tr('创建 PR 失败')) }
-        }
-        const me = ghOwner() || owner
-        const args = ['pr', 'create', '--repo', owner + '/' + repo, '--head', me + ':' + branchName, '--base', baseBranch, '--title', titleTxt]
-        if (bodyTxt) args.push('--body', bodyTxt)
-        const r = run(GH, args, { timeout: 180_000, cwd: cloneDir, env: { GIT_SSH: WORKING_SSH } })
-        const blob = ((r.stdout || '') + (r.stderr || '')).trim()
-        const urlM = /https:\/\/github\.com\/[^\s"]+/.exec(blob)
-        logs.push({ label: tr('创建 PR'), ok: r.ok, output: blob || tr('已创建 PR') })
-        return { ok: r.ok, logs, prUrl: urlM ? urlM[0] : undefined, error: r.ok ? undefined : (blob || tr('创建 PR 失败')) }
-      }
-      default:
-        logs.push({ label: type || tr('未知步骤'), ok: false, output: tr('未知步骤类型') })
-    }
-  }
-  return { ok: true, logs }
-}
+// ---------- ⑤ 发布 npm 包（npm publish） ----------
 
-// ---------- ⑥ 发布 npm 包（npm publish） ----------
+/** 发布/登录统一使用的官方 npm registry（镜像源只同步、不接受发布）。 */
+const NPM_OFFICIAL_REGISTRY = 'https://registry.npmjs.org'
 
-/** npm 状态：是否安装、registry、whoami、目标目录是否存在 package.json。 */
+/** npm 状态：是否安装、registry、whoami、目标目录是否存在 package.json。
+ *  whoami 与发布都固定走官方源 NPM_OFFICIAL_REGISTRY（用户全局可能是镜像源）。 */
 function npmStatus(dir) {
   const npm = NPM
   const cwd = String(dir || '').trim() || cloneDefaultDir()
   const installed = npm !== 'npm' && npm !== 'npm.cmd'
   const registry = run(npm, ['config', 'get', 'registry'], { shell: IS_WIN })
-  const whoami = run(npm, ['whoami'], { shell: IS_WIN })
+  const whoami = run(npm, ['whoami', '--registry=' + NPM_OFFICIAL_REGISTRY], { shell: IS_WIN })
+  const configReg = registry.ok ? registry.stdout.trim() : undefined
   return {
     ok: true,
     installed,
@@ -2706,7 +2507,10 @@ function npmStatus(dir) {
     dir: cwd,
     dirExists: existsSync(cwd),
     hasPackageJson: existsSync(join(cwd, 'package.json')),
-    registry: registry.ok ? registry.stdout.trim() : undefined,
+    registry: configReg,
+    // 发布实际使用的官方源；配置源是镜像时置 warning 供面板提示。
+    publishRegistry: NPM_OFFICIAL_REGISTRY,
+    mirrorConfigured: configReg !== undefined && !configReg.startsWith('https://registry.npmjs.org'),
     whoami: whoami.ok ? whoami.stdout.trim() : undefined,
     whoamiError: whoami.ok ? undefined : ((whoami.stderr || whoami.stdout || '').trim() || tr('未登录 npm')),
   }
@@ -2714,13 +2518,19 @@ function npmStatus(dir) {
 
 /**
  * 打开一个终端窗口，在目标目录运行 `npm login`（交互式登录无法非交互执行，
- * 需要用户在弹出的终端里完成）。Windows 用 `start cmd /k`；macOS/Linux 探测常见终端。
+ * 需要用户在弹出的终端里完成）。登录固定走官方源。
+ *
+ * 安全要点：
+ *  - 先探测终端二进制真实存在（findTerminal），绝不 spawn 不存在的程序——
+ *    spawn 对 ENOENT 是异步 error，无监听器会抛未捕获异常把 host 进程打崩；
+ *  - 每个 child 都挂 'error' 监听器兜底；
+ *  - KDE 的 konsole 用 --separate 开独立窗口，避免与宿主所在的 konsole 实例纠缠。
  * @param {string} [dir] - 目标目录。
  * @returns {{ok:boolean, opened:boolean, command:string, detail:string}}
  */
 function npmLoginTerminal(dir) {
   const cwd = String(dir || '').trim() || cloneDefaultDir()
-  const command = 'npm login'
+  const command = 'npm login --registry=' + NPM_OFFICIAL_REGISTRY
   const cdCmd = IS_WIN
     ? `cd /d "${cwd}" && ${command}`
     : `cd "${cwd}" && ${command}`
@@ -2728,28 +2538,40 @@ function npmLoginTerminal(dir) {
     if (IS_WIN) {
       // start cmd /k 打开独立窗口（第一引号段是窗口标题）；detached 不阻塞宿主。
       const child = spawn('cmd', ['/c', 'start', '"npm-login"', 'cmd', '/k', cdCmd], { detached: true, stdio: 'ignore', windowsHide: false })
+      child.on('error', () => { /* 防御：错误已由返回文案覆盖 */ })
       child.unref()
       return { ok: true, opened: true, command, detail: tr('已打开终端窗口，请完成 npm login 后回到面板点「重新检查」') }
     }
-    const terms = [
-      ['x-terminal-emulator', ['-e', 'sh', '-c', cdCmd]],
-      ['gnome-terminal', ['--', 'sh', '-c', cdCmd]],
-      ['konsole', ['-e', 'sh', '-c', cdCmd]],
-      ['xterm', ['-e', 'sh', '-c', cdCmd]],
-    ]
-    for (const [bin, args] of terms) {
-      try {
-        const child = spawn(bin, args, { detached: true, stdio: 'ignore' })
-        child.unref()
-        return { ok: true, opened: true, command, detail: tr('已打开终端窗口，请完成 npm login 后回到面板点「重新检查」') }
-      } catch { /* try next terminal */ }
+    const bin = findTerminal()
+    if (bin === null) {
+      return { ok: false, opened: false, command, detail: tr('未找到可用终端，请手动在目标目录运行：') + command }
     }
-    return { ok: false, opened: false, command, detail: tr('未找到可用终端，请手动在目标目录运行：') + command }
+    const args = (bin === 'konsole')
+      ? ['--separate', '-e', 'sh', '-c', cdCmd]                       // KDE：独立窗口，不并入宿主实例
+      : (bin === 'gnome-terminal')
+        ? ['--', 'sh', '-c', cdCmd]
+        : ['-e', 'sh', '-c', cdCmd]                                   // xterm 系 / x-terminal-emulator 等
+    const child = spawn(bin, args, { detached: true, stdio: 'ignore' })
+    child.on('error', () => { /* 防御：二进制被删等竞态也不会崩宿主 */ })
+    child.unref()
+    return { ok: true, opened: true, command, detail: tr('已打开终端窗口，请完成 npm login 后回到面板点「重新检查」') }
   } catch (e) {
     return { ok: false, opened: false, command, detail: String((e && e.message) || e) }
   }
 }
 
+/** 在 PATH 中找可用的终端程序（找不到返回 null）。 */
+function findTerminal() {
+  const candidates = [
+    'x-terminal-emulator', 'konsole', 'gnome-terminal', 'xfce4-terminal',
+    'mate-terminal', 'lxterminal', 'xterm', 'kitty', 'alacritty', 'wezterm',
+  ]
+  for (const bin of candidates) {
+    if (findOnPath(bin)) return bin
+  }
+  return null
+}
+
 /** 脱敏 npm config list 输出：隐藏 token / auth 等敏感值。 */
 function redactNpmList(output) {
   return String(output || '').split(/\r?\n/).map((line) => {
@@ -2772,14 +2594,19 @@ function npmRunStep(dir, step) {
   switch (step) {
     case 'registry': {
       const r = runNpm(['config', 'get', 'registry'])
-      return { ok: true, step, output: r.ok ? r.stdout.trim() : ((r.stderr || '') + (r.stdout || '')).trim() }
+      const cfg = r.ok ? r.stdout.trim() : ((r.stderr || '') + (r.stdout || '')).trim()
+      // 配置源与发布源分离展示：发布固定走官方源，避免镜像源导致发布失败。
+      const extra = cfg && !cfg.startsWith('https://registry.npmjs.org')
+        ? '\n' + tr('配置源是镜像，发布将使用官方源：') + NPM_OFFICIAL_REGISTRY
+        : ''
+      return { ok: true, step, output: cfg + extra }
     }
     case 'list': {
       const r = runNpm(['config', 'list'])
       return { ok: true, step, output: redactNpmList((r.stdout || '') + (r.stderr || '')) }
     }
     case 'whoami': {
-      const r = runNpm(['whoami'])
+      const r = runNpm(['whoami', '--registry=' + NPM_OFFICIAL_REGISTRY])
       return { ok: true, step, output: r.ok ? r.stdout.trim() : ((r.stderr || r.stdout || '').trim() || tr('未登录 npm')), loggedIn: r.ok }
     }
     case 'pack': {
@@ -2787,7 +2614,8 @@ function npmRunStep(dir, step) {
       return { ok: true, step, output: (r.stdout || '') + (r.stderr || '') }
     }
     case 'publish': {
-      const r = runNpm(['publish'], 180_000)
+      // 发布固定走官方源（用户全局可能是 npmmirror 等镜像，镜像不接受发布）。
+      const r = runNpm(['publish', '--registry=' + NPM_OFFICIAL_REGISTRY], 180_000)
       const blob = ((r.stdout || '') + (r.stderr || '')).trim()
       return { ok: r.ok, step, output: blob || tr('npm publish 已执行'), error: r.ok ? undefined : (blob || tr('npm publish 失败')) }
     }
@@ -3108,8 +2936,6 @@ function baseName(p) {
 }
 
 export function apply(ctx) {
-  // 启动时把预置 PR 规则（awesome-dsh-plugin 等）写入插件目录 rules/（不存在才写）。
-  seedPresetPrRules()
   const fallbackDir = resolveDefaultDir(process.cwd())
   // 每个请求按 ?lang= 参数跑在独立语言上下文里（AsyncLocalStorage），
   // 所有 flow 函数内的 tr() 都能读到当前请求的语言，并发请求互不干扰。
@@ -3119,15 +2945,57 @@ export function apply(ctx) {
     json(res, 200, payload)
   })
 
+  // 流式变体：逐行 NDJSON 事件（{type:'step'|'out'|'result'}），供一键安装弹窗展示实时进度。
+  const handleStream = async (req, res, fn) => requestLangStore.run(langOf(req), async () => {
+    if (!isLoopbackRequest(req)) return forbidden(res)
+    res.writeHead(200, { 'Content-Type': 'application/x-ndjson; charset=utf-8', 'Cache-Control': 'no-cache' })
+    const emit = (obj) => { try { res.write(JSON.stringify(obj) + '\n') } catch { /* client gone */ } }
+    try {
+      const result = await fn(emit)
+      emit({ type: 'result', result })
+    } catch (error) {
+      emit({ type: 'result', result: { ok: false, error: String((error && error.message) || error) } })
+    }
+    try { res.end() } catch { /* ignore */ }
+  })
+
   const routes = {
     '/env': (req, res) => handle(req, res, async () => ({ ok: true, ...checkEnv() })),
     '/install-tool': async (req, res) => {
       if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
+      await handleStream(req, res, async (emit) => {
         const body = JSON.parse((await readBody(req)) || '{}')
-        return installToolFlow(body.tool)
+        return installToolFlow(body.tool, emit)
       })
     },
+    '/restart': async (req, res) => {
+      if (req.method !== 'POST') {
+        res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8' })
+        res.end('method not allowed')
+        return
+      }
+      if (!trustedRestartRequest(req)) {
+        res.writeHead(403, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ ok: false, code: 'forbidden' }))
+        return
+      }
+      if (!restartAllowed()) {
+        res.writeHead(403, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ ok: false, code: 'restart-disabled', message: '重启已被禁用（supervisor 托管或 DSH_SCM_RESTART=0）' }))
+        return
+      }
+      // 先应答，再让 helper 接手：500ms 后本进程退出，helper 等端口释放后按原命令拉起新进程。
+      let result
+      try {
+        result = scheduleRestart(servingPort(req))
+      } catch (error) {
+        res.writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ ok: false, error: `无法启动重启进程：${error instanceof Error ? error.message : String(error)}` }))
+        return
+      }
+      res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-cache' })
+      res.end(JSON.stringify({ ok: true, ...(result ?? { already: true }) }))
+    },
     '/ssh': (req, res) => handle(req, res, async () => ({ ok: true, ...checkSsh() })),
     '/gen-key': async (req, res) => {
       if (req.method !== 'POST') return methodNotAllowed(res, req.method)
@@ -3380,7 +3248,7 @@ export function apply(ctx) {
     },
 
     // ---- ④ 克隆远程仓库 ----
-    // 默认工作区（⑤⑥ 等板块兜底）。
+    // 默认工作区（⑤ 等板块兜底）。
     '/clone/default-dir': (req, res) => handle(req, res, async () => {
       const dir = cloneDefaultDir()
       return { ok: true, dir, name: baseName(dir) }
@@ -3407,64 +3275,7 @@ export function apply(ctx) {
       })
     },
 
-    // ---- ⑤ 提交 PR ----
-    '/pr/targets': async (req, res) => {
-      if (req.method === 'GET') {
-        await handle(req, res, async () => ({ ok: true, targets: readPrTargets() }))
-      } else if (req.method === 'POST') {
-        await handle(req, res, async (req) => {
-          const body = JSON.parse((await readBody(req)) || '{}')
-          const url = String(body.url || '').trim()
-          if (!url) return { ok: false, error: tr('缺少仓库地址') }
-          if (body.remove) return { ok: true, targets: removePrTarget(url) }
-          return { ok: true, targets: savePrTarget(url) }
-        })
-      } else {
-        return methodNotAllowed(res, req.method)
-      }
-    },
-    // 只读查询某仓库是否有缓存规则（命中插件目录 rules/，不触发 AI，不生成）。
-    '/pr/rule': async (req, res) => {
-      if (req.method !== 'GET') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const q = new URL(req.url ?? '', 'http://localhost')
-        const url = q.searchParams.get('url') || ''
-        const { provider, owner, repo } = parseRepoUrl(url)
-        if (!owner || !repo) return { ok: true, hasRule: false, url: String(url) }
-        const cached = readPrRule(owner, repo)
-        return {
-          ok: true, hasRule: !!cached, url: String(url),
-          provider, owner, repo,
-          rule: cached || null,
-        }
-      })
-    },
-    '/pr/analyze': async (req, res) => {
-      if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const body = JSON.parse((await readBody(req)) || '{}')
-        return prAnalyzeFlow(ctx, { url: body.url, force: !!body.force, ruleText: body.ruleText, ruleFile: body.ruleFile })
-      })
-    },
-    '/pr/generate': async (req, res) => {
-      if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const body = JSON.parse((await readBody(req)) || '{}')
-        return prGenerateFlow(ctx, { url: body.url, rule: body.rule, pluginInfo: body.pluginInfo })
-      })
-    },
-    '/pr/execute': async (req, res) => {
-      if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const body = JSON.parse((await readBody(req)) || '{}')
-        return prExecuteFlow(ctx, {
-          url: body.url, workdir: body.workdir, rule: body.rule,
-          entryContent: body.entryContent, title: body.title, body: body.body, base: body.base,
-        })
-      })
-    },
-
-    // ---- ⑥ 发布 npm 包 ----
+    // ---- ⑤ 发布 npm 包 ----
     '/npm/status': async (req, res) => {
       if (req.method !== 'GET') return methodNotAllowed(res, req.method)
       await handle(req, res, async (req) => {
@@ -3497,3 +3308,6 @@ export function apply(ctx) {
 }
 
 export default { name, inject, apply }
+
+// 供插件作者 / 测试直接调用（不影响插件加载）。
+export { checkEnv, installCommand, installCommandSystem, ghUserLevelScript, ghUserLevelSteps, ghReleaseAsset, toolInstalled, canSudo, restartNeededFor, installToolFlow, restartAllowed, servingPort, trustedRestartRequest, restartLaunch, scheduleRestart, npmStatus, npmLoginTerminal, npmRunStep, findTerminal }