codex-wakatime 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 WakaTime
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# codex-wakatime
+
+WakaTime integration for [OpenAI Codex CLI](https://github.com/openai/codex) - Track AI coding activity and time spent.
+
+## Features
+
+- Automatic time tracking for Codex CLI sessions
+- File-level activity detection via message parsing
+- 60-second heartbeat rate limiting
+- Automatic WakaTime CLI installation and updates
+- Cross-platform support (macOS, Linux, Windows)
+
+## Prerequisites
+
+1. [WakaTime account](https://wakatime.com) and API key
+2. WakaTime API key configured in `~/.wakatime.cfg`:
+   ```ini
+   [settings]
+   api_key = your-api-key-here
+   ```
+3. [Codex CLI](https://github.com/openai/codex) installed
+
+## Installation
+
+```bash
+# Install the package
+npm install -g codex-wakatime
+
+# Configure the notification hook
+codex-wakatime --install
+```
+
+This adds `notify = ["codex-wakatime"]` to your `~/.codex/config.toml`.
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     Codex CLI Session                        │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│              agent-turn-complete event                       │
+│   Codex sends notification with:                             │
+│   - thread-id, turn-id                                       │
+│   - cwd (working directory)                                  │
+│   - last-assistant-message                                   │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│                   codex-wakatime                             │
+│   1. Parse notification JSON from CLI argument               │
+│   2. Extract file paths from assistant message               │
+│   3. Check 60-second rate limit                              │
+│   4. Send heartbeat(s) to WakaTime                           │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│                   WakaTime Dashboard                         │
+│   View your AI coding metrics at wakatime.com                │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Notification Hook
+
+| Event | Purpose |
+|-------|---------|
+| `agent-turn-complete` | Triggered after each Codex turn completes |
+
+### File Detection Patterns
+
+The plugin extracts file paths from the assistant's response using these patterns:
+
+- **Code block headers**: ` ```typescript:src/index.ts `
+- **Backtick paths**: `` `src/file.ts` ``
+- **Action patterns**: `Created src/file.ts`, `Modified package.json`
+- **Quoted paths**: `"src/file.ts"` or `'src/file.ts'`
+
+If no files are detected, a project-level heartbeat is sent using the working directory.
+
+## Configuration
+
+The plugin auto-configures `~/.codex/config.toml` on installation:
+
+```toml
+notify = ["codex-wakatime"]
+```
+
+### Debug Mode
+
+Enable debug logging by adding to `~/.wakatime.cfg`:
+
+```ini
+[settings]
+debug = true
+```
+
+Logs are written to `~/.wakatime/codex.log`.
+
+## Files & Locations
+
+| File | Purpose |
+|------|---------|
+| `~/.wakatime/codex.json` | Rate limiting state |
+| `~/.wakatime/codex.log` | Debug logs |
+| `~/.wakatime/codex-cli-state.json` | CLI version tracking |
+| `~/.codex/config.toml` | Codex configuration |
+| `~/.wakatime.cfg` | WakaTime API key and settings |
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/wakatime/codex-wakatime
+cd codex-wakatime
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Type check
+npm run typecheck
+
+# Lint
+npm run check
+```
+
+### Project Structure
+
+```
+codex-wakatime/
+├── src/
+│   ├── index.ts          # Main entry point
+│   ├── install.ts        # Hook installation
+│   ├── extractor.ts      # File path extraction
+│   ├── wakatime.ts       # CLI invocation
+│   ├── dependencies.ts   # CLI management
+│   ├── state.ts          # Rate limiting
+│   ├── logger.ts         # Logging
+│   ├── options.ts        # Config parsing
+│   ├── types.ts          # TypeScript interfaces
+│   └── __tests__/        # Test files
+├── scripts/
+│   └── generate-version.js
+├── package.json
+├── tsconfig.json
+└── biome.json
+```
+
+## Uninstall
+
+```bash
+# Remove the notification hook
+codex-wakatime --uninstall
+
+# Uninstall the package
+npm uninstall -g codex-wakatime
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `codex-wakatime --install` | Add notification hook to Codex config |
+| `codex-wakatime --uninstall` | Remove notification hook from Codex config |
+| `codex-wakatime '{"type":"agent-turn-complete",...}'` | Process a notification (called by Codex) |
+
+## Troubleshooting
+
+### No heartbeats being sent
+
+1. Check that your API key is configured in `~/.wakatime.cfg`
+2. Verify the notify hook is set in `~/.codex/config.toml`
+3. Enable debug mode and check `~/.wakatime/codex.log`
+
+### Rate limiting
+
+Heartbeats are rate-limited to once per 60 seconds. If you're testing, wait at least 60 seconds between Codex turns.
+
+### CLI not found
+
+The plugin automatically downloads `wakatime-cli` if not found. If this fails:
+
+1. Check your internet connection
+2. Manually install: https://github.com/wakatime/wakatime-cli/releases
+3. Ensure `wakatime-cli` is in your PATH
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,1070 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/isexe/dist/cjs/posix.js
+var require_posix = __commonJS({
+  "node_modules/isexe/dist/cjs/posix.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = void 0;
+    var fs_1 = require("fs");
+    var promises_1 = require("fs/promises");
+    var isexe = async (path8, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat(await (0, promises_1.stat)(path8), options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports2.isexe = isexe;
+    var sync = (path8, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat((0, fs_1.statSync)(path8), options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports2.sync = sync;
+    var checkStat = (stat, options) => stat.isFile() && checkMode(stat, options);
+    var checkMode = (stat, options) => {
+      const myUid = options.uid ?? process.getuid?.();
+      const myGroups = options.groups ?? process.getgroups?.() ?? [];
+      const myGid = options.gid ?? process.getgid?.() ?? myGroups[0];
+      if (myUid === void 0 || myGid === void 0) {
+        throw new Error("cannot get uid or gid");
+      }
+      const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]);
+      const mod = stat.mode;
+      const uid = stat.uid;
+      const gid = stat.gid;
+      const u = parseInt("100", 8);
+      const g = parseInt("010", 8);
+      const o = parseInt("001", 8);
+      const ug = u | g;
+      return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
+    };
+  }
+});
+
+// node_modules/isexe/dist/cjs/win32.js
+var require_win32 = __commonJS({
+  "node_modules/isexe/dist/cjs/win32.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = void 0;
+    var fs_1 = require("fs");
+    var promises_1 = require("fs/promises");
+    var isexe = async (path8, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat(await (0, promises_1.stat)(path8), path8, options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports2.isexe = isexe;
+    var sync = (path8, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat((0, fs_1.statSync)(path8), path8, options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports2.sync = sync;
+    var checkPathExt = (path8, options) => {
+      const { pathExt = process.env.PATHEXT || "" } = options;
+      const peSplit = pathExt.split(";");
+      if (peSplit.indexOf("") !== -1) {
+        return true;
+      }
+      for (let i = 0; i < peSplit.length; i++) {
+        const p = peSplit[i].toLowerCase();
+        const ext = path8.substring(path8.length - p.length).toLowerCase();
+        if (p && ext === p) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var checkStat = (stat, path8, options) => stat.isFile() && checkPathExt(path8, options);
+  }
+});
+
+// node_modules/isexe/dist/cjs/options.js
+var require_options = __commonJS({
+  "node_modules/isexe/dist/cjs/options.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/isexe/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/isexe/dist/cjs/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0;
+    var posix = __importStar(require_posix());
+    exports2.posix = posix;
+    var win32 = __importStar(require_win32());
+    exports2.win32 = win32;
+    __exportStar(require_options(), exports2);
+    var platform3 = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+    var impl = platform3 === "win32" ? win32 : posix;
+    exports2.isexe = impl.isexe;
+    exports2.sync = impl.sync;
+  }
+});
+
+// node_modules/which/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/which/lib/index.js"(exports2, module2) {
+    var { isexe, sync: isexeSync } = require_cjs();
+    var { join: join7, delimiter, sep, posix } = require("path");
+    var isWindows2 = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows2 ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows2) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    };
+    var getPathPart = (raw, cmd) => {
+      const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join7(pathPart, cmd);
+    };
+    var which2 = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which2;
+    which2.sync = whichSync;
+  }
+});
+
+// src/index.ts
+var path7 = __toESM(require("node:path"), 1);
+
+// src/extractor.ts
+var path = __toESM(require("node:path"), 1);
+var PATTERNS = [
+  // Code block headers: ```typescript:src/index.ts or ```ts:src/index.ts
+  /```\w*:([^\n`]+)/g,
+  // Backtick paths with extension: `src/foo/bar.ts`
+  /`([^`\s]+\.\w{1,6})`/g,
+  // Action patterns: Created/Modified/Updated/Wrote/Edited/Deleted file.ts
+  /(?:Created|Modified|Updated|Wrote|Edited|Deleted|Reading|Writing)\s+`?([^\s`\n]+\.\w{1,6})`?/gi,
+  // File path in quotes: "src/file.ts" or 'src/file.ts'
+  /["']([^"'\s]+\.\w{1,6})["']/g
+];
+function isValidFilePath(p) {
+  if (!p || p.length === 0) return false;
+  if (p.startsWith("http://") || p.startsWith("https://") || p.includes("://"))
+    return false;
+  if (/[<>|?*]/.test(p)) return false;
+  const ext = path.extname(p).slice(1).toLowerCase();
+  if (!ext) return false;
+  if (ext.length > 6) return false;
+  return true;
+}
+function normalizePath(filePath, cwd) {
+  const cleaned = filePath.trim();
+  if (path.isAbsolute(cleaned)) {
+    return path.normalize(cleaned);
+  }
+  return path.normalize(path.join(cwd, cleaned));
+}
+function extractFilePaths(message, cwd) {
+  if (!message || message.length === 0) {
+    return [];
+  }
+  const files = /* @__PURE__ */ new Set();
+  for (const pattern of PATTERNS) {
+    pattern.lastIndex = 0;
+    for (const match of message.matchAll(pattern)) {
+      const filePath = match[1];
+      if (filePath && isValidFilePath(filePath)) {
+        const normalized = normalizePath(filePath, cwd);
+        files.add(normalized);
+      }
+    }
+  }
+  return Array.from(files);
+}
+
+// src/install.ts
+var fs = __toESM(require("node:fs"), 1);
+var os = __toESM(require("node:os"), 1);
+var path2 = __toESM(require("node:path"), 1);
+var CODEX_CONFIG_PATH = path2.join(os.homedir(), ".codex", "config.toml");
+function parseToml(content) {
+  const config = {};
+  const lines = content.split("\n");
+  let currentSection = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      currentSection = trimmed.slice(1, -1);
+      if (!config[currentSection]) {
+        config[currentSection] = {};
+      }
+      continue;
+    }
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex > 0) {
+      const key = trimmed.slice(0, equalIndex).trim();
+      const value = trimmed.slice(equalIndex + 1).trim();
+      let parsedValue;
+      if (value.startsWith("[") && value.endsWith("]")) {
+        const arrayContent = value.slice(1, -1).trim();
+        if (arrayContent) {
+          parsedValue = arrayContent.split(",").map((item) => {
+            const trimmedItem = item.trim();
+            if (trimmedItem.startsWith('"') && trimmedItem.endsWith('"') || trimmedItem.startsWith("'") && trimmedItem.endsWith("'")) {
+              return trimmedItem.slice(1, -1);
+            }
+            return trimmedItem;
+          });
+        } else {
+          parsedValue = [];
+        }
+      } else if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        parsedValue = value.slice(1, -1);
+      } else if (value === "true") {
+        parsedValue = true;
+      } else if (value === "false") {
+        parsedValue = false;
+      } else if (!Number.isNaN(Number(value))) {
+        parsedValue = Number(value);
+      } else {
+        parsedValue = value;
+      }
+      if (currentSection) {
+        config[currentSection][key] = parsedValue;
+      } else {
+        config[key] = parsedValue;
+      }
+    }
+  }
+  return config;
+}
+function stringifyToml(config) {
+  const lines = [];
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      lines.push(`${key} = ${formatTomlValue(value)}`);
+    }
+  }
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
+      if (lines.length > 0) {
+        lines.push("");
+      }
+      lines.push(`[${key}]`);
+      for (const [subKey, subValue] of Object.entries(
+        value
+      )) {
+        lines.push(`${subKey} = ${formatTomlValue(subValue)}`);
+      }
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatTomlValue(value) {
+  if (Array.isArray(value)) {
+    const items = value.map(
+      (item) => typeof item === "string" ? `"${item}"` : String(item)
+    );
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return String(value);
+}
+function normalizeNotifyValue(value) {
+  if (Array.isArray(value)) return value.slice();
+  if (typeof value === "string") return [value];
+  return [];
+}
+function hasNotifyEntry(entries, command) {
+  return entries.some((entry) => typeof entry === "string" && entry === command);
+}
+function removeNotifyEntry(entries, command) {
+  return entries.filter(
+    (entry) => !(typeof entry === "string" && entry === command)
+  );
+}
+function getPluginCommand() {
+  return ["codex-wakatime"];
+}
+function installHook() {
+  console.log("Installing codex-wakatime notification hook...");
+  const codexDir = path2.dirname(CODEX_CONFIG_PATH);
+  if (!fs.existsSync(codexDir)) {
+    fs.mkdirSync(codexDir, { recursive: true });
+    console.log(`Created ${codexDir}`);
+  }
+  let config = {};
+  if (fs.existsSync(CODEX_CONFIG_PATH)) {
+    try {
+      const content = fs.readFileSync(CODEX_CONFIG_PATH, "utf-8");
+      config = parseToml(content);
+      console.log("Found existing Codex config");
+    } catch {
+      console.warn("Could not parse existing config, creating new one");
+    }
+  }
+  const pluginCommand = getPluginCommand()[0];
+  const existingNotify = normalizeNotifyValue(config.notify);
+  if (hasNotifyEntry(existingNotify, pluginCommand)) {
+    console.log("codex-wakatime is already configured");
+    return;
+  }
+  config.notify = [...existingNotify, pluginCommand];
+  const newContent = stringifyToml(config);
+  fs.writeFileSync(CODEX_CONFIG_PATH, newContent);
+  console.log(`Updated ${CODEX_CONFIG_PATH}`);
+  console.log("codex-wakatime notification hook installed successfully!");
+  console.log("");
+  console.log(
+    "Make sure you have your WakaTime API key configured in ~/.wakatime.cfg"
+  );
+}
+function uninstallHook() {
+  console.log("Uninstalling codex-wakatime notification hook...");
+  if (!fs.existsSync(CODEX_CONFIG_PATH)) {
+    console.log("No Codex config found, nothing to uninstall");
+    return;
+  }
+  try {
+    const content = fs.readFileSync(CODEX_CONFIG_PATH, "utf-8");
+    const config = parseToml(content);
+    const pluginCommand = getPluginCommand()[0];
+    const existingNotify = normalizeNotifyValue(config.notify);
+    if (!hasNotifyEntry(existingNotify, pluginCommand)) {
+      console.log("codex-wakatime was not configured");
+      return;
+    }
+    const updatedNotify = removeNotifyEntry(existingNotify, pluginCommand);
+    if (updatedNotify.length === 0) {
+      delete config.notify;
+    } else {
+      config.notify = updatedNotify;
+    }
+    const newContent = stringifyToml(config);
+    fs.writeFileSync(CODEX_CONFIG_PATH, newContent);
+    console.log("codex-wakatime notification hook removed");
+  } catch (err) {
+    console.error("Error uninstalling hook:", err);
+  }
+}
+
+// src/logger.ts
+var fs2 = __toESM(require("node:fs"), 1);
+var os2 = __toESM(require("node:os"), 1);
+var path3 = __toESM(require("node:path"), 1);
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var LOG_FILE = path3.join(os2.homedir(), ".wakatime", "codex.log");
+var Logger = class {
+  level = 1 /* INFO */;
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(msg) {
+    this.log(0 /* DEBUG */, msg);
+  }
+  info(msg) {
+    this.log(1 /* INFO */, msg);
+  }
+  warn(msg) {
+    this.log(2 /* WARN */, msg);
+  }
+  error(msg) {
+    this.log(3 /* ERROR */, msg);
+  }
+  warnException(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    this.warn(message);
+  }
+  errorException(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    this.error(message);
+  }
+  log(level, msg) {
+    if (level < this.level) return;
+    const levelName = LogLevel[level];
+    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${timestamp2}][${levelName}] ${msg}
+`;
+    try {
+      const dir = path3.dirname(LOG_FILE);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+      fs2.appendFileSync(LOG_FILE, line);
+    } catch {
+    }
+  }
+};
+var logger = new Logger();
+
+// src/options.ts
+var fs3 = __toESM(require("node:fs"), 1);
+var os3 = __toESM(require("node:os"), 1);
+var path4 = __toESM(require("node:path"), 1);
+var WAKATIME_CONFIG = path4.join(os3.homedir(), ".wakatime.cfg");
+function parseIni(content) {
+  const config = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("[")) {
+      continue;
+    }
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex > 0) {
+      const key = trimmed.slice(0, equalIndex).trim();
+      const value = trimmed.slice(equalIndex + 1).trim();
+      if (value.toLowerCase() === "true") {
+        config[key] = true;
+      } else if (value.toLowerCase() === "false") {
+        config[key] = false;
+      } else {
+        config[key] = value;
+      }
+    }
+  }
+  return config;
+}
+function getWakaTimeConfig() {
+  try {
+    if (fs3.existsSync(WAKATIME_CONFIG)) {
+      const content = fs3.readFileSync(WAKATIME_CONFIG, "utf-8");
+      return parseIni(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function isDebugEnabled() {
+  const config = getWakaTimeConfig();
+  return config.debug === true;
+}
+
+// src/state.ts
+var fs4 = __toESM(require("node:fs"), 1);
+var os4 = __toESM(require("node:os"), 1);
+var path5 = __toESM(require("node:path"), 1);
+var STATE_FILE = path5.join(os4.homedir(), ".wakatime", "codex.json");
+function readState() {
+  try {
+    const content = fs4.readFileSync(STATE_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function writeState(state) {
+  try {
+    const dir = path5.dirname(STATE_FILE);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch {
+  }
+}
+function timestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function shouldSendHeartbeat(force = false) {
+  if (force) return true;
+  try {
+    const state = readState();
+    const lastHeartbeat = state.lastHeartbeatAt ?? 0;
+    return timestamp() - lastHeartbeat >= 60;
+  } catch {
+    return true;
+  }
+}
+function updateLastHeartbeat() {
+  writeState({ lastHeartbeatAt: timestamp() });
+}
+
+// src/wakatime.ts
+var import_node_child_process = require("node:child_process");
+var os6 = __toESM(require("node:os"), 1);
+
+// src/dependencies.ts
+var fs5 = __toESM(require("node:fs"), 1);
+var import_node_fs = require("node:fs");
+var https = __toESM(require("node:https"), 1);
+var os5 = __toESM(require("node:os"), 1);
+var path6 = __toESM(require("node:path"), 1);
+var import_which = __toESM(require_lib(), 1);
+var GITHUB_RELEASES_URL = "https://api.github.com/repos/wakatime/wakatime-cli/releases/latest";
+var GITHUB_DOWNLOAD_URL = "https://github.com/wakatime/wakatime-cli/releases/latest/download";
+var UPDATE_CHECK_INTERVAL = 4 * 60 * 60 * 1e3;
+var Dependencies = class {
+  resourcesLocation;
+  cliLocation;
+  stateFile;
+  constructor() {
+    this.resourcesLocation = path6.join(os5.homedir(), ".wakatime");
+    this.stateFile = path6.join(this.resourcesLocation, "codex-cli-state.json");
+  }
+  isWindows() {
+    return os5.platform() === "win32";
+  }
+  getOsName() {
+    const platform3 = os5.platform();
+    if (platform3 === "win32") return "windows";
+    return platform3;
+  }
+  getArchitecture() {
+    const arch2 = os5.arch();
+    if (arch2 === "x64") return "amd64";
+    if (arch2 === "ia32" || arch2.includes("32")) return "386";
+    if (arch2 === "arm64") return "arm64";
+    if (arch2 === "arm") return "arm";
+    return arch2;
+  }
+  getCliBinaryName() {
+    const osname = this.getOsName();
+    const arch2 = this.getArchitecture();
+    const ext = this.isWindows() ? ".exe" : "";
+    return `wakatime-cli-${osname}-${arch2}${ext}`;
+  }
+  getCliDownloadUrl() {
+    const osname = this.getOsName();
+    const arch2 = this.getArchitecture();
+    return `${GITHUB_DOWNLOAD_URL}/wakatime-cli-${osname}-${arch2}.zip`;
+  }
+  readState() {
+    try {
+      if (fs5.existsSync(this.stateFile)) {
+        return JSON.parse(fs5.readFileSync(this.stateFile, "utf-8"));
+      }
+    } catch {
+    }
+    return {};
+  }
+  writeState(state) {
+    try {
+      fs5.mkdirSync(path6.dirname(this.stateFile), { recursive: true });
+      fs5.writeFileSync(this.stateFile, JSON.stringify(state, null, 2));
+    } catch {
+    }
+  }
+  getCliLocationGlobal() {
+    const binaryName = `wakatime-cli${this.isWindows() ? ".exe" : ""}`;
+    try {
+      const globalPath = import_which.default.sync(binaryName, { nothrow: true });
+      if (globalPath) {
+        logger.debug(`Found global wakatime-cli: ${globalPath}`);
+        return globalPath;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  getCliLocation() {
+    if (this.cliLocation) return this.cliLocation;
+    const globalCli = this.getCliLocationGlobal();
+    if (globalCli) {
+      this.cliLocation = globalCli;
+      return this.cliLocation;
+    }
+    const binary = this.getCliBinaryName();
+    this.cliLocation = path6.join(this.resourcesLocation, binary);
+    return this.cliLocation;
+  }
+  isCliInstalled() {
+    const location = this.getCliLocation();
+    return fs5.existsSync(location);
+  }
+  shouldCheckForUpdates() {
+    if (this.getCliLocationGlobal()) {
+      return false;
+    }
+    const state = this.readState();
+    if (!state.lastChecked) return true;
+    return Date.now() - state.lastChecked > UPDATE_CHECK_INTERVAL;
+  }
+  async checkAndInstallCli() {
+    if (this.getCliLocationGlobal()) {
+      logger.debug("Using global wakatime-cli, skipping installation check");
+      return;
+    }
+    if (!this.isCliInstalled()) {
+      logger.info("wakatime-cli not found, downloading...");
+      await this.installCli();
+      return;
+    }
+    if (this.shouldCheckForUpdates()) {
+      logger.debug("Checking for wakatime-cli updates...");
+      const latestVersion = await this.getLatestVersion();
+      const state = this.readState();
+      if (latestVersion && latestVersion !== state.version) {
+        logger.info(`Updating wakatime-cli to ${latestVersion}...`);
+        await this.installCli();
+        this.writeState({ lastChecked: Date.now(), version: latestVersion });
+      } else {
+        this.writeState({ ...state, lastChecked: Date.now() });
+      }
+    }
+  }
+  async getLatestVersion() {
+    return new Promise((resolve) => {
+      const options = {
+        headers: {
+          "User-Agent": "codex-wakatime"
+        }
+      };
+      https.get(GITHUB_RELEASES_URL, options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.tag_name);
+          } catch {
+            resolve(void 0);
+          }
+        });
+      }).on("error", () => {
+        resolve(void 0);
+      });
+    });
+  }
+  async installCli() {
+    const zipUrl = this.getCliDownloadUrl();
+    const zipFile = path6.join(
+      this.resourcesLocation,
+      `wakatime-cli-${Date.now()}.zip`
+    );
+    try {
+      fs5.mkdirSync(this.resourcesLocation, { recursive: true });
+      logger.debug(`Downloading wakatime-cli from ${zipUrl}`);
+      await this.downloadFile(zipUrl, zipFile);
+      logger.debug(`Extracting wakatime-cli to ${this.resourcesLocation}`);
+      await this.extractZip(zipFile, this.resourcesLocation);
+      if (!this.isWindows()) {
+        const cliPath = this.getCliLocation();
+        if (fs5.existsSync(cliPath)) {
+          fs5.chmodSync(cliPath, 493);
+          logger.debug(`Set executable permission on ${cliPath}`);
+        }
+      }
+      logger.info("wakatime-cli installed successfully");
+    } catch (err) {
+      logger.errorException(err);
+      throw err;
+    } finally {
+      try {
+        if (fs5.existsSync(zipFile)) {
+          fs5.unlinkSync(zipFile);
+        }
+      } catch {
+      }
+    }
+  }
+  downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+      const followRedirect = (url2, redirectCount = 0) => {
+        if (redirectCount > 5) {
+          reject(new Error("Too many redirects"));
+          return;
+        }
+        https.get(url2, (res) => {
+          if (res.statusCode === 301 || res.statusCode === 302) {
+            const location = res.headers.location;
+            if (location) {
+              followRedirect(location, redirectCount + 1);
+              return;
+            }
+          }
+          if (res.statusCode !== 200) {
+            reject(new Error(`HTTP ${res.statusCode}`));
+            return;
+          }
+          const file = (0, import_node_fs.createWriteStream)(dest);
+          res.pipe(file);
+          file.on("finish", () => {
+            file.close();
+            resolve();
+          });
+          file.on("error", (err) => {
+            fs5.unlinkSync(dest);
+            reject(err);
+          });
+        }).on("error", reject);
+      };
+      followRedirect(url);
+    });
+  }
+  async extractZip(zipFile, destDir) {
+    const { execSync } = await import("node:child_process");
+    try {
+      if (this.isWindows()) {
+        execSync(
+          `powershell -command "Expand-Archive -Force '${zipFile}' '${destDir}'"`,
+          {
+            windowsHide: true
+          }
+        );
+      } else {
+        execSync(`unzip -o "${zipFile}" -d "${destDir}"`, {
+          stdio: "ignore"
+        });
+      }
+    } catch {
+      logger.warn("Native unzip failed, attempting manual extraction");
+      await this.extractZipManual(zipFile, destDir);
+    }
+  }
+  async extractZipManual(zipFile, destDir) {
+    const data = fs5.readFileSync(zipFile);
+    let offset = 0;
+    while (offset < data.length - 4) {
+      if (data[offset] === 80 && data[offset + 1] === 75 && data[offset + 2] === 3 && data[offset + 3] === 4) {
+        const compressedSize = data.readUInt32LE(offset + 18);
+        const uncompressedSize = data.readUInt32LE(offset + 22);
+        const fileNameLength = data.readUInt16LE(offset + 26);
+        const extraFieldLength = data.readUInt16LE(offset + 28);
+        const fileName = data.slice(offset + 30, offset + 30 + fileNameLength).toString();
+        const dataStart = offset + 30 + fileNameLength + extraFieldLength;
+        const compressionMethod = data.readUInt16LE(offset + 8);
+        if (fileName.includes("wakatime-cli")) {
+          const destPath = path6.join(destDir, path6.basename(fileName));
+          if (compressionMethod === 0) {
+            const fileData = data.slice(
+              dataStart,
+              dataStart + uncompressedSize
+            );
+            fs5.writeFileSync(destPath, fileData);
+          } else if (compressionMethod === 8) {
+            const { inflateRawSync } = await import("node:zlib");
+            const compressedData = data.slice(
+              dataStart,
+              dataStart + compressedSize
+            );
+            const decompressed = inflateRawSync(compressedData);
+            fs5.writeFileSync(destPath, decompressed);
+          }
+          logger.debug(`Extracted ${fileName} to ${destPath}`);
+          return;
+        }
+        offset = dataStart + compressedSize;
+      } else {
+        offset++;
+      }
+    }
+    throw new Error("Could not find wakatime-cli in zip file");
+  }
+};
+var dependencies = new Dependencies();
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/wakatime.ts
+function isWindows() {
+  return os6.platform() === "win32";
+}
+function buildExecOptions() {
+  const options = {
+    windowsHide: true,
+    timeout: 3e4
+  };
+  if (!isWindows() && !process.env.WAKATIME_HOME && !process.env.HOME) {
+    options.env = { ...process.env, WAKATIME_HOME: os6.homedir() };
+  }
+  return options;
+}
+function formatArgs(args) {
+  return args.map((arg) => {
+    if (arg.includes(" ")) {
+      return `"${arg.replace(/"/g, '\\"')}"`;
+    }
+    return arg;
+  }).join(" ");
+}
+async function ensureCliInstalled() {
+  try {
+    await dependencies.checkAndInstallCli();
+    return dependencies.isCliInstalled();
+  } catch (err) {
+    logger.errorException(err);
+    return false;
+  }
+}
+function sendHeartbeat(params) {
+  const cliLocation = dependencies.getCliLocation();
+  if (!dependencies.isCliInstalled()) {
+    logger.warn("wakatime-cli not installed, skipping heartbeat");
+    return;
+  }
+  const args = [
+    "--entity",
+    params.entity,
+    "--entity-type",
+    params.entityType,
+    "--category",
+    params.category ?? "ai coding",
+    "--plugin",
+    `codex/1.0.0 codex-wakatime/${VERSION}`
+  ];
+  if (params.projectFolder) {
+    args.push("--project-folder", params.projectFolder);
+  }
+  if (params.project) {
+    args.push("--project", params.project);
+  }
+  if (params.lineChanges !== void 0 && params.lineChanges !== 0) {
+    args.push("--ai-line-changes", params.lineChanges.toString());
+  }
+  if (params.isWrite) {
+    args.push("--write");
+  }
+  logger.debug(`Sending heartbeat: wakatime-cli ${formatArgs(args)}`);
+  const execOptions = buildExecOptions();
+  (0, import_node_child_process.execFile)(cliLocation, args, execOptions, (error, stdout, stderr) => {
+    const output = (stdout?.toString().trim() ?? "") + (stderr?.toString().trim() ?? "");
+    if (output) {
+      logger.debug(`wakatime-cli output: ${output}`);
+    }
+    if (error) {
+      logger.error(`wakatime-cli error: ${error.message}`);
+    }
+  });
+}
+
+// src/index.ts
+function parseNotification() {
+  const jsonArg = process.argv[2];
+  if (!jsonArg) {
+    return void 0;
+  }
+  if (jsonArg.startsWith("-")) {
+    return void 0;
+  }
+  try {
+    const notification = JSON.parse(jsonArg);
+    return notification;
+  } catch (err) {
+    logger.warnException(err);
+    return void 0;
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--install")) {
+    installHook();
+    return;
+  }
+  if (args.includes("--uninstall")) {
+    uninstallHook();
+    return;
+  }
+  if (isDebugEnabled()) {
+    logger.setLevel(0 /* DEBUG */);
+  }
+  logger.debug("codex-wakatime started");
+  const notification = parseNotification();
+  if (!notification) {
+    logger.debug("No valid notification received");
+    return;
+  }
+  logger.debug(`Received notification: ${notification.type}`);
+  if (notification.type !== "agent-turn-complete") {
+    logger.debug(`Ignoring notification type: ${notification.type}`);
+    return;
+  }
+  if (!shouldSendHeartbeat()) {
+    logger.debug("Skipping heartbeat due to rate limiting");
+    return;
+  }
+  const cliAvailable = await ensureCliInstalled();
+  if (!cliAvailable) {
+    logger.warn("wakatime-cli not available, skipping heartbeat");
+    return;
+  }
+  const assistantMessage = notification["last-assistant-message"] ?? "";
+  const cwd = notification.cwd;
+  const files = extractFilePaths(assistantMessage, cwd);
+  logger.debug(`Extracted ${files.length} files from message`);
+  if (files.length > 0) {
+    for (const file of files) {
+      logger.debug(`Sending heartbeat for file: ${file}`);
+      sendHeartbeat({
+        entity: file,
+        entityType: "file",
+        category: "ai coding",
+        projectFolder: cwd
+      });
+    }
+  } else {
+    logger.debug(`Sending project heartbeat for: ${cwd}`);
+    sendHeartbeat({
+      entity: cwd,
+      entityType: "app",
+      category: "ai coding",
+      project: path7.basename(cwd)
+    });
+  }
+  updateLastHeartbeat();
+  logger.debug("codex-wakatime completed");
+}
+main().catch((err) => {
+  logger.errorException(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "codex-wakatime",
+  "version": "1.0.0",
+  "description": "WakaTime plugin for OpenAI Codex CLI - Track AI coding activity and time spent",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wakatime/codex-wakatime.git"
+  },
+  "type": "module",
+  "main": "dist/index.cjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "codex-wakatime": "dist/index.cjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "node scripts/generate-version.js",
+    "build": "npm run prebuild && esbuild src/index.ts --bundle --platform=node --format=cjs --outfile=dist/index.cjs --banner:js=\"#!/usr/bin/env node\"",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome lint .",
+    "format": "biome format --write .",
+    "check": "biome check .",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "codex",
+    "openai",
+    "wakatime",
+    "time-tracking",
+    "ai",
+    "coding",
+    "productivity"
+  ],
+  "author": "WakaTime",
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.10",
+    "@types/node": "^22.0.0",
+    "@types/which": "^3.0.0",
+    "@vitest/coverage-v8": "^4.0.16",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "@iarna/toml": "^3.0.0",
+    "which": "^4.0.0"
+  }
+}