troxy-cli 1.29.42 → 1.29.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.42",
+  "version": "1.29.44",
   "description": "A secure control layer for AI agents: policies across payments, messages, logins, destructive actions, model usage, and secrets, all enforceable from the CLI",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/mods/troxy-guard/hooks/register.js

@@ -24,7 +24,7 @@ async function guardBash($, e, next) {
       body: JSON.stringify({ domain: mapped.domain, fields: mapped.fields }),
       signal: controller.signal,
     });
-    result = res.ok ? await res.json() : { decision: 'ESCALATE', reason: 'policy service returned an error' };
+    result = res.ok ? JSON.parse(res.text) : { decision: 'ESCALATE', reason: 'policy service returned an error' };
   } finally {
     clearTimeout(timer);
   }
@@ -121,6 +121,7 @@ const PRICE = { haiku: 1, sonnet: 2, opus: 4 }; // list $/MTok in; output keeps
 const WINDOW_LABEL = { five_hour: '5h', seven_day: '7d' };
 // Drawn in Troxy's teal: the status line can't be colored and shows as a yellow warning.
 const LINE = { plugin: 'troxy-guard', key: 'line' };
+const SAVINGS = { plugin: 'troxy-guard', key: 'savings' }; // the band's compression + trimming text
 const SAVED = { plugin: 'troxy-guard', key: 'saved' }; // { paid, full, meter }; survives a troxy update
 const TROXY_TEAL = '#0a9e88';
 
@@ -157,14 +158,49 @@ function sessionLine(t) {
     Object.entries(t.meter).map(([kind, percentUsed]) => ({ kind, percentUsed })));
 }
 
+// Tokens Troxy kept out of the requests of this session (compression + trimming), counted
+// by the server. undefined until something was saved.
+function savingsText(s) {
+  const c = (s && s.compressed_tokens) || 0, t = (s && s.trimmed_tokens) || 0;
+  if (!(c + t > 0)) return undefined;
+  const k = n => n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+  return `${k(c + t)} tokens saved by compression and trimming`;
+}
+
+// This session's savings from the server, or null when there is no key, no session id or
+// the call fails (the band then keeps what it showed).
+async function fetchSavings($) {
+  const sid = await $.session.id();
+  if (!/^[A-Za-z0-9-]{8,64}$/.test(String(sid))) return null;
+  let key = await $.env.get('TROXY_API_KEY');
+  if (!key) {
+    const home = await $.env.get('HOME');
+    if (!home) return null;
+    key = JSON.parse(await $.fs.read(`${home}/.troxy/config.json`)).apiKey;
+  }
+  if (!key) return null;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const res = await $.http.fetch(`https://api.troxy.io/mcp/session-savings?session_id=${sid}`, {
+      headers: { 'x-troxy-key': key }, signal: controller.signal,
+    });
+    return res.ok ? JSON.parse(res.text) : null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // /troxy status: everything about this session's Troxy in one place.
-function statusText({ version, paused, totals, rateLimits = [] }) {
+function statusText({ version, paused, totals, rateLimits = [], compactOff = false }) {
   const lines = [`Troxy ${version || ''}`.trim() + ` · routing is ${paused ? 'off' : 'on'}`];
   lines.push(sessionLine(totals) ? `This session: ${sessionLine(totals).replace(/^.*?This session: /, '')}`
     : 'This session: nothing moved to a cheaper model yet');
   const meter = rateLimits.filter(w => WINDOW_LABEL[w.kind]).map(w => `${WINDOW_LABEL[w.kind]} ${Math.round(w.percentUsed)}%`);
   if (meter.length) lines.push(`Plan usage now: ${meter.join(' · ')}`);
   lines.push(`Prompts with over ${ROUTE_CONTEXT_FLOOR_TOKENS / 1000}k tokens of context stay on your model (switching would rewrite the cache).`);
+  lines.push(compactOff ? 'Idle compaction is off (/troxy compact on).'
+    : `Idle compaction is on: sessions over ${COMPACT_MIN_TOKENS / 1000}k tokens are compacted after ${COMPACT_IDLE_MS / 60000} min idle (/troxy compact off).`);
   lines.push('All sessions: dash.troxy.io');
   lines.push(paused ? 'Type /troxy on to resume.' : 'Type /troxy off to pause routing.');
   return lines.join('\n');
@@ -190,6 +226,50 @@ function addTurn(totals, start, end, ratio) {
   return { paid: t.paid + paid, full: t.full + paid * ratio, meter };
 }
 
+// Idle compaction: shrink a big session just before its prompt cache expires (1h), so
+// the summary reads the conversation from cache (~0.1x) and the user comes back to a
+// small session instead of re-sending the whole thing. Never while the plan meter is
+// nearly full: then it waits for the window to reset and compacts on a fresh bar.
+const COMPACT_IDLE_MS = 55 * 60 * 1000;
+const COMPACT_MIN_TOKENS = 100000;
+const COMPACT_LIMIT_PCT = 95;
+const COMPACT_AFTER_RESET_MS = 60 * 1000;
+const COMPACT_INSTRUCTIONS = 'Keep the current task, the files involved, decisions made, and open to-dos.';
+const COMPACTED = { plugin: 'troxy-guard', key: 'compacted' }; // the band's note until the next prompt
+let compactTimer = null;
+
+// What to do when the idle timer fires: skip, compact now, or wait for the meter to reset.
+function compactPlan({ tokens, rateLimits = [], now, off }) {
+  if (off || !(tokens >= COMPACT_MIN_TOKENS)) return { action: 'skip' };
+  const full = rateLimits.filter(w => WINDOW_LABEL[w.kind] && w.percentUsed >= COMPACT_LIMIT_PCT);
+  if (!full.length) return { action: 'compact' };
+  const resets = full.map(w => Date.parse(w.resetsAt)).filter(Number.isFinite);
+  if (resets.length < full.length) return { action: 'skip' }; // unknown reset: never spend a nearly full bar
+  return { action: 'wait', inMs: Math.max(0, Math.max(...resets) - now) + COMPACT_AFTER_RESET_MS };
+}
+
+function cancelCompact() {
+  if (compactTimer) compactTimer.cancel();
+  compactTimer = null;
+}
+
+function armCompact($, ms) {
+  cancelCompact();
+  compactTimer = $.clock.after(ms, () => { compactTimer = null; idleCompact($).catch(() => {}); });
+}
+
+async function idleCompact($) {
+  const u = await $.session.usage();
+  const plan = compactPlan({ tokens: u.context && u.context.tokens, rateLimits: u.rateLimits, now: await $.clock.now(), off: await $.store.get('compactOff') });
+  if (plan.action === 'wait') return armCompact($, plan.inMs);
+  if (plan.action !== 'compact') return;
+  const r = await $.session.compact({ instructions: COMPACT_INSTRUCTIONS });
+  if (r.skip) return;
+  const k = n => `${Math.round(n / 1000)}k`;
+  await $.state.set(COMPACTED, r.tokensBefore && r.tokensAfter
+    ? `compacted this idle session ${k(r.tokensBefore)} → ${k(r.tokensAfter)} tokens` : 'compacted this idle session');
+}
+
 // Where the local daemon looks for this session's routing note (see interceptor.js).
 // Only when installed under ~/.claude/skills, so a --plugin-dir test run never writes
 // into a real user's folder.
@@ -208,6 +288,8 @@ let decision = null;
 
 async function scorePrompt($, e, next) {
   decision = null;
+  cancelCompact();
+  if ((await $.state.get(COMPACTED)).value) await $.state.set(COMPACTED, null);
   turn = { start: await snapshot($), ratio: 1 };
   const sid = await $.session.id();
   const file = modRouteFile($.plugin.root, sid);
@@ -254,15 +336,21 @@ export function register(on) {
     const file = modRouteFile($.plugin.root, sid);
     if (file) { lastNote = `${sid}:{}`; await $.fs.write(file, '{}'); }
     $.ui.status(undefined); // the bar moved to the band above the prompt
+    armCompact($, COMPACT_IDLE_MS); // a hot reload cancels the old timer
     return next(e);
   });
   on('command.run', { command: 'troxy' }, async ($, e) => {
+    const c = /^\s*compact\s+(on|off)\s*$/i.exec(String(e.args || ''));
+    if (c) {
+      await $.store.set('compactOff', c[1].toLowerCase() === 'off');
+      return { text: c[1].toLowerCase() === 'off' ? 'Troxy idle compaction is off.' : 'Troxy idle compaction is on.' };
+    }
     const r = troxyCommand(e.args, Boolean(await $.store.get('paused')));
     await $.store.set('paused', r.paused);
     if (/^\s*(on|off)\s*$/i.test(String(e.args || ''))) return { text: r.text };
     const manifest = JSON.parse(await $.fs.read(`${$.plugin.root}/.claude-plugin/plugin.json`).catch(() => '{}'));
     const { value: totals } = await $.state.get(SAVED);
-    return { text: statusText({ version: manifest.version, paused: r.paused, totals, rateLimits: (await $.session.usage()).rateLimits }) };
+    return { text: statusText({ version: manifest.version, paused: r.paused, totals, rateLimits: (await $.session.usage()).rateLimits, compactOff: Boolean(await $.store.get('compactOff')) }) };
   });
   // Routing fails open: a scorer or hook error must never break the session,
   // it just means the requested model is used as-is.
@@ -270,9 +358,11 @@ export function register(on) {
   on('turn.step', routeStep).catch(async function* ($, e, next) { return yield* next(e); });
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
     const { value: line } = await $.state.get(LINE); // subscribes the band to the line
-    if (!line || e.props.hasSurvey) return next(e);
+    const { value: note } = await $.state.get(COMPACTED);
+    const { value: kept } = await $.state.get(SAVINGS);
+    if ((!line && !kept && !note) || e.props.hasSurvey) return next(e);
     const { Text } = $.ui.resolve(e);
-    return h(Text, { color: TROXY_TEAL }, `Troxy ${line}`);
+    return h(Text, { color: TROXY_TEAL }, `Troxy ${[line, kept, note].filter(Boolean).join(' · ')}`);
   });
   // After the answer, so counting never delays a prompt.
   on('turn.complete', async ($, e, next) => {
@@ -288,9 +378,14 @@ export function register(on) {
         if (line) await $.state.set(LINE, line);
       } catch {} // a missed turn only leaves the band as it was
     }
+    try {
+      const text = savingsText(await fetchSavings($));
+      if (text) await $.state.set(SAVINGS, text);
+    } catch {} // a missed fetch only leaves the band as it was
+    armCompact($, COMPACT_IDLE_MS);
     return r;
   });
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { toDomainAndFields, guardBash, failClosed, parseScore, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText };
+export const _internal = { toDomainAndFields, guardBash, failClosed, parseScore, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText, compactPlan, savingsText, fetchSavings };

package/src/mods/troxy-guard/types/index.d.ts

@@ -3,6 +3,6 @@ export type SessionSaved = { paid: number; full: number; meter: Record<string, n
 
 declare module 'claude-code' {
   interface PluginState {
-    'troxy-guard': { line: BarLine; saved: SessionSaved }
+    'troxy-guard': { line: BarLine; saved: SessionSaved; compacted: BarLine; savings: BarLine }
   }
 }

package/src/tests/mods-troxy-guard.test.js

@@ -99,7 +99,46 @@ test('statusText: version, routing, this session, plan usage, where the account
     + 'This session: your bar lasts 4.0x longer · $0.09 saved of $0.12 at list price · estimate\n'
     + 'Plan usage now: 5h 23% · 7d 77%\n'
     + 'Prompts with over 50k tokens of context stay on your model (switching would rewrite the cache).\n'
+    + 'Idle compaction is on: sessions over 100k tokens are compacted after 55 min idle (/troxy compact off).\n'
     + 'All sessions: dash.troxy.io\n'
     + 'Type /troxy off to pause routing.');
   assert.match(statusText({ paused: true }), /^Troxy · routing is off\nThis session: nothing moved to a cheaper model yet\n/);
 });
+
+test('compactPlan: big idle sessions compact, small ones and a nearly full bar do not', () => {
+  const { compactPlan } = _internal;
+  const now = Date.parse('2026-10-08T15:00:00Z');
+  assert.deepEqual(compactPlan({ tokens: 210000, rateLimits: [{ kind: 'five_hour', percentUsed: 40 }], now }), { action: 'compact' });
+  assert.deepEqual(compactPlan({ tokens: 40000, now }), { action: 'skip' });
+  assert.deepEqual(compactPlan({ tokens: 210000, now, off: true }), { action: 'skip' });
+  // 5h at 95%, resets in 2h; 7d at 95%, resets in 3h: wait for the later one, plus a minute
+  assert.deepEqual(compactPlan({ tokens: 210000, now, rateLimits: [
+    { kind: 'five_hour', percentUsed: 95, resetsAt: '2026-10-08T17:00:00Z' },
+    { kind: 'seven_day', percentUsed: 95, resetsAt: '2026-10-08T18:00:00Z' }] }), { action: 'wait', inMs: 3 * 3600000 + 60000 });
+  // nearly full with no known reset: never spend it
+  assert.deepEqual(compactPlan({ tokens: 210000, now, rateLimits: [{ kind: 'seven_day', percentUsed: 99 }] }), { action: 'skip' });
+});
+
+test('savingsText: shows compression + trimming together, nothing when nothing was saved', () => {
+  const { savingsText } = _internal;
+  assert.equal(savingsText({ compressed_tokens: 5200, trimmed_tokens: 40100 }), '45k tokens saved by compression and trimming');
+  assert.equal(savingsText({ compressed_tokens: 300, trimmed_tokens: 0 }), '300 tokens saved by compression and trimming');
+  assert.equal(savingsText({ compressed_tokens: 0, trimmed_tokens: 0 }), undefined);
+  assert.equal(savingsText(null), undefined);
+});
+
+test('fetchSavings: sends the saved key and the session id; null without a key or on an error', async () => {
+  const { fetchSavings } = _internal;
+  const calls = [];
+  const mk = ({ env = {}, config, res = { ok: true, text: '{"compressed_tokens":1}' } } = {}) => ({
+    session: { id: async () => 'abc-12345678' },
+    env: { get: async n => env[n] },
+    fs: { read: async p => { if (!config) throw new Error('missing'); calls.push(p); return JSON.stringify(config); } },
+    http: { fetch: async (url, init) => { calls.push([url, init.headers]); return res; } },
+  });
+  assert.deepEqual(await fetchSavings(mk({ env: { HOME: '/h' }, config: { apiKey: 'txy-1' } })), { compressed_tokens: 1 });
+  assert.deepEqual(calls, ['/h/.troxy/config.json', ['https://api.troxy.io/mcp/session-savings?session_id=abc-12345678', { 'x-troxy-key': 'txy-1' }]]);
+  assert.equal(await fetchSavings(mk({ env: { TROXY_API_KEY: 'txy-2' }, res: { ok: false } })), null);
+  assert.equal(await fetchSavings(mk({ env: { HOME: '/h' }, config: {} })), null);
+  assert.equal(await fetchSavings({ ...mk(), session: { id: async () => 'x' } }), null);
+});