@humwick/runner 0.0.0-stage → 0.130.1

package/plugins/claude/claude-statusline-probe.cjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+"use strict";
+
+const { mkdirSync, renameSync, writeFileSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { basename, dirname, join } = require("node:path");
+
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => { input += chunk; });
+process.stdin.on("end", () => {
+  const metrics = parseClaudeStatusLineInput(input);
+  if (metrics) writeState(metrics);
+  process.stdout.write(`${standaloneOutput(metrics)}\n`);
+});
+
+function statuslineAgentId() {
+  return stringValue(process.env.AGENT_RELAY_AGENT_ID) || stringValue(process.env.AGENT_RELAY_ID);
+}
+
+function statuslineStateDir() {
+  return process.env.AGENT_RELAY_CONTEXT_STATE_DIR || process.env.AGENT_RELAY_HOST_TMPDIR || tmpdir();
+}
+
+function parseClaudeStatusLineInput(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(data) || !isRecord(data.context_window)) return null;
+  const context = data.context_window;
+  const timestamp = Date.now();
+  const contextPercent = numberValue(context.used_percentage);
+  const tokensMax = numberValue(context.context_window_size);
+  const usage = isRecord(context.current_usage) ? context.current_usage : undefined;
+  const tokensUsed = sumNumbers(
+    usage && usage.input_tokens,
+    usage && usage.cache_creation_input_tokens,
+    usage && usage.cache_read_input_tokens,
+  );
+  if (contextPercent === undefined && tokensUsed === undefined) return null;
+
+  const rateLimits = isRecord(data.rate_limits) ? data.rate_limits : undefined;
+  const fiveHour = isRecord(rateLimits && rateLimits.five_hour) ? rateLimits.five_hour : undefined;
+  const quotaWindows = quotaWindowsFromRateLimits(rateLimits);
+  const model = stringValue(data.model) || stringValue(process.env.CLAUDE_MODEL);
+  const effort = isRecord(data.effort) ? stringValue(data.effort.level) : stringValue(data.effort);
+  const resolvedEffort = effort || stringValue(process.env.CLAUDE_EFFORT) || stringValue(process.env.CLAUDE_CODE_EFFORT_LEVEL);
+
+  const metrics = {
+    agentId: statuslineAgentId() || stringValue(data.session_id) || "unknown",
+    contextPercent: contextPercent !== undefined ? contextPercent : ((tokensUsed || 0) / (tokensMax || 1)) * 100,
+    source: "statusline",
+    confidence: "exact",
+    timestamp,
+  };
+  if (tokensUsed !== undefined) metrics.tokensUsed = tokensUsed;
+  if (tokensMax !== undefined) metrics.tokensMax = tokensMax;
+  const quotaUsed = numberValue(fiveHour && fiveHour.used_percentage);
+  if (quotaUsed !== undefined) metrics.quotaUsed = quotaUsed;
+  const quotaResetIn = secondsUntil(numberValue(fiveHour && fiveHour.resets_at), timestamp);
+  if (quotaResetIn !== undefined) metrics.quotaResetIn = quotaResetIn;
+  if (quotaWindows.length > 0) metrics.quotaWindows = quotaWindows;
+  if (model) metrics.model = model;
+  if (resolvedEffort) metrics.effort = resolvedEffort;
+  metrics.contextPercent = Math.max(0, Math.min(100, metrics.contextPercent));
+  return metrics;
+}
+
+function writeState(metrics) {
+  // The runner reads this from the host temp root, not this agent's private TMPDIR (#3084).
+  const dir = statuslineStateDir();
+  const file = join(dir, `agent-relay-context-${safeStateId(metrics.agentId)}.json`);
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(metrics, null, 2));
+  renameSync(tmp, file);
+}
+
+function quotaWindowsFromRateLimits(rateLimits) {
+  const windows = [];
+  for (const name of ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"]) {
+    const raw = isRecord(rateLimits && rateLimits[name]) ? rateLimits[name] : undefined;
+    const usedPercentage = numberValue(raw && raw.used_percentage);
+    if (usedPercentage === undefined) continue;
+    const window = { name, utilization: usedPercentage / 100, unit: "%" };
+    const resetsAt = epochSecondsToMs(numberValue(raw && raw.resets_at));
+    if (resetsAt !== undefined) window.resetsAt = resetsAt;
+    windows.push(window);
+  }
+  return windows;
+}
+
+function standaloneOutput(metrics) {
+  if (!metrics) return "humwick context: unavailable";
+  const pct = Math.round(metrics.contextPercent);
+  const tokens = metrics.tokensUsed && metrics.tokensMax ? ` ${formatTokens(metrics.tokensUsed)}/${formatTokens(metrics.tokensMax)}` : "";
+  return `humwick context: ${pct}%${tokens}`;
+}
+
+function formatTokens(tokens) {
+  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(1)}M`;
+  if (tokens >= 1000) return `${Math.round(tokens / 1000)}K`;
+  return String(tokens);
+}
+
+function safeStateId(agentId) {
+  const safe = basename(agentId).replace(/[^\w.-]/g, "-");
+  return safe || "unknown";
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function sumNumbers(...values) {
+  let total = 0;
+  let seen = false;
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      total += value;
+      seen = true;
+    }
+  }
+  return seen ? total : undefined;
+}
+
+function secondsUntil(epochSeconds, nowMs) {
+  return epochSeconds === undefined ? undefined : Math.max(0, Math.round(epochSeconds - nowMs / 1000));
+}
+
+function epochSecondsToMs(epochSeconds) {
+  return epochSeconds === undefined ? undefined : epochSeconds * 1000;
+}