claude-code-wakatime 1.0.0 → 2.0.0

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

@@ -4,6 +4,11 @@ import fs from 'fs';
 import path from 'path';
 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 WAKATIME_CLI = path.join(os.homedir(), '.wakatime', 'wakatime-cli');
@@ -12,33 +17,145 @@ type State = {
   lastHeartbeatAt?: number;
 };
 
-function timestamp() {
-  return Date.now() / 1000;
-}
+type Input = {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+};
 
 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;
   }
 }
 
+function parseInput() {
+  try {
+    const stdinData = fs.readFileSync(0, 'utf-8');
+    if (stdinData.trim()) {
+      const input: Input = JSON.parse(stdinData);
+      return input;
+    }
+  } catch (err) {
+    console.error(err);
+  }
+  return undefined;
+}
+
+function getLastHeartbeat() {
+  try {
+    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() {
+function sendHeartbeat(inp: Input | undefined, logger: Logger) {
+  const projectFolder = inp?.cwd;
   try {
-    execFileSync(WAKATIME_CLI, ['--entity', 'claude code', '--entity-type', 'app', '--category', 'ai coding']);
+    const args: string[] = [
+      '--entity',
+      'claude code',
+      '--entity-type',
+      'app',
+      '--category',
+      'ai coding',
+      '--plugin',
+      `claude-code-wakatime/${VERSION}`,
+    ];
+    if (projectFolder) {
+      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);
   }
 }
 
-if (shouldSendHeartbeat()) {
-  sendHeartbeat();
-  updateState();
+function main() {
+  const inp = parseInput();
+
+  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) {
+    try {
+      logger.debug(JSON.stringify(inp, null, 2));
+    } catch (err) {
+      // ignore
+    }
+  }
+
+  if (inp?.hook_event_name === 'SessionStart') {
+    deps.checkAndInstallCli();
+  }
+
+  if (shouldSendHeartbeat()) {
+    sendHeartbeat(inp, logger);
+    updateState();
+  }
 }
+
+main();

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());
+    }
+  }
+}