codetime-cli 0.6.0 → 0.7.1

package/bin/codetime.mjs

@@ -19,10 +19,13 @@ __export(fs_exports, {
   parseJsonFile: () => parseJsonFile,
   pathExists: () => pathExists,
   readJsonIfExists: () => readJsonIfExists,
+  readJsonIfExistsTolerant: () => readJsonIfExistsTolerant,
   readTextIfExists: () => readTextIfExists,
+  writeFileAtomic: () => writeFileAtomic,
   writeGeneratedFile: () => writeGeneratedFile
 });
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { mkdir, open, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 async function pathExists(filePath) {
   try {
@@ -56,6 +59,59 @@ function parseJsonFile(filePath, text) {
     throw new Error(`Could not parse JSON file ${filePath}: ${error.message}`);
   }
 }
+async function readJsonIfExistsTolerant(filePath, onCorrupt) {
+  const text = await readTextIfExists(filePath);
+  if (text === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    onCorrupt?.(error);
+    return null;
+  }
+}
+async function writeFileAtomic(filePath, data, options = {}) {
+  const dir = path.dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const tmpPath = path.join(
+    dir,
+    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomBytes(6).toString("hex")}.tmp`
+  );
+  let handle;
+  try {
+    handle = await open(tmpPath, "wx", options.mode ?? 438);
+    await handle.writeFile(data, "utf8");
+    if (options.mode !== void 0) {
+      await handle.chmod(options.mode);
+    }
+    await handle.close();
+    handle = void 0;
+    await renameWithRetry(tmpPath, filePath);
+  } catch (error) {
+    if (handle) {
+      await handle.close().catch(() => {
+      });
+    }
+    await rm(tmpPath, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+}
+async function renameWithRetry(from, to, attempts = 5) {
+  for (let i = 0; ; i++) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (i >= attempts - 1 || code !== "EPERM" && code !== "EACCES" && code !== "EBUSY") {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10 * (i + 1)));
+    }
+  }
+}
 async function writeGeneratedFile(filePath, content, { dryRun, force, onWrite }) {
   if (dryRun) {
     onWrite(`Would write ${filePath}`);
@@ -152,7 +208,7 @@ var init_fs = __esm({
 
 // src/cli.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir3, rm, stat as stat6, writeFile as writeFile2 } from "node:fs/promises";
+import { rm as rm2, stat as stat6 } from "node:fs/promises";
 import os3 from "node:os";
 import path13 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -160,7 +216,7 @@ import { fileURLToPath } from "node:url";
 // ../shared/src/index.ts
 import { createHash } from "node:crypto";
 var AGENT_TIME_SCHEMA_VERSION = "2026-04-29";
-var AGENT_ROLLUP_SCHEMA_VERSION = 2;
+var AGENT_ROLLUP_SCHEMA_VERSION = 3;
 var TELEMETRY_EVENT_TYPES = [
   "session.started",
   "session.ended",
@@ -974,7 +1030,7 @@ import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import path2 from "node:path";
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.6.0" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.7.1" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -1932,16 +1988,29 @@ function claudeUsageFromMessage(message) {
   const outputTokens = numberField(usage, "output_tokens") || 0;
   const cachedInputTokens = cacheCreationInputTokens + cacheReadInputTokens;
   const totalInputTokens = inputTokens + cachedInputTokens;
+  const cacheCreationSplit = claudeCacheCreationSplit(usage);
   return {
     tokensInput: totalInputTokens || void 0,
     tokensCachedInput: cachedInputTokens || void 0,
     tokensCacheCreationInput: cacheCreationInputTokens || void 0,
+    tokensCacheCreation5mInput: cacheCreationSplit?.fiveMinute,
+    tokensCacheCreation1hInput: cacheCreationSplit?.oneHour,
     tokensCacheReadInput: cacheReadInputTokens || void 0,
     tokensOutput: outputTokens || void 0,
     tokensTotal: totalInputTokens + outputTokens || void 0,
     modelCalls: 1
   };
 }
+function claudeCacheCreationSplit(usage) {
+  const breakdown = usage.cache_creation;
+  if (!isPlainObject(breakdown)) {
+    return void 0;
+  }
+  return {
+    fiveMinute: numberField(breakdown, "ephemeral_5m_input_tokens") || 0,
+    oneHour: numberField(breakdown, "ephemeral_1h_input_tokens") || 0
+  };
+}
 function claudeSubagentMetrics(toolResult, fallbackDurationMs) {
   const usage = objectField(toolResult, "usage");
   const inputTokens = numberField(usage, "input_tokens") || 0;
@@ -1950,6 +2019,7 @@ function claudeSubagentMetrics(toolResult, fallbackDurationMs) {
   const outputTokens = numberField(usage, "output_tokens") || 0;
   const cachedInputTokens = cacheCreationInputTokens + cacheReadInputTokens;
   const totalInputTokens = inputTokens + cachedInputTokens;
+  const cacheCreationSplit = claudeCacheCreationSplit(usage);
   const durationMs = numberField(toolResult, "totalDurationMs") || fallbackDurationMs;
   return {
     durationMs,
@@ -1958,6 +2028,8 @@ function claudeSubagentMetrics(toolResult, fallbackDurationMs) {
     tokensInput: totalInputTokens || void 0,
     tokensCachedInput: cachedInputTokens || void 0,
     tokensCacheCreationInput: cacheCreationInputTokens || void 0,
+    tokensCacheCreation5mInput: cacheCreationSplit?.fiveMinute,
+    tokensCacheCreation1hInput: cacheCreationSplit?.oneHour,
     tokensCacheReadInput: cacheReadInputTokens || void 0,
     tokensOutput: outputTokens || void 0,
     tokensTotal: numberField(toolResult, "totalTokens") || totalInputTokens + outputTokens || void 0
@@ -4137,6 +4209,7 @@ function buildSessionRollup(rollupKey, events) {
   const lastEventAt = ordered.at(-1)?.ts || startedAt;
   const timeBuckets = /* @__PURE__ */ new Map();
   const modelRollups = /* @__PURE__ */ new Map();
+  const modelBuckets = /* @__PURE__ */ new Map();
   const toolRollups = /* @__PURE__ */ new Map();
   const fileRollups = /* @__PURE__ */ new Map();
   const turnRollups = /* @__PURE__ */ new Map();
@@ -4158,6 +4231,8 @@ function buildSessionRollup(rollupKey, events) {
     const eventInputTokens = Math.max(0, event.metrics?.tokensInput || 0);
     const eventCachedInputTokens = Math.max(0, event.metrics?.tokensCachedInput || 0);
     const eventCacheCreationInputTokens = Math.max(0, event.metrics?.tokensCacheCreationInput || 0);
+    const eventCacheCreation5mInputTokens = Math.max(0, event.metrics?.tokensCacheCreation5mInput || 0);
+    const eventCacheCreation1hInputTokens = Math.max(0, event.metrics?.tokensCacheCreation1hInput || 0);
     const eventCacheReadInputTokens = Math.max(0, event.metrics?.tokensCacheReadInput || 0);
     const eventOutputTokens = Math.max(0, event.metrics?.tokensOutput || 0);
     const eventReasoningOutputTokens = Math.max(0, event.metrics?.tokensReasoningOutput || 0);
@@ -4278,6 +4353,8 @@ function buildSessionRollup(rollupKey, events) {
         inputTokens: 0,
         cachedInputTokens: 0,
         cacheCreationInputTokens: 0,
+        cacheCreation5mInputTokens: 0,
+        cacheCreation1hInputTokens: 0,
         cacheReadInputTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
@@ -4288,12 +4365,40 @@ function buildSessionRollup(rollupKey, events) {
       modelRollup.inputTokens += eventInputTokens;
       modelRollup.cachedInputTokens += eventCachedInputTokens;
       modelRollup.cacheCreationInputTokens += eventCacheCreationInputTokens;
+      modelRollup.cacheCreation5mInputTokens += eventCacheCreation5mInputTokens;
+      modelRollup.cacheCreation1hInputTokens += eventCacheCreation1hInputTokens;
       modelRollup.cacheReadInputTokens += eventCacheReadInputTokens;
       modelRollup.outputTokens += eventOutputTokens;
       modelRollup.reasoningOutputTokens += eventReasoningOutputTokens;
       modelRollup.totalTokens += eventTotalTokens;
       modelRollup.estimatedCostUsd += eventCostUsd;
       modelRollups.set(modelKey, modelRollup);
+      const modelBucketKey = `${bucketTs}\0${modelKey}`;
+      const modelBucket = modelBuckets.get(modelBucketKey) || {
+        ts: bucketTs,
+        model: modelKey,
+        callCount: 0,
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        cacheCreation5mInputTokens: 0,
+        cacheCreation1hInputTokens: 0,
+        cacheReadInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0
+      };
+      modelBucket.callCount += 1;
+      modelBucket.inputTokens += eventInputTokens;
+      modelBucket.cachedInputTokens += eventCachedInputTokens;
+      modelBucket.cacheCreationInputTokens += eventCacheCreationInputTokens;
+      modelBucket.cacheCreation5mInputTokens += eventCacheCreation5mInputTokens;
+      modelBucket.cacheCreation1hInputTokens += eventCacheCreation1hInputTokens;
+      modelBucket.cacheReadInputTokens += eventCacheReadInputTokens;
+      modelBucket.outputTokens += eventOutputTokens;
+      modelBucket.reasoningOutputTokens += eventReasoningOutputTokens;
+      modelBucket.totalTokens += eventTotalTokens;
+      modelBuckets.set(modelBucketKey, modelBucket);
     }
     if (event.type === "tool.started") {
       bucket.toolCalls += 1;
@@ -4361,11 +4466,12 @@ function buildSessionRollup(rollupKey, events) {
   const baseRollup = {
     rollupKey,
     payloadHash: "",
-    // v2 schema: trustworthy gap-clamped turn durations + billable-output token
-    // convention. Set on baseRollup (not after) so it participates in payloadHash:
-    // every historical rollup's hash changes, and a re-backfill (uploaded with
-    // replace=true by default) cleanly refreshes all data onto the new convention.
-    // This full-refresh churn is intentional.
+    // v3 schema: v2 (gap-clamped turn durations + billable-output token
+    // convention) plus per-model cache-creation TTL split and modelBuckets. Set on
+    // baseRollup (not after) so it participates in payloadHash: every historical
+    // rollup's hash changes, and a re-backfill (uploaded with replace=true by
+    // default) cleanly refreshes all data onto the new convention. This
+    // full-refresh churn is intentional.
     schemaVersion: AGENT_ROLLUP_SCHEMA_VERSION,
     source: first.source,
     project,
@@ -4390,6 +4496,8 @@ function buildSessionRollup(rollupKey, events) {
     durationMs: Math.max(0, Date.parse(lastEventAt) - Date.parse(startedAt)),
     timeBuckets: [...timeBuckets.values()].sort((a, b) => a.ts.localeCompare(b.ts)),
     modelRollups: [...modelRollups.values()].sort((a, b) => b.callCount - a.callCount || a.model.localeCompare(b.model)),
+    // Sorted ts ascending, then model lexicographically (wire contract).
+    modelBuckets: [...modelBuckets.values()].sort((a, b) => a.ts.localeCompare(b.ts) || a.model.localeCompare(b.model)),
     toolRollups: [...toolRollups.values()].sort((a, b) => b.callCount - a.callCount || a.tool.localeCompare(b.tool)),
     fileRollups: [...fileRollups.values()].sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.displayPath.localeCompare(b.displayPath)),
     turnRollups: [...turnRollups.values()].map((rollup) => ({
@@ -4464,7 +4572,7 @@ async function installEntry(entry, options) {
   });
 }
 async function mergeHooksJson(filePath, content, { dryRun, force, onWrite }) {
-  const { mkdir: mkdir4, writeFile: writeFile3 } = await import("node:fs/promises");
+  const { mkdir: mkdir3, writeFile: writeFile2 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
   if (dryRun) {
     onWrite(`Would merge ${filePath}`);
@@ -4485,8 +4593,8 @@ async function mergeHooksJson(filePath, content, { dryRun, force, onWrite }) {
     onWrite(`Already installed ${filePath}`);
     return;
   }
-  await mkdir4(pathMod.dirname(filePath), { recursive: true });
-  await writeFile3(filePath, nextText, "utf8");
+  await mkdir3(pathMod.dirname(filePath), { recursive: true });
+  await writeFile2(filePath, nextText, "utf8");
   onWrite(`Installed ${filePath}`);
 }
 function mergeHookObjects(existing, addition) {
@@ -4524,7 +4632,7 @@ function hookCommandFromGroup(group) {
 
 // src/lib/config.ts
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import path11 from "node:path";
 function configDir(home = homedir()) {
@@ -4548,30 +4656,87 @@ function readConfig(home = homedir()) {
     return {};
   }
 }
-function writeConfig(config, home = homedir()) {
-  const dir = configDir(home);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+var atomicTmpCounter = 0;
+function writeFileAtomicSync(filePath, data, mode) {
+  const dir = path11.dirname(filePath);
+  mkdirSync(dir, { recursive: true });
+  const tmp = path11.join(dir, `.${path11.basename(filePath)}.${process.pid}.${Date.now()}.${(atomicTmpCounter++).toString(36)}.tmp`);
+  let fd;
+  try {
+    fd = openSync(tmp, "wx", mode);
+    writeSync(fd, data);
+    closeSync(fd);
+    fd = void 0;
+    chmodSync(tmp, mode);
+    renameSyncWithRetry(tmp, filePath);
+  } catch (error) {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
   }
-  writeFileSync(configPath(home), `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
+}
+function renameSyncWithRetry(from, to, attempts = 5) {
+  for (let i = 0; ; i++) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (i >= attempts - 1 || code !== "EPERM" && code !== "EACCES" && code !== "EBUSY") {
+        throw error;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10 * (i + 1));
+    }
+  }
+}
+function writeConfig(config, home = homedir()) {
+  writeFileAtomicSync(configPath(home), `${JSON.stringify(config, null, 2)}
+`, 384);
 }
 function ensureLocalMachineId(home = homedir()) {
   const file = machineIdPath(home);
-  if (existsSync(file)) {
-    const value = readFileSync(file, "utf8").trim();
-    if (value.length > 0) {
-      return value;
-    }
+  const existing = readMachineId(file);
+  if (existing) {
+    return existing;
   }
+  mkdirSync(configDir(home), { recursive: true });
   const id = randomUUID();
-  const dir = configDir(home);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  try {
+    const fd = openSync(file, "wx", 384);
+    try {
+      writeSync(fd, `${id}
+`);
+    } finally {
+      closeSync(fd);
+    }
+    return id;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const peer = readMachineId(file);
+    if (peer) {
+      return peer;
+    }
+    writeFileAtomicSync(file, `${id}
+`, 384);
+    return id;
   }
-  writeFileSync(file, `${id}
-`, { mode: 384 });
-  return id;
+}
+function readMachineId(file) {
+  if (!existsSync(file)) {
+    return null;
+  }
+  const value = readFileSync(file, "utf8").trim();
+  return value.length > 0 ? value : null;
 }
 function defaultMachineName() {
   return hostname();
@@ -4581,7 +4746,7 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir2, rename, stat as stat5 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir2, rename as rename2, stat as stat5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import path12 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
@@ -4601,7 +4766,7 @@ async function rotateIfNeeded(file) {
   try {
     const info = await stat5(file);
     if (info.size > MAX_BYTES) {
-      await rename(file, `${file}.1`).catch(() => {
+      await rename2(file, `${file}.1`).catch(() => {
       });
     }
   } catch {
@@ -5435,7 +5600,7 @@ async function importBackfillPlan(plan, options, ctx, registry) {
 }
 async function purgeForcedSources(sourceDefs, home, options, ctx) {
   try {
-    await rm(backfillIncrementalStatePath(home), { force: true });
+    await rm2(backfillIncrementalStatePath(home), { force: true });
   } catch (error) {
     debug(ctx, `Failed to clear backfill watermark: ${error.message}
 `);
@@ -5633,7 +5798,11 @@ function syncLocalTriggerLockPath(home) {
 }
 async function readBackfillIncrementalState(home, ctx) {
   const statePath = backfillIncrementalStatePath(home);
-  const state = await readJsonIfExists(statePath);
+  const state = await readJsonIfExistsTolerant(
+    statePath,
+    ctx ? (error) => debug(ctx, `backfill-state unreadable at ${statePath}; dropping watermarks and re-importing (${error.message})
+`) : void 0
+  );
   if (state === null) {
     return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
   }
@@ -5669,12 +5838,11 @@ async function updateBackfillIncrementalState(home, state, selectedFilesBySource
     state.sources[source] = { watermarkTs: latest };
   }
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir3(path13.dirname(statePath), { recursive: true });
-  await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+  await writeFileAtomic(statePath, `${JSON.stringify(state, null, 2)}
+`);
 }
 async function readSyncLocalTriggerState(statePath) {
-  const state = await readJsonIfExists(statePath);
+  const state = await readJsonIfExistsTolerant(statePath);
   if (!isPlainObject(state)) {
     return { version: 1 };
   }
@@ -5697,12 +5865,11 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir3(path13.dirname(statePath), { recursive: true });
-  await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+  await writeFileAtomic(statePath, `${JSON.stringify(state, null, 2)}
+`);
 }
 async function readSyncLocalLock(lockPath) {
-  const lock = await readJsonIfExists(lockPath);
+  const lock = await readJsonIfExistsTolerant(lockPath);
   if (!isPlainObject(lock)) {
     return void 0;
   }
@@ -5712,13 +5879,12 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir3(path13.dirname(lockPath), { recursive: true });
-  await writeFile2(lockPath, `${JSON.stringify(lock, null, 2)}
-`, "utf8");
+  await writeFileAtomic(lockPath, `${JSON.stringify(lock, null, 2)}
+`);
 }
 async function clearSyncLocalLock(lockPath) {
   try {
-    await rm(lockPath, { force: true });
+    await rm2(lockPath, { force: true });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codetime-cli",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {