sanjang 0.3.4 → 0.3.6

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 };
         }
     }

package/dist/lib/engine/pr.js

@@ -27,7 +27,7 @@ export function buildFallbackPrBody({ message, actions, diffStat }) {
 export function buildClaudePrPrompt({ message, diffStat, diff }) {
     return [
         "You are writing a GitHub Pull Request description.",
-        'The author described the change as: "' + message + '"',
+        `The author described the change as: "${message}"`,
         "",
         "Here is the diff stat:",
         diffStat || "(no stat)",

package/dist/lib/engine/process-utils.d.ts

@@ -0,0 +1,11 @@
+import { type ChildProcess } from "node:child_process";
+export declare function stripAnsi(s: string): string;
+/** Build the full dev command, handling npm/yarn/pnpm's `--` separator requirement */
+export declare function buildDevCommand(command: string, portFlag: string | null | undefined, port: number): string;
+/** Kill a process and its entire process group (for shell: true + detached: true spawns) */
+export declare function killProcessGroup(proc: ChildProcess): void;
+/**
+ * Detect actual port from dev server stdout logs by polling for a localhost URL.
+ * Strips ANSI codes before matching. Verifies port is reachable via TCP probe.
+ */
+export declare function detectPortFromLogs(logs: string[], timeoutMs: number): Promise<number | null>;

package/dist/lib/engine/process-utils.js

@@ -0,0 +1,65 @@
+import { createConnection } from "node:net";
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, "");
+}
+/** Build the full dev command, handling npm/yarn/pnpm's `--` separator requirement */
+export function buildDevCommand(command, portFlag, port) {
+    if (!portFlag)
+        return command;
+    const needsSeparator = /\b(npm|yarn|pnpm)\s+run\b/.test(command);
+    return `${command}${needsSeparator ? " --" : ""} ${portFlag} ${port}`;
+}
+/** Kill a process and its entire process group (for shell: true + detached: true spawns) */
+export function killProcessGroup(proc) {
+    const pid = proc.pid;
+    if (pid) {
+        try {
+            process.kill(-pid, "SIGTERM");
+        }
+        catch {
+            proc.kill("SIGTERM");
+        }
+    }
+    else {
+        proc.kill("SIGTERM");
+    }
+}
+/**
+ * Detect actual port from dev server stdout logs by polling for a localhost URL.
+ * Strips ANSI codes before matching. Verifies port is reachable via TCP probe.
+ */
+export function detectPortFromLogs(logs, timeoutMs) {
+    return new Promise((resolve) => {
+        const deadline = Date.now() + timeoutMs;
+        const portRe = /https?:\/\/localhost:(\d+)/;
+        function check() {
+            for (const line of logs) {
+                const match = portRe.exec(stripAnsi(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);
+            }
+        }
+        check();
+    });
+}

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

@@ -7,6 +7,8 @@ export declare function setConfig(config: SanjangConfig): void;
 interface StartCampParams {
     name: string;
     fePort: number;
+    /** Ports reserved by other camps — detected port must not collide with these */
+    reservedPorts?: Set<number>;
 }
 export declare function startCamp(pg: StartCampParams, onEvent: EventCallback): Promise<number>;
 export declare function stopCamp(name: string): void;

package/dist/lib/engine/process.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { createConnection } from "node:net";
 import { join } from "node:path";
 import { campPath, getProjectRoot } from "./worktree.js";
+import { buildDevCommand, detectPortFromLogs, killProcessGroup } from "./process-utils.js";
 const procs = new Map();
 let projectConfig = null;
 let sharedBeProc = null;
@@ -11,41 +12,8 @@ export function setConfig(config) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-// Detect actual port from dev server stdout (Vite: "➜  Local: http://localhost:3004/")
-function detectPortFromStdout(logs, timeoutMs) {
-    return new Promise((resolve) => {
-        const deadline = Date.now() + timeoutMs;
-        // Patterns: Vite "Local:   http://localhost:PORT/", Next "- Local: http://localhost:PORT"
-        const portRe = /https?:\/\/localhost:(\d+)/;
-        function check() {
-            for (const line of logs) {
-                const match = portRe.exec(line);
-                if (match?.[1]) {
-                    const port = parseInt(match[1], 10);
-                    // Wait briefly for the port to actually be ready
-                    const sock = createConnection({ port, host: "localhost" });
-                    sock.once("connect", () => { sock.destroy(); resolve(port); });
-                    sock.once("error", () => {
-                        sock.destroy();
-                        // Port printed but not ready yet, retry
-                        if (Date.now() < deadline)
-                            setTimeout(check, 1000);
-                        else
-                            resolve(port); // return the port anyway
-                    });
-                    return;
-                }
-            }
-            if (Date.now() >= deadline) {
-                resolve(null);
-            }
-            else {
-                setTimeout(check, 1000);
-            }
-        }
-        check();
-    });
-}
+// Re-export detectPortFromLogs as the local name used throughout this file
+const detectPortFromStdout = detectPortFromLogs;
 function waitForPort(port, timeoutMs) {
     return new Promise((resolve, reject) => {
         const deadline = Date.now() + timeoutMs;
@@ -169,8 +137,7 @@ export async function startCamp(pg, onEvent) {
     // Step 2: Frontend
     onEvent({ type: "log", source: "sanjang", data: "Frontend 준비 중..." });
     onEvent({ type: "status", data: "starting-frontend" });
-    // Build command — try to pass port flag if available, but always verify via stdout
-    const fullCommand = dev.portFlag ? `${dev.command} ${dev.portFlag} ${fePort}` : dev.command;
+    const fullCommand = buildDevCommand(dev.command, dev.portFlag, fePort);
     const cwd = dev.cwd ? join(wtPath, dev.cwd) : wtPath;
     const feProc = spawn(fullCommand, [], {
         cwd,
@@ -185,6 +152,7 @@ export async function startCamp(pg, onEvent) {
         },
         stdio: ["ignore", "pipe", "pipe"],
         shell: true,
+        detached: true,
     });
     entry.feProc = feProc;
     attachLogs(feProc, entry.feLogs, "frontend", onEvent);
@@ -198,6 +166,23 @@ export async function startCamp(pg, onEvent) {
     if (!detectedPort) {
         throw new Error("dev 서버가 시작되지 않았습니다. 로그를 확인하세요.");
     }
+    // Validate: detected port must not collide with another camp's port
+    if (pg.reservedPorts?.has(detectedPort)) {
+        onEvent({
+            type: "log",
+            source: "sanjang",
+            data: `⚠️ 포트 충돌 감지: dev 서버가 ${fePort} 대신 ${detectedPort}을 사용했고, 다른 캠프와 겹칩니다. 프로세스를 종료합니다.`,
+        });
+        stopCamp(name);
+        throw new Error(`포트 충돌: dev 서버가 :${detectedPort}에 바인딩했지만, 다른 캠프가 이미 사용 중입니다. 해당 캠프를 정리하거나 포트를 확인하세요.`);
+    }
+    if (detectedPort !== fePort) {
+        onEvent({
+            type: "log",
+            source: "sanjang",
+            data: `ℹ️ dev 서버가 요청한 포트(${fePort}) 대신 ${detectedPort}을 사용합니다.`,
+        });
+    }
     const url = `http://localhost:${detectedPort}`;
     onEvent({ type: "log", source: "sanjang", data: `Frontend 준비 완료 ✓` });
     onEvent({ type: "url-detected", data: { url, port: detectedPort } });
@@ -209,12 +194,15 @@ export function stopCamp(name) {
     if (!entry)
         return;
     if (entry.feProc && !entry.feProc.killed) {
-        entry.feProc.kill("SIGTERM");
+        killProcessGroup(entry.feProc);
         // SIGKILL fallback if still alive after 5s
         const proc = entry.feProc;
+        const pid = proc.pid;
         setTimeout(() => {
             try {
-                if (!proc.killed)
+                if (!proc.killed && pid)
+                    process.kill(-pid, "SIGKILL");
+                else if (!proc.killed)
                     proc.kill("SIGKILL");
             }
             catch {

package/dist/lib/engine/self-heal.js

@@ -1,6 +1,6 @@
-import { existsSync, copyFileSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
 import { execSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
 const PATTERNS = [
     {
         test: /Cannot find module|MODULE_NOT_FOUND/i,
@@ -64,7 +64,12 @@ export function executeHeal(action, campPath, projectRoot, setupCommand, copyFil
             if (!setupCommand)
                 return { action, success: false, detail: "설치 명령이 없습니다." };
             try {
-                execSync(setupCommand, { cwd: campPath, stdio: "pipe", timeout: 120_000, shell: true });
+                execSync(setupCommand, {
+                    cwd: campPath,
+                    stdio: "pipe",
+                    timeout: 120_000,
+                    shell: true,
+                });
                 return { action, success: true };
             }
             catch {
@@ -82,10 +87,16 @@ export function executeHeal(action, campPath, projectRoot, setupCommand, copyFil
                         copyFileSync(src, dst);
                         copied++;
                     }
-                    catch { /* skip */ }
+                    catch {
+                        /* skip */
+                    }
                 }
             }
-            return { action, success: copied > 0, detail: copied > 0 ? `${copied}개 파일 복사됨` : "복사할 파일이 없습니다." };
+            return {
+                action,
+                success: copied > 0,
+                detail: copied > 0 ? `${copied}개 파일 복사됨` : "복사할 파일이 없습니다.",
+            };
         }
         case "restart":
             // Restart is handled by the caller (stop + start)

package/dist/lib/engine/smart-init.js

@@ -32,7 +32,7 @@ export function deepFindEnvFiles(projectRoot, maxDepth = 4) {
 export function detectSetupIssues(projectRoot) {
     const issues = [];
     // 1. Check for env variable references without .env files
-    const hasEnvFile = ENV_PATTERNS.some(f => existsSync(join(projectRoot, f)));
+    const hasEnvFile = ENV_PATTERNS.some((f) => existsSync(join(projectRoot, f)));
     if (!hasEnvFile) {
         const envRefFound = scanForEnvReferences(projectRoot);
         if (envRefFound) {
@@ -52,7 +52,7 @@ export function detectSetupIssues(projectRoot) {
     }
     // 3. Check for missing lockfile
     const lockfiles = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
-    if (!lockfiles.some(f => existsSync(join(projectRoot, f)))) {
+    if (!lockfiles.some((f) => existsSync(join(projectRoot, f)))) {
         issues.push({
             type: "missing-lockfile",
             message: "lockfile이 없습니다. 의존성 설치가 느릴 수 있습니다.",
@@ -97,7 +97,10 @@ function scanForEnvReferences(dir, depth = 0) {
                 continue;
             }
         }
-        if (entry.isDirectory() && !SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        if (entry.isDirectory() &&
+            !SKIP_DIRS.has(entry.name) &&
+            !entry.name.startsWith(".") &&
+            entry.name !== "node_modules") {
             if (scanForEnvReferences(join(dir, entry.name), depth + 1))
                 return true;
         }
@@ -129,9 +132,7 @@ function countTurboApps(root) {
                 if (scripts?.dev)
                     count++;
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
     }
     return count;

package/dist/lib/engine/state.js

@@ -15,23 +15,32 @@ function stateFile() {
 function ensureDir() {
     mkdirSync(getCampsDir(), { recursive: true });
 }
+// --- In-memory cache ---
+let _stateCache = null;
 function read() {
+    if (_stateCache !== null)
+        return _stateCache;
     const f = stateFile();
-    if (!existsSync(f))
-        return [];
+    if (!existsSync(f)) {
+        _stateCache = [];
+        return _stateCache;
+    }
     try {
-        return JSON.parse(readFileSync(f, "utf8"));
+        _stateCache = JSON.parse(readFileSync(f, "utf8"));
+        return _stateCache;
     }
     catch {
-        return [];
+        _stateCache = [];
+        return _stateCache;
     }
 }
 function write(records) {
     ensureDir();
     // Atomic write: write to temp file then rename to prevent corruption
-    const tmp = stateFile() + ".tmp";
+    const tmp = `${stateFile()}.tmp`;
     writeFileSync(tmp, JSON.stringify(records, null, 2), "utf8");
     renameSync(tmp, stateFile());
+    _stateCache = records;
 }
 export function getAll() {
     return read();

package/dist/lib/engine/suggest.js

@@ -97,10 +97,7 @@ async function fetchRecentCommits(cwd) {
 export async function suggestTasks(projectRoot) {
     const results = [];
     // gh-dependent fetches — tolerate failure (gh not installed / no repo)
-    const [issues, prs] = await Promise.allSettled([
-        fetchIssues(projectRoot),
-        fetchMyPrs(projectRoot),
-    ]);
+    const [issues, prs] = await Promise.allSettled([fetchIssues(projectRoot), fetchMyPrs(projectRoot)]);
     // PRs first — most actionable ("이어하기")
     if (prs.status === "fulfilled") {
         results.push(...prs.value);

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

@@ -15,7 +15,7 @@ export declare function detectWarp(): WarpDetectResult;
  * Opens as a new tab in the existing Warp window (not a new window).
  * The tab title naturally shows the directory name (= camp name).
  */
-export declare function openWarpTab(campName: string, worktreePath: string): WarpOpenResult;
+export declare function openWarpTab(_campName: string, worktreePath: string): WarpOpenResult;
 /**
  * No-op cleanup (launch config removed — using open -a instead).
  */

package/dist/lib/engine/warp.js

@@ -12,7 +12,7 @@ export function detectWarp() {
  * Opens as a new tab in the existing Warp window (not a new window).
  * The tab title naturally shows the directory name (= camp name).
  */
-export function openWarpTab(campName, worktreePath) {
+export function openWarpTab(_campName, worktreePath) {
     const { installed } = detectWarp();
     if (!installed) {
         return { opened: false, terminal: null, path: worktreePath };

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

@@ -9,5 +9,7 @@ export declare function setProjectRoot(root: string): void;
 export declare function getProjectRoot(): string;
 export declare function campPath(name: string): string;
 export declare function listBranches(): Promise<BranchInfo[]>;
+export declare function invalidateBranchCache(): void;
+export declare function startBranchRefresh(intervalMs?: number): ReturnType<typeof setInterval>;
 export declare function addWorktree(name: string, branch: string): Promise<void>;
 export declare function removeWorktree(name: string): Promise<void>;

package/dist/lib/engine/worktree.js

@@ -16,14 +16,11 @@ export function campPath(name) {
 function git() {
     return simpleGit(getProjectRoot());
 }
-export async function listBranches() {
-    // Best-effort fetch — continue with local refs on network failure
-    try {
-        await git().fetch(["--prune"]);
-    }
-    catch {
-        /* offline is OK */
-    }
+// --- Branch cache ---
+let _branchCache = null;
+let _branchCacheTime = 0;
+const BRANCH_CACHE_TTL = 30_000;
+async function parseBranches() {
     const raw = await git().raw([
         "for-each-ref",
         "--sort=-committerdate",
@@ -70,6 +67,31 @@ export async function listBranches() {
     }
     return branches;
 }
+async function refreshBranches() {
+    try {
+        await git().fetch(["--prune"]);
+    }
+    catch {
+        /* offline is OK */
+    }
+    const branches = await parseBranches();
+    _branchCache = branches;
+    _branchCacheTime = Date.now();
+    return branches;
+}
+export async function listBranches() {
+    if (_branchCache && Date.now() - _branchCacheTime < BRANCH_CACHE_TTL) {
+        return _branchCache;
+    }
+    return refreshBranches();
+}
+export function invalidateBranchCache() {
+    _branchCacheTime = 0;
+}
+export function startBranchRefresh(intervalMs = 30_000) {
+    refreshBranches().catch(() => { });
+    return setInterval(() => refreshBranches().catch(() => { }), intervalMs);
+}
 export async function addWorktree(name, branch) {
     const path = campPath(name);
     const refs = [`origin/${branch}`, branch];

package/dist/lib/server.d.ts

@@ -14,6 +14,7 @@ interface CreateAppResult {
         installed: boolean;
     };
     watchers: Map<string, CampWatcher>;
+    healthCheckTimer: NodeJS.Timeout;
 }
 export declare function createApp(projectRoot: string, options?: CreateAppOptions): Promise<CreateAppResult>;
 export declare function startServer(projectRoot: string, options?: CreateAppOptions): Promise<Server>;