claude-code-wakatime 1.0.1 → 2.0.0

package/dist/dependencies.js

@@ -0,0 +1,416 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependencies = void 0;
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const child_process = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const request = __importStar(require("request"));
+const semver = __importStar(require("semver"));
+const which = __importStar(require("which"));
+const utils_1 = require("./utils");
+var osName;
+(function (osName) {
+    osName["darwin"] = "darwin";
+    osName["windows"] = "windows";
+    osName["linux"] = "linux";
+})(osName || (osName = {}));
+class Dependencies {
+    constructor(options, logger) {
+        this.cliLocation = undefined;
+        this.cliLocationGlobal = undefined;
+        this.cliInstalled = false;
+        this.githubDownloadUrl = 'https://github.com/wakatime/wakatime-cli/releases/latest/download';
+        this.githubReleasesUrl = 'https://api.github.com/repos/wakatime/wakatime-cli/releases/latest';
+        this.legacyOperatingSystems = {
+            [osName.darwin]: [{ kernelLessThan: '17.0.0', tag: 'v1.39.1-alpha.1' }],
+        };
+        this.options = options;
+        this.logger = logger;
+        this.resourcesLocation = options.resourcesLocation;
+    }
+    getCliLocation() {
+        if (this.cliLocation)
+            return this.cliLocation;
+        this.cliLocation = this.getCliLocationGlobal();
+        if (this.cliLocation)
+            return this.cliLocation;
+        const osname = this.osName();
+        const arch = this.architecture();
+        const ext = utils_1.Utils.isWindows() ? '.exe' : '';
+        const binary = `wakatime-cli-${osname}-${arch}${ext}`;
+        this.cliLocation = path.join(this.resourcesLocation, binary);
+        return this.cliLocation;
+    }
+    getCliLocationGlobal() {
+        if (this.cliLocationGlobal)
+            return this.cliLocationGlobal;
+        const binaryName = `wakatime-cli${utils_1.Utils.isWindows() ? '.exe' : ''}`;
+        const path = which.sync(binaryName, { nothrow: true });
+        if (path) {
+            this.cliLocationGlobal = path;
+            this.logger.debug(`Using global wakatime-cli location: ${path}`);
+        }
+        return this.cliLocationGlobal;
+    }
+    isCliInstalled() {
+        if (this.cliInstalled)
+            return true;
+        this.cliInstalled = fs.existsSync(this.getCliLocation());
+        return this.cliInstalled;
+    }
+    checkAndInstallCli(callback) {
+        if (!this.isCliInstalled()) {
+            this.installCli(callback ?? (() => { }));
+        }
+        else {
+            this.isCliLatest((isLatest) => {
+                if (!isLatest) {
+                    this.installCli(callback ?? (() => { }));
+                }
+                else {
+                    callback?.();
+                }
+            });
+        }
+    }
+    isCliLatest(callback) {
+        if (this.getCliLocationGlobal()) {
+            callback(true);
+            return;
+        }
+        let args = ['--version'];
+        const options = utils_1.Utils.buildOptions();
+        try {
+            child_process.execFile(this.getCliLocation(), args, options, (error, _stdout, stderr) => {
+                if (!(error != null)) {
+                    let currentVersion = _stdout.toString().trim() + stderr.toString().trim();
+                    this.logger.debug(`Current wakatime-cli version is ${currentVersion}`);
+                    if (currentVersion === '<local-build>') {
+                        callback(true);
+                        return;
+                    }
+                    const tag = this.legacyReleaseTag();
+                    if (tag && currentVersion !== tag) {
+                        callback(false);
+                        return;
+                    }
+                    const accessed = this.options.getSetting('internal', 'cli_version_last_accessed', true);
+                    const now = Math.round(Date.now() / 1000);
+                    const lastAccessed = parseInt(accessed ?? '0');
+                    const fourHours = 4 * 3600;
+                    if (lastAccessed && lastAccessed + fourHours > now) {
+                        this.logger.debug(`Skip checking for wakatime-cli updates because recently checked ${now - lastAccessed} seconds ago.`);
+                        callback(true);
+                        return;
+                    }
+                    this.logger.debug('Checking for updates to wakatime-cli...');
+                    this.getLatestCliVersion((latestVersion) => {
+                        if (currentVersion === latestVersion) {
+                            this.logger.debug('wakatime-cli is up to date');
+                            callback(true);
+                        }
+                        else if (latestVersion) {
+                            this.logger.debug(`Found an updated wakatime-cli ${latestVersion}`);
+                            callback(false);
+                        }
+                        else {
+                            this.logger.debug('Unable to find latest wakatime-cli version');
+                            callback(false);
+                        }
+                    });
+                }
+                else {
+                    callback(false);
+                }
+            });
+        }
+        catch (e) {
+            callback(false);
+        }
+    }
+    getLatestCliVersion(callback) {
+        const proxy = this.options.getSetting('settings', 'proxy');
+        const noSSLVerify = this.options.getSetting('settings', 'no_ssl_verify');
+        let options = {
+            url: this.githubReleasesUrl,
+            json: true,
+            headers: {
+                'User-Agent': 'github.com/wakatime/vscode-wakatime',
+            },
+        };
+        this.logger.debug(`Fetching latest wakatime-cli version from GitHub API: ${options.url}`);
+        if (proxy) {
+            this.logger.debug(`Using Proxy: ${proxy}`);
+            options['proxy'] = proxy;
+        }
+        if (noSSLVerify === 'true')
+            options['strictSSL'] = false;
+        try {
+            request.get(options, (error, response, json) => {
+                if (!error && response && response.statusCode == 200) {
+                    this.logger.debug(`GitHub API Response ${response.statusCode}`);
+                    const latestCliVersion = json['tag_name'];
+                    this.logger.debug(`Latest wakatime-cli version from GitHub: ${latestCliVersion}`);
+                    this.options.setSetting('internal', 'cli_version_last_accessed', String(Math.round(Date.now() / 1000)), true);
+                    callback(latestCliVersion);
+                }
+                else {
+                    if (response) {
+                        this.logger.warn(`GitHub API Response ${response.statusCode}: ${error}`);
+                    }
+                    else {
+                        this.logger.warn(`GitHub API Response Error: ${error}`);
+                    }
+                    callback('');
+                }
+            });
+        }
+        catch (e) {
+            this.logger.warnException(e);
+            callback('');
+        }
+    }
+    installCli(callback) {
+        this.logger.debug(`Downloading wakatime-cli from GitHub...`);
+        const url = this.cliDownloadUrl();
+        let zipFile = path.join(this.resourcesLocation, 'wakatime-cli' + this.randStr() + '.zip');
+        this.downloadFile(url, zipFile, () => {
+            this.extractCli(zipFile, callback);
+        }, callback);
+    }
+    isSymlink(file) {
+        try {
+            return fs.lstatSync(file).isSymbolicLink();
+        }
+        catch (_) { }
+        return false;
+    }
+    extractCli(zipFile, callback) {
+        this.logger.debug(`Extracting wakatime-cli into "${this.resourcesLocation}"...`);
+        this.backupCli();
+        this.unzip(zipFile, this.resourcesLocation, (unzipped) => {
+            if (!unzipped) {
+                this.restoreCli();
+            }
+            else if (!utils_1.Utils.isWindows()) {
+                this.removeCli();
+                const cli = this.getCliLocation();
+                try {
+                    this.logger.debug('Chmod 755 wakatime-cli...');
+                    fs.chmodSync(cli, 0o755);
+                }
+                catch (e) {
+                    this.logger.warnException(e);
+                }
+                const ext = utils_1.Utils.isWindows() ? '.exe' : '';
+                const link = path.join(this.resourcesLocation, `wakatime-cli${ext}`);
+                if (!this.isSymlink(link)) {
+                    try {
+                        this.logger.debug(`Create symlink from wakatime-cli to ${cli}`);
+                        fs.symlinkSync(cli, link);
+                    }
+                    catch (e) {
+                        this.logger.warnException(e);
+                        try {
+                            fs.copyFileSync(cli, link);
+                            fs.chmodSync(link, 0o755);
+                        }
+                        catch (e2) {
+                            this.logger.warnException(e2);
+                        }
+                    }
+                }
+            }
+            callback();
+        });
+        this.logger.debug('Finished extracting wakatime-cli.');
+    }
+    backupCli() {
+        if (fs.existsSync(this.getCliLocation())) {
+            fs.renameSync(this.getCliLocation(), `${this.getCliLocation()}.backup`);
+        }
+    }
+    restoreCli() {
+        const backup = `${this.getCliLocation()}.backup`;
+        if (fs.existsSync(backup)) {
+            fs.renameSync(backup, this.getCliLocation());
+        }
+    }
+    removeCli() {
+        const backup = `${this.getCliLocation()}.backup`;
+        if (fs.existsSync(backup)) {
+            fs.unlinkSync(backup);
+        }
+    }
+    downloadFile(url, outputFile, callback, error) {
+        const proxy = this.options.getSetting('settings', 'proxy');
+        const noSSLVerify = this.options.getSetting('settings', 'no_ssl_verify');
+        let options = { url: url };
+        if (proxy) {
+            this.logger.debug(`Using Proxy: ${proxy}`);
+            options['proxy'] = proxy;
+        }
+        if (noSSLVerify === 'true')
+            options['strictSSL'] = false;
+        try {
+            let r = request.get(options);
+            r.on('error', (e) => {
+                this.logger.warn(`Failed to download ${url}`);
+                this.logger.warn(e.toString());
+                error();
+            });
+            let out = fs.createWriteStream(outputFile);
+            r.pipe(out);
+            r.on('end', () => {
+                out.on('finish', () => {
+                    callback();
+                });
+            });
+        }
+        catch (e) {
+            this.logger.warnException(e);
+            callback();
+        }
+    }
+    unzip(file, outputDir, callback) {
+        if (fs.existsSync(file)) {
+            try {
+                let zip = new adm_zip_1.default(file);
+                zip.extractAllTo(outputDir, true);
+                fs.unlinkSync(file);
+                callback(true);
+                return;
+            }
+            catch (e) {
+                this.logger.warnException(e);
+            }
+            try {
+                fs.unlinkSync(file);
+            }
+            catch (e2) {
+                this.logger.warnException(e2);
+            }
+            callback(false);
+        }
+    }
+    legacyReleaseTag() {
+        const osname = this.osName();
+        const legacyOS = this.legacyOperatingSystems[osname];
+        if (!legacyOS)
+            return;
+        const version = legacyOS.find((spec) => {
+            try {
+                return semver.lt(os.release(), spec.kernelLessThan);
+            }
+            catch (e) {
+                return false;
+            }
+        });
+        return version?.tag;
+    }
+    architecture() {
+        const arch = os.arch();
+        if (arch.indexOf('32') > -1)
+            return '386';
+        if (arch.indexOf('x64') > -1)
+            return 'amd64';
+        return arch;
+    }
+    osName() {
+        let osname = os.platform();
+        if (osname == 'win32')
+            osname = 'windows';
+        return osname;
+    }
+    cliDownloadUrl() {
+        const osname = this.osName();
+        const arch = this.architecture();
+        // Use legacy wakatime-cli release to support older operating systems
+        const tag = this.legacyReleaseTag();
+        if (tag) {
+            return `https://github.com/wakatime/wakatime-cli/releases/download/${tag}/wakatime-cli-${osname}-${arch}.zip`;
+        }
+        const validCombinations = [
+            'android-amd64',
+            'android-arm64',
+            'darwin-amd64',
+            'darwin-arm64',
+            'freebsd-386',
+            'freebsd-amd64',
+            'freebsd-arm',
+            'linux-386',
+            'linux-amd64',
+            'linux-arm',
+            'linux-arm64',
+            'netbsd-386',
+            'netbsd-amd64',
+            'netbsd-arm',
+            'openbsd-386',
+            'openbsd-amd64',
+            'openbsd-arm',
+            'openbsd-arm64',
+            'windows-386',
+            'windows-amd64',
+            'windows-arm64',
+        ];
+        if (!validCombinations.includes(`${osname}-${arch}`))
+            this.reportMissingPlatformSupport(osname, arch);
+        return `${this.githubDownloadUrl}/wakatime-cli-${osname}-${arch}.zip`;
+    }
+    reportMissingPlatformSupport(osname, architecture) {
+        const url = `https://api.wakatime.com/api/v1/cli-missing?osname=${osname}&architecture=${architecture}&plugin=vscode`;
+        const proxy = this.options.getSetting('settings', 'proxy');
+        const noSSLVerify = this.options.getSetting('settings', 'no_ssl_verify');
+        let options = { url: url };
+        if (proxy)
+            options['proxy'] = proxy;
+        if (noSSLVerify === 'true')
+            options['strictSSL'] = false;
+        try {
+            request.get(options);
+        }
+        catch (e) { }
+    }
+    randStr() {
+        return (Math.random() + 1).toString(36).substring(7);
+    }
+}
+exports.Dependencies = Dependencies;

package/dist/index.js

@@ -9,17 +9,16 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const child_process_1 = require("child_process");
 const options_1 = require("./options");
-const VERSION = '1.0.0';
+const version_1 = require("./version");
+const dependencies_1 = require("./dependencies");
+const utils_1 = require("./utils");
+const logger_1 = require("./logger");
 const STATE_FILE = path_1.default.join(os_1.default.homedir(), '.wakatime', 'claude-code.json');
-const SESSION_LOG_FILE = path_1.default.join(os_1.default.homedir(), '.wakatime', 'claude-sessions.log');
 const WAKATIME_CLI = path_1.default.join(os_1.default.homedir(), '.wakatime', 'wakatime-cli');
-function timestamp() {
-    return Date.now() / 1000;
-}
 function shouldSendHeartbeat() {
     try {
-        const last = JSON.parse(fs_1.default.readFileSync(STATE_FILE, 'utf-8')).lastHeartbeatAt ?? timestamp();
-        return timestamp() - last >= 60;
+        const last = JSON.parse(fs_1.default.readFileSync(STATE_FILE, 'utf-8')).lastHeartbeatAt ?? utils_1.Utils.timestamp();
+        return utils_1.Utils.timestamp() - last >= 60;
     }
     catch {
         return true;
@@ -38,20 +37,11 @@ function parseInput() {
     }
     return undefined;
 }
-function logSessionData(inp) {
-    try {
-        fs_1.default.mkdirSync(path_1.default.dirname(SESSION_LOG_FILE), { recursive: true });
-        fs_1.default.appendFileSync(SESSION_LOG_FILE, JSON.stringify(inp, null, 2) + '\n\n');
-    }
-    catch (err) {
-        // ignore
-    }
-}
 function updateState() {
     fs_1.default.mkdirSync(path_1.default.dirname(STATE_FILE), { recursive: true });
-    fs_1.default.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: timestamp() }, null, 2));
+    fs_1.default.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: utils_1.Utils.timestamp() }, null, 2));
 }
-function sendHeartbeat(inp) {
+function sendHeartbeat(inp, logger) {
     const projectFolder = inp?.cwd;
     try {
         const args = [
@@ -62,7 +52,7 @@ function sendHeartbeat(inp) {
             '--category',
             'ai coding',
             '--plugin',
-            `claude-code-wakatime/${VERSION}`,
+            `claude-code-wakatime/${version_1.VERSION}`,
         ];
         if (projectFolder) {
             args.push('--project-folder');
@@ -71,17 +61,28 @@ function sendHeartbeat(inp) {
         (0, child_process_1.execFileSync)(WAKATIME_CLI, args);
     }
     catch (err) {
-        console.error('Failed to send WakaTime heartbeat:', err.message);
+        logger.errorException(err);
     }
 }
 function main() {
     const inp = parseInput();
     const options = new options_1.Options();
     const debug = options.getSetting('settings', 'debug');
-    if (inp && debug === 'true')
-        logSessionData(inp);
+    const logger = new logger_1.Logger(debug === 'true' ? logger_1.LogLevel.DEBUG : logger_1.LogLevel.INFO);
+    const deps = new dependencies_1.Dependencies(options, logger);
+    if (inp) {
+        try {
+            logger.debug(JSON.stringify(inp, null, 2));
+        }
+        catch (err) {
+            // ignore
+        }
+    }
+    if (inp?.hook_event_name === 'SessionStart') {
+        deps.checkAndInstallCli();
+    }
     if (shouldSendHeartbeat()) {
-        sendHeartbeat(inp);
+        sendHeartbeat(inp, logger);
         updateState();
     }
 }

package/dist/logger.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevel = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const utils_1 = require("./utils");
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const LOG_FILE = path_1.default.join(os_1.default.homedir(), '.wakatime', 'claude-code.log');
+class Logger {
+    constructor(level) {
+        this.level = LogLevel.INFO;
+        if (level)
+            this.setLevel(level);
+    }
+    getLevel() {
+        return this.level;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    log(level, msg) {
+        if (level >= this.level) {
+            msg = `[${utils_1.Utils.timestamp()}][${LogLevel[level]}] ${msg}\n`;
+            fs_1.default.mkdirSync(path_1.default.dirname(LOG_FILE), { recursive: true });
+            fs_1.default.appendFileSync(LOG_FILE, msg);
+        }
+    }
+    debug(msg) {
+        this.log(LogLevel.DEBUG, msg);
+    }
+    debugException(msg) {
+        if (msg.message !== undefined) {
+            this.log(LogLevel.DEBUG, msg.message);
+        }
+        else {
+            this.log(LogLevel.DEBUG, msg.toString());
+        }
+    }
+    info(msg) {
+        this.log(LogLevel.INFO, msg);
+    }
+    warn(msg) {
+        this.log(LogLevel.WARN, msg);
+    }
+    warnException(msg) {
+        if (msg.message !== undefined) {
+            this.log(LogLevel.WARN, msg.message);
+        }
+        else {
+            this.log(LogLevel.WARN, msg.toString());
+        }
+    }
+    error(msg) {
+        this.log(LogLevel.ERROR, msg);
+    }
+    errorException(msg) {
+        if (msg.message !== undefined) {
+            this.log(LogLevel.ERROR, msg.message);
+        }
+        else {
+            this.log(LogLevel.ERROR, msg.toString());
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/utils.js

@@ -122,5 +122,8 @@ class Utils {
         }
         return options;
     }
+    static timestamp() {
+        return Date.now() / 1000;
+    }
 }
 exports.Utils = Utils;

package/dist/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// This file is auto-generated during build. Do not edit manually.
+exports.VERSION = '1.0.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-wakatime",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "WakaTime plugin for Claude Code",
   "bin": {
     "claude-code-wakatime": "dist/index.js"
@@ -30,11 +30,21 @@
     "@types/node": "^20.9.2",
     "@types/pidusage": "^2.0.5",
     "@types/prettier": "^2.7.3",
+    "@types/adm-zip": "^0.5.7",
+    "@types/azdata": "^1.46.6",
+    "@types/request": "^2.48.12",
+    "@types/semver": "^7.7.0",
     "@typescript-eslint/eslint-plugin": "6.11.0",
     "@typescript-eslint/parser": "6.11.0",
+    "@types/which": "^3.0.4",
     "eslint": "^8.54.0",
+    "adm-zip": "0.5.16",
+    "azdata": "^1.0.0",
     "prettier": "^3.1.0",
-    "typescript": "^5.2.2"
+    "request": "2.88.2",
+    "semver": "^7.7.2",
+    "typescript": "^5.2.2",
+    "which": "^5.0.0"
   },
   "author": "WakaTime",
   "license": "BSD-3-Clause",

package/src/dependencies.ts

@@ -0,0 +1,395 @@
+import adm_zip from 'adm-zip';
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as request from 'request';
+import * as semver from 'semver';
+import * as which from 'which';
+
+import { Options, Setting } from './options';
+import { Utils } from './utils';
+import { Logger } from './logger';
+
+enum osName {
+  darwin = 'darwin',
+  windows = 'windows',
+  linux = 'linux',
+}
+
+export class Dependencies {
+  private options: Options;
+  private logger: Logger;
+  private resourcesLocation: string;
+  private cliLocation?: string = undefined;
+  private cliLocationGlobal?: string = undefined;
+  private cliInstalled: boolean = false;
+  private githubDownloadUrl = 'https://github.com/wakatime/wakatime-cli/releases/latest/download';
+  private githubReleasesUrl = 'https://api.github.com/repos/wakatime/wakatime-cli/releases/latest';
+  private legacyOperatingSystems: {
+    [key in osName]?: {
+      kernelLessThan: string;
+      tag: string;
+    }[];
+  } = {
+    [osName.darwin]: [{ kernelLessThan: '17.0.0', tag: 'v1.39.1-alpha.1' }],
+  };
+
+  constructor(options: Options, logger: Logger) {
+    this.options = options;
+    this.logger = logger;
+    this.resourcesLocation = options.resourcesLocation;
+  }
+
+  public getCliLocation(): string {
+    if (this.cliLocation) return this.cliLocation;
+
+    this.cliLocation = this.getCliLocationGlobal();
+    if (this.cliLocation) return this.cliLocation;
+
+    const osname = this.osName();
+    const arch = this.architecture();
+    const ext = Utils.isWindows() ? '.exe' : '';
+    const binary = `wakatime-cli-${osname}-${arch}${ext}`;
+    this.cliLocation = path.join(this.resourcesLocation, binary);
+
+    return this.cliLocation;
+  }
+
+  public getCliLocationGlobal(): string | undefined {
+    if (this.cliLocationGlobal) return this.cliLocationGlobal;
+
+    const binaryName = `wakatime-cli${Utils.isWindows() ? '.exe' : ''}`;
+    const path = which.sync(binaryName, { nothrow: true });
+    if (path) {
+      this.cliLocationGlobal = path;
+      this.logger.debug(`Using global wakatime-cli location: ${path}`);
+    }
+
+    return this.cliLocationGlobal;
+  }
+
+  public isCliInstalled(): boolean {
+    if (this.cliInstalled) return true;
+    this.cliInstalled = fs.existsSync(this.getCliLocation());
+    return this.cliInstalled;
+  }
+
+  public checkAndInstallCli(callback?: () => void): void {
+    if (!this.isCliInstalled()) {
+      this.installCli(callback ?? (() => {}));
+    } else {
+      this.isCliLatest((isLatest) => {
+        if (!isLatest) {
+          this.installCli(callback ?? (() => {}));
+        } else {
+          callback?.();
+        }
+      });
+    }
+  }
+
+  private isCliLatest(callback: (arg0: boolean) => void): void {
+    if (this.getCliLocationGlobal()) {
+      callback(true);
+      return;
+    }
+
+    let args = ['--version'];
+    const options = Utils.buildOptions();
+    try {
+      child_process.execFile(this.getCliLocation(), args, options, (error, _stdout, stderr) => {
+        if (!(error != null)) {
+          let currentVersion = _stdout.toString().trim() + stderr.toString().trim();
+          this.logger.debug(`Current wakatime-cli version is ${currentVersion}`);
+
+          if (currentVersion === '<local-build>') {
+            callback(true);
+            return;
+          }
+
+          const tag = this.legacyReleaseTag();
+          if (tag && currentVersion !== tag) {
+            callback(false);
+            return;
+          }
+
+          const accessed = this.options.getSetting('internal', 'cli_version_last_accessed', true);
+          const now = Math.round(Date.now() / 1000);
+          const lastAccessed = parseInt(accessed ?? '0');
+          const fourHours = 4 * 3600;
+          if (lastAccessed && lastAccessed + fourHours > now) {
+            this.logger.debug(`Skip checking for wakatime-cli updates because recently checked ${now - lastAccessed} seconds ago.`);
+            callback(true);
+            return;
+          }
+
+          this.logger.debug('Checking for updates to wakatime-cli...');
+          this.getLatestCliVersion((latestVersion) => {
+            if (currentVersion === latestVersion) {
+              this.logger.debug('wakatime-cli is up to date');
+              callback(true);
+            } else if (latestVersion) {
+              this.logger.debug(`Found an updated wakatime-cli ${latestVersion}`);
+              callback(false);
+            } else {
+              this.logger.debug('Unable to find latest wakatime-cli version');
+              callback(false);
+            }
+          });
+        } else {
+          callback(false);
+        }
+      });
+    } catch (e) {
+      callback(false);
+    }
+  }
+
+  private getLatestCliVersion(callback: (arg0: string) => void): void {
+    const proxy = this.options.getSetting('settings', 'proxy');
+    const noSSLVerify = this.options.getSetting('settings', 'no_ssl_verify');
+    let options: request.CoreOptions & { url: string } = {
+      url: this.githubReleasesUrl,
+      json: true,
+      headers: {
+        'User-Agent': 'github.com/wakatime/vscode-wakatime',
+      },
+    };
+    this.logger.debug(`Fetching latest wakatime-cli version from GitHub API: ${options.url}`);
+    if (proxy) {
+      this.logger.debug(`Using Proxy: ${proxy}`);
+      options['proxy'] = proxy;
+    }
+    if (noSSLVerify === 'true') options['strictSSL'] = false;
+    try {
+      request.get(options, (error, response, json) => {
+        if (!error && response && response.statusCode == 200) {
+          this.logger.debug(`GitHub API Response ${response.statusCode}`);
+          const latestCliVersion = json['tag_name'];
+          this.logger.debug(`Latest wakatime-cli version from GitHub: ${latestCliVersion}`);
+          this.options.setSetting('internal', 'cli_version_last_accessed', String(Math.round(Date.now() / 1000)), true);
+          callback(latestCliVersion);
+        } else {
+          if (response) {
+            this.logger.warn(`GitHub API Response ${response.statusCode}: ${error}`);
+          } else {
+            this.logger.warn(`GitHub API Response Error: ${error}`);
+          }
+          callback('');
+        }
+      });
+    } catch (e) {
+      this.logger.warnException(e);
+      callback('');
+    }
+  }
+
+  private installCli(callback: () => void): void {
+    this.logger.debug(`Downloading wakatime-cli from GitHub...`);
+    const url = this.cliDownloadUrl();
+    let zipFile = path.join(this.resourcesLocation, 'wakatime-cli' + this.randStr() + '.zip');
+    this.downloadFile(
+      url,
+      zipFile,
+      () => {
+        this.extractCli(zipFile, callback);
+      },
+      callback,
+    );
+  }
+
+  private isSymlink(file: string): boolean {
+    try {
+      return fs.lstatSync(file).isSymbolicLink();
+    } catch (_) {}
+    return false;
+  }
+
+  private extractCli(zipFile: string, callback: () => void): void {
+    this.logger.debug(`Extracting wakatime-cli into "${this.resourcesLocation}"...`);
+    this.backupCli();
+    this.unzip(zipFile, this.resourcesLocation, (unzipped) => {
+      if (!unzipped) {
+        this.restoreCli();
+      } else if (!Utils.isWindows()) {
+        this.removeCli();
+        const cli = this.getCliLocation();
+        try {
+          this.logger.debug('Chmod 755 wakatime-cli...');
+          fs.chmodSync(cli, 0o755);
+        } catch (e) {
+          this.logger.warnException(e);
+        }
+        const ext = Utils.isWindows() ? '.exe' : '';
+        const link = path.join(this.resourcesLocation, `wakatime-cli${ext}`);
+        if (!this.isSymlink(link)) {
+          try {
+            this.logger.debug(`Create symlink from wakatime-cli to ${cli}`);
+            fs.symlinkSync(cli, link);
+          } catch (e) {
+            this.logger.warnException(e);
+            try {
+              fs.copyFileSync(cli, link);
+              fs.chmodSync(link, 0o755);
+            } catch (e2) {
+              this.logger.warnException(e2);
+            }
+          }
+        }
+      }
+      callback();
+    });
+    this.logger.debug('Finished extracting wakatime-cli.');
+  }
+
+  private backupCli() {
+    if (fs.existsSync(this.getCliLocation())) {
+      fs.renameSync(this.getCliLocation(), `${this.getCliLocation()}.backup`);
+    }
+  }
+
+  private restoreCli() {
+    const backup = `${this.getCliLocation()}.backup`;
+    if (fs.existsSync(backup)) {
+      fs.renameSync(backup, this.getCliLocation());
+    }
+  }
+
+  private removeCli() {
+    const backup = `${this.getCliLocation()}.backup`;
+    if (fs.existsSync(backup)) {
+      fs.unlinkSync(backup);
+    }
+  }
+
+  private downloadFile(url: string, outputFile: string, callback: () => void, error: () => void): void {
+    const proxy = this.options.getSetting('settings', 'proxy');
+    const noSSLVerify = this.options.getSetting('settings', 'no_ssl_verify');
+    let options: request.CoreOptions & { url: string } = { url: url };
+    if (proxy) {
+      this.logger.debug(`Using Proxy: ${proxy}`);
+      options['proxy'] = proxy;
+    }
+    if (noSSLVerify === 'true') options['strictSSL'] = false;
+    try {
+      let r = request.get(options);
+      r.on('error', (e) => {
+        this.logger.warn(`Failed to download ${url}`);
+        this.logger.warn(e.toString());
+        error();
+      });
+      let out = fs.createWriteStream(outputFile);
+      r.pipe(out);
+      r.on('end', () => {
+        out.on('finish', () => {
+          callback();
+        });
+      });
+    } catch (e) {
+      this.logger.warnException(e);
+      callback();
+    }
+  }
+
+  private unzip(file: string, outputDir: string, callback: (unzipped: boolean) => void): void {
+    if (fs.existsSync(file)) {
+      try {
+        let zip = new adm_zip(file);
+        zip.extractAllTo(outputDir, true);
+        fs.unlinkSync(file);
+        callback(true);
+        return;
+      } catch (e) {
+        this.logger.warnException(e);
+      }
+      try {
+        fs.unlinkSync(file);
+      } catch (e2) {
+        this.logger.warnException(e2);
+      }
+      callback(false);
+    }
+  }
+
+  private legacyReleaseTag() {
+    const osname = this.osName() as osName;
+    const legacyOS = this.legacyOperatingSystems[osname];
+    if (!legacyOS) return;
+    const version = legacyOS.find((spec) => {
+      try {
+        return semver.lt(os.release(), spec.kernelLessThan);
+      } catch (e) {
+        return false;
+      }
+    });
+    return version?.tag;
+  }
+
+  private architecture(): string {
+    const arch = os.arch();
+    if (arch.indexOf('32') > -1) return '386';
+    if (arch.indexOf('x64') > -1) return 'amd64';
+    return arch;
+  }
+
+  private osName(): string {
+    let osname = os.platform() as string;
+    if (osname == 'win32') osname = 'windows';
+    return osname;
+  }
+
+  private cliDownloadUrl(): string {
+    const osname = this.osName();
+    const arch = this.architecture();
+
+    // Use legacy wakatime-cli release to support older operating systems
+    const tag = this.legacyReleaseTag();
+    if (tag) {
+      return `https://github.com/wakatime/wakatime-cli/releases/download/${tag}/wakatime-cli-${osname}-${arch}.zip`;
+    }
+
+    const validCombinations = [
+      'android-amd64',
+      'android-arm64',
+      'darwin-amd64',
+      'darwin-arm64',
+      'freebsd-386',
+      'freebsd-amd64',
+      'freebsd-arm',
+      'linux-386',
+      'linux-amd64',
+      'linux-arm',
+      'linux-arm64',
+      'netbsd-386',
+      'netbsd-amd64',
+      'netbsd-arm',
+      'openbsd-386',
+      'openbsd-amd64',
+      'openbsd-arm',
+      'openbsd-arm64',
+      'windows-386',
+      'windows-amd64',
+      'windows-arm64',
+    ];
+    if (!validCombinations.includes(`${osname}-${arch}`)) this.reportMissingPlatformSupport(osname, arch);
+
+    return `${this.githubDownloadUrl}/wakatime-cli-${osname}-${arch}.zip`;
+  }
+
+  private reportMissingPlatformSupport(osname: string, architecture: string): void {
+    const url = `https://api.wakatime.com/api/v1/cli-missing?osname=${osname}&architecture=${architecture}&plugin=vscode`;
+    const proxy = this.options.getSetting('settings', 'proxy');
+    const noSSLVerify = this.options.getSetting('settings', 'no_ssl_verify');
+    let options: request.CoreOptions & { url: string } = { url: url };
+    if (proxy) options['proxy'] = proxy;
+    if (noSSLVerify === 'true') options['strictSSL'] = false;
+    try {
+      request.get(options);
+    } catch (e) {}
+  }
+
+  private randStr(): string {
+    return (Math.random() + 1).toString(36).substring(7);
+  }
+}

package/src/index.ts

@@ -6,8 +6,11 @@ import os from 'os';
 import { execFileSync } from 'child_process';
 import { Options } from './options';
 import { VERSION } from './version';
+import { Dependencies } from './dependencies';
+import { Utils } from './utils';
+import { Logger, LogLevel } from './logger';
+
 const STATE_FILE = path.join(os.homedir(), '.wakatime', 'claude-code.json');
-const SESSION_LOG_FILE = path.join(os.homedir(), '.wakatime', 'claude-sessions.log');
 const WAKATIME_CLI = path.join(os.homedir(), '.wakatime', 'wakatime-cli');
 
 type State = {
@@ -21,14 +24,10 @@ type Input = {
   hook_event_name: string;
 };
 
-function timestamp() {
-  return Date.now() / 1000;
-}
-
 function shouldSendHeartbeat(): boolean {
   try {
-    const last = (JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State).lastHeartbeatAt ?? timestamp();
-    return timestamp() - last >= 60;
+    const last = (JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State).lastHeartbeatAt ?? Utils.timestamp();
+    return Utils.timestamp() - last >= 60;
   } catch {
     return true;
   }
@@ -47,21 +46,61 @@ function parseInput() {
   return undefined;
 }
 
-function logSessionData(inp: Input) {
+function getLastHeartbeat() {
   try {
-    fs.mkdirSync(path.dirname(SESSION_LOG_FILE), { recursive: true });
-    fs.appendFileSync(SESSION_LOG_FILE, JSON.stringify(inp, null, 2) + '\n\n');
-  } catch (err) {
-    // ignore
+    const stateData = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State;
+    return stateData.lastHeartbeatAt ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+function calculateLineChanges(transcriptPath: string): number {
+  try {
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+      return 0;
+    }
+
+    const content = fs.readFileSync(transcriptPath, 'utf-8');
+    const lines = content.split('\n');
+    let totalLineChanges = 0;
+
+    const lastHeartbeatAt = getLastHeartbeat();
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const logEntry = JSON.parse(line);
+
+          // Only count changes since last heartbeat
+          if (logEntry.timestamp && logEntry.toolUseResult?.structuredPatch) {
+            const entryTimestamp = new Date(logEntry.timestamp).getTime() / 1000;
+            if (entryTimestamp >= lastHeartbeatAt) {
+              const patches = logEntry.toolUseResult.structuredPatch;
+              for (const patch of patches) {
+                if (patch.newLines !== undefined && patch.oldLines !== undefined) {
+                  totalLineChanges += patch.newLines - patch.oldLines;
+                }
+              }
+            }
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    return totalLineChanges;
+  } catch {
+    return 0;
   }
 }
 
 function updateState() {
   fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
-  fs.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: timestamp() } as State, null, 2));
+  fs.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: Utils.timestamp() } as State, null, 2));
 }
 
-function sendHeartbeat(inp?: Input) {
+function sendHeartbeat(inp: Input | undefined, logger: Logger) {
   const projectFolder = inp?.cwd;
   try {
     const args: string[] = [
@@ -78,9 +117,18 @@ function sendHeartbeat(inp?: Input) {
       args.push('--project-folder');
       args.push(projectFolder);
     }
+
+    if (inp?.transcript_path) {
+      const lineChanges = calculateLineChanges(inp.transcript_path);
+      if (lineChanges !== 0) {
+        args.push('--ai-line-changes');
+        args.push(lineChanges.toString());
+      }
+    }
+
     execFileSync(WAKATIME_CLI, args);
   } catch (err: any) {
-    console.error('Failed to send WakaTime heartbeat:', err.message);
+    logger.errorException(err);
   }
 }
 
@@ -89,11 +137,23 @@ function main() {
 
   const options = new Options();
   const debug = options.getSetting('settings', 'debug');
+  const logger = new Logger(debug === 'true' ? LogLevel.DEBUG : LogLevel.INFO);
+  const deps = new Dependencies(options, logger);
 
-  if (inp && debug === 'true') logSessionData(inp);
+  if (inp) {
+    try {
+      logger.debug(JSON.stringify(inp, null, 2));
+    } catch (err) {
+      // ignore
+    }
+  }
+
+  if (inp?.hook_event_name === 'SessionStart') {
+    deps.checkAndInstallCli();
+  }
 
   if (shouldSendHeartbeat()) {
-    sendHeartbeat(inp);
+    sendHeartbeat(inp, logger);
     updateState();
   }
 }

package/src/logger.ts

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { Utils } from './utils';
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO,
+  WARN,
+  ERROR,
+}
+
+const LOG_FILE = path.join(os.homedir(), '.wakatime', 'claude-code.log');
+
+export class Logger {
+  private level: LogLevel = LogLevel.INFO;
+
+  constructor(level?: LogLevel) {
+    if (level) this.setLevel(level);
+  }
+
+  public getLevel(): LogLevel {
+    return this.level;
+  }
+
+  public setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  public log(level: LogLevel, msg: string): void {
+    if (level >= this.level) {
+      msg = `[${Utils.timestamp()}][${LogLevel[level]}] ${msg}\n`;
+      fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+      fs.appendFileSync(LOG_FILE, msg);
+    }
+  }
+
+  public debug(msg: string): void {
+    this.log(LogLevel.DEBUG, msg);
+  }
+
+  public debugException(msg: unknown): void {
+    if ((msg as Error).message !== undefined) {
+      this.log(LogLevel.DEBUG, (msg as Error).message);
+    } else {
+      this.log(LogLevel.DEBUG, (msg as Error).toString());
+    }
+  }
+
+  public info(msg: string): void {
+    this.log(LogLevel.INFO, msg);
+  }
+
+  public warn(msg: string): void {
+    this.log(LogLevel.WARN, msg);
+  }
+
+  public warnException(msg: unknown): void {
+    if ((msg as Error).message !== undefined) {
+      this.log(LogLevel.WARN, (msg as Error).message);
+    } else {
+      this.log(LogLevel.WARN, (msg as Error).toString());
+    }
+  }
+
+  public error(msg: string): void {
+    this.log(LogLevel.ERROR, msg);
+  }
+
+  public errorException(msg: unknown): void {
+    if ((msg as Error).message !== undefined) {
+      this.log(LogLevel.ERROR, (msg as Error).message);
+    } else {
+      this.log(LogLevel.ERROR, (msg as Error).toString());
+    }
+  }
+}

package/src/options.ts

@@ -13,8 +13,8 @@ export interface Setting {
 export class Options {
   private configFile: string;
   private internalConfigFile: string;
-  private resourcesLocation: string;
   private logFile: string;
+  public resourcesLocation: string;
 
   constructor() {
     const home = Utils.getHomeDirectory();

package/src/utils.ts

@@ -90,4 +90,8 @@ export class Utils {
     }
     return options;
   }
+
+  public static timestamp() {
+    return Date.now() / 1000;
+  }
 }