troxy-cli 1.29.17 → 1.29.19

package/bin/troxy.js

@@ -127,23 +127,36 @@ switch (command) {
     process.exit(1);
   }
 
-  // ── Token-efficiency instructions in AGENTS.md (opt-in at init) ────────
+  // ── Token-efficiency instructions in AGENTS.md / global CLAUDE.md ──────
+  // --project scopes enable/disable/status to just this directory's
+  // AGENTS.md; default (no flag) is the global ~/.claude/CLAUDE.md, matching
+  // what the init/update prompt now recommends by default.
   case 'concise': {
-    const { maybeEnableConciseInstructions, removeConciseInstructions, conciseInstructionsConfigured } = await import('../src/init.js');
+    const {
+      maybeEnableConciseInstructions, removeConciseInstructions, conciseInstructionsConfigured,
+      enableGlobalConciseInstructions, removeGlobalConciseInstructions, globalConciseConfigured,
+    } = await import('../src/init.js');
     const dir = process.cwd();
-    if (sub === 'enable') { await maybeEnableConciseInstructions(true, dir); break; }
+    const projectOnly = Boolean(flags.project);
+
+    if (sub === 'enable') {
+      if (projectOnly) { await maybeEnableConciseInstructions('project', dir); }
+      else { console.log(`\n  Added token-efficiency instructions to ${enableGlobalConciseInstructions()} (all projects)\n`); }
+      break;
+    }
     if (sub === 'disable') {
-      const removed = removeConciseInstructions(dir);
-      console.log(removed ? '\n  Removed ✓\n' : '\n  Not enabled in this project.\n');
+      const removed = projectOnly ? removeConciseInstructions(dir) : removeGlobalConciseInstructions();
+      console.log(removed ? '\n  Removed ✓\n' : `\n  Not enabled ${projectOnly ? 'in this project' : 'globally'}.\n`);
       break;
     }
     if (sub === 'status' || !sub) {
-      console.log(conciseInstructionsConfigured(dir)
-        ? '\n  Enabled in this project.\n'
-        : '\n  Not enabled in this project. Run "troxy concise enable" to add it.\n');
+      console.log('');
+      console.log(`  Global (~/.claude/CLAUDE.md): ${globalConciseConfigured() ? 'enabled' : 'not enabled'}`);
+      console.log(`  This project (./AGENTS.md):   ${conciseInstructionsConfigured(dir) ? 'enabled' : 'not enabled'}`);
+      console.log('');
       break;
     }
-    console.error(`  Unknown: troxy concise ${sub}. Try: status, enable, disable\n`);
+    console.error(`  Unknown: troxy concise ${sub}. Try: status, enable, disable (add --project to scope to this directory)\n`);
     process.exit(1);
   }
 
@@ -214,7 +227,7 @@ switch (command) {
 
     // Re-point every real consumer (MCP client configs, the background service) at the new
     // key BEFORE revoking the old one — otherwise every consumer, which holds the key via
-    // ENV rather than config.json, keeps presenting the now-revoked key and payment control
+    // ENV rather than config.json, keeps presenting the now-revoked key and policy enforcement
     // goes down until the user thinks to re-run init. (H6)
     await reprovisionKeyConsumers(newKey, existing.agentName || 'my-agent');
 
@@ -734,7 +747,7 @@ switch (command) {
   Everything else requires: troxy login
 
   MCP
-    troxy pause                        Pause this MCP (blocks all payments)
+    troxy pause                        Pause this MCP (blocks all checkpoints)
     troxy resume                       Resume this MCP
     troxy mcps list                    All MCPs in your account
     troxy mcps rename --name "x"       Rename this machine's MCP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.17",
+  "version": "1.29.19",
   "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": {
@@ -11,6 +11,7 @@
     "troxy": "bin/troxy.js"
   },
   "scripts": {
+    "preinstall": "node scripts/check-node.js",
     "test": "node --test src/tests/*.test.js"
   },
   "dependencies": {
@@ -30,7 +31,8 @@
   },
   "files": [
     "bin/",
-    "src/"
+    "src/",
+    "scripts/check-node.js"
   ],
   "keywords": [
     "mcp",

package/scripts/check-node.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+const major = parseInt(process.versions.node.split('.')[0], 10);
+if (major < 18) {
+  console.error(`\ntroxy-cli requires Node >=18, you have ${process.version}.\nInstall a newer Node (e.g. via nvm: https://github.com/nvm-sh/nvm) and retry.\n`);
+  process.exit(1);
+}

package/src/init.js

@@ -264,13 +264,18 @@ async function printHostedAgentSetup(key) {
   console.log('  Then follow it before you pay, email, log in, or delete anything.\n');
 }
 
-// Idempotent, and never clobbers instructions the user wrote themselves: the
-// Troxy section lives between markers, so re-running init (or rotate-key, which
-// changes the key inside the block) replaces only that span. Each marker pair
-// is independent - writing/removing one never touches another's span or
-// anything the user wrote outside all of them.
-export function writeAgentsFile(dir, text, startMarker = AGENTS_START, endMarker = AGENTS_END) {
-  const file = path.join(dir, 'AGENTS.md');
+// Claude Code's real, documented global instructions file - not the same
+// thing as a bare ~/AGENTS.md, which (per our own testing) a project working
+// directory does not walk up to. This is the one path that actually applies
+// everywhere, so it's the file the "all projects" option below writes to.
+function globalClaudeMdPath() {
+  return path.join(os.homedir(), '.claude', 'CLAUDE.md');
+}
+
+// Same merge algorithm as writeAgentsFile (marker-delimited, never clobbers
+// content outside its own span), generalized to any file path so both the
+// per-project AGENTS.md and the global CLAUDE.md can share it.
+function writeMarkedBlock(file, text, startMarker, endMarker) {
   const block = `${startMarker}\n${text}\n${endMarker}`;
   let existing = '';
   try { existing = fs.readFileSync(file, 'utf8'); } catch {}
@@ -285,55 +290,94 @@ export function writeAgentsFile(dir, text, startMarker = AGENTS_START, endMarker
   } else {
     next = block + '\n';
   }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, next);
   return file;
 }
 
-export function conciseInstructionsConfigured(dir) {
+function removeMarkedBlock(file, startMarker, endMarker) {
+  let existing;
+  try { existing = fs.readFileSync(file, 'utf8'); } catch { return false; }
+  if (!existing.includes(startMarker) || !existing.includes(endMarker)) return false;
+  const head = existing.slice(0, existing.indexOf(startMarker));
+  const tail = existing.slice(existing.indexOf(endMarker) + endMarker.length);
+  fs.writeFileSync(file, (head + tail).replace(/\n{3,}/g, '\n\n'));
+  return true;
+}
+
+function hasMarkedBlock(file, startMarker, endMarker) {
   try {
-    const text = fs.readFileSync(path.join(dir, 'AGENTS.md'), 'utf8');
-    return text.includes(CONCISE_START) && text.includes(CONCISE_END);
+    const text = fs.readFileSync(file, 'utf8');
+    return text.includes(startMarker) && text.includes(endMarker);
   } catch { return false; }
 }
 
+// Idempotent, and never clobbers instructions the user wrote themselves: the
+// Troxy section lives between markers, so re-running init (or rotate-key,
+// which changes the key inside the block) replaces only that span. Each
+// marker pair is independent - writing/removing one never touches another's
+// span or anything the user wrote outside all of them.
+export function writeAgentsFile(dir, text, startMarker = AGENTS_START, endMarker = AGENTS_END) {
+  return writeMarkedBlock(path.join(dir, 'AGENTS.md'), text, startMarker, endMarker);
+}
+
+export function conciseInstructionsConfigured(dir) {
+  return hasMarkedBlock(path.join(dir, 'AGENTS.md'), CONCISE_START, CONCISE_END);
+}
+
 export function removeConciseInstructions(dir) {
-  const file = path.join(dir, 'AGENTS.md');
-  let existing;
-  try { existing = fs.readFileSync(file, 'utf8'); } catch { return false; }
-  if (!existing.includes(CONCISE_START) || !existing.includes(CONCISE_END)) return false;
-  const head = existing.slice(0, existing.indexOf(CONCISE_START));
-  const tail = existing.slice(existing.indexOf(CONCISE_END) + CONCISE_END.length);
-  fs.writeFileSync(file, (head + tail).replace(/\n{3,}/g, '\n\n'));
-  return true;
+  return removeMarkedBlock(path.join(dir, 'AGENTS.md'), CONCISE_START, CONCISE_END);
+}
+
+export function globalConciseConfigured() {
+  return hasMarkedBlock(globalClaudeMdPath(), CONCISE_START, CONCISE_END);
 }
 
-// Mirrors maybeEnableTroxyInterception's opt-in shape exactly: explain what
-// and the real trade-off before asking, respect a --concise flag for
-// non-interactive runs (no --no-concise - this parser doesn't auto-negate,
-// see --no-confirm, and --proxy has no negation flag either; omit the flag
-// to get the default), never prompt if stdin isn't a TTY, and skip asking
-// again once it's already configured.
+export function removeGlobalConciseInstructions() {
+  return removeMarkedBlock(globalClaudeMdPath(), CONCISE_START, CONCISE_END);
+}
+
+export function enableGlobalConciseInstructions() {
+  return writeMarkedBlock(globalClaudeMdPath(), CONCISE_INSTRUCTIONS, CONCISE_START, CONCISE_END);
+}
+
+// conciseOptIn is one of: 'global', 'project', false (explicitly skip), or
+// null (ask interactively). Global first, and recommended by default in the
+// prompt: it's the one location Claude Code always reads regardless of which
+// directory you're in, so it structurally can't land in the wrong place the
+// way the project-scoped option did on its first real run. Never claims a
+// specific percentage in the copy below - the one number we measured for
+// this came from a flawed test (subagents don't reliably load these files
+// the way a real session does) and shouldn't be repeated as fact.
 export async function maybeEnableConciseInstructions(conciseOptIn, dir) {
-  if (conciseInstructionsConfigured(dir)) return;
+  if (globalConciseConfigured() || conciseInstructionsConfigured(dir)) return;
 
-  let enable;
-  if (conciseOptIn !== null) {
-    enable = conciseOptIn;
+  let choice;
+  if (conciseOptIn === 'global' || conciseOptIn === 'project' || conciseOptIn === false) {
+    choice = conciseOptIn;
   } else if (!process.stdin.isTTY) {
-    enable = false;
+    choice = false;
   } else {
-    console.log('\n  Add token-efficiency instructions to this project\'s AGENTS.md?');
-    console.log('  Makes Claude Code\'s responses more concise - in one real test, ~30%');
-    console.log('  shorter output on the same task. Trade-off: less verbose can mean');
-    console.log('  less detail. Only touches this project.');
-    console.log('  Remove any time with: troxy concise disable');
-    const ans = await prompt('  Enable? (y/N): ');
-    enable = /^y(es)?$/i.test(ans);
+    console.log('\n  Add token-efficiency instructions to make Claude Code\'s responses');
+    console.log('  more concise? Trade-off: less verbose can mean less detail.');
+    console.log('');
+    console.log('    [G] All projects (recommended) - writes once to ~/.claude/CLAUDE.md');
+    console.log('    [P] This project only          - writes to ./AGENTS.md');
+    console.log('    [N] Skip');
+    console.log('');
+    console.log('  Remove any time with: troxy concise disable (add --project for just this one)');
+    const ans = (await prompt('  Choice (G/p/n): ')).toLowerCase();
+    choice = ans === 'p' ? 'project' : ans === 'n' ? false : 'global';
   }
 
-  if (!enable) return;
-  const file = writeAgentsFile(dir, CONCISE_INSTRUCTIONS, CONCISE_START, CONCISE_END);
-  console.log(`  Added token-efficiency instructions to ${file}`);
+  if (choice === false) return;
+  if (choice === 'global') {
+    const file = enableGlobalConciseInstructions();
+    console.log(`  Added token-efficiency instructions to ${file} (all projects)`);
+  } else {
+    const file = writeAgentsFile(dir, CONCISE_INSTRUCTIONS, CONCISE_START, CONCISE_END);
+    console.log(`  Added token-efficiency instructions to ${file} (this project)`);
+  }
 }
 
 export function prompt(question) {
@@ -394,10 +438,16 @@ export async function runInit({ key, name, proxy, concise } = {}) {
   // undefined (flag never passed) -> null, so reprovisionKeyConsumers can
   // tell "not decided, ask interactively" apart from an explicit --proxy.
   const proxyOptIn = proxy === undefined ? null : Boolean(proxy);
-  // Same null-means-ask-interactively shape as proxyOptIn. --concise is
-  // presence-only, like --proxy - neither has a negation flag in this CLI;
-  // omit it to get the default (interactive ask, or off when non-interactive).
-  const conciseOptIn = concise === undefined ? null : Boolean(concise);
+  // Same null-means-ask-interactively shape as proxyOptIn, but three-valued:
+  // --concise alone (bare flag, parses as boolean true) means the
+  // recommended default, 'global'; --concise project or --concise global
+  // pick explicitly; --concise false skips. Omit the flag entirely for the
+  // default (interactive ask, or off when non-interactive).
+  const conciseOptIn =
+    concise === undefined ? null :
+    concise === true ? 'global' :
+    concise === 'false' ? false :
+    concise;
   if (!key || !key.startsWith('txy-')) {
     console.error('\n  Error: --key is required and must start with txy-');
     console.error('  Usage: npx troxy-cli init --key txy-...\n');