embertime 0.1.3 → 0.1.5

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "ember",
   "description": "Ember coding-time tracker: records Claude Code sessions, prompts and file edits as anonymised Ember heartbeats (no prompt text, file contents or paths are sent).",
-  "version": "0.1.3"
+  "version": "0.1.4"
 }

package/cli.mjs

@@ -193,6 +193,7 @@ function uninstall(o) {
 const HELP = `embertime: track coding time across editors and AI agents
 
   npx embertime setup --key <ember_key> [--api-url <url>] [--vsix <file>] [--skip-editors]
+  npx embertime setup                     re-run with the key you already saved
   npx embertime status
   npx embertime uninstall [--purge]
 

package/ember-hook.mjs

@@ -9,19 +9,22 @@
 //   * never writes to stdout for Claude Code / Codex (they may interpret it); for
 //     Cursor it prints the minimal JSON reply Cursor expects. Always exits 0
 //   * never sends file contents, raw paths or prompt text: files are reduced
-//     to sha1(absolute path) and the project to the git root's basename
+//     to an HMAC of the absolute path, keyed with a random per-machine secret
+//     (~/.ember/entity.key), and the project to the git root's basename
 //   * heartbeats are appended to ~/.ember/queue.jsonl before any network I/O,
 //     so nothing is lost when the server is down
 //
-// Environment overrides: EMBER_HOME (default ~/.ember), EMBER_API_URL, EMBER_API_KEY.
+// Environment overrides: EMBER_HOME (default ~/.ember), EMBER_API_URL, EMBER_API_KEY,
+// EMBER_SEND_BRANCH=0 (don't send branch names).
 
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
-export const VERSION = '0.1.3';
+export const VERSION = '0.1.5';
 export const AGENTS = ['claude-code', 'codex', 'cursor-agent'];
 
 /** Events whose heartbeats are throttled: they fire on every tool call or file edit. */
@@ -59,6 +62,7 @@ function paths(home) {
     state: path.join(home, 'hook-state.json'),
     log: path.join(home, 'hook.log'),
     lastError: path.join(home, 'last_error'),
+    entityKey: path.join(home, 'entity.key'),
   };
 }
 
@@ -70,12 +74,16 @@ function readJson(file, fallback) {
   }
 }
 
-/** Resolve API URL + key: env overrides win over ~/.ember/config.json. */
+/**
+ * Resolve API URL + key: env overrides win over ~/.ember/config.json.
+ * `send_branch: false` (or EMBER_SEND_BRANCH=0) keeps branch names on this machine.
+ */
 export function loadConfig(home, env = process.env) {
   const cfg = readJson(paths(home).config, {}) || {};
   const apiUrl = String(env.EMBER_API_URL || cfg.api_url || DEFAULT_API_URL).replace(/\/+$/, '');
   const apiKey = env.EMBER_API_KEY || cfg.api_key || '';
-  return { apiUrl, apiKey };
+  const sendBranch = env.EMBER_SEND_BRANCH !== undefined ? env.EMBER_SEND_BRANCH !== '0' : cfg.send_branch !== false;
+  return { apiUrl, apiKey, sendBranch };
 }
 
 function writeAtomic(file, data) {
@@ -361,6 +369,56 @@ export function isWriteTool(toolName) {
   return typeof toolName === 'string' && WRITE_TOOLS.has(toolName.toLowerCase());
 }
 
+/** Shell tools (Claude Code's Bash, Codex's shell). They can write files without naming them. */
+const SHELL_TOOLS = new Set(['bash', 'shell', 'local_shell', 'exec_command']);
+
+export function isShellTool(toolName) {
+  return typeof toolName === 'string' && SHELL_TOOLS.has(toolName.toLowerCase());
+}
+
+const SHELL_LOOKBACK_S = 600; // never credit a shell command with edits older than this
+const SHELL_FIRST_LOOKBACK_S = 120; // when there is no earlier event to measure from
+const GIT_TIMEOUT_MS = 1_500;
+const MAX_CHANGED_FILES = 5_000;
+
+/**
+ * The file a shell command most likely wrote: among files git reports as
+ * modified, or new and not ignored, under `root`, the one changed most recently
+ * after `sinceSec`. Ignored paths (node_modules, build output) never count, and
+ * `git pull` or `git checkout` leave nothing modified, so they don't either.
+ */
+export function recentlyChangedFile(root, sinceSec) {
+  let out;
+  try {
+    out = execFileSync('git', ['-C', root, 'ls-files', '--modified', '--others', '--exclude-standard', '-z'], {
+      encoding: 'utf8',
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return undefined; // not a git checkout, git missing, or too slow
+  }
+  let best;
+  let bestTime = sinceSec;
+  const names = out.split('\0');
+  for (let i = 0; i < names.length && i < MAX_CHANGED_FILES; i++) {
+    if (!names[i]) continue;
+    const abs = path.join(root, names[i]);
+    let mtime;
+    try {
+      mtime = fs.statSync(abs).mtimeMs / 1000;
+    } catch {
+      continue; // deleted
+    }
+    if (mtime > bestTime) {
+      best = abs;
+      bestTime = mtime;
+    }
+  }
+  return best;
+}
+
 /** All file paths named in an apply_patch body ("*** Update File: path", Add/Delete/Move to). */
 export function parseApplyPatchPaths(text) {
   if (typeof text !== 'string') return [];
@@ -409,8 +467,57 @@ export function extractFilePath(toolInput, cwd) {
   return path.resolve(cwd || process.cwd(), p);
 }
 
-export function sha1(text) {
-  return crypto.createHash('sha1').update(text).digest('hex');
+/**
+ * File identity sent as `entity`: HMAC-SHA256 of the absolute path under the
+ * per-machine key, cut to the 40 hex characters the server accepts. A plain hash
+ * of a path could be reversed by guessing likely paths; without the key it can't.
+ */
+export function entityHash(key, file) {
+  return crypto.createHmac('sha256', key).update(file).digest('hex').slice(0, 40);
+}
+
+const ENTITY_KEY_RE = /^[a-f0-9]{64}$/;
+
+function readEntityKey(file) {
+  try {
+    const key = fs.readFileSync(file, 'utf8').trim();
+    return ENTITY_KEY_RE.test(key) ? key : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The random key shared by every collector on this machine (mode 0600), created
+ * on first use. Concurrent first runs agree on one key: the first hard link wins.
+ * If it can't be stored, a one-off key is used: entities then differ between runs,
+ * which only weakens de-duplication, never privacy.
+ */
+export function loadEntityKey(home) {
+  const file = paths(home).entityKey;
+  const existing = readEntityKey(file);
+  if (existing) return existing;
+  const key = crypto.randomBytes(32).toString('hex');
+  const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  try {
+    fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(tmp, `${key}\n`, { mode: 0o600 });
+    try {
+      fs.linkSync(tmp, file);
+      return key;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      const winner = readEntityKey(file);
+      if (winner) return winner;
+      fs.renameSync(tmp, file); // existing file is corrupt: replace it
+      return key;
+    }
+  } catch (e) {
+    log(home, 'warn', `could not store entity key: ${e.message}`);
+    return key;
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
 }
 
 export function parsePayload(text) {
@@ -423,15 +530,22 @@ export function parsePayload(text) {
   }
 }
 
+/** Working directory of a hook payload. Claude Code and Codex send `cwd`; Cursor sends `workspace_roots` (and sets CURSOR_PROJECT_DIR). */
+export function payloadCwd(payload, env = process.env) {
+  const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots.filter((r) => typeof r === 'string' && r) : [];
+  return (typeof payload.cwd === 'string' && payload.cwd) || roots[0] || env.CURSOR_PROJECT_DIR || process.cwd();
+}
+
 /**
  * Build exactly one heartbeat from a hook payload. Only derived, non-sensitive
  * fields are copied: never prompt text, tool output, file contents or paths.
+ * `changedFile` is a file a shell command was found to have written.
  */
-export function buildHeartbeat(payload, { agent, now = Date.now() / 1000, env = process.env } = {}) {
-  // Claude Code and Codex send `cwd`; Cursor sends `workspace_roots` (and sets CURSOR_PROJECT_DIR).
-  const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots.filter((r) => typeof r === 'string' && r) : [];
-  const cwd =
-    (typeof payload.cwd === 'string' && payload.cwd) || roots[0] || env.CURSOR_PROJECT_DIR || process.cwd();
+export function buildHeartbeat(
+  payload,
+  { agent, now = Date.now() / 1000, env = process.env, entityKey, sendBranch = true, changedFile } = {},
+) {
+  const cwd = payloadCwd(payload, env);
   const root = findGitRoot(cwd);
   const projectDir = root || path.resolve(cwd);
   const hb = {
@@ -439,18 +553,19 @@ export function buildHeartbeat(payload, { agent, now = Date.now() / 1000, env =
     project: path.basename(projectDir) || 'unknown',
     editor: agent,
     category: 'ai',
-    is_write: isWriteTool(payload.tool_name) || payload.hook_event_name === 'afterFileEdit',
+    is_write: Boolean(changedFile) || isWriteTool(payload.tool_name) || payload.hook_event_name === 'afterFileEdit',
   };
-  if (root) {
+  if (root && sendBranch) {
     const branch = readBranch(root);
     if (branch) hb.branch = branch;
   }
   // Cursor's afterFileEdit puts the edited file at the top level.
   const file =
+    changedFile ||
     extractFilePath(payload.tool_input, cwd) ||
     (typeof payload.file_path === 'string' && payload.file_path.trim() ? path.resolve(cwd, payload.file_path.trim()) : undefined);
   if (file) {
-    hb.entity = sha1(file);
+    hb.entity = entityHash(entityKey ?? loadEntityKey(emberHome(env)), file);
     const language = languageForPath(file);
     if (language) hb.language = language;
   }
@@ -758,20 +873,39 @@ export async function runHook({ argv = [], env = process.env, stdinText = '' } =
     }
     const payload = parsePayload(stdinText);
     const event = typeof payload.hook_event_name === 'string' ? payload.hook_event_name : '';
-    const hb = buildHeartbeat(payload, { agent, env });
-    const { apiUrl, apiKey } = loadConfig(home, env);
+    const { apiUrl, apiKey, sendBranch } = loadConfig(home, env);
+    let hb = buildHeartbeat(payload, { agent, env, sendBranch });
+
+    // Every event records when this agent last acted in this project, so a shell
+    // command is only credited with files changed since the agent's previous step.
+    const state = readState(home);
+    const key = `${hb.editor}|${hb.project}`;
+    const previous = state.seen?.[key];
+    state.seen = { ...(state.seen || {}), [key]: hb.time };
+
+    if (!hb.is_write && event === 'PostToolUse' && isShellTool(payload.tool_name) && !shouldThrottle(state, hb, event)) {
+      const root = findGitRoot(payloadCwd(payload, env));
+      const since = typeof previous === 'number'
+        ? Math.max(previous, hb.time - SHELL_LOOKBACK_S)
+        : hb.time - SHELL_FIRST_LOOKBACK_S;
+      const changedFile = root && recentlyChangedFile(root, since);
+      if (changedFile) hb = buildHeartbeat(payload, { agent, env, sendBranch, changedFile, now: hb.time });
+    }
 
     // Only an agent changing a file counts as coding. Opening a session,
     // sending a prompt or reading files does not; those events just deliver
     // anything still queued.
     if (!hb.is_write) {
+      writeState(home, state);
       await flushQueue(home, { apiUrl, apiKey });
       return { status: 'not-writing' };
     }
 
-    const state = readState(home);
-    if (shouldThrottle(state, hb, event)) return { status: 'throttled' };
-    state.last = { ...(state.last || {}), [`${hb.editor}|${hb.project}`]: hb.time };
+    if (shouldThrottle(state, hb, event)) {
+      writeState(home, state);
+      return { status: 'throttled' };
+    }
+    state.last = { ...(state.last || {}), [key]: hb.time };
     writeState(home, state);
 
     appendToQueue(home, hb);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "embertime",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Connect VS Code, Cursor, Windsurf, Claude Code and Codex to Ember in one command. Tracks coding time, never code or prompts.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "cli.mjs",
     "editors.mjs",
+    "postinstall.mjs",
     "ember-hook.mjs",
     "install.mjs",
     "hooks",
@@ -30,7 +31,8 @@
     "heatmap"
   ],
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "node --test test/*.test.mjs",
+    "postinstall": "node postinstall.mjs"
   },
   "repository": {
     "type": "git",

package/postinstall.mjs

@@ -0,0 +1,20 @@
+// Runs after `npm install -g embertime` (and upgrades). If Ember was already set
+// up on this machine, refresh the hook copy in ~/.ember/agent-hook so agents run
+// the new version straight away. Your key in ~/.ember/config.json is untouched.
+// Best effort: it never fails the install and does nothing on a fresh machine.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+try {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const dest = path.join(process.env.EMBER_HOME || path.join(os.homedir(), '.ember'), 'agent-hook');
+  if (fs.existsSync(path.join(dest, 'ember-hook.mjs'))) {
+    for (const f of ['ember-hook.mjs', 'install.mjs', 'package.json']) fs.copyFileSync(path.join(here, f), path.join(dest, f));
+    console.log('embertime: updated the hook in ~/.ember/agent-hook (your key is unchanged).');
+  }
+} catch {
+  /* never block an install */
+}