worktree-bay 4.0.2 → 4.0.4

package/dist/commands/lifecycle.js

@@ -8,17 +8,17 @@ import { color as c } from '../util/color.js';
 import { t } from '../i18n.js';
 // dev server + infra 生命周期：stop/start/restart 同时管 node（managed 进程）与 docker（stop 钩子 + setup 恢复），不动 worktree。
 // services 为空 = 整功能；否则只这些服务
+// 幂等：未占槽 / 指定服务当前未占用 → 返回空，交调用方按 no-op 处理（重复执行不报错）。
+// 仅对「未知服务名」（typo，根本不在 config）报错。
 function occupantsOf(cfg, feature, services = []) {
+    for (const s of services)
+        if (!cfg.services[s])
+            throw new Error(t(`未知服务「${s}」。运行 \`worktree-bay doctor\` 查看配置里有哪些服务。`, `unknown service "${s}". Run \`worktree-bay doctor\` to see configured services.`));
     const slot = slotOfFeature(cfg, feature);
     if (slot === undefined)
-        throw new Error(t(`功能「${feature}」未占槽。先 \`worktree-bay up ${feature} <服务...>\` 起它。`, `feature "${feature}" hasn't claimed a slot. Run \`worktree-bay up ${feature} <services...>\` first.`));
+        return [];
     const all = scanOccupancy(cfg).get(slot) ?? [];
-    if (!services.length)
-        return all;
-    for (const s of services)
-        if (!all.some((o) => o.service === s))
-            throw new Error(t(`服务「${s}」不在功能「${feature}」里。用 \`worktree-bay ls\` 看已起的服务。`, `service "${s}" is not in feature "${feature}". See \`worktree-bay ls\`.`));
-    return all.filter((o) => services.includes(o.service));
+    return services.length ? all.filter((o) => services.includes(o.service)) : all;
 }
 function ctxOf(cfg, o) {
     const base = { cfg, service: o.service, sp: cfg.services[o.service], slot: o.slot, slug: o.slug, dir: o.dir, repo: repoPath(cfg, o.service) };
@@ -37,7 +37,7 @@ export async function stopCommand(cfg, feature, services = []) {
             await stopRuntime(ctxOf(cfg, o));
         }
         if (!any)
-            log(t('没有可停止的运行体（相关服务未配置 start/stop）', 'nothing to stop (no start/stop configured for those services)'));
+            log(c.dim(t('没有可停止的运行体（功能未占槽，或相关服务未配置 start/stop）', 'nothing to stop (feature has no slot, or those services have no start/stop)')));
     });
 }
 export async function startCommand(cfg, feature, services = []) {
@@ -51,14 +51,16 @@ export async function startCommand(cfg, feature, services = []) {
             await ensureRuntime(ctxOf(cfg, o));
         }
         if (!any)
-            log(t('没有可启动的运行体（相关服务未配置 start/stop）', 'nothing to start (no start/stop configured for those services)'));
+            log(c.dim(t(`没有可启动的运行体（功能未占槽——先 \`worktree-bay up ${feature} <服务...>\`，或相关服务未配 start/stop）`, `nothing to start (feature has no slot — run \`worktree-bay up ${feature} <services...>\` first, or those services have no start/stop)`)));
     });
 }
 export async function restartCommand(cfg, feature, services = []) {
     await withLock(cfg.workspaceRoot, async () => {
+        let any = false;
         for (const o of occupantsOf(cfg, feature, services)) {
             if (!hasRuntime(cfg, o.service))
                 continue;
+            any = true;
             const ctx = ctxOf(cfg, o);
             log(c.bold(c.cyan(o.service)) + c.dim(t('  ·  重启…', '  ·  restarting…')));
             await stopRuntime(ctx);
@@ -69,5 +71,7 @@ export async function restartCommand(cfg, feature, services = []) {
             } // 等端口释放
             await ensureRuntime(ctx);
         }
+        if (!any)
+            log(c.dim(t('没有可重启的运行体（功能未占槽，或相关服务未配置 start/stop）', 'nothing to restart (feature has no slot, or those services have no start/stop)')));
     });
 }

package/dist/commands/rm.js

@@ -9,24 +9,32 @@ import { stopManaged } from '../proc.js';
 import { log, warn } from '../util/log.js';
 import { color as c } from '../util/color.js';
 import { t } from '../i18n.js';
-// services 为空 = 整功能；否则只这些服务（顺带校验服务名确实在该功能里）
+// services 为空 = 整功能；否则只这些服务。幂等：未占槽 / 指定服务当前未占用 → 返回空（no-op），
+// 仅对「未知服务名」（typo，根本不在 config）报错。
 export function resolveRm(cfg, feature, services = []) {
+    for (const s of services)
+        if (!cfg.services[s])
+            throw new Error(t(`未知服务「${s}」。运行 \`worktree-bay doctor\` 查看配置里有哪些服务。`, `unknown service "${s}". Run \`worktree-bay doctor\` to see configured services.`));
     const slot = slotOfFeature(cfg, feature);
     if (slot === undefined)
-        throw new Error(t(`功能「${feature}」未占槽，无需拆除。用 \`worktree-bay ls\` 看在用的功能。`, `feature "${feature}" has no slot — nothing to tear down. See \`worktree-bay ls\`.`));
+        return [];
     const all = scanOccupancy(cfg).get(slot) ?? [];
-    if (!services.length)
-        return all;
-    for (const s of services)
-        if (!all.some((o) => o.service === s))
-            throw new Error(t(`服务「${s}」不在功能「${feature}」里。用 \`worktree-bay ls\` 看已起的服务。`, `service "${s}" is not in feature "${feature}". See \`worktree-bay ls\`.`));
-    return all.filter((o) => services.includes(o.service));
+    return services.length ? all.filter((o) => services.includes(o.service)) : all;
 }
 export async function rmCommand(cfg, feature, services, force) {
     await withLock(cfg.workspaceRoot, async () => {
+        const slot = slotOfFeature(cfg, feature);
+        if (slot === undefined) {
+            log(c.green('✓') + ' ' + t(`功能「${feature}」未占槽，无需拆除（已是目标状态）`, `feature "${feature}" has no slot — nothing to tear down (already in target state)`));
+            return;
+        }
         let removed = 0;
         const wholeFeature = services.length === 0;
         const occs = resolveRm(cfg, feature, services);
+        if (occs.length === 0) {
+            log(c.dim(t('指定服务当前未占用，无需拆除（已是目标状态）', 'those services aren\'t occupied — nothing to tear down (already in target state)')));
+            return;
+        }
         for (const o of occs) {
             const repo = repoPath(cfg, o.service);
             const branch = currentBranch(o.dir);
@@ -47,7 +55,6 @@ export async function rmCommand(cfg, feature, services, force) {
             await withProgress(t(`移除 ${o.service} 的 worktree`, `removing ${o.service} worktree`), () => removeWorktree(repo, o.dir, force));
             removed++;
         }
-        const slot = slotOfFeature(cfg, feature);
         if (wholeFeature && (scanOccupancy(cfg).get(slot) ?? []).length === 0) {
             removeLabel(cfg, slot);
             if (removed === 0)

package/dist/engine.js

@@ -8,7 +8,7 @@ import { runShellLive, run, spliceArgv, isTTY } from './util/exec.js';
 import { warn, log } from './util/log.js';
 import { withProgress } from './util/progress.js';
 import { color as cc } from './util/color.js';
-import { startDetached, recordedFor, pidAlive, setPid, pidOnPort, readLogTail, stopManaged } from './proc.js';
+import { startDetached, recordedFor, pidAlive, setPid, pidOnPort, readLogTail, stopManaged, stopUnrecordedOnPort } from './proc.js';
 import { t } from './i18n.js';
 export function mergeEnvText(text, kv) {
     const lines = text.split('\n');
@@ -82,7 +82,7 @@ export async function ensureStarted(ctx) {
         log(cc.dim(t(`  • ${service} dev server 已在跑（pid ${rec.pid}，端口 ${port}）`, `  • ${service} dev server already running (pid ${rec.pid}, port ${port})`)));
         return;
     }
-    if (await portInUse(port)) {
+    if (pidOnPort(port)) {
         log(cc.dim(t(`  • 端口 ${port} 已在监听，视为 ${service} dev server 在跑，跳过启动`, `  • port ${port} already listening; treating ${service} dev server as up, skip`)));
         return;
     }
@@ -115,38 +115,53 @@ async function waitForListen(port, ms) {
     }
 }
 // 「运行体」= docker 容器(infra) + node dev server。up 重入 / start / restart 共用，统一边界。
-// 恢复运行体：有 stop 钩子的 infra 服务重跑 setup（docker compose up -d 幂等恢复）+ 起 managed dev server。
+// 恢复运行体：有 stop 钩子的 infra 服务在端口没监听时才重跑 setup（docker compose up -d）+ 起 managed dev server。
+// 「是否在跑」一律按端口实判，与 ls 同源（pidOnPort/netstat，而非 connect 探测——docker 发布端口两者会不一致，
+// 导致 ls 显示在跑、start 却误判没跑去「恢复」）。端口已在监听就视为在跑、跳过，不再无脑重跑 setup。
 export async function ensureRuntime(ctx) {
     const { sp, dir, service, vars } = ctx;
     if (sp.stop && sp.setup) {
-        const cmd = renderTemplate(sp.setup, vars);
-        await runShellLive(cmd, { cwd: dir }, t(`恢复 ${service}：${cmd}`, `resume ${service}: ${cmd}`));
+        const port = Number(vars.port);
+        if (pidOnPort(port))
+            log(cc.dim(t(`  • ${service} 已在跑（端口 ${port} 在监听），跳过恢复`, `  • ${service} already up (port ${port} listening), skip resume`)));
+        else {
+            const cmd = renderTemplate(sp.setup, vars);
+            await runShellLive(cmd, { cwd: dir }, t(`恢复 ${service}：${cmd}`, `resume ${service}: ${cmd}`));
+        }
     }
     await ensureStarted(ctx);
 }
 // 停止运行体：杀 managed dev server + 跑 stop 钩子（docker compose stop）。不动 worktree。
-// 始终给每个服务输出一行状态——哪怕本就没在跑（否则只剩一个裸服务名，看不出结果）。
-// 用端口实判：docker 容器停了端口即释放、dev server 同理，比「有没有 managed 记录」更准，
-// 据此给出诚实状态（本就空闲 / 外部未托管 / 未在运行），不让一个绿勾掩盖「其实没东西在跑」。
+// 始终给每个服务输出一行状态。「是否在跑」用 pidOnPort（与 ls 同源），不用 connect 探测。
+// 严格判定：只停「本目录 + 本端口 + 本进程」——dev server 凭账本（dir 已规范化匹配）认本进程，
+// 不去按端口盲杀（端口可能被无关进程占）；没有账本记录就如实报告、不动它。
 export async function stopRuntime(ctx) {
     const { cfg, sp, dir, service, vars } = ctx;
     const port = Number(vars.port);
-    const wasUp = await portInUse(port);
+    const onPort = pidOnPort(port); // 停之前先记下端口真相（stopManaged 可能把它杀掉）
     const stopped = stopManaged(cfg.workspaceRoot, dir);
     if (stopped)
-        log(`  ${cc.green('✓')} ` + t(`已停止 dev server（pid ${stopped.pid}）`, `stopped dev server (pid ${stopped.pid})`));
+        log(`  ${cc.green('✓')} ` + t(`已停止 dev server（pid ${stopped.pid}，端口 ${stopped.port}）`, `stopped dev server (pid ${stopped.pid}, port ${stopped.port})`));
     if (sp.stop) {
         // stop 钩子始终跑（docker compose stop 幂等，且能收掉 app 端口没监听、但 mysql/redis 等边车还在的情况）。
         const cmd = renderTemplate(sp.stop, vars);
         await runShellLive(cmd, { cwd: dir }, t(`停 ${service}：${cmd}`, `stop ${service}: ${cmd}`));
-        if (!wasUp)
+        if (!onPort)
             log(`  ${cc.dim('•')} ` + t(`（端口 ${port} 此前空闲，${service} 实际并未在对外服务）`, `(port ${port} was idle; ${service} wasn't actually serving)`));
     }
     if (!stopped && !sp.stop) {
-        if (wasUp)
-            log(`  ${cc.yellow('•')} ` + t(`端口 ${port} 仍被占用（外部启动、未托管），请手动停止`, `port ${port} in use (external, unmanaged); stop manually`));
-        else
+        if (!onPort) {
             log(`  ${cc.dim('•')} ` + t('未在运行', 'not running'));
+            return;
+        }
+        // 无账本记录：校验后才杀（cwd==本目录 或 命令行含本端口），确证不了就不动
+        const r = stopUnrecordedOnPort(cfg.workspaceRoot, dir, port);
+        if (r.confirmed)
+            log(`  ${cc.green('✓')} ` + t(`已停止（端口 ${port} 上 pid ${r.pid}，经${r.how === 'cwd' ? '工作目录' : '命令行'}确认属本 worktree）`, `stopped (pid ${r.pid} on port ${port}, confirmed as this worktree by ${r.how})`));
+        else if (r.reason === 'cwd-mismatch')
+            log(`  ${cc.yellow('•')} ` + t(`端口 ${port} 被 pid ${r.pid} 占用，但其工作目录非本 worktree（${r.cwd}），未停`, `port ${port} held by pid ${r.pid}, but its cwd isn't this worktree (${r.cwd}); left running`));
+        else
+            log(`  ${cc.yellow('•')} ` + t(`端口 ${port} 被 pid ${r.pid} 占用，无账本记录且无法确认是本服务本进程，未自动停止`, `port ${port} held by pid ${r.pid}, no record and can't confirm it's this service; left running`));
     }
 }
 export function execArgv(ctx, cmd) {

package/dist/proc.js

@@ -17,8 +17,12 @@ export function pidAlive(pid) { if (!pid || pid < 1)
 catch {
     return false;
 } }
-export function recordedFor(ws, dir) { return readProcs(ws).find((r) => r.dir === dir); }
-export function setPid(ws, dir, pid) { const recs = readProcs(ws); const r = recs.find((x) => x.dir === dir); if (r) {
+// 账本 dir 可能存成相对/绝对、斜杠或大小写不一（写入与查时来源不同）。统一相对 ws 解析成绝对、
+// Windows 下再大小写折叠后比较，保证「同一个 worktree 目录」一定能匹配上（严格判定的「本目录」凭据）。
+function normDir(ws, p) { const r = path.resolve(ws, p); return process.platform === 'win32' ? r.toLowerCase() : r; }
+function sameDir(ws, a, b) { return normDir(ws, a) === normDir(ws, b); }
+export function recordedFor(ws, dir) { return readProcs(ws).find((r) => sameDir(ws, r.dir, dir)); }
+export function setPid(ws, dir, pid) { const recs = readProcs(ws); const r = recs.find((x) => sameDir(ws, x.dir, dir)); if (r) {
     r.pid = pid;
     writeProcs(ws, recs);
 } }
@@ -55,6 +59,70 @@ export function pidOnPort(port) {
     }
     return undefined;
 }
+// 取进程工作目录(cwd)。Linux/macOS 原生可取（最强的「本目录」证据）；
+// Windows 普通命令拿不到他进程 cwd（存在 PEB、需 ReadProcessMemory），返回 undefined，由调用方降级到命令行核对。
+export function processCwd(pid) {
+    if (!pid || pid < 1)
+        return undefined;
+    try {
+        if (process.platform === 'linux')
+            return fs.readlinkSync(`/proc/${pid}/cwd`);
+        if (process.platform === 'darwin') {
+            const r = spawnSync('lsof', ['-a', '-d', 'cwd', '-p', String(pid), '-Fn'], { encoding: 'utf8' });
+            if (r.status === 0) {
+                const m = /^n(.+)$/m.exec(r.stdout || '');
+                if (m)
+                    return m[1].trim();
+            }
+        }
+    }
+    catch { /* 取不到就降级 */ }
+    return undefined;
+}
+// 取进程命令行（cwd 取不到时的跨平台兜底，尤其 Windows）。
+export function processCmdline(pid) {
+    if (!pid || pid < 1)
+        return undefined;
+    try {
+        if (process.platform === 'win32') {
+            const r = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`], { encoding: 'utf8' });
+            if (r.status === 0)
+                return (r.stdout || '').trim() || undefined;
+        }
+        else {
+            const r = spawnSync('ps', ['-o', 'args=', '-p', String(pid)], { encoding: 'utf8' });
+            if (r.status === 0)
+                return (r.stdout || '').trim() || undefined;
+        }
+    }
+    catch { /* 取不到就放弃确证 */ }
+    return undefined;
+}
+// 无账本记录时的严格兜底：端口上的进程，仅当能确证属于本 worktree 才杀（先校验后杀，绝不凭端口盲杀）。
+// 证据：① cwd == 本 worktree 目录（Linux/macOS，最强，证明「本目录」）；
+//      ② cwd 取不到（Windows）→ 命令行含 `--port <本端口>`（本端口按槽唯一分配，等价确证本服务本进程）。
+// 杀用 killTree（含进程树）；都无法确证则不动、返回 confirmed:false 供上层如实报告。
+export function stopUnrecordedOnPort(ws, dir, port) {
+    const pid = pidOnPort(port);
+    if (!pid)
+        return { confirmed: false, reason: 'idle' };
+    const cwd = processCwd(pid);
+    if (cwd !== undefined) {
+        if (sameDir(ws, cwd, dir)) {
+            if (pidAlive(pid))
+                killTree(pid);
+            return { pid, confirmed: true, how: 'cwd', cwd };
+        }
+        return { pid, confirmed: false, cwd, reason: 'cwd-mismatch' };
+    }
+    const cmd = processCmdline(pid);
+    if (cmd && (cmd.includes(`--port ${port}`) || cmd.includes(`--port=${port}`))) {
+        if (pidAlive(pid))
+            killTree(pid);
+        return { pid, confirmed: true, how: 'cmdline', cmd };
+    }
+    return { pid, confirmed: false, cmd, reason: 'unverified' };
+}
 export function startDetached(ws, dir, service, slug, port, cmd) {
     const logDir = path.join(ws, '.worktree-bay', 'logs');
     fs.mkdirSync(logDir, { recursive: true });
@@ -69,8 +137,9 @@ export function startDetached(ws, dir, service, slug, port, cmd) {
     const child = spawn(cmd, { cwd: dir, shell: true, detached, stdio: ['ignore', fd, fd], windowsHide: true });
     const pid = child.pid ?? -1;
     child.unref();
-    const rec = { dir, service, port, pid, cmd, log, startedAt: Date.now() };
-    writeProcs(ws, [...readProcs(ws).filter((r) => r.dir !== dir), rec]);
+    // 一律存绝对 dir，避免相对/绝对混存导致后续按目录匹配漂移
+    const rec = { dir: path.resolve(ws, dir), service, port, pid, cmd, log, startedAt: Date.now() };
+    writeProcs(ws, [...readProcs(ws).filter((r) => !sameDir(ws, r.dir, dir)), rec]);
     return rec;
 }
 function killTree(pid) {
@@ -92,7 +161,7 @@ function killTree(pid) {
 // 同时按「记录 pid」和「当前端口占用 pid」双杀——shell/pnpm 中间层会让记录 pid 漂移，按端口兜底最稳。
 export function stopManaged(ws, dir) {
     const recs = readProcs(ws);
-    const rec = recs.find((r) => r.dir === dir);
+    const rec = recs.find((r) => sameDir(ws, r.dir, dir));
     if (!rec)
         return undefined;
     const targets = new Set();
@@ -104,6 +173,6 @@ export function stopManaged(ws, dir) {
     for (const pid of targets)
         if (pidAlive(pid))
             killTree(pid);
-    writeProcs(ws, recs.filter((r) => r.dir !== dir));
+    writeProcs(ws, recs.filter((r) => !sameDir(ws, r.dir, dir)));
     return rec;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktree-bay",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "Per-feature git worktree + port slots for parallel multi-service development: auto deps, env wiring, frontend-to-backend, merge-aware reclaim, plus an MCP server for AI agents.",
   "keywords": [
     "git",

package/skill.md

@@ -161,9 +161,11 @@ worktree-bay gc                        # 回收已合并的
 
 ## 工作原理要点
 
+- **全命令幂等**：`up / down / start / stop / restart` 重复执行都收敛到同一目标态、不报错——`up` 重入＝复用 worktree + 恢复运行体；`start`/`stop` 已在目标态则跳过/仍逐服务给状态；`down` 对未占槽或已拆的服务是友好 no-op。仅「未知服务名」（typo，不在 config）才报错。
 - **占用真相 = 文件系统**：扫各服务 `.worktrees/s<N>-*`；`.worktree-bay-slots.json` 只是「功能名→槽号」标签账本（预约）。
 - **dev server 托管**：`start` 进程后台 detach 启动、日志落 `.worktree-bay/logs/`、按端口追踪真实 pid；`ls` 行首 `●` 标在跑（绿）/未跑（灰）；`stop`/`down` 按端口可靠停。
-- **运行状态判断 = 端口**：`ls` 的 `running`、`stop` 的「是否真在跑」一律按约定端口是否被监听判（覆盖 docker / 托管 dev server / 外部手起三类），不依赖 pid 账本（dir 形态会漂移、docker 无账本记录）。`stop` 对每个服务都给状态：已停 / 端口空闲（docker 钩子仍幂等跑一遍）/ 外部未托管需手动停。
+- **运行状态判断 = 端口**：`ls`/`start`/`stop` 判「在不在跑」全用 `pidOnPort`（netstat/lsof，与 ls 同源），不用 connect 探测（docker 发布端口两者会不一致）、也不只看 pid 账本（dir 形态会漂移、docker 无账本记录）。`start` 端口已在监听就跳过、不再误报「恢复」。
+- **stop 严格停「本目录+本端口+本进程」**：① 优先用启动账本（dir 已规范化匹配：相对/绝对/大小写都认）；② 账本缺失时**校验后才杀**——Linux/macOS 比对进程 `cwd` 是否为本 worktree，Windows 取不到 cwd 则核对命令行含 `--port <本端口>`（端口按槽唯一，等价确证）；都确证不了就**不动它**并如实报告（绝不凭端口盲杀）。每个服务都有状态行：已停 / 端口空闲 / 无法确认未停。
 - **并发安全**：`claim/add/up/rm/down/gc` 全程持工作区原子锁。
 - **前端自接后端**：前端有 `upstream` 且同槽该上游服务的 worktree 已建，则 `{upstreamBase}` = 本槽上游端口；否则用 `fallback`。所以**联调时先 `up`/`add` 后端，再起前端**。
 - **合并感知回收**：`gc` 先 `git fetch`，用 `merge-base --is-ancestor` 判断是否并入主分支；**只在「已合并 + 工作区干净 + 无未推」时才自动删**，判不准一律保守不删、只标记。