sanjang 0.3.5 → 0.3.7

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,44 +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;
@@ -172,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,
@@ -188,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);
@@ -201,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 } });
@@ -212,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/state.js

@@ -15,15 +15,23 @@ 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) {
@@ -32,6 +40,7 @@ function write(records) {
     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/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>;