troxy-cli 1.29.1 → 1.29.3

package/README.md

@@ -94,6 +94,12 @@ prediction, and the dashboard marks that agent's figures as unverified.
 - Paste the code into the terminal
 - Stores the JWT locally for 12 hours
 
+Without a real terminal attached (a script, CI, an agent's own shell), the
+masked prompt is skipped in favor of a plain line read from stdin - it never
+crashes for lack of a TTY. There's no flag to pass the code directly: the
+code the browser shows is only valid against this run's own session, so it
+has to come back through this same process, e.g. `troxy login < code.txt`.
+
 ## Stack
 
 - Node.js 18+ (ESM)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.1",
+  "version": "1.29.3",
   "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/auth.js

@@ -95,6 +95,44 @@ function _openBrowser(url) {
   }
 }
 
+// Which strategy resolves the login code, given whether stdin is a TTY.
+// Exported so this decision is unit-testable without a real terminal: the
+// raw-mode branch itself needs a real TTY and can't be, but which branch
+// gets picked is exactly the logic that used to crash with no TTY at all
+// (setRawMode is not a function on a pipe/non-interactive stdin - found live
+// by another Claude instance running in a non-interactive shell). No --code
+// flag: the code the browser shows is minted for, and only valid against,
+// this specific run's own session_id (auth.py's handle_cli_authorize binds
+// cli_code to session_id server-side, 5-minute TTL) - a flag read before a
+// fresh cliStart() would always redeem a stale session and 401.
+export function _codeInputStrategy(isTTY) {
+  return isTTY ? 'raw-tty' : 'line-read';
+}
+
+// A plain, non-masked line read for the no-TTY fallback - deliberately not
+// init.js's shared prompt(), which leaves its Promise permanently unresolved
+// if the input stream closes (EOF) before an answer, a real Node readline
+// quirk: init.js's own callers are all isTTY-guarded already, so a live human
+// terminal never hits it, but a no-TTY `troxy login` (a pipe with nothing
+// written to it, or none at all) hits EOF immediately and is exactly this
+// fallback's whole reason to exist - it must resolve either way, so the
+// existing "No code entered" handling below still runs instead of the
+// process just going quiet with no explanation and exit code 0.
+function _readCodeLine(question) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    let answered = false;
+    rl.question(question, ans => {
+      answered = true;
+      rl.close();
+      resolve(ans.trim());
+    });
+    rl.on('close', () => {
+      if (!answered) resolve('');
+    });
+  });
+}
+
 /** Device-code login flow — opens browser, user copies code back to CLI. */
 export async function runLogin() {
   // 1. Start a CLI auth session
@@ -118,41 +156,51 @@ export async function runLogin() {
     _openBrowser(session.url);
   }
 
-  // 3. Prompt for the code shown in the browser (masked like a password,
-  //    one bullet per char so the terminal doesn't look frozen)
-  const code = await new Promise(resolve => {
-    const rl = readline.createInterface({ input: process.stdin, output: null });
-    process.stdout.write('  Paste the code from your browser: ');
-    let buf = '';
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
-    const onData = chunk => {
-      for (const ch of chunk) {
-        if (ch === '\r' || ch === '\n') {
-          process.stdin.setRawMode(false);
-          process.stdin.pause();
-          process.stdin.removeListener('data', onData);
-          rl.close();
-          process.stdout.write('\n');
-          resolve(buf.trim());
-          return;
-        } else if (ch === '\u0003') { // Ctrl-C
-          process.stdout.write('\n');
-          process.exit(0);
-        } else if (ch === '\u007f' || ch === '\b') { // backspace
-          if (buf.length > 0) {
-            buf = buf.slice(0, -1);
-            process.stdout.write('\b \b');
+  // 3. Resolve the code shown in the browser. A real TTY gets the masked
+  //    raw-mode prompt (one bullet per char so the terminal doesn't look
+  //    frozen); anything else (a script, CI, an agent's own shell) falls
+  //    back to a plain line read (_readCodeLine below) - process.stdin.
+  //    setRawMode is not a function at all without a real TTY, so it must
+  //    never run unguarded (it used to, and crashed uncaught).
+  const strategy = _codeInputStrategy(process.stdin.isTTY);
+  let code;
+  if (strategy === 'line-read') {
+    code = await _readCodeLine('  Paste the code from your browser: ');
+  } else {
+    code = await new Promise(resolve => {
+      const rl = readline.createInterface({ input: process.stdin, output: null });
+      process.stdout.write('  Paste the code from your browser: ');
+      let buf = '';
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding('utf8');
+      const onData = chunk => {
+        for (const ch of chunk) {
+          if (ch === '\r' || ch === '\n') {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.removeListener('data', onData);
+            rl.close();
+            process.stdout.write('\n');
+            resolve(buf.trim());
+            return;
+          } else if (ch === '\u0003') { // Ctrl-C
+            process.stdout.write('\n');
+            process.exit(0);
+          } else if (ch === '\u007f' || ch === '\b') { // backspace
+            if (buf.length > 0) {
+              buf = buf.slice(0, -1);
+              process.stdout.write('\b \b');
+            }
+          } else if (ch >= ' ') {
+            buf += ch;
+            process.stdout.write('•');
           }
-        } else if (ch >= ' ') {
-          buf += ch;
-          process.stdout.write('•');
         }
-      }
-    };
-    process.stdin.on('data', onData);
-  });
+      };
+      process.stdin.on('data', onData);
+    });
+  }
 
   if (!code) {
     console.error('\n  No code entered. Run troxy login to try again.\n');

package/src/hook-report.js

@@ -42,6 +42,11 @@ export function extractUsage(entry) {
     // dollar math server-side from the model id; this file only sums what
     // the transcript says was used.
     tokens: inputTokens + outputTokens + cacheCreation + cacheRead,
+    // Reply-only portion of the total above - sent alongside actual_tokens,
+    // never in place of it (server still bills off the combined total; this
+    // is purely so the activity log can show "X tokens (Y reply)" instead
+    // of one opaque combined number - Gilad, 2026-09-04).
+    outputTokens,
     // Lives on the transcript ENTRY itself, not inside message.usage -
     // confirmed live 2026-09-03 against a real session file (values seen:
     // 'high', 'max'). Whatever string Claude Code actually used, passed
@@ -128,7 +133,11 @@ export function usageForCurrentTurn(transcriptPath) {
   if (seen.size === 0) return null;
 
   let totalTokens = 0;
-  for (const u of seen.values()) totalTokens += u.tokens;
+  let totalOutputTokens = 0;
+  for (const u of seen.values()) {
+    totalTokens += u.tokens;
+    totalOutputTokens += u.outputTokens || 0;
+  }
 
   // turn_key: dedups a hook that fires twice for the same turn (a retry,
   // a Claude Code internal replay) against a repeat POST for the same
@@ -151,8 +160,8 @@ export function usageForCurrentTurn(transcriptPath) {
   const contentExcerpt = replyText ? replyText.slice(0, MAX_EXCERPT_LEN) : null;
 
   return {
-    tokens: totalTokens, model: lastModel, effort: lastEffort, toolUseBlocksSoFar,
-    turnKey, contentExcerpt,
+    tokens: totalTokens, outputTokens: totalOutputTokens, model: lastModel,
+    effort: lastEffort, toolUseBlocksSoFar, turnKey, contentExcerpt,
   };
 }
 
@@ -202,6 +211,10 @@ export async function runHookReport() {
     const turnKey = sessionId ? `${sessionId}:${usage.turnKey}` : null;
 
     const body = { model: usage.model, actual_tokens: usage.tokens, turn_key: turnKey };
+    // Additive only - the backend already treats a missing/invalid value as
+    // "no breakdown available" and falls back to the plain total, so it's
+    // safe to just omit this rather than validate it client-side too.
+    if (usage.outputTokens > 0) body.actual_output_tokens = usage.outputTokens;
     // content_excerpt is optional and additive - the backend classifies it
     // if present, samples/rate-limits on its own, and silently skips when
     // it isn't. Sending it is not required for the usage report itself to

package/src/tests/auth.test.js

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert';
 
-import { isOpenableUrl } from '../auth.js';
+import { isOpenableUrl, _codeInputStrategy } from '../auth.js';
 
 test('isOpenableUrl accepts plain https and rejects everything else (H4)', () => {
   assert.equal(isOpenableUrl('https://dash.troxy.io/cli?code=abc'), true);
@@ -25,3 +25,14 @@ test('isOpenableUrl accepts plain https and rejects everything else (H4)', () =>
     assert.equal(isOpenableUrl(bad), false, `should reject: ${String(bad)}`);
   }
 });
+
+test('_codeInputStrategy: a real TTY gets the masked raw-mode prompt', () => {
+  assert.equal(_codeInputStrategy(true), 'raw-tty');
+});
+
+test('_codeInputStrategy: no TTY falls back to a plain line read, never raw mode ' +
+     '(regression: process.stdin.setRawMode is not a function without a real TTY - ' +
+     'used to crash `troxy login` outright for a script, CI, or an agent\'s own shell)', () => {
+  assert.equal(_codeInputStrategy(false), 'line-read');
+  assert.equal(_codeInputStrategy(undefined), 'line-read');
+});

package/src/tests/hook-report.test.js

@@ -59,8 +59,9 @@ describe('extractUsage', () => {
       },
     };
     const result = extractUsage(entry);
-    assert.deepEqual(Object.keys(result).sort(), ['effort', 'messageId', 'model', 'tokens']);
+    assert.deepEqual(Object.keys(result).sort(), ['effort', 'messageId', 'model', 'outputTokens', 'tokens']);
     assert.equal(result.effort, 'high');
+    assert.equal(result.outputTokens, 5);
     assert.ok(!JSON.stringify(result).includes('actual conversation'));
   });
 
@@ -108,6 +109,20 @@ describe('usageForCurrentTurn', () => {
     assert.equal(result.tokens, 10 + 20 + 5 + 8);
   });
 
+  it('sums outputTokens (reply-only) alongside tokens, same dedup-by-message-id rule', () => {
+    // Same fixture as the two-real-model-calls test above - outputTokens must
+    // dedup identically (20 + 8, not 20+20+8) since it comes off the same
+    // per-message.id `seen` map as the combined total.
+    writeLines([
+      { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } },
+      assistantLine('msg_1', { input_tokens: 10, output_tokens: 20 }),
+      assistantLine('msg_1', { input_tokens: 10, output_tokens: 20 }),
+      assistantLine('msg_2', { input_tokens: 5, output_tokens: 8 }),
+    ]);
+    const result = usageForCurrentTurn(transcriptPath());
+    assert.equal(result.outputTokens, 20 + 8, 'reply-only total did not dedup by message.id like tokens does');
+  });
+
   it('only looks back to the last user-authored line, not the whole session', () => {
     writeLines([
       { type: 'user', message: { content: [{ type: 'text', text: 'first turn' }] } },