troxy-cli 1.29.16 → 1.29.17

package/bin/troxy.js

@@ -127,6 +127,26 @@ switch (command) {
     process.exit(1);
   }
 
+  // ── Token-efficiency instructions in AGENTS.md (opt-in at init) ────────
+  case 'concise': {
+    const { maybeEnableConciseInstructions, removeConciseInstructions, conciseInstructionsConfigured } = await import('../src/init.js');
+    const dir = process.cwd();
+    if (sub === 'enable') { await maybeEnableConciseInstructions(true, dir); break; }
+    if (sub === 'disable') {
+      const removed = removeConciseInstructions(dir);
+      console.log(removed ? '\n  Removed ✓\n' : '\n  Not enabled in this project.\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');
+      break;
+    }
+    console.error(`  Unknown: troxy concise ${sub}. Try: status, enable, disable\n`);
+    process.exit(1);
+  }
+
   // ── Auth ──────────────────────────────────────────────────────
   case 'login':
     await runLogin(flags);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.16",
+  "version": "1.29.17",
   "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/init.js

@@ -81,7 +81,7 @@ export async function refreshHostedInstructions(key) {
   return true;
 }
 
-export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null) {
+export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null, conciseOptIn = null) {
   const platform = process.platform;
   const { detected, hasOpenClaw, hasClaude, none } = detectMcpClients();
 
@@ -163,6 +163,13 @@ export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null)
     console.log('\n  Restart your MCP client to activate Troxy.');
   }
 
+  // Own opt-in, outside the client-detection if/else above: AGENTS.md is a
+  // cross-tool convention, not tied to which specific MCP client got patched.
+  // Idempotent (conciseInstructionsConfigured short-circuits), so it's safe
+  // to run on every reprovision - fresh init AND `troxy update`/rotate-key -
+  // not just the first-ever connect, without re-prompting once it's set.
+  await maybeEnableConciseInstructions(conciseOptIn, process.cwd());
+
   console.log('\n  Setting up background service...');
   const viaEphemeralNpx = ranViaEphemeralNpx();
   try {
@@ -195,6 +202,23 @@ export async function reprovisionKeyConsumers(key, agentName, proxyOptIn = null)
 const AGENTS_START = '<!-- troxy:start -->';
 const AGENTS_END   = '<!-- troxy:end -->';
 
+// A separate marker pair, not a section inside AGENTS_START/END: the security
+// checkpoint block above is load-bearing (Troxy doesn't function without it)
+// and always written. Concise instructions are a style preference the user
+// opts into separately - same file, independently addable/removable without
+// touching or re-flowing the checkpoint block.
+const CONCISE_START = '<!-- troxy:concise:start -->';
+const CONCISE_END   = '<!-- troxy:concise:end -->';
+
+const CONCISE_INSTRUCTIONS = `## Style (via Troxy)
+
+- Read existing files before writing. Don't re-read unless changed.
+- Thorough in reasoning, concise in output.
+- Skip files over 100KB unless required.
+- No sycophantic openers or closing fluff.
+- No emojis or em-dashes.
+- Do not guess APIs, versions, flags, commit SHAs, or package names. Verify by reading code or docs before asserting.`;
+
 // The endpoint deliberately does not echo the caller's key back, so the live
 // key is substituted here, on the machine that already has it. Split/join
 // rather than a regex because a key is user-controlled input and would other-
@@ -242,17 +266,19 @@ async function printHostedAgentSetup(key) {
 
 // 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.
-export function writeAgentsFile(dir, text) {
+// 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');
-  const block = `${AGENTS_START}\n${text}\n${AGENTS_END}`;
+  const block = `${startMarker}\n${text}\n${endMarker}`;
   let existing = '';
   try { existing = fs.readFileSync(file, 'utf8'); } catch {}
 
   let next;
-  if (existing.includes(AGENTS_START) && existing.includes(AGENTS_END)) {
-    const head = existing.slice(0, existing.indexOf(AGENTS_START));
-    const tail = existing.slice(existing.indexOf(AGENTS_END) + AGENTS_END.length);
+  if (existing.includes(startMarker) && existing.includes(endMarker)) {
+    const head = existing.slice(0, existing.indexOf(startMarker));
+    const tail = existing.slice(existing.indexOf(endMarker) + endMarker.length);
     next = head + block + tail;
   } else if (existing.trim()) {
     next = existing.replace(/\s*$/, '') + '\n\n' + block + '\n';
@@ -263,6 +289,53 @@ export function writeAgentsFile(dir, text) {
   return file;
 }
 
+export function conciseInstructionsConfigured(dir) {
+  try {
+    const text = fs.readFileSync(path.join(dir, 'AGENTS.md'), 'utf8');
+    return text.includes(CONCISE_START) && text.includes(CONCISE_END);
+  } catch { return false; }
+}
+
+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;
+}
+
+// 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 async function maybeEnableConciseInstructions(conciseOptIn, dir) {
+  if (conciseInstructionsConfigured(dir)) return;
+
+  let enable;
+  if (conciseOptIn !== null) {
+    enable = conciseOptIn;
+  } else if (!process.stdin.isTTY) {
+    enable = 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);
+  }
+
+  if (!enable) return;
+  const file = writeAgentsFile(dir, CONCISE_INSTRUCTIONS, CONCISE_START, CONCISE_END);
+  console.log(`  Added token-efficiency instructions to ${file}`);
+}
+
 export function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
@@ -317,10 +390,14 @@ const MCP_CLIENTS = [
   },
 ];
 
-export async function runInit({ key, name, proxy } = {}) {
+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);
   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');
@@ -381,7 +458,7 @@ export async function runInit({ key, name, proxy } = {}) {
     // Non-fatal: the daemon's own heartbeat will retry this later.
   }
 
-  await reprovisionKeyConsumers(key, agentName, proxyOptIn);
+  await reprovisionKeyConsumers(key, agentName, proxyOptIn, conciseOptIn);
 
   // 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.

package/src/tests/tool_detect.test.js

@@ -269,7 +269,7 @@ describe('wiring: api.js / bin/troxy.js / init.js', () => {
   });
 
   it('runInit calls tool detection after reprovisionKeyConsumers, wrapped so a scan failure never blocks init', () => {
-    const reprovisionIdx = initSrc.indexOf('reprovisionKeyConsumers(key, agentName, proxyOptIn)');
+    const reprovisionIdx = initSrc.indexOf('reprovisionKeyConsumers(key, agentName, proxyOptIn, conciseOptIn)');
     const toolIdx = initSrc.indexOf('runToolDetection');
     assert.ok(reprovisionIdx !== -1, 'reprovisionKeyConsumers call not found in init.js');
     assert.ok(toolIdx !== -1, 'runToolDetection not wired into runInit');