sanjang 0.3.5 → 0.3.7

package/dist/bin/sanjang.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+// Node 22+ required for --experimental-transform-types
+const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeVersion < 22) {
+    console.error(`⛰ 산장: Node 22 이상이 필요합니다. (현재: v${process.versions.node})`);
+    console.error("  해결: nvm install 22 && nvm use 22");
+    console.error("  또는: https://nodejs.org 에서 최신 LTS를 설치하세요.");
+    process.exit(1);
+}
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
@@ -116,21 +124,156 @@ if (command === "init") {
 }
 else if (command === "help" || command === "--help" || command === "-h") {
     console.log(`
-⛰ 산장 (Sanjang) — 바이브코더를 위한 로컬 개발 환경 매니저
+⛰ 산장 (Sanjang) — 비개발자가 AI로 코드를 고치고 PR을 보낼 수 있는 로컬 개발 환경
 
 사용법:
   sanjang              서버 시작 (대시보드: http://localhost:4000)
   sanjang init         프로젝트 분석 → sanjang.config.js 생성
+  sanjang list         캠프 목록 보기
+  sanjang status       서버 + 캠프 상태 확인
+  sanjang start <name> 캠프 시작
+  sanjang stop <name>  캠프 중지
+  sanjang open <name>  캠프를 브라우저에서 열기
   sanjang help         이 도움말
 
 옵션:
   --port <N>           대시보드 포트 (기본: 4000)
   --project <path>     프로젝트 경로 (기본: 현재 디렉토리)
+  --json               JSON으로 출력 (Claude Code 등 자동화용)
   --force              기존 설정을 덮어쓰고 다시 생성
 
 자세히: https://github.com/paul-sherpas/sanjang
 `);
 }
+else if (command === "list" || command === "status" || command === "start" || command === "stop" || command === "open") {
+    // CLI commands that talk to the running sanjang server
+    const jsonMode = args.includes("--json");
+    const campName = args[1] && !args[1].startsWith("-") ? args[1] : undefined;
+    const baseUrl = `http://127.0.0.1:${port}`;
+    async function apiFetch(path, method = "GET", body) {
+        const opts = { method, headers: { "content-type": "application/json" } };
+        if (body)
+            opts.body = JSON.stringify(body);
+        const res = await fetch(`${baseUrl}${path}`, opts);
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(err.error || `HTTP ${res.status}`);
+        }
+        return res.json();
+    }
+    async function tryApi(fn) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (err.cause && String(err.cause).includes("ECONNREFUSED")) {
+                console.error("⛰ 산장 서버가 실행되지 않고 있습니다.");
+                console.error(`  sanjang 또는 npx sanjang 으로 먼저 시작하세요.`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    }
+    try {
+        if (command === "list") {
+            const camps = await tryApi(() => apiFetch("/api/playgrounds"));
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify(camps, null, 2) + "\n");
+            }
+            else if (camps.length === 0) {
+                console.log("⛰ 캠프가 없습니다. 대시보드에서 만들어보세요.");
+            }
+            else {
+                console.log("⛰ 캠프 목록:\n");
+                for (const c of camps) {
+                    const status = c.status === "running" ? "🟢" : c.status === "error" ? "🔴" : "⚪";
+                    const url = c.status === "running" && c.fePort ? `http://localhost:${c.fePort}` : "";
+                    console.log(`  ${status} ${c.name}\t${c.branch}\t${url}`);
+                }
+            }
+        }
+        else if (command === "status") {
+            const camps = await tryApi(() => apiFetch("/api/playgrounds"));
+            const running = camps.filter(c => c.status === "running").length;
+            const total = camps.length;
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify({ server: { url: baseUrl, status: "running" }, camps }, null, 2) + "\n");
+            }
+            else {
+                console.log(`⛰ 산장 서버: ${baseUrl}`);
+                console.log(`  캠프: ${total}개 (실행 중 ${running}개)`);
+                for (const c of camps) {
+                    const status = c.status === "running" ? "🟢" : c.status === "error" ? "🔴" : "⚪";
+                    console.log(`  ${status} ${c.name} (${c.status})`);
+                }
+            }
+        }
+        else if (command === "start") {
+            if (!campName) {
+                console.error("⛰ 사용법: sanjang start <캠프이름>");
+                process.exit(1);
+            }
+            const result = await tryApi(() => apiFetch(`/api/playgrounds/${campName}/start`, "POST"));
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+            }
+            else {
+                console.log(`⛰ ${campName} 캠프를 시작합니다.`);
+            }
+        }
+        else if (command === "stop") {
+            if (!campName) {
+                console.error("⛰ 사용법: sanjang stop <캠프이름>");
+                process.exit(1);
+            }
+            const result = await tryApi(() => apiFetch(`/api/playgrounds/${campName}/stop`, "POST"));
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+            }
+            else {
+                console.log(`⛰ ${campName} 캠프를 중지합니다.`);
+            }
+        }
+        else if (command === "open") {
+            if (!campName) {
+                console.error("⛰ 사용법: sanjang open <캠프이름>");
+                process.exit(1);
+            }
+            const camps = await tryApi(() => apiFetch("/api/playgrounds"));
+            const camp = camps.find(c => c.name === campName);
+            if (!camp) {
+                console.error(`⛰ "${campName}" 캠프를 찾을 수 없습니다.`);
+                process.exit(1);
+            }
+            if (camp.status !== "running" || !camp.fePort) {
+                console.error(`⛰ "${campName}" 캠프가 실행 중이 아닙니다. sanjang start ${campName} 을 먼저 실행하세요.`);
+                process.exit(1);
+            }
+            const campUrl = `http://localhost:${camp.fePort}`;
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify({ name: campName, url: campUrl, status: camp.status }, null, 2) + "\n");
+            }
+            else {
+                console.log(`⛰ ${campName} 캠프를 브라우저에서 엽니다. → ${campUrl}`);
+            }
+            const { spawn: spawnOpen } = await import("node:child_process");
+            const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+            try {
+                spawnOpen(openCmd, [campUrl], { stdio: "ignore", detached: true }).unref();
+            }
+            catch { /* */ }
+        }
+    }
+    catch (err) {
+        if (jsonMode) {
+            process.stdout.write(JSON.stringify({ error: err.message }, null, 2) + "\n");
+        }
+        else {
+            console.error(`⛰ 오류: ${err.message}`);
+        }
+        process.exit(1);
+    }
+}
 else {
     // Default: start server — auto-init if no config exists
     const configPath = resolve(projectRoot, "sanjang.config.js");

package/dist/lib/config.d.ts

@@ -4,6 +4,11 @@ import type { DetectedApp, DetectedProject, GenerateConfigResult, SanjangConfig
  * Returns merged config with defaults.
  */
 export declare function loadConfig(projectRoot: string): Promise<SanjangConfig>;
+/**
+ * Auto-detect a test command from package.json.
+ * Returns null if no test script found or it's the npm default placeholder.
+ */
+export declare function detectTestCommand(projectRoot: string, cwd?: string): string | null;
 /**
  * Auto-detect project type and generate config.
  */

package/dist/lib/config.js

@@ -26,6 +26,7 @@ const DEFAULTS = {
         fe: { base: 3000, slots: 8 },
         be: { base: 8000, slots: 8 },
     },
+    test: null,
 };
 /**
  * Load sanjang.config.js from project root.
@@ -69,8 +70,33 @@ function mergeConfig(user) {
             be: { ...DEFAULTS.ports.be, ...userPorts.be },
         };
     }
+    if (user.test) {
+        config.test = typeof user.test === "string"
+            ? { command: user.test }
+            : user.test;
+    }
     return config;
 }
+/**
+ * Auto-detect a test command from package.json.
+ * Returns null if no test script found or it's the npm default placeholder.
+ */
+export function detectTestCommand(projectRoot, cwd = ".") {
+    const pkgPath = join(projectRoot, cwd, "package.json");
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        const testScript = pkg?.scripts?.test;
+        if (typeof testScript === "string" && !testScript.includes("no test specified")) {
+            return "npm test";
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
 /**
  * Auto-detect project type and generate config.
  */

package/dist/lib/engine/conflict.d.ts

@@ -6,6 +6,19 @@
  * Conflict markers: UU (both modified), AA (both added), DD, AU, UA, DU, UD
  */
 export declare function parseConflictFiles(statusOutput: string | null | undefined): string[];
+/**
+ * A single conflict section within a file.
+ */
+export interface ConflictSection {
+    ours: string;
+    theirs: string;
+    startLine: number;
+}
+/**
+ * Parse conflict markers from file content.
+ * Returns an array of conflict sections found in the file.
+ */
+export declare function parseConflictSections(content: string): ConflictSection[];
 /**
  * Build a Claude prompt to resolve merge conflicts.
  */

package/dist/lib/engine/conflict.js

@@ -14,6 +14,47 @@ export function parseConflictFiles(statusOutput) {
         .filter((line) => /^(UU|AA|DD|AU|UA|DU|UD)\s/.test(line))
         .map((line) => line.slice(3).trim());
 }
+/**
+ * Parse conflict markers from file content.
+ * Returns an array of conflict sections found in the file.
+ */
+export function parseConflictSections(content) {
+    const lines = content.split("\n");
+    const sections = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (lines[i].startsWith("<<<<<<<")) {
+            const startLine = i + 1;
+            const oursLines = [];
+            const theirsLines = [];
+            let inTheirs = false;
+            i++;
+            while (i < lines.length) {
+                const line = lines[i];
+                if (line.startsWith("=======")) {
+                    inTheirs = true;
+                }
+                else if (line.startsWith(">>>>>>>")) {
+                    break;
+                }
+                else if (inTheirs) {
+                    theirsLines.push(line);
+                }
+                else {
+                    oursLines.push(line);
+                }
+                i++;
+            }
+            sections.push({
+                ours: oursLines.join("\n"),
+                theirs: theirsLines.join("\n"),
+                startLine,
+            });
+        }
+        i++;
+    }
+    return sections;
+}
 /**
  * Build a Claude prompt to resolve merge conflicts.
  */

package/dist/lib/engine/main-server.d.ts

@@ -1,6 +1,7 @@
 /**
  * Main branch dev server manager.
- * Runs a dev server from the project root for side-by-side comparison preview.
+ * Creates a git worktree from origin's default branch and runs a dev server
+ * for side-by-side comparison with the camp's changes.
  */
 import type { SanjangConfig } from "../types.ts";
 interface MainServerState {
@@ -10,6 +11,9 @@ interface MainServerState {
 }
 export declare function getMainServerState(): MainServerState;
 export declare function getMainServerLogs(): string[];
-export declare function startMainServer(projectRoot: string, config: SanjangConfig, onReady?: (port: number) => void): Promise<void>;
+export declare function startMainServer(projectRoot: string, config: SanjangConfig, callbacks?: {
+    onReady?: (port: number) => void;
+    onLog?: (msg: string) => void;
+}): Promise<void>;
 export declare function stopMainServer(): void;
 export {};

package/dist/lib/engine/main-server.js

@@ -1,111 +1,181 @@
 /**
  * Main branch dev server manager.
- * Runs a dev server from the project root for side-by-side comparison preview.
+ * Creates a git worktree from origin's default branch and runs a dev server
+ * for side-by-side comparison with the camp's changes.
  */
-import { spawn } from "node:child_process";
-import { createConnection } from "node:net";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { buildDevCommand, detectPortFromLogs, killProcessGroup } from "./process-utils.js";
 let state = { status: "stopped", port: null, error: null };
 let proc = null;
 let logs = [];
+let worktreePath = null;
+let savedProjectRoot = null;
 export function getMainServerState() {
     return { ...state };
 }
 export function getMainServerLogs() {
     return [...logs];
 }
-export async function startMainServer(projectRoot, config, onReady) {
-    if (state.status === "running" || state.status === "starting")
-        return;
-    state = { status: "starting", port: null, error: null };
-    logs = [];
-    const basePort = config.dev.port + 100;
-    const cmdParts = config.dev.command.split(/\s+/);
-    const cmd = cmdParts[0];
-    const args = cmdParts.slice(1);
-    if (config.dev.portFlag) {
-        args.push(config.dev.portFlag, String(basePort));
-    }
-    const cwd = config.dev.cwd
-        ? config.dev.cwd.startsWith("/")
-            ? config.dev.cwd
-            : `${projectRoot}/${config.dev.cwd}`
-        : projectRoot;
-    proc = spawn(cmd, args, {
-        cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, ...config.dev.env, FORCE_COLOR: "0" },
-        shell: true,
-    });
-    proc.stdout?.on("data", (chunk) => {
-        const line = chunk.toString();
-        logs.push(line);
-        if (logs.length > 100)
-            logs.shift();
-    });
-    proc.stderr?.on("data", (chunk) => {
-        const line = chunk.toString();
-        logs.push(line);
-        if (logs.length > 100)
-            logs.shift();
+/** Detect the default branch from origin (main, master, dev, etc.) */
+function detectDefaultBranch(projectRoot) {
+    const headRef = spawnSync("git", ["-C", projectRoot, "symbolic-ref", "refs/remotes/origin/HEAD"], {
+        encoding: "utf8",
+        stdio: "pipe",
     });
-    proc.on("close", (code) => {
-        if (state.status !== "stopped") {
-            state = { status: "stopped", port: null, error: code ? `exit ${code}` : null };
+    if (headRef.status === 0 && headRef.stdout.trim()) {
+        return headRef.stdout.trim().replace("refs/remotes/origin/", "");
+    }
+    for (const name of ["main", "master", "dev", "develop"]) {
+        const check = spawnSync("git", ["-C", projectRoot, "rev-parse", "--verify", `origin/${name}`], {
+            encoding: "utf8",
+            stdio: "pipe",
+        });
+        if (check.status === 0)
+            return name;
+    }
+    return "main";
+}
+/** Create a git worktree for the comparison server */
+function ensureWorktree(projectRoot, branch) {
+    const campsDir = join(projectRoot, ".sanjang", "camps");
+    const wtPath = join(campsDir, "__main__");
+    if (existsSync(wtPath)) {
+        spawnSync("git", ["-C", projectRoot, "worktree", "remove", "--force", wtPath], { stdio: "pipe" });
+        if (existsSync(wtPath)) {
+            rmSync(wtPath, { recursive: true, force: true });
         }
-        proc = null;
+    }
+    const hasOrigin = spawnSync("git", ["-C", projectRoot, "remote"], {
+        encoding: "utf8",
+        stdio: "pipe",
+    }).stdout.trim().includes("origin");
+    let ref;
+    if (hasOrigin) {
+        spawnSync("git", ["-C", projectRoot, "fetch", "origin", branch], { stdio: "pipe" });
+        ref = `origin/${branch}`;
+    }
+    else {
+        ref = branch;
+    }
+    if (!existsSync(campsDir))
+        mkdirSync(campsDir, { recursive: true });
+    const result = spawnSync("git", ["-C", projectRoot, "worktree", "add", "--detach", wtPath, ref], {
+        encoding: "utf8",
+        stdio: "pipe",
     });
-    proc.on("error", (err) => {
-        state = { status: "error", port: null, error: err.message };
-        proc = null;
+    if (result.status !== 0) {
+        throw new Error(`worktree 생성 실패: ${result.stderr?.trim() || "unknown error"}`);
+    }
+    return wtPath;
+}
+function runSetup(wtPath, config, onLog) {
+    if (!config.setup)
+        return;
+    const setupCwd = config.dev.cwd ? join(wtPath, config.dev.cwd) : wtPath;
+    onLog(`의존성 설치 중: ${config.setup}`);
+    const result = spawnSync(config.setup, [], {
+        cwd: setupCwd,
+        shell: true,
+        stdio: "pipe",
+        encoding: "utf8",
+        timeout: 120_000,
     });
-    const detectedPort = await detectMainPort(logs, basePort, 15_000);
-    if (detectedPort) {
-        state = { status: "running", port: detectedPort, error: null };
-        onReady?.(detectedPort);
+    if (result.status !== 0) {
+        onLog(`⚠️ setup 실패 (exit ${result.status}), 계속 진행합니다`);
     }
     else {
-        state = { status: "error", port: null, error: "포트를 감지하지 못했어요" };
+        onLog("의존성 설치 완료 ✓");
+    }
+}
+export async function startMainServer(projectRoot, config, callbacks) {
+    if (state.status === "running" || state.status === "starting")
+        return;
+    const log = callbacks?.onLog ?? (() => { });
+    state = { status: "starting", port: null, error: null };
+    logs = [];
+    savedProjectRoot = projectRoot;
+    try {
+        const branch = detectDefaultBranch(projectRoot);
+        log(`비교 기준: origin/${branch}`);
+        log("원본 소스 준비 중...");
+        const wtPath = ensureWorktree(projectRoot, branch);
+        worktreePath = wtPath;
+        runSetup(wtPath, config, log);
+        const basePort = config.dev.port + 100;
+        const fullCommand = buildDevCommand(config.dev.command, config.dev.portFlag, basePort);
+        const cwd = config.dev.cwd ? join(wtPath, config.dev.cwd) : wtPath;
+        log(`dev 서버 시작: ${fullCommand}`);
+        proc = spawn(fullCommand, [], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, ...config.dev.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+            shell: true,
+            detached: true,
+        });
+        proc.stdout?.on("data", (chunk) => {
+            const line = chunk.toString();
+            logs.push(line);
+            if (logs.length > 100)
+                logs.shift();
+        });
+        proc.stderr?.on("data", (chunk) => {
+            const line = chunk.toString();
+            logs.push(line);
+            if (logs.length > 100)
+                logs.shift();
+        });
+        proc.on("close", (code) => {
+            if (state.status !== "stopped") {
+                state = { status: "stopped", port: null, error: code ? `exit ${code}` : null };
+            }
+            proc = null;
+        });
+        proc.on("error", (err) => {
+            state = { status: "error", port: null, error: err.message };
+            proc = null;
+        });
+        const detectedPort = await detectPortFromLogs(logs, 60_000);
+        if (detectedPort) {
+            state = { status: "running", port: detectedPort, error: null };
+            log(`비교 서버 준비 완료 ✓ (origin/${branch}, :${detectedPort})`);
+            callbacks?.onReady?.(detectedPort);
+        }
+        else {
+            if (proc) {
+                killProcessGroup(proc);
+                proc = null;
+            }
+            const lastLog = logs.slice(-5).join("\n").trim();
+            state = { status: "error", port: null, error: lastLog || "포트를 감지하지 못했어요" };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        state = { status: "error", port: null, error: message };
+        log(`❌ 비교 서버 시작 실패: ${message}`);
     }
 }
 export function stopMainServer() {
     state = { status: "stopped", port: null, error: null };
     if (proc) {
-        proc.kill("SIGTERM");
+        killProcessGroup(proc);
         proc = null;
     }
     logs = [];
-}
-function detectMainPort(logLines, _fallbackPort, timeoutMs) {
-    return new Promise((resolve) => {
-        const deadline = Date.now() + timeoutMs;
-        const portRe = /https?:\/\/localhost:(\d+)/;
-        function check() {
-            for (const line of logLines) {
-                const match = portRe.exec(line);
-                if (match?.[1]) {
-                    const port = parseInt(match[1], 10);
-                    const sock = createConnection({ port, host: "localhost" });
-                    sock.once("connect", () => {
-                        sock.destroy();
-                        resolve(port);
-                    });
-                    sock.once("error", () => {
-                        sock.destroy();
-                        if (Date.now() < deadline)
-                            setTimeout(check, 1000);
-                        else
-                            resolve(port);
-                    });
-                    return;
-                }
-            }
-            if (Date.now() >= deadline) {
-                resolve(null);
-            }
-            else {
-                setTimeout(check, 1000);
+    if (worktreePath && existsSync(worktreePath) && savedProjectRoot) {
+        try {
+            spawnSync("git", ["-C", savedProjectRoot, "worktree", "remove", "--force", worktreePath], {
+                stdio: "pipe",
+            });
+        }
+        catch {
+            try {
+                rmSync(worktreePath, { recursive: true, force: true });
             }
+            catch { }
         }
-        check();
-    });
+        worktreePath = null;
+    }
 }

package/dist/lib/engine/ports.d.ts

@@ -4,6 +4,6 @@ export declare function portsForSlot(slot: number): {
     fePort: number;
     bePort: number;
 };
-export declare function scanPorts(): PortStatus[];
-export declare function allocate(existingCamps: Pick<Camp, "slot">[]): PortAllocation;
+export declare function scanPorts(): Promise<PortStatus[]>;
+export declare function allocate(existingCamps: Pick<Camp, "slot" | "fePort" | "bePort">[]): Promise<PortAllocation>;
 export declare function release(_name: string): void;

package/dist/lib/engine/ports.js

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { createServer } from "node:net";
 const portConfig = {
     fe: { base: 3000, slots: 8 },
     be: { base: 8000, slots: 8 },
@@ -15,38 +15,48 @@ export function portsForSlot(slot) {
         bePort: portConfig.be.base + slot,
     };
 }
-function isPortBusy(port) {
-    try {
-        const out = execSync(`lsof -i :${port} -t 2>/dev/null`, { encoding: "utf8" }).trim();
-        return out.length > 0;
-    }
-    catch {
-        return false;
-    }
+function probePort(port) {
+    return new Promise((resolve) => {
+        const srv = createServer();
+        srv.once("error", () => resolve(true));
+        srv.once("listening", () => {
+            srv.close(() => resolve(false));
+        });
+        srv.listen(port, "127.0.0.1");
+    });
 }
-export function scanPorts() {
-    const status = [];
+// --- 10-second cache ---
+let _cache = null;
+let _cacheTime = 0;
+const CACHE_TTL = 10_000;
+export async function scanPorts() {
+    const now = Date.now();
+    if (_cache && now - _cacheTime < CACHE_TTL)
+        return _cache;
     const maxSlots = Math.max(portConfig.fe.slots, portConfig.be.slots);
-    for (let slot = 0; slot < maxSlots; slot++) {
+    const slots = Array.from({ length: maxSlots }, (_, i) => i);
+    const results = await Promise.all(slots.map(async (slot) => {
         const { fePort, bePort } = portsForSlot(slot);
-        status.push({
-            slot,
-            fePort,
-            feBusy: isPortBusy(fePort),
-            bePort,
-            beBusy: isPortBusy(bePort),
-        });
-    }
-    return status;
+        const [feBusy, beBusy] = await Promise.all([probePort(fePort), probePort(bePort)]);
+        return { slot, fePort, feBusy, bePort, beBusy };
+    }));
+    _cache = results;
+    _cacheTime = Date.now();
+    return results;
 }
-export function allocate(existingCamps) {
+export async function allocate(existingCamps) {
     const usedSlots = new Set(existingCamps.map((p) => p.slot));
+    const usedFePorts = new Set(existingCamps.map((p) => p.fePort));
+    const usedBePorts = new Set(existingCamps.map((p) => p.bePort));
     const maxSlots = portConfig.fe.slots;
     for (let slot = 1; slot < maxSlots; slot++) {
         if (usedSlots.has(slot))
             continue;
         const { fePort, bePort } = portsForSlot(slot);
-        if (!isPortBusy(fePort) && !isPortBusy(bePort)) {
+        if (usedFePorts.has(fePort) || usedBePorts.has(bePort))
+            continue;
+        const [feBusy, beBusy] = await Promise.all([probePort(fePort), probePort(bePort)]);
+        if (!feBusy && !beBusy) {
             return { slot, fePort, bePort };
         }
     }