codex-blocker 0.0.3

package/README.md

@@ -0,0 +1,94 @@
+# codex-blocker
+
+CLI tool and server for Codex Blocker — block distracting websites unless Codex is actively running.
+
+## Installation
+
+```bash
+npm install -g codex-blocker
+# or
+npx codex-blocker
+```
+
+## Quick Start
+
+```bash
+# Optional setup info
+npx codex-blocker --setup
+```
+
+## Usage
+
+```bash
+# Start server (default port 8765)
+npx codex-blocker
+
+# Show setup info
+npx codex-blocker --setup
+
+# Custom port
+npx codex-blocker --port 9000
+
+# Remove setup (no-op)
+npx codex-blocker --remove
+
+# Show help
+npx codex-blocker --help
+```
+
+## How It Works
+
+1. **Codex sessions** — The server tails Codex session logs under `~/.codex/sessions`
+   to detect activity.
+
+2. **Server** — Runs on localhost and:
+   - Tracks active Codex sessions
+   - Marks sessions "working" when new log lines arrive
+   - Broadcasts state via WebSocket to the Chrome extension
+
+3. **Extension** — Connects to the server and:
+   - Blocks configured sites when no sessions are working
+   - Shows a modal overlay (soft block, not network block)
+   - Updates in real-time without page refresh
+
+## API
+
+### HTTP Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/status` | GET | Returns current state (sessions, blocked status) |
+
+### WebSocket
+
+Connect to `ws://localhost:8765/ws` to receive real-time state updates:
+
+```json
+{
+  "type": "state",
+  "blocked": true,
+  "sessions": 1,
+  "working": 0
+}
+```
+
+## Programmatic Usage
+
+```typescript
+import { startServer } from 'codex-blocker';
+
+// Start on default port (8765)
+startServer();
+
+// Or custom port
+startServer(9000);
+```
+
+## Requirements
+
+- Node.js 18+
+- Codex CLI
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import {
+  startServer
+} from "./chunk-7TKQB72O.js";
+
+// src/bin.ts
+import { createInterface } from "readline";
+
+// src/setup.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CODEX_HOME = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+var CODEX_SESSIONS_DIR = join(CODEX_HOME, "sessions");
+function setupCodex() {
+  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
+\u2502                                                 \u2502
+\u2502   Codex Blocker Setup                            \u2502
+\u2502                                                 \u2502
+\u2502   No hooks needed. The server reads Codex       \u2502
+\u2502   session logs from:                             \u2502
+\u2502   ${CODEX_SESSIONS_DIR}
+\u2502                                                 \u2502
+\u2502   Tip: run Codex once to create the sessions    \u2502
+\u2502   directory if it doesn't exist yet.            \u2502
+\u2502                                                 \u2502
+\u2502   Next: Run 'npx codex-blocker' to start        \u2502
+\u2502                                                 \u2502
+\u2514\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\u2518
+`);
+}
+function isCodexAvailable() {
+  return existsSync(CODEX_SESSIONS_DIR);
+}
+function removeCodexSetup() {
+  console.log("No Codex hooks to remove.");
+}
+
+// src/bin.ts
+import { DEFAULT_PORT } from "@claude-blocker/shared";
+var args = process.argv.slice(2);
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+function printHelp() {
+  console.log(`
+Codex Blocker - Block distracting sites when Codex isn't working
+
+Usage:
+  npx codex-blocker [options]
+
+Options:
+  --setup     Show Codex setup info
+  --remove    Remove Codex setup (no-op)
+  --port      Server port (default: ${DEFAULT_PORT})
+  --help      Show this help message
+
+Examples:
+  npx codex-blocker            # Start the server
+  npx codex-blocker --port 9000
+`);
+}
+async function main() {
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.includes("--setup")) {
+    setupCodex();
+    process.exit(0);
+  }
+  if (args.includes("--remove")) {
+    removeCodexSetup();
+    process.exit(0);
+  }
+  let port = DEFAULT_PORT;
+  const portIndex = args.indexOf("--port");
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    const parsed = parseInt(args[portIndex + 1], 10);
+    if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
+      port = parsed;
+    } else {
+      console.error("Invalid port number");
+      process.exit(1);
+    }
+  }
+  if (!isCodexAvailable()) {
+    console.log("Codex sessions directory not found yet.");
+    const answer = await prompt("Run Codex once to create it, then press enter to continue. ");
+    if (answer !== void 0) {
+      console.log("");
+    }
+  }
+  startServer(port);
+}
+main();

package/dist/chunk-7TKQB72O.js

@@ -0,0 +1,509 @@
+// src/server.ts
+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 { 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
+var SessionState = class {
+  sessions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  cleanupInterval = null;
+  constructor() {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupStaleSessions();
+    }, 3e4);
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    callback(this.getStateMessage());
+    return () => this.listeners.delete(callback);
+  }
+  broadcast() {
+    const message = this.getStateMessage();
+    for (const listener of this.listeners) {
+      listener(message);
+    }
+  }
+  getStateMessage() {
+    const sessions = Array.from(this.sessions.values());
+    const working = sessions.filter((s) => s.status === "working").length;
+    const waitingForInput = sessions.filter(
+      (s) => s.status === "waiting_for_input"
+    ).length;
+    return {
+      type: "state",
+      blocked: working === 0,
+      sessions: sessions.length,
+      working,
+      waitingForInput
+    };
+  }
+  handleCodexActivity(activity) {
+    this.ensureSession(activity.sessionId, activity.cwd);
+    const session = this.sessions.get(activity.sessionId);
+    session.status = "working";
+    session.waitingForInputSince = void 0;
+    session.lastActivity = /* @__PURE__ */ new Date();
+    session.lastSeen = /* @__PURE__ */ new Date();
+    session.idleTimeoutMs = activity.idleTimeoutMs;
+    this.broadcast();
+  }
+  setCodexIdle(sessionId, cwd) {
+    this.ensureSession(sessionId, cwd);
+    const session = this.sessions.get(sessionId);
+    if (session.status !== "idle") {
+      session.status = "idle";
+      session.waitingForInputSince = void 0;
+      session.lastActivity = /* @__PURE__ */ new Date();
+      this.broadcast();
+    }
+  }
+  markCodexSessionSeen(sessionId, cwd) {
+    const created = this.ensureSession(sessionId, cwd);
+    const session = this.sessions.get(sessionId);
+    session.lastSeen = /* @__PURE__ */ new Date();
+    if (created) {
+      this.broadcast();
+    }
+  }
+  removeSession(sessionId) {
+    if (this.sessions.delete(sessionId)) {
+      this.broadcast();
+    }
+  }
+  ensureSession(sessionId, cwd) {
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, {
+        id: sessionId,
+        status: "idle",
+        lastActivity: /* @__PURE__ */ new Date(),
+        lastSeen: /* @__PURE__ */ new Date(),
+        cwd
+      });
+      console.log("Codex session connected");
+      return true;
+    } else if (cwd) {
+      const session = this.sessions.get(sessionId);
+      session.cwd = cwd;
+    }
+    return false;
+  }
+  cleanupStaleSessions() {
+    const now = Date.now();
+    let removed = 0;
+    let changed = 0;
+    for (const [id, session] of this.sessions) {
+      if (now - session.lastSeen.getTime() > SESSION_TIMEOUT_MS) {
+        this.sessions.delete(id);
+        removed++;
+        continue;
+      }
+      if (session.status === "working" && session.idleTimeoutMs && now - session.lastActivity.getTime() > session.idleTimeoutMs) {
+        session.status = "idle";
+        session.waitingForInputSince = void 0;
+        changed++;
+      }
+    }
+    if (removed > 0 || changed > 0) {
+      this.broadcast();
+    }
+  }
+  getStatus() {
+    const sessions = Array.from(this.sessions.values());
+    const working = sessions.filter((s) => s.status === "working").length;
+    const waitingForInput = sessions.filter(
+      (s) => s.status === "waiting_for_input"
+    ).length;
+    return {
+      blocked: working === 0,
+      sessions: sessions.length,
+      working,
+      waitingForInput
+    };
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.sessions.clear();
+    this.listeners.clear();
+  }
+};
+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");
+function isRolloutFile(filePath) {
+  const name = basename(filePath);
+  return name === "rollout.jsonl" || /^rollout-.+\.jsonl$/.test(name);
+}
+function sessionIdFromPath(filePath) {
+  const name = basename(filePath);
+  const match = name.match(/^rollout-(.+)\.jsonl$/);
+  if (match) return match[1];
+  if (name === "rollout.jsonl") {
+    const parent = basename(dirname(filePath));
+    if (parent !== "sessions") return parent;
+  }
+  return filePath;
+}
+function findFirstStringValue(obj, keys, maxDepth = 6) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const queue = [{ value: obj, depth: 0 }];
+  while (queue.length) {
+    const current = queue.shift();
+    if (!current) break;
+    const { value, depth } = current;
+    if (!value || typeof value !== "object") continue;
+    const record = value;
+    for (const key of keys) {
+      const candidate = record[key];
+      if (typeof candidate === "string" && candidate.length > 0) {
+        return candidate;
+      }
+    }
+    if (depth >= maxDepth) continue;
+    for (const child of Object.values(record)) {
+      if (child && typeof child === "object") {
+        queue.push({ value: child, depth: depth + 1 });
+      }
+    }
+  }
+  return void 0;
+}
+async function listRolloutFiles(root) {
+  const files = [];
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listRolloutFiles(fullPath));
+    } else if (entry.isFile() && isRolloutFile(fullPath)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function readNewLines(filePath, fileState) {
+  const stat = await fs.stat(filePath);
+  if (stat.size < fileState.position) {
+    fileState.position = 0;
+    fileState.remainder = "";
+  }
+  if (stat.size === fileState.position) return [];
+  const start = fileState.position;
+  const end = Math.max(stat.size - 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);
+  });
+  fileState.position = stat.size;
+  const content = fileState.remainder + Buffer.concat(chunks).toString("utf-8");
+  const lines = content.split("\n");
+  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" || innerTypeString === "turn_aborted")) {
+      shouldMarkIdle = true;
+    }
+    if (entryType === "response_item" && innerTypeString === "message") {
+      const role = innerPayload && typeof innerPayload === "object" ? innerPayload.role : void 0;
+      if (role === "assistant") {
+        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;
+  start() {
+    this.scan();
+    this.scanTimer = setInterval(() => {
+      this.scan();
+    }, CODEX_SESSIONS_SCAN_INTERVAL_MS);
+  }
+  stop() {
+    if (this.scanTimer) {
+      clearInterval(this.scanTimer);
+      this.scanTimer = null;
+    }
+  }
+  async scan() {
+    if (!existsSync(CODEX_SESSIONS_DIR)) {
+      if (!this.warnedMissing) {
+        console.log(`Waiting for Codex sessions at ${CODEX_SESSIONS_DIR}`);
+        this.warnedMissing = true;
+      }
+      return;
+    }
+    this.warnedMissing = false;
+    let files = [];
+    try {
+      files = await listRolloutFiles(CODEX_SESSIONS_DIR);
+    } catch {
+      return;
+    }
+    for (const filePath of files) {
+      const fileState = this.fileStates.get(filePath) ?? {
+        position: 0,
+        remainder: "",
+        sessionId: sessionIdFromPath(filePath)
+      };
+      if (!this.fileStates.has(filePath)) {
+        this.fileStates.set(filePath, fileState);
+        try {
+          const stat = await fs.stat(filePath);
+          fileState.position = stat.size;
+        } catch {
+          continue;
+        }
+        continue;
+      }
+      let newLines = [];
+      try {
+        newLines = await readNewLines(filePath, fileState);
+      } catch {
+        continue;
+      }
+      if (newLines.length === 0) continue;
+      for (const line of newLines) {
+        handleLine(line, fileState);
+      }
+    }
+  }
+};
+
+// src/server.ts
+var TOKEN_DIR = join2(homedir2(), ".codex-blocker");
+var TOKEN_PATH = join2(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;
+  try {
+    return readFileSync(TOKEN_PATH, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function saveToken(token) {
+  if (!existsSync2(TOKEN_DIR)) {
+    mkdirSync(TOKEN_DIR, { recursive: true });
+  }
+  writeFileSync(TOKEN_PATH, token, "utf-8");
+}
+function isChromeExtensionOrigin(origin) {
+  return Boolean(origin && origin.startsWith("chrome-extension://"));
+}
+function getClientIp(req) {
+  return req.socket.remoteAddress ?? "unknown";
+}
+function checkRateLimit(ip) {
+  const now = Date.now();
+  const state2 = rateByIp.get(ip);
+  if (!state2 || state2.resetAt <= now) {
+    rateByIp.set(ip, { count: 1, resetAt: now + RATE_WINDOW_MS });
+    return true;
+  }
+  if (state2.count >= RATE_LIMIT) return false;
+  state2.count += 1;
+  return true;
+}
+function readAuthToken(req, url) {
+  const header = req.headers.authorization;
+  if (header && header.startsWith("Bearer ")) {
+    return header.slice("Bearer ".length).trim();
+  }
+  const query = url.searchParams.get("token");
+  if (query) return query;
+  const alt = req.headers["x-codex-blocker-token"];
+  if (typeof alt === "string" && alt.length > 0) return alt;
+  return null;
+}
+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();
+  const server = createServer(async (req, res) => {
+    const clientIp = getClientIp(req);
+    if (!checkRateLimit(clientIp)) {
+      sendJson(res, { error: "Too Many Requests" }, 429);
+      return;
+    }
+    const url = new URL(req.url || "/", `http://localhost:${port}`);
+    const origin = req.headers.origin;
+    const allowOrigin = isChromeExtensionOrigin(origin);
+    if (allowOrigin && origin) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Vary", "Origin");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader(
+        "Access-Control-Allow-Headers",
+        "Content-Type, Authorization, X-Codex-Blocker-Token"
+      );
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(allowOrigin ? 204 : 403);
+      res.end();
+      return;
+    }
+    const providedToken = readAuthToken(req, url);
+    if (authToken) {
+      if (!providedToken || providedToken !== authToken) {
+        sendJson(res, { error: "Unauthorized" }, 401);
+        return;
+      }
+    } else if (providedToken && allowOrigin) {
+      authToken = providedToken;
+      saveToken(providedToken);
+    } else {
+      sendJson(res, { error: "Unauthorized" }, 401);
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/status") {
+      sendJson(res, state.getStatus());
+      return;
+    }
+    sendJson(res, { error: "Not found" }, 404);
+  });
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  wss.on("connection", (ws, req) => {
+    const wsUrl = new URL(req.url || "", `http://localhost:${port}`);
+    const providedToken = wsUrl.searchParams.get("token");
+    const origin = req.headers.origin;
+    const allowOrigin = isChromeExtensionOrigin(origin);
+    const clientIp = getClientIp(req);
+    const currentConnections = wsConnectionsByIp.get(clientIp) ?? 0;
+    if (currentConnections >= MAX_WS_CONNECTIONS_PER_IP) {
+      ws.close(1013, "Too many connections");
+      return;
+    }
+    if (authToken) {
+      if (!providedToken || providedToken !== authToken) {
+        ws.close(1008, "Unauthorized");
+        return;
+      }
+    } else if (providedToken && allowOrigin) {
+      authToken = providedToken;
+      saveToken(providedToken);
+    } else {
+      ws.close(1008, "Unauthorized");
+      return;
+    }
+    wsConnectionsByIp.set(clientIp, currentConnections + 1);
+    const unsubscribe = state.subscribe((message) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(message));
+      }
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === "ping") {
+          ws.send(JSON.stringify({ type: "pong" }));
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      unsubscribe();
+      wsConnectionsByIp.set(
+        clientIp,
+        Math.max(0, (wsConnectionsByIp.get(clientIp) ?? 1) - 1)
+      );
+    });
+    ws.on("error", () => {
+      unsubscribe();
+      wsConnectionsByIp.set(
+        clientIp,
+        Math.max(0, (wsConnectionsByIp.get(clientIp) ?? 1) - 1)
+      );
+    });
+  });
+  const codexWatcher = new CodexSessionWatcher();
+  codexWatcher.start();
+  server.listen(port, "127.0.0.1", () => {
+    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                                     \u2502
+\u2502   Watching Codex sessions...        \u2502
+\u2502                                     \u2502
+\u2514\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\u2518
+`);
+  });
+  process.once("SIGINT", () => {
+    console.log("\nShutting down...");
+    state.destroy();
+    codexWatcher.stop();
+    wss.close();
+    server.close();
+    process.exit(0);
+  });
+}
+
+export {
+  startServer
+};

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+declare function startServer(port?: number): void;
+
+export { startServer };

package/dist/server.js

@@ -0,0 +1,6 @@
+import {
+  startServer
+} from "./chunk-7TKQB72O.js";
+export {
+  startServer
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "codex-blocker",
+  "version": "0.0.3",
+  "description": "Block distracting websites unless Codex is actively running inference. Forked from Theo Browne's (T3) Claude Blocker",
+  "author": "Adam Blumoff ",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adamblumoff/codex-blocker.git"
+  },
+  "homepage": "https://github.com/adamblumoff/codex-blocker",
+  "bugs": {
+    "url": "https://github.com/adamblumoff/codex-blocker/issues"
+  },
+  "type": "module",
+  "bin": {
+    "codex-blocker": "dist/bin.js"
+  },
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/bin.ts src/server.ts --format esm --dts --clean",
+    "dev": "tsx src/bin.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@claude-blocker/shared": "workspace:*",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "codex",
+    "codex-cli",
+    "productivity",
+    "blocker",
+    "focus",
+    "distraction"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}