zen-gitsync 2.13.29 → 2.13.32

package/README.md

@@ -288,7 +288,7 @@ Prompt presets and tasks are persisted to `~/.zen-gitsync/prompts.json` and `~/.
 
 ### Self-Upgrade
 
-The footer version chip in the GUI checks npm for newer releases once per session. When an update is available, a **Upgrade** button appears next to the version; clicking it streams `npm install -g zen-gitsync` output into a modal dialog. On success, the dialog switches to a "Restart and reload now" CTA that calls `POST /api/app-restart` (which gracefully exits the Node process — your launcher / desktop shell brings it back up) and then reloads the browser tab so the new SPA bundle takes effect. The footer version also updates instantly to the new number so you can see the bump even before restarting.
+The footer version chip in the GUI checks npm for newer releases once per session. When an update is available, a **Upgrade** button appears next to the version; clicking it streams `npm install -g zen-gitsync` output into a modal dialog. On success, the dialog switches to a "Restart and reload now" CTA. Clicking it calls `POST /api/app-restart`, which **self-respawns a new Node process** (no external launcher / desktop shell is required), waits for the new process to bind its port, streams that port back to the browser over NDJSON, and gracefully exits the old process. The browser then **redirects** to the new port (preserving the current path, query, and hash) so the upgraded backend serves the next request. The footer version also updates instantly to the new number so you can see the bump even before restarting. If the child process fails to come up within 8s, the old process is preserved and an error toast is shown — your session stays connected.
 
 On macOS / Linux, the global install is run under `sudo -n` (non-interactive); if sudo can't authenticate non-interactively, re-launch the GUI with admin rights and try again.
 
@@ -690,7 +690,7 @@ Activity Bar 第四个视图，用于在当前仓库上批量调度 Claude：定
 
 ### 自升级
 
-GUI 底栏版本号每个会话会向 npm 查询一次最新版本。检测到更新时版本旁会出现 **升级** 按钮，点击后在弹窗里实时回传 `npm install -g zen-gitsync` 的输出；升级成功后弹窗会切换为「**立即重启并刷新**」主 CTA，调用 `POST /api/app-restart` 让 Node 进程优雅退出（外层 launcher / desktop 壳会自动拉起新版本），再 reload 当前 tab 让新 SPA 资源生效。同时底栏版本号会立刻刷新到新版本号，重启前就能看到。
+GUI 底栏版本号每个会话会向 npm 查询一次最新版本。检测到更新时版本旁会出现 **升级** 按钮，点击后在弹窗里实时回传 `npm install -g zen-gitsync` 的输出；升级成功后弹窗会切换为「**立即重启并刷新**」主 CTA。点击后调用 `POST /api/app-restart`，后端**自行 spawn 新 Node 进程**（不依赖任何外层 launcher / 桌面壳），通过 NDJSON 流把新进程端口推回前端，旧进程再优雅退出；浏览器**重定向**到新端口（保留当前 path、query、hash）由新后端服务后续请求。同时底栏版本号会立刻刷新到新版本号，重启前就能看到。若子进程 8 秒内未就绪，旧进程不退出并弹错误提示，您的会话保持连接。
 
 > macOS / Linux 上全局安装需要 sudo，前端会用 `sudo -n` 非交互式尝试；如非免密 sudo，请以管理员权限重启 GUI 后再试。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-gitsync",
-  "version": "2.13.29",
+  "version": "2.13.32",
   "description": "Auto commit, scheduled sync, and visual GUI for Git. Run `g` in any repo for one-key commit & push, AI commit messages, scheduled background sync, and a drag-and-drop workflow builder.",
   "main": "index.js",
   "type": "module",
@@ -55,7 +55,9 @@
     "src/utils/**",
     "src/gitCommit.js",
     "src/config.js",
+    "src/cli/**",
     "scripts/**",
+    "!scripts/archive/**",
     "package.json",
     "index.js"
   ],

package/src/cli/cleanup.js

@@ -0,0 +1,179 @@
+// Copyright 2026 xz333221
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// 长跑 CLI 任务的资源清理工具(SIGINT 时统一 drain 定时器 + 子进程)。
+// 抽到独立模块是为了便于单元测试 + 跨多个 CLI 入口(gitCommit.js /
+// future scheduled 命令面板)复用。
+//
+// 用法:
+//   import { registerCleanup, trackChild, setupSigintHandler } from './cli/cleanup.js'
+//   registerCleanup('mytimer', () => clearInterval(t))
+//   const child = trackChild(exec('npm run build'))
+//   setupSigintHandler()  // 只调一次,SIGINT 时按顺序 drain
+//
+// 设计原则:
+//   - 单次注册:setupSigintHandler 内部用 sigintRegistered 守防止重复挂监听
+//   - 幂等触发:多次 SIGINT 只生效第一次,避免 drain 中再次进入 cleanupTasks
+//   - 优雅退出:子进程先 SIGTERM 给 500ms 窗口,SIGKILL 兜底
+//   - 错误隔离:cleanup fn 抛错不影响后续 fn 与 killChildren
+
+import process from 'node:process'
+
+/**
+ * @typedef {Object} CleanupRegistry
+ * @property {() => Promise<void> | void} [fn] - cleanup 函数
+ */
+
+/** @type {Map<string, () => void | Promise<void>>} */
+const cleanupTasks = new Map()
+
+/** @type {Set<import('node:child_process').ChildProcess>} */
+const activeChildren = new Set()
+
+let sigintRegistered = false
+let sigintFired = false
+
+/**
+ * 注册一个 cleanup 任务。同名注册会覆盖前一次(常用于"最近一次 setTimeout"
+ * 这种语义:递归 commit 时,新 timer 替换旧 timer,旧 timer 自然过期)。
+ *
+ * @param {string} name - 任务唯一标识
+ * @param {() => void | Promise<void>} fn - 清理函数,可异步
+ */
+export function registerCleanup(name, fn) {
+  if (typeof name !== 'string' || !name) {
+    throw new TypeError('registerCleanup: name 必须是非空字符串')
+  }
+  if (typeof fn !== 'function') {
+    throw new TypeError('registerCleanup: fn 必须是函数')
+  }
+  cleanupTasks.set(name, fn)
+}
+
+/**
+ * 注销一个已注册的 cleanup 任务。
+ *
+ * @param {string} name
+ */
+export function unregisterCleanup(name) {
+  cleanupTasks.delete(name)
+}
+
+/**
+ * 清空所有已注册任务(测试 / 重置场景用)。
+ */
+export function clearAllCleanup() {
+  cleanupTasks.clear()
+}
+
+/**
+ * 跟踪 child_process 子进程,SIGINT 时统一 kill。
+ * 子进程 exit 时自动从集合移除,避免内存泄漏。
+ *
+ * @template {import('node:child_process').ChildProcess} T
+ * @param {T} child
+ * @returns {T} 原 child(便于链式调用)
+ */
+export function trackChild(child) {
+  if (!child || typeof child.kill !== 'function') return child
+  activeChildren.add(child)
+  child.once('exit', () => activeChildren.delete(child))
+  return child
+}
+
+/**
+ * 杀掉所有跟踪中的子进程。先 SIGTERM 给 graceMs 优雅退出,再 SIGKILL 兜底。
+ *
+ * @param {number} [graceMs=500] - SIGTERM 后等多久升级到 SIGKILL
+ */
+export async function killAllTrackedChildren(graceMs = 500) {
+  const children = [...activeChildren]
+  if (children.length === 0) return { terminated: 0 }
+  for (const child of children) {
+    try { child.kill('SIGTERM') } catch (_) {}
+  }
+  await new Promise((r) => setTimeout(r, graceMs))
+  for (const child of children) {
+    try { child.kill('SIGKILL') } catch (_) {}
+  }
+  return { terminated: children.length }
+}
+
+/**
+ * 同步执行所有注册任务(支持 async fn)。任何 fn 抛错都被吞掉,不影响后续。
+ */
+export async function runCleanupTasks() {
+  const tasks = [...cleanupTasks.values()]
+  cleanupTasks.clear()
+  for (const fn of tasks) {
+    try {
+      await fn()
+    } catch (_) {
+      // 隔离错误 — 单个 cleanup 失败不能阻断其它资源释放
+    }
+  }
+}
+
+/**
+ * 当前跟踪中的子进程数(测试 / 调试用)。
+ */
+export function getTrackedChildCount() {
+  return activeChildren.size
+}
+
+/**
+ * 全程序注册一次 SIGINT 处理器。
+ * 顺序:logUpdate.clear → runCleanupTasks → killAllTrackedChildren → exit 130。
+ * 多次调用安全(幂等 — sigintRegistered 守卫)。
+ *
+ * @param {object} [options]
+ * @param {() => void} [options.onBeforeCleanup] - 清理前钩子(用于 logUpdate.clear 等)
+ * @param {() => void} [options.onAfterCleanup] - 清理后钩子
+ * @returns {() => void} dispose — 注销函数(测试场景用来清理)
+ */
+export function setupSigintHandler(options = {}) {
+  if (sigintRegistered) return () => {}
+  sigintRegistered = true
+  const handler = async () => {
+    if (sigintFired) return
+    sigintFired = true
+    try {
+      try { options.onBeforeCleanup?.() } catch (_) {}
+      await runCleanupTasks()
+      await killAllTrackedChildren()
+      try { options.onAfterCleanup?.() } catch (_) {}
+    } finally {
+      // 128 + SIGINT(2) = 130,符合 shell 惯例
+      process.exit(130)
+    }
+  }
+  process.on('SIGINT', handler)
+  // 返回 dispose 用于测试清理 — removeListener + 重置标志
+  return () => {
+    process.removeListener('SIGINT', handler)
+    sigintRegistered = false
+    sigintFired = false
+  }
+}
+
+/**
+ * 重置内部状态 — 仅用于测试场景,生产代码不要调。
+ * 注意:不主动移除 SIGINT listener(由调用方通过 setupSigintHandler 返回的 dispose 处理)。
+ */
+export function _resetForTests() {
+  cleanupTasks.clear()
+  activeChildren.clear()
+  sigintRegistered = false
+  sigintFired = false
+}

package/src/cli/cleanup.test.js

@@ -0,0 +1,269 @@
+// Copyright 2026 xz333221
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// src/cli/cleanup.js 单元测试(node:test 内置)。
+// 覆盖 registerCleanup / trackChild / runCleanupTasks / killAllTrackedChildren
+// 的核心契约:幂等、错误隔离、覆盖语义、SIGINT 触发清理。
+import { test, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import {
+  registerCleanup, unregisterCleanup, clearAllCleanup,
+  trackChild, killAllTrackedChildren, runCleanupTasks,
+  getTrackedChildCount, setupSigintHandler, _resetForTests,
+} from './cleanup.js'
+
+// 每个 case 跑完清理一次,避免 SIGINT 注册 / 子进程跟踪跨用例污染。
+// 保存当前 case 注册的 dispose,在 afterEach 调用,确保 process 的 SIGINT
+// listener 列表不会越积越多,跨 test 的 handler 不会误触发。
+const disposers = []
+afterEach(() => {
+  while (disposers.length) {
+    try { disposers.pop()() } catch (_) {}
+  }
+  _resetForTests()
+})
+function trackDispose(dispose) { disposers.push(dispose); return dispose }
+
+// ========== registerCleanup ==========
+
+test('registerCleanup: 注册同步 fn 并触发 runCleanupTasks', async () => {
+  let called = 0
+  registerCleanup('sync', () => { called++ })
+  await runCleanupTasks()
+  assert.equal(called, 1)
+})
+
+test('registerCleanup: 注册异步 fn 并 await 完成', async () => {
+  let resolved = false
+  registerCleanup('async', async () => {
+    await new Promise((r) => setTimeout(r, 10))
+    resolved = true
+  })
+  await runCleanupTasks()
+  assert.equal(resolved, true)
+})
+
+test('registerCleanup: 同名注册覆盖前一次', async () => {
+  let first = 0
+  let second = 0
+  registerCleanup('overlap', () => { first++ })
+  registerCleanup('overlap', () => { second++ })
+  await runCleanupTasks()
+  assert.equal(first, 0, '首次注册应被覆盖')
+  assert.equal(second, 1)
+})
+
+test('registerCleanup: 多个任务按注册顺序串行执行', async () => {
+  const order = []
+  registerCleanup('a', async () => {
+    await new Promise((r) => setTimeout(r, 5))
+    order.push('a')
+  })
+  registerCleanup('b', () => { order.push('b') })
+  registerCleanup('c', () => { order.push('c') })
+  await runCleanupTasks()
+  assert.deepEqual(order, ['a', 'b', 'c'])
+})
+
+test('registerCleanup: 单个 fn 抛错不影响后续', async () => {
+  let afterError = false
+  registerCleanup('bad', () => { throw new Error('boom') })
+  registerCleanup('good', () => { afterError = true })
+  await runCleanupTasks()
+  assert.equal(afterError, true)
+})
+
+test('registerCleanup: 入参校验', () => {
+  assert.throws(() => registerCleanup('', () => {}), /name/)
+  assert.throws(() => registerCleanup(null, () => {}), /name/)
+  assert.throws(() => registerCleanup('x', null), /fn/)
+  assert.throws(() => registerCleanup('x', 'not fn'), /fn/)
+})
+
+test('registerCleanup: runCleanupTasks 后任务被清空(单次执行语义)', async () => {
+  let called = 0
+  registerCleanup('once', () => { called++ })
+  await runCleanupTasks()
+  await runCleanupTasks()
+  assert.equal(called, 1, '第二次 run 不应再触发已清理任务')
+})
+
+test('unregisterCleanup: 注销后任务不再触发', async () => {
+  let called = 0
+  registerCleanup('temp', () => { called++ })
+  unregisterCleanup('temp')
+  await runCleanupTasks()
+  assert.equal(called, 0)
+})
+
+// ========== trackChild ==========
+
+test('trackChild: 自动跟踪 child 并在 exit 时移除', () => {
+  const fake = new EventEmitter()
+  fake.kill = () => true
+  trackChild(fake)
+  assert.equal(getTrackedChildCount(), 1)
+  fake.emit('exit', 0, null)
+  assert.equal(getTrackedChildCount(), 0, 'exit 后应自动移除')
+})
+
+test('trackChild: null / 非 child 入参安全 passthrough', () => {
+  // 防御:exec() 在某些平台可能返回 undefined
+  assert.equal(trackChild(null), null)
+  assert.equal(trackChild(undefined), undefined)
+  assert.equal(getTrackedChildCount(), 0)
+})
+
+test('trackChild: 链式调用保留原 child 引用', () => {
+  const fake = new EventEmitter()
+  fake.kill = () => true
+  const result = trackChild(fake)
+  assert.equal(result, fake)
+})
+
+// ========== killAllTrackedChildren ==========
+
+test('killAllTrackedChildren: 空集合快速返回', async () => {
+  const result = await killAllTrackedChildren(10)
+  assert.deepEqual(result, { terminated: 0 })
+})
+
+test('killAllTrackedChildren: 调用所有 child 的 kill', async () => {
+  const kills = []
+  const fake1 = new EventEmitter(); fake1.kill = (sig) => { kills.push(sig); fake1.emit('exit') }
+  const fake2 = new EventEmitter(); fake2.kill = (sig) => { kills.push(sig); fake2.emit('exit') }
+  trackChild(fake1); trackChild(fake2)
+  const result = await killAllTrackedChildren(10) // 短 graceMs 让测试快
+  assert.equal(result.terminated, 2)
+  // 每个 child 应被 SIGTERM,exit 后 SIGKILL 不再调用(已从集合移除)
+  assert.equal(kills.filter(s => s === 'SIGTERM').length, 2)
+})
+
+test('killAllTrackedChildren: child.kill 抛错不阻断其它', async () => {
+  const bad = new EventEmitter(); bad.kill = () => { throw new Error('EPERM') }
+  const good = new EventEmitter(); good.kill = () => good.emit('exit')
+  trackChild(bad); trackChild(good)
+  // 不应抛 — 错误隔离
+  const result = await killAllTrackedChildren(10)
+  assert.equal(result.terminated, 2)
+})
+
+// ========== runCleanupTasks 与 child 协同 ==========
+
+test('runCleanupTasks 顺序:先 cleanup 再 kill children(cleanup 可主动撤销子进程)', async () => {
+  const fake = new EventEmitter()
+  let killCount = 0
+  fake.kill = () => { killCount++; fake.emit('exit') }
+  trackChild(fake)
+  let cleanupRanFirst = null
+  registerCleanup('kill-it', () => {
+    if (killCount === 0) cleanupRanFirst = true
+    fake.kill('SIGTERM')
+  })
+  // 注:这里手动模拟顺序 — 实际 setupSigintHandler 中 runCleanupTasks 在 kill 之前
+  await runCleanupTasks()
+  assert.equal(cleanupRanFirst, true, 'cleanup 应在 kill 之前跑')
+  // killAllTrackedChildren 之后:
+  await killAllTrackedChildren(10)
+  // 此时 fake 已 exit,集合为空,不会再被 kill
+})
+
+// ========== setupSigintHandler 行为契约(不真触发 SIGINT) ==========
+
+test('setupSigintHandler: 多次调用幂等(只注册一次)', () => {
+  // 通过 listenerCount 验证
+  const before = process.listenerCount('SIGINT')
+  trackDispose(setupSigintHandler())
+  trackDispose(setupSigintHandler())
+  trackDispose(setupSigintHandler())
+  const after = process.listenerCount('SIGINT')
+  assert.equal(after - before, 1, '多次 setupSigintHandler 只应增加 1 个 listener')
+})
+
+// 辅助:触发 SIGINT 后等待 async handler 跑完。
+// 直接 await emit 不行,因为 process.emit 对 async listener 不等待。
+// 关键是:把 process.exit stub 成"只记录、不退出",这样 handler 跑完后
+// promise 正常 resolve,不会变成 unhandled rejection。
+async function fireSigintAndAwait() {
+  process.emit('SIGINT')
+  // 给 async handler 几个 microtask + macrotask 跑完
+  await new Promise((r) => setImmediate(r))
+  await new Promise((r) => setImmediate(r))
+  await new Promise((r) => setImmediate(r))
+}
+
+test('setupSigintHandler: SIGINT 触发 cleanup → exit(集成测试)', async () => {
+  let cleaned = false
+  registerCleanup('sigint-test', () => { cleaned = true })
+  trackDispose(setupSigintHandler({ onBeforeCleanup: () => {}, onAfterCleanup: () => {} }))
+  const originalExit = process.exit
+  let exitCode = null
+  process.exit = (code) => { exitCode = code /* 不真退出,让 handler 继续跑 */ }
+  try {
+    await fireSigintAndAwait()
+    assert.equal(cleaned, true, 'SIGINT 应触发 cleanup')
+    assert.equal(exitCode, 130, 'SIGINT 应以 exit code 130 退出(128 + 2)')
+  } finally {
+    process.exit = originalExit
+  }
+})
+
+test('setupSigintHandler: SIGINT 二次触发幂等', async () => {
+  let cleaned = 0
+  registerCleanup('idempotent', () => { cleaned++ })
+  trackDispose(setupSigintHandler())
+  const originalExit = process.exit
+  process.exit = () => { /* 不真退出 */ }
+  try {
+    await fireSigintAndAwait()
+    await fireSigintAndAwait()
+    await fireSigintAndAwait()
+    assert.equal(cleaned, 1, 'cleanup 应只跑一次')
+  } finally {
+    process.exit = originalExit
+  }
+})
+
+test('setupSigintHandler: cleanup 抛错不阻断 exit', async () => {
+  registerCleanup('bad', () => { throw new Error('boom') })
+  trackDispose(setupSigintHandler())
+  const originalExit = process.exit
+  let exited = false
+  process.exit = () => { exited = true }
+  try {
+    await fireSigintAndAwait()
+    assert.equal(exited, true, '即使 cleanup 抛错也应调用 exit')
+  } finally {
+    process.exit = originalExit
+  }
+})
+
+test('setupSigintHandler: onBeforeCleanup / onAfterCleanup 钩子被调用', async () => {
+  let before = false
+  let after = false
+  trackDispose(setupSigintHandler({
+    onBeforeCleanup: () => { before = true },
+    onAfterCleanup: () => { after = true },
+  }))
+  const originalExit = process.exit
+  process.exit = () => { /* 不真退出 */ }
+  try {
+    await fireSigintAndAwait()
+    assert.equal(before, true)
+    assert.equal(after, true)
+  } finally {
+    process.exit = originalExit
+  }
+})

package/src/cli/customCommand.js

@@ -0,0 +1,94 @@
+// Copyright 2026 xz333221
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// --cmd= 自定义命令的输入校验与执行模式选择。
+// 抽到独立模块是为了集中 SEC-CLI-1 的对策,便于单测和复用。
+//
+// 设计原则:
+//   1. **不破坏向后兼容**:`g:test-cmd="echo hello | wc -l"` 这种合法用法必须能跑
+//   2. **检测而非阻止**:本地 CLI 工具,用户明确输入,主要拦截意外/恶意输入
+//   3. **严格模式可显式启用**:--cmd-strict 走 execFile 拆 argv,无 shell 特性
+
+/**
+ * 自定义命令的最大允许长度 — 防止误粘贴巨型 base64 等
+ */
+export const MAX_CUSTOM_CMD_LENGTH = 1000
+
+/**
+ * 检测输入校验结果
+ * @typedef {Object} CmdValidation
+ * @property {boolean} ok - 是否可继续执行
+ * @property {string[]} warnings - 风险提示(不阻止,仅 console.warn)
+ * @property {string} [rejectReason] - 不可执行的硬性原因(null/undefined 表示允许)
+ */
+
+/**
+ * 校验 --cmd= 的输入
+ *
+ * 校验项:
+ *   - 必须是非空字符串
+ *   - 不能以 - 开头(看起来像选项,容易被 exec 误解析或 git 误接收)
+ *   - 长度不超过 MAX_CUSTOM_CMD_LENGTH
+ *   - 包含明显危险模式时打 warning(不阻止):rm -rf / · fork bomb · chmod -R 777 /
+ *
+ * @param {unknown} cmd - 来自 argv 的命令字符串
+ * @returns {CmdValidation}
+ */
+export function validateCustomCommand(cmd) {
+  const warnings = []
+  if (typeof cmd !== 'string') {
+    return { ok: false, warnings, rejectReason: '命令必须是字符串' }
+  }
+  const trimmed = cmd.trim()
+  if (trimmed.length === 0) {
+    return { ok: false, warnings, rejectReason: '命令不能为空' }
+  }
+  if (cmd.length > MAX_CUSTOM_CMD_LENGTH) {
+    return {
+      ok: false,
+      warnings,
+      rejectReason: `命令过长(${cmd.length} > ${MAX_CUSTOM_CMD_LENGTH} 字符),可能是误粘贴`
+    }
+  }
+  // 以 - 开头容易被 exec 解析成 flag 而非命令
+  if (trimmed.startsWith('-')) {
+    return {
+      ok: false,
+      warnings,
+      rejectReason: '命令不能以 - 开头(避免被误解析为选项)'
+    }
+  }
+  // 危险模式检测 — 仅警告不阻止,因为这是本地 CLI,用户明确输入
+  if (/\brm\s+(-\w+\s+)*\/(?:\s|$|\*)/.test(trimmed)) {
+    warnings.push('检测到 `rm -<flag> /` 模式,确认这不是误输入?')
+  }
+  if (/:?\(?\)\s*\{.*:\|:.*\}/.test(trimmed)) {
+    warnings.push('检测到 fork bomb 模式(:(){ :|:& };:),确定要执行?')
+  }
+  if (/\bchmod\s+(-\w+\s+)*\s*777\s+\//.test(trimmed)) {
+    warnings.push('检测到 `chmod 777 /` 模式,会放开根目录权限')
+  }
+  return { ok: true, warnings }
+}
+
+/**
+ * 判断是否启用严格模式(--cmd-strict 表示禁用 shell 特性)
+ *
+ * @param {readonly string[]} argv
+ * @returns {boolean}
+ */
+export function isCmdStrictMode(argv) {
+  if (!Array.isArray(argv)) return false
+  return argv.includes('--cmd-strict')
+}