code-squad-cli 1.2.16 → 1.2.17

package/dist/flip/index.js

@@ -1,9 +1,13 @@
-import { Server, findFreePort } from './server/Server.js';
+import { Server, findFreePort, findExistingServer } from './server/Server.js';
 import open from 'open';
 import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import http from 'http';
 import { execSync } from 'child_process';
 import { copyToClipboard } from './output/clipboard.js';
 const DEFAULT_PORT = 51234;
+const MAX_PORT = 51240;
 // Use stderr for info messages (stdout goes to terminal input in coprocess mode)
 const log = (...args) => console.error(...args);
 function formatTime() {
@@ -13,6 +17,51 @@ function formatTime() {
     const secs = String(now.getSeconds()).padStart(2, '0');
     return `${hours}:${mins}:${secs}`;
 }
+/**
+ * Generate a unique session ID from the current tty
+ */
+function getSessionId() {
+    try {
+        const tty = execSync('tty', { encoding: 'utf-8' }).trim();
+        return tty;
+    }
+    catch {
+        // Fallback to random ID if tty not available
+        return `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+}
+/**
+ * Register a session with the server
+ */
+async function registerSession(port, sessionId, cwd) {
+    return new Promise((resolve) => {
+        const data = JSON.stringify({ session_id: sessionId, cwd });
+        const req = http.request({
+            hostname: '127.0.0.1',
+            port,
+            path: '/api/session/register',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(data),
+            },
+            timeout: 5000,
+        }, (res) => {
+            let body = '';
+            res.on('data', chunk => body += chunk);
+            res.on('end', () => {
+                resolve(res.statusCode === 200);
+            });
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.write(data);
+        req.end();
+    });
+}
 export async function runFlip(args) {
     // Parse --session flag from anywhere in args
     let sessionId;
@@ -57,52 +106,88 @@ export async function runFlip(args) {
         command = 'oneshot';
     }
     const cwd = pathArg ? path.resolve(pathArg) : process.cwd();
+    // Get or generate session ID
+    const finalSessionId = sessionId || getSessionId();
     switch (command) {
         case 'setup': {
             await setupHotkey();
             return;
         }
         case 'serve': {
-            // Daemon mode: start server, keep running
-            const port = await findFreePort(DEFAULT_PORT);
-            log(`Server running at http://localhost:${port}`);
+            // Daemon mode: start or reuse server, keep running
+            let port = await findExistingServer(DEFAULT_PORT, MAX_PORT);
+            if (port) {
+                log(`[${formatTime()}] Found existing server at port ${port}`);
+            }
+            else {
+                port = await findFreePort(DEFAULT_PORT, MAX_PORT);
+                log(`[${formatTime()}] Starting new server at port ${port}`);
+                // Start server in background (non-blocking)
+                const server = new Server(port, { sessionTimeoutMs: 4000 });
+                server.run().catch(err => {
+                    log(`[${formatTime()}] Server error:`, err);
+                });
+            }
+            log(`[${formatTime()}] Server running at http://localhost:${port}`);
             log('Press Ctrl+C to stop');
             log('');
             log('To open browser, run: csq flip open');
             log(`Or use hotkey to open: open http://localhost:${port}`);
-            // Run server in loop (restarts after each submit/cancel)
-            while (true) {
-                const server = new Server(cwd, port);
-                const result = await server.run();
-                if (result) {
-                    log(`[${formatTime()}] Submitted ${result.length} characters`);
-                }
-                else {
-                    log(`[${formatTime()}] Cancelled`);
-                }
-                log(`[${formatTime()}] Ready for next session...`);
-            }
+            // Keep the process alive
+            await new Promise(() => { });
         }
         case 'open': {
             // Just open browser to existing server
-            const url = `http://localhost:${DEFAULT_PORT}`;
+            const port = await findExistingServer(DEFAULT_PORT, MAX_PORT);
+            if (!port) {
+                log('No csq flip server running.');
+                log('Start with: csq flip serve');
+                log('Or use: csq flip (one-shot mode)');
+                return;
+            }
+            // Register session
+            if (!await registerSession(port, finalSessionId, cwd)) {
+                log('Failed to register session with server');
+                return;
+            }
+            const url = `http://localhost:${port}?session=${encodeURIComponent(finalSessionId)}`;
             log(`Opening ${url} in browser...`);
             try {
                 await open(url);
             }
             catch (e) {
                 log('Failed to open browser:', e);
-                log('Is the server running? Start with: csq flip serve');
+                log(`Please open ${url} manually`);
             }
             break;
         }
         case 'oneshot':
         default: {
-            // Original behavior: start server, open browser, exit after submit/cancel
-            const port = await findFreePort(DEFAULT_PORT);
-            const url = sessionId
-                ? `http://localhost:${port}?session=${sessionId}`
-                : `http://localhost:${port}`;
+            // One-shot mode: find or start server, register session, open browser
+            let port = await findExistingServer(DEFAULT_PORT, MAX_PORT);
+            let serverPromise = null;
+            if (!port) {
+                port = await findFreePort(DEFAULT_PORT, MAX_PORT);
+                log(`Starting server at http://localhost:${port}...`);
+                // Start server with idle timeout
+                const server = new Server(port, {
+                    sessionTimeoutMs: 4000, // 4s (polling is 2s, so 2 missed polls = dead)
+                    idleTimeout: 5000,
+                });
+                // Run server and save promise
+                serverPromise = server.run();
+                // Wait a bit for server to start
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            else {
+                log(`Using existing server at http://localhost:${port}`);
+            }
+            // Register session
+            if (!await registerSession(port, finalSessionId, cwd)) {
+                log('Failed to register session with server');
+                return;
+            }
+            const url = `http://localhost:${port}?session=${encodeURIComponent(finalSessionId)}`;
             log(`Opening ${url} in browser...`);
             try {
                 await open(url);
@@ -111,13 +196,12 @@ export async function runFlip(args) {
                 log('Failed to open browser:', e);
                 log(`Please open ${url} manually`);
             }
-            const server = new Server(cwd, port);
-            const result = await server.run();
-            if (result) {
-                log(`\nSubmitted ${result.length} characters`);
-            }
-            else {
-                log('\nCancelled');
+            // If we started the server, wait for it to shutdown
+            if (serverPromise) {
+                log(`Session: ${finalSessionId}`);
+                log('Waiting for session to complete... (Ctrl+C to exit)');
+                await serverPromise;
+                log(`[${formatTime()}] Done`);
             }
             break;
         }
@@ -129,12 +213,12 @@ function printUsage() {
     console.error('Commands:');
     console.error('  serve [path]    Start server in daemon mode (keeps running)');
     console.error('  open            Open browser to existing server');
-    console.error('  setup           Setup Alt+; hotkey in shell config');
+    console.error('  setup           Setup hotkey in shell config');
     console.error('  (no command)    Start server + open browser (one-shot mode)');
     console.error('');
     console.error('Options:');
     console.error('  path               Directory to serve (default: current directory)');
-    console.error('  --session <uuid>   Session ID for paste-back tracking');
+    console.error('  --session <id>     Session ID for paste-back tracking (auto-generated from tty)');
 }
 async function setupHotkey() {
     let nodePath;
@@ -144,8 +228,47 @@ async function setupHotkey() {
     catch {
         nodePath = '/usr/local/bin/node';
     }
-    const csqPath = new URL(import.meta.url).pathname;
-    const command = `${nodePath} ${csqPath} flip`;
+    let csqPath;
+    try {
+        csqPath = execSync('which csq', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        csqPath = new URL(import.meta.url).pathname;
+    }
+    // Wrapper script that gets cwd from iTerm2 and passes to csq flip
+    const nodeDir = path.dirname(nodePath);
+    const wrapperScript = `#!/bin/bash
+# Add node to PATH (coprocess doesn't inherit shell PATH)
+export PATH="${nodeDir}:$PATH"
+
+# Get current directory from iTerm2
+CWD=$(osascript -e 'tell application "iTerm2" to tell current session of current tab of current window to return variable named "session.path"' 2>/dev/null)
+
+# Fallback: try to get from tty
+if [ -z "$CWD" ] || [ "$CWD" = "missing value" ]; then
+    TTY=$(osascript -e 'tell application "iTerm2" to tell current session of current tab of current window to return tty' 2>/dev/null)
+    if [ -n "$TTY" ]; then
+        PID=$(lsof -t "$TTY" 2>/dev/null | head -1)
+        if [ -n "$PID" ]; then
+            CWD=$(lsof -a -d cwd -p "$PID" -Fn 2>/dev/null | grep ^n | cut -c2-)
+        fi
+    fi
+fi
+
+# Run csq flip with cwd
+if [ -n "$CWD" ] && [ "$CWD" != "missing value" ]; then
+    exec ${csqPath} flip "$CWD"
+else
+    exec ${csqPath} flip
+fi
+`;
+    // Save wrapper script
+    const scriptDir = path.join(os.homedir(), '.config', 'csq');
+    const scriptPath = path.join(scriptDir, 'flip-hotkey.sh');
+    if (!fs.existsSync(scriptDir)) {
+        fs.mkdirSync(scriptDir, { recursive: true });
+    }
+    fs.writeFileSync(scriptPath, wrapperScript, { mode: 0o755 });
     console.log('');
     console.log('┌─────────────────────────────────────────────────┐');
     console.log('│           Flip Hotkey Setup (iTerm2)            │');
@@ -157,10 +280,10 @@ async function setupHotkey() {
     console.log('4. Action: "Run Coprocess"');
     console.log('5. Command (아래 자동 복사됨):');
     console.log('');
-    console.log(`   ${command}`);
+    console.log(`   ${scriptPath}`);
     console.log('');
     try {
-        await copyToClipboard(command);
+        await copyToClipboard(scriptPath);
         console.log('   (Copied to clipboard!)');
     }
     catch {

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

@@ -1,4 +1,7 @@
 import type { Router as IRouter } from 'express';
+export interface CancelRequest {
+    session_id: string;
+}
 export interface CancelResponse {
     status: string;
 }

package/dist/flip/routes/cancel.js

@@ -1,13 +1,16 @@
 import { Router } from 'express';
 const router = Router();
 // POST /api/cancel
-router.post('/', (req, res) => {
-    const state = req.app.locals.state;
-    // Send response before shutdown
-    res.json({ status: 'ok' });
-    // Trigger shutdown without output
-    if (state.resolve) {
-        state.resolve(null);
+router.post('/', async (req, res) => {
+    const sessionManager = req.app.locals.sessionManager;
+    const body = req.body;
+    if (!body.session_id) {
+        res.status(400).json({ error: 'Missing session_id' });
+        return;
     }
+    // Send response before cleanup
+    res.json({ status: 'ok' });
+    // Unregister the session
+    await sessionManager.unregisterSession(body.session_id);
 });
 export { router as cancelRouter };

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

@@ -0,0 +1,8 @@
+import type { Router as IRouter } from 'express';
+import { SessionManager } from '../session/SessionManager.js';
+export interface ChangesResponse {
+    filesChanged: boolean;
+    gitChanged: boolean;
+    changedFiles: string[];
+}
+export declare function createChangesRouter(sessionManager: SessionManager): IRouter;

package/dist/flip/routes/changes.js

@@ -0,0 +1,26 @@
+import { Router } from 'express';
+export function createChangesRouter(sessionManager) {
+    const router = Router();
+    // GET /api/changes?session_id=xxx - Get pending changes for a session (polling endpoint)
+    router.get('/', (req, res) => {
+        const sessionId = req.query.session_id;
+        if (!sessionId) {
+            res.status(400).json({ error: 'Missing session_id' });
+            return;
+        }
+        // Touch session to update activity
+        sessionManager.touchSession(sessionId);
+        const changes = sessionManager.consumePendingChanges(sessionId);
+        if (!changes) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        const response = {
+            filesChanged: changes.filesChanged,
+            gitChanged: changes.gitChanged,
+            changedFiles: Array.from(changes.changedFiles),
+        };
+        res.json(response);
+    });
+    return router;
+}

package/dist/flip/routes/file.js

@@ -127,18 +127,37 @@ function detectLanguage(filePath) {
     }
     return 'text';
 }
-// GET /api/file?path=<path>
+/**
+ * Get cwd from session_id query parameter
+ */
+function getCwdFromSession(req, res) {
+    const sessionId = req.query.session_id;
+    if (!sessionId) {
+        res.status(400).json({ error: 'Missing session_id parameter' });
+        return null;
+    }
+    const sessionManager = req.app.locals.sessionManager;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+        res.status(404).json({ error: 'Session not found' });
+        return null;
+    }
+    return session.cwd;
+}
+// GET /api/file?session_id=xxx&path=<path>
 router.get('/', (req, res) => {
-    const state = req.app.locals.state;
+    const cwd = getCwdFromSession(req, res);
+    if (!cwd)
+        return;
     const relativePath = req.query.path;
     if (!relativePath) {
         res.status(400).json({ error: 'Missing path parameter' });
         return;
     }
-    const filePath = path.join(state.cwd, relativePath);
+    const filePath = path.join(cwd, relativePath);
     // Security check: ensure path is within cwd
     const resolvedPath = path.resolve(filePath);
-    const resolvedCwd = path.resolve(state.cwd);
+    const resolvedCwd = path.resolve(cwd);
     if (!resolvedPath.startsWith(resolvedCwd)) {
         res.status(403).json({ error: 'Access denied' });
         return;

package/dist/flip/routes/files.js

@@ -66,20 +66,41 @@ function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = {
     }
     return result;
 }
-// GET /api/files - Get file tree structure
+/**
+ * Get cwd from session_id query parameter
+ */
+function getCwdFromSession(req, res) {
+    const sessionId = req.query.session_id;
+    if (!sessionId) {
+        res.status(400).json({ error: 'Missing session_id parameter' });
+        return null;
+    }
+    const sessionManager = req.app.locals.sessionManager;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+        res.status(404).json({ error: 'Session not found' });
+        return null;
+    }
+    return session.cwd;
+}
+// GET /api/files?session_id=xxx - Get file tree structure
 router.get('/', (req, res) => {
-    const state = req.app.locals.state;
-    const tree = buildFileTree(state.cwd, state.cwd, 10);
+    const cwd = getCwdFromSession(req, res);
+    if (!cwd)
+        return;
+    const tree = buildFileTree(cwd, cwd, 10);
     const response = {
-        root: state.cwd,
+        root: cwd,
         tree,
     };
     res.json(response);
 });
-// GET /api/files/flat - Get flat list of all files with mtime
+// GET /api/files/flat?session_id=xxx - 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);
+    const cwd = getCwdFromSession(req, res);
+    if (!cwd)
+        return;
+    const result = collectFlatFiles(cwd, cwd, 10);
     // Sort files by path for consistent display
     result.files.sort((a, b) => a.path.localeCompare(b.path));
     result.filteredDirs.sort();

package/dist/flip/routes/git.js

@@ -116,14 +116,33 @@ function createAddedFileDiff(content) {
             lines: diffLines,
         }];
 }
-// GET /api/git/status
+/**
+ * Get cwd from session_id query parameter
+ */
+function getCwdFromSession(req, res) {
+    const sessionId = req.query.session_id;
+    if (!sessionId) {
+        res.status(400).json({ error: 'Missing session_id parameter' });
+        return null;
+    }
+    const sessionManager = req.app.locals.sessionManager;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+        res.status(404).json({ error: 'Session not found' });
+        return null;
+    }
+    return session.cwd;
+}
+// GET /api/git/status?session_id=xxx
 router.get('/status', (req, res) => {
-    const state = req.app.locals.state;
+    const cwd = getCwdFromSession(req, res);
+    if (!cwd)
+        return;
     // Check if it's a git repository
     let isGitRepo = false;
     try {
         execSync('git rev-parse --git-dir', {
-            cwd: state.cwd,
+            cwd,
             stdio: 'pipe',
         });
         isGitRepo = true;
@@ -143,7 +162,7 @@ router.get('/status', (req, res) => {
     let unstaged = [];
     try {
         const output = execSync('git status --porcelain', {
-            cwd: state.cwd,
+            cwd,
             encoding: 'utf-8',
         });
         unstaged = parseGitStatus(output);
@@ -157,20 +176,22 @@ router.get('/status', (req, res) => {
     };
     res.json(response);
 });
-// GET /api/git/diff?path=<file>
+// GET /api/git/diff?session_id=xxx&path=<file>
 router.get('/diff', (req, res) => {
-    const state = req.app.locals.state;
+    const cwd = getCwdFromSession(req, res);
+    if (!cwd)
+        return;
     const relativePath = req.query.path;
     if (!relativePath) {
         res.status(400).json({ error: 'Missing path parameter' });
         return;
     }
-    const fullPath = path.join(state.cwd, relativePath);
+    const fullPath = path.join(cwd, relativePath);
     // Check git status for this file
     let fileStatus = 'modified';
     try {
         const statusOutput = execSync(`git status --porcelain -- "${relativePath}"`, {
-            cwd: state.cwd,
+            cwd,
             encoding: 'utf-8',
         });
         if (statusOutput.startsWith('??')) {
@@ -205,7 +226,7 @@ router.get('/diff', (req, res) => {
     // Get diff for tracked file
     try {
         const diffOutput = execSync(`git diff --no-color -- "${relativePath}"`, {
-            cwd: state.cwd,
+            cwd,
             encoding: 'utf-8',
         });
         if (!diffOutput.trim()) {

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

@@ -0,0 +1,6 @@
+import type { Router as IRouter } from 'express';
+export interface PingResponse {
+    id: string;
+    version: string;
+}
+export declare function createPingRouter(): IRouter;

package/dist/flip/routes/ping.js

@@ -0,0 +1,14 @@
+import { Router } from 'express';
+import { SERVER_ID } from '../server/Server.js';
+export function createPingRouter() {
+    const router = Router();
+    // GET /api/ping - Server identification for discovery
+    router.get('/', (_req, res) => {
+        const response = {
+            id: SERVER_ID,
+            version: '1.0.0',
+        };
+        res.json(response);
+    });
+    return router;
+}

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

@@ -0,0 +1,14 @@
+import type { Router as IRouter } from 'express';
+import { SessionManager } from '../session/SessionManager.js';
+export interface RegisterSessionRequest {
+    session_id: string;
+    cwd: string;
+}
+export interface RegisterSessionResponse {
+    status: string;
+    session_id: string;
+}
+export interface UnregisterSessionResponse {
+    status: string;
+}
+export declare function createSessionRouter(sessionManager: SessionManager): IRouter;

package/dist/flip/routes/session.js

@@ -0,0 +1,54 @@
+import { Router } from 'express';
+export function createSessionRouter(sessionManager) {
+    const router = Router();
+    // POST /api/session/register - Register a new session
+    router.post('/register', (req, res) => {
+        const body = req.body;
+        if (!body.session_id || !body.cwd) {
+            res.status(400).json({ error: 'Missing session_id or cwd' });
+            return;
+        }
+        // Clear idle timer on first session registration
+        if (!sessionManager.hasSessions && req.app.locals.clearIdleTimer) {
+            req.app.locals.clearIdleTimer();
+        }
+        sessionManager.registerSession(body.session_id, body.cwd);
+        const response = {
+            status: 'ok',
+            session_id: body.session_id,
+        };
+        res.json(response);
+    });
+    // POST /api/session/unregister - Unregister a session
+    router.post('/unregister', async (req, res) => {
+        const body = req.body;
+        if (!body.session_id) {
+            res.status(400).json({ error: 'Missing session_id' });
+            return;
+        }
+        await sessionManager.unregisterSession(body.session_id);
+        const response = {
+            status: 'ok',
+        };
+        res.json(response);
+    });
+    // GET /api/session/info?session_id=xxx - Get session info
+    router.get('/info', (req, res) => {
+        const sessionId = req.query.session_id;
+        if (!sessionId) {
+            res.status(400).json({ error: 'Missing session_id' });
+            return;
+        }
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.json({
+            session_id: session.id,
+            cwd: session.cwd,
+            lastActivity: session.lastActivity,
+        });
+    });
+    return router;
+}

package/dist/flip/routes/submit.js

@@ -3,8 +3,12 @@ import { formatComments, copyToClipboard, schedulePaste } from '../output/index.
 const router = Router();
 // POST /api/submit
 router.post('/', async (req, res) => {
-    const state = req.app.locals.state;
+    const sessionManager = req.app.locals.sessionManager;
     const body = req.body;
+    if (!body.session_id) {
+        res.status(400).json({ error: 'Missing session_id' });
+        return;
+    }
     if (!body.items || body.items.length === 0) {
         res.status(400).json({ error: 'No items to submit' });
         return;
@@ -39,11 +43,9 @@ router.post('/', async (req, res) => {
             console.error('Failed to schedule paste:', e);
         }
     }
-    // Send response before shutdown
+    // Send response before cleanup
     res.json({ status: 'ok' });
-    // Trigger shutdown with the output
-    if (state.resolve) {
-        state.resolve(formatted);
-    }
+    // Unregister the session
+    await sessionManager.unregisterSession(body.session_id);
 });
 export { router as submitRouter };