pennyrouter 0.3.46 → 0.3.48

package/standalone/remote/rc_tools.py

@@ -0,0 +1,171 @@
+"""Remote file-tool approval probe confined to a disposable test folder.
+
+Only Read and Edit are available; every call asks the phone. No shell, MCP,
+permission-mode changes, or arbitrary control commands are forwarded.
+"""
+
+import argparse
+import asyncio
+import copy
+from pathlib import Path
+import tempfile
+
+import httpx
+
+from rc_echo import EchoWorker, read_login
+from rc_penny import PennyClaude, PennyWorker, read_profile
+
+
+def confined_input(cwd, request, tool_input):
+    if request.get("tool_name") not in {"Read", "Edit"} or not isinstance(tool_input, dict):
+        return False
+    path = tool_input.get("file_path")
+    if not isinstance(path, str) or not path:
+        return False
+    root = Path(cwd).resolve()
+    target = Path(path)
+    if not target.is_absolute():
+        target = root / target
+    try:
+        return target.resolve().is_relative_to(root) and target.resolve() != root
+    except (OSError, ValueError):
+        return False
+
+
+class ToolsWorker(PennyWorker):
+    def __init__(self, client, oauth, profile, model, cwd):
+        super().__init__(client, oauth, profile, model, cwd)
+        self.title = "Penny file approvals test"
+        self.cwd = cwd
+        self.tools = ["Read", "Edit"]
+        self.claude = PennyClaude(profile, model, self.local_session, cwd, self.permission)
+        self.pending_permissions = {}
+        self.permission_futures = {}
+        self.inbox = asyncio.Queue(maxsize=10)
+        self.queued_ids = set()
+        self.active_turn = False
+        self.disconnect_after_turns = 0
+
+    async def permission(self, event):
+        request = event.get("request", {})
+        denied = {"behavior": "deny", "message": "Only file operations inside this test folder are permitted."}
+        if request.get("subtype") != "can_use_tool" or not confined_input(self.cwd, request, request.get("input")):
+            return denied
+        request_id = event["request_id"]
+        future = asyncio.get_running_loop().create_future()
+        saved = copy.deepcopy(event)
+        self.pending_permissions[request_id] = saved
+        self.permission_futures[request_id] = future
+        print(f"Phone approval needed: {request['tool_name']}", flush=True)
+        try:
+            await self.events({**saved, "session_id": self.local_session, "uuid": self.payload("unused")["uuid"]})
+            async with asyncio.timeout(180):
+                decision = await future
+            if decision.get("behavior") == "allow":
+                tool_input = decision.get("updatedInput", request["input"])
+                if not confined_input(self.cwd, request, tool_input):
+                    return denied
+                # Accept one tool decision, never persistent permission updates.
+                return {"behavior": "allow", "updatedInput": tool_input}
+            return {"behavior": "deny", "message": "The user denied this tool from the phone."}
+        except TimeoutError:
+            return {"behavior": "deny", "message": "Phone approval timed out."}
+        finally:
+            self.pending_permissions.pop(request_id, None)
+            self.permission_futures.pop(request_id, None)
+
+    async def handle(self, envelope):
+        event_id = envelope.get("event_id")
+        if not event_id or event_id in self.seen or event_id in self.queued_ids:
+            return
+        payload = envelope.get("payload", {})
+        kind = payload.get("type")
+        if kind == "user":
+            self.queued_ids.add(event_id)
+            await self.inbox.put(envelope)
+            return
+        if kind == "control_response":
+            await self.delivery(event_id, "received")
+            response = payload.get("response", {})
+            request_id = response.get("request_id")
+            future = self.permission_futures.get(request_id)
+            if future is not None and not future.done():
+                decision = response.get("response", {}) if response.get("subtype") == "success" else {}
+                future.set_result(decision)
+                print(f"Phone decision: {decision.get('behavior', 'deny')}", flush=True)
+            else:
+                print("Ignored unmatched permission response", flush=True)
+            await self.delivery(event_id, "processed")
+            self.seen.add(event_id)
+            return
+        if kind == "control_request" and payload.get("request", {}).get("subtype") == "interrupt":
+            await self.delivery(event_id, "received")
+            for future in self.permission_futures.values():
+                if not future.done():
+                    future.set_result({"behavior": "deny"})
+            if self.active_turn:
+                await self.claude.interrupt(payload["request_id"])
+            else:
+                await self.events(self.payload("control_response", response={
+                    "subtype": "success", "request_id": payload.get("request_id"), "response": {}}))
+            await self.delivery(event_id, "processed")
+            self.seen.add(event_id)
+            return
+        await EchoWorker.handle(self, envelope)
+
+    async def process_turns(self):
+        while not self.stopping:
+            envelope = await self.inbox.get()
+            self.active_turn = True
+            try:
+                await EchoWorker.handle(self, envelope)
+                if self.disconnect_after_turns and self.replies == self.disconnect_after_turns:
+                    self.force_reconnect.set()
+            finally:
+                self.active_turn = False
+                self.queued_ids.discard(envelope["event_id"])
+                self.inbox.task_done()
+
+
+async def run(seconds, effort="low", disconnect_after_turns=0):
+    profile, model = read_profile()
+    async with httpx.AsyncClient(headers={"anthropic-version": "2023-06-01",
+        "User-Agent": "penny-rc-file-probe/0.1"}, timeout=httpx.Timeout(30, read=None), trust_env=False) as client:
+        response = await client.get(profile["gateway_base_url"].rstrip("/") + "/health", timeout=5)
+        if response.status_code != 200:
+            raise RuntimeError("Configured Penny gateway is not healthy.")
+        with tempfile.TemporaryDirectory(prefix="penny-rc-files-") as cwd:
+            (Path(cwd) / "note.txt").write_text("original test content\n")
+            worker = ToolsWorker(client, read_login(), profile, model, cwd)
+            worker.claude.effort = effort
+            worker.disconnect_after_turns = disconnect_after_turns
+            tasks = []
+            try:
+                await worker.start()
+                print("TEST FOLDER " + cwd, flush=True)
+                tasks = [asyncio.create_task(worker.listen()), asyncio.create_task(worker.heartbeat()),
+                         asyncio.create_task(worker.process_turns())]
+                done, _ = await asyncio.wait(tasks, timeout=seconds, return_when=asyncio.FIRST_COMPLETED)
+                for task in done:
+                    task.result()
+            finally:
+                for task in tasks:
+                    task.cancel()
+                await asyncio.gather(*tasks, return_exceptions=True)
+                await worker.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--seconds", type=int, default=900)
+    parser.add_argument("--effort", choices=["low", "medium", "high"], default="low")
+    parser.add_argument("--disconnect-after-turns", type=int, default=0,
+                        help="Simulate one three-second stream drop after this many completed turns")
+    args = parser.parse_args()
+    try:
+        asyncio.run(run(max(1, min(args.seconds, 1800)), args.effort, args.disconnect_after_turns))
+    except KeyboardInterrupt:
+        pass
+    except (RuntimeError, TimeoutError, httpx.HTTPError):
+        print("File approval probe stopped after a protocol, gateway, or timeout failure.")
+        raise SystemExit(1)

package/standalone/web-demo/claude-meter.mjs

@@ -84,6 +84,10 @@ function emptyTotals() {
     fresh_input: 0, output: 0, reasoning_output: 0, total: 0, cost: 0 };
 }
 
+function emptySideCalls() {
+  return { count: 0, cost: 0, cache_read: 0, cache_write: 0, fresh_input: 0, output: 0, total: 0, models: {} };
+}
+
 export class ClaudeMeter {
   constructor({ sessionId, cwd, side, role, label, variant, pricingProfile = 'standard', options = {} }) {
     this.sessionId = sessionId;
@@ -106,7 +110,7 @@ export class ClaudeMeter {
     this.transcriptPrints = new Map();
     this.chargedPrints = new Map();
     this.telemetry = new Map();
-    this.sideCalls = { count: 0, cost: 0, models: {} };
+    this.sideCalls = emptySideCalls();
     this.localReplyIds = new Set();
   }
 
@@ -162,6 +166,11 @@ export class ClaudeMeter {
       byModel.calls += 1; byModel.tokens += total; byModel.cost += cost;
       this.sideCalls.count += 1;
       this.sideCalls.cost += cost;
+      this.sideCalls.cache_read += read;
+      this.sideCalls.cache_write += write;
+      this.sideCalls.fresh_input += input;
+      this.sideCalls.output += output;
+      this.sideCalls.total += total;
     }
   }
 
@@ -287,11 +296,17 @@ export class ClaudeMeter {
     } finally { await handle.close(); }
   }
 
+  // `totals` is everything billed; `main` leaves out the side calls.
   snapshot() {
+    const side = this.sideCalls;
+    const main = { ...this.totals, cache_read: this.totals.cache_read - side.cache_read,
+      cache_write: this.totals.cache_write - side.cache_write, write_5m: this.totals.write_5m - side.cache_write,
+      fresh_input: this.totals.fresh_input - side.fresh_input, output: this.totals.output - side.output,
+      total: this.totals.total - side.total, cost: this.totals.cost - side.cost };
     return { side: this.side, role: this.role, label: this.label, variant: this.variant, options: this.options,
       harness: 'claude-code', cwd: this.cwd, pricing_profile: this.pricingProfile, session_id: this.sessionId,
       transcript_path: this.transcriptPath, model: this.model, call_count: this.calls.length,
-      totals: { ...this.totals }, local_replies: this.localReplyIds.size,
+      totals: { ...this.totals }, main, local_replies: this.localReplyIds.size,
       side_calls: { ...this.sideCalls, models: structuredClone(this.sideCalls.models) } };
   }
 }
@@ -454,7 +469,7 @@ export function galleryReport(left, right, { environment, harnessVersions }) {
   const penny = sides.find((side) => side.role === 'PENNY');
   if (!native || !penny || native.harness !== penny.harness) return null;
   const side = (snapshot) => ({ model: snapshot.model, call_count: snapshot.call_count, totals: snapshot.totals,
-    side_calls: snapshot.side_calls || { count: 0, cost: 0, models: {} } });
+    side_calls: snapshot.side_calls || emptySideCalls() });
   return JSON.stringify({ version: 1, harness: native.harness,
     harness_version: harnessVersions?.[native.harness === 'codex' ? 'codex' : 'claude'] || '',
     environment, native: side(native), penny: side(penny), finished_at: new Date().toISOString() });

package/standalone/web-demo/compare.html

@@ -31,6 +31,7 @@
     .bar .sync-on { color: var(--accent); border-color: #547a50; background: var(--accent-wash); }
     .bar .sync-off { color: #a0a0aa; border-color: #62626d; background: #292930; }
     #delta { color: var(--accent); }
+    .pane header #delta { margin-left: auto; white-space: nowrap; }
     #versions { margin-left: auto; color: #92929c; font-size: 12px; }
     #status { color: #b8b8c3; }
     @media (max-width: 760px) { .bar { overflow-x: auto; } #versions { display: none; } }
@@ -84,7 +85,7 @@
     .meter .field.read strong { color: var(--accent); }
     .meter .field.write strong { color: var(--warn); }
     .meter .field.in strong, .meter .field.out strong { color: #75ec45; }
-    .meter .field.side { color: #77777e; }
+    .meter .field.main, .meter .field.side { color: #77777e; }
     .meter .wait { display: none; color: #77777e; }
     .meter.waiting .wait { display: block; }
     .meter.waiting .field { display: none; }
@@ -214,7 +215,6 @@
     <button id="finish" disabled>Finish comparison</button>
     <button id="download-logs" hidden>Download logs</button>
     <button id="add-to-gallery" disabled title="Finish this comparison and share it in the PennyRouter gallery">Add to gallery</button>
-    <span id="delta" aria-live="polite"></span>
     <span id="versions"></span>
     <span id="status">Connecting…</span>
   </div>
@@ -225,6 +225,7 @@
         <div class="file-list" id="left-file-list" hidden><p>HTML files the agent writes will appear here.</p></div></div>
       </header><div class="meter" id="left-meter"></div><div class="terminal" id="left"></div></section>
     <section class="pane" id="right-pane"><header><strong class="label" id="right-label">PENNY</strong><span class="chip" id="right-chip" hidden></span>
+      <span id="delta" aria-live="polite"></span>
       <div class="files" id="right-files"><button class="newest" id="right-newest" hidden></button>
         <button class="count" id="right-files-count" aria-expanded="false" aria-controls="right-file-list">No files</button>
         <div class="file-list" id="right-file-list" hidden><p>HTML files the agent writes will appear here.</p></div></div>
@@ -801,6 +802,9 @@
     // Same abbreviation as hud.py: 1.2k, 3.45M.
     const abbreviate = (value) => value >= 1_000_000 ? `${(value / 1_000_000).toFixed(2)}M`
       : value >= 1_000 ? `${(value / 1_000).toFixed(1)}k` : String(value);
+    // Cents alone would round a cheap side call to $0.00.
+    const dollars = (value) => `$${value.toLocaleString('en-US',
+      { minimumFractionDigits: value < 1 ? 4 : 2, maximumFractionDigits: value < 1 ? 4 : 2 })}`;
     const reducedMotion = matchMedia('(prefers-reduced-motion: reduce)');
     const meters = {};
     const buildMeter = (side) => {
@@ -812,15 +816,16 @@
       model.append(role, name);
       root.append(model);
       const amounts = {};
-      for (const label of ['read', 'write', 'in', 'out', 'total', 'side', 'cost']) {
-        const field = document.createElement('span'); field.className = `field ${label}`;
+      // Token rows count the main thread only. Background calls Claude Code makes outside the
+      // transcript (auto-mode reviewer, titles) show only as `side` cost; the last row is main + side.
+      for (const [key, label] of [['read', 'read'], ['write', 'write'], ['in', 'in'], ['out', 'out'],
+        ['total', 'total'], ['main', 'main'], ['side', 'side'], ['cost', 'total']]) {
+        const field = document.createElement('span'); field.className = `field ${key}`;
         field.append(document.createTextNode(`${label} `));
-        amounts[label] = document.createElement('strong');
-        field.append(amounts[label]);
+        amounts[key] = document.createElement('strong');
+        field.append(amounts[key]);
         root.append(field);
       }
-      // Background calls (auto-mode reviewer, titles) that Claude Code makes outside the transcript.
-      amounts.side.parentElement.hidden = true;
       // Zeros would read as a measurement; the pane has simply not seen a turn yet.
       const wait = document.createElement('span'); wait.className = 'wait'; wait.textContent = 'waiting for first turn';
       root.append(wait);
@@ -844,7 +849,7 @@
         amounts.out.textContent = abbreviate(rolled.output);
         amounts.total.textContent = abbreviate(rolled.cache_read + rolled.cache_write +
           rolled.fresh_input + rolled.output);
-        amounts.cost.textContent = `$${meter.cost.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+        amounts.cost.textContent = dollars(meter.cost);
         if (Object.keys(rolled).some((key) => rolled[key] !== meter.targets[key])) settled = false;
       }
       if (settled) lastFrame = 0;
@@ -853,15 +858,15 @@
     const showMeter = (snapshot) => {
       const meter = meters[snapshot.side] ||= buildMeter(snapshot.side);
       const { totals } = snapshot;
+      const main = snapshot.main || totals;
       meter.role.textContent = snapshot.label || snapshot.role;
       meter.name.textContent = (snapshot.model || 'waiting').split('/').pop();
-      meter.targets = { cache_read: totals.cache_read, cache_write: totals.cache_write,
-        fresh_input: totals.fresh_input, output: totals.output };
+      meter.targets = { cache_read: main.cache_read, cache_write: main.cache_write,
+        fresh_input: main.fresh_input, output: main.output };
       meter.cost = totals.cost;
       const side = snapshot.side_calls;
-      const sideField = meter.amounts.side.parentElement;
-      sideField.hidden = !side?.count;
-      if (side?.count) meter.amounts.side.textContent = `${side.count} · $${side.cost.toFixed(2)}`;
+      meter.amounts.main.textContent = dollars(main.cost);
+      meter.amounts.side.textContent = dollars(side?.cost || 0);
       meter.root.classList.add('has-data');
       meter.root.classList.toggle('waiting', !totals.total);
       if (!frameRequest) frameRequest = requestAnimationFrame(paintMeters);
@@ -870,8 +875,10 @@
       const native = meterSnapshots.left?.totals;
       const penny = meterSnapshots.right?.totals;
       if (!native || !penny) return;
+      const nativeMain = meterSnapshots.left.main || native;
+      const pennyMain = meterSnapshots.right.main || penny;
       const cost = native.cost ? (native.cost - penny.cost) / native.cost * 100 : 0;
-      const tokens = native.total ? (native.total - penny.total) / native.total * 100 : 0;
+      const tokens = nativeMain.total ? (nativeMain.total - pennyMain.total) / nativeMain.total * 100 : 0;
       $('delta').textContent =
         `${cost > 0 ? '-' : '+'}${Math.abs(cost).toFixed(0)}% cost  ${tokens > 0 ? '-' : '+'}${Math.abs(tokens).toFixed(0)}% tok`;
     };
@@ -1159,6 +1166,7 @@
         button.disabled = true;
         button.textContent = 'Submitted to gallery';
       }
+      $('publish').hidden = true;
     };
 
     // Messages common to both servers
@@ -1263,8 +1271,9 @@
         // ids), so the alias is what is sent; the label names the model it currently resolves to.
         claude: [['opus', 'Claude Opus 5.5'], ['sonnet', 'Claude Sonnet 5.5'], ['haiku', 'Claude Haiku 4.5'],
           ['fable', 'Claude Fable 5.1']],
-        codex: [['gpt-5.6-sol', 'GPT-5.6 Sol'], ['gpt-5.6-terra', 'GPT-5.6 Terra'], ['gpt-5.6-luna', 'GPT-5.6 Luna'],
-          ['gpt-5.5', 'GPT-5.5'], ['gpt-5.4', 'GPT-5.4'], ['gpt-5.4-mini', 'GPT-5.4 mini']],
+        codex: [['gpt-6.1-sol', 'GPT-6.1 Sol'], ['gpt-6-astra', 'GPT-6 Astra'], ['gpt-6-sol', 'GPT-6 Sol'],
+          ['gpt-6-luna', 'GPT-6 Luna'], ['gpt-5.6-sol', 'GPT-5.6 Sol'], ['gpt-5.6-terra', 'GPT-5.6 Terra'],
+          ['gpt-5.6-luna', 'GPT-5.6 Luna'], ['gpt-5.5', 'GPT-5.5']],
       };
       $('left-variant').value = config.defaultHarness;
       $('right-variant').value = `penny-${config.defaultHarness}`;

package/standalone/web-demo/server.mjs

@@ -170,7 +170,8 @@ function validateEnvironment(environment = {}) {
 const safeModel = /^[A-Za-z0-9._/-]{1,160}$/;
 
 async function validateConfig(config) {
-  const codexModels = ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'];
+  const codexModels = ['gpt-6.1-sol', 'gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-sol', 'gpt-5.6-terra',
+    'gpt-5.6-luna', 'gpt-5.5'];
   const claudeModels = ['opus', 'sonnet', 'haiku', 'fable'];
   if (!config || !variants.has(config.variant) || typeof config.cwd !== 'string' ||
       config.cwd.length > 4096 || typeof config.label !== 'string' || config.label.length > 80 ||