ctxline-claude 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mithun Wijayasiri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# Claude Code Enhanced Statusline
+
+![preview](preview.png)
+
+A real-time statusline for [Claude Code](https://github.com/anthropics/claude-code) that shows your current directory, model, context window usage, and session token limits at a glance. The usage bar pulls directly from Anthropic's API, the same data you get from `/usage`, so it's always accurate. One script, zero config. Auto-detects subscription vs API key.
+
+## Why This Statusline
+
+Two metrics have the biggest impact on a Claude Code session: **context window usage** and **remaining session usage**. Model output quality tends to degrade as the context window fills (often called "context rot"), so keeping an eye on it helps you compact or reset at the right time. Session usage tells you how much of your current limit remains, so you can plan work before hitting a reset. This statusline surfaces both at a glance, letting you stay focused on the task rather than guessing where you stand.
+
+## Requirements
+
+- [Claude Code](https://github.com/anthropics/claude-code) installed
+- Node.js (comes with Claude Code)
+- Authenticated Claude account (for usage tracking on subscription plans)
+
+## Installation
+
+### Quick Install (Recommended)
+
+```bash
+npx ctxline-claude
+```
+
+Or with bun:
+
+```bash
+bunx ctxline-claude
+```
+
+Restart Claude Code or start a new session.
+
+### Clone & Install
+
+```bash
+git clone https://github.com/MithunWijayasiri/claudecode-statusline.git
+cd claudecode-statusline
+
+# macOS / Linux
+./install.sh
+
+# Windows (PowerShell)
+./install.ps1
+```
+
+### Manual Install
+
+1. **Download the script:**
+
+   ```bash
+   curl -o ~/.claude/hooks/statusline.js https://raw.githubusercontent.com/MithunWijayasiri/claudecode-statusline/main/statusline.js
+   ```
+
+2. **Make it executable:**
+
+   ```bash
+   chmod +x ~/.claude/hooks/statusline.js
+   ```
+
+3. **Update Claude Code settings:**
+
+   Edit `~/.claude/settings.json` and add/modify the `statusLine` section:
+
+   ```json
+   {
+     "statusLine": {
+       "type": "command",
+       "command": "node ~/.claude/hooks/statusline.js"
+     }
+   }
+   ```
+
+4. **Restart Claude Code** or start a new session.
+
+## Uninstall
+
+### Quick Uninstall (Recommended)
+
+```bash
+npx ctxline-claude uninstall
+```
+
+This removes the `statusLine` entry from `~/.claude/settings.json` (backing the file up first, and leaving any other settings intact), deletes `~/.claude/hooks/statusline.js`, and clears the cached usage data. Restart Claude Code afterward. If `settings.json` points to a different statusline, it's left untouched.
+
+### Manual Uninstall
+
+The installer only does two things: it copies `statusline.js` into `~/.claude/hooks/` and adds a `statusLine` block to `~/.claude/settings.json`. To fully remove it, undo both.
+
+1. **Remove the `statusLine` block from `~/.claude/settings.json`.**
+
+   Open the file and delete this section:
+
+   ```json
+   "statusLine": {
+     "type": "command",
+     "command": "node ~/.claude/hooks/statusline.js"
+   }
+   ```
+
+   (The installer saved a timestamped backup, e.g. `settings.json.backup.<number>`, if you'd rather restore that.)
+
+2. **Delete the script (and optional cache):**
+
+   ```bash
+   # macOS / Linux
+   rm ~/.claude/hooks/statusline.js
+   rm -f ~/.claude/cache/usage-cache.json   # optional: clears cached usage data
+   ```
+
+   ```powershell
+   # Windows (PowerShell)
+   Remove-Item "$env:USERPROFILE\.claude\hooks\statusline.js"
+   Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction SilentlyContinue
+   ```
+
+3. **Restart Claude Code** or start a new session. The statusline is gone.
+
+## Features
+
+- **Context Usage**: Visual bar showing token usage (green → yellow → orange → red)
+- **API Usage**: Real-time 5-hour session limit tracking with countdown timer (subscription users)
+- **Current Directory**: Shows your working directory
+- **Model Name**: Displays which Claude model you're using (Opus, Sonnet, Haiku)
+- **Auto-Detection**: Detects API key vs subscription and adapts automatically
+- **Adaptive Performance**: Fast after first prompt (1.2s vs 1.5s)
+- **Smart Caching**: Shares usage data across sessions, fallback on API timeout
+
+**Color Coding:**
+
+- 🟢 Green: < 50% usage
+- 🟡 Yellow: 50-75% usage
+- 🟠 Orange: 75-90% usage
+- 🔴 Red (blinking): > 90% usage
+
+## How It Works
+
+### Adaptive Timing
+
+- **First prompt**: Uses 1500ms timeout (cold start, OAuth validation)
+- **Subsequent prompts**: Uses 1200ms timeout (faster, connection reused)
+- **Result**: Smooth experience after initial setup
+
+### Caching System
+
+- Usage data is cached in `~/.claude/cache/usage-cache.json`, shared across all sessions
+- **Cache-first**: within 30 seconds the cache is used directly and the API call is skipped (faster renders, fewer calls)
+- **Stale fallback**: if a live API call fails or times out, the last known usage (up to 10 minutes old) is shown instead of disappearing
+- The reset countdown is recomputed on every render, so it keeps ticking even when shown from cache
+
+### API Usage
+
+- Fetches from `https://api.anthropic.com/api/oauth/usage`
+- Tracks 5-hour session limits
+- Shows percentage used + time until reset
+- Fails gracefully (no statusline breakage)
+
+## License
+
+MIT
+
+## Credits
+
+Originally created by [@TahaSabir0](https://github.com/TahaSabir0).
+
+Built for the [Claude Code](https://github.com/anthropics/claude-code) community.
+
+---

package/bin/install.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const claudeDir = path.join(os.homedir(), '.claude');
+const hooksDir = path.join(claudeDir, 'hooks');
+const settingsFile = path.join(claudeDir, 'settings.json');
+const scriptDest = path.join(hooksDir, 'statusline.js');
+const scriptSrc = path.join(__dirname, '..', 'statusline.js');
+
+const green = '\x1b[32m';
+const red = '\x1b[31m';
+const yellow = '\x1b[33m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+
+// Uninstall mode: `npx ctxline-claude uninstall` (additive — plain install is unchanged)
+const mode = (process.argv[2] || '').toLowerCase();
+if (mode === 'uninstall' || mode === 'remove') {
+  runUninstall();
+  process.exit(0);
+}
+
+console.log(`${cyan}======================================${reset}`);
+console.log(`${cyan}  Claude Code Statusline Installer${reset}`);
+console.log(`${cyan}======================================${reset}\n`);
+
+// Check Claude Code is installed
+if (!fs.existsSync(claudeDir)) {
+  console.log(`${red}Error: Claude Code not found!${reset}`);
+  console.log('Please install Claude Code first: https://github.com/anthropics/claude-code');
+  process.exit(1);
+}
+
+// Create hooks directory
+if (!fs.existsSync(hooksDir)) {
+  fs.mkdirSync(hooksDir, { recursive: true });
+}
+
+// Copy statusline script
+console.log(`${yellow}Installing statusline...${reset}`);
+fs.copyFileSync(scriptSrc, scriptDest);
+fs.chmodSync(scriptDest, 0o755);
+console.log(`${green}✓ Installed statusline.js${reset}`);
+
+// Update settings.json
+console.log(`${yellow}Updating settings...${reset}`);
+
+let settings = {};
+if (fs.existsSync(settingsFile)) {
+  // Backup existing settings
+  const backup = `${settingsFile}.backup.${Date.now()}`;
+  fs.copyFileSync(settingsFile, backup);
+  console.log(`${green}✓ Backed up existing settings${reset}`);
+
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+  } catch (e) {
+    settings = {};
+  }
+}
+
+settings.statusLine = {
+  type: 'command',
+  command: `node ${scriptDest.replace(/\\/g, '/')}`
+};
+
+fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+console.log(`${green}✓ Updated settings.json${reset}`);
+
+console.log(`\n${green}======================================${reset}`);
+console.log(`${green}  Installation Complete!${reset}`);
+console.log(`${green}======================================${reset}`);
+console.log('\nRestart Claude Code or start a new session.');
+console.log('The statusline will auto-detect your setup (subscription vs API key).\n');
+
+function runUninstall() {
+  console.log(`${cyan}======================================${reset}`);
+  console.log(`${cyan}  Claude Code Statusline Uninstaller${reset}`);
+  console.log(`${cyan}======================================${reset}\n`);
+
+  if (!fs.existsSync(claudeDir)) {
+    console.log(`${yellow}Nothing to remove — ~/.claude was not found.${reset}\n`);
+    return;
+  }
+
+  // 1. Remove our statusLine entry from settings.json (preserving everything else)
+  if (fs.existsSync(settingsFile)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+      const command = ((settings.statusLine && settings.statusLine.command) || '').replace(/\\/g, '/');
+      // Match our hook path only (covers absolute + manual `~` installs), not any statusline.js.
+      const isOurs = command.includes('/.claude/hooks/statusline.js');
+      if (settings.statusLine && isOurs) {
+        const backup = `${settingsFile}.backup.${Date.now()}`;
+        fs.copyFileSync(settingsFile, backup);
+        delete settings.statusLine;
+        fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+        console.log(`${green}✓ Removed statusLine from settings.json (backup: ${path.basename(backup)})${reset}`);
+      } else if (settings.statusLine) {
+        console.log(`${yellow}! settings.json has a different statusLine — leaving it untouched.${reset}`);
+      } else {
+        console.log(`${green}✓ No statusLine entry in settings.json${reset}`);
+      }
+    } catch (e) {
+      console.log(`${red}✗ Could not parse settings.json — remove the "statusLine" block manually.${reset}`);
+    }
+  }
+
+  // 2. Delete the hook script
+  if (fs.existsSync(scriptDest)) {
+    try {
+      fs.unlinkSync(scriptDest);
+      console.log(`${green}✓ Deleted ${scriptDest}${reset}`);
+    } catch (e) {
+      console.log(`${red}✗ Could not delete ${scriptDest}: ${e.message}${reset}`);
+      console.log(`${yellow}  Remove it manually.${reset}`);
+    }
+  } else {
+    console.log(`${green}✓ No statusline.js found in hooks${reset}`);
+  }
+
+  // 3. Clear cached usage data (best-effort)
+  const cacheFile = path.join(claudeDir, 'cache', 'usage-cache.json');
+  if (fs.existsSync(cacheFile)) {
+    try {
+      fs.unlinkSync(cacheFile);
+      console.log(`${green}✓ Cleared usage cache${reset}`);
+    } catch (e) {}
+  }
+
+  console.log(`\n${green}Uninstall complete.${reset} Restart Claude Code or start a new session.\n`);
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ctxline-claude",
+  "version": "0.0.1",
+  "description": "A customizable statusline for Claude Code that tracks context usage and session limits",
+  "bin": {
+    "ctxline-claude": "bin/install.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "preview": "node scripts/preview.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "statusline.js",
+    "README.md",
+    "LICENSE",
+    "preview.png"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "vibe-coding",
+    "context-window"
+  ],
+  "author": "Mithun Wijayasiri",
+  "license": "MIT",
+  "homepage": "https://github.com/MithunWijayasiri/claudecode-statusline#readme",
+  "bugs": {
+    "url": "https://github.com/MithunWijayasiri/claudecode-statusline/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MithunWijayasiri/claudecode-statusline.git"
+  }
+}

package/statusline.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+// Claude Code Enhanced Statusline
+// Shows: directory | model | context usage | API usage (5-hour limit) | current task
+// Auto-detects API key vs subscription usage
+// https://github.com/MithunWijayasiri/claudecode-statusline
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const { execSync } = require('child_process');
+
+const IS_API_KEY = !!process.env.ANTHROPIC_API_KEY;
+
+// Cache configuration
+const CACHE_DIR = path.join(os.homedir(), '.claude', 'cache');
+const USAGE_CACHE_FILE = path.join(CACHE_DIR, 'usage-cache.json');
+// Fresh: trust the cache and skip the API call entirely (fewer calls, faster render).
+const FRESH_TTL_MS = 30000;            // 30 seconds
+// Stale: used only as a fallback when a live API call fails, so the usage bar stays
+// visible through transient timeouts/errors instead of disappearing.
+const STALE_TTL_MS = 10 * 60 * 1000;   // 10 minutes
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  orange: '\x1b[38;5;208m',
+  red: '\x1b[31m',
+  blink: '\x1b[5m'
+};
+
+function getUsageColor(percentage) {
+  if (percentage < 50) return colors.green;
+  if (percentage < 75) return colors.yellow;
+  if (percentage < 90) return colors.orange;
+  return colors.red;
+}
+
+function getContextBar(remaining) {
+  const effectiveRemaining = remaining ?? 100;
+  const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
+
+  const filled = Math.floor(used / 10);
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+
+  let coloredBar;
+  if (used < 50) {
+    coloredBar = `${colors.green}${bar} ${used}%${colors.reset}`;
+  } else if (used < 65) {
+    coloredBar = `${colors.yellow}${bar} ${used}%${colors.reset}`;
+  } else if (used < 80) {
+    coloredBar = `${colors.orange}${bar} ${used}%${colors.reset}`;
+  } else {
+    coloredBar = `${colors.blink}${colors.red}\u{1F480} ${bar} ${used}%${colors.reset}`;
+  }
+
+  return coloredBar;
+}
+
+// Render the usage bar from raw data. Called on every read (live or cached) so the
+// reset countdown is always recomputed from resetsAt rather than frozen at fetch time.
+function buildUsageBar(percentage, resetsAt) {
+  let timeStr = '';
+  if (resetsAt) {
+    const diffMins = Math.max(0, Math.floor((new Date(resetsAt) - new Date()) / 60000));
+    const hours = Math.floor(diffMins / 60);
+    const mins = diffMins % 60;
+    timeStr = hours > 0 ? `${hours}h${mins}m` : `${mins}m`;
+  }
+
+  const barWidth = 10;
+  const filledWidth = Math.max(0, Math.min(barWidth, Math.round((percentage / 100) * barWidth)));
+  const filled = '█'.repeat(filledWidth);
+  const empty = '░'.repeat(barWidth - filledWidth);
+  const color = getUsageColor(percentage);
+
+  return `${color}${filled}${empty} ${percentage}%${colors.reset}${colors.dim} (${timeStr})${colors.reset}`;
+}
+
+// Read the raw cached usage data ({ timestamp, data: { percentage, resetsAt } }).
+// Returns { age, data } or null. Age-vs-TTL decisions are made by the caller.
+function readCachedUsage() {
+  try {
+    if (!fs.existsSync(USAGE_CACHE_FILE)) return null;
+
+    const cache = JSON.parse(fs.readFileSync(USAGE_CACHE_FILE, 'utf8'));
+    if (!cache || !Number.isFinite(cache.timestamp) || cache.timestamp <= 0) return null;
+
+    // Validate data (also rejects the legacy string-cache format from older versions),
+    // so callers never receive undefined/NaN percentage or an unparseable resetsAt.
+    const data = cache.data;
+    if (!data || typeof data !== 'object') return null;
+    if (!Number.isFinite(data.percentage) || data.percentage < 0 || data.percentage > 100) return null;
+    if (data.resetsAt != null && Number.isNaN(new Date(data.resetsAt).getTime())) return null;
+
+    return { age: Date.now() - cache.timestamp, data };
+  } catch (e) {
+    return null;
+  }
+}
+
+// Write usage data to cache (shared across all sessions)
+function setCachedUsage(data) {
+  try {
+    if (!fs.existsSync(CACHE_DIR)) {
+      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+
+    const cache = {
+      timestamp: Date.now(),
+      data: data
+    };
+
+    fs.writeFileSync(USAGE_CACHE_FILE, JSON.stringify(cache), 'utf8');
+  } catch (e) {
+    // Silently fail
+  }
+}
+
+function getCredentials() {
+  // Try file first (legacy / Linux / Windows)
+  const credsPath = path.join(os.homedir(), '.claude', '.credentials.json');
+  if (fs.existsSync(credsPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(credsPath, 'utf8'));
+    } catch (e) {}
+  }
+
+  // Fallback: macOS keychain
+  if (os.platform() === 'darwin') {
+    try {
+      const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null', { encoding: 'utf8', timeout: 1000 });
+      return JSON.parse(raw.trim());
+    } catch (e) {}
+  }
+
+  return null;
+}
+
+function getApiUsage(callback) {
+  try {
+    // Read credentials (file or macOS keychain)
+    const creds = getCredentials();
+    if (!creds) {
+      return callback(null);
+    }
+
+    const accessToken = creds.claudeAiOauth?.accessToken;
+
+    if (!accessToken) {
+      return callback(null);
+    }
+
+    // Adaptive timeout: if cache exists, be faster (1200ms); if not, be patient (1500ms)
+    // API typically takes ~850ms, so 1200ms gives reasonable headroom
+    const hasCache = fs.existsSync(USAGE_CACHE_FILE);
+    const timeout = hasCache ? 1200 : 1500;
+
+    // Make API call with adaptive timeout
+    const req = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/api/oauth/usage',
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+        'anthropic-beta': 'oauth-2025-04-20'
+      },
+      timeout: timeout
+    }, (res) => {
+      let data = '';
+
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const usage = JSON.parse(data);
+
+          // Get 5-hour session usage
+          if (usage.five_hour) {
+            const percentage = Math.round(usage.five_hour.utilization);
+            const resetsAt = usage.five_hour.resets_at || null;
+
+            // Cache the raw data (shared across sessions); render the bar from it.
+            setCachedUsage({ percentage, resetsAt });
+            callback(buildUsageBar(percentage, resetsAt));
+          } else {
+            callback(null);
+          }
+        } catch (e) {
+          callback(null);
+        }
+      });
+    });
+
+    req.on('error', () => callback(null));
+    req.on('timeout', () => {
+      req.destroy();
+      callback(null);
+    });
+
+    req.end();
+  } catch (e) {
+    callback(null);
+  }
+}
+
+// Get usage, cache-first.
+function getUsageWithCache(callback) {
+  const cached = readCachedUsage();
+
+  // Cache is fresh -> render it and skip the API entirely (fewer calls, faster).
+  if (cached && cached.age < FRESH_TTL_MS) {
+    return callback(buildUsageBar(cached.data.percentage, cached.data.resetsAt));
+  }
+
+  // Cache is stale or missing -> refresh from the API.
+  getApiUsage((freshBar) => {
+    if (freshBar) {
+      callback(freshBar);
+    } else if (cached && cached.age < STALE_TTL_MS) {
+      // API failed/timed out, but recent cache exists -> show it instead of nothing.
+      callback(buildUsageBar(cached.data.percentage, cached.data.resetsAt));
+    } else {
+      callback(null);
+    }
+  });
+}
+
+function getCurrentTask(sessionId) {
+  if (!sessionId) return '';
+
+  const homeDir = os.homedir();
+  const todosDir = path.join(homeDir, '.claude', 'todos');
+
+  if (!fs.existsSync(todosDir)) return '';
+
+  try {
+    const files = fs.readdirSync(todosDir)
+      .filter(f => f.startsWith(sessionId) && f.includes('-agent-') && f.endsWith('.json'))
+      .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+      .sort((a, b) => b.mtime - a.mtime);
+
+    if (files.length > 0) {
+      const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+      const inProgress = todos.find(t => t.status === 'in_progress');
+      if (inProgress) return inProgress.activeForm || '';
+    }
+  } catch (e) {}
+
+  return '';
+}
+
+// Main
+function outputStatus(data, usageBar) {
+  try {
+    const model = data?.model?.display_name || 'Claude';
+    const dir = data?.workspace?.current_dir || process.cwd();
+    const dirname = path.basename(dir);
+    const sessionId = data?.session_id || '';
+    const remaining = data?.context_window?.remaining_percentage;
+
+    const contextBar = getContextBar(remaining);
+    const task = getCurrentTask(sessionId);
+    const parts = [];
+    parts.push(dirname);
+    parts.push(model);
+    parts.push(`context: ${contextBar}`);
+
+    if (usageBar) {
+      parts.push(`usage: ${usageBar}`);
+    }
+
+    if (task) parts.push(`${colors.dim}${task}${colors.reset}`);
+    process.stdout.write(parts.join(' \u2502 '));
+  } catch (e) {
+    process.stdout.write('Status unavailable');
+  }
+}
+
+function outputFallback(usageBar) {
+  const contextBar = getContextBar(undefined);
+  const parts = ['~', 'Claude', `context: ${contextBar}`];
+  if (usageBar) parts.push(`usage: ${usageBar}`);
+  process.stdout.write(parts.join(' \u2502 '));
+}
+
+// Wrapper that skips usage fetch for API key users
+function getUsage(callback) {
+  if (IS_API_KEY) {
+    callback(null);
+  } else {
+    getUsageWithCache(callback);
+  }
+}
+
+// Process with timeout
+if (process.stdin.isTTY) {
+  getUsage((usageBar) => {
+    outputFallback(usageBar);
+    process.exit(0);
+  });
+} else {
+  let input = '';
+  let timeoutReached = false;
+
+  const overallTimeout = IS_API_KEY ? 500 : (fs.existsSync(USAGE_CACHE_FILE) ? 1300 : 1600);
+
+  const timeout = setTimeout(() => {
+    timeoutReached = true;
+    getUsage((usageBar) => {
+      if (input.length > 0) {
+        try {
+          const data = JSON.parse(input);
+          outputStatus(data, usageBar);
+        } catch (e) {
+          outputFallback(usageBar);
+        }
+      } else {
+        outputFallback(usageBar);
+      }
+      process.exit(0);
+    });
+  }, overallTimeout);
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    if (timeoutReached) return;
+    clearTimeout(timeout);
+
+    getUsage((usageBar) => {
+      try {
+        const data = JSON.parse(input);
+        outputStatus(data, usageBar);
+      } catch (e) {
+        outputFallback(usageBar);
+      }
+      process.exit(0);
+    });
+  });
+}