codetime-cli 0.4.0 → 0.6.0

package/bin/codetime.mjs

@@ -160,6 +160,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 TELEMETRY_EVENT_TYPES = [
   "session.started",
   "session.ended",
@@ -973,11 +974,12 @@ 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.4.0" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.6.0" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
 var ROLLUP_BUCKET_MS = 15 * 60 * 1e3;
+var TURN_GAP_CLAMP_MS = 5 * 60 * 1e3;
 var DEFAULT_HOOK_SYNC_MIN_INTERVAL_SECONDS = 60;
 
 // src/lib/fields.ts
@@ -2243,6 +2245,23 @@ async function parseCodexSessionFile(filePath, options) {
   let sessionMetaLocked = false;
   let lastTokenUsageKey;
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  const turnLastEventAt = /* @__PURE__ */ new Map();
+  const turnStartedAt = /* @__PURE__ */ new Map();
+  const closedTurnIds = /* @__PURE__ */ new Set();
+  const pushEvent = (event, refs) => {
+    const turnId = event.turnId;
+    if (turnId && event.ts) {
+      if (!turnStartedAt.has(turnId)) {
+        turnStartedAt.set(turnId, event.ts);
+      }
+      const prev = turnLastEventAt.get(turnId);
+      if (!prev || event.ts > prev) {
+        turnLastEventAt.set(turnId, event.ts);
+      }
+    }
+    events.push(withBackfillRefs(event, refs));
+  };
+  const turnCloseTs = (turnId) => turnLastEventAt.get(turnId) || turnStartedAt.get(turnId) || (/* @__PURE__ */ new Date()).toISOString();
   for (const [index, line] of lines.entries()) {
     const lineNumber = index + 1;
     const raw = parseJsonLine(line);
@@ -2299,23 +2318,23 @@ async function parseCodexSessionFile(filePath, options) {
         const eventModel = parsedModel || model || "gpt-5";
         const headlessTs = headlessCodexTimestamp(raw) || ts;
         if (!sessionStartEmitted) {
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts: headlessTs,
             type: "session.started",
             sessionId,
             model: eventModel,
             confidence: "derived"
-          }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "session", options }));
+          }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "session", options });
           sessionStartEmitted = true;
         }
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts: headlessTs,
           type: "model.usage",
           sessionId,
           model: eventModel,
           confidence: "partial",
           metrics: usage
-        }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "headless", options }));
+        }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "headless", options });
       }
       continue;
     }
@@ -2325,7 +2344,7 @@ async function parseCodexSessionFile(filePath, options) {
     switch (payloadType) {
       case "task_started": {
         currentTurnId = stringField(payload, "turn_id") || currentTurnId;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "turn.started",
           sessionId,
@@ -2334,14 +2353,15 @@ async function parseCodexSessionFile(filePath, options) {
           project,
           model,
           confidence: "exact"
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "user_message": {
         const message = stringField(payload, "message") || "";
-        if (currentTurnId && currentTurnId !== turnIdAtLastUserMessage && lastTurnIdForComplete) {
-          events.push(withBackfillRefs(baseCodexEvent({
-            ts,
+        if (currentTurnId && currentTurnId !== turnIdAtLastUserMessage && lastTurnIdForComplete && !closedTurnIds.has(lastTurnIdForComplete)) {
+          closedTurnIds.add(lastTurnIdForComplete);
+          pushEvent(baseCodexEvent({
+            ts: turnCloseTs(lastTurnIdForComplete),
             type: "turn.completed",
             sessionId,
             turnId: lastTurnIdForComplete,
@@ -2349,14 +2369,14 @@ async function parseCodexSessionFile(filePath, options) {
             project,
             model,
             confidence: "derived"
-          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         }
         if (!currentTurnId || currentTurnId === turnIdAtLastUserMessage) {
           currentTurnId = `turn_${createStableHash([sessionId, lineNumber, ts]).slice(0, 24)}`;
         }
         lastTurnIdForComplete = currentTurnId;
         turnIdAtLastUserMessage = currentTurnId;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "prompt.submitted",
           sessionId,
@@ -2372,7 +2392,7 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             promptHash: message ? `sha256:${createStableHash(message)}` : void 0
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "token_count": {
@@ -2394,7 +2414,7 @@ async function parseCodexSessionFile(filePath, options) {
             break;
           }
           lastTokenUsageKey = usageKey;
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts,
             type: "model.usage",
             sessionId,
@@ -2407,13 +2427,13 @@ async function parseCodexSessionFile(filePath, options) {
             model: rewriteCodexModelForTier(model, serviceTier),
             confidence: "partial",
             metrics: usage
-          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         }
         break;
       }
       case "agent_message": {
         const message = stringField(payload, "message") || "";
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "agent.operation",
           operation: "agent message",
@@ -2426,7 +2446,7 @@ async function parseCodexSessionFile(filePath, options) {
           metrics: {
             agentMessageChars: message.length
           }
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "function_call":
@@ -2438,7 +2458,7 @@ async function parseCodexSessionFile(filePath, options) {
         if (callId) {
           pendingToolCalls.set(callId, { tool, startedAt: ts, turnId: currentTurnId });
         }
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "tool.started",
           operation: `${tool} started`,
@@ -2455,9 +2475,9 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             sourceId: callId
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         if (fileActivities.length > 0) {
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts,
             type: eventTypeFromFileActivities(fileActivities),
             operation: `${tool} file activity`,
@@ -2473,7 +2493,7 @@ async function parseCodexSessionFile(filePath, options) {
             refs: stringRefs({
               sourceId: callId
             })
-          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         }
         break;
       }
@@ -2485,7 +2505,7 @@ async function parseCodexSessionFile(filePath, options) {
           pendingToolCalls.delete(callId);
         }
         const durationMs = pending ? durationMsBetween(pending.startedAt, ts) : void 0;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "tool.completed",
           operation: pending ? `${pending.tool} completed` : "tool completed",
@@ -2503,13 +2523,13 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             sourceId: callId
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "exec_command_end": {
         const durationMs = durationObjectToMs(objectField(payload, "duration"));
         const success = Number(payload.exit_code) === 0;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: success ? "command.completed" : "command.failed",
           operation: "command completed",
@@ -2530,7 +2550,7 @@ async function parseCodexSessionFile(filePath, options) {
             sourceId: stringField(payload, "call_id"),
             commandHash: createStableHash(payload.command)
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "patch_apply_end": {
@@ -2540,7 +2560,7 @@ async function parseCodexSessionFile(filePath, options) {
           cwd,
           displayFilePath2
         );
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "file.changed",
           operation: "apply patch",
@@ -2557,15 +2577,19 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             sourceId: stringField(payload, "call_id")
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "task_complete": {
-        events.push(withBackfillRefs(baseCodexEvent({
+        const completedTurnId = stringField(payload, "turn_id") || currentTurnId;
+        if (completedTurnId) {
+          closedTurnIds.add(completedTurnId);
+        }
+        pushEvent(baseCodexEvent({
           ts,
           type: "turn.completed",
           sessionId,
-          turnId: stringField(payload, "turn_id") || currentTurnId,
+          turnId: completedTurnId,
           cwd,
           project,
           model,
@@ -2573,15 +2597,15 @@ async function parseCodexSessionFile(filePath, options) {
           metrics: {
             durationMs: numberField(payload, "duration_ms")
           }
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
     }
   }
-  if (lastTurnIdForComplete) {
-    const lastTs = events.length > 0 ? events.at(-1).ts : (/* @__PURE__ */ new Date()).toISOString();
-    events.push(withBackfillRefs(baseCodexEvent({
-      ts: lastTs,
+  if (lastTurnIdForComplete && !closedTurnIds.has(lastTurnIdForComplete)) {
+    closedTurnIds.add(lastTurnIdForComplete);
+    pushEvent(baseCodexEvent({
+      ts: turnCloseTs(lastTurnIdForComplete),
       type: "turn.completed",
       sessionId,
       turnId: lastTurnIdForComplete,
@@ -2589,7 +2613,7 @@ async function parseCodexSessionFile(filePath, options) {
       project,
       model,
       confidence: "derived"
-    }), { filePath, sourcePathHash, lineNumber: lines.length, topType: "event_msg", payloadType: "turn.completed", options }));
+    }), { filePath, sourcePathHash, lineNumber: lines.length, topType: "event_msg", payloadType: "turn.completed", options });
   }
   return events.filter((event) => validateCanonicalEvent(event).valid);
 }
@@ -2628,10 +2652,11 @@ function headlessCodexUsage(raw) {
   if (input === 0 && cached === 0 && output === 0 && reasoning === 0 && total === 0) {
     return;
   }
+  const billableOutput = output + reasoning;
   return {
     tokensInput: input || void 0,
     tokensCachedInput: cached || void 0,
-    tokensOutput: output || void 0,
+    tokensOutput: billableOutput || void 0,
     tokensReasoningOutput: reasoning || void 0,
     tokensTotal: total,
     modelCalls: 1
@@ -2992,9 +3017,10 @@ async function parseGeminiSessionFile(filePath, options) {
   let lastTs = usages[0].ts;
   for (const [index, usage] of usages.entries()) {
     lastTs = usage.ts;
+    const billableOutput = usage.tokensOutput + usage.tokensReasoning;
     const metrics = {
       tokensInput: usage.tokensInput || void 0,
-      tokensOutput: usage.tokensOutput || void 0,
+      tokensOutput: billableOutput || void 0,
       tokensCachedInput: usage.tokensCacheRead || void 0,
       tokensCacheReadInput: usage.tokensCacheRead || void 0,
       tokensReasoningOutput: usage.tokensReasoning || void 0,
@@ -3439,13 +3465,14 @@ function opencodeUsageFromInfo(info) {
   const cacheRead = Math.max(0, numberField(cache, "read") || 0);
   const cacheWrite = Math.max(0, numberField(cache, "write") || 0);
   const totalInput = input + cacheRead + cacheWrite;
-  const total = Math.max(0, numberField(tokensObj, "total") || totalInput + output + reasoning);
+  const billableOutput = output + reasoning;
+  const total = Math.max(0, numberField(tokensObj, "total") || totalInput + billableOutput);
   if (total <= 0) {
     return void 0;
   }
   return {
     tokensInput: totalInput || void 0,
-    tokensOutput: output || void 0,
+    tokensOutput: billableOutput || void 0,
     tokensReasoningOutput: reasoning || void 0,
     tokensCachedInput: cacheRead + cacheWrite || void 0,
     tokensCacheReadInput: cacheRead || void 0,
@@ -4113,6 +4140,7 @@ function buildSessionRollup(rollupKey, events) {
   const toolRollups = /* @__PURE__ */ new Map();
   const fileRollups = /* @__PURE__ */ new Map();
   const turnRollups = /* @__PURE__ */ new Map();
+  const turnEventTimes = /* @__PURE__ */ new Map();
   let promptCount = 0;
   let turnCount = 0;
   let toolCallCount = 0;
@@ -4210,6 +4238,12 @@ function buildSessionRollup(rollupKey, events) {
       turnRollup.outputTokens += eventOutputTokens;
       turnRollup.totalTokens += eventTotalTokens;
       turnRollups.set(event.turnId, turnRollup);
+      const times = turnEventTimes.get(event.turnId);
+      if (times) {
+        times.push(event.ts);
+      } else {
+        turnEventTimes.set(event.turnId, [event.ts]);
+      }
     }
     inputTokens += eventInputTokens;
     cachedInputTokens += eventCachedInputTokens;
@@ -4327,6 +4361,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.
+    schemaVersion: AGENT_ROLLUP_SCHEMA_VERSION,
     source: first.source,
     project,
     sessionId,
@@ -4354,7 +4394,10 @@ function buildSessionRollup(rollupKey, events) {
     fileRollups: [...fileRollups.values()].sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.displayPath.localeCompare(b.displayPath)),
     turnRollups: [...turnRollups.values()].map((rollup) => ({
       ...rollup,
-      durationMs: Math.max(0, Date.parse(rollup.lastEventAt) - Date.parse(rollup.startedAt))
+      // Gap-clamped active duration: startedAt/lastEventAt/completedAt keep their
+      // real timestamps, but durationMs only counts active intervals so lazy
+      // completed_at timestamps and long in-turn silences don't inflate it.
+      durationMs: gapClampedTurnDurationMs(rollup, turnEventTimes.get(rollup.turnId) || [])
     })).sort((a, b) => a.startedAt.localeCompare(b.startedAt))
   };
   return {
@@ -4362,6 +4405,22 @@ function buildSessionRollup(rollupKey, events) {
     payloadHash: createPayloadHash(baseRollup)
   };
 }
+function gapClampedTurnDurationMs(rollup, eventTimes) {
+  const millis = [
+    rollup.promptSubmittedAt,
+    rollup.startedAt,
+    ...eventTimes
+  ].map((ts) => ts ? Date.parse(ts) : Number.NaN).filter((ms) => Number.isFinite(ms));
+  const unique = [...new Set(millis)].sort((a, b) => a - b);
+  if (unique.length < 2) {
+    return 0;
+  }
+  let duration = 0;
+  for (let i = 1; i < unique.length; i += 1) {
+    duration += Math.min(unique[i] - unique[i - 1], TURN_GAP_CLAMP_MS);
+  }
+  return Math.max(0, duration);
+}
 function floorRollupBucket(ts) {
   const ms = Date.parse(ts);
   if (!Number.isFinite(ms)) {
@@ -4374,7 +4433,7 @@ function totalTokensFromEvent(event) {
   if (typeof explicit === "number" && explicit > 0) {
     return explicit;
   }
-  return Math.max(0, event.metrics?.tokensInput || 0) + Math.max(0, event.metrics?.tokensOutput || 0) + Math.max(0, event.metrics?.tokensReasoningOutput || 0);
+  return Math.max(0, event.metrics?.tokensInput || 0) + Math.max(0, event.metrics?.tokensOutput || 0);
 }
 function lineStatsFromEvent(event) {
   const files = event.fileActivities || [];
@@ -4578,6 +4637,40 @@ async function logError(scope, error, meta = {}, home = homedir2()) {
   await writeLog({ scope, error, meta, level: "error" }, home);
 }
 
+// src/lib/login.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function openBrowser(ctx, url) {
+  const { command, args } = browserCommand(ctx.env.CODETIME_OS ?? process.platform, url);
+  try {
+    const child = ctx.spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref?.();
+  } catch {
+  }
+}
+function browserCommand(platform, url) {
+  if (platform === "darwin") {
+    return { command: "open", args: [url] };
+  }
+  if (platform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", url] };
+  }
+  return { command: "xdg-open", args: [url] };
+}
+function isHeadless(ctx) {
+  if (ctx.env.CODETIME_NO_BROWSER) {
+    return true;
+  }
+  if (ctx.env.SSH_CONNECTION || ctx.env.SSH_TTY) {
+    return true;
+  }
+  if (process.platform === "linux") {
+    return !ctx.env.DISPLAY && !ctx.env.WAYLAND_DISPLAY;
+  }
+  return false;
+}
+
 // src/lib/progress.ts
 var BAR_WIDTH = 24;
 var ProgressBar = class {
@@ -4737,6 +4830,28 @@ async function deleteRollupsBySource(remote, source, machine) {
   const body = await response.json();
   return Number(body.deleted) || 0;
 }
+async function startCliLink(remote) {
+  const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/cli/link/start"), {
+    method: "POST",
+    headers: buildHeaders(),
+    body: "{}"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to start login: ${response.status}`);
+  }
+  return await response.json();
+}
+async function pollCliLink(remote, deviceCode) {
+  const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/cli/link/poll"), {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify({ deviceCode })
+  });
+  if (!response.ok) {
+    throw new Error(`Login poll failed: ${response.status}`);
+  }
+  return await response.json();
+}
 async function listMachines(remote) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/machines"), {
     headers: buildHeaders(remote.token)
@@ -4843,6 +4958,11 @@ function createCli(ctx, registry) {
   cli.command("sync-local-trigger", "Trigger one background local sync with throttle and locking").option("--min-interval <seconds>", "Minimum seconds between sync triggers").action((options) => syncLocalTriggerCommand(normalizeOptions(options), ctx, registry));
   cli.command("sync-local-runner", "Internal background local sync runner").option("--lock-file <path>", "Lock file for the active sync").option("--state-file <path>", "State file for trigger metadata").action((options) => syncLocalRunnerCommand(normalizeOptions(options), ctx, registry));
   cli.command("backfill [action]", "Inspect local history import candidates").option("--source <source>", "Backfill source").option("--since <time>", "Only include history after this time").option("--until <time>", "Only include history before this time").option("--project <name>", "Project filter").option("--source-root <path>", "Override source history root").option("--include-source-path", "Include local source paths in output").option("--import-run <id>", "Import run id for verify/resume workflows").option("--limit <count>", "Maximum session files to parse").option("--batch-size <count>", "Max rollups per request (also bounded by --batch-bytes)").option("--batch-bytes <bytes>", "Soft byte cap for the JSON body of a single ingest POST").option("--replace", "Replace conflicting records during import (default)").option("--skip-conflicts", "Skip conflicting records instead of replacing them").option("--force", "Force full re-import: clear watermark and re-process all files").action((action, options) => backfillCommand({ ...normalizeOptions(options), action }, ctx, registry));
+  cli.command("sync", "Import and upload all local agent history (shorthand for `backfill import --source all`)").option("--source <source>", "Limit to one source (default: all)").option("--since <time>", "Only include history after this time").option("--until <time>", "Only include history before this time").option("--project <name>", "Project filter").option("--batch-size <count>", "Max rollups per request (also bounded by --batch-bytes)").option("--force", "Force full re-import: clear watermark and re-process all files").option("--dry-run", "Print the planned import without uploading").action((options) => {
+    const opts = normalizeOptions(options);
+    return backfillCommand({ ...opts, action: "import", source: stringOption(opts.source) || "all" }, ctx, registry);
+  });
+  cli.command("login", "Authorize this machine by signing in through your browser").option("--remote <url>", "Override API base URL for this login").option("--no-browser", "Print the login URL instead of opening a browser").action((options) => loginCommand(normalizeOptions(options), ctx));
   cli.command("token [action] [value]", "Set, show, or clear the persisted API token").option("--remote <url>", "Override API base URL when setting a token").action((action, value, options) => tokenCommand(action, value, normalizeOptions(options), ctx));
   cli.command("machine [action]", "List or rename machines (requires login)").option("--name <name>", "New display name (used by `machine rename`)").option("--id <id>", "Machine id (defaults to current machine)").action((action, options) => machineCommand(action, normalizeOptions(options), ctx));
   return cli;
@@ -5716,6 +5836,80 @@ function maskToken(token) {
   }
   return `${token.slice(0, 3)}\u2026${token.slice(-4)}`;
 }
+var LOGIN_MAX_WAIT_MS = 15 * 60 * 1e3;
+async function loginCommand(options, ctx) {
+  const home = resolveHome(options, ctx);
+  const remoteOverride = stringOption(options.remote) || stringOption(options["api-url"]);
+  const existing = readConfig(home);
+  const baseUrl = (remoteOverride || ctx.env.CODETIME_API_URL || existing.remoteUrl || DEFAULT_API_URL).replace(/\/$/, "");
+  const remote = resolveRemote({
+    apiUrl: baseUrl,
+    env: ctx.env,
+    fetch: ctx.fetch,
+    homeOverride: home
+  });
+  if (!remote) {
+    write(ctx.stderr, "No fetch implementation available.\n");
+    return 1;
+  }
+  let link;
+  try {
+    link = await startCliLink(remote);
+  } catch (error) {
+    write(ctx.stderr, `${error.message}
+`);
+    return 1;
+  }
+  const authUrl = `${baseUrl}/cli/auth?code=${encodeURIComponent(link.userCode)}`;
+  const noBrowser = options.browser === false;
+  const headless = isHeadless(ctx);
+  write(ctx.stdout, `
+To sign in, visit:
+
+  ${authUrl}
+
+and confirm this code:  ${link.userCode}
+
+`);
+  if (!noBrowser && !headless) {
+    openBrowser(ctx, authUrl);
+  }
+  write(ctx.stdout, "Waiting for authorization\u2026\n");
+  const intervalMs = Math.max(1, link.interval || 4) * 1e3;
+  const deadline = Date.now() + Math.min(LOGIN_MAX_WAIT_MS, Math.max(1, link.expiresIn || 600) * 1e3);
+  while (Date.now() < deadline) {
+    let poll;
+    try {
+      poll = await pollCliLink(remote, link.deviceCode);
+    } catch (error) {
+      void error;
+      await sleep(intervalMs);
+      continue;
+    }
+    if (poll.status === "pending") {
+      await sleep(intervalMs);
+      continue;
+    }
+    if (poll.status === "expired") {
+      write(ctx.stderr, "Login code expired before it was approved. Re-run `codetime login`.\n");
+      return 1;
+    }
+    writeConfig({
+      ...existing,
+      token: poll.token,
+      ...poll.userId == null ? {} : { userId: String(poll.userId) },
+      // Persist the host only when explicitly overridden, matching
+      // `token set` so a default-host login never clobbers an earlier
+      // --remote choice.
+      ...remoteOverride ? { remoteUrl: remoteOverride } : {}
+    }, home);
+    write(ctx.stdout, `Logged in. Token saved (${maskToken(poll.token)}).
+`);
+    return 0;
+  }
+  write(ctx.stderr, "Timed out waiting for authorization. Re-run `codetime login`.\n");
+  return 1;
+}
 async function tokenCommand(action, value, options, ctx) {
   const verb = action || "show";
   const home = resolveHome(options, ctx);
@@ -5827,20 +6021,25 @@ Usage:
   codetime detect [--json] [--home <path>]
   codetime install [--target codex,claude,opencode,pi] [--all] [--dry-run] [--force] [--home <path>]
   codetime hook --agent <name>
+  codetime sync [--source <source>] [--force] [--dry-run]
   codetime backfill discover|plan|import|verify --source codex|claude-code|opencode|pi|all --dry-run [--json] [--batch-size <count>]
+  codetime login [--no-browser] [--remote <url>]
   codetime token set <token>
   codetime token show
   codetime token clear
 
 Setup:
-  Copy your upload token from https://codetime.dev/dashboard/settings,
-  then run: codetime token set <token>
+  Run: codetime login  (signs in through your browser)
+  Or copy your upload token from https://codetime.dev/dashboard/settings
+  and run: codetime token set <token>
 
 Commands:
   detect    Show supported local targets and install status.
   install   Install integration files into detected or requested targets.
   hook      Read agent hook JSON from stdin and report a throttled event.
+  sync      Import and upload all local agent history (backfill import --source all).
   backfill  Discover local history and create metadata-only import plans.
+  login     Authorize this machine by signing in through your browser.
   token     Set, show, or clear the persisted API token.
   machine   List your machines (read-only).
   version   Print CLI version.

package/package.json

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