worktree-bay 2.3.8 → 2.4.0

package/dist/cli.js

@@ -7,6 +7,7 @@ import { lsCommand } from './commands/ls.js';
 import { addCommand, upCommand } from './commands/add.js';
 import { runCommand, shCommand, pathCommand } from './commands/passthrough.js';
 import { rmCommand } from './commands/rm.js';
+import { startCommand, stopCommand, restartCommand } from './commands/lifecycle.js';
 import { gcCommand } from './commands/gc.js';
 import { doctorCommand } from './commands/doctor.js';
 import { complete, completionCommand, installCompletion } from './commands/completion.js';
@@ -82,6 +83,27 @@ program.command('run <feature> <service> <name> [args...]').description(t('在
     .action((f, s, n, args) => sync((c) => runCommand(c, f, s, n, args ?? [])));
 program.command('sh <feature> <service>').description(t('进入服务运行体的 shell', 'open a shell inside the service runtime'))
     .action((f, s) => sync((c) => shCommand(c, f, s)));
+program.command('start <feature> [service]').description(t('启动该功能的 dev server（worktree 已在，只起 start 进程，不动 worktree）', 'start the feature\'s dev server(s) (worktree already exists; runs the start process only)'))
+    .action(async (f, s) => { try {
+    await startCommand(loadConfig(process.cwd()), f, s);
+}
+catch (e) {
+    die(e.message);
+} });
+program.command('stop <feature> [service]').description(t('停止该功能的 dev server（保留 worktree）', 'stop the feature\'s dev server(s) (keeps the worktree)'))
+    .action(async (f, s) => { try {
+    await stopCommand(loadConfig(process.cwd()), f, s);
+}
+catch (e) {
+    die(e.message);
+} });
+program.command('restart <feature> [service]').description(t('重启该功能的 dev server（停掉再起）', 'restart the feature\'s dev server(s) (stop then start)'))
+    .action(async (f, s) => { try {
+    await restartCommand(loadConfig(process.cwd()), f, s);
+}
+catch (e) {
+    die(e.message);
+} });
 program.command('down <feature>').description(t('拆除整个功能的所有服务 worktree（= rm <feature>）', 'tear down all of a feature\'s service worktrees (= rm <feature>)')).option('-f, --force', t('跳过脏/未推检查强制删除', 'skip dirty/unpushed checks and force-remove'))
     .action(async (f, o) => { try {
     await rmCommand(loadConfig(process.cwd()), f, undefined, !!o.force);

package/dist/commands/completion.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { readLabels } from '../slots.js';
 import { log } from '../util/log.js';
 import { t } from '../i18n.js';
-const SUBCMDS = ['init', 'doctor', 'claim', 'up', 'add', 'ls', 'path', 'gc', 'down', 'rm', 'run', 'sh', 'completion', 'mcp', 'skill', 'version', 'help'];
+const SUBCMDS = ['init', 'doctor', 'claim', 'up', 'add', 'ls', 'path', 'gc', 'down', 'rm', 'run', 'sh', 'start', 'stop', 'restart', 'completion', 'mcp', 'skill', 'version', 'help'];
 // words = 命令名 + 光标前已输入完的词（不含当前正在补的词）
 export function complete(cfg, words) {
     const prev = words.slice(1);
@@ -14,10 +14,10 @@ export function complete(cfg, words) {
         return []; // 无配置（不在工作区内）：子命令已补全，feature/service 无从读取
     const sub = prev[0];
     const pos = prev.length;
-    const featureSubs = ['up', 'add', 'rm', 'down', 'run', 'sh', 'path'];
+    const featureSubs = ['up', 'add', 'rm', 'down', 'run', 'sh', 'path', 'start', 'stop', 'restart'];
     if (featureSubs.includes(sub) && pos === 1)
         return Object.values(readLabels(cfg));
-    if (['add', 'run', 'sh', 'path'].includes(sub) && pos === 2)
+    if (['add', 'run', 'sh', 'path', 'start', 'stop', 'restart'].includes(sub) && pos === 2)
         return Object.keys(cfg.services);
     if (sub === 'run' && pos === 3)
         return Object.keys(cfg.services[prev[2]]?.run ?? {}); // run <feature> <service> <name>：补该服务的 run 命令名

package/dist/commands/lifecycle.js

@@ -0,0 +1,65 @@
+import { repoPath } from '../config.js';
+import { withLock } from '../lock.js';
+import { scanOccupancy, slotOfFeature } from '../slots.js';
+import { buildVars, ensureStarted } from '../engine.js';
+import { stopManaged } from '../proc.js';
+import { portInUse } from '../ports.js';
+import { log, warn } from '../util/log.js';
+import { color as c } from '../util/color.js';
+import { t } from '../i18n.js';
+// dev server 生命周期：start/stop/restart（只管 start 配置起的进程，不动 worktree）
+function occupantsOf(cfg, feature, service) {
+    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.`));
+    const all = scanOccupancy(cfg).get(slot) ?? [];
+    return service ? all.filter((o) => o.service === service) : all;
+}
+function ctxOf(cfg, o) {
+    const sp = cfg.services[o.service];
+    const base = { cfg, service: o.service, sp, slot: o.slot, slug: o.slug, dir: o.dir, repo: repoPath(cfg, o.service) };
+    return { ...base, vars: buildVars(cfg, base) };
+}
+export async function startCommand(cfg, feature, service) {
+    await withLock(cfg.workspaceRoot, async () => {
+        let any = false;
+        for (const o of occupantsOf(cfg, feature, service)) {
+            if (!cfg.services[o.service].start)
+                continue;
+            any = true;
+            log(c.bold(c.cyan(o.service)));
+            await ensureStarted(ctxOf(cfg, o));
+        }
+        if (!any)
+            warn(t('没有可启动的 dev server（相关服务未配置 start）', 'nothing to start (those services have no start configured)'));
+    });
+}
+export async function stopCommand(cfg, feature, service) {
+    await withLock(cfg.workspaceRoot, async () => {
+        let any = false;
+        for (const o of occupantsOf(cfg, feature, service)) {
+            const stopped = stopManaged(cfg.workspaceRoot, o.dir);
+            if (stopped) {
+                any = true;
+                log(`${c.green('✓')} ` + t(`已停止 ${o.service} dev server（pid ${stopped.pid}）`, `stopped ${o.service} dev server (pid ${stopped.pid})`));
+            }
+        }
+        if (!any)
+            log(t('没有在跑的 dev server', 'no running dev server'));
+    });
+}
+export async function restartCommand(cfg, feature, service) {
+    await withLock(cfg.workspaceRoot, async () => {
+        for (const o of occupantsOf(cfg, feature, service)) {
+            const sp = cfg.services[o.service];
+            if (!sp.start)
+                continue;
+            log(c.bold(c.cyan(o.service)) + c.dim(t('  ·  重启…', '  ·  restarting…')));
+            stopManaged(cfg.workspaceRoot, o.dir);
+            const port = Number(ctxOf(cfg, o).vars.port);
+            for (let i = 0; i < 40 && (await portInUse(port)); i++)
+                await new Promise((r) => setTimeout(r, 100)); // 等端口释放（最多 ~4s）
+            await ensureStarted(ctxOf(cfg, o));
+        }
+    });
+}

package/dist/lock.js

@@ -1,25 +1,85 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { t } from './i18n.js';
+import { warn } from './util/log.js';
+// 工作区原子锁（mkdir）。锁目录内写 owner=pid：
+// - 锁主进程已死 / 无主（陈旧锁，多为上次进程被杀残留）→ 秒级清除重试，不再空等 30s；
+// - 锁被另一个在跑的 worktree-bay 持有 → 立刻提示在等谁，再按需等待，超时给明确指引。
+function pidAlive(pid) { if (!pid)
+    return false; try {
+    process.kill(pid, 0);
+    return true;
+}
+catch {
+    return false;
+} }
+function ownerPid(lockDir) {
+    try {
+        const n = Number(fs.readFileSync(path.join(lockDir, 'owner'), 'utf8').trim());
+        return n || null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function withLock(ws, fn) {
-    const lockDir = path.join(ws, '.worktree-bay', 'lock');
-    fs.mkdirSync(path.join(ws, '.worktree-bay'), { recursive: true });
+    const baseDir = path.join(ws, '.worktree-bay');
+    const lockDir = path.join(baseDir, 'lock');
+    fs.mkdirSync(baseDir, { recursive: true });
     const start = Date.now();
+    let notified = false;
+    let ownerMissingSince = 0;
     for (;;) {
         try {
             fs.mkdirSync(lockDir);
             break;
-        }
+        } // 抢到锁
         catch {
-            if (Date.now() - start > 30000)
-                throw new Error(t('获取工作区锁超时（是否有另一个 worktree-bay 在运行？）。若确认没有，删掉 .worktree-bay/lock 目录再试。', 'timed out acquiring the workspace lock (is another worktree-bay running?). If not, delete the .worktree-bay/lock directory and retry.'));
+            const pid = ownerPid(lockDir);
+            if (pid === null) {
+                // 无 owner 文件：可能是陈旧锁（旧版/被杀残留），也可能是别人刚抢到还没写 owner（竞态）。
+                // 给 ~600ms 宽限，仍无主就当陈旧锁清掉。
+                if (ownerMissingSince === 0)
+                    ownerMissingSince = Date.now();
+                if (Date.now() - ownerMissingSince > 600) {
+                    try {
+                        fs.rmSync(lockDir, { recursive: true, force: true });
+                    }
+                    catch { /* 让下轮重试 */ }
+                    ownerMissingSince = 0;
+                    continue;
+                }
+            }
+            else {
+                ownerMissingSince = 0;
+                if (!pidAlive(pid)) {
+                    try {
+                        fs.rmSync(lockDir, { recursive: true, force: true });
+                    }
+                    catch { /* 重试 */ }
+                    continue;
+                } // 锁主已死 → 陈旧锁，清掉
+                if (!notified) {
+                    warn(t(`正在等待另一个 worktree-bay（pid ${pid}）释放工作区锁…`, `waiting for another worktree-bay (pid ${pid}) to release the workspace lock…`));
+                    notified = true;
+                }
+                if (Date.now() - start > 30000)
+                    throw new Error(t(`等待工作区锁超时：另一个 worktree-bay（pid ${pid}）仍持有。若它已卡死，结束该进程或删掉 ${lockDir} 再试。`, `timed out waiting for the workspace lock: another worktree-bay (pid ${pid}) still holds it. If stuck, kill it or delete ${lockDir}, then retry.`));
+            }
             await new Promise((r) => setTimeout(r, 50));
         }
     }
+    try {
+        fs.writeFileSync(path.join(lockDir, 'owner'), String(process.pid));
+    }
+    catch { /* 忽略：owner 仅用于陈旧检测 */ }
     try {
         return await fn();
     }
     finally {
-        fs.rmdirSync(lockDir);
+        try {
+            fs.rmSync(lockDir, { recursive: true, force: true });
+        }
+        catch { /* 已被清理 */ }
     }
 }

package/dist/mcp.js

@@ -58,7 +58,8 @@ export const TOOLS = [
         inputSchema: { type: 'object', properties: {} }, toArgs: () => ['skill'] },
 ];
 function runCli(args) {
-    const r = spawnSync(process.execPath, [CLI, ...args], { encoding: 'utf8' });
+    // 强制非交互：给 AI 的输出不带颜色/spinner 控制符，保留完整日志
+    const r = spawnSync(process.execPath, [CLI, ...args], { encoding: 'utf8', env: { ...process.env, WORKTREE_BAY_NONINTERACTIVE: '1' } });
     return [r.stdout, r.stderr].filter(Boolean).join('\n').trim() || '(无输出)';
 }
 export function handle(msg) {

package/dist/util/color.js

@@ -1,5 +1,14 @@
-// 轻量 ANSI 着色：仅在 TTY 且未设 NO_COLOR 时上色，否则原样返回（管道/CI/重定向不带控制符）。
-const enabled = (!!process.stdout.isTTY || !!process.stderr.isTTY) && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
+// 终端是否「类 TTY」（可上色/动画）。Git Bash/mintty 下 Node 的 isTTY 会误报 false，
+// 但其实是交互终端、支持 ANSI（MSYSTEM/TERM_PROGRAM 可识别）。MCP/脚本可设 WORKTREE_BAY_NONINTERACTIVE 强制纯文本。
+export function ttyLike(stream) {
+    if (process.env.WORKTREE_BAY_NONINTERACTIVE)
+        return false;
+    if (stream?.isTTY)
+        return true;
+    return !!(process.env.MSYSTEM || process.env.TERM_PROGRAM === 'mintty');
+}
+// 轻量 ANSI 着色：仅在类 TTY 且未设 NO_COLOR 时上色，否则原样返回（管道/CI/重定向/MCP 不带控制符）。
+const enabled = (ttyLike(process.stdout) || ttyLike(process.stderr)) && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
 const paint = (code) => (s) => (enabled ? `\x1b[${code}m${s}\x1b[0m` : s);
 export const color = {
     enabled,

package/dist/util/exec.js

@@ -1,6 +1,6 @@
 import { spawnSync, spawn } from 'node:child_process';
 import { t } from '../i18n.js';
-import { color as c } from './color.js';
+import { color as c, ttyLike } from './color.js';
 export function run(cmd, args, opts = {}) { const r = spawnSync(cmd, args, { cwd: opts.cwd, stdio: 'inherit', shell: false }); return { code: r.status ?? 1 }; }
 export function runShell(line, opts = {}) { const r = spawnSync(line, { cwd: opts.cwd, stdio: 'inherit', shell: true }); return { code: r.status ?? 1 }; }
 export function spliceArgv(template, cmd) { const out = []; for (const el of template) {
@@ -14,7 +14,7 @@ const SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '
 // 折叠式执行 setup/teardown 这类外部命令：TTY 下把输出收进单行临时进度（spinner + 秒数 + 最后一行），
 // 成功收成「✓ label（Ns）」，失败才吐完整日志便于排查；非 TTY（CI/管道/MCP）原样透传保留完整日志。
 export function runShellLive(line, opts, label) {
-    if (!process.stderr.isTTY) {
+    if (!ttyLike(process.stderr)) {
         const r = spawnSync(line, { cwd: opts.cwd, stdio: 'inherit', shell: true });
         return Promise.resolve({ code: r.status ?? 1 });
     }

package/dist/util/progress.js

@@ -1,12 +1,12 @@
 import { log } from './log.js';
-import { color as c } from './color.js';
+import { color as c, ttyLike } from './color.js';
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 // 给长耗时异步步骤一个「在干活」的反馈：TTY 下转圈 + 秒数（写 stderr，用 \r 原地刷新），
 // 非 TTY（管道 / CI / MCP）下退化为「开始…」「✓ 完成（Ns）」两行，避免刷屏。
 export async function withProgress(label, fn) {
     const t0 = Date.now();
     const secs = () => ((Date.now() - t0) / 1000).toFixed(1);
-    if (!process.stderr.isTTY) {
+    if (!ttyLike(process.stderr)) {
         log(`  → ${label} …`);
         const r = await fn();
         log(`  ${c.green('✓')} ${label}${c.dim(`（${secs()}s）`)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktree-bay",
-  "version": "2.3.8",
+  "version": "2.4.0",
   "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

@@ -35,6 +35,9 @@ worktree-bay completion install   # 一键装 shell 补全（可选）
 | `worktree-bay path <feature> <service>` | 打印某服务 worktree 的绝对路径（可 `cd $(worktree-bay path f api)`） |
 | `worktree-bay run <feature> <service> <name> [args...]` | 在某服务运行体里跑配置的 `run.<name>`（如 test），透传 args |
 | `worktree-bay sh <feature> <service>` | 进入某服务运行体的 shell |
+| `worktree-bay start <feature> [service]` | 启动该功能的 dev server（worktree 已在，只起 `start` 进程，不动 worktree） |
+| `worktree-bay stop <feature> [service]` | 停止该功能的 dev server（保留 worktree） |
+| `worktree-bay restart <feature> [service]` | 重启 dev server（停掉再起；改了配置/端口卡住时用） |
 | `worktree-bay down <feature> [-f]` | 拆除整个功能的所有服务 worktree（= `rm <feature>`） |
 | `worktree-bay rm <feature> [service] [-f]` | 拆除某服务或整槽。默认查脏/未推保护，`-f` 强删 |
 | `worktree-bay gc [--apply]` | 合并感知回收：默认 dry-run 只列建议，`--apply` 才删「已合并且干净」的 |