code-squad-cli 1.2.22 → 1.3.0

package/dist/dash/index.js

@@ -0,0 +1,216 @@
+import chalk from 'chalk';
+import * as path from 'path';
+import { confirm } from '@inquirer/prompts';
+import { TmuxAdapter } from './TmuxAdapter.js';
+import { GitAdapter } from '../adapters/GitAdapter.js';
+import { runInkDashboard } from './InkDashboard.js';
+import { loadAllWindows } from './windowHelpers.js';
+const tmuxAdapter = new TmuxAdapter();
+const gitAdapter = new GitAdapter();
+/**
+ * tmux 자동 설치
+ */
+async function installTmux() {
+    const platform = process.platform;
+    const { spawn } = await import('child_process');
+    let command;
+    let args;
+    if (platform === 'darwin') {
+        // macOS: brew 사용
+        console.log(chalk.dim('Installing tmux via Homebrew...'));
+        command = 'brew';
+        args = ['install', 'tmux'];
+    }
+    else if (platform === 'linux') {
+        // Linux: apt 또는 yum
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        // apt 사용 가능 여부 확인
+        try {
+            await execAsync('which apt-get');
+            console.log(chalk.dim('Installing tmux via apt...'));
+            command = 'sudo';
+            args = ['apt-get', 'install', '-y', 'tmux'];
+        }
+        catch {
+            // yum 사용
+            try {
+                await execAsync('which yum');
+                console.log(chalk.dim('Installing tmux via yum...'));
+                command = 'sudo';
+                args = ['yum', 'install', '-y', 'tmux'];
+            }
+            catch {
+                console.error(chalk.red('Could not find apt or yum package manager'));
+                return false;
+            }
+        }
+    }
+    else {
+        console.error(chalk.red(`Unsupported platform: ${platform}`));
+        console.error(chalk.dim('Please install tmux manually'));
+        return false;
+    }
+    return new Promise((resolve) => {
+        const proc = spawn(command, args, { stdio: 'inherit' });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                console.log(chalk.green('✓ tmux installed successfully'));
+                resolve(true);
+            }
+            else {
+                console.error(chalk.red(`Installation failed with code ${code}`));
+                resolve(false);
+            }
+        });
+        proc.on('error', (error) => {
+            console.error(chalk.red(`Installation error: ${error.message}`));
+            resolve(false);
+        });
+    });
+}
+/**
+ * 대시보드 모드 실행
+ */
+export async function runDash(workspaceRoot) {
+    const repoName = path.basename(workspaceRoot);
+    // tmux 설치 확인
+    if (!await tmuxAdapter.isTmuxAvailable()) {
+        console.log(chalk.yellow('tmux is not installed.'));
+        console.log(chalk.dim('tmux is required for the dashboard mode.'));
+        console.log('');
+        const shouldInstall = await confirm({
+            message: 'Would you like to install tmux now?',
+            default: true,
+        });
+        if (shouldInstall) {
+            const success = await installTmux();
+            if (!success) {
+                console.error(chalk.red('\nFailed to install tmux.'));
+                console.error(chalk.dim('Please install manually:'));
+                console.error(chalk.dim('  macOS: brew install tmux'));
+                console.error(chalk.dim('  Ubuntu: sudo apt install tmux'));
+                process.exit(1);
+            }
+            console.log('');
+        }
+        else {
+            console.log(chalk.dim('\nTo use dashboard mode, install tmux:'));
+            console.error(chalk.dim('  macOS: brew install tmux'));
+            console.error(chalk.dim('  Ubuntu: sudo apt install tmux'));
+            console.log(chalk.dim('\nOr use legacy mode: csq --legacy'));
+            process.exit(0);
+        }
+    }
+    // tmux 세션 내부인지 확인
+    if (!tmuxAdapter.isInsideTmux()) {
+        // tmux 세션 외부에서 실행됨 → 새 세션 생성 또는 기존 세션에 attach
+        const sessionName = `csq-${repoName}`;
+        try {
+            // 기존 세션 확인
+            const isNewSession = await tmuxAdapter.ensureSession(sessionName, workspaceRoot);
+            // UX 설정 적용 (마우스 모드, 테두리 강조 등)
+            await tmuxAdapter.applyUXSettings();
+            // 현재 실행 중인 스크립트의 절대 경로 사용
+            const scriptPath = process.argv[1];
+            const nodeCmd = `node "${scriptPath}"`;
+            if (isNewSession) {
+                console.log(chalk.dim('Starting new tmux session...'));
+                // 세션 내에서 같은 스크립트 재실행
+                await tmuxAdapter.sendKeys(`${sessionName}:0`, nodeCmd);
+                await tmuxAdapter.sendEnter(`${sessionName}:0`);
+            }
+            else {
+                console.log(chalk.dim('Restoring dashboard...'));
+                // Kill leftover dashboard window at index 0 if it exists
+                try {
+                    await tmuxAdapter.killWindow(`${sessionName}:0`);
+                }
+                catch {
+                    // Window 0 may not exist, ignore
+                }
+                // 기존 세션에 대시보드 window를 맨 앞에 생성
+                await tmuxAdapter.createWindowAtIndex(sessionName, 0, workspaceRoot);
+                // Make window 0 the active window so csq's tmux commands target it
+                await tmuxAdapter.selectWindow(`${sessionName}:0`);
+                // 새 window에서 csq 재실행
+                await tmuxAdapter.sendKeys(`${sessionName}:0`, nodeCmd);
+                await tmuxAdapter.sendEnter(`${sessionName}:0`);
+            }
+            // attach
+            const { spawn } = await import('child_process');
+            const tmux = spawn('tmux', ['attach-session', '-t', sessionName], {
+                stdio: 'inherit',
+            });
+            await new Promise((resolve, reject) => {
+                tmux.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`tmux exited with code ${code}`));
+                    }
+                });
+                tmux.on('error', reject);
+            });
+        }
+        catch (error) {
+            console.error(chalk.red(`Failed to start tmux session: ${error.message}`));
+            process.exit(1);
+        }
+        return;
+    }
+    // tmux 세션 내부에서 실행됨 → 대시보드 UI 실행
+    console.clear();
+    console.log(chalk.bold.cyan('Code Squad Dashboard'));
+    console.log(chalk.dim('Setting up layout...'));
+    // UX 설정 적용 (마우스 모드, 테두리 강조 등)
+    await tmuxAdapter.applyUXSettings();
+    try {
+        // 현재 pane ID 저장 (대시보드 pane)
+        const dashPaneId = await tmuxAdapter.getCurrentPaneId();
+        if (!dashPaneId) {
+            throw new Error('Could not get current pane ID');
+        }
+        // 현재 window index 저장 (대시보드 window)
+        const dashWindowIndex = await tmuxAdapter.getCurrentWindowIndex();
+        if (dashWindowIndex === null) {
+            throw new Error('Could not get current window index');
+        }
+        // 대시보드 pane 고정 리사이즈 훅 설정
+        await tmuxAdapter.setDashboardResizeHook(dashPaneId, 35);
+        // 윈도우 목록 로드 (대시보드 제외)
+        const windows = await loadAllWindows(tmuxAdapter, dashWindowIndex);
+        // 현재 브랜치 조회
+        const currentBranch = await gitAdapter.getCurrentBranch(workspaceRoot);
+        // 초기 레이아웃 설정: 좌측에 대시보드(20%), 우측에 터미널(80%)
+        const initialTerminalPaneId = await tmuxAdapter.splitWindow('v', workspaceRoot, 80);
+        // 대시보드 pane으로 포커스 복귀
+        await tmuxAdapter.selectPane(dashPaneId);
+        // splitWindow triggers async SIGWINCH signals from the resize hook cascade.
+        // Wait briefly for them to settle, then sync process.stdout.columns with the
+        // actual pane width so Ink calculates line counts correctly on first render.
+        await new Promise(resolve => setTimeout(resolve, 50));
+        process.stdout.columns = await tmuxAdapter.getPaneWidth(dashPaneId);
+        process.stdout.rows = await tmuxAdapter.getPaneHeight(dashPaneId);
+        console.clear();
+        // 대시보드 UI 실행 (Ink)
+        // This never returns - the dashboard keeps running until tmux session is killed
+        // When user presses 'q', the dashboard calls detachClient() directly
+        const paneHeight = await tmuxAdapter.getPaneHeight(dashPaneId);
+        await runInkDashboard({
+            workspaceRoot,
+            repoName,
+            currentBranch,
+            initialWindows: windows,
+            tmuxAdapter,
+            dashWindowIndex,
+            paneHeight,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red(`Dashboard error: ${error.message}`));
+        process.exit(1);
+    }
+}

package/dist/dash/pathUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ~ 를 홈 디렉토리로 확장
+ */
+export declare function expandTilde(p: string): string;
+/**
+ * 경로를 parentDir + leafPrefix로 분리 (자동완성용)
+ */
+export declare function splitPathForCompletion(p: string): {
+    parentDir: string;
+    leafPrefix: string;
+};
+/**
+ * 긴 경로를 maxLen 이하로 축약 (앞부분을 ...로 대체)
+ */
+export declare function truncatePath(p: string, maxLen: number): string;
+export type PathStatus = 'valid' | 'creatable' | 'invalid';
+export interface PathValidationResult {
+    status: PathStatus;
+    isGitRepo: boolean;
+}
+/**
+ * 경로 유효성 검사
+ * - valid: 디렉토리가 존재
+ * - creatable: 부모가 존재하고 마지막 한 단계만 새로 생성 가능
+ * - invalid: 그 외
+ */
+export declare function validatePath(p: string): Promise<PathValidationResult>;

package/dist/dash/pathUtils.js

@@ -0,0 +1,70 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+import { GitAdapter } from '../adapters/GitAdapter.js';
+const gitAdapter = new GitAdapter();
+/**
+ * ~ 를 홈 디렉토리로 확장
+ */
+export function expandTilde(p) {
+    if (p === '~')
+        return os.homedir();
+    if (p.startsWith('~/'))
+        return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+/**
+ * 경로를 parentDir + leafPrefix로 분리 (자동완성용)
+ */
+export function splitPathForCompletion(p) {
+    const expanded = expandTilde(p);
+    if (expanded.endsWith('/')) {
+        return { parentDir: expanded, leafPrefix: '' };
+    }
+    return {
+        parentDir: path.dirname(expanded),
+        leafPrefix: path.basename(expanded),
+    };
+}
+/**
+ * 긴 경로를 maxLen 이하로 축약 (앞부분을 ...로 대체)
+ */
+export function truncatePath(p, maxLen) {
+    if (p.length <= maxLen)
+        return p;
+    return '...' + p.slice(p.length - maxLen + 3);
+}
+/**
+ * 경로 유효성 검사
+ * - valid: 디렉토리가 존재
+ * - creatable: 부모가 존재하고 마지막 한 단계만 새로 생성 가능
+ * - invalid: 그 외
+ */
+export async function validatePath(p) {
+    const expanded = expandTilde(p);
+    if (!expanded || !path.isAbsolute(expanded)) {
+        return { status: 'invalid', isGitRepo: false };
+    }
+    try {
+        const stat = await fs.promises.stat(expanded);
+        if (stat.isDirectory()) {
+            const isGitRepo = await gitAdapter.isGitRepository(expanded);
+            return { status: 'valid', isGitRepo };
+        }
+        return { status: 'invalid', isGitRepo: false };
+    }
+    catch {
+        // 존재하지 않음 — 부모가 존재하면 creatable
+        const parent = path.dirname(expanded);
+        try {
+            const parentStat = await fs.promises.stat(parent);
+            if (parentStat.isDirectory()) {
+                return { status: 'creatable', isGitRepo: false };
+            }
+        }
+        catch {
+            // 부모도 없음
+        }
+        return { status: 'invalid', isGitRepo: false };
+    }
+}

package/dist/dash/threadHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { ThreadInfo } from './types.js';
+/**
+ * worktree 스레드 생성
+ */
+export declare function createThread(workspaceRoot: string, name: string, rootOverride?: string): Promise<ThreadInfo>;
+/**
+ * worktree 스레드 삭제
+ */
+export declare function deleteThread(workspaceRoot: string, thread: ThreadInfo): Promise<void>;

package/dist/dash/threadHelpers.js

@@ -0,0 +1,37 @@
+import * as path from 'path';
+import { GitAdapter } from '../adapters/GitAdapter.js';
+import { loadConfig, getWorktreeCopyPatterns } from '../config.js';
+import { copyFilesWithPatterns } from '../fileUtils.js';
+const gitAdapter = new GitAdapter();
+/**
+ * worktree 스레드 생성
+ */
+export async function createThread(workspaceRoot, name, rootOverride) {
+    const baseRoot = rootOverride || workspaceRoot;
+    const repoName = path.basename(baseRoot);
+    const defaultBasePath = path.join(path.dirname(baseRoot), `${repoName}.worktree`);
+    const worktreePath = path.join(defaultBasePath, name);
+    // Git worktree 생성
+    await gitAdapter.createWorktree(worktreePath, name, baseRoot);
+    // 파일 복사
+    const configData = await loadConfig(baseRoot);
+    const patterns = getWorktreeCopyPatterns(configData);
+    if (patterns.length > 0) {
+        await copyFilesWithPatterns(baseRoot, worktreePath, patterns);
+    }
+    return {
+        id: worktreePath,
+        name,
+        path: worktreePath,
+        branch: name,
+    };
+}
+/**
+ * worktree 스레드 삭제
+ */
+export async function deleteThread(workspaceRoot, thread) {
+    await gitAdapter.removeWorktree(thread.path, workspaceRoot, true);
+    if (thread.branch) {
+        await gitAdapter.deleteBranch(thread.branch, workspaceRoot, true);
+    }
+}

package/dist/dash/types.d.ts

@@ -0,0 +1,42 @@
+import type { WorktreeInfo } from '@code-squad/core';
+/**
+ * tmux window 정보
+ */
+export interface TmuxWindowInfo {
+    windowId: string;
+    windowIndex: number;
+    name: string;
+    cwd: string;
+    isActive: boolean;
+    isGitRepo?: boolean;
+    worktreeBranch?: string;
+    projectRoot?: string;
+}
+/**
+ * 스레드 정보
+ */
+export interface ThreadInfo {
+    id: string;
+    name: string;
+    path: string;
+    branch?: string;
+}
+/**
+ * tmux pane 정보
+ */
+export interface PaneInfo {
+    id: string;
+    index: number;
+    worktreePath: string;
+    worktreeName: string;
+    active: boolean;
+}
+/**
+ * 경로 유효성 검사 상태
+ */
+export type PathStatus = 'valid' | 'creatable' | 'invalid';
+export interface PathValidation {
+    status: PathStatus;
+    isGitRepo: boolean;
+}
+export type { WorktreeInfo };

package/dist/dash/types.js

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

package/dist/dash/useDirectorySuggestions.d.ts

@@ -0,0 +1,23 @@
+export interface VisibleSuggestion {
+    name: string;
+    isSelected: boolean;
+}
+export interface DirectorySuggestions {
+    visibleSuggestions: VisibleSuggestion[];
+    hasMore: boolean;
+    isOpen: boolean;
+    triggerComplete: (inputPath: string) => Promise<string | null>;
+    selectNext: () => void;
+    selectPrev: () => void;
+    acceptSelected: (inputPath: string) => string | null;
+    clearSuggestions: () => void;
+}
+/**
+ * 디렉토리 자동완성 훅
+ * - Tab: triggerComplete → 매치 1개면 인라인 완성, 여러 개면 제안 목록 표시
+ * - Tab (목록 열림): selectNext → 다음 항목
+ * - ↑↓ (목록 열림): selectPrev/selectNext
+ * - Enter (목록 열림): acceptSelected → 선택 항목 적용
+ * - 문자 입력: clearSuggestions → 목록 닫기
+ */
+export declare function useDirectorySuggestions(): DirectorySuggestions;

package/dist/dash/useDirectorySuggestions.js

@@ -0,0 +1,136 @@
+import { useState, useRef, useCallback, useMemo } from 'react';
+import * as fs from 'fs';
+import * as os from 'os';
+import { splitPathForCompletion } from './pathUtils.js';
+const MAX_VISIBLE = 5;
+/**
+ * 디렉토리 자동완성 훅
+ * - Tab: triggerComplete → 매치 1개면 인라인 완성, 여러 개면 제안 목록 표시
+ * - Tab (목록 열림): selectNext → 다음 항목
+ * - ↑↓ (목록 열림): selectPrev/selectNext
+ * - Enter (목록 열림): acceptSelected → 선택 항목 적용
+ * - 문자 입력: clearSuggestions → 목록 닫기
+ */
+export function useDirectorySuggestions() {
+    const [suggestions, setSuggestions] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [isOpen, setIsOpen] = useState(false);
+    const requestIdRef = useRef(0);
+    const clearSuggestions = useCallback(() => {
+        setSuggestions([]);
+        setSelectedIndex(0);
+        setIsOpen(false);
+    }, []);
+    const triggerComplete = useCallback(async (inputPath) => {
+        const reqId = ++requestIdRef.current;
+        const { parentDir, leafPrefix } = splitPathForCompletion(inputPath);
+        let entries;
+        try {
+            const dirEntries = await fs.promises.readdir(parentDir, { withFileTypes: true });
+            entries = dirEntries
+                .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+                .filter(e => e.name.toLowerCase().startsWith(leafPrefix.toLowerCase()))
+                .map(e => e.name)
+                .sort();
+        }
+        catch {
+            return null;
+        }
+        // Stale check
+        if (reqId !== requestIdRef.current)
+            return null;
+        if (entries.length === 0) {
+            clearSuggestions();
+            return null;
+        }
+        if (entries.length === 1) {
+            // Single match — inline complete
+            clearSuggestions();
+            const completed = parentDir.endsWith('/')
+                ? parentDir + entries[0] + '/'
+                : parentDir + '/' + entries[0] + '/';
+            return collapseHome(completed);
+        }
+        // Multiple matches — store all, show scrolling window
+        const commonPrefix = findCommonPrefix(entries);
+        setSuggestions(entries);
+        setSelectedIndex(0);
+        setIsOpen(true);
+        if (commonPrefix.length > leafPrefix.length) {
+            const completed = parentDir.endsWith('/')
+                ? parentDir + commonPrefix
+                : parentDir + '/' + commonPrefix;
+            return collapseHome(completed);
+        }
+        return null;
+    }, [clearSuggestions]);
+    const selectNext = useCallback(() => {
+        setSelectedIndex(prev => (prev + 1) % Math.max(suggestions.length, 1));
+    }, [suggestions.length]);
+    const selectPrev = useCallback(() => {
+        setSelectedIndex(prev => (prev - 1 + Math.max(suggestions.length, 1)) % Math.max(suggestions.length, 1));
+    }, [suggestions.length]);
+    const acceptSelected = useCallback((inputPath) => {
+        if (!isOpen || suggestions.length === 0)
+            return null;
+        const selected = suggestions[selectedIndex];
+        if (!selected)
+            return null;
+        const { parentDir } = splitPathForCompletion(inputPath);
+        const completed = parentDir.endsWith('/')
+            ? parentDir + selected + '/'
+            : parentDir + '/' + selected + '/';
+        clearSuggestions();
+        return collapseHome(completed);
+    }, [isOpen, suggestions, selectedIndex, clearSuggestions]);
+    // Scrolling window: show MAX_VISIBLE items around selectedIndex
+    const visibleSuggestions = useMemo(() => {
+        if (suggestions.length === 0)
+            return [];
+        let start;
+        if (suggestions.length <= MAX_VISIBLE) {
+            start = 0;
+        }
+        else {
+            // Center the selected item, clamped to edges
+            start = Math.min(Math.max(0, selectedIndex - Math.floor(MAX_VISIBLE / 2)), suggestions.length - MAX_VISIBLE);
+        }
+        const end = Math.min(start + MAX_VISIBLE, suggestions.length);
+        return suggestions.slice(start, end).map(name => ({
+            name,
+            isSelected: name === suggestions[selectedIndex],
+        }));
+    }, [suggestions, selectedIndex]);
+    const hasMore = suggestions.length > MAX_VISIBLE;
+    return {
+        visibleSuggestions,
+        hasMore,
+        isOpen,
+        triggerComplete,
+        selectNext,
+        selectPrev,
+        acceptSelected,
+        clearSuggestions,
+    };
+}
+function findCommonPrefix(strs) {
+    if (strs.length === 0)
+        return '';
+    let prefix = strs[0];
+    for (let i = 1; i < strs.length; i++) {
+        while (!strs[i].toLowerCase().startsWith(prefix.toLowerCase())) {
+            prefix = prefix.slice(0, -1);
+            if (prefix === '')
+                return '';
+        }
+    }
+    return prefix;
+}
+function collapseHome(p) {
+    const home = os.homedir();
+    if (p === home)
+        return '~';
+    if (p.startsWith(home + '/'))
+        return '~' + p.slice(home.length);
+    return p;
+}

package/dist/dash/usePathValidation.d.ts

@@ -0,0 +1,9 @@
+import type { PathValidationResult } from './pathUtils.js';
+export interface PathValidationState {
+    validation: PathValidationResult | null;
+    isGitRepo: boolean;
+}
+/**
+ * 경로 유효성 검사 훅 (300ms 디바운스)
+ */
+export declare function usePathValidation(inputPath: string): PathValidationState;

package/dist/dash/usePathValidation.js

@@ -0,0 +1,34 @@
+import { useState, useEffect, useRef } from 'react';
+import { validatePath, expandTilde } from './pathUtils.js';
+/**
+ * 경로 유효성 검사 훅 (300ms 디바운스)
+ */
+export function usePathValidation(inputPath) {
+    const [validation, setValidation] = useState(null);
+    const [isGitRepo, setIsGitRepo] = useState(false);
+    const timerRef = useRef(null);
+    const requestIdRef = useRef(0);
+    useEffect(() => {
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        const expanded = expandTilde(inputPath);
+        if (!expanded || expanded.length < 2) {
+            setValidation(null);
+            setIsGitRepo(false);
+            return;
+        }
+        timerRef.current = setTimeout(async () => {
+            const reqId = ++requestIdRef.current;
+            const result = await validatePath(inputPath);
+            if (reqId !== requestIdRef.current)
+                return;
+            setValidation(result);
+            setIsGitRepo(result.isGitRepo);
+        }, 300);
+        return () => {
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+        };
+    }, [inputPath]);
+    return { validation, isGitRepo };
+}

package/dist/dash/windowHelpers.d.ts

@@ -0,0 +1,10 @@
+import type { TmuxWindowInfo } from './types.js';
+import type { TmuxAdapter } from './TmuxAdapter.js';
+/**
+ * 현재 세션의 모든 window 목록 조회 (대시보드 제외)
+ */
+export declare function loadAllWindows(tmuxAdapter: TmuxAdapter, dashWindowIndex: number): Promise<TmuxWindowInfo[]>;
+/**
+ * window 종료
+ */
+export declare function deleteWindowById(tmuxAdapter: TmuxAdapter, windowId: string): Promise<void>;

package/dist/dash/windowHelpers.js

@@ -0,0 +1,43 @@
+import { GitAdapter } from '../adapters/GitAdapter.js';
+const gitAdapter = new GitAdapter();
+/**
+ * 현재 세션의 모든 window 목록 조회 (대시보드 제외)
+ */
+export async function loadAllWindows(tmuxAdapter, dashWindowIndex) {
+    const rawWindows = await tmuxAdapter.listWindows();
+    // 대시보드 window 제외
+    const filteredWindows = rawWindows.filter(w => w.index !== dashWindowIndex);
+    // Git 정보 추가
+    const windowsWithGitInfo = await Promise.all(filteredWindows.map(async (w) => {
+        const isGitRepo = await gitAdapter.isGitRepository(w.cwd);
+        let worktreeBranch;
+        let projectRoot;
+        if (isGitRepo) {
+            try {
+                const context = await gitAdapter.getWorktreeContext(w.cwd);
+                worktreeBranch = context.branch ?? undefined;
+                projectRoot = context.mainRoot ?? undefined;
+            }
+            catch {
+                // ignore
+            }
+        }
+        return {
+            windowId: w.id,
+            windowIndex: w.index,
+            name: w.name,
+            cwd: w.cwd,
+            isActive: w.active,
+            isGitRepo,
+            worktreeBranch,
+            projectRoot,
+        };
+    }));
+    return windowsWithGitInfo;
+}
+/**
+ * window 종료
+ */
+export async function deleteWindowById(tmuxAdapter, windowId) {
+    await tmuxAdapter.killWindow(windowId);
+}