codex-blocker 0.0.6 → 0.0.8

package/README.md

@@ -39,7 +39,8 @@ npx codex-blocker --help
 ## How It Works
 
 1. **Codex sessions** — The server tails Codex session logs under `~/.codex/sessions`
-   to detect activity.
+   to detect activity. It marks a session “working” on your prompt and “idle” on the
+   final assistant reply (tool calls don’t count as idle).
 
 2. **Server** — Runs on localhost and:
    - Tracks active Codex sessions

package/dist/bin.js

@@ -2,7 +2,7 @@
 import {
   DEFAULT_PORT,
   startServer
-} from "./chunk-FXDFFIXM.js";
+} from "./chunk-2Q6Z6NQH.js";
 
 // src/bin.ts
 import { createInterface } from "readline";

package/dist/{chunk-FXDFFIXM.js → chunk-2Q6Z6NQH.js}

@@ -2,13 +2,12 @@
 import { createServer } from "http";
 import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/types.ts
 var DEFAULT_PORT = 8765;
 var SESSION_TIMEOUT_MS = 5 * 60 * 1e3;
-var CODEX_ACTIVITY_IDLE_TIMEOUT_MS = 60 * 1e3;
 var CODEX_SESSIONS_SCAN_INTERVAL_MS = 2e3;
 
 // src/state.ts
@@ -142,9 +141,10 @@ var state = new SessionState();
 // src/codex.ts
 import { existsSync, createReadStream, promises as fs } from "fs";
 import { homedir } from "os";
-import { basename, dirname, join } from "path";
-var CODEX_HOME = process.env.CODEX_HOME ?? join(homedir(), ".codex");
-var CODEX_SESSIONS_DIR = join(CODEX_HOME, "sessions");
+import { join } from "path";
+
+// src/codex-parse.ts
+import { basename, dirname } from "path";
 function isRolloutFile(filePath) {
   const name = basename(filePath);
   return name === "rollout.jsonl" || /^rollout-.+\.jsonl$/.test(name);
@@ -183,6 +183,47 @@ function findFirstStringValue(obj, keys, maxDepth = 6) {
   }
   return void 0;
 }
+function parseCodexLine(line, sessionId) {
+  let currentSessionId = sessionId;
+  let previousSessionId;
+  let cwd;
+  let markWorking = false;
+  let markIdle = false;
+  try {
+    const payload = JSON.parse(line);
+    const entryType = typeof payload.type === "string" ? payload.type : void 0;
+    const innerPayload = payload.payload;
+    const innerType = innerPayload && typeof innerPayload === "object" ? innerPayload.type : void 0;
+    if (entryType === "session_meta") {
+      const metaId = innerPayload && typeof innerPayload === "object" ? innerPayload.id : void 0;
+      if (typeof metaId === "string" && metaId.length > 0 && metaId !== currentSessionId) {
+        previousSessionId = currentSessionId;
+        currentSessionId = metaId;
+      }
+    }
+    cwd = findFirstStringValue(innerPayload, ["cwd"]) ?? findFirstStringValue(payload, ["cwd"]);
+    const innerTypeString = typeof innerType === "string" ? innerType : void 0;
+    if (entryType === "event_msg" && innerTypeString === "user_message") {
+      markWorking = true;
+    }
+    if (entryType === "event_msg" && innerTypeString === "agent_message") {
+      markIdle = true;
+    }
+  } catch {
+  }
+  return {
+    sessionId: currentSessionId,
+    previousSessionId,
+    cwd,
+    markWorking,
+    markIdle
+  };
+}
+
+// src/codex.ts
+var DEFAULT_CODEX_HOME = join(homedir(), ".codex");
+var TAIL_MAX_BYTES = 64 * 1024;
+var TAIL_MAX_LINES = 200;
 async function listRolloutFiles(root) {
   const files = [];
   const entries = await fs.readdir(root, { withFileTypes: true });
@@ -196,6 +237,30 @@ async function listRolloutFiles(root) {
   }
   return files;
 }
+async function readTailLines(filePath, fileSize, maxBytes, maxLines) {
+  if (fileSize === 0) return [];
+  const start = Math.max(0, fileSize - maxBytes);
+  const end = Math.max(fileSize - 1, start);
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    const stream = createReadStream(filePath, { start, end });
+    stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    stream.on("error", reject);
+    stream.on("end", resolve);
+  });
+  let content = Buffer.concat(chunks).toString("utf-8");
+  let lines = content.split("\n");
+  if (start > 0 && content[0] !== "\n") {
+    lines = lines.slice(1);
+  }
+  if (lines.length > 0 && lines[lines.length - 1]?.trim() === "") {
+    lines.pop();
+  }
+  if (lines.length > maxLines) {
+    lines = lines.slice(-maxLines);
+  }
+  return lines.filter((line) => line.trim().length > 0);
+}
 async function readNewLines(filePath, fileState) {
   const stat = await fs.stat(filePath);
   if (stat.size < fileState.position) {
@@ -218,51 +283,17 @@ async function readNewLines(filePath, fileState) {
   fileState.remainder = content.endsWith("\n") ? "" : lines.pop() ?? "";
   return lines.filter((line) => line.trim().length > 0);
 }
-function handleLine(line, fileState) {
-  let sessionId = fileState.sessionId;
-  let cwd;
-  let shouldMarkWorking = false;
-  let shouldMarkIdle = false;
-  try {
-    const payload = JSON.parse(line);
-    const entryType = typeof payload.type === "string" ? payload.type : void 0;
-    const innerPayload = payload.payload;
-    const innerType = innerPayload && typeof innerPayload === "object" ? innerPayload.type : void 0;
-    if (entryType === "session_meta") {
-      const metaId = innerPayload && typeof innerPayload === "object" ? innerPayload.id : void 0;
-      if (typeof metaId === "string" && metaId.length > 0 && metaId !== sessionId) {
-        const previousId = sessionId;
-        fileState.sessionId = metaId;
-        sessionId = metaId;
-        state.removeSession(previousId);
-      }
-    }
-    cwd = findFirstStringValue(innerPayload, ["cwd"]) ?? findFirstStringValue(payload, ["cwd"]);
-    const innerTypeString = typeof innerType === "string" ? innerType : void 0;
-    if (entryType === "event_msg" && innerTypeString === "user_message") {
-      shouldMarkWorking = true;
-    }
-    if (entryType === "event_msg" && innerTypeString === "agent_message") {
-      shouldMarkIdle = true;
-    }
-  } catch {
-  }
-  state.markCodexSessionSeen(sessionId, cwd);
-  if (shouldMarkWorking) {
-    state.handleCodexActivity({
-      sessionId,
-      cwd,
-      idleTimeoutMs: CODEX_ACTIVITY_IDLE_TIMEOUT_MS
-    });
-  }
-  if (shouldMarkIdle) {
-    state.setCodexIdle(sessionId, cwd);
-  }
-}
 var CodexSessionWatcher = class {
   fileStates = /* @__PURE__ */ new Map();
   scanTimer = null;
   warnedMissing = false;
+  sessionsDir;
+  state;
+  constructor(state2, options) {
+    this.state = state2;
+    const base = process.env.CODEX_HOME ?? DEFAULT_CODEX_HOME;
+    this.sessionsDir = options?.sessionsDir ?? join(base, "sessions");
+  }
   start() {
     this.scan();
     this.scanTimer = setInterval(() => {
@@ -276,9 +307,9 @@ var CodexSessionWatcher = class {
     }
   }
   async scan() {
-    if (!existsSync(CODEX_SESSIONS_DIR)) {
+    if (!existsSync(this.sessionsDir)) {
       if (!this.warnedMissing) {
-        console.log(`Waiting for Codex sessions at ${CODEX_SESSIONS_DIR}`);
+        console.log(`Waiting for Codex sessions at ${this.sessionsDir}`);
         this.warnedMissing = true;
       }
       return;
@@ -286,7 +317,7 @@ var CodexSessionWatcher = class {
     this.warnedMissing = false;
     let files = [];
     try {
-      files = await listRolloutFiles(CODEX_SESSIONS_DIR);
+      files = await listRolloutFiles(this.sessionsDir);
     } catch {
       return;
     }
@@ -301,6 +332,15 @@ var CodexSessionWatcher = class {
         try {
           const stat = await fs.stat(filePath);
           fileState.position = stat.size;
+          const tailLines = await readTailLines(
+            filePath,
+            stat.size,
+            TAIL_MAX_BYTES,
+            TAIL_MAX_LINES
+          );
+          if (tailLines.length > 0) {
+            this.processLines(tailLines, fileState);
+          }
         } catch {
           continue;
         }
@@ -313,34 +353,52 @@ var CodexSessionWatcher = class {
         continue;
       }
       if (newLines.length === 0) continue;
-      for (const line of newLines) {
-        handleLine(line, fileState);
+      this.processLines(newLines, fileState);
+    }
+  }
+  processLines(lines, fileState) {
+    for (const line of lines) {
+      const parsed = parseCodexLine(line, fileState.sessionId);
+      fileState.sessionId = parsed.sessionId;
+      if (parsed.previousSessionId) {
+        this.state.removeSession(parsed.previousSessionId);
+      }
+      this.state.markCodexSessionSeen(parsed.sessionId, parsed.cwd);
+      if (parsed.markWorking) {
+        this.state.handleCodexActivity({
+          sessionId: parsed.sessionId,
+          cwd: parsed.cwd
+        });
+      }
+      if (parsed.markIdle) {
+        this.state.setCodexIdle(parsed.sessionId, parsed.cwd);
       }
     }
   }
 };
 
 // src/server.ts
-var TOKEN_DIR = join2(homedir2(), ".codex-blocker");
-var TOKEN_PATH = join2(TOKEN_DIR, "token");
+var DEFAULT_TOKEN_DIR = join2(homedir2(), ".codex-blocker");
+var DEFAULT_TOKEN_PATH = join2(DEFAULT_TOKEN_DIR, "token");
 var RATE_WINDOW_MS = 6e4;
 var RATE_LIMIT = 60;
 var MAX_WS_CONNECTIONS_PER_IP = 3;
 var rateByIp = /* @__PURE__ */ new Map();
 var wsConnectionsByIp = /* @__PURE__ */ new Map();
-function loadToken() {
-  if (!existsSync2(TOKEN_PATH)) return null;
+function loadToken(tokenPath) {
+  if (!existsSync2(tokenPath)) return null;
   try {
-    return readFileSync(TOKEN_PATH, "utf-8").trim() || null;
+    return readFileSync(tokenPath, "utf-8").trim() || null;
   } catch {
     return null;
   }
 }
-function saveToken(token) {
-  if (!existsSync2(TOKEN_DIR)) {
-    mkdirSync(TOKEN_DIR, { recursive: true });
+function saveToken(tokenPath, token) {
+  const tokenDir = dirname2(tokenPath);
+  if (!existsSync2(tokenDir)) {
+    mkdirSync(tokenDir, { recursive: true });
   }
-  writeFileSync(TOKEN_PATH, token, "utf-8");
+  writeFileSync(tokenPath, token, "utf-8");
 }
 function isChromeExtensionOrigin(origin) {
   return Boolean(origin && origin.startsWith("chrome-extension://"));
@@ -374,8 +432,12 @@ function sendJson(res, data, status = 200) {
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify(data));
 }
-function startServer(port = DEFAULT_PORT) {
-  let authToken = loadToken();
+function startServer(port = DEFAULT_PORT, options) {
+  const stateInstance = options?.state ?? state;
+  const tokenPath = options?.tokenPath ?? DEFAULT_TOKEN_PATH;
+  const startWatcher = options?.startWatcher ?? true;
+  const logBanner = options?.log ?? true;
+  let authToken = loadToken(tokenPath);
   const server = createServer(async (req, res) => {
     const clientIp = getClientIp(req);
     if (!checkRateLimit(clientIp)) {
@@ -407,13 +469,13 @@ function startServer(port = DEFAULT_PORT) {
       }
     } else if (providedToken && allowOrigin) {
       authToken = providedToken;
-      saveToken(providedToken);
+      saveToken(tokenPath, providedToken);
     } else {
       sendJson(res, { error: "Unauthorized" }, 401);
       return;
     }
     if (req.method === "GET" && url.pathname === "/status") {
-      sendJson(res, state.getStatus());
+      sendJson(res, stateInstance.getStatus());
       return;
     }
     sendJson(res, { error: "Not found" }, 404);
@@ -437,13 +499,13 @@ function startServer(port = DEFAULT_PORT) {
       }
     } else if (providedToken && allowOrigin) {
       authToken = providedToken;
-      saveToken(providedToken);
+      saveToken(tokenPath, providedToken);
     } else {
       ws.close(1008, "Unauthorized");
       return;
     }
     wsConnectionsByIp.set(clientIp, currentConnections + 1);
-    const unsubscribe = state.subscribe((message) => {
+    const unsubscribe = stateInstance.subscribe((message) => {
       if (ws.readyState === WebSocket.OPEN) {
         ws.send(JSON.stringify(message));
       }
@@ -472,16 +534,40 @@ function startServer(port = DEFAULT_PORT) {
       );
     });
   });
-  const codexWatcher = new CodexSessionWatcher();
-  codexWatcher.start();
+  const codexWatcher = new CodexSessionWatcher(stateInstance, {
+    sessionsDir: options?.sessionsDir
+  });
+  if (startWatcher) {
+    codexWatcher.start();
+  }
+  let resolveReady = () => {
+  };
+  const ready = new Promise((resolve) => {
+    resolveReady = resolve;
+  });
+  const handle = {
+    port,
+    ready,
+    close: async () => {
+      stateInstance.destroy();
+      codexWatcher.stop();
+      await new Promise((resolve) => wss.close(() => resolve()));
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
   server.listen(port, "127.0.0.1", () => {
+    const address = server.address();
+    const actualPort = typeof address === "object" && address ? address.port : port;
+    handle.port = actualPort;
+    resolveReady(actualPort);
+    if (!logBanner) return;
     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\u2510
 \u2502                                     \u2502
 \u2502   Codex Blocker Server              \u2502
 \u2502                                     \u2502
-\u2502   HTTP:      http://localhost:${port}  \u2502
-\u2502   WebSocket: ws://localhost:${port}/ws \u2502
+\u2502   HTTP:      http://localhost:${actualPort}  \u2502
+\u2502   WebSocket: ws://localhost:${actualPort}/ws \u2502
 \u2502                                     \u2502
 \u2502   Watching Codex sessions...        \u2502
 \u2502                                     \u2502
@@ -489,13 +575,12 @@ function startServer(port = DEFAULT_PORT) {
 `);
   });
   process.once("SIGINT", () => {
-    console.log("\nShutting down...");
-    state.destroy();
-    codexWatcher.stop();
-    wss.close();
-    server.close();
-    process.exit(0);
+    if (logBanner) {
+      console.log("\nShutting down...");
+    }
+    void handle.close().then(() => process.exit(0));
   });
+  return handle;
 }
 
 export {

package/dist/server.d.ts

@@ -1,3 +1,54 @@
-declare function startServer(port?: number): void;
+interface CodexActivity {
+    sessionId: string;
+    cwd?: string;
+    idleTimeoutMs?: number;
+}
+type ServerMessage = {
+    type: "state";
+    blocked: boolean;
+    sessions: number;
+    working: number;
+    waitingForInput: number;
+} | {
+    type: "pong";
+};
 
-export { startServer };
+type StateChangeCallback = (message: ServerMessage) => void;
+declare class SessionState {
+    private sessions;
+    private listeners;
+    private cleanupInterval;
+    constructor();
+    subscribe(callback: StateChangeCallback): () => void;
+    private broadcast;
+    private getStateMessage;
+    handleCodexActivity(activity: CodexActivity): void;
+    setCodexIdle(sessionId: string, cwd?: string): void;
+    markCodexSessionSeen(sessionId: string, cwd?: string): void;
+    removeSession(sessionId: string): void;
+    private ensureSession;
+    private cleanupStaleSessions;
+    getStatus(): {
+        blocked: boolean;
+        sessions: number;
+        working: number;
+        waitingForInput: number;
+    };
+    destroy(): void;
+}
+
+type ServerOptions = {
+    sessionsDir?: string;
+    startWatcher?: boolean;
+    tokenPath?: string;
+    state?: SessionState;
+    log?: boolean;
+};
+type ServerHandle = {
+    port: number;
+    ready: Promise<number>;
+    close: () => Promise<void>;
+};
+declare function startServer(port?: number, options?: ServerOptions): ServerHandle;
+
+export { type ServerHandle, type ServerOptions, startServer };

package/dist/server.js

@@ -1,6 +1,6 @@
 import {
   startServer
-} from "./chunk-FXDFFIXM.js";
+} from "./chunk-2Q6Z6NQH.js";
 export {
   startServer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-blocker",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Block distracting websites unless Codex is actively running inference. Forked from Theo Browne's (T3) Claude Blocker",
   "author": "Adam Blumoff ",
   "repository": {