code-squad-cli 1.2.7 → 1.2.10

package/dist/flip/constants/filters.d.ts

@@ -0,0 +1,2 @@
+export declare const FILTERED_PATTERNS: Set<string>;
+export declare function isFiltered(name: string): boolean;

package/dist/flip/constants/filters.js

@@ -0,0 +1,30 @@
+// Patterns to filter for performance (O(1) lookup with Set)
+// These are system directories that users don't directly edit
+export const FILTERED_PATTERNS = new Set([
+    // Package managers
+    'node_modules',
+    'vendor',
+    '.pnpm-store',
+    // VCS internal
+    '.git',
+    '.svn',
+    '.hg',
+    // OS metadata
+    '.DS_Store',
+    'Thumbs.db',
+    // Build output
+    'dist',
+    'build',
+    'out',
+    // Cache directories
+    '.cache',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '__pycache__',
+    '.pytest_cache',
+    'target',
+]);
+export function isFiltered(name) {
+    return FILTERED_PATTERNS.has(name);
+}

package/dist/flip/events/SSEManager.d.ts

@@ -0,0 +1,10 @@
+import { Response } from 'express';
+import { SyncEvent } from './types.js';
+export declare class SSEManager {
+    private clients;
+    addClient(res: Response): void;
+    removeClient(res: Response): void;
+    broadcast(event: SyncEvent): void;
+    closeAll(): void;
+    get clientCount(): number;
+}

package/dist/flip/events/SSEManager.js

@@ -0,0 +1,28 @@
+export class SSEManager {
+    clients = new Set();
+    addClient(res) {
+        this.clients.add(res);
+        res.on('close', () => {
+            this.clients.delete(res);
+        });
+    }
+    removeClient(res) {
+        this.clients.delete(res);
+    }
+    broadcast(event) {
+        const data = JSON.stringify(event);
+        const message = `data: ${data}\n\n`;
+        this.clients.forEach(client => {
+            client.write(message);
+        });
+    }
+    closeAll() {
+        this.clients.forEach(client => {
+            client.end();
+        });
+        this.clients.clear();
+    }
+    get clientCount() {
+        return this.clients.size;
+    }
+}

package/dist/flip/events/types.d.ts

@@ -0,0 +1,11 @@
+export type FilesChangeEvent = {
+    type: 'files-changed';
+};
+export type FileContentEvent = {
+    type: 'file-changed';
+    path: string;
+};
+export type GitChangeEvent = {
+    type: 'git-changed';
+};
+export type SyncEvent = FilesChangeEvent | FileContentEvent | GitChangeEvent;

package/dist/flip/events/types.js

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

package/dist/flip/index.js

@@ -5,7 +5,7 @@ import fs from 'fs';
 import os from 'os';
 import { execSync } from 'child_process';
 import { confirm } from '@inquirer/prompts';
-import clipboardy from 'clipboardy';
+import { copyToClipboard } from './output/clipboard.js';
 const DEFAULT_PORT = 51234;
 function formatTime() {
     const now = new Date();
@@ -226,7 +226,7 @@ osascript ${applescriptPath} > /dev/null 2>&1
     console.log('└─────────────────────────────────────────────────┘');
     console.log('');
     // Copy path to clipboard
-    await clipboardy.write(shPath);
+    await copyToClipboard(shPath);
     console.log(`✓ Copied to clipboard: ${shPath}`);
     console.log('');
     await confirm({

package/dist/flip/output/autopaste.js

@@ -1,4 +1,4 @@
-import { execSync } from 'child_process';
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -70,9 +70,21 @@ async function pasteToOriginalSession(sessionId) {
         `;
     }
     try {
-        execSync(`osascript -e '${script.replace(/'/g, "'\"'\"'")}'`, {
-            stdio: 'pipe',
+        // Write script to temp file and execute via detached process
+        const tmpScript = path.join(os.tmpdir(), `flip-paste-${Date.now()}.scpt`);
+        fs.writeFileSync(tmpScript, script);
+        const child = spawn('osascript', [tmpScript], {
+            detached: true,
+            stdio: 'ignore',
         });
+        child.unref();
+        // Schedule cleanup
+        setTimeout(() => {
+            try {
+                fs.unlinkSync(tmpScript);
+            }
+            catch { }
+        }, 5000);
     }
     catch (e) {
         console.error('Failed to paste to iTerm:', e);

package/dist/flip/output/clipboard.js

@@ -1,7 +1,61 @@
-import clipboardy from 'clipboardy';
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 /**
  * Copy text to system clipboard
  */
 export async function copyToClipboard(text) {
-    await clipboardy.write(text);
+    if (process.platform === 'darwin') {
+        // Write to temp file first, then use pbcopy via shell
+        const tmpFile = path.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+        try {
+            fs.writeFileSync(tmpFile, text);
+            // Use a detached process to avoid EBADF
+            const child = spawn('sh', ['-c', `cat "${tmpFile}" | pbcopy && rm "${tmpFile}"`], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        catch (e) {
+            // Fallback: just leave the file for manual copy
+            console.log(`Output saved to: ${tmpFile}`);
+            throw e;
+        }
+    }
+    else if (process.platform === 'linux') {
+        const tmpFile = path.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+        fs.writeFileSync(tmpFile, text);
+        try {
+            const child = spawn('sh', ['-c', `cat "${tmpFile}" | xclip -selection clipboard && rm "${tmpFile}"`], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        catch {
+            try {
+                const child = spawn('sh', ['-c', `cat "${tmpFile}" | xsel --clipboard --input && rm "${tmpFile}"`], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+                child.unref();
+            }
+            catch (e) {
+                // Final fallback if both xclip and xsel fail
+                console.log(`Output saved to: ${tmpFile}`);
+                throw e;
+            }
+        }
+    }
+    else if (process.platform === 'win32') {
+        const tmpFile = path.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+        fs.writeFileSync(tmpFile, text);
+        const child = spawn('cmd', ['/c', `type "${tmpFile}" | clip && del "${tmpFile}"`], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
 }

package/dist/flip/routes/events.d.ts

@@ -0,0 +1,3 @@
+import type { Router as IRouter } from 'express';
+import { SSEManager } from '../events/SSEManager.js';
+export declare function createEventsRouter(sseManager: SSEManager): IRouter;

package/dist/flip/routes/events.js

@@ -0,0 +1,25 @@
+import { Router } from 'express';
+export function createEventsRouter(sseManager) {
+    const router = Router();
+    // GET /api/events - SSE endpoint for real-time updates
+    router.get('/', (req, res) => {
+        // Set SSE headers
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering
+        // Send initial connection message
+        res.write('data: {"type":"connected"}\n\n');
+        // Register client
+        sseManager.addClient(res);
+        // Keep connection alive with heartbeat
+        const heartbeat = setInterval(() => {
+            res.write(':heartbeat\n\n');
+        }, 30000);
+        // Cleanup on close (removeClient is handled by SSEManager)
+        req.on('close', () => {
+            clearInterval(heartbeat);
+        });
+    });
+    return router;
+}

package/dist/flip/routes/files.d.ts

@@ -10,9 +10,14 @@ export interface FilesResponse {
     root: string;
     tree: FileNode[];
 }
+export interface FileWithMtime {
+    path: string;
+    mtime: number;
+}
 export interface FlatFilesResponse {
-    files: string[];
+    files: FileWithMtime[];
     filteredDirs: string[];
+    recentFile: string | null;
 }
 declare const router: IRouter;
 export { router as filesRouter };

package/dist/flip/routes/files.js

@@ -1,36 +1,7 @@
 import { Router } from 'express';
 import fs from 'fs';
 import path from 'path';
-// Patterns to filter for performance (O(1) lookup with Set)
-// These are system directories that users don't directly edit
-const FILTERED_PATTERNS = new Set([
-    // Package managers
-    'node_modules',
-    'vendor',
-    '.pnpm-store',
-    // VCS internal
-    '.git',
-    '.svn',
-    '.hg',
-    // OS metadata
-    '.DS_Store',
-    'Thumbs.db',
-    // Build output
-    'dist',
-    'build',
-    'out',
-    // Cache directories
-    '.cache',
-    '.next',
-    '.nuxt',
-    'coverage',
-    '__pycache__',
-    '.pytest_cache',
-    'target',
-]);
-function isFiltered(name) {
-    return FILTERED_PATTERNS.has(name);
-}
+import { isFiltered } from '../constants/filters.js';
 const router = Router();
 function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
     if (depth > maxDepth)
@@ -78,7 +49,16 @@ function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = {
             continue; // Don't traverse filtered directories
         }
         if (entry.isFile()) {
-            result.files.push(relativePath);
+            try {
+                const stat = fs.statSync(fullPath);
+                result.files.push({
+                    path: relativePath,
+                    mtime: stat.mtimeMs,
+                });
+            }
+            catch {
+                // Skip files that can't be stat'd
+            }
         }
         else if (entry.isDirectory()) {
             collectFlatFiles(rootPath, fullPath, maxDepth, depth + 1, result);
@@ -96,15 +76,23 @@ router.get('/', (req, res) => {
     };
     res.json(response);
 });
-// GET /api/files/flat - Get flat list of all files
+// GET /api/files/flat - Get flat list of all files with mtime
 router.get('/flat', (req, res) => {
     const state = req.app.locals.state;
     const result = collectFlatFiles(state.cwd, state.cwd, 10);
-    result.files.sort();
+    // Sort files by path for consistent display
+    result.files.sort((a, b) => a.path.localeCompare(b.path));
     result.filteredDirs.sort();
+    // Find the most recently modified file
+    let recentFile = null;
+    if (result.files.length > 0) {
+        const mostRecent = result.files.reduce((prev, curr) => curr.mtime > prev.mtime ? curr : prev);
+        recentFile = mostRecent.path;
+    }
     const response = {
         files: result.files,
         filteredDirs: result.filteredDirs,
+        recentFile,
     };
     res.json(response);
 });

package/dist/flip/routes/static.js

@@ -8,8 +8,14 @@ export function createStaticRouter() {
     // Get __dirname equivalent in ESM
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    // Path to the built web-ui (relative to dist/ after bundling)
-    const distPath = path.resolve(__dirname, 'flip-ui/dist');
+    // First, check for the bundled path. This is more robust than checking the filename.
+    // - Bundled: dist/flip-ui/dist
+    let distPath = path.resolve(__dirname, 'flip-ui/dist');
+    // If the bundled path doesn't exist, fall back to the unbundled (development) path.
+    // - Unbundled: packages/cli/flip-ui/dist
+    if (!fs.existsSync(distPath)) {
+        distPath = path.resolve(__dirname, '../../../flip-ui/dist');
+    }
     // Check if dist exists (for development vs production)
     if (fs.existsSync(distPath)) {
         // Serve static files

package/dist/flip/routes/submit.js

@@ -18,19 +18,26 @@ router.post('/', async (req, res) => {
     }));
     // Format the output
     const formatted = formatComments(comments);
-    // Copy to clipboard
+    // Copy to clipboard and schedule paste only if copy succeeds
+    let clipboardSuccess = false;
     try {
         await copyToClipboard(formatted);
+        clipboardSuccess = true;
     }
     catch (e) {
         console.error('Failed to copy to clipboard:', e);
+        console.log('\n--- Output (copy manually) ---');
+        console.log(formatted);
+        console.log('--- End of output ---\n');
     }
-    // Schedule paste (will execute after server shuts down)
-    try {
-        await schedulePaste(body.session_id);
-    }
-    catch (e) {
-        console.error('Failed to schedule paste:', e);
+    // Schedule paste only if clipboard copy succeeded
+    if (clipboardSuccess) {
+        try {
+            await schedulePaste(body.session_id);
+        }
+        catch (e) {
+            console.error('Failed to schedule paste:', e);
+        }
     }
     // Send response before shutdown
     res.json({ status: 'ok' });

package/dist/flip/server/Server.d.ts

@@ -1,6 +1,6 @@
 export interface AppState {
     cwd: string;
-    resolve: ((output: string | null) => void) | null;
+    resolve: ((output: string | null) => void | Promise<void>) | null;
 }
 export declare class Server {
     private cwd;

package/dist/flip/server/Server.js

@@ -8,6 +8,9 @@ import { gitRouter } from '../routes/git.js';
 import { submitRouter } from '../routes/submit.js';
 import { cancelRouter } from '../routes/cancel.js';
 import { createStaticRouter } from '../routes/static.js';
+import { createEventsRouter } from '../routes/events.js';
+import { FileWatcher } from '../watcher/FileWatcher.js';
+import { SSEManager } from '../events/SSEManager.js';
 export class Server {
     cwd;
     port;
@@ -27,18 +30,37 @@ export class Server {
             app.use(express.json());
             // Store state in app locals
             app.locals.state = state;
+            // Initialize SSE manager and file watcher
+            const sseManager = new SSEManager();
+            const fileWatcher = new FileWatcher({ cwd: this.cwd });
+            // Set up watcher event handlers
+            fileWatcher.onFilesChanged(() => {
+                sseManager.broadcast({ type: 'files-changed' });
+            });
+            fileWatcher.onFileChanged((path) => {
+                sseManager.broadcast({ type: 'file-changed', path });
+            });
+            fileWatcher.onGitChanged(() => {
+                sseManager.broadcast({ type: 'git-changed' });
+            });
+            // Start watching
+            fileWatcher.start();
             // API routes
             app.use('/api/files', filesRouter);
             app.use('/api/file', fileRouter);
             app.use('/api/git', gitRouter);
             app.use('/api/submit', submitRouter);
             app.use('/api/cancel', cancelRouter);
+            app.use('/api/events', createEventsRouter(sseManager));
             // Static files (fallback to web-ui dist)
             app.use(createStaticRouter());
             const server = http.createServer(app);
             // Set up the shutdown mechanism
-            state.resolve = (output) => {
-                server.close();
+            state.resolve = async (output) => {
+                // Cleanup watcher and SSE connections
+                await fileWatcher.stop();
+                sseManager.closeAll();
+                await new Promise(res => server.close(() => res()));
                 resolve(output);
             };
             server.listen(this.port, '127.0.0.1', () => {

package/dist/flip/watcher/FileWatcher.d.ts

@@ -0,0 +1,29 @@
+export interface FileWatcherOptions {
+    cwd: string;
+    debounceMs?: number;
+}
+type EventCallback = () => void;
+type FileEventCallback = (filePath: string) => void;
+export declare class FileWatcher {
+    private watcher;
+    private cwd;
+    private debounceMs;
+    private filesChangedCallbacks;
+    private fileChangedCallbacks;
+    private gitChangedCallbacks;
+    private filesDebounceTimer;
+    private gitDebounceTimer;
+    private fileDebounceTimers;
+    constructor(options: FileWatcherOptions);
+    start(): void;
+    stop(): Promise<void>;
+    onFilesChanged(callback: EventCallback): void;
+    onFileChanged(callback: FileEventCallback): void;
+    onGitChanged(callback: EventCallback): void;
+    private handleFileEvent;
+    private handleDirEvent;
+    private emitFilesChanged;
+    private emitFileChanged;
+    private emitGitChanged;
+}
+export {};

package/dist/flip/watcher/FileWatcher.js

@@ -0,0 +1,128 @@
+import chokidar from 'chokidar';
+import * as path from 'path';
+import { FILTERED_PATTERNS } from '../constants/filters.js';
+export class FileWatcher {
+    watcher = null;
+    cwd;
+    debounceMs;
+    filesChangedCallbacks = [];
+    fileChangedCallbacks = [];
+    gitChangedCallbacks = [];
+    filesDebounceTimer = null;
+    gitDebounceTimer = null;
+    fileDebounceTimers = new Map();
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.debounceMs = options.debounceMs ?? 300;
+    }
+    start() {
+        const ignoredPatterns = Array.from(FILTERED_PATTERNS).map(pattern => {
+            // .git은 감시하되 내부 변경은 git-changed 이벤트로 처리
+            if (pattern === '.git') {
+                return undefined;
+            }
+            return `**/${pattern}/**`;
+        }).filter(Boolean);
+        this.watcher = chokidar.watch(this.cwd, {
+            ignored: ignoredPatterns,
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50,
+            },
+        });
+        this.watcher
+            .on('add', (filePath) => this.handleFileEvent(filePath, 'add'))
+            .on('unlink', (filePath) => this.handleFileEvent(filePath, 'unlink'))
+            .on('change', (filePath) => this.handleFileEvent(filePath, 'change'))
+            .on('addDir', (filePath) => this.handleDirEvent(filePath, 'addDir'))
+            .on('unlinkDir', (filePath) => this.handleDirEvent(filePath, 'unlinkDir'))
+            .on('error', (error) => console.error('Watcher error:', error));
+    }
+    async stop() {
+        if (this.filesDebounceTimer) {
+            clearTimeout(this.filesDebounceTimer);
+        }
+        if (this.gitDebounceTimer) {
+            clearTimeout(this.gitDebounceTimer);
+        }
+        Array.from(this.fileDebounceTimers.values()).forEach(timer => {
+            clearTimeout(timer);
+        });
+        this.fileDebounceTimers.clear();
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    onFilesChanged(callback) {
+        this.filesChangedCallbacks.push(callback);
+    }
+    onFileChanged(callback) {
+        this.fileChangedCallbacks.push(callback);
+    }
+    onGitChanged(callback) {
+        this.gitChangedCallbacks.push(callback);
+    }
+    handleFileEvent(filePath, event) {
+        const relativePath = path.relative(this.cwd, filePath);
+        // .git 내부 변경은 git-changed 이벤트
+        if (relativePath.startsWith('.git')) {
+            this.emitGitChanged();
+            return;
+        }
+        // 파일 추가/삭제는 트리 변경
+        if (event === 'add' || event === 'unlink') {
+            this.emitFilesChanged();
+        }
+        // 파일 내용 변경
+        if (event === 'change' || event === 'add') {
+            this.emitFileChanged(relativePath);
+        }
+        // 모든 파일 변경은 잠재적으로 git 상태에 영향
+        this.emitGitChanged();
+    }
+    handleDirEvent(dirPath, event) {
+        const relativePath = path.relative(this.cwd, dirPath);
+        // .git 내부는 무시
+        if (relativePath.startsWith('.git')) {
+            return;
+        }
+        // 디렉토리 변경은 트리 변경
+        this.emitFilesChanged();
+    }
+    emitFilesChanged() {
+        if (this.filesDebounceTimer) {
+            clearTimeout(this.filesDebounceTimer);
+        }
+        this.filesDebounceTimer = setTimeout(() => {
+            for (const callback of this.filesChangedCallbacks) {
+                callback();
+            }
+        }, this.debounceMs);
+    }
+    emitFileChanged(relativePath) {
+        const existingTimer = this.fileDebounceTimers.get(relativePath);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(() => {
+            this.fileDebounceTimers.delete(relativePath);
+            for (const callback of this.fileChangedCallbacks) {
+                callback(relativePath);
+            }
+        }, this.debounceMs);
+        this.fileDebounceTimers.set(relativePath, timer);
+    }
+    emitGitChanged() {
+        if (this.gitDebounceTimer) {
+            clearTimeout(this.gitDebounceTimer);
+        }
+        this.gitDebounceTimer = setTimeout(() => {
+            for (const callback of this.gitChangedCallbacks) {
+                callback();
+            }
+        }, this.debounceMs);
+    }
+}