troxy-cli 1.30.17 → 1.30.19

package/bin/troxy.js

@@ -159,6 +159,20 @@ switch (command) {
     process.exit(1);
   }
 
+  // ── Unused Claude Code tools (see src/slim.js) ───────────────
+  case 'slim': {
+    const { TOOLS, setToolOff, printToolsStatus } = 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);
+      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 +789,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.17",
+  "version": "1.30.19",
   "description": "Make your Claude Code usage go further: lighter requests, less usage, less money",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/action-classification.js

@@ -116,12 +116,10 @@ const RULES = [
       const paths = pathArgs(segment, 2).filter((w) => !w.startsWith('-'));
       return { action_verb: 'delete', resource: summarizeResource(paths, 'a branch'), item_count: 1 };
     }
-    if (/^git\s+push\b/.test(segment) && (/\s--delete\b/.test(segment) || /\s\S*:\S+/.test(segment))) {
-      // `git push origin :branch` (empty source = delete) and
-      // `git push origin local:branch` both use the same refspec shape;
-      // either way the part after the colon is the remote branch being
-      // touched, which is what matters here regardless of which it deletes.
-      const target = segment.match(/--delete\s+(\S+)/)?.[1] || segment.match(/\s\S*:(\S+)/)?.[1];
+    if (/^git\s+push\b/.test(segment) && (/\s--delete\b/.test(segment) || /\s:\S+/.test(segment))) {
+      // Only an empty source (`git push origin :branch`) deletes.
+      // `git push origin HEAD:main` is a normal push, not a delete.
+      const target = segment.match(/--delete\s+(\S+)/)?.[1] || segment.match(/\s:(\S+)/)?.[1];
       return { action_verb: 'delete', resource: target || 'a remote branch', item_count: 1 };
     }
     return null;

package/src/init.js

@@ -566,6 +566,11 @@ export async function runInit({ key, name, proxy, concise } = {}) {
 
   await reprovisionKeyConsumers(key, agentName, proxyOptIn, conciseOptIn);
 
+  if (hasClaudeCode()) {
+    const { askToSlimTools } = await import('./slim.js');
+    await askToSlimTools();
+  }
+
   // Scan for local AI coding tools so the dashboard's "My AI tools" view has
   // something to show. Non-fatal - a scan failure never breaks setup.
   try {

package/src/slim.js

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import { claudeCodeSettingsPath, prompt } from './init.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)
+export const TOOLS = [
+  { id: 'chrome',   label: 'Claude in Chrome (lets Claude control your browser)' },
+  { id: 'artifact', label: 'Artifacts (lets Claude publish pages to claude.ai)' },
+];
+
+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('');
+}
+
+// Asked once from `troxy init`. Default is keep: a tool turned off by surprise
+// is worse than a few thousand tokens.
+export async function askToSlimTools(file = claudeCodeSettingsPath()) {
+  const left = TOOLS.filter(t => !toolIsOff(t.id, file));
+  if (!left.length || !process.stdin.isTTY) return;
+  console.log('\n  Claude Code loads these tools into every request, even when unused.');
+  console.log('  Turning off the ones you never use makes each call lighter.');
+  console.log('  Turn back on any time with: troxy slim <name> --undo\n');
+  for (const t of left) {
+    const ans = (await prompt(`  Turn off ${t.label}? (y/N): `)).toLowerCase();
+    if (ans === 'y') { setToolOff(t.id, true, file); console.log(`  ${t.id} off ✓`); }
+  }
+}

package/src/tests/action-classification.test.js

@@ -86,6 +86,10 @@ describe('actionFor - git force push / branch delete', () => {
     assert.equal(bash('git push origin --delete old-feature').action_verb, 'delete');
     assert.equal(bash('git push origin :old-feature').action_verb, 'delete');
   });
+
+  it('does not treat a normal src:dst push as a delete', () => {
+    assert.equal(bash('git push -q origin HEAD:main'), null);
+  });
 });
 
 describe('actionFor - terraform / kubectl / docker / aws', () => {

package/src/tests/slim.test.js

@@ -0,0 +1,43 @@
+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 } 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/);
+  });
+});

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('✗');