troxy-cli 1.30.19 → 1.30.21

package/bin/troxy.js

@@ -161,11 +161,12 @@ switch (command) {
 
   // ── Unused Claude Code tools (see src/slim.js) ───────────────
   case 'slim': {
-    const { TOOLS, setToolOff, printToolsStatus } = await import('../src/slim.js');
+    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;
     }
@@ -685,20 +686,26 @@ switch (command) {
     process.stdout.write('  Installing... ');
     try {
       try {
-        execSync('npm install -g troxy-cli@latest', { stdio: 'pipe' });
+        // The exact version, fetched fresh: `@latest` resolves from npm's own
+        // cache, which can still point at the old version for minutes after a
+        // publish, and then this "updated" to the version already installed.
+        execSync(`npm install -g troxy-cli@${latest} --prefer-online`, { stdio: 'pipe' });
       } catch (err) {
         const stderr = err.stderr?.toString() || '';
         if (stderr.includes('ENOTEMPTY')) {
           // npm bug on macOS/Homebrew: rename fails because dir has contents.
           // rm -rf the stale dir directly, then reinstall cleanly.
           const globalRoot = execSync('npm root -g', { stdio: 'pipe' }).toString().trim();
-          execSync(`rm -rf "${globalRoot}/troxy-cli" && npm install -g troxy-cli@latest`, { stdio: 'pipe', shell: true });
+          execSync(`rm -rf "${globalRoot}/troxy-cli" && npm install -g troxy-cli@${latest} --prefer-online`, { stdio: 'pipe', shell: true });
         } else {
           throw err;
         }
       }
       // Also refresh the npx cache so MCP servers (e.g. OpenClaw) pick up the new version
       try { execSync(`npx --yes troxy-cli@${latest} --version`, { stdio: 'pipe' }); } catch { /* non-fatal */ }
+      const globalRoot = execSync('npm root -g', { stdio: 'pipe' }).toString().trim();
+      const installed = JSON.parse((await import('fs')).readFileSync(`${globalRoot}/troxy-cli/package.json`, 'utf8')).version;
+      if (installed !== latest) throw new Error(`npm installed ${installed}, not ${latest}. Try again in a few minutes.`);
       console.log(`✓\n\n  Updated to ${latest}.`);
 
       // Re-run the exact same client/hook provisioning `troxy init` does,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.30.19",
+  "version": "1.30.21",
   "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.');
   }
 
@@ -566,11 +572,6 @@ 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

@@ -1,5 +1,9 @@
-import fs from 'fs';
-import { claudeCodeSettingsPath, prompt } from './init.js';
+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
@@ -11,9 +15,16 @@ import { claudeCodeSettingsPath, prompt } from './init.js';
 //   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)' },
-  { id: 'artifact', label: 'Artifacts (lets Claude publish pages to claude.ai)' },
+  { 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) {
@@ -54,16 +65,50 @@ export function printToolsStatus(file = claudeCodeSettingsPath()) {
   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 ✓`); }
+/** 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

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { TOOLS, toolIsOff, setToolOff } from '../slim.js';
+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.
@@ -40,4 +40,17 @@ describe('troxy slim', () => {
   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'))], []);
+  });
 });