codetime-cli 0.2.0 → 0.3.0

package/bin/codetime.mjs

@@ -143,6 +143,9 @@ var init_fs = __esm({
   }
 });
 
+// src/lib/types.ts
+var BACKFILL_STATE_SCHEMA_VERSION = 2;
+
 // src/cli.ts
 import { spawn } from "node:child_process";
 import { mkdir as mkdir2, rm, stat as stat4, writeFile as writeFile2 } from "node:fs/promises";
@@ -1329,7 +1332,7 @@ function msToIso(ms) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.2.0" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.3.0" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -1472,6 +1475,7 @@ async function parseClaudeCodeSessionFile(filePath, options) {
   const lines = text.split("\n").filter(Boolean);
   const projectContext = await claudeProjectContextFromLines(filePath, lines, options);
   const pendingTools = /* @__PURE__ */ new Map();
+  const seenUsageKeys = /* @__PURE__ */ new Set();
   let sessionId = sessionIdFromFilePath(filePath, "claude");
   let cwd;
   let project = projectContext.project;
@@ -1623,8 +1627,19 @@ async function parseClaudeCodeSessionFile(filePath, options) {
       continue;
     }
     model = stringField(message, "model") || model;
+    const messageId = stringField(message, "id");
+    const requestId = stringField(raw, "requestId");
+    const usageKey = messageId ? `${messageId}:${requestId}` : null;
+    if (usageKey != null && seenUsageKeys.has(usageKey)) {
+      continue;
+    }
+    if (usageKey != null) {
+      seenUsageKeys.add(usageKey);
+    }
     const usage = claudeUsageFromMessage(message);
     if (usage) {
+      const speed = stringField(objectField(message, "usage"), "speed");
+      const usageModel = speed === "fast" && model ? `${model}-fast` : model;
       push(baseClaudeEvent({
         ts,
         type: "model.usage",
@@ -1632,7 +1647,7 @@ async function parseClaudeCodeSessionFile(filePath, options) {
         turnId: state.currentTurnId,
         cwd,
         project,
-        model,
+        model: usageModel,
         confidence: "partial",
         metrics: usage
       }), lineNumber, topType, "usage");
@@ -1940,35 +1955,43 @@ function hookConfig() {
     }
   };
 }
+function claudeConfigDir(home, env) {
+  const override = env?.CLAUDE_CONFIG_DIR;
+  if (override && override.trim()) {
+    return path5.resolve(override);
+  }
+  return path5.join(home, ".claude");
+}
 function createClaudeCodeAdapter() {
-  const CLAUDE_PATH = ".claude";
   return {
     id: "claude-code",
     label: "Claude Code",
     agentName: "claude",
     kind: "agent",
-    detectPath(home) {
-      return path5.join(home, CLAUDE_PATH);
+    detectPath(home, env) {
+      return claudeConfigDir(home, env);
     },
-    installedPath(home) {
-      return path5.join(home, CLAUDE_PATH, "settings.json");
+    installedPath(home, env) {
+      return path5.join(claudeConfigDir(home, env), "settings.json");
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path5.join(home, CLAUDE_PATH, "settings.json"),
+        path5.join(claudeConfigDir(home, env), "settings.json"),
         "codetime hook --agent claude"
       );
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path5.join(home, CLAUDE_PATH, "settings.json"),
+        path: path5.join(claudeConfigDir(home, env), "settings.json"),
         content: hookConfig()
       }];
     },
-    sourcePaths(home) {
+    sourcePaths(home, env) {
+      const base = claudeConfigDir(home, env);
       return [
-        path5.join(home, ".claude", "projects"),
+        path5.join(base, "projects"),
+        path5.join(base, ".claude.json"),
         path5.join(home, ".claude.json")
       ];
     },
@@ -2473,36 +2496,43 @@ function hookConfig2() {
     }
   };
 }
+function codexHome(home, env) {
+  const override = env?.CODEX_HOME;
+  if (override && override.trim()) {
+    return path6.resolve(override);
+  }
+  return path6.join(home, ".codex");
+}
 function createCodexAdapter() {
-  const CODE_PATH = ".codex";
   return {
     id: "codex",
     label: "Codex",
     agentName: "codex",
     kind: "agent",
-    detectPath(home) {
-      return path6.join(home, CODE_PATH);
+    detectPath(home, env) {
+      return codexHome(home, env);
     },
-    installedPath(home) {
-      return path6.join(home, CODE_PATH, "hooks.json");
+    installedPath(home, env) {
+      return path6.join(codexHome(home, env), "hooks.json");
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path6.join(home, CODE_PATH, "hooks.json"),
+        path6.join(codexHome(home, env), "hooks.json"),
         "codetime hook --agent codex"
       );
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path6.join(home, CODE_PATH, "hooks.json"),
+        path: path6.join(codexHome(home, env), "hooks.json"),
         content: hookConfig2()
       }];
     },
-    sourcePaths(home) {
+    sourcePaths(home, env) {
+      const base = codexHome(home, env);
       return [
-        path6.join(home, ".codex", "sessions"),
-        path6.join(home, ".codex", "history.jsonl")
+        path6.join(base, "sessions"),
+        path6.join(base, "history.jsonl")
       ];
     },
     parseSessionFile: parseCodexSessionFile
@@ -2855,7 +2885,23 @@ function opencodeUsageFromInfo(info) {
     tokensTotal: total
   };
 }
-async function opencodeBackfillFiles(sourceRoot) {
+function opencodeConfigDir(home, env) {
+  const override = env?.OPENCODE_CONFIG_DIR;
+  if (override && override.trim()) {
+    return path7.resolve(override);
+  }
+  const xdgConfig = env?.XDG_CONFIG_HOME;
+  if (xdgConfig && xdgConfig.trim()) {
+    return path7.join(path7.resolve(xdgConfig), "opencode");
+  }
+  return path7.join(home, ".config", "opencode");
+}
+function opencodeDataCandidates(home, env) {
+  const xdgData = env?.XDG_DATA_HOME;
+  const primary = xdgData && xdgData.trim() ? path7.join(path7.resolve(xdgData), "opencode", "opencode.db") : path7.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path7.join(home, ".opencode", "opencode.db")];
+}
+async function opencodeBackfillFiles(sourceRoot, home = os2.homedir(), env) {
   const { stat: stat5 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
@@ -2867,11 +2913,7 @@ async function opencodeBackfillFiles(sourceRoot) {
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
-  const candidates = [
-    path7.join(os2.homedir(), ".local", "share", "opencode", "opencode.db"),
-    path7.join(os2.homedir(), ".opencode", "opencode.db")
-  ];
-  for (const candidatePath of candidates) {
+  for (const candidatePath of opencodeDataCandidates(home, env)) {
     const info = await stat5(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
@@ -2925,39 +2967,35 @@ export const AgentTime = async ({ $, directory }) => {
 `;
 }
 function createOpenCodeAdapter() {
-  const OPENCODE_CONFIG = ".config/opencode";
   const PLUGIN_PATH = "plugins/codetime.mjs";
   return {
     id: "opencode",
     label: "OpenCode",
     agentName: "opencode",
     kind: "agent",
-    detectPath(home) {
-      return path7.join(home, OPENCODE_CONFIG);
+    detectPath(home, env) {
+      return opencodeConfigDir(home, env);
     },
-    installedPath(home) {
-      return path7.join(home, OPENCODE_CONFIG, PLUGIN_PATH);
+    installedPath(home, env) {
+      return path7.join(opencodeConfigDir(home, env), PLUGIN_PATH);
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path7.join(home, OPENCODE_CONFIG, PLUGIN_PATH)) || await pathExists2(path7.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path7.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path7.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "file",
-        path: path7.join(home, OPENCODE_CONFIG, PLUGIN_PATH),
+        path: path7.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
-    sourcePaths(home) {
-      return [
-        path7.join(home, ".local", "share", "opencode", "opencode.db"),
-        path7.join(home, ".opencode", "opencode.db")
-      ];
+    sourcePaths(home, env) {
+      return opencodeDataCandidates(home, env);
     },
     parseSessionFile: parseOpenCodeSessionFile
   };
@@ -3391,36 +3429,49 @@ export default function (pi: ExtensionAPI) {
 }
 `;
 }
+function piAgentDir(home, env) {
+  const override = env?.PI_CODING_AGENT_DIR;
+  if (override && override.trim()) {
+    return path8.resolve(override);
+  }
+  return path8.join(home, ".pi", "agent");
+}
+function piSessionDir(home, env) {
+  const override = env?.PI_CODING_AGENT_SESSION_DIR;
+  if (override && override.trim()) {
+    return path8.resolve(override);
+  }
+  return path8.join(piAgentDir(home, env), "sessions");
+}
 function createPiAdapter() {
-  const PI_EXTENSIONS_DIR = ".pi/agent/extensions";
   return {
     id: "pi",
     label: "Pi",
     agentName: "pi",
     kind: "agent",
-    detectPath(home) {
-      return path8.join(home, ".pi", "agent");
+    detectPath(home, env) {
+      return piAgentDir(home, env);
     },
-    installedPath(home) {
-      return path8.join(home, PI_EXTENSIONS_DIR, "codetime.ts");
+    installedPath(home, env) {
+      return path8.join(piAgentDir(home, env), "extensions", "codetime.ts");
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path8.join(home, PI_EXTENSIONS_DIR, "codetime.ts"));
+        return await pathExists2(path8.join(piAgentDir(home, env), "extensions", "codetime.ts"));
       } catch {
         return false;
       }
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "file",
-        path: path8.join(home, PI_EXTENSIONS_DIR, "codetime.ts"),
+        path: path8.join(piAgentDir(home, env), "extensions", "codetime.ts"),
         content: piExtensionContent()
       }];
     },
-    sourcePaths(home) {
-      return [path8.join(home, ".pi", "agent", "sessions")];
+    sourcePaths(home, env) {
+      return [piSessionDir(home, env)];
     },
     parseSessionFile: parsePiSessionFile
   };
@@ -4569,18 +4620,19 @@ function normalizeOptions(options) {
 }
 async function detectCommand(options, ctx, registry) {
   const home = resolveHome(options, ctx);
+  const env = ctx.env;
   const adapters = registry.all();
   const targets = await Promise.all(adapters.map(async (adapter) => {
-    const detected = await pathExists(adapter.detectPath(home));
-    const installed = await adapter.isInstalled(home);
+    const detected = await pathExists(adapter.detectPath(home, env));
+    const installed = await adapter.isInstalled(home, env);
     return {
       id: adapter.id,
       label: adapter.label,
       kind: adapter.kind,
       detected,
       installed,
-      detectPath: adapter.detectPath(home),
-      installedPath: adapter.installedPath(home)
+      detectPath: adapter.detectPath(home, env),
+      installedPath: adapter.installedPath(home, env)
     };
   }));
   if (options.json) {
@@ -4597,6 +4649,7 @@ async function detectCommand(options, ctx, registry) {
 }
 async function installCommand(options, ctx, registry) {
   const home = resolveHome(options, ctx);
+  const env = ctx.env;
   const dryRun = Boolean(options["dry-run"]);
   const force = Boolean(options.force);
   const allAdapters = registry.all();
@@ -4607,7 +4660,7 @@ async function installCommand(options, ctx, registry) {
   }
   const detected = [];
   for (const adapter of allAdapters) {
-    if (await pathExists(adapter.detectPath(home))) {
+    if (await pathExists(adapter.detectPath(home, env))) {
       detected.push(adapter.id);
     }
   }
@@ -4617,7 +4670,7 @@ async function installCommand(options, ctx, registry) {
     return 1;
   }
   for (const adapter of allAdapters.filter((a) => selectedIds.includes(a.id))) {
-    for (const entry of adapter.installEntries(home)) {
+    for (const entry of adapter.installEntries(home, env)) {
       await installEntry(entry, {
         dryRun,
         force,
@@ -4746,13 +4799,14 @@ async function backfillCommand(options, ctx, registry) {
 }
 async function createBackfillPlanFromOptions(options, ctx, action, registry) {
   const home = resolveHome(options, ctx);
+  const env = ctx.env;
   const source = normalizeBackfillSource(stringOption(options.source) || "all");
-  const sourceDefs = source === "all" ? registry.all().map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home) })) : (() => {
+  const sourceDefs = source === "all" ? registry.all().map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home, env) })) : (() => {
     const adapter = registry.get(source);
     if (!adapter) {
       return [];
     }
-    return [{ id: adapter.id, label: adapter.label, paths: adapter.sourcePaths(home) }];
+    return [{ id: adapter.id, label: adapter.label, paths: adapter.sourcePaths(home, env) }];
   })();
   if (sourceDefs.length === 0) {
     throw new Error(`Unknown backfill source: ${source}`);
@@ -4761,7 +4815,7 @@ async function createBackfillPlanFromOptions(options, ctx, action, registry) {
   const candidates = candidateList.flat();
   let events = [];
   if (action !== "discover") {
-    const eventList = await createBackfillEventsFromDefs(sourceDefs, options, registry);
+    const eventList = await createBackfillEventsFromDefs(sourceDefs, options, registry, ctx);
     events = eventList.flat();
   }
   const plannedEvents = events.map((event) => ({
@@ -4811,14 +4865,14 @@ async function createBackfillPlanFromOptions(options, ctx, action, registry) {
     privacy: "metadata only; prompt text, command text, source code, and diffs are not imported"
   };
 }
-async function createBackfillEventsFromDefs(sourceDefs, options, registry, overrideFiles) {
+async function createBackfillEventsFromDefs(sourceDefs, options, registry, ctx, overrideFiles) {
   const events = [];
   for (const item of sourceDefs) {
     const parser = registry.getParser(item.id);
     if (!parser) {
       continue;
     }
-    const sourceFiles = await listBackfillSourceFiles(item, options);
+    const sourceFiles = await listBackfillSourceFiles(item, options, ctx);
     const files = overrideFiles ?? sourceFiles.map((f) => f.path);
     for (const filePath of files) {
       const parsed = await parser(filePath, options);
@@ -4846,9 +4900,9 @@ async function createBackfillCandidates(source, options) {
     };
   }));
 }
-async function listBackfillSourceFiles(source, options) {
+async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "opencode") {
-    return opencodeBackfillFiles(stringOption(options["source-root"]));
+    return opencodeBackfillFiles(stringOption(options["source-root"]), resolveHome(options, ctx), ctx.env);
   }
   const roots = stringOption(options["source-root"]) ? [requiredOption(options, "source-root")] : source.paths;
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
@@ -4936,119 +4990,122 @@ async function importBackfillPlan(plan, options, ctx, registry) {
     write(ctx.stderr, "Only Codex, Claude Code, OpenCode, and Pi backfill import are implemented.\n");
     return 1;
   }
-  const allAdapters = registry.all();
-  const sourceDefs = allAdapters.filter((a) => supportedSources.has(a.id) && (source === "all" || a.id === source)).map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home) }));
+  const sourceDefs = registry.all().filter((a) => supportedSources.has(a.id) && (source === "all" || a.id === source)).map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home, ctx.env) }));
   if (options.force) {
-    try {
-      await rm(backfillIncrementalStatePath(home), { force: true });
-    } catch {
-    }
-    for (const item of sourceDefs) {
-      try {
-        const deleted = await deleteSessionRollupsBySourceAPI(item.id, options, ctx);
-        if (!options.json) {
-          write(ctx.stdout, `purged ${item.id}: ${deleted} old rollups
-`);
-        }
-      } catch (error) {
-        debug(ctx, `Failed to purge ${item.id} rollups: ${error.message}
-`);
-      }
-    }
+    await purgeForcedSources(sourceDefs, home, options, ctx);
   }
-  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home) : void 0;
-  const selectedFilesBySource = /* @__PURE__ */ new Map();
-  const canonicalEvents = [];
+  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home, ctx) : void 0;
   if (!options.json) {
     write(ctx.stdout, `importRun ${plan.importRun.importRunId}
 `);
     write(ctx.stdout, `sources ${sourceDefs.map((s) => s.id).join(", ") || "none"}
 `);
   }
+  const { canonicalEvents, selectedFilesBySource } = await collectCanonicalEvents(
+    sourceDefs,
+    registry,
+    incrementalState,
+    options,
+    ctx
+  );
+  const rollups = buildSessionRollups(canonicalEvents);
+  const counts = await uploadSessionRollups(rollups, canonicalEvents.length, options, ctx);
+  const result = {
+    importRunId: plan.importRun.importRunId,
+    source,
+    planned: rollups.length,
+    sourceEvents: canonicalEvents.length,
+    ...counts
+  };
+  if (options.json) {
+    write(ctx.stdout, `${JSON.stringify(result, null, 2)}
+`);
+  }
+  if (counts.failed === 0 && counts.conflicts === 0 && incrementalState) {
+    await updateBackfillIncrementalState(home, incrementalState, selectedFilesBySource);
+  }
+  return counts.failed > 0 || counts.conflicts > 0 && !options["skip-conflicts"] ? 1 : 0;
+}
+async function purgeForcedSources(sourceDefs, home, options, ctx) {
+  try {
+    await rm(backfillIncrementalStatePath(home), { force: true });
+  } catch (error) {
+    debug(ctx, `Failed to clear backfill watermark: ${error.message}
+`);
+  }
+  for (const item of sourceDefs) {
+    try {
+      const deleted = await deleteSessionRollupsBySourceAPI(item.id, options, ctx);
+      if (!options.json) {
+        write(ctx.stdout, `purged ${item.id}: ${deleted} old rollups
+`);
+      }
+    } catch (error) {
+      debug(ctx, `Failed to purge ${item.id} rollups: ${error.message}
+`);
+    }
+  }
+}
+async function collectCanonicalEvents(sourceDefs, registry, incrementalState, options, ctx) {
+  const selectedFilesBySource = /* @__PURE__ */ new Map();
+  const canonicalEvents = [];
   for (const item of sourceDefs) {
     const parser = registry.getParser(item.id);
     if (!parser) {
       continue;
     }
-    const sourceFiles = await listBackfillSourceFiles(item, options);
+    const sourceFiles = await listBackfillSourceFiles(item, options, ctx);
     const selectedFiles = selectBackfillFilesForImport(sourceFiles, incrementalState?.sources[item.id]?.watermarkTs);
     selectedFilesBySource.set(item.id, selectedFiles);
     const filePaths = selectedFiles.map((f) => f.path);
     const sourceEvents = [];
-    if (options.json) {
-      for (const filePath of filePaths) {
-        const parsed = await parser(filePath, options);
-        for (const event of parsed) {
-          if (matchesBackfillFilters(event, options)) {
-            sourceEvents.push(event);
-          }
-        }
-      }
-    } else {
-      const bar = new ProgressBar(ctx.stdout, `${item.id.padEnd(12)}`);
-      bar.init(filePaths.length, `0 events`);
-      for (let fi = 0; fi < filePaths.length; fi += 1) {
-        const parsed = await parser(filePaths[fi], options);
-        for (const event of parsed) {
-          if (matchesBackfillFilters(event, options)) {
-            sourceEvents.push(event);
-          }
+    const bar = options.json ? void 0 : new ProgressBar(ctx.stdout, `${item.id.padEnd(12)}`);
+    bar?.init(filePaths.length, `0 events`);
+    for (let fi = 0; fi < filePaths.length; fi += 1) {
+      const parsed = await parser(filePaths[fi], options);
+      for (const event of parsed) {
+        if (matchesBackfillFilters(event, options)) {
+          sourceEvents.push(event);
         }
-        bar.tick(`${fi + 1}/${filePaths.length} files, ${sourceEvents.length} events`);
       }
-      bar.finalize(`${sourceEvents.length} events`);
+      bar?.tick(`${fi + 1}/${filePaths.length} files, ${sourceEvents.length} events`);
     }
+    bar?.finalize(`${sourceEvents.length} events`);
     for (const event of sourceEvents) canonicalEvents.push(event);
   }
+  return { canonicalEvents, selectedFilesBySource };
+}
+async function uploadSessionRollups(rollups, eventCount, options, ctx) {
   const counts = { inserted: 0, skipped: 0, conflicts: 0, failed: 0 };
-  const rollups = buildSessionRollups(canonicalEvents);
   const batchSize = Math.max(1, Math.floor(numberOption(options["batch-size"]) || DEFAULT_BACKFILL_BATCH_SIZE));
   const batchBytes = Math.max(64 * 1024, Math.floor(numberOption(options["batch-bytes"]) || DEFAULT_BACKFILL_BATCH_BYTES));
   const batches = packRollupBatches(rollups, batchSize, batchBytes);
   const totalBatches = batches.length;
   let uploadBar;
   if (!options.json) {
-    write(ctx.stdout, `rollup ${rollups.length} from ${canonicalEvents.length} events
+    write(ctx.stdout, `rollup ${rollups.length} from ${eventCount} events
 `);
     uploadBar = new ProgressBar(ctx.stdout, `upload`.padEnd(12));
     uploadBar.init(totalBatches, `0/${totalBatches} batches, 0 inserted`);
   }
-  for (let i = 0; i < batches.length; i += 1) {
-    const batch = batches[i];
+  for (const [i, batch_] of batches.entries()) {
+    const batch = batch_;
     const batchNumber = i + 1;
     try {
-      const result2 = await sendSessionRollupBatch(batch, options, ctx);
-      counts.inserted += result2.inserted;
-      counts.skipped += result2.skipped;
-      counts.conflicts += result2.conflicts;
-      counts.failed += result2.failed;
+      const result = await sendSessionRollupBatch(batch, options, ctx);
+      counts.inserted += result.inserted;
+      counts.skipped += result.skipped;
+      counts.conflicts += result.conflicts;
+      counts.failed += result.failed;
     } catch (error) {
       debug(ctx, `backfill rollup batch ${batchNumber}/${totalBatches} (${batch.length} rollups) failed: ${error.message}
 `);
       counts.failed += batch.length;
     }
-    if (uploadBar) {
-      uploadBar.update(batchNumber, `${batchNumber}/${totalBatches} batches, inserted ${counts.inserted}`);
-    }
+    uploadBar?.update(batchNumber, `${batchNumber}/${totalBatches} batches, inserted ${counts.inserted}`);
   }
-  if (uploadBar) {
-    uploadBar.finalize(`inserted ${counts.inserted} \xB7 skipped ${counts.skipped}${counts.conflicts ? ` \xB7 conflicts ${counts.conflicts}` : ""}${counts.failed ? ` \xB7 failed ${counts.failed}` : ""}`);
-  }
-  const result = {
-    importRunId: plan.importRun.importRunId,
-    source,
-    planned: rollups.length,
-    sourceEvents: canonicalEvents.length,
-    ...counts
-  };
-  if (options.json) {
-    write(ctx.stdout, `${JSON.stringify(result, null, 2)}
-`);
-  }
-  if (counts.failed === 0 && counts.conflicts === 0 && incrementalState) {
-    await updateBackfillIncrementalState(home, incrementalState, selectedFilesBySource);
-  }
-  return counts.failed > 0 || counts.conflicts > 0 && !options["skip-conflicts"] ? 1 : 0;
+  uploadBar?.finalize(`inserted ${counts.inserted} \xB7 skipped ${counts.skipped}${counts.conflicts ? ` \xB7 conflicts ${counts.conflicts}` : ""}${counts.failed ? ` \xB7 failed ${counts.failed}` : ""}`);
+  return counts;
 }
 function backfillVerifyCommand(options, ctx) {
   const importRunId = stringOption(options["import-run"]);
@@ -5072,12 +5129,7 @@ ${result.message}
   return 0;
 }
 async function sendSessionRollupBatch(rollups, options, ctx) {
-  const remote = resolveRemote({
-    apiUrl: stringOption(options["api-url"]),
-    token: stringOption(options.token),
-    env: ctx.env,
-    fetch: ctx.fetch
-  });
+  const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote) {
     throw new Error("No fetch available for HTTP upload");
   }
@@ -5096,12 +5148,7 @@ async function sendSessionRollupBatch(rollups, options, ctx) {
   return result;
 }
 async function deleteSessionRollupsBySourceAPI(source, options, ctx) {
-  const remote = resolveRemote({
-    apiUrl: stringOption(options["api-url"]),
-    token: stringOption(options.token),
-    env: ctx.env,
-    fetch: ctx.fetch
-  });
+  const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote) {
     throw new Error("No fetch available for HTTP delete");
   }
@@ -5130,7 +5177,9 @@ function packRollupBatches(rollups, maxCount, maxBytes) {
     current.push(rollup);
     currentBytes += size;
   }
-  if (current.length > 0) batches.push(current);
+  if (current.length > 0) {
+    batches.push(current);
+  }
   return batches;
 }
 function selectBackfillFilesForImport(files, watermarkTs) {
@@ -5155,10 +5204,25 @@ function syncLocalTriggerStatePath(home) {
 function syncLocalTriggerLockPath(home) {
   return path11.join(home, ".codetime", "sync-local-trigger.lock");
 }
-async function readBackfillIncrementalState(home) {
-  const state = await readJsonIfExists(backfillIncrementalStatePath(home));
+async function readBackfillIncrementalState(home, ctx) {
+  const statePath = backfillIncrementalStatePath(home);
+  const state = await readJsonIfExists(statePath);
+  if (state === null) {
+    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+  }
   if (!isPlainObject(state) || !isPlainObject(state.sources)) {
-    return { version: 1, sources: {} };
+    if (ctx) {
+      debug(ctx, `backfill-state malformed at ${statePath}; ignoring watermarks
+`);
+    }
+    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+  }
+  if (state.version !== BACKFILL_STATE_SCHEMA_VERSION) {
+    if (ctx) {
+      debug(ctx, `backfill-state version ${String(state.version)} at ${statePath} differs from current v${BACKFILL_STATE_SCHEMA_VERSION}; dropping watermarks so the next sync re-imports under the new parser
+`);
+    }
+    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
   }
   const sources = {};
   for (const source of ["codex", "claude-code", "opencode", "pi"]) {
@@ -5167,7 +5231,7 @@ async function readBackfillIncrementalState(home) {
       sources[source] = { watermarkTs: item.watermarkTs };
     }
   }
-  return { version: 1, sources };
+  return { version: BACKFILL_STATE_SCHEMA_VERSION, sources };
 }
 async function updateBackfillIncrementalState(home, state, selectedFilesBySource) {
   for (const [source, files] of selectedFilesBySource.entries()) {
@@ -5339,6 +5403,15 @@ function debug(ctx, message) {
     write(ctx.stderr, message);
   }
 }
+function resolveRemoteFromOptions(options, ctx) {
+  return resolveRemote({
+    apiUrl: stringOption(options["api-url"]),
+    token: stringOption(options.token),
+    env: ctx.env,
+    fetch: ctx.fetch,
+    homeOverride: stringOption(options.home)
+  });
+}
 function maskToken(token) {
   if (token.length <= 8) {
     return "***";
@@ -5399,12 +5472,7 @@ Usage: codetime token [set <token>|show|clear] [--remote <url>]
   return 1;
 }
 async function machineCommand(action, options, ctx) {
-  const remote = resolveRemote({
-    apiUrl: stringOption(options["api-url"]),
-    token: stringOption(options.token),
-    env: ctx.env,
-    fetch: ctx.fetch
-  });
+  const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote || !remote.token) {
     write(ctx.stderr, "machine command requires login (run `codetime login`).\n");
     return 1;
@@ -5485,14 +5553,11 @@ Global options:
   --token <token>   Bearer token for this invocation (overrides config).
 
 Token precedence (highest first):
-  --token flag  >  CODETIME_AGENT_TOKEN env  >  AGENT_TIME_API_TOKEN env
-  (legacy alias)  >  saved config (~/.codetime/config.json).
+  --token flag  >  CODETIME_TOKEN env  >  saved config (~/.codetime/config.json).
 
 Environment:
   CODETIME_API_URL        Defaults to ${DEFAULT_API_URL}
-  CODETIME_AGENT_TOKEN    Bearer token for the API
-  AGENT_TIME_API_URL      Legacy alias for CODETIME_API_URL
-  AGENT_TIME_API_TOKEN    Legacy alias for CODETIME_AGENT_TOKEN
+  CODETIME_TOKEN          Bearer token for the API
 `;
 }
 export {

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "codetime-cli",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "homepage": "https://github.com/jannchie/codetime-cli#readme",
+  "homepage": "https://github.com/codetime-dev/codetime-cli#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jannchie/codetime-cli.git"
+    "url": "git+https://github.com/codetime-dev/codetime-cli.git"
   },
   "bugs": {
-    "url": "https://github.com/jannchie/codetime-cli/issues"
+    "url": "https://github.com/codetime-dev/codetime-cli/issues"
   },
   "keywords": [
     "codetime",
@@ -35,7 +35,7 @@
   "devDependencies": {
     "cac": "^7.0.0",
     "esbuild": "^0.28.0",
-    "@codetime/shared": "0.2.0"
+    "@codetime/shared": "0.3.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",