sanjang 0.3.4 → 0.3.6

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.
  */
@@ -230,13 +256,11 @@ function detectTurboMainApp(root) {
                 const port = portMatch?.[1] ? parseInt(portMatch[1], 10) : 3000;
                 candidates.push({ name: entry.name, port });
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
     }
     // Prefer app with explicit port, then first candidate
-    return candidates.find(c => c.port !== 3000) ?? candidates[0] ?? null;
+    return candidates.find((c) => c.port !== 3000) ?? candidates[0] ?? null;
 }
 function detectPackageManager(root) {
     if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock")))
@@ -272,7 +296,7 @@ export function generateConfig(projectRoot, options = {}) {
     // Exclude .env.example, .env.test, .env.template
     (f) => !f.includes("example") && !f.includes("template") && !f.includes(".test"));
     // Detect potential issues
-    const issues = detectSetupIssues(detectRoot);
+    const _issues = detectSetupIssues(detectRoot);
     const lines = [
         "export default {",
         `  // ${detected.framework} detected`,

package/dist/lib/engine/change-report.d.ts

@@ -0,0 +1,27 @@
+import type { ChangeReport, ChangeReportFile, ChangeReportWarning } from "../types.ts";
+type FileCategory = "ui" | "api" | "config" | "test" | "docs" | "other";
+/**
+ * Classify a file path into one of the known categories.
+ * Rules are checked in priority order: test > ui > api > docs > config > other
+ */
+export declare function categorizeFile(filePath: string): FileCategory;
+/**
+ * Detect warnings from a list of categorized files.
+ * Returns deduplicated warnings (one per type).
+ */
+export declare function detectWarnings(files: ChangeReportFile[]): ChangeReportWarning[];
+/**
+ * Build a ChangeReport from raw file list (path + status).
+ * summary and humanDescription are set to null — call generateReportSummary to enrich.
+ */
+export declare function buildChangeReport(rawFiles: {
+    path: string;
+    status: ChangeReportFile["status"];
+}[]): ChangeReport;
+/**
+ * Enrich a ChangeReport with AI-generated category-level descriptions.
+ * Each category gets human-readable bullet points explaining what changed.
+ * Tries `claude -p --model haiku` and falls back to file-based summary.
+ */
+export declare function generateReportSummary(diffStat: string, diff: string, report: ChangeReport): ChangeReport;
+export {};

package/dist/lib/engine/change-report.js

@@ -0,0 +1,233 @@
+import { spawnSync } from "node:child_process";
+import { basename, extname } from "node:path";
+/**
+ * Classify a file path into one of the known categories.
+ * Rules are checked in priority order: test > ui > api > docs > config > other
+ */
+export function categorizeFile(filePath) {
+    const name = basename(filePath);
+    const ext = extname(filePath).toLowerCase();
+    const lower = filePath.toLowerCase();
+    // 1. test
+    if (/\.(test|spec)\.[^.]+$/.test(lower))
+        return "test";
+    if (/[/\\](test|tests|__tests__|__mocks__|fixtures)[/\\]/.test(lower))
+        return "test";
+    if (/^(test|tests|__tests__|__mocks__|fixtures)[/\\]/.test(lower))
+        return "test";
+    // 2. ui
+    const uiExts = new Set([
+        ".css",
+        ".scss",
+        ".less",
+        ".sass",
+        ".styl",
+        ".html",
+        ".htm",
+        ".svg",
+        ".tsx",
+        ".jsx",
+        ".vue",
+        ".svelte",
+    ]);
+    if (uiExts.has(ext))
+        return "ui";
+    if (/[/\\](pages|views|components|layouts|styles|public)[/\\]/.test(lower))
+        return "ui";
+    if (/^(pages|views|components|layouts|styles|public)[/\\]/.test(lower))
+        return "ui";
+    // 3. api
+    if (/[/\\](api|routes|controllers|handlers|middleware|graphql|resolvers|schema)[/\\]/.test(lower))
+        return "api";
+    if (/^(api|routes|controllers|handlers|middleware|graphql|resolvers|schema)[/\\]/.test(lower))
+        return "api";
+    // files named "server" (any extension)
+    if (/[/\\]server\.[^/\\]+$/.test(lower) || /^server\.[^/\\]+$/.test(lower))
+        return "api";
+    // 4. docs
+    if (ext === ".md")
+        return "docs";
+    if (/[/\\]docs[/\\]/.test(lower) || /^docs[/\\]/.test(lower))
+        return "docs";
+    if (/^(README|CHANGELOG|LICENSE|CONTRIBUTING)(\.|$)/i.test(name))
+        return "docs";
+    // 5. config
+    const configPrefixes = [
+        "package",
+        "tsconfig",
+        "jest.config",
+        "vite.config",
+        "next.config",
+        "webpack.config",
+        "biome",
+        ".eslint",
+        ".prettier",
+        ".babel",
+    ];
+    const nameLower = name.toLowerCase();
+    if (configPrefixes.some((p) => nameLower.startsWith(p.toLowerCase())))
+        return "config";
+    if (name.startsWith("."))
+        return "config";
+    if ([".json", ".yaml", ".yml", ".toml"].includes(ext))
+        return "config";
+    // 6. other
+    return "other";
+}
+/**
+ * Detect warnings from a list of categorized files.
+ * Returns deduplicated warnings (one per type).
+ */
+export function detectWarnings(files) {
+    const seen = new Set();
+    const warnings = [];
+    const add = (type, message, file) => {
+        if (seen.has(type))
+            return;
+        seen.add(type);
+        warnings.push({ type, message, file });
+    };
+    for (const f of files) {
+        const p = f.path.toLowerCase();
+        const name = basename(f.path);
+        // env
+        if (/\.env($|\.)/.test(name.toLowerCase())) {
+            add("env", "환경 변수 파일이 변경되었습니다", f.path);
+        }
+        // db
+        if (/migrat|schema|\.sql|prisma/.test(p)) {
+            add("db", "데이터베이스 스키마 또는 마이그레이션이 변경되었습니다", f.path);
+        }
+        // infra
+        if (/dockerfile|docker-compose|\.github\/|deploy\/|[/\\]k8s[/\\]|^k8s[/\\]|terraform|infrastructure/.test(p)) {
+            add("infra", "인프라 설정이 변경되었습니다", f.path);
+        }
+        // config (package manager files)
+        if (/package\.json|package-lock|yarn\.lock|pnpm-lock/.test(p)) {
+            add("config", "패키지 의존성이 변경되었습니다", f.path);
+        }
+        // security
+        if (/auth|security|token|secret|credential|password/.test(p)) {
+            add("security", "보안 관련 파일이 변경되었습니다", f.path);
+        }
+    }
+    return warnings;
+}
+/**
+ * Build a ChangeReport from raw file list (path + status).
+ * summary and humanDescription are set to null — call generateReportSummary to enrich.
+ */
+export function buildChangeReport(rawFiles) {
+    const files = rawFiles.map((f) => ({
+        path: f.path,
+        status: f.status,
+        category: categorizeFile(f.path),
+    }));
+    const byCategory = {};
+    for (const f of files) {
+        const cat = f.category;
+        if (!byCategory[cat])
+            byCategory[cat] = [];
+        byCategory[cat].push(f);
+    }
+    const warnings = detectWarnings(files);
+    // 기본 카테고리 설명 — AI 없이도 즉시 표시
+    const categoryDetails = {};
+    for (const [cat, catFiles] of Object.entries(byCategory)) {
+        categoryDetails[cat] = catFiles.map((f) => {
+            const name = f.path.split("/").pop() || f.path;
+            return f.status === "새 파일" ? `${name} 추가됨` : `${name} 수정됨`;
+        });
+    }
+    return {
+        files,
+        totalCount: files.length,
+        byCategory,
+        warnings,
+        summary: null,
+        humanDescription: null,
+        categoryDetails,
+    };
+}
+/**
+ * Enrich a ChangeReport with AI-generated category-level descriptions.
+ * Each category gets human-readable bullet points explaining what changed.
+ * Tries `claude -p --model haiku` and falls back to file-based summary.
+ */
+export function generateReportSummary(diffStat, diff, report) {
+    const categoryNames = {
+        ui: "화면",
+        api: "서버/API",
+        config: "설정",
+        test: "테스트",
+        docs: "문서",
+        other: "기타",
+    };
+    const categoryList = Object.keys(report.byCategory)
+        .map((cat) => `${categoryNames[cat] || cat}: ${(report.byCategory[cat] ?? []).length}개`)
+        .join(", ");
+    const fallbackSummary = `${categoryList} 변경`;
+    // Build per-category diff sections for the prompt
+    const categoryDiffSections = Object.entries(report.byCategory)
+        .map(([cat, files]) => {
+        const fileList = files.map((f) => `  ${f.status} ${f.path}`).join("\n");
+        return `[${categoryNames[cat] || cat}]\n${fileList}`;
+    })
+        .join("\n\n");
+    const prompt = `너는 비개발자에게 코드 변경사항을 설명하는 도우미야.
+아래 git diff를 분석하고, 카테고리별로 "실제로 뭐가 바뀌었는지"를 설명해.
+
+규칙:
+- 파일명이 아니라 사용자 관점에서 뭐가 바뀌었는지 설명 (예: "로그인 버튼이 보라색으로 바뀌었어요")
+- 각 항목은 한국어, '~했어요/~됐어요' 체, 한 줄
+- 새 파일이면 "추가됐어요", 수정이면 구체적으로 뭐가 바뀌었는지
+
+카테고리별 파일:
+${categoryDiffSections}
+
+diff:
+${diff.slice(0, 4000)}
+
+JSON으로만 응답해 (다른 텍스트 없이):
+{"summary": "전체 한 줄 요약 (30자 이내)", "categories": {"ui": ["설명1", "설명2"], "api": ["설명1"], ...}}
+
+categories의 키는 반드시 다음 중 하나: ${Object.keys(report.byCategory).join(", ")}`;
+    try {
+        const result = spawnSync("claude", ["-p", prompt], {
+            encoding: "utf8",
+            timeout: 30_000,
+        });
+        if (result.status === 0 && result.stdout) {
+            const output = result.stdout.trim();
+            const jsonMatch = output.match(/\{[\s\S]*"summary"[\s\S]*"categories"[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                if (parsed.summary && parsed.categories) {
+                    return {
+                        ...report,
+                        summary: parsed.summary,
+                        humanDescription: null,
+                        categoryDetails: parsed.categories,
+                    };
+                }
+            }
+        }
+    }
+    catch {
+        // Fall through to fallback
+    }
+    // Fallback: 파일 기반 설명 생성
+    const fallbackDetails = {};
+    for (const [cat, files] of Object.entries(report.byCategory)) {
+        fallbackDetails[cat] = files.map((f) => {
+            const name = f.path.split("/").pop() || f.path;
+            return f.status === "새 파일" ? `${name} 파일이 추가됐어요` : `${name} 파일이 수정됐어요`;
+        });
+    }
+    return {
+        ...report,
+        summary: fallbackSummary,
+        humanDescription: null,
+        categoryDetails: fallbackDetails,
+    };
+}

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/diagnostics.js

@@ -14,9 +14,7 @@ function checkPortConflict(processInfo) {
         name: "port-conflict",
         status: hit ? "error" : "ok",
         detail: hit ? "다른 프로그램과 충돌이 발생했습니다." : "정상.",
-        guide: hit
-            ? '"중지" → "시작"을 눌러보세요. 계속되면 "삭제" 후 다시 만들어보세요.'
-            : null,
+        guide: hit ? '"중지" → "시작"을 눌러보세요. 계속되면 "삭제" 후 다시 만들어보세요.' : null,
     };
 }
 function checkFrontendExit(processInfo) {
@@ -47,9 +45,7 @@ function checkFePort(pg) {
     return {
         name: "fe-status",
         status: output?.length ? "ok" : "warn",
-        detail: output?.length
-            ? "Frontend 서버가 실행 중입니다."
-            : "Frontend 서버가 응답하지 않습니다.",
+        detail: output?.length ? "Frontend 서버가 실행 중입니다." : "Frontend 서버가 응답하지 않습니다.",
         guide: !output?.length ? '"시작" 버튼을 눌러보세요.' : null,
     };
 }

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

@@ -0,0 +1,19 @@
+/**
+ * Main branch dev server manager.
+ * 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 {
+    status: "stopped" | "starting" | "running" | "error";
+    port: number | null;
+    error: string | null;
+}
+export declare function getMainServerState(): MainServerState;
+export declare function getMainServerLogs(): string[];
+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

@@ -0,0 +1,181 @@
+/**
+ * Main branch dev server manager.
+ * 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, 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];
+}
+/** 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",
+    });
+    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 });
+        }
+    }
+    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",
+    });
+    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,
+    });
+    if (result.status !== 0) {
+        onLog(`⚠️ setup 실패 (exit ${result.status}), 계속 진행합니다`);
+    }
+    else {
+        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) {
+        killProcessGroup(proc);
+        proc = null;
+    }
+    logs = [];
+    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 { }
+        }
+        worktreePath = null;
+    }
+}

package/dist/lib/engine/naming.js

@@ -5,10 +5,19 @@ import { spawnSync } from "node:child_process";
  */
 export function aiSlugify(description) {
     try {
-        const result = spawnSync("claude", ["-p", "--model", "haiku", `Convert this task description to a kebab-case English slug. Rules: 3-5 words, max 30 chars, lowercase, descriptive (not just one word), no explanation, output ONLY the slug.\n\nExample: "로그인 버튼 색상 변경" → "login-button-color-change"\nExample: "대시보드 차트 추가" → "dashboard-chart-add"\n\nTask: "${description}"`], { encoding: "utf8", stdio: "pipe", timeout: 10_000 });
+        const result = spawnSync("claude", [
+            "-p",
+            "--model",
+            "haiku",
+            `Convert this task description to a kebab-case English slug. Rules: 3-5 words, max 30 chars, lowercase, descriptive (not just one word), no explanation, output ONLY the slug.\n\nExample: "로그인 버튼 색상 변경" → "login-button-color-change"\nExample: "대시보드 차트 추가" → "dashboard-chart-add"\n\nTask: "${description}"`,
+        ], { encoding: "utf8", stdio: "pipe", timeout: 10_000 });
         if (result.status !== 0)
             return null;
-        const slug = (result.stdout ?? "").trim().toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
+        const slug = (result.stdout ?? "")
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, "")
+            .replace(/^-+|-+$/g, "");
         if (!slug || slug.length > 30)
             return null;
         return slug;

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;