kimi-wakatime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DanielWTE
+
+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,169 @@
+# kimi-wakatime
+
+WakaTime integration for [Kimi Code CLI](https://www.kimi.com/code/). Track AI coding activity and time spent.
+
+Inspired by [codex-wakatime](https://github.com/angristan/codex-wakatime).
+
+## Features
+
+- Automatic time tracking for Kimi Code CLI sessions
+- File-level write heartbeats when Kimi edits or creates files (`Edit`/`Write` tools)
+- Project-level heartbeats on prompts and completed turns
+- Heartbeats categorized as **AI coding** in your WakaTime dashboard
+- 60-second heartbeat rate limiting
+- Automatic `wakatime-cli` installation if missing
+- Zero dependencies, plain Node.js (>= 18)
+
+## Prerequisites
+
+1. A [WakaTime](https://wakatime.com) account and API key
+2. API key configured in `~/.wakatime.cfg`:
+
+   ```ini
+   [settings]
+   api_key = your-api-key-here
+   ```
+
+3. [Kimi Code CLI](https://www.kimi.com/code/) installed
+
+## Installation
+
+```sh
+# Install the package
+npm install -g kimi-wakatime
+
+# Register the Kimi Code hooks
+kimi-wakatime --install
+```
+
+This appends `[[hooks]]` entries to `~/.kimi-code/config.toml`. Start a new
+Kimi Code session to activate them.
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Kimi Code CLI Session                     │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│   Hooks (configured in ~/.kimi-code/config.toml)            │
+│   - UserPromptSubmit  → project-level heartbeat             │
+│   - PostToolUse (Edit|Write) → file-level write heartbeat   │
+│   - Stop              → project-level heartbeat             │
+│   Payload arrives as JSON on stdin:                         │
+│   { hook_event_name, session_id, cwd, tool_input, ... }     │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│                     kimi-wakatime                           │
+│   1. Parse hook JSON from stdin                             │
+│   2. Extract file path from Edit/Write tool input           │
+│   3. Check 60-second rate limit                             │
+│   4. Spawn wakatime-cli detached (never blocks the session) │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    WakaTime Dashboard                       │
+│   Time appears under category "AI coding",                  │
+│   editor "kimi-wakatime"                                    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Installed hook configuration
+
+`kimi-wakatime --install` appends this to `~/.kimi-code/config.toml`:
+
+```toml
+# >>> kimi-wakatime >>>
+[[hooks]]
+event = "PostToolUse"
+matcher = "^(Edit|Write)$"
+command = "kimi-wakatime --hook"
+timeout = 15
+
+[[hooks]]
+event = "Stop"
+command = "kimi-wakatime --hook"
+timeout = 15
+
+[[hooks]]
+event = "UserPromptSubmit"
+command = "kimi-wakatime --hook"
+timeout = 15
+# <<< kimi-wakatime <<<
+```
+
+The marker comments make `--uninstall` and re-installs safe and idempotent.
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `kimi-wakatime --install` | Add hooks to `~/.kimi-code/config.toml` |
+| `kimi-wakatime --uninstall` | Remove hooks from `~/.kimi-code/config.toml` |
+| `kimi-wakatime --hook` | Process a hook payload from stdin (called by Kimi Code) |
+| `kimi-wakatime --version` | Print version |
+| `kimi-wakatime --help` | Show help |
+
+## Files & Locations
+
+| File | Purpose |
+| --- | --- |
+| `~/.wakatime/kimi.json` | Rate limiting state |
+| `~/.wakatime/kimi.log` | Debug logs |
+| `~/.kimi-code/config.toml` | Kimi Code configuration |
+| `~/.wakatime.cfg` | WakaTime API key and settings |
+| `~/.wakatime/wakatime-cli-*` | Auto-downloaded wakatime-cli (if not already in PATH) |
+
+## Debug Mode
+
+Enable debug logging by adding to `~/.wakatime.cfg`:
+
+```ini
+[settings]
+debug = true
+```
+
+Logs are written to `~/.wakatime/kimi.log`. wakatime-cli's own log is at
+`~/.wakatime/wakatime.log` (pass `--verbose` there for more detail).
+
+## Troubleshooting
+
+### No heartbeats being sent
+
+1. Check that your API key is configured in `~/.wakatime.cfg`
+2. Verify the hooks are present in `~/.kimi-code/config.toml` and you started a **new** session after installing
+3. Enable debug mode and check `~/.wakatime/kimi.log`
+4. Confirm heartbeats arrive on the [plugin status page](https://wakatime.com/plugins/status)
+
+### Rate limiting
+
+Heartbeats for the same entity are limited to one per 60 seconds (write events
+always go through). If you're testing, wait at least 60 seconds between turns.
+
+### wakatime-cli not found
+
+The plugin automatically downloads `wakatime-cli` from
+[GitHub releases](https://github.com/wakatime/wakatime-cli/releases) if it's
+not in your PATH or `~/.wakatime/`. If that fails, install it manually.
+
+## Uninstall
+
+```sh
+kimi-wakatime --uninstall
+npm uninstall -g kimi-wakatime
+```
+
+## Development
+
+```sh
+npm test    # run tests (node:test, no dependencies)
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "kimi-wakatime",
+  "version": "0.1.0",
+  "description": "WakaTime integration for Kimi Code CLI - track AI coding activity and time spent",
+  "type": "module",
+  "bin": {
+    "kimi-wakatime": "src/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test 'test/*.test.js'"
+  },
+  "keywords": [
+    "wakatime",
+    "kimi",
+    "kimi-code",
+    "time-tracking",
+    "ai-coding"
+  ],
+  "license": "MIT"
+}

package/src/extractor.js

@@ -0,0 +1,21 @@
+// Extract file paths from Kimi Code hook payloads.
+import { isAbsolute, resolve } from 'node:path';
+
+// Tool input fields that may carry the target file path,
+// depending on the tool (Edit/Write use `path`).
+const PATH_FIELDS = ['path', 'file_path', 'filePath', 'target_file', 'filename'];
+
+/**
+ * Extract the edited/written file path from a PostToolUse tool_input object.
+ * Returns an absolute path, or null if no path was found.
+ */
+export function extractFilePath(toolInput, cwd) {
+  if (!toolInput || typeof toolInput !== 'object') return null;
+  for (const field of PATH_FIELDS) {
+    const value = toolInput[field];
+    if (typeof value === 'string' && value.length > 0) {
+      return isAbsolute(value) ? value : resolve(cwd, value);
+    }
+  }
+  return null;
+}

package/src/index.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// kimi-wakatime: WakaTime integration for Kimi Code CLI
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+import { install, uninstall } from './install.js';
+import { extractFilePath } from './extractor.js';
+import { shouldSend, markSent } from './state.js';
+import { ensureCli, sendHeartbeat } from './wakatime.js';
+import { log } from './logger.js';
+
+const pkg = JSON.parse(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'),
+);
+const PLUGIN_ID = `kimi-wakatime/${pkg.version}`;
+
+const HELP = `kimi-wakatime v${pkg.version} - WakaTime integration for Kimi Code CLI
+
+Usage:
+  kimi-wakatime --install     Add WakaTime hooks to ~/.kimi-code/config.toml
+  kimi-wakatime --uninstall   Remove the hooks from ~/.kimi-code/config.toml
+  kimi-wakatime --hook        Process a Kimi Code hook payload from stdin
+  kimi-wakatime --version     Print version
+  kimi-wakatime --help        Show this help
+
+Prerequisites: a WakaTime API key in ~/.wakatime.cfg
+  [settings]
+  api_key = your-api-key-here
+`;
+
+function readStdin() {
+  return new Promise((resolveP) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolveP(data));
+    // no stdin (e.g. run manually without a pipe): bail out quickly
+    if (process.stdin.isTTY) resolveP('');
+  });
+}
+
+async function handleHook() {
+  const raw = await readStdin();
+  let payload = {};
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    log('hook invoked with unparseable payload, ignoring');
+    return;
+  }
+
+  const event = payload.hook_event_name ?? '';
+  const cwd = payload.cwd || process.cwd();
+  log('hook event:', event, 'cwd:', cwd);
+
+  let entity;
+  let isWrite = false;
+
+  if (event === 'PostToolUse') {
+    // Edit/Write tools: file-level write heartbeat
+    const file = extractFilePath(payload.tool_input, cwd);
+    if (!file) {
+      log('no file path in tool_input, skipping');
+      return;
+    }
+    entity = file;
+    isWrite = true;
+  } else {
+    // Stop / UserPromptSubmit / anything else: project-level heartbeat
+    entity = cwd;
+  }
+
+  if (!shouldSend(entity, { isWrite })) {
+    log('rate limited, skipping:', entity);
+    return;
+  }
+  markSent(entity);
+
+  const cli = await ensureCli();
+  sendHeartbeat({ cli, entity, cwd, isWrite, plugin: PLUGIN_ID });
+}
+
+async function main() {
+  const arg = process.argv[2];
+  try {
+    switch (arg) {
+      case '--install': {
+        const file = install();
+        console.log(`WakaTime hooks installed into ${file}`);
+        console.log('Start a new Kimi Code session to activate them.');
+        break;
+      }
+      case '--uninstall': {
+        const removed = uninstall();
+        console.log(removed ? 'WakaTime hooks removed from ~/.kimi-code/config.toml' : 'No kimi-wakatime hooks found.');
+        break;
+      }
+      case '--hook':
+        await handleHook();
+        break;
+      case '--version':
+        console.log(pkg.version);
+        break;
+      case '--help':
+      case undefined:
+        console.log(HELP);
+        break;
+      default:
+        console.error(`Unknown argument: ${arg}\n`);
+        console.log(HELP);
+        process.exitCode = 1;
+    }
+  } catch (err) {
+    // Hooks must fail open: never break a Kimi Code session.
+    log('error:', err?.stack ?? err);
+    if (arg !== '--hook') {
+      console.error(`Error: ${err?.message ?? err}`);
+      process.exitCode = 1;
+    }
+  }
+}
+
+main();

package/src/install.js

@@ -0,0 +1,59 @@
+// Install/uninstall hooks in ~/.kimi-code/config.toml
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+
+const CONFIG_FILE = join(homedir(), '.kimi-code', 'config.toml');
+const START_MARK = '# >>> kimi-wakatime >>>';
+const END_MARK = '# <<< kimi-wakatime <<<';
+
+const HOOKS_BLOCK = `
+${START_MARK}
+[[hooks]]
+event = "PostToolUse"
+matcher = "^(Edit|Write)$"
+command = "kimi-wakatime --hook"
+timeout = 15
+
+[[hooks]]
+event = "Stop"
+command = "kimi-wakatime --hook"
+timeout = 15
+
+[[hooks]]
+event = "UserPromptSubmit"
+command = "kimi-wakatime --hook"
+timeout = 15
+${END_MARK}
+`;
+
+function readConfig() {
+  return existsSync(CONFIG_FILE) ? readFileSync(CONFIG_FILE, 'utf8') : '';
+}
+
+export function install() {
+  let config = readConfig();
+  if (config.includes(START_MARK)) {
+    // already installed: replace old block with current version
+    config = removeBlock(config);
+  }
+  mkdirSync(dirname(CONFIG_FILE), { recursive: true });
+  const separator = config.length > 0 && !config.endsWith('\n') ? '\n' : '';
+  writeFileSync(CONFIG_FILE, config + separator + HOOKS_BLOCK);
+  return CONFIG_FILE;
+}
+
+function removeBlock(config) {
+  const start = config.indexOf(START_MARK);
+  const end = config.indexOf(END_MARK);
+  if (start === -1 || end === -1 || end < start) return config;
+  return (config.slice(0, start) + config.slice(end + END_MARK.length)).replace(/\n{3,}/g, '\n\n');
+}
+
+export function uninstall() {
+  const config = readConfig();
+  const cleaned = removeBlock(config);
+  if (cleaned === config) return false;
+  writeFileSync(CONFIG_FILE, cleaned);
+  return true;
+}

package/src/logger.js

@@ -0,0 +1,33 @@
+// Debug logging to ~/.wakatime/kimi.log, enabled via `debug = true` in ~/.wakatime.cfg
+import { appendFileSync, readFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const WAKATIME_DIR = join(homedir(), '.wakatime');
+const LOG_FILE = join(WAKATIME_DIR, 'kimi.log');
+const CONFIG_FILE = join(homedir(), '.wakatime.cfg');
+
+let debugEnabled = null;
+
+function isDebug() {
+  if (debugEnabled === null) {
+    try {
+      const cfg = readFileSync(CONFIG_FILE, 'utf8');
+      debugEnabled = /^\s*debug\s*=\s*true\s*$/im.test(cfg);
+    } catch {
+      debugEnabled = false;
+    }
+  }
+  return debugEnabled;
+}
+
+export function log(...args) {
+  if (!isDebug()) return;
+  try {
+    mkdirSync(WAKATIME_DIR, { recursive: true });
+    const line = `${new Date().toISOString()} ${args.map(String).join(' ')}\n`;
+    appendFileSync(LOG_FILE, line);
+  } catch {
+    // never break the hook because of logging
+  }
+}

package/src/state.js

@@ -0,0 +1,50 @@
+// Rate limiting state: at most one heartbeat per entity per 60 seconds.
+// State lives in ~/.wakatime/kimi.json
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const STATE_FILE = join(homedir(), '.wakatime', 'kimi.json');
+export const RATE_LIMIT_SECONDS = 60;
+
+function loadState() {
+  try {
+    return JSON.parse(readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveState(state) {
+  try {
+    mkdirSync(join(homedir(), '.wakatime'), { recursive: true });
+    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch {
+    // ignore: rate limiting is best-effort
+  }
+}
+
+/**
+ * Decide whether a heartbeat for `entity` should be sent now.
+ * Write events always pass. Otherwise skip if the same entity was
+ * sent less than RATE_LIMIT_SECONDS ago.
+ */
+export function shouldSend(entity, { isWrite = false, now = Date.now() } = {}) {
+  if (isWrite) return true;
+  const state = loadState();
+  const last = state[entity];
+  return !last || now - last >= RATE_LIMIT_SECONDS * 1000;
+}
+
+export function markSent(entity, now = Date.now()) {
+  const state = loadState();
+  state[entity] = now;
+  // keep the file small
+  const keys = Object.keys(state);
+  if (keys.length > 500) {
+    for (const k of keys.sort((a, b) => state[a] - state[b]).slice(0, keys.length - 500)) {
+      delete state[k];
+    }
+  }
+  saveState(state);
+}

package/src/wakatime.js

@@ -0,0 +1,114 @@
+// wakatime-cli discovery, installation and invocation.
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, mkdirSync, chmodSync, createWriteStream, unlinkSync } from 'node:fs';
+import { homedir, platform, arch } from 'node:os';
+import { join } from 'node:path';
+import { log } from './logger.js';
+
+const WAKATIME_DIR = join(homedir(), '.wakatime');
+const RELEASE_API = 'https://api.github.com/repos/wakatime/wakatime-cli/releases/latest';
+
+function isWindows() {
+  return platform() === 'win32';
+}
+
+function run(cmd, args) {
+  const r = spawnSync(cmd, args, { stdio: 'ignore', timeout: 10_000 });
+  return r.status === 0;
+}
+
+/** Locate a usable wakatime-cli binary, or null. */
+export function findCli() {
+  // 1. PATH
+  if (run('wakatime-cli', ['--version'])) return 'wakatime-cli';
+
+  // 2. ~/.wakatime/wakatime-cli* (layout used by all official plugins)
+  try {
+    const entries = readdirSync(WAKATIME_DIR);
+    const candidate = entries.find((e) => {
+      if (!e.startsWith('wakatime-cli')) return false;
+      if (isWindows()) return e.endsWith('.exe');
+      return !e.includes('.') || e.startsWith(`wakatime-cli-${platform()}`);
+    });
+    if (candidate) {
+      const full = join(WAKATIME_DIR, candidate);
+      if (run(full, ['--version'])) return full;
+    }
+  } catch {
+    // dir does not exist yet
+  }
+  return null;
+}
+
+async function download(url, dest) {
+  const res = await fetch(url, { redirect: 'follow' });
+  if (!res.ok) throw new Error(`download failed: HTTP ${res.status} for ${url}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  const w = createWriteStream(dest);
+  w.write(buf);
+  await new Promise((resolveP, reject) => {
+    w.end(resolveP);
+    w.on('error', reject);
+  });
+}
+
+/** Download the latest wakatime-cli release into ~/.wakatime and return its path. */
+export async function installCli() {
+  const osName = { darwin: 'darwin', linux: 'linux', win32: 'windows' }[platform()];
+  if (!osName) throw new Error(`unsupported platform: ${platform()}`);
+  const archName = { x64: 'amd64', arm64: 'arm64' }[arch()] ?? 'amd64';
+
+  const res = await fetch(RELEASE_API, {
+    headers: { 'User-Agent': 'kimi-wakatime' },
+  });
+  if (!res.ok) throw new Error(`GitHub API failed: HTTP ${res.status}`);
+  const release = await res.json();
+  const tag = release.tag_name; // e.g. v1.115.0
+  const name = `wakatime-cli-${osName}-${archName}`;
+  const url = `https://github.com/wakatime/wakatime-cli/releases/download/${tag}/${name}.zip`;
+
+  mkdirSync(WAKATIME_DIR, { recursive: true });
+  const zipPath = join(WAKATIME_DIR, `${name}.zip`);
+  log('downloading', url);
+  await download(url, zipPath);
+
+  // bsdtar (ships with macOS, Linux and Windows 10+) extracts zips fine
+  const r = spawnSync('tar', ['-xf', zipPath, '-C', WAKATIME_DIR], { stdio: 'ignore' });
+  unlinkSync(zipPath);
+  if (r.status !== 0) throw new Error('failed to extract wakatime-cli zip');
+
+  const binName = isWindows() ? `${name}.exe` : name;
+  const binPath = join(WAKATIME_DIR, binName);
+  if (!existsSync(binPath)) throw new Error(`expected binary missing after extract: ${binPath}`);
+  if (!isWindows()) chmodSync(binPath, 0o755);
+  return binPath;
+}
+
+/** Resolve a usable wakatime-cli, downloading it if necessary. */
+export async function ensureCli() {
+  const existing = findCli();
+  if (existing) return existing;
+  log('wakatime-cli not found, installing');
+  return installCli();
+}
+
+/**
+ * Send a heartbeat. Spawns wakatime-cli detached so the hook returns
+ * immediately and never blocks the Kimi Code session.
+ */
+export function sendHeartbeat({ cli, entity, cwd, isWrite, plugin }) {
+  const args = [
+    '--entity', entity,
+    '--plugin', plugin,
+    '--category', 'ai coding',
+    '--alternate-project', cwd.split(/[\\/]/).filter(Boolean).pop() || 'unknown',
+  ];
+  if (isWrite) args.push('--write');
+  log('heartbeat:', cli, args.join(' '));
+  const child = spawn(cli, args, {
+    cwd,
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+}

package/test/extractor.test.js

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolve } from 'node:path';
+import { extractFilePath } from '../src/extractor.js';
+
+const cwd = '/Users/test/project';
+
+test('extracts absolute path as-is', () => {
+  assert.equal(
+    extractFilePath({ path: '/Users/test/project/src/a.ts' }, cwd),
+    '/Users/test/project/src/a.ts',
+  );
+});
+
+test('resolves relative path against cwd', () => {
+  assert.equal(
+    extractFilePath({ path: 'src/a.ts' }, cwd),
+    resolve(cwd, 'src/a.ts'),
+  );
+});
+
+test('supports alternative field names', () => {
+  assert.equal(extractFilePath({ file_path: 'a.ts' }, cwd), resolve(cwd, 'a.ts'));
+  assert.equal(extractFilePath({ filePath: 'b.ts' }, cwd), resolve(cwd, 'b.ts'));
+});
+
+test('returns null when no path is present', () => {
+  assert.equal(extractFilePath({ command: 'ls' }, cwd), null);
+  assert.equal(extractFilePath({}, cwd), null);
+  assert.equal(extractFilePath(null, cwd), null);
+  assert.equal(extractFilePath(undefined, cwd), null);
+});

package/test/install.test.js

@@ -0,0 +1,59 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { install, uninstall } from '../src/install.js';
+import { readFileSync, writeFileSync, existsSync, rmSync, mkdirSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// Redirect the config file location by monkey-patching is not trivial in ESM,
+// so test the block logic through the real functions against a temp HOME copy
+// is also invasive. Instead, test idempotency invariants on a scratch string
+// via the exported install/uninstall against a temporary .kimi-code dir.
+
+const CONFIG_DIR = join(homedir(), '.kimi-code');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.toml');
+
+function backup() {
+  return existsSync(CONFIG_FILE) ? readFileSync(CONFIG_FILE, 'utf8') : null;
+}
+
+function restore(content) {
+  if (content === null) {
+    rmSync(CONFIG_FILE, { force: true });
+  } else {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, content);
+  }
+}
+
+test('install then uninstall restores the original config', () => {
+  const original = backup();
+  try {
+    install();
+    const withHooks = readFileSync(CONFIG_FILE, 'utf8');
+    assert.match(withHooks, /kimi-wakatime --hook/);
+    assert.match(withHooks, /event = "PostToolUse"/);
+    assert.match(withHooks, /event = "Stop"/);
+    assert.match(withHooks, /event = "UserPromptSubmit"/);
+
+    assert.equal(uninstall(), true);
+    const after = readFileSync(CONFIG_FILE, 'utf8');
+    assert.equal(after.trimEnd(), (original ?? '').trimEnd());
+    assert.equal(uninstall(), false); // nothing left to remove
+  } finally {
+    restore(original);
+  }
+});
+
+test('install is idempotent (replaces its own block)', () => {
+  const original = backup();
+  try {
+    install();
+    install();
+    const content = readFileSync(CONFIG_FILE, 'utf8');
+    const matches = content.match(/kimi-wakatime --hook/g) ?? [];
+    assert.equal(matches.length, 3); // exactly one block with three hooks
+  } finally {
+    restore(original);
+  }
+});