troxy-cli 1.30.6 → 1.30.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.30.6",
+  "version": "1.30.7",
   "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/mcp-server.js

@@ -21,12 +21,50 @@ const reportModelUsage = (body, apiKey) => api.reportModelUsage(body, apiKey);
 // agent whose only way to reach Troxy is through the tools listed here.
 const evaluateSecrets = (body, apiKey) => api.evaluateSecrets(body, apiKey);
 
+// Just the part Claude asks for, so a recall does not put a whole output back into the
+// conversation: `lines` is "120-180" or "120" (1-based), `pattern` is case-insensitive text and
+// returns each matching line with `context` lines around it (default 2, at most 10), within `lines`
+// when both are given. Line numbers are added to partial results.
+const RECALL_MAX_LINES = 200;
+export function sliceRecall(content, { lines, pattern, context } = {}) {
+  if ((lines === undefined || lines === null || lines === '') && !pattern) return { text: content };
+  const all = content.split('\n');
+  let from = 1, to = all.length;
+  if (lines !== undefined && lines !== null && lines !== '') {
+    const m = /^\s*(\d+)\s*(?:-\s*(\d+))?\s*$/.exec(String(lines));
+    if (!m) return { error: 'lines must look like "120-180" or "120"' };
+    from = Math.max(1, Number(m[1]));
+    to = Math.min(all.length, m[2] ? Number(m[2]) : from);
+    if (from > to) return { error: `the output has ${all.length} lines` };
+  }
+  let keep = [];
+  if (pattern) {
+    const needle = String(pattern).toLowerCase();
+    const ctx = Math.min(10, Math.max(0, Number.isFinite(Number(context)) ? Math.floor(Number(context)) : 2));
+    const shown = new Set();
+    for (let i = from - 1; i < to; i++) {
+      if (!all[i].toLowerCase().includes(needle)) continue;
+      for (let j = Math.max(from - 1, i - ctx); j <= Math.min(to - 1, i + ctx); j++) shown.add(j);
+    }
+    keep = [...shown].sort((a, b) => a - b);
+    if (!keep.length) return { text: `No line${lines ? ` in ${from}-${to}` : ''} contains "${pattern}" (the output has ${all.length} lines).` };
+  } else {
+    for (let i = from - 1; i < to; i++) keep.push(i);
+  }
+  const cut = keep.length > RECALL_MAX_LINES;
+  const body = keep.slice(0, RECALL_MAX_LINES).map(i => `${i + 1}: ${all[i]}`).join('\n');
+  const note = cut ? `\n(first ${RECALL_MAX_LINES} of ${keep.length} lines shown, narrow with lines or pattern)` : '';
+  return { text: `(${all.length} lines in total, line numbers added)\n${body}${note}` };
+}
+
 export async function handleRecall(args, dir = storeDir()) {
   const content = await sandboxGet(args.handle, dir);
   if (content === null) {
     return { content: [{ type: 'text', text: `Troxy error: handle "${args.handle}" not found (it may have expired).` }], isError: true };
   }
-  return { content: [{ type: 'text', text: content }], isError: false };
+  const r = sliceRecall(content, args);
+  if (r.error) return { content: [{ type: 'text', text: `Troxy error: ${r.error}.` }], isError: true };
+  return { content: [{ type: 'text', text: r.text }], isError: false };
 }
 
 export async function runMcp() {
@@ -291,14 +329,18 @@ export async function runMcp() {
       {
         name: 'troxy_recall',
         description:
-          'Fetch the full content behind a troxy_recall(...) handle shown after a large tool ' +
+          'Fetch the content behind a troxy_recall(...) handle shown after a large tool ' +
           'output was compressed. Use this when the summary you were shown doesn\'t have the ' +
-          'detail you need.',
+          'detail you need. Prefer lines or pattern when you only need part of it: the whole ' +
+          'output goes back into the conversation and stays there.',
         inputSchema: {
           type: 'object',
           required: ['handle'],
           properties: {
             handle: { type: 'string', description: 'The handle shown in the compressed output, e.g. "a1b2c3d4e5f6a7b8"' },
+            lines: { type: 'string', description: 'Only these lines, 1-based: "120-180" or "120".' },
+            pattern: { type: 'string', description: 'Only lines containing this text (case-insensitive), with a few lines around each. Combine with lines to search inside a range.' },
+            context: { type: 'number', description: 'Lines around each pattern match, default 2, at most 10.' },
           },
         },
       },

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

@@ -230,7 +230,7 @@ const REPORT_KEEP_ROWS = 1000; // kept for the next try while Troxy is unreachab
 let pending = [];
 let compacting = false;
 
-function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimits, ts, effort, effortAsked, surfaces, compressed }) {
+function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimits, ts, effort, effortAsked, surfaces, compressed, recalled }) {
   const rl = {};
   for (const w of rateLimits || []) {
     if (!WINDOW_LABEL[w.kind]) continue;
@@ -244,24 +244,29 @@ function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimit
     cache_read_tokens: usage.cache_read_input_tokens, cache_creation_tokens: usage.cache_creation_input_tokens,
     rate_limits: rl, ts, effort: effort || null, effort_requested: effortAsked || null,
     compressed_tokens: compressed > 0 ? compressed : null,
+    recalled_tokens: recalled > 0 ? recalled : null,
     surface: (surfaces || []).includes('desktop') ? 'desktop' : (surfaces || []).includes('terminal') ? 'terminal' : null,
   };
 }
 
 // Tokens the compression hook kept out of this session since the last report (it appends one
 // line per compressed tool output, see sandbox/posttooluse-hook.js). Each count is reported once.
+// The same hook logs the tokens Claude fetched back with troxy_recall (`recalled/`), which the
+// dashboard subtracts.
 const savedSeen = new Map();
-async function compressedSince($, sid) {
+async function compressedSince($, sid, dir = 'saved') {
   try {
     if (!/^[A-Za-z0-9-]{8,128}$/.test(String(sid))) return 0;
     const home = await $.env.get('HOME');
-    const text = await $.fs.read(`${home}/.troxy/sandbox/saved/${sid}.log`);
+    const text = await $.fs.read(`${home}/.troxy/sandbox/${dir}/${sid}.log`);
     const total = String(text).split('\n').reduce((n, l) => n + (Number(l) || 0), 0);
-    const delta = Math.max(0, total - (savedSeen.get(sid) || 0));
-    savedSeen.set(sid, total);
+    const key = `${dir}:${sid}`;
+    const delta = Math.max(0, total - (savedSeen.get(key) || 0));
+    savedSeen.set(key, total);
     return delta;
   } catch { return 0; }
 }
+const recalledSince = ($, sid) => compressedSince($, sid, 'recalled');
 
 async function noteStep($, result, meta) {
   const usage = result && result.usage;
@@ -271,7 +276,7 @@ async function noteStep($, result, meta) {
   let surfaces = [];
   try { surfaces = await $.session.surfaces(); } catch {}
   const sid = await $.session.id();
-  pending.push(reportRow({ ...meta, sid, usage, compact: compacting, rateLimits, surfaces, compressed: await compressedSince($, sid), ts: await $.clock.now() }));
+  pending.push(reportRow({ ...meta, sid, usage, compact: compacting, rateLimits, surfaces, compressed: await compressedSince($, sid), recalled: await recalledSince($, sid), ts: await $.clock.now() }));
   if (pending.length > REPORT_KEEP_ROWS) pending = pending.slice(-REPORT_KEEP_ROWS);
 }
 
@@ -665,4 +670,4 @@ export function register(on) {
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { compressedSince, stepEffort, reportRow, noteStep, flushReport, pendingRows: () => pending, troxyConfig, askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, withKept, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, lastSent };
+export const _internal = { compressedSince, recalledSince, stepEffort, reportRow, noteStep, flushReport, pendingRows: () => pending, troxyConfig, askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, withKept, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, lastSent };

package/src/sandbox/posttooluse-hook.js

@@ -41,14 +41,25 @@ function sessionArm(dir, sessionId, holdoutFraction, randomFn) {
 // One line per compression: the tokens it kept out of the conversation (about 4 characters
 // each). The troxy-guard mod reads this per session and reports it, since in the mod-only setup
 // no proxy sees the traffic. Append-only so parallel hook processes never overwrite each other.
-export function recordSaved(dir, sessionId, tokens) {
+function recordTokens(dir, sub, sessionId, tokens) {
   if (typeof sessionId !== 'string' || !SESSION_ID_RE.test(sessionId) || !(tokens > 0)) return;
   try {
-    const file = path.join(dir, 'saved', `${sessionId}.log`);
+    const file = path.join(dir, sub, `${sessionId}.log`);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.appendFileSync(file, `${Math.round(tokens)}\n`);
   } catch { /* fails open: a missed count never blocks the tool output */ }
 }
+export const recordSaved = (dir, sessionId, tokens) => recordTokens(dir, 'saved', sessionId, tokens);
+// Tokens Claude fetched back with troxy_recall: they re-enter the conversation, so the
+// dashboard takes them off what compression saved.
+export const recordRecalled = (dir, sessionId, tokens) => recordTokens(dir, 'recalled', sessionId, tokens);
+
+function textChars(v) {
+  if (typeof v === 'string') return v.length;
+  if (Array.isArray(v)) return v.reduce((n, x) => n + textChars(x), 0);
+  if (v && typeof v === 'object') return textChars(v.text) + textChars(v.content);
+  return 0;
+}
 
 function writeState(dir, state) {
   try {
@@ -103,6 +114,10 @@ export async function buildHookResponse(toolUseBlock, {
   storeDir = defaultStoreDir(),
 } = {}) {
   const toolResponse = toolUseBlock?.tool_response;
+  if (/troxy_recall$/.test(String(toolUseBlock?.tool_name || ''))) {
+    recordRecalled(storeDir, toolUseBlock?.session_id, textChars(toolResponse) / 4);
+    return undefined;
+  }
   const arm = sessionArm(storeDir, toolUseBlock?.session_id, holdoutFraction, randomFn);
   if (arm === 'holdout') {
     writeState(storeDir, 'holdout');
@@ -128,7 +143,7 @@ export async function buildHookResponse(toolUseBlock, {
     const summary = summarize(output);
     const { handle } = await put(output, { summary, tags: [] }, storeDir);
     writeState(storeDir, 'treated');
-    const updatedText = `${summary}\n\n(troxy_recall("${handle}") to fetch the full output)`;
+    const updatedText = `${summary}\n\n(troxy_recall("${handle}") to fetch the full output; add lines or pattern for just a part)`;
     recordSaved(storeDir, toolUseBlock?.session_id, (output.length - updatedText.length) / 4);
     return {
       hookSpecificOutput: {

package/src/tests/mcp-recall.test.js

@@ -20,3 +20,32 @@ test('troxy_recall returns a clear error for an unknown handle', async () => {
   assert.equal(result.isError, true);
   assert.match(result.content[0].text, /not found/i);
 });
+
+test('troxy_recall returns only the lines asked for, with line numbers', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-sandbox-'));
+  const { handle } = await put(Array.from({ length: 50 }, (_, i) => `row ${i + 1}`).join('\n'), { summary: 'x', tags: [] }, dir);
+  const r = await handleRecall({ handle, lines: '10-12' }, dir);
+  assert.equal(r.isError, false);
+  assert.equal(r.content[0].text, '(50 lines in total, line numbers added)\n10: row 10\n11: row 11\n12: row 12');
+  assert.match((await handleRecall({ handle, lines: '49' }, dir)).content[0].text, /49: row 49$/);
+  assert.equal((await handleRecall({ handle, lines: 'abc' }, dir)).isError, true);
+  assert.equal((await handleRecall({ handle, lines: '60-70' }, dir)).isError, true);
+});
+
+test('troxy_recall finds a pattern with context, inside a range, and says when nothing matches', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-sandbox-'));
+  const text = Array.from({ length: 30 }, (_, i) => (i === 9 || i === 24 ? `FAILED test ${i + 1}` : `ok ${i + 1}`)).join('\n');
+  const { handle } = await put(text, { summary: 'x', tags: [] }, dir);
+  const out = (await handleRecall({ handle, pattern: 'failed', context: 1 }, dir)).content[0].text;
+  assert.match(out, /9: ok 9\n10: FAILED test 10\n11: ok 11\n24: ok 24\n25: FAILED test 25\n26: ok 26$/);
+  const inRange = (await handleRecall({ handle, pattern: 'failed', context: 0, lines: '1-15' }, dir)).content[0].text;
+  assert.doesNotMatch(inRange, /FAILED test 25/);
+  assert.match((await handleRecall({ handle, pattern: 'nope' }, dir)).content[0].text, /No line contains "nope"/);
+});
+
+test('troxy_recall caps a pattern result at 200 lines and says so', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-sandbox-'));
+  const { handle } = await put(Array.from({ length: 500 }, () => 'hit').join('\n'), { summary: 'x', tags: [] }, dir);
+  const out = (await handleRecall({ handle, pattern: 'hit' }, dir)).content[0].text;
+  assert.match(out, /first 200 of 500 lines shown/);
+});

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

@@ -460,3 +460,17 @@ test('compressedSince reports each compression once, per session', async () => {
   assert.equal(await compressedSince({ ...$, fs: { read: async () => { throw new Error('no file'); } } }, 'dddddddd-1111-2222'), 0);
   assert.equal(await compressedSince($, '../etc/passwd'), 0);
 });
+
+test('recalledSince reports fetched-back tokens once, and reportRow carries them', async () => {
+  const { recalledSince, reportRow } = _internal;
+  const sid = 'ffffffff-1111-2222-3333-444444444444';
+  let log = '2000\n';
+  const $ = { env: { get: async () => '/home/u' }, fs: { read: async (p) => { assert.ok(p.endsWith(`/.troxy/sandbox/recalled/${sid}.log`)); return log; } } };
+  assert.equal(await recalledSince($, sid), 2000);
+  assert.equal(await recalledSince($, sid), 0);
+  log += '100\n';
+  assert.equal(await recalledSince($, sid), 100);
+  const usage = { model: 'claude-sonnet-5-5', input_tokens: 1, output_tokens: 1, cache_read_input_tokens: 1, cache_creation_input_tokens: 1 };
+  assert.equal(reportRow({ sid: 's1', usage, recalled: 100 }).recalled_tokens, 100);
+  assert.equal(reportRow({ sid: 's1', usage }).recalled_tokens, null);
+});

package/src/tests/posttooluse-hook.test.js

@@ -243,3 +243,15 @@ test('no session id or a small output records nothing', async () => {
   await buildHookResponse({ session_id: 'bbbbbbbb-1111-2222-3333-444444444444', tool_response: bashResult('short') }, opts);
   assert.equal(fs.existsSync(path.join(dir, 'saved')), false);
 });
+
+test('the hook records the tokens fetched back with troxy_recall, per session, and leaves the result alone', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-recalled-'));
+  const sid = 'eeeeeeee-1111-2222-3333-444444444444';
+  const out = await buildHookResponse({ tool_name: 'mcp__troxy__troxy_recall', session_id: sid, tool_response: [{ type: 'text', text: 'x'.repeat(8000) }] }, { storeDir: dir });
+  assert.equal(out, undefined);
+  assert.deepEqual(fs.readFileSync(path.join(dir, 'recalled', `${sid}.log`), 'utf8').trim().split('\n').map(Number), [2000]);
+  await buildHookResponse({ tool_name: 'mcp__troxy__troxy_recall', session_id: sid, tool_response: { content: [{ type: 'text', text: 'y'.repeat(400) }] } }, { storeDir: dir });
+  assert.deepEqual(fs.readFileSync(path.join(dir, 'recalled', `${sid}.log`), 'utf8').trim().split('\n').map(Number), [2000, 100]);
+  await buildHookResponse({ tool_name: 'mcp__troxy__troxy_recall', tool_response: [{ type: 'text', text: 'z'.repeat(800) }] }, { storeDir: dir });
+  assert.equal(fs.readdirSync(path.join(dir, 'recalled')).length, 1);
+});