port-arranger 0.0.1

package/dist/cli/core/port-injector.js

@@ -0,0 +1,191 @@
+// 포트 플래그 제거 헬퍼
+const removePortFlag = (cmd, flag) => {
+    // --port 8000 또는 -p 8000 형태 제거
+    const regex = new RegExp(`${flag}\\s+\\d+`, 'g');
+    return cmd.replace(regex, '').replace(/\s+/g, ' ').trim();
+};
+// 명령어 패턴 정의
+const patterns = [
+    // Next.js - 환경변수 방식
+    {
+        name: 'next',
+        patterns: [/\bnext\s+dev\b/, /\bnext\s+start\b/, /\bnext\b/],
+        injectionType: 'env',
+        defaultPort: 3000,
+        injectPort: (cmd) => cmd,
+    },
+    // Node.js (Express 등) - 환경변수 방식
+    {
+        name: 'node',
+        patterns: [/\bnode\s+\S+\.js\b/, /\bnode\s+\S+\.mjs\b/, /\bnode\s+\S+\.cjs\b/],
+        injectionType: 'env',
+        defaultPort: 3000,
+        injectPort: (cmd) => cmd,
+    },
+    // Vite - 플래그 방식
+    {
+        name: 'vite',
+        patterns: [/\bvite\b/],
+        injectionType: 'flag',
+        defaultPort: 5173,
+        injectPort: (cmd, port) => {
+            const cleaned = removePortFlag(cmd, '--port');
+            return `${cleaned} --port ${port}`;
+        },
+    },
+    // npm run dev (vite 프로젝트) - 플래그 방식
+    {
+        name: 'npm-dev',
+        patterns: [/\bnpm\s+run\s+dev\b/],
+        injectionType: 'flag',
+        defaultPort: 5173,
+        injectPort: (cmd, port) => {
+            // npm run dev -- --port 3001 형태로 전달
+            const cleaned = cmd.replace(/\s+--\s+--port\s+\d+/, '');
+            return `${cleaned} -- --port ${port}`;
+        },
+    },
+    // yarn run dev - 플래그 방식
+    {
+        name: 'yarn-dev',
+        patterns: [/\byarn\s+run\s+dev\b/, /\byarn\s+dev\b/],
+        injectionType: 'flag',
+        defaultPort: 5173,
+        injectPort: (cmd, port) => {
+            const cleaned = cmd.replace(/\s+--port\s+\d+/, '');
+            return `${cleaned} --port ${port}`;
+        },
+    },
+    // pnpm run dev - 플래그 방식
+    {
+        name: 'pnpm-dev',
+        patterns: [/\bpnpm\s+run\s+dev\b/, /\bpnpm\s+dev\b/],
+        injectionType: 'flag',
+        defaultPort: 5173,
+        injectPort: (cmd, port) => {
+            const cleaned = cmd.replace(/\s+--port\s+\d+/, '');
+            return `${cleaned} --port ${port}`;
+        },
+    },
+    // uvicorn - 플래그 방식
+    {
+        name: 'uvicorn',
+        patterns: [/\buvicorn\b/],
+        injectionType: 'flag',
+        defaultPort: 8000,
+        injectPort: (cmd, port) => {
+            const cleaned = removePortFlag(cmd, '--port');
+            return `${cleaned} --port ${port}`;
+        },
+    },
+    // FastAPI - 플래그 방식
+    {
+        name: 'fastapi',
+        patterns: [/\bfastapi\s+(dev|run)\b/],
+        injectionType: 'flag',
+        defaultPort: 8000,
+        injectPort: (cmd, port) => {
+            const cleaned = removePortFlag(cmd, '--port');
+            return `${cleaned} --port ${port}`;
+        },
+    },
+    // Flask - 플래그 방식
+    {
+        name: 'flask',
+        patterns: [/\bflask\s+run\b/],
+        injectionType: 'flag',
+        defaultPort: 5000,
+        injectPort: (cmd, port) => {
+            const cleaned = removePortFlag(cmd, '--port');
+            return `${cleaned} --port ${port}`;
+        },
+    },
+    // http-server (npm) - 플래그 방식 (-p)
+    {
+        name: 'http-server',
+        patterns: [/\bhttp-server\b/],
+        injectionType: 'flag',
+        defaultPort: 8080,
+        injectPort: (cmd, port) => {
+            const cleaned = removePortFlag(cmd, '-p');
+            return `${cleaned} -p ${port}`;
+        },
+    },
+    // Python http.server - 인자 방식
+    {
+        name: 'http.server',
+        patterns: [/python3?\s+-m\s+http\.server/],
+        injectionType: 'arg',
+        defaultPort: 8000,
+        injectPort: (cmd, port) => {
+            // 기존 포트 번호 제거 (http.server 뒤의 숫자)
+            const cleaned = cmd.replace(/(http\.server)\s+\d+/, '$1');
+            return `${cleaned} ${port}`;
+        },
+    },
+    // Django runserver - 인자 방식
+    {
+        name: 'django',
+        patterns: [/manage\.py\s+runserver/],
+        injectionType: 'arg',
+        defaultPort: 8000,
+        injectPort: (cmd, port) => {
+            // 기존 포트 번호 제거 (runserver 뒤의 host:port 또는 숫자)
+            // host:port를 먼저 매칭해야 함 (0.0.0.0:8000 등)
+            const cleaned = cmd.replace(/(runserver)\s+([\w.]+:\d+|\d+)/, '$1');
+            return `${cleaned} ${port}`;
+        },
+    },
+    // Docker Compose - compose 방식
+    {
+        name: 'docker-compose',
+        patterns: [/docker\s+compose\s+(up|start|run)\b/],
+        injectionType: 'compose',
+        defaultPort: 0, // compose는 yml에서 파싱
+        injectPort: (cmd) => cmd, // compose는 run.ts에서 별도 처리
+    },
+];
+function findMatchingPattern(command) {
+    for (const pattern of patterns) {
+        for (const regex of pattern.patterns) {
+            if (regex.test(command)) {
+                return pattern;
+            }
+        }
+    }
+    return null;
+}
+// 도구별 기본 포트 조회
+export function getDefaultPort(command) {
+    const matchedPattern = findMatchingPattern(command);
+    return matchedPattern?.defaultPort ?? 3000;
+}
+export function injectPort(originalCommand, port) {
+    const matchedPattern = findMatchingPattern(originalCommand);
+    if (matchedPattern) {
+        const injectionType = matchedPattern.injectionType;
+        const env = {};
+        if (injectionType === 'env') {
+            env.PORT = String(port);
+            return {
+                command: originalCommand,
+                env,
+                injectionType,
+                toolName: matchedPattern.name,
+            };
+        }
+        return {
+            command: matchedPattern.injectPort(originalCommand, port),
+            env,
+            injectionType,
+            toolName: matchedPattern.name,
+        };
+    }
+    // Fallback: 환경변수 방식
+    return {
+        command: originalCommand,
+        env: { PORT: String(port) },
+        injectionType: 'env',
+        toolName: 'unknown',
+    };
+}

package/dist/cli/core/port-injector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/core/port-injector.test.js

@@ -0,0 +1,264 @@
+import { describe, it, expect } from 'vitest';
+import { injectPort, getDefaultPort } from './port-injector.js';
+describe('injectPort', () => {
+    // 환경변수 방식 (PORT=X)
+    describe('환경변수 방식 (env)', () => {
+        it('next dev → PORT 환경변수', () => {
+            const result = injectPort('next dev', 3001);
+            expect(result.env.PORT).toBe('3001');
+            expect(result.command).toBe('next dev');
+            expect(result.toolName).toBe('next');
+            expect(result.injectionType).toBe('env');
+        });
+        it('npx next dev → PORT 환경변수', () => {
+            const result = injectPort('npx next dev', 3001);
+            expect(result.env.PORT).toBe('3001');
+            expect(result.toolName).toBe('next');
+        });
+        it('node server.js → PORT 환경변수', () => {
+            const result = injectPort('node server.js', 3001);
+            expect(result.env.PORT).toBe('3001');
+            expect(result.toolName).toBe('node');
+            expect(result.injectionType).toBe('env');
+        });
+        it('node index.js → PORT 환경변수', () => {
+            const result = injectPort('node index.js', 3001);
+            expect(result.env.PORT).toBe('3001');
+        });
+    });
+    // 플래그 방식 (--port X)
+    describe('플래그 방식 (flag)', () => {
+        it('vite → --port 플래그', () => {
+            const result = injectPort('vite', 3001);
+            expect(result.command).toBe('vite --port 3001');
+            expect(result.toolName).toBe('vite');
+            expect(result.injectionType).toBe('flag');
+        });
+        it('vite dev → --port 플래그', () => {
+            const result = injectPort('vite dev', 3001);
+            expect(result.command).toBe('vite dev --port 3001');
+            expect(result.toolName).toBe('vite');
+        });
+        it('npx vite → --port 플래그', () => {
+            const result = injectPort('npx vite', 3001);
+            expect(result.command).toBe('npx vite --port 3001');
+            expect(result.toolName).toBe('vite');
+        });
+        it('uvicorn main:app → --port 플래그', () => {
+            const result = injectPort('uvicorn main:app', 8001);
+            expect(result.command).toBe('uvicorn main:app --port 8001');
+            expect(result.toolName).toBe('uvicorn');
+            expect(result.injectionType).toBe('flag');
+        });
+        it('fastapi dev → --port 플래그', () => {
+            const result = injectPort('fastapi dev', 8001);
+            expect(result.command).toBe('fastapi dev --port 8001');
+            expect(result.toolName).toBe('fastapi');
+        });
+        it('flask run → --port 플래그', () => {
+            const result = injectPort('flask run', 5001);
+            expect(result.command).toBe('flask run --port 5001');
+            expect(result.toolName).toBe('flask');
+        });
+        it('npx http-server → -p 플래그', () => {
+            const result = injectPort('npx http-server', 8080);
+            expect(result.command).toBe('npx http-server -p 8080');
+            expect(result.toolName).toBe('http-server');
+        });
+        it('http-server → -p 플래그', () => {
+            const result = injectPort('http-server .', 8080);
+            expect(result.command).toBe('http-server . -p 8080');
+            expect(result.toolName).toBe('http-server');
+        });
+    });
+    // 인자 방식 (마지막 인자로 포트)
+    describe('인자 방식 (arg)', () => {
+        it('python -m http.server → 마지막 인자', () => {
+            const result = injectPort('python -m http.server', 8000);
+            expect(result.command).toBe('python -m http.server 8000');
+            expect(result.toolName).toBe('http.server');
+            expect(result.injectionType).toBe('arg');
+        });
+        it('python3 -m http.server → 마지막 인자', () => {
+            const result = injectPort('python3 -m http.server', 8000);
+            expect(result.command).toBe('python3 -m http.server 8000');
+            expect(result.toolName).toBe('http.server');
+        });
+        it('manage.py runserver → 포트 인자', () => {
+            const result = injectPort('python manage.py runserver', 8000);
+            expect(result.command).toBe('python manage.py runserver 8000');
+            expect(result.toolName).toBe('django');
+        });
+        it('./manage.py runserver → 포트 인자', () => {
+            const result = injectPort('./manage.py runserver', 8000);
+            expect(result.command).toBe('./manage.py runserver 8000');
+            expect(result.toolName).toBe('django');
+        });
+    });
+    // Fallback
+    describe('fallback (인식되지 않는 명령어)', () => {
+        it('인식 안 되는 명령어 → PORT 환경변수', () => {
+            const result = injectPort('my-custom-server', 3001);
+            expect(result.env.PORT).toBe('3001');
+            expect(result.command).toBe('my-custom-server');
+            expect(result.toolName).toBe('unknown');
+            expect(result.injectionType).toBe('env');
+        });
+        it('임의의 스크립트 → PORT 환경변수', () => {
+            const result = injectPort('./start.sh', 3001);
+            expect(result.env.PORT).toBe('3001');
+            expect(result.toolName).toBe('unknown');
+        });
+    });
+    // 기존 포트 옵션이 있는 경우
+    describe('기존 포트 옵션 처리', () => {
+        it('vite --port 3000 → 포트 교체', () => {
+            const result = injectPort('vite --port 3000', 3001);
+            expect(result.command).toBe('vite --port 3001');
+        });
+        it('uvicorn main:app --port 8000 → 포트 교체', () => {
+            const result = injectPort('uvicorn main:app --port 8000', 8001);
+            expect(result.command).toBe('uvicorn main:app --port 8001');
+        });
+        it('python http.server 기존 포트 → 포트 교체', () => {
+            const result = injectPort('python3 -m http.server 3000', 3002);
+            expect(result.command).toBe('python3 -m http.server 3002');
+            expect(result.injectionType).toBe('arg');
+        });
+        it('flask run --port 5000 → 포트 교체', () => {
+            const result = injectPort('flask run --port 5000', 5001);
+            expect(result.command).toBe('flask run --port 5001');
+        });
+        it('fastapi dev --port 8000 → 포트 교체', () => {
+            const result = injectPort('fastapi dev --port 8000', 8001);
+            expect(result.command).toBe('fastapi dev --port 8001');
+        });
+        it('http-server -p 8080 → 포트 교체', () => {
+            const result = injectPort('http-server -p 8080', 9000);
+            expect(result.command).toBe('http-server -p 9000');
+        });
+        it('django runserver 기존 포트 → 포트 교체', () => {
+            const result = injectPort('python manage.py runserver 8000', 8001);
+            expect(result.command).toBe('python manage.py runserver 8001');
+        });
+        it('django runserver host:port → 포트 교체', () => {
+            const result = injectPort('python manage.py runserver 0.0.0.0:8000', 8001);
+            expect(result.command).toBe('python manage.py runserver 8001');
+        });
+    });
+    // npm run dev 방식
+    describe('npm run dev 방식', () => {
+        it('npm run dev → -- --port 플래그', () => {
+            const result = injectPort('npm run dev', 3001);
+            expect(result.command).toBe('npm run dev -- --port 3001');
+            expect(result.injectionType).toBe('flag');
+        });
+        it('npm run dev에 이미 포트가 지정된 경우 교체해야 한다', () => {
+            const result = injectPort('npm run dev -- --port 3000', 3001);
+            expect(result.command).toBe('npm run dev -- --port 3001');
+        });
+    });
+    // yarn/pnpm run dev 방식
+    describe('yarn/pnpm run dev 방식', () => {
+        it('yarn run dev → --port 플래그', () => {
+            const result = injectPort('yarn run dev', 3001);
+            expect(result.command).toBe('yarn run dev --port 3001');
+            expect(result.injectionType).toBe('flag');
+        });
+        it('pnpm run dev → --port 플래그', () => {
+            const result = injectPort('pnpm run dev', 3001);
+            expect(result.command).toBe('pnpm run dev --port 3001');
+            expect(result.injectionType).toBe('flag');
+        });
+        it('yarn dev (shortcut) → --port 플래그', () => {
+            const result = injectPort('yarn dev', 3001);
+            expect(result.command).toBe('yarn dev --port 3001');
+            expect(result.toolName).toBe('yarn-dev');
+        });
+        it('pnpm dev (shortcut) → --port 플래그', () => {
+            const result = injectPort('pnpm dev', 3001);
+            expect(result.command).toBe('pnpm dev --port 3001');
+            expect(result.toolName).toBe('pnpm-dev');
+        });
+    });
+    // Docker Compose 방식
+    describe('Docker Compose 방식 (compose)', () => {
+        it('docker compose up → compose 타입', () => {
+            const result = injectPort('docker compose up', 3001);
+            expect(result.injectionType).toBe('compose');
+            expect(result.toolName).toBe('docker-compose');
+            expect(result.command).toBe('docker compose up'); // 원본 유지
+        });
+        it('docker compose up -d → compose 타입', () => {
+            const result = injectPort('docker compose up -d', 3001);
+            expect(result.injectionType).toBe('compose');
+            expect(result.toolName).toBe('docker-compose');
+        });
+        it('docker compose up service1 service2 → compose 타입', () => {
+            const result = injectPort('docker compose up web api', 3001);
+            expect(result.injectionType).toBe('compose');
+            expect(result.toolName).toBe('docker-compose');
+        });
+        it('docker compose start → compose 타입', () => {
+            const result = injectPort('docker compose start web', 3001);
+            expect(result.injectionType).toBe('compose');
+            expect(result.toolName).toBe('docker-compose');
+        });
+        it('docker compose run → compose 타입', () => {
+            const result = injectPort('docker compose run api', 3001);
+            expect(result.injectionType).toBe('compose');
+            expect(result.toolName).toBe('docker-compose');
+        });
+    });
+});
+describe('getDefaultPort', () => {
+    describe('도구별 기본 포트 반환', () => {
+        it('next dev → 3000', () => {
+            expect(getDefaultPort('next dev')).toBe(3000);
+        });
+        it('node server.js → 3000', () => {
+            expect(getDefaultPort('node server.js')).toBe(3000);
+        });
+        it('vite → 5173', () => {
+            expect(getDefaultPort('vite')).toBe(5173);
+        });
+        it('npm run dev → 5173', () => {
+            expect(getDefaultPort('npm run dev')).toBe(5173);
+        });
+        it('yarn dev → 5173', () => {
+            expect(getDefaultPort('yarn dev')).toBe(5173);
+        });
+        it('pnpm dev → 5173', () => {
+            expect(getDefaultPort('pnpm dev')).toBe(5173);
+        });
+        it('uvicorn main:app → 8000', () => {
+            expect(getDefaultPort('uvicorn main:app')).toBe(8000);
+        });
+        it('fastapi dev main.py → 8000', () => {
+            expect(getDefaultPort('fastapi dev main.py')).toBe(8000);
+        });
+        it('flask run → 5000', () => {
+            expect(getDefaultPort('flask run')).toBe(5000);
+        });
+        it('http-server → 8080', () => {
+            expect(getDefaultPort('http-server .')).toBe(8080);
+        });
+        it('python -m http.server → 8000', () => {
+            expect(getDefaultPort('python -m http.server')).toBe(8000);
+        });
+        it('python manage.py runserver → 8000', () => {
+            expect(getDefaultPort('python manage.py runserver')).toBe(8000);
+        });
+        it('docker compose up -d → 0 (yml에서 파싱)', () => {
+            expect(getDefaultPort('docker compose up -d')).toBe(0);
+        });
+    });
+    describe('알 수 없는 명령어는 3000 반환', () => {
+        it('my-custom-server → 3000', () => {
+            expect(getDefaultPort('my-custom-server')).toBe(3000);
+        });
+        it('./start.sh → 3000', () => {
+            expect(getDefaultPort('./start.sh')).toBe(3000);
+        });
+    });
+});

package/dist/cli/core/process-manager.d.ts

@@ -0,0 +1,8 @@
+export declare function spawnProcess(name: string, command: string, env: Record<string, string>, cwd: string): Promise<number>;
+export declare function killProcess(pid: number): Promise<void>;
+export declare function isProcessRunning(pid: number): boolean;
+export interface ComposeServiceStatus {
+    serviceName: string;
+    running: boolean;
+}
+export declare function getComposeServicesStatus(cwd: string): Promise<Map<string, boolean>>;

package/dist/cli/core/process-manager.js

@@ -0,0 +1,84 @@
+import { spawn } from 'child_process';
+import treeKill from 'tree-kill';
+export async function spawnProcess(name, command, env, cwd) {
+    return new Promise((resolve, reject) => {
+        const [cmd, ...args] = command.split(' ').filter(Boolean);
+        const child = spawn(cmd, args, {
+            cwd,
+            env: { ...process.env, ...env },
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to start process: ${error.message}`));
+        });
+        // 프로세스가 시작되면 PID 반환
+        if (child.pid) {
+            child.unref();
+            resolve(child.pid);
+        }
+        else {
+            reject(new Error('Could not get process PID'));
+        }
+    });
+}
+export async function killProcess(pid) {
+    return new Promise((resolve, reject) => {
+        treeKill(pid, 'SIGTERM', (err) => {
+            if (err) {
+                // 프로세스가 이미 종료된 경우 무시
+                if (err.message?.includes('No such process') ||
+                    err.message?.includes('ESRCH')) {
+                    resolve();
+                    return;
+                }
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export function isProcessRunning(pid) {
+    try {
+        // kill(pid, 0)은 프로세스 존재 여부만 확인 (실제로 시그널을 보내지 않음)
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getComposeServicesStatus(cwd) {
+    const { execSync } = await import('child_process');
+    const statusMap = new Map();
+    try {
+        // docker compose ps -a --format json으로 서비스 상태 조회 (중지된 것 포함)
+        const output = execSync('docker compose ps -a --format json', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // 각 줄이 JSON 객체
+        const lines = output.trim().split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                const container = JSON.parse(line);
+                const serviceName = container.Service || container.Name;
+                const state = container.State || '';
+                const isRunning = state.toLowerCase() === 'running';
+                // 이미 running으로 설정된 서비스는 덮어쓰지 않음
+                if (!statusMap.has(serviceName) || isRunning) {
+                    statusMap.set(serviceName, isRunning);
+                }
+            }
+            catch {
+                // JSON 파싱 실패 시 무시
+            }
+        }
+    }
+    catch {
+        // docker compose ps 실패 시 빈 맵 반환
+    }
+    return statusMap;
+}

package/dist/cli/core/process-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/core/process-manager.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { spawnProcess, killProcess, isProcessRunning } from './process-manager.js';
+describe('process-manager', () => {
+    const spawnedPids = [];
+    afterEach(async () => {
+        // 테스트 후 생성된 프로세스 정리
+        for (const pid of spawnedPids) {
+            try {
+                await killProcess(pid);
+            }
+            catch {
+                // 이미 종료된 프로세스 무시
+            }
+        }
+        spawnedPids.length = 0;
+    });
+    it('프로세스를 생성하고 PID를 반환해야 한다', async () => {
+        const pid = await spawnProcess('test', 'node -e "setTimeout(() => {}, 30000)"', {}, process.cwd());
+        spawnedPids.push(pid);
+        expect(pid).toBeGreaterThan(0);
+    });
+    it('프로세스 생존 여부를 확인할 수 있어야 한다', async () => {
+        const pid = await spawnProcess('test', 'node -e "setTimeout(() => {}, 30000)"', {}, process.cwd());
+        spawnedPids.push(pid);
+        expect(isProcessRunning(pid)).toBe(true);
+        await killProcess(pid);
+        // 프로세스 종료 대기
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        expect(isProcessRunning(pid)).toBe(false);
+    });
+    it('환경변수를 프로세스에 전달할 수 있어야 한다', async () => {
+        // 환경변수 설정 후 즉시 종료되는 프로세스
+        const pid = await spawnProcess('test', 'node -e "console.log(process.env.TEST_VAR); setTimeout(() => {}, 30000)"', { TEST_VAR: 'hello' }, process.cwd());
+        spawnedPids.push(pid);
+        expect(pid).toBeGreaterThan(0);
+        expect(isProcessRunning(pid)).toBe(true);
+    });
+    it('존재하지 않는 PID에 대해 isProcessRunning이 false를 반환해야 한다', () => {
+        const nonExistentPid = 999999999;
+        expect(isProcessRunning(nonExistentPid)).toBe(false);
+    });
+    it('프로세스 종료 후 재확인 시 false를 반환해야 한다', async () => {
+        const pid = await spawnProcess('test', 'node -e "setTimeout(() => {}, 30000)"', {}, process.cwd());
+        spawnedPids.push(pid);
+        expect(isProcessRunning(pid)).toBe(true);
+        await killProcess(pid);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        expect(isProcessRunning(pid)).toBe(false);
+    });
+});

package/dist/cli/core/state.d.ts

@@ -0,0 +1,10 @@
+import type { State, ProcessMapping } from '../../shared/types.js';
+export declare function setStatePath(path: string): void;
+export declare function resetStatePath(): void;
+export declare function getStatePath(): string;
+export declare function loadState(): Promise<State>;
+export declare function saveState(state: State): Promise<void>;
+export declare function addProcess(name: string, mapping: ProcessMapping): Promise<void>;
+export declare function removeProcess(name: string): Promise<void>;
+export declare function getAllProcesses(): Promise<Record<string, ProcessMapping>>;
+export declare function getProcess(name: string): Promise<ProcessMapping | undefined>;

package/dist/cli/core/state.js

@@ -0,0 +1,65 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+const DEFAULT_STATE_DIR = join(homedir(), '.port-arranger');
+const DEFAULT_STATE_PATH = join(DEFAULT_STATE_DIR, 'state.json');
+let statePath = DEFAULT_STATE_PATH;
+// 테스트용 상태 파일 경로 설정
+export function setStatePath(path) {
+    statePath = path;
+}
+// 기본 경로로 리셋
+export function resetStatePath() {
+    statePath = DEFAULT_STATE_PATH;
+}
+export function getStatePath() {
+    return statePath;
+}
+const emptyState = { mappings: {} };
+export async function loadState() {
+    try {
+        const content = await readFile(statePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        // 파일이 없거나 읽기 실패 시 빈 상태 반환
+        if (error.code === 'ENOENT') {
+            return { ...emptyState };
+        }
+        throw error;
+    }
+}
+export async function saveState(state) {
+    // 디렉토리가 없으면 생성
+    const dir = dirname(statePath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(statePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+export async function addProcess(name, mapping) {
+    const state = await loadState();
+    const newState = {
+        ...state,
+        mappings: {
+            ...state.mappings,
+            [name]: mapping,
+        },
+    };
+    await saveState(newState);
+}
+export async function removeProcess(name) {
+    const state = await loadState();
+    const { [name]: _, ...rest } = state.mappings;
+    const newState = {
+        ...state,
+        mappings: rest,
+    };
+    await saveState(newState);
+}
+export async function getAllProcesses() {
+    const state = await loadState();
+    return state.mappings;
+}
+export async function getProcess(name) {
+    const state = await loadState();
+    return state.mappings[name];
+}