code-squad-cli 1.2.16 → 1.2.19

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // dist/index.js
 import * as path12 from "path";
-import * as fs10 from "fs";
-import * as os4 from "os";
+import * as fs11 from "fs";
+import * as os5 from "os";
 import * as crypto from "crypto";
 import chalk2 from "chalk";
 
@@ -533,18 +533,36 @@ function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = {
   }
   return result;
 }
+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;
+}
 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);
 });
 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);
   result.files.sort((a, b) => a.path.localeCompare(b.path));
   result.filteredDirs.sort();
   let recentFile = null;
@@ -686,16 +704,32 @@ function detectLanguage(filePath) {
   }
   return "text";
 }
+function getCwdFromSession2(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;
+}
 router2.get("/", (req, res) => {
-  const state = req.app.locals.state;
+  const cwd = getCwdFromSession2(req, res);
+  if (!cwd)
+    return;
   const relativePath = req.query.path;
   if (!relativePath) {
     res.status(400).json({ error: "Missing path parameter" });
     return;
   }
-  const filePath = path3.join(state.cwd, relativePath);
+  const filePath = path3.join(cwd, relativePath);
   const resolvedPath = path3.resolve(filePath);
-  const resolvedCwd = path3.resolve(state.cwd);
+  const resolvedCwd = path3.resolve(cwd);
   if (!resolvedPath.startsWith(resolvedCwd)) {
     res.status(403).json({ error: "Access denied" });
     return;
@@ -823,12 +857,28 @@ function createAddedFileDiff(content) {
     lines: diffLines
   }];
 }
+function getCwdFromSession3(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;
+}
 router3.get("/status", (req, res) => {
-  const state = req.app.locals.state;
+  const cwd = getCwdFromSession3(req, res);
+  if (!cwd)
+    return;
   let isGitRepo = false;
   try {
     execSync("git rev-parse --git-dir", {
-      cwd: state.cwd,
+      cwd,
       stdio: "pipe"
     });
     isGitRepo = true;
@@ -845,7 +895,7 @@ router3.get("/status", (req, res) => {
   let unstaged = [];
   try {
     const output = execSync("git status --porcelain", {
-      cwd: state.cwd,
+      cwd,
       encoding: "utf-8"
     });
     unstaged = parseGitStatus(output);
@@ -858,17 +908,19 @@ router3.get("/status", (req, res) => {
   res.json(response);
 });
 router3.get("/diff", (req, res) => {
-  const state = req.app.locals.state;
+  const cwd = getCwdFromSession3(req, res);
+  if (!cwd)
+    return;
   const relativePath = req.query.path;
   if (!relativePath) {
     res.status(400).json({ error: "Missing path parameter" });
     return;
   }
-  const fullPath = path4.join(state.cwd, relativePath);
+  const fullPath = path4.join(cwd, relativePath);
   let fileStatus = "modified";
   try {
     const statusOutput = execSync(`git status --porcelain -- "${relativePath}"`, {
-      cwd: state.cwd,
+      cwd,
       encoding: "utf-8"
     });
     if (statusOutput.startsWith("??")) {
@@ -896,7 +948,7 @@ router3.get("/diff", (req, res) => {
   }
   try {
     const diffOutput = execSync(`git diff --no-color -- "${relativePath}"`, {
-      cwd: state.cwd,
+      cwd,
       encoding: "utf-8"
     });
     if (!diffOutput.trim()) {
@@ -1070,8 +1122,12 @@ async function pasteToOriginalSession(sessionId) {
 // dist/flip/routes/submit.js
 var router4 = Router4();
 router4.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;
@@ -1101,20 +1157,21 @@ router4.post("/", async (req, res) => {
     }
   }
   res.json({ status: "ok" });
-  if (state.resolve) {
-    state.resolve(formatted);
-  }
+  await sessionManager.unregisterSession(body.session_id);
 });
 
 // dist/flip/routes/cancel.js
 import { Router as Router5 } from "express";
 var router5 = Router5();
-router5.post("/", (req, res) => {
-  const state = req.app.locals.state;
-  res.json({ status: "ok" });
-  if (state.resolve) {
-    state.resolve(null);
+router5.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;
   }
+  res.json({ status: "ok" });
+  await sessionManager.unregisterSession(body.session_id);
 });
 
 // dist/flip/routes/static.js
@@ -1149,28 +1206,97 @@ function createStaticRouter() {
   return router6;
 }
 
-// dist/flip/routes/events.js
+// dist/flip/routes/ping.js
 import { Router as Router7 } from "express";
-function createEventsRouter(sseManager) {
+function createPingRouter() {
   const router6 = Router7();
-  router6.get("/", (req, res) => {
-    res.setHeader("Content-Type", "text/event-stream");
-    res.setHeader("Cache-Control", "no-cache");
-    res.setHeader("Connection", "keep-alive");
-    res.setHeader("X-Accel-Buffering", "no");
-    res.write('data: {"type":"connected"}\n\n');
-    sseManager.addClient(res);
-    const heartbeat = setInterval(() => {
-      res.write(":heartbeat\n\n");
-    }, 3e4);
-    req.on("close", () => {
-      clearInterval(heartbeat);
-      res.end();
+  router6.get("/", (_req, res) => {
+    const response = {
+      id: SERVER_ID,
+      version: "1.0.0"
+    };
+    res.json(response);
+  });
+  return router6;
+}
+
+// dist/flip/routes/session.js
+import { Router as Router8 } from "express";
+function createSessionRouter(sessionManager) {
+  const router6 = Router8();
+  router6.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;
+    }
+    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);
+  });
+  router6.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);
+  });
+  router6.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
     });
   });
   return router6;
 }
 
+// dist/flip/routes/changes.js
+import { Router as Router9 } from "express";
+function createChangesRouter(sessionManager) {
+  const router6 = Router9();
+  router6.get("/", (req, res) => {
+    const sessionId = req.query.session_id;
+    if (!sessionId) {
+      res.status(400).json({ error: "Missing session_id" });
+      return;
+    }
+    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 router6;
+}
+
 // dist/flip/watcher/FileWatcher.js
 import chokidar from "chokidar";
 import * as path8 from "path";
@@ -1294,87 +1420,266 @@ var FileWatcher = class {
   }
 };
 
-// dist/flip/events/SSEManager.js
-var SSEManager = class {
-  clients = /* @__PURE__ */ new Set();
-  addClient(res) {
-    this.clients.add(res);
-    res.on("close", () => {
-      this.clients.delete(res);
-    });
+// dist/flip/session/SessionManager.js
+var log = (...args) => console.error(...args);
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  options;
+  constructor(options) {
+    this.options = options;
   }
-  removeClient(res) {
-    this.clients.delete(res);
+  /**
+   * Start the session manager (no-op, kept for API compatibility)
+   */
+  start() {
   }
-  broadcast(event) {
-    const data = JSON.stringify(event);
-    const message = `data: ${data}
-
-`;
-    this.clients.forEach((client) => {
-      client.write(message);
+  /**
+   * Stop the session manager and clean up all sessions
+   */
+  async stop() {
+    const stopPromises = Array.from(this.sessions.values()).map((session) => {
+      if (session.timeoutTimer) {
+        clearTimeout(session.timeoutTimer);
+      }
+      return session.watcher.stop();
     });
+    await Promise.all(stopPromises);
+    this.sessions.clear();
+  }
+  /**
+   * Register a new session or update existing one
+   */
+  registerSession(sessionId, cwd) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      this.resetSessionTimeout(sessionId);
+      if (existing.cwd !== cwd) {
+        existing.watcher.stop();
+        existing.cwd = cwd;
+        existing.watcher = this.createWatcher(sessionId, cwd);
+        existing.pendingChanges = this.createEmptyPendingChanges();
+      }
+      return existing;
+    }
+    const watcher = this.createWatcher(sessionId, cwd);
+    const session = {
+      id: sessionId,
+      cwd,
+      watcher,
+      pendingChanges: this.createEmptyPendingChanges(),
+      timeoutTimer: null
+    };
+    this.sessions.set(sessionId, session);
+    this.resetSessionTimeout(sessionId);
+    log(`[SessionManager] Session registered: ${sessionId} (cwd: ${cwd})`);
+    return session;
+  }
+  /**
+   * Get a session by ID and reset timeout
+   */
+  getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      this.resetSessionTimeout(sessionId);
+    }
+    return session;
+  }
+  /**
+   * Touch session to reset timeout (called on every API request)
+   */
+  touchSession(sessionId) {
+    this.resetSessionTimeout(sessionId);
+  }
+  /**
+   * Unregister a session (e.g., on cancel/submit/timeout)
+   */
+  async unregisterSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      if (session.timeoutTimer) {
+        clearTimeout(session.timeoutTimer);
+      }
+      await session.watcher.stop();
+      this.sessions.delete(sessionId);
+      log(`[SessionManager] Session unregistered: ${sessionId}`);
+      if (this.sessions.size === 0 && this.options.onAllSessionsGone) {
+        this.options.onAllSessionsGone();
+      }
+    }
   }
-  closeAll() {
-    this.clients.forEach((client) => {
-      client.end();
+  /**
+   * Get pending changes for a session and clear them
+   */
+  consumePendingChanges(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return null;
+    const changes = { ...session.pendingChanges };
+    changes.changedFiles = new Set(session.pendingChanges.changedFiles);
+    session.pendingChanges = this.createEmptyPendingChanges();
+    return changes;
+  }
+  /**
+   * Get number of active sessions
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * Check if any sessions exist
+   */
+  get hasSessions() {
+    return this.sessions.size > 0;
+  }
+  createWatcher(sessionId, cwd) {
+    const watcher = new FileWatcher({ cwd });
+    watcher.onFilesChanged(() => {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pendingChanges.filesChanged = true;
+      }
+    });
+    watcher.onFileChanged((filePath) => {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pendingChanges.changedFiles.add(filePath);
+      }
     });
-    this.clients.clear();
+    watcher.onGitChanged(() => {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pendingChanges.gitChanged = true;
+      }
+    });
+    watcher.start();
+    return watcher;
+  }
+  createEmptyPendingChanges() {
+    return {
+      filesChanged: false,
+      gitChanged: false,
+      changedFiles: /* @__PURE__ */ new Set()
+    };
   }
-  get clientCount() {
-    return this.clients.size;
+  /**
+   * Reset the timeout timer for a session.
+   * Called on every activity (register, poll, etc.)
+   */
+  resetSessionTimeout(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return;
+    if (session.timeoutTimer) {
+      clearTimeout(session.timeoutTimer);
+    }
+    session.timeoutTimer = setTimeout(() => {
+      log(`[SessionManager] Session timed out: ${sessionId}`);
+      this.unregisterSession(sessionId).catch((error) => {
+        log(`[SessionManager] Error during session unregister for ${sessionId}:`, error);
+      });
+    }, this.options.sessionTimeoutMs);
   }
 };
 
 // dist/flip/server/Server.js
+var log2 = (...args) => console.error(...args);
+var SERVER_ID = "csq-flip";
 var Server = class {
-  cwd;
   port;
-  constructor(cwd, port) {
-    this.cwd = cwd;
+  options;
+  app = null;
+  server = null;
+  sessionManager = null;
+  resolveShutdown = null;
+  constructor(port, options = {}) {
     this.port = port;
+    this.options = {
+      sessionTimeoutMs: options.sessionTimeoutMs ?? 3e4,
+      idleTimeout: options.idleTimeout ?? 0
+    };
   }
+  /**
+   * Start the server and return a promise that resolves when server shuts down
+   */
   async run() {
     return new Promise((resolve2) => {
-      const state = {
-        cwd: this.cwd,
-        resolve: null
-      };
-      const app = express2();
-      app.use(cors());
-      app.use(express2.json());
-      app.locals.state = state;
-      const sseManager = new SSEManager();
-      const fileWatcher = new FileWatcher({ cwd: this.cwd });
-      fileWatcher.onFilesChanged(() => {
-        sseManager.broadcast({ type: "files-changed" });
-      });
-      fileWatcher.onFileChanged((path13) => {
-        sseManager.broadcast({ type: "file-changed", path: path13 });
-      });
-      fileWatcher.onGitChanged(() => {
-        sseManager.broadcast({ type: "git-changed" });
+      this.resolveShutdown = resolve2;
+      this.app = express2();
+      this.app.use(cors());
+      this.app.use(express2.json());
+      this.sessionManager = new SessionManager({
+        sessionTimeoutMs: this.options.sessionTimeoutMs,
+        onAllSessionsGone: () => {
+          log2("[Server] All sessions gone, shutting down...");
+          this.shutdown();
+        }
       });
-      fileWatcher.start();
-      app.use("/api/files", router);
-      app.use("/api/file", router2);
-      app.use("/api/git", router3);
-      app.use("/api/submit", router4);
-      app.use("/api/cancel", router5);
-      app.use("/api/events", createEventsRouter(sseManager));
-      app.use(createStaticRouter());
-      const server = http.createServer(app);
-      state.resolve = async (output) => {
-        await fileWatcher.stop();
-        sseManager.closeAll();
-        await new Promise((res) => server.close(() => res()));
-        resolve2(output);
+      this.sessionManager.start();
+      this.app.locals.sessionManager = this.sessionManager;
+      this.app.use("/api/ping", createPingRouter());
+      this.app.use("/api/session", createSessionRouter(this.sessionManager));
+      this.app.use("/api/changes", createChangesRouter(this.sessionManager));
+      this.app.use("/api/files", router);
+      this.app.use("/api/file", router2);
+      this.app.use("/api/git", router3);
+      this.app.use("/api/submit", router4);
+      this.app.use("/api/cancel", router5);
+      this.app.use(createStaticRouter());
+      this.server = http.createServer(this.app);
+      const signalHandler = () => {
+        log2("\nShutting down...");
+        this.shutdown();
       };
-      server.listen(this.port, "127.0.0.1", () => {
-        console.error(`Server running at http://localhost:${this.port}`);
+      process.on("SIGINT", signalHandler);
+      process.on("SIGTERM", signalHandler);
+      let idleTimer = null;
+      if (this.options.idleTimeout && this.options.idleTimeout > 0) {
+        idleTimer = setTimeout(() => {
+          if (!this.sessionManager?.hasSessions) {
+            log2("\nNo session registered, shutting down...");
+            this.shutdown();
+          }
+        }, this.options.idleTimeout);
+      }
+      this.app.locals.idleTimer = idleTimer;
+      this.app.locals.clearIdleTimer = () => {
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+          idleTimer = null;
+          this.app.locals.idleTimer = null;
+        }
+      };
+      this.server.listen(this.port, "127.0.0.1", () => {
+        log2(`[Server] Running at http://localhost:${this.port}`);
       });
     });
   }
+  /**
+   * Shutdown the server gracefully
+   */
+  async shutdown() {
+    if (!this.server)
+      return;
+    if (this.app?.locals.idleTimer) {
+      clearTimeout(this.app.locals.idleTimer);
+    }
+    if (this.sessionManager) {
+      await this.sessionManager.stop();
+    }
+    await new Promise((res) => {
+      this.server.close(() => res());
+    });
+    log2("[Server] Shutdown complete");
+    if (this.resolveShutdown) {
+      this.resolveShutdown();
+    }
+  }
+  /**
+   * Get the session manager
+   */
+  getSessionManager() {
+    return this.sessionManager;
+  }
 };
 async function findFreePort(preferred, maxPort = 65535) {
   return new Promise((resolve2, reject) => {
@@ -1395,13 +1700,53 @@ async function findFreePort(preferred, maxPort = 65535) {
     });
   });
 }
+async function isFlipServerRunning(port, timeoutMs = 1e3) {
+  return new Promise((resolve2) => {
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port,
+      path: "/api/ping",
+      method: "GET",
+      timeout: timeoutMs
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          resolve2(json.id === SERVER_ID);
+        } catch {
+          resolve2(false);
+        }
+      });
+    });
+    req.on("error", () => resolve2(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(false);
+    });
+    req.end();
+  });
+}
+async function findExistingServer(startPort, endPort) {
+  for (let port = startPort; port <= endPort; port++) {
+    if (await isFlipServerRunning(port)) {
+      return port;
+    }
+  }
+  return null;
+}
 
 // dist/flip/index.js
 import open from "open";
 import path9 from "path";
+import fs8 from "fs";
+import os3 from "os";
+import http2 from "http";
 import { execSync as execSync2 } from "child_process";
 var DEFAULT_PORT = 51234;
-var log = (...args) => console.error(...args);
+var MAX_PORT = 51240;
+var log3 = (...args) => console.error(...args);
 function formatTime() {
   const now = /* @__PURE__ */ new Date();
   const hours = String(now.getHours()).padStart(2, "0");
@@ -1409,6 +1754,43 @@ function formatTime() {
   const secs = String(now.getSeconds()).padStart(2, "0");
   return `${hours}:${mins}:${secs}`;
 }
+function getSessionId() {
+  try {
+    const tty = execSync2("tty", { encoding: "utf-8" }).trim();
+    return tty;
+  } catch {
+    return `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+}
+async function registerSession(port, sessionId, cwd) {
+  return new Promise((resolve2) => {
+    const data = JSON.stringify({ session_id: sessionId, cwd });
+    const req = http2.request({
+      hostname: "127.0.0.1",
+      port,
+      path: "/api/session/register",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data)
+      },
+      timeout: 5e3
+    }, (res) => {
+      let body = "";
+      res.on("data", (chunk) => body += chunk);
+      res.on("end", () => {
+        resolve2(res.statusCode === 200);
+      });
+    });
+    req.on("error", () => resolve2(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(false);
+    });
+    req.write(data);
+    req.end();
+  });
+}
 async function runFlip(args) {
   let sessionId;
   const sessionIdx = args.indexOf("--session");
@@ -1449,58 +1831,88 @@ async function runFlip(args) {
     command = "oneshot";
   }
   const cwd = pathArg ? path9.resolve(pathArg) : process.cwd();
+  const finalSessionId = sessionId || getSessionId();
   switch (command) {
     case "setup": {
       await setupHotkey();
       return;
     }
     case "serve": {
-      const port = await findFreePort(DEFAULT_PORT);
-      log(`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}`);
-      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...`);
+      let port = await findExistingServer(DEFAULT_PORT, MAX_PORT);
+      if (port) {
+        log3(`[${formatTime()}] Found existing server at port ${port}`);
+      } else {
+        port = await findFreePort(DEFAULT_PORT, MAX_PORT);
+        log3(`[${formatTime()}] Starting new server at port ${port}`);
+        const server = new Server(port, { sessionTimeoutMs: 4e3 });
+        server.run().catch((err) => {
+          log3(`[${formatTime()}] Server error:`, err);
+        });
       }
+      log3(`[${formatTime()}] Server running at http://localhost:${port}`);
+      log3("Press Ctrl+C to stop");
+      log3("");
+      log3("To open browser, run: csq flip open");
+      log3(`Or use hotkey to open: open http://localhost:${port}`);
+      await new Promise(() => {
+      });
     }
     case "open": {
-      const url = `http://localhost:${DEFAULT_PORT}`;
-      log(`Opening ${url} in browser...`);
+      const port = await findExistingServer(DEFAULT_PORT, MAX_PORT);
+      if (!port) {
+        log3("No csq flip server running.");
+        log3("Start with: csq flip serve");
+        log3("Or use: csq flip (one-shot mode)");
+        return;
+      }
+      if (!await registerSession(port, finalSessionId, cwd)) {
+        log3("Failed to register session with server");
+        return;
+      }
+      const url = `http://localhost:${port}?session=${encodeURIComponent(finalSessionId)}`;
+      log3(`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");
+        log3("Failed to open browser:", e);
+        log3(`Please open ${url} manually`);
       }
       break;
     }
     case "oneshot":
     default: {
-      const port = await findFreePort(DEFAULT_PORT);
-      const url = sessionId ? `http://localhost:${port}?session=${sessionId}` : `http://localhost:${port}`;
-      log(`Opening ${url} in browser...`);
+      let port = await findExistingServer(DEFAULT_PORT, MAX_PORT);
+      let serverPromise = null;
+      if (!port) {
+        port = await findFreePort(DEFAULT_PORT, MAX_PORT);
+        log3(`Starting server at http://localhost:${port}...`);
+        const server = new Server(port, {
+          sessionTimeoutMs: 4e3,
+          // 4s (polling is 2s, so 2 missed polls = dead)
+          idleTimeout: 5e3
+        });
+        serverPromise = server.run();
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
+      } else {
+        log3(`Using existing server at http://localhost:${port}`);
+      }
+      if (!await registerSession(port, finalSessionId, cwd)) {
+        log3("Failed to register session with server");
+        return;
+      }
+      const url = `http://localhost:${port}?session=${encodeURIComponent(finalSessionId)}`;
+      log3(`Opening ${url} in browser...`);
       try {
         await open(url);
       } catch (e) {
-        log("Failed to open browser:", e);
-        log(`Please open ${url} manually`);
+        log3("Failed to open browser:", e);
+        log3(`Please open ${url} manually`);
       }
-      const server = new Server(cwd, port);
-      const result = await server.run();
-      if (result) {
-        log(`
-Submitted ${result.length} characters`);
-      } else {
-        log("\nCancelled");
+      if (serverPromise) {
+        log3(`Session: ${finalSessionId}`);
+        log3("Waiting for session to complete... (Ctrl+C to exit)");
+        await serverPromise;
+        log3(`[${formatTime()}] Done`);
       }
       break;
     }
@@ -1512,12 +1924,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;
@@ -1526,8 +1938,44 @@ 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 = execSync2("which csq", { encoding: "utf-8" }).trim();
+  } catch {
+    csqPath = new URL(import.meta.url).pathname;
+  }
+  const nodeDir = path9.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
+`;
+  const scriptDir = path9.join(os3.homedir(), ".config", "csq");
+  const scriptPath = path9.join(scriptDir, "flip-hotkey.sh");
+  if (!fs8.existsSync(scriptDir)) {
+    fs8.mkdirSync(scriptDir, { recursive: true });
+  }
+  fs8.writeFileSync(scriptPath, wrapperScript, { mode: 493 });
   console.log("");
   console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
   console.log("\u2502           Flip Hotkey Setup (iTerm2)            \u2502");
@@ -1539,10 +1987,10 @@ async function setupHotkey() {
   console.log('4. Action: "Run Coprocess"');
   console.log("5. Command (\uC544\uB798 \uC790\uB3D9 \uBCF5\uC0AC\uB428):");
   console.log("");
-  console.log(`   ${command}`);
+  console.log(`   ${scriptPath}`);
   console.log("");
   try {
-    await copyToClipboard(command);
+    await copyToClipboard(scriptPath);
     console.log("   (Copied to clipboard!)");
   } catch {
   }
@@ -1550,13 +1998,13 @@ async function setupHotkey() {
 }
 
 // dist/config.js
-import * as fs8 from "fs";
-import * as os3 from "os";
+import * as fs9 from "fs";
+import * as os4 from "os";
 import * as path10 from "path";
-var GLOBAL_CONFIG_PATH = path10.join(os3.homedir(), ".code-squad", "config.json");
+var GLOBAL_CONFIG_PATH = path10.join(os4.homedir(), ".code-squad", "config.json");
 async function loadGlobalConfig() {
   try {
-    const content = await fs8.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
+    const content = await fs9.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -1587,7 +2035,7 @@ function getWorktreeCopyPatterns(config) {
 }
 
 // dist/fileUtils.js
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path11 from "path";
 import fg from "fast-glob";
 async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
@@ -1624,8 +2072,8 @@ async function copySingleFile(absolutePath, sourceRoot, destRoot) {
   const relativePath = path11.relative(sourceRoot, absolutePath);
   const destPath = path11.join(destRoot, relativePath);
   const destDir = path11.dirname(destPath);
-  await fs9.promises.mkdir(destDir, { recursive: true });
-  await fs9.promises.copyFile(absolutePath, destPath);
+  await fs10.promises.mkdir(destDir, { recursive: true });
+  await fs10.promises.copyFile(absolutePath, destPath);
 }
 
 // dist/index.js
@@ -1681,12 +2129,12 @@ function getProjectHash(workspaceRoot) {
 function getSessionsPath(workspaceRoot) {
   const projectHash = getProjectHash(workspaceRoot);
   const projectName = path12.basename(workspaceRoot);
-  return path12.join(os4.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
+  return path12.join(os5.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
 }
 async function loadLocalThreads(workspaceRoot) {
   const sessionsPath = getSessionsPath(workspaceRoot);
   try {
-    const content = await fs10.promises.readFile(sessionsPath, "utf-8");
+    const content = await fs11.promises.readFile(sessionsPath, "utf-8");
     const data = JSON.parse(content);
     return data.localThreads || [];
   } catch {
@@ -1696,8 +2144,8 @@ async function loadLocalThreads(workspaceRoot) {
 async function saveLocalThreads(workspaceRoot, threads) {
   const sessionsPath = getSessionsPath(workspaceRoot);
   const dir = path12.dirname(sessionsPath);
-  await fs10.promises.mkdir(dir, { recursive: true });
-  await fs10.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
+  await fs11.promises.mkdir(dir, { recursive: true });
+  await fs11.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
 }
 async function addLocalThread(workspaceRoot, name) {
   const threads = await loadLocalThreads(workspaceRoot);