codetime-cli 0.7.0 → 0.7.2

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";
@@ -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.7.0" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.7.2" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -2260,6 +2316,8 @@ async function parseCodexSessionFile(filePath, options) {
   let turnIdAtLastUserMessage;
   let sessionMetaLocked = false;
   let lastTokenUsageKey;
+  const replaySecond = detectSubagentReplaySecond(text, lines);
+  let skipReplay = replaySecond !== void 0;
   const pendingToolCalls = /* @__PURE__ */ new Map();
   const turnLastEventAt = /* @__PURE__ */ new Map();
   const turnStartedAt = /* @__PURE__ */ new Map();
@@ -2419,6 +2477,12 @@ async function parseCodexSessionFile(filePath, options) {
         }
         const usage = tokenUsageFromPayload(payload);
         if (usage) {
+          if (skipReplay) {
+            if (ts.slice(0, 19) === replaySecond) {
+              break;
+            }
+            skipReplay = false;
+          }
           const usageKey = [
             usage.tokensInput,
             usage.tokensCachedInput,
@@ -2699,6 +2763,38 @@ function headlessCodexTimestamp(raw) {
   }
   return void 0;
 }
+function detectSubagentReplaySecond(text, lines) {
+  if (!text.includes("thread_spawn")) {
+    return void 0;
+  }
+  let firstSecond;
+  for (const line of lines) {
+    const raw = parseJsonLine(line);
+    if (!raw || stringField(raw, "type") !== "event_msg") {
+      continue;
+    }
+    const payload = objectField(raw, "payload");
+    if (stringField(payload, "type") !== "token_count") {
+      continue;
+    }
+    const info = objectField(payload, "info");
+    const hasUsage = Object.keys(objectField(info, "last_token_usage")).length > 0 || Object.keys(objectField(info, "total_token_usage")).length > 0;
+    if (!hasUsage) {
+      continue;
+    }
+    const ts = timestampFrom(raw.timestamp) || timestampFrom(payload.timestamp);
+    if (!ts) {
+      continue;
+    }
+    const second = ts.slice(0, 19);
+    if (firstSecond === void 0) {
+      firstSecond = second;
+    } else {
+      return firstSecond === second ? firstSecond : void 0;
+    }
+  }
+  return void 0;
+}
 function tokenUsageFromPayload(payload) {
   const info = objectField(payload, "info");
   const usage = objectField(info, "last_token_usage");
@@ -4516,7 +4612,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}`);
@@ -4537,8 +4633,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) {
@@ -4576,7 +4672,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()) {
@@ -4600,30 +4696,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;
+  }
+}
+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));
+    }
   }
-  writeFileSync(configPath(home), `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
+}
+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();
@@ -4633,7 +4786,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;
@@ -4653,7 +4806,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 {
@@ -5487,7 +5640,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}
 `);
@@ -5685,7 +5838,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: {} };
   }
@@ -5721,12 +5878,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 };
   }
@@ -5749,12 +5905,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;
   }
@@ -5764,13 +5919,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.7.0",
+  "version": "0.7.2",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {