ctxline-claude 1.2.2 → 1.6.0

package/README.md

@@ -17,10 +17,13 @@
   <a href="https://github.com/MithunWijayasiri/ctxline-claude/stargazers">
     <img src="https://img.shields.io/github/stars/MithunWijayasiri/ctxline-claude" alt="stars">
   </a>
+  <a href="https://ko-fi.com/mithunwijayasiri">
+    <img src="https://img.shields.io/badge/Ko--fi-support-ff5e5b?logo=ko-fi&logoColor=white" alt="Support on Ko-fi">
+  </a>
 </p>
 
 <p align="center">
-  <img src="preview.svg" alt="Claude Code Statusline">
+  <img src="docs/assets/preview.svg" alt="Claude Code Statusline">
 </p>
 
 <p align="center">
@@ -74,6 +77,17 @@ chmod +x ~/.claude/hooks/statusline.js
 }
 ```
 
+**Subagent rows.** The same script also renders per-task rows in the agent panel for running subagents — wire it as a separate `subagentStatusLine` command:
+
+```json
+{
+  "subagentStatusLine": {
+    "type": "command",
+    "command": "node ~/.claude/hooks/statusline.js subagent"
+  }
+}
+```
+
 </details>
 
 ## Update
@@ -121,6 +135,7 @@ Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction Silen
 | **Context** | Visual bar of context-window usage |
 | **Current** | Live 5-hour session limit + reset countdown (subscription users) |
 | **Weekly** | Weekly usage allowance + time until the weekly reset (subscription users) |
+| **Model limit** | Weekly limit scoped to a single model, when your account has one — labelled by the model's initial (`F` = Fable) |
 | **Cost** | Running session cost in USD (e.g. `$0.42`) |
 | **Task** | The in-progress todo, when there is one |
 
@@ -137,7 +152,7 @@ Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction Silen
 
 The statusline is zero-config by default. To **hide segments you don't want**, set the `CTXLINE_DISABLE` environment variable to a comma-separated list of any of:
 
-`branch` · `effort` · `cost` · `task` · `usage` (5-hour + weekly)
+`branch` · `effort` · `cost` · `task` · `usage` (5-hour + weekly + model-scoped)
 
 Directory, model, and context always show; unknown names are ignored. Example below hides cost and the current task.
 
@@ -181,7 +196,8 @@ To re-enable a segment, remove it from the list (or delete the variable) and res
 
 ## How it works
 
-- **Source** — context comes from Claude Code's session data. Usage bars are read straight from the `rate_limits` field Claude Code pipes in (no network), falling back to `https://api.anthropic.com/api/oauth/usage` (the same `/usage` data — 5-hour and weekly limits) when that field isn't present yet. API-key users skip usage entirely.
+- **Source** — context comes from Claude Code's session data. The 5-hour and weekly bars are read straight from the `rate_limits` field Claude Code pipes in (no network), falling back to `https://api.anthropic.com/api/oauth/usage` when that field isn't present yet. API-key users skip usage entirely.
+- **Model-scoped limits** — `rate_limits` carries only `five_hour` and `seven_day`, so a model-scoped weekly limit can only come from `/usage` (its `limits` array). It's served from the same cache as everything else, so this costs at most one call per 30s no matter how often the line renders.
 - **No network on the fast path** — when `rate_limits` is in the session data, there's no API call at all. The fetch below only runs as a fallback (e.g. the first render of a session, before the field appears).
 - **Adaptive timing** — for the fallback fetch: 1.5s timeout on the first prompt (cold start), 1.2s after (connection reused).
 - **Caching** — the fallback fetch is cached at `~/.claude/cache/usage-cache.json`, shared across sessions. Within 30s the cache renders directly (the API call is skipped); if a live call fails, the last value (up to 10 min old) is shown so the bar never vanishes. The reset countdown recomputes every render.
@@ -238,10 +254,17 @@ No. Your credentials never leave your machine. On the fast path no token is read
 
 </details>
 
-## License
 
-MIT
+## Support
+
+If you find this project useful, consider supporting its development on [Ko-fi](https://ko-fi.com/mithunwijayasiri). Your donations help keep the project maintained, improve existing features, and fund new open-source tools.
+
+Thank you for your support! ❤️
 
 ## Credits
 
 Thanks to [@TahaSabir0](https://github.com/TahaSabir0) for the base config.
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxline-claude",
-  "version": "1.2.2",
+  "version": "1.6.0",
   "description": "A customizable statusline for Claude Code that tracks context usage and session limits",
   "bin": {
     "ctxline-claude": "bin/install.js"

package/statusline.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Claude Code Enhanced Statusline
-// Shows: directory | model | context usage | current (5-hour) + weekly usage | current task
+// Shows: directory | model | context usage | 5-hour + weekly + model-scoped usage | current task
 // Auto-detects API key vs subscription usage
 // https://github.com/MithunWijayasiri/ctxline-claude
 
@@ -13,7 +13,7 @@ const { execSync, execFileSync } = require('child_process');
 const IS_API_KEY = !!process.env.ANTHROPIC_API_KEY;
 
 // Optional segment opt-out: CTXLINE_DISABLE is a comma list of segments to hide.
-// Recognized: branch, effort, cost, task, usage (H+W). dir/model/context always render.
+// Recognized: branch, effort, cost, task, usage (H+W+model-scoped). dir/model/context always render.
 // Unknown names are ignored. Disabling a segment also skips its work (git, todo read,
 // usage fetch).
 const DISABLED = new Set(
@@ -54,6 +54,10 @@ const GIT_FRESH_TTL_MS = 5000;          // 5s: reuse counts within a render burs
 const GIT_STALE_TTL_MS = 60000;         // 60s: fall back to last counts if git fails
 const GIT_TIMEOUT_MS = 500;             // hard cap on the rev-list subprocess (warm ~130ms)
 
+// Subagent mode reads only stdin (no usage API to race), so its stdin read gets a
+// short hard cap of its own instead of the main-mode overallTimeout.
+const SUBAGENT_TIMEOUT_MS = 500;
+
 // ANSI color codes
 const colors = {
   reset: '\x1b[0m',
@@ -84,11 +88,31 @@ function getUsageColor(percentage) {
   return colors.red;
 }
 
+// Model-scoped bars skip the H/W thresholds: a line can carry several at once, so a flat
+// orange keeps them readable as one group. Red at >=90 is the one distinction kept — that
+// bar is about to block the model it names.
+function getScopedColor(percentage) {
+  return percentage >= 90 ? colors.red : colors.orange;
+}
+
 // Shorten verbose model names for the statusline: "Opus 4.8 (1M context)" -> "Opus 4.8 (1M)".
 function shortenModel(name) {
   return name.replace(/\s+context\)/i, ')');
 }
 
+// Shorten a resolved model ID (subagent task.model, e.g. "claude-opus-5") for the
+// subagent row: "claude-opus-5" -> "Opus 5", "claude-haiku-4-5-20251001" -> "Haiku 4.5".
+// Distinct from shortenModel, which trims a display name rather than parsing an ID.
+function shortenModelId(id) {
+  if (!id) return '';
+  const stripped = String(id).replace(/^(us\.)?(anthropic\.)?claude-/, '').replace(/-\d{8}$/, '');
+  const [family, ...rest] = stripped.split('-');
+  if (!family) return stripped;
+  const name = family[0].toUpperCase() + family.slice(1);
+  const version = rest.join('.');
+  return version ? `${name} ${version}` : name;
+}
+
 // Tail-truncate an over-long branch name, preserving the leading ticket ID.
 function truncateBranch(name) {
   return name.length > MAX_BRANCH_LEN ? name.slice(0, MAX_BRANCH_LEN - 1) + '…' : name;
@@ -201,10 +225,11 @@ function formatAheadBehind(ab) {
   return s;
 }
 
-function getContextBar(remaining) {
-  const effectiveRemaining = remaining ?? 100;
-  const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
-
+// Colored "C<used> <bar>" (e.g. "C45 ███░░░") for an already-clamped 0-100 used
+// percentage. Shared by the main context bar (derived from remaining%) and the
+// subagent row (derived from tokenCount/contextWindowSize) so both use the same
+// thresholds and bar style.
+function renderContextBar(used) {
   const filled = Math.round((used / 100) * BAR_WIDTH);
   const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(BAR_WIDTH - filled);
 
@@ -215,14 +240,20 @@ function getContextBar(remaining) {
   else if (used < 80) color = colors.orange;
   else color = colors.blink + colors.red;
 
-  // Compact label form: "C<used> <bar>" (e.g. "C45 ███░░░"), colored as a whole.
   return `${color}C${used} ${bar}${colors.reset}`;
 }
 
+function getContextBar(remaining) {
+  const effectiveRemaining = remaining ?? 100;
+  const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
+  return renderContextBar(used);
+}
+
 // Render a compact usage segment from raw data: "<label><pct> ↺ <countdown>"
 // (e.g. "H81 ↺ 2h21m") — no bar. Called on every read (live or cached) so the reset
 // countdown is always recomputed from resetsAt rather than frozen at fetch time.
-function buildUsageBar(label, percentage, resetsAt) {
+// `color` overrides the threshold color — the model-scoped bars pass getScopedColor.
+function buildUsageBar(label, percentage, resetsAt, color) {
   let timeStr = '';
   if (resetsAt) {
     const diffMins = Math.max(0, Math.floor((new Date(resetsAt) - new Date()) / 60000));
@@ -234,18 +265,41 @@ function buildUsageBar(label, percentage, resetsAt) {
     else timeStr = `${mins}m`;
   }
 
-  const color = getUsageColor(percentage);
+  const barColor = color || getUsageColor(percentage);
   const timePart = timeStr ? `${colors.dim} ↺ ${timeStr}${colors.reset}` : '';
 
-  return `${color}${label}${percentage}${colors.reset}${timePart}`;
+  return `${barColor}${label}${percentage}${colors.reset}${timePart}`;
 }
 
-// Build both usage segments from raw entries. Each entry is { percentage, resetsAt } or
-// null/absent. Returns { current, weekly } where each is a rendered segment string or null.
-function buildUsageBars(fiveHour, weekly) {
+// Model-scoped weekly limits (e.g. "Fable weekly limit at 86%"), rendered after the
+// account-wide W bar. The /usage payload reports these in a `limits` array, each entry
+// carrying the model in scope.model.display_name:
+//
+//   { kind: "weekly_scoped", percent: 86, severity: "warning",
+//     resets_at: "...", scope: { model: { display_name: "Fable" } } }
+//
+// The label is the model's first initial (Fable -> F), so a new model family needs no
+// code change. Older payloads instead exposed flat seven_day_<model> keys, kept below as
+// a fallback for accounts still reporting that shape.
+//
+// NOTE: these appear only in the API payload. Claude Code's statusline stdin carries just
+// five_hour and seven_day under rate_limits, so the scoped limits always come from the
+// cache/API path even when stdin supplies the H and W bars.
+const LEGACY_MODEL_WEEKLY_KEYS = [
+  { key: 'seven_day_opus', label: 'O' },
+  { key: 'seven_day_sonnet', label: 'S' }
+];
+
+// Build the usage segments from raw entries. fiveHour/weekly are { percentage, resetsAt }
+// or null/absent; models is an array of { label, percentage, resetsAt } (possibly empty).
+// Returns { current, weekly, models } — the first two rendered strings or null, models a
+// (possibly empty) array of rendered strings. Scoped bars use getScopedColor instead of the
+// H/W thresholds, so the full threshold palette stays exclusive to H/W.
+function buildUsageBars(fiveHour, weekly, models) {
   return {
     current: fiveHour ? buildUsageBar('H', fiveHour.percentage, fiveHour.resetsAt) : null,
-    weekly: weekly ? buildUsageBar('W', weekly.percentage, weekly.resetsAt) : null
+    weekly: weekly ? buildUsageBar('W', weekly.percentage, weekly.resetsAt) : null,
+    models: (models || []).map(m => buildUsageBar(m.label, m.percentage, m.resetsAt, getScopedColor(m.percentage)))
   };
 }
 
@@ -257,11 +311,42 @@ function normalizePercentage(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
 
+// Extract the model-scoped weekly limits from a raw /usage payload as
+// [{ label, percentage, resetsAt }], in payload order. Prefers the `limits` array;
+// falls back to the legacy flat keys only when it yields nothing, so an account
+// reporting both shapes doesn't render the same limit twice.
+function parseScopedLimits(usage) {
+  const scoped = [];
+
+  if (Array.isArray(usage?.limits)) {
+    for (const entry of usage.limits) {
+      if (!entry || entry.kind !== 'weekly_scoped') continue;
+      const name = entry.scope?.model?.display_name;
+      const pct = normalizePercentage(entry.percent);
+      if (typeof name !== 'string' || !name.trim() || pct == null) continue;
+      scoped.push({
+        label: name.trim().charAt(0).toUpperCase(),
+        percentage: pct,
+        resetsAt: entry.resets_at || null
+      });
+    }
+    if (scoped.length) return scoped;
+  }
+
+  for (const { key, label } of LEGACY_MODEL_WEEKLY_KEYS) {
+    const seg = usage?.[key];
+    const pct = seg ? normalizePercentage(seg.utilization) : null;
+    if (pct != null) scoped.push({ label, percentage: pct, resetsAt: seg.resets_at || null });
+  }
+  return scoped;
+}
+
 // Build usage bars from stdin `rate_limits` (Claude.ai Pro/Max, present only after the
 // first API response of a session). Same data as the OAuth usage API, so reading it here
 // skips the network/credentials/cache path entirely. `resets_at` is a Unix epoch in
-// SECONDS (not ISO) — ×1000 before Date. Returns { current, weekly } bars, or null when
-// rate_limits is absent or the required five_hour segment is unusable (caller falls back).
+// SECONDS (not ISO) — ×1000 before Date. Returns raw { fiveHour, weekly } entries, or null
+// when rate_limits is absent or the required five_hour segment is unusable (caller falls
+// back). Model-scoped weekly limits are never present here — see LEGACY_MODEL_WEEKLY_KEYS.
 function buildUsageFromStdin(data) {
   const rl = data?.rate_limits;
   if (!rl) return null;
@@ -284,8 +369,7 @@ function buildUsageFromStdin(data) {
 
   const fiveHour = toEntry(rl.five_hour);
   if (!fiveHour) return null;          // five_hour is the required bar
-  const weekly = toEntry(rl.seven_day);
-  return buildUsageBars(fiveHour, weekly);
+  return { fiveHour, weekly: toEntry(rl.seven_day) };
 }
 
 // Validate a single usage entry ({ percentage, resetsAt }). Returns true only for a
@@ -307,13 +391,18 @@ function readCachedUsage() {
     const cache = JSON.parse(fs.readFileSync(USAGE_CACHE_FILE, 'utf8'));
     if (!cache || !Number.isFinite(cache.timestamp) || cache.timestamp <= 0) return null;
 
-    // Validate data. fiveHour is required; weekly is optional (the API may omit it).
-    // This also rejects the legacy single-{percentage,resetsAt} format from older
-    // versions, which had no fiveHour key, so stale caches are ignored on read.
+    // Validate data. fiveHour is required; weekly and models are optional (the API may
+    // omit either). This also rejects the legacy single-{percentage,resetsAt} format from
+    // older versions, which had no fiveHour key, so stale caches are ignored on read.
+    // A cache written before model bars existed simply has no models key — still valid.
     const data = cache.data;
     if (!data || typeof data !== 'object') return null;
     if (!isValidUsageEntry(data.fiveHour)) return null;
     if (data.weekly != null && !isValidUsageEntry(data.weekly)) return null;
+    if (data.models != null) {
+      if (!Array.isArray(data.models)) return null;
+      if (!data.models.every(m => typeof m?.label === 'string' && isValidUsageEntry(m))) return null;
+    }
 
     return { age: Date.now() - cache.timestamp, data };
   } catch (e) {
@@ -412,9 +501,13 @@ function getApiUsage(callback) {
               resetsAt: usage.seven_day.resets_at || null
             } : null;
 
-            // Cache the raw data (shared across sessions); render the bars from it.
-            setCachedUsage({ fiveHour, weekly });
-            callback(buildUsageBars(fiveHour, weekly));
+            // Model-scoped weekly limits, rendered only when the account reports them.
+            const models = parseScopedLimits(usage);
+
+            // Cache the raw data (shared across sessions); callers render from it.
+            const resolved = { fiveHour, weekly, models };
+            setCachedUsage(resolved);
+            callback(resolved);
           } else {
             callback(null);
           }
@@ -436,28 +529,42 @@ function getApiUsage(callback) {
   }
 }
 
-// Get usage, cache-first.
-function getUsageWithCache(callback) {
+// Resolve raw usage data ({ fiveHour, weekly, models }), cache-first. Callers render it.
+function getRawUsage(callback) {
   const cached = readCachedUsage();
 
-  // Cache is fresh -> render it and skip the API entirely (fewer calls, faster).
+  // Cache is fresh -> use it and skip the API entirely (fewer calls, faster).
   if (cached && cached.age < FRESH_TTL_MS) {
-    return callback(buildUsageBars(cached.data.fiveHour, cached.data.weekly));
+    return callback(cached.data);
   }
 
   // Cache is stale or missing -> refresh from the API.
-  getApiUsage((freshBars) => {
-    if (freshBars) {
-      callback(freshBars);
+  getApiUsage((fresh) => {
+    if (fresh) {
+      callback(fresh);
     } else if (cached && cached.age < STALE_TTL_MS) {
       // API failed/timed out, but recent cache exists -> show it instead of nothing.
-      callback(buildUsageBars(cached.data.fiveHour, cached.data.weekly));
+      callback(cached.data);
     } else {
       callback(null);
     }
   });
 }
 
+// Get usage, cache-first, rendered.
+function getUsageWithCache(callback) {
+  getRawUsage((data) => {
+    callback(data ? buildUsageBars(data.fiveHour, data.weekly, data.models) : null);
+  });
+}
+
+// Model-scoped weekly limits only, cache-first. Used alongside the stdin H/W bars, which
+// can't carry them. Falls back to the stale cache and finally to [] so a failed or slow
+// call costs the scoped bars but never the bars stdin already gave us.
+function getScopedModels(callback) {
+  getRawUsage((data) => callback(data?.models || []));
+}
+
 // Session cost from stdin `cost.total_cost_usd` (USD float, computed client-side by
 // Claude Code as tokens × per-model API pricing). Pure stdin — no network/cache.
 // Returns "$0.00" rendered dim, or '' when absent/non-finite so the segment is omitted.
@@ -537,6 +644,7 @@ function outputStatus(data, usage) {
     const line2 = [];
     if (usage?.current) line2.push(usage.current);
     if (usage?.weekly) line2.push(usage.weekly);
+    if (usage?.models?.length) line2.push(...usage.models);
     if (cost) line2.push(cost);
     if (task) line2.push(`${colors.dim}${task}${colors.reset}`);
 
@@ -551,6 +659,7 @@ function outputFallback(usage) {
   const parts = ['~', 'Claude', contextBar];
   if (usage?.current) parts.push(usage.current);
   if (usage?.weekly) parts.push(usage.weekly);
+  if (usage?.models?.length) parts.push(...usage.models);
   process.stdout.write(parts.join(' \u2502 '));
 }
 
@@ -563,7 +672,12 @@ function resolveUsage(data, callback) {
   }
   const fromStdin = buildUsageFromStdin(data);
   if (fromStdin) {
-    return callback(fromStdin);
+    // stdin covers H and W with no network. Model-scoped weekly limits only exist in the
+    // API payload, so they come from the cache — refreshed on the same TTL as every other
+    // usage read, which keeps at most one call per FRESH_TTL_MS regardless of render rate.
+    return getScopedModels((models) => {
+      callback(buildUsageBars(fromStdin.fiveHour, fromStdin.weekly, models));
+    });
   }
   getUsageWithCache(callback);
 }
@@ -591,24 +705,123 @@ function emit(data) {
   });
 }
 
-if (process.stdin.isTTY) {
-  emit(null);
+// now - startTime as "45s" / "4m12s" / "2h5m". '' when startTime is missing/unparseable.
+// Format isn't documented by Claude Code, so accept epoch-seconds, epoch-ms, or an ISO
+// string: numbers below 1e12 are epoch-seconds (today's epoch-seconds ~1.7e9, epoch-ms
+// ~1.7e12 — far enough apart that the threshold is unambiguous for any real timestamp).
+function formatElapsed(startTime) {
+  if (startTime == null) return '';
+  const ms = typeof startTime === 'number' && startTime < 1e12 ? startTime * 1000 : startTime;
+  const start = new Date(ms).getTime();
+  if (Number.isNaN(start)) return '';
+
+  const diffSec = Math.max(0, Math.floor((Date.now() - start) / 1000));
+  const hours = Math.floor(diffSec / 3600);
+  const mins = Math.floor((diffSec % 3600) / 60);
+  const secs = diffSec % 60;
+  if (hours > 0) return `${hours}h${mins}m`;
+  if (mins > 0) return `${mins}m${secs}s`;
+  return `${secs}s`;
+}
+
+// One subagentStatusLine row: "name │ Model · effort │ C<used> <bar> │ ⏱ <elapsed>".
+// Every segment past name is conditional on its source being present/finite.
+function renderSubagentTask(t) {
+  const parts = [t.label || t.name || t.description || 'agent'];
+
+  const model = shortenModelId(t.model);
+  // effort absent = subagent inherits the session effort; show model alone then.
+  const effort = t.effort != null ? String(t.effort) : '';
+  if (model) {
+    parts.push(effort
+      ? `${model}${getEffortColor(effort)} · ${effort}${colors.reset}`
+      : model);
+  } else if (effort) {
+    parts.push(`${getEffortColor(effort)}${effort}${colors.reset}`);
+  }
+
+  if (Number.isFinite(t.tokenCount) && Number.isFinite(t.contextWindowSize) && t.contextWindowSize > 0) {
+    const used = Math.max(0, Math.min(100, Math.round((t.tokenCount / t.contextWindowSize) * 100)));
+    parts.push(renderContextBar(used));
+  }
+
+  const elapsed = formatElapsed(t.startTime);
+  if (elapsed) parts.push(`${colors.dim}⏱ ${elapsed}${colors.reset}`);
+
+  return parts.join(SEGMENT_SEP);
+}
+
+// subagentStatusLine mode: emit one {id, content} JSON line per task with an id, then
+// exit. No usage/git/todos/cache work — the task objects carry everything needed.
+// Bad payload or a task that fails to render -> emit nothing, keeping default
+// rendering for every task, rather than a partial/broken output.
+function emitSubagent(data) {
+  try {
+    const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+    const out = tasks
+      .filter(t => t && t.id)
+      .map(t => JSON.stringify({ id: t.id, content: renderSubagentTask(t) }))
+      .join('\n');
+    if (out) {
+      // Exit from the write callback: process.exit() would drop output still queued
+      // behind stdout backpressure. A write error (e.g. EPIPE) also lands here — the
+      // callback form reports it instead of throwing, and the answer is the same: exit 0.
+      process.stdout.write(out + '\n', () => process.exit(0));
+      return;
+    }
+  } catch (e) {}
+  process.exit(0);
+}
+
+// Entry point, guarded so tests can require this file to exercise payload parsing
+// directly (the /usage response shape is the easiest thing here to get wrong, and it
+// can't be reached through stdin). Running the script normally is unchanged.
+if (require.main === module) {
+  if (process.argv[2] === 'subagent') {
+    if (process.stdin.isTTY) {
+      emitSubagent(null);
+    } else {
+      let input = '';
+      let finished = false;
+
+      // Single guarded exit shared by all three triggers: timeout, stdin 'end', and
+      // stdin 'error' (which can fire before 'end' and would otherwise throw unhandled,
+      // breaking the never-throw contract). Whatever accumulated so far gets rendered.
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timeout);
+        emitSubagent(parseInput(input));
+      };
+
+      const timeout = setTimeout(finish, SUBAGENT_TIMEOUT_MS);
+
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', chunk => input += chunk);
+      process.stdin.on('end', finish);
+      process.stdin.on('error', finish);
+    }
+  } else if (process.stdin.isTTY) {
+    emit(null);
+  } else {
+    let input = '';
+    let timeoutReached = false;
+
+    const overallTimeout = IS_API_KEY ? 500 : (fs.existsSync(USAGE_CACHE_FILE) ? 1300 : 1600);
+
+    const timeout = setTimeout(() => {
+      timeoutReached = true;
+      emit(parseInput(input));
+    }, overallTimeout);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => input += chunk);
+    process.stdin.on('end', () => {
+      if (timeoutReached) return;
+      clearTimeout(timeout);
+      emit(parseInput(input));
+    });
+  }
 } else {
-  let input = '';
-  let timeoutReached = false;
-
-  const overallTimeout = IS_API_KEY ? 500 : (fs.existsSync(USAGE_CACHE_FILE) ? 1300 : 1600);
-
-  const timeout = setTimeout(() => {
-    timeoutReached = true;
-    emit(parseInput(input));
-  }, overallTimeout);
-
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', chunk => input += chunk);
-  process.stdin.on('end', () => {
-    if (timeoutReached) return;
-    clearTimeout(timeout);
-    emit(parseInput(input));
-  });
+  module.exports = { parseScopedLimits, normalizePercentage };
 }