troxy-cli 1.30.18 → 1.30.20

package/bin/troxy.js

@@ -159,6 +159,21 @@ switch (command) {
     process.exit(1);
   }
 
+  // ── Unused Claude Code tools (see src/slim.js) ───────────────
+  case 'slim': {
+    const { TOOLS, setToolOff, printToolsStatus, reportSlim } = await import('../src/slim.js');
+    if (sub === 'status' || !sub) { printToolsStatus(); break; }
+    if (TOOLS.some(t => t.id === sub)) {
+      const undo = Boolean(flags.undo);
+      setToolOff(sub, !undo);
+      await reportSlim();
+      console.log(`\n  ${sub} ${undo ? 'on' : 'off'} ✓  Start a new Claude Code session to apply.\n`);
+      break;
+    }
+    console.error(`  Usage: troxy slim [status] | troxy slim <${TOOLS.map(t => t.id).join('|')}> [--undo]\n`);
+    process.exit(1);
+  }
+
   // ── Auth ──────────────────────────────────────────────────────
   case 'login':
     await runLogin(flags);
@@ -775,6 +790,7 @@ switch (command) {
     troxy status                   Health and connection status
     troxy update                   Update to the latest version
     troxy uninstall                Remove Troxy from this machine
+    troxy slim                     Turn off Claude Code tools you never use
     troxy login                    Start a 12h CLI session for the commands below
     troxy usage-bar [--period 7]   Your usage and what Troxy saved
     troxy activity [--limit 50]    Recent requests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.30.18",
+  "version": "1.30.20",
   "description": "Make your Claude Code usage go further: lighter requests, less usage, less money",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/init.js

@@ -203,6 +203,12 @@ export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null,
     if (hasClaude) {
       await useDirectAnthropic();
     }
+    if (hasClaude || hasDesktop) {
+      try {
+        const { autoSlim } = await import('./slim.js');
+        await autoSlim();
+      } catch {}
+    }
     console.log('\n  Restart your MCP client to activate Troxy.');
   }
 

package/src/slim.js

@@ -0,0 +1,114 @@
+import fs   from 'fs';
+import os   from 'os';
+import path from 'path';
+import { claudeCodeSettingsPath } from './init.js';
+import { loadConfig, saveConfig } from './config.js';
+import { api } from './api.js';
+
+// `troxy slim`: turn off Claude Code tools the user never uses. Every tool
+// Claude Code loads is part of the fixed start of each request, re-read on
+// every call. Measured 2026-11-05: with Chrome and Artifact off, the first
+// call of an interactive session went from about 52.2k to 37.5k tokens.
+//
+// Both live in ~/.claude/settings.json, so turning them back on is just
+// removing what we added:
+//   chrome:   env CLAUDE_CODE_ENABLE_CFC=0 (same as starting with --no-chrome)
+//   artifact: permissions.deny "Artifact" (same as --disallowedTools Artifact,
+//             which removes the tool from the prompt, not just blocks calls)
+//
+// `tokens` is what each one added to every call in that test (chrome alone:
+// 52.2k -> 45.0k; then artifact: 45.0k -> 37.5k). `used` matches a real call
+// of the tool in a transcript; tool definitions are in transcripts too, so
+// matching the bare name would find every session.
+export const TOOLS = [
+  { id: 'chrome',   label: 'Claude in Chrome (lets Claude control your browser)', tokens: 7200,
+    used: /"type":"tool_use","id":"[^"]+","name":"mcp__claude-in-chrome__/ },
+  { id: 'artifact', label: 'Artifacts (lets Claude publish pages to claude.ai)', tokens: 7500,
+    used: /"type":"tool_use","id":"[^"]+","name":"Artifact"/ },
+];
+
+function read(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return {}; }
+}
+
+function write(file, s) {
+  fs.writeFileSync(file, JSON.stringify(s, null, 2) + '\n');
+}
+
+export function toolIsOff(id, file = claudeCodeSettingsPath()) {
+  const s = read(file);
+  if (id === 'chrome') return s.env?.CLAUDE_CODE_ENABLE_CFC === '0';
+  if (id === 'artifact') return (s.permissions?.deny || []).includes('Artifact');
+  return false;
+}
+
+export function setToolOff(id, off, file = claudeCodeSettingsPath()) {
+  const s = read(file);
+  if (id === 'chrome') {
+    if (off) s.env = { ...s.env, CLAUDE_CODE_ENABLE_CFC: '0' };
+    else if (s.env) { delete s.env.CLAUDE_CODE_ENABLE_CFC; if (!Object.keys(s.env).length) delete s.env; }
+  } else if (id === 'artifact') {
+    const deny = (s.permissions?.deny || []).filter(t => t !== 'Artifact');
+    if (off) deny.push('Artifact');
+    s.permissions = { ...s.permissions, deny };
+    if (!deny.length) delete s.permissions.deny;
+    if (!Object.keys(s.permissions).length) delete s.permissions;
+  } else {
+    throw new Error(`Unknown tool "${id}". Try: ${TOOLS.map(t => t.id).join(', ')}`);
+  }
+  write(file, s);
+}
+
+export function printToolsStatus(file = claudeCodeSettingsPath()) {
+  console.log('');
+  for (const t of TOOLS) console.log(`  ${t.id.padEnd(9)} ${toolIsOff(t.id, file) ? 'off' : 'on '}  ${t.label}`);
+  console.log('');
+}
+
+/** Ids of the tools this user has ever called, from Claude Code's own transcripts. */
+export function usedTools(dir = path.join(os.homedir(), '.claude', 'projects')) {
+  const found = new Set();
+  let files = [];
+  try { files = fs.readdirSync(dir, { recursive: true }).filter(f => f.endsWith('.jsonl')); } catch {}
+  for (const f of files) {
+    let fd;
+    try { fd = fs.openSync(path.join(dir, f), 'r'); } catch { continue; }
+    // Chunked so a large transcript is never held in memory; the tail
+    // carries over so a match split across two chunks is still found.
+    const buf = Buffer.alloc(1 << 20);
+    let tail = '', n;
+    while ((n = fs.readSync(fd, buf, 0, buf.length, null)) > 0) {
+      const text = tail + buf.toString('utf8', 0, n);
+      for (const t of TOOLS) if (t.used.test(text)) found.add(t.id);
+      if (found.size === TOOLS.length) break;
+      tail = text.slice(-200);
+    }
+    fs.closeSync(fd);
+    if (found.size === TOOLS.length) break;
+  }
+  return found;
+}
+
+/** Sends which tools are off to the dashboard. Never throws. */
+export async function reportSlim(apiKey = loadConfig()?.apiKey, file = claudeCodeSettingsPath()) {
+  if (!apiKey) return;
+  const slim = Object.fromEntries(TOOLS.map(t => [t.id, toolIsOff(t.id, file) ? 'off' : 'on']));
+  try { await api.reportToolPlans(apiKey, [{ slug: 'claude_code', installed: true, slim }]); } catch {}
+}
+
+// Runs once per machine, from `troxy init` and `troxy update`: turns off each
+// tool the user has never called, so nobody has to decide anything. A tool
+// they have used stays on. Once done it never runs again, so a tool turned
+// back on with --undo stays on.
+export async function autoSlim({ file = claudeCodeSettingsPath(), projectsDir } = {}) {
+  const cfg = loadConfig();
+  if (!cfg || cfg.slimChecked) return;
+  const used = usedTools(projectsDir);
+  for (const t of TOOLS) {
+    if (used.has(t.id) || toolIsOff(t.id, file)) continue;
+    setToolOff(t.id, true, file);
+    console.log(`    • Turned off ${t.label.split(' (')[0]} (never used), saves about ${+(t.tokens / 1000).toFixed(1)}k tokens per call. Undo: troxy slim ${t.id} --undo`);
+  }
+  saveConfig({ ...loadConfig(), slimChecked: true });
+  await reportSlim(cfg.apiKey, file);
+}

package/src/tests/slim.test.js

@@ -0,0 +1,56 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { TOOLS, toolIsOff, setToolOff, usedTools } from '../slim.js';
+
+// Turning a tool off and back on must leave the user's own settings.json
+// exactly as it was, including their own env vars and deny rules.
+let dir, file;
+beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-slim-')); file = path.join(dir, 'settings.json'); });
+afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
+
+const read = () => JSON.parse(fs.readFileSync(file, 'utf8'));
+
+describe('troxy slim', () => {
+  it('turns each tool off and back on, keeping the user settings', () => {
+    const theirs = { env: { HTTPS_PROXY: 'x' }, permissions: { deny: ['Bash(rm:*)'], allow: ['Read'] }, model: 'opus' };
+    fs.writeFileSync(file, JSON.stringify(theirs));
+    for (const t of TOOLS) {
+      assert.equal(toolIsOff(t.id, file), false);
+      setToolOff(t.id, true, file);
+      setToolOff(t.id, true, file);
+      assert.equal(toolIsOff(t.id, file), true);
+    }
+    assert.equal(read().env.CLAUDE_CODE_ENABLE_CFC, '0');
+    assert.deepEqual(read().permissions.deny, ['Bash(rm:*)', 'Artifact']);
+    for (const t of TOOLS) setToolOff(t.id, false, file);
+    assert.deepEqual(read(), theirs);
+  });
+
+  it('cleans up empty keys it created', () => {
+    fs.writeFileSync(file, '{}');
+    for (const t of TOOLS) setToolOff(t.id, true, file);
+    for (const t of TOOLS) setToolOff(t.id, false, file);
+    assert.deepEqual(read(), {});
+  });
+
+  it('rejects an unknown tool', () => {
+    assert.throws(() => setToolOff('nope', true, file), /Unknown tool/);
+  });
+
+  it('finds only real tool calls in transcripts, across chunk boundaries', () => {
+    const proj = path.join(dir, 'projects', 'p');
+    fs.mkdirSync(proj, { recursive: true });
+    // A tool definition names the tool too; that alone is not a use.
+    fs.writeFileSync(path.join(proj, 'a.jsonl'), '{"tools":[{"name":"Artifact"},{"name":"mcp__claude-in-chrome__navigate"}]}\n');
+    assert.deepEqual([...usedTools(path.join(dir, 'projects'))], []);
+    // A real call that straddles the 1 MB read chunk.
+    const call = '{"type":"tool_use","id":"toolu_1","name":"mcp__claude-in-chrome__navigate"}';
+    fs.writeFileSync(path.join(proj, 'b.jsonl'), 'x'.repeat((1 << 20) - 20) + call);
+    assert.deepEqual([...usedTools(path.join(dir, 'projects'))], ['chrome']);
+    assert.deepEqual([...usedTools(path.join(dir, 'missing'))], []);
+  });
+});

package/src/uninstall.js

@@ -12,6 +12,7 @@ import {
   uninstallTroxyGuardMod,
 } from './init.js';
 import { launchdUserDomain } from './launchd.js';
+import { TOOLS, toolIsOff, setToolOff } from './slim.js';
 
 const MCP_CLIENTS = [
   {
@@ -149,6 +150,7 @@ export async function runUninstall() {
     unpatchClaudeCodeProxy(claudeCodeSettingsPath());
     unpatchClaudeCodeInterception(claudeCodeSettingsPath());
     uninstallTroxyGuardMod();
+    for (const t of TOOLS) if (toolIsOff(t.id)) setToolOff(t.id, false);
     console.log('✓');
   } catch (err) {
     console.log('✗');