claude-code-wakatime 1.0.0 → 1.0.1

package/dist/index.js

@@ -8,7 +8,10 @@ const fs_1 = __importDefault(require("fs"));
 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 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;
@@ -22,19 +25,64 @@ function shouldSendHeartbeat() {
         return true;
     }
 }
+function parseInput() {
+    try {
+        const stdinData = fs_1.default.readFileSync(0, 'utf-8');
+        if (stdinData.trim()) {
+            const input = JSON.parse(stdinData);
+            return input;
+        }
+    }
+    catch (err) {
+        console.error(err);
+    }
+    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));
 }
-function sendHeartbeat() {
+function sendHeartbeat(inp) {
+    const projectFolder = inp?.cwd;
     try {
-        (0, child_process_1.execFileSync)(WAKATIME_CLI, ['--entity', 'claude code', '--entity-type', 'app', '--category', 'ai coding']);
+        const args = [
+            '--entity',
+            'claude code',
+            '--entity-type',
+            'app',
+            '--category',
+            'ai coding',
+            '--plugin',
+            `claude-code-wakatime/${VERSION}`,
+        ];
+        if (projectFolder) {
+            args.push('--project-folder');
+            args.push(projectFolder);
+        }
+        (0, child_process_1.execFileSync)(WAKATIME_CLI, args);
     }
     catch (err) {
         console.error('Failed to send WakaTime heartbeat:', err.message);
     }
 }
-if (shouldSendHeartbeat()) {
-    sendHeartbeat();
-    updateState();
+function main() {
+    const inp = parseInput();
+    const options = new options_1.Options();
+    const debug = options.getSetting('settings', 'debug');
+    if (inp && debug === 'true')
+        logSessionData(inp);
+    if (shouldSendHeartbeat()) {
+        sendHeartbeat(inp);
+        updateState();
+    }
 }
+main();

package/dist/options.js

@@ -0,0 +1,214 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Options = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+class Options {
+    constructor() {
+        const home = utils_1.Utils.getHomeDirectory();
+        const wakaFolder = path.join(home, '.wakatime');
+        try {
+            if (!fs.existsSync(wakaFolder)) {
+                fs.mkdirSync(wakaFolder, { recursive: true });
+            }
+            this.resourcesLocation = wakaFolder;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+        this.configFile = path.join(home, '.wakatime.cfg');
+        this.internalConfigFile = path.join(this.resourcesLocation, 'wakatime-internal.cfg');
+        this.logFile = path.join(this.resourcesLocation, 'wakatime.log');
+    }
+    getSetting(section, key, internal) {
+        const content = fs.readFileSync(this.getConfigFile(internal ?? false), 'utf-8');
+        if (content.trim()) {
+            let currentSection = '';
+            let lines = content.split('\n');
+            for (var i = 0; i < lines.length; i++) {
+                let line = lines[i];
+                if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+                    currentSection = line
+                        .trim()
+                        .substring(1, line.trim().length - 1)
+                        .toLowerCase();
+                }
+                else if (currentSection === section) {
+                    let parts = line.split('=');
+                    let currentKey = parts[0].trim();
+                    if (currentKey === key && parts.length > 1) {
+                        return this.removeNulls(parts[1].trim());
+                    }
+                }
+            }
+            return undefined;
+        }
+    }
+    setSetting(section, key, val, internal) {
+        const configFile = this.getConfigFile(internal);
+        fs.readFile(configFile, 'utf-8', (err, content) => {
+            // ignore errors because config file might not exist yet
+            if (err)
+                content = '';
+            let contents = [];
+            let currentSection = '';
+            let found = false;
+            let lines = content.split('\n');
+            for (var i = 0; i < lines.length; i++) {
+                let line = lines[i];
+                if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+                    if (currentSection === section && !found) {
+                        contents.push(this.removeNulls(key + ' = ' + val));
+                        found = true;
+                    }
+                    currentSection = line
+                        .trim()
+                        .substring(1, line.trim().length - 1)
+                        .toLowerCase();
+                    contents.push(this.removeNulls(line));
+                }
+                else if (currentSection === section) {
+                    let parts = line.split('=');
+                    let currentKey = parts[0].trim();
+                    if (currentKey === key) {
+                        if (!found) {
+                            contents.push(this.removeNulls(key + ' = ' + val));
+                            found = true;
+                        }
+                    }
+                    else {
+                        contents.push(this.removeNulls(line));
+                    }
+                }
+                else {
+                    contents.push(this.removeNulls(line));
+                }
+            }
+            if (!found) {
+                if (currentSection !== section) {
+                    contents.push('[' + section + ']');
+                }
+                contents.push(this.removeNulls(key + ' = ' + val));
+            }
+            fs.writeFile(configFile, contents.join('\n'), (err) => {
+                if (err)
+                    throw err;
+            });
+        });
+    }
+    setSettings(section, settings, internal) {
+        const configFile = this.getConfigFile(internal);
+        fs.readFile(configFile, 'utf-8', (err, content) => {
+            // ignore errors because config file might not exist yet
+            if (err)
+                content = '';
+            let contents = [];
+            let currentSection = '';
+            const found = {};
+            let lines = content.split('\n');
+            for (var i = 0; i < lines.length; i++) {
+                let line = lines[i];
+                if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+                    if (currentSection === section) {
+                        settings.forEach((setting) => {
+                            if (!found[setting.key]) {
+                                contents.push(this.removeNulls(setting.key + ' = ' + setting.value));
+                                found[setting.key] = true;
+                            }
+                        });
+                    }
+                    currentSection = line
+                        .trim()
+                        .substring(1, line.trim().length - 1)
+                        .toLowerCase();
+                    contents.push(this.removeNulls(line));
+                }
+                else if (currentSection === section) {
+                    let parts = line.split('=');
+                    let currentKey = parts[0].trim();
+                    let keepLineUnchanged = true;
+                    settings.forEach((setting) => {
+                        if (currentKey === setting.key) {
+                            keepLineUnchanged = false;
+                            if (!found[setting.key]) {
+                                contents.push(this.removeNulls(setting.key + ' = ' + setting.value));
+                                found[setting.key] = true;
+                            }
+                        }
+                    });
+                    if (keepLineUnchanged) {
+                        contents.push(this.removeNulls(line));
+                    }
+                }
+                else {
+                    contents.push(this.removeNulls(line));
+                }
+            }
+            settings.forEach((setting) => {
+                if (!found[setting.key]) {
+                    if (currentSection !== section) {
+                        contents.push('[' + section + ']');
+                        currentSection = section;
+                    }
+                    contents.push(this.removeNulls(setting.key + ' = ' + setting.value));
+                    found[setting.key] = true;
+                }
+            });
+            fs.writeFile(configFile, contents.join('\n'), (err) => {
+                if (err)
+                    throw err;
+            });
+        });
+    }
+    getConfigFile(internal) {
+        return internal ? this.internalConfigFile : this.configFile;
+    }
+    getLogFile() {
+        return this.logFile;
+    }
+    startsWith(outer, inner) {
+        return outer.slice(0, inner.length) === inner;
+    }
+    endsWith(outer, inner) {
+        return inner === '' || outer.slice(-inner.length) === inner;
+    }
+    removeNulls(s) {
+        return s.replace(/\0/g, '');
+    }
+}
+exports.Options = Options;

package/dist/utils.js

@@ -0,0 +1,126 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+class Utils {
+    static quote(str) {
+        if (str.includes(' '))
+            return `"${str.replace('"', '\\"')}"`;
+        return str;
+    }
+    static apiKeyInvalid(key) {
+        const err = 'Invalid api key... check https://wakatime.com/api-key for your key';
+        if (!key)
+            return err;
+        const re = new RegExp('^(waka_)?[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$', 'i');
+        if (!re.test(key))
+            return err;
+        return '';
+    }
+    static formatDate(date) {
+        let months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+        let ampm = 'AM';
+        let hour = date.getHours();
+        if (hour > 11) {
+            ampm = 'PM';
+            hour = hour - 12;
+        }
+        if (hour == 0) {
+            hour = 12;
+        }
+        let minute = date.getMinutes();
+        return `${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()} ${hour}:${minute < 10 ? `0${minute}` : minute} ${ampm}`;
+    }
+    static obfuscateKey(key) {
+        let newKey = '';
+        if (key) {
+            newKey = key;
+            if (key.length > 4)
+                newKey = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXX' + key.substring(key.length - 4);
+        }
+        return newKey;
+    }
+    static wrapArg(arg) {
+        if (arg.indexOf(' ') > -1)
+            return '"' + arg.replace(/"/g, '\\"') + '"';
+        return arg;
+    }
+    static formatArguments(binary, args) {
+        let clone = args.slice(0);
+        clone.unshift(this.wrapArg(binary));
+        let newCmds = [];
+        let lastCmd = '';
+        for (let i = 0; i < clone.length; i++) {
+            if (lastCmd == '--key')
+                newCmds.push(this.wrapArg(this.obfuscateKey(clone[i])));
+            else
+                newCmds.push(this.wrapArg(clone[i]));
+            lastCmd = clone[i];
+        }
+        return newCmds.join(' ');
+    }
+    static apiUrlToDashboardUrl(url) {
+        url = url
+            .replace('://api.', '://')
+            .replace('/api/v1', '')
+            .replace(/^api\./, '')
+            .replace('/api', '');
+        return url;
+    }
+    static isWindows() {
+        return os.platform() === 'win32';
+    }
+    static getHomeDirectory() {
+        let home = process.env.WAKATIME_HOME;
+        if (home && home.trim() && fs.existsSync(home.trim()))
+            return home.trim();
+        return process.env[this.isWindows() ? 'USERPROFILE' : 'HOME'] || process.cwd();
+    }
+    static buildOptions(stdin) {
+        const options = {
+            windowsHide: true,
+        };
+        if (stdin) {
+            options.stdio = ['pipe', 'pipe', 'pipe'];
+        }
+        if (!this.isWindows() && !process.env.WAKATIME_HOME && !process.env.HOME) {
+            options['env'] = { ...process.env, WAKATIME_HOME: this.getHomeDirectory() };
+        }
+        return options;
+    }
+}
+exports.Utils = Utils;

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "claude-code-wakatime",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "WakaTime plugin for Claude Code",
   "bin": {
     "claude-code-wakatime": "dist/index.js"
   },
   "scripts": {
     "postinstall": "node dist/install-hooks.js",
+    "prebuild": "node scripts/generate-version.js",
     "build": "tsc",
-    "watch": "tsc --watch",
+    "watch": "npm run prebuild && tsc --watch",
     "release:major": "npm version major && npm publish && git push && git push --tags",
     "release:minor": "npm version minor && npm publish && git push && git push --tags",
     "release:patch": "npm version patch && npm publish && git push && git push --tags"

package/scripts/generate-version.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const packagePath = path.join(__dirname, '..', 'package.json');
+const versionFilePath = path.join(__dirname, '..', 'src', 'version.ts');
+
+try {
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  const version = packageJson.version;
+  
+  const versionFileContent = `// This file is auto-generated during build. Do not edit manually.
+export const VERSION = '${version}';
+`;
+  
+  fs.writeFileSync(versionFilePath, versionFileContent);
+  console.log(`Generated version.ts with version ${version}`);
+} catch (error) {
+  console.error('Error generating version file:', error);
+  process.exit(1);
+}

package/src/index.ts

@@ -4,14 +4,23 @@ 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';
 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 = {
   lastHeartbeatAt?: number;
 };
 
+type Input = {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+};
+
 function timestamp() {
   return Date.now() / 1000;
 }
@@ -25,20 +34,68 @@ function shouldSendHeartbeat(): boolean {
   }
 }
 
+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 logSessionData(inp: Input) {
+  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
+  }
+}
+
 function updateState() {
   fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
   fs.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: timestamp() } as State, null, 2));
 }
 
-function sendHeartbeat() {
+function sendHeartbeat(inp?: Input) {
+  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);
+    }
+    execFileSync(WAKATIME_CLI, args);
   } catch (err: any) {
     console.error('Failed to send WakaTime heartbeat:', err.message);
   }
 }
 
-if (shouldSendHeartbeat()) {
-  sendHeartbeat();
-  updateState();
+function main() {
+  const inp = parseInput();
+
+  const options = new Options();
+  const debug = options.getSetting('settings', 'debug');
+
+  if (inp && debug === 'true') logSessionData(inp);
+
+  if (shouldSendHeartbeat()) {
+    sendHeartbeat(inp);
+    updateState();
+  }
 }
+
+main();

package/src/options.ts

@@ -0,0 +1,198 @@
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { Utils } from './utils';
+
+export interface Setting {
+  key: string;
+  value: string;
+  error?: string;
+}
+
+export class Options {
+  private configFile: string;
+  private internalConfigFile: string;
+  private resourcesLocation: string;
+  private logFile: string;
+
+  constructor() {
+    const home = Utils.getHomeDirectory();
+    const wakaFolder = path.join(home, '.wakatime');
+    try {
+      if (!fs.existsSync(wakaFolder)) {
+        fs.mkdirSync(wakaFolder, { recursive: true });
+      }
+      this.resourcesLocation = wakaFolder;
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+
+    this.configFile = path.join(home, '.wakatime.cfg');
+    this.internalConfigFile = path.join(this.resourcesLocation, 'wakatime-internal.cfg');
+    this.logFile = path.join(this.resourcesLocation, 'wakatime.log');
+  }
+
+  public getSetting(section: string, key: string, internal?: boolean): string | undefined {
+    const content = fs.readFileSync(this.getConfigFile(internal ?? false), 'utf-8');
+    if (content.trim()) {
+      let currentSection = '';
+      let lines = content.split('\n');
+      for (var i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+          currentSection = line
+            .trim()
+            .substring(1, line.trim().length - 1)
+            .toLowerCase();
+        } else if (currentSection === section) {
+          let parts = line.split('=');
+          let currentKey = parts[0].trim();
+          if (currentKey === key && parts.length > 1) {
+            return this.removeNulls(parts[1].trim());
+          }
+        }
+      }
+
+      return undefined;
+    }
+  }
+
+  public setSetting(section: string, key: string, val: string, internal: boolean): void {
+    const configFile = this.getConfigFile(internal);
+    fs.readFile(configFile, 'utf-8', (err: NodeJS.ErrnoException | null, content: string) => {
+      // ignore errors because config file might not exist yet
+      if (err) content = '';
+
+      let contents: string[] = [];
+      let currentSection = '';
+
+      let found = false;
+      let lines = content.split('\n');
+      for (var i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+          if (currentSection === section && !found) {
+            contents.push(this.removeNulls(key + ' = ' + val));
+            found = true;
+          }
+          currentSection = line
+            .trim()
+            .substring(1, line.trim().length - 1)
+            .toLowerCase();
+          contents.push(this.removeNulls(line));
+        } else if (currentSection === section) {
+          let parts = line.split('=');
+          let currentKey = parts[0].trim();
+          if (currentKey === key) {
+            if (!found) {
+              contents.push(this.removeNulls(key + ' = ' + val));
+              found = true;
+            }
+          } else {
+            contents.push(this.removeNulls(line));
+          }
+        } else {
+          contents.push(this.removeNulls(line));
+        }
+      }
+
+      if (!found) {
+        if (currentSection !== section) {
+          contents.push('[' + section + ']');
+        }
+        contents.push(this.removeNulls(key + ' = ' + val));
+      }
+
+      fs.writeFile(configFile as string, contents.join('\n'), (err) => {
+        if (err) throw err;
+      });
+    });
+  }
+
+  public setSettings(section: string, settings: Setting[], internal: boolean): void {
+    const configFile = this.getConfigFile(internal);
+    fs.readFile(configFile, 'utf-8', (err: NodeJS.ErrnoException | null, content: string) => {
+      // ignore errors because config file might not exist yet
+      if (err) content = '';
+
+      let contents: string[] = [];
+      let currentSection = '';
+
+      const found: Record<string, boolean> = {};
+      let lines = content.split('\n');
+      for (var i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+          if (currentSection === section) {
+            settings.forEach((setting) => {
+              if (!found[setting.key]) {
+                contents.push(this.removeNulls(setting.key + ' = ' + setting.value));
+                found[setting.key] = true;
+              }
+            });
+          }
+          currentSection = line
+            .trim()
+            .substring(1, line.trim().length - 1)
+            .toLowerCase();
+          contents.push(this.removeNulls(line));
+        } else if (currentSection === section) {
+          let parts = line.split('=');
+          let currentKey = parts[0].trim();
+          let keepLineUnchanged = true;
+          settings.forEach((setting) => {
+            if (currentKey === setting.key) {
+              keepLineUnchanged = false;
+              if (!found[setting.key]) {
+                contents.push(this.removeNulls(setting.key + ' = ' + setting.value));
+                found[setting.key] = true;
+              }
+            }
+          });
+          if (keepLineUnchanged) {
+            contents.push(this.removeNulls(line));
+          }
+        } else {
+          contents.push(this.removeNulls(line));
+        }
+      }
+
+      settings.forEach((setting) => {
+        if (!found[setting.key]) {
+          if (currentSection !== section) {
+            contents.push('[' + section + ']');
+            currentSection = section;
+          }
+          contents.push(this.removeNulls(setting.key + ' = ' + setting.value));
+          found[setting.key] = true;
+        }
+      });
+
+      fs.writeFile(configFile as string, contents.join('\n'), (err) => {
+        if (err) throw err;
+      });
+    });
+  }
+
+  public getConfigFile(internal: boolean): string {
+    return internal ? this.internalConfigFile : this.configFile;
+  }
+
+  public getLogFile(): string {
+    return this.logFile;
+  }
+
+  private startsWith(outer: string, inner: string): boolean {
+    return outer.slice(0, inner.length) === inner;
+  }
+
+  private endsWith(outer: string, inner: string): boolean {
+    return inner === '' || outer.slice(-inner.length) === inner;
+  }
+
+  private removeNulls(s: string): string {
+    return s.replace(/\0/g, '');
+  }
+}

package/src/utils.ts

@@ -0,0 +1,93 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as child_process from 'child_process';
+import { StdioOptions } from 'child_process';
+
+export class Utils {
+  public static quote(str: string): string {
+    if (str.includes(' ')) return `"${str.replace('"', '\\"')}"`;
+    return str;
+  }
+
+  public static apiKeyInvalid(key?: string): string {
+    const err = 'Invalid api key... check https://wakatime.com/api-key for your key';
+    if (!key) return err;
+    const re = new RegExp('^(waka_)?[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$', 'i');
+    if (!re.test(key)) return err;
+    return '';
+  }
+
+  public static formatDate(date: Date): String {
+    let months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    let ampm = 'AM';
+    let hour = date.getHours();
+    if (hour > 11) {
+      ampm = 'PM';
+      hour = hour - 12;
+    }
+    if (hour == 0) {
+      hour = 12;
+    }
+    let minute = date.getMinutes();
+    return `${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()} ${hour}:${minute < 10 ? `0${minute}` : minute} ${ampm}`;
+  }
+
+  public static obfuscateKey(key: string): string {
+    let newKey = '';
+    if (key) {
+      newKey = key;
+      if (key.length > 4) newKey = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXX' + key.substring(key.length - 4);
+    }
+    return newKey;
+  }
+
+  public static wrapArg(arg: string): string {
+    if (arg.indexOf(' ') > -1) return '"' + arg.replace(/"/g, '\\"') + '"';
+    return arg;
+  }
+
+  public static formatArguments(binary: string, args: string[]): string {
+    let clone = args.slice(0);
+    clone.unshift(this.wrapArg(binary));
+    let newCmds: string[] = [];
+    let lastCmd = '';
+    for (let i = 0; i < clone.length; i++) {
+      if (lastCmd == '--key') newCmds.push(this.wrapArg(this.obfuscateKey(clone[i])));
+      else newCmds.push(this.wrapArg(clone[i]));
+      lastCmd = clone[i];
+    }
+    return newCmds.join(' ');
+  }
+
+  public static apiUrlToDashboardUrl(url: string): string {
+    url = url
+      .replace('://api.', '://')
+      .replace('/api/v1', '')
+      .replace(/^api\./, '')
+      .replace('/api', '');
+    return url;
+  }
+
+  public static isWindows(): boolean {
+    return os.platform() === 'win32';
+  }
+
+  public static getHomeDirectory(): string {
+    let home = process.env.WAKATIME_HOME;
+    if (home && home.trim() && fs.existsSync(home.trim())) return home.trim();
+    return process.env[this.isWindows() ? 'USERPROFILE' : 'HOME'] || process.cwd();
+  }
+
+  public static buildOptions(stdin?: boolean): Object {
+    const options: child_process.ExecFileOptions = {
+      windowsHide: true,
+    };
+    if (stdin) {
+      (options as any).stdio = ['pipe', 'pipe', 'pipe'] as StdioOptions;
+    }
+    if (!this.isWindows() && !process.env.WAKATIME_HOME && !process.env.HOME) {
+      options['env'] = { ...process.env, WAKATIME_HOME: this.getHomeDirectory() };
+    }
+    return options;
+  }
+}