@moxxy/sdk 0.14.2 → 0.14.4

package/src/mode.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { migrateModeName } from './mode.js';
+
+describe('migrateModeName', () => {
+  it('maps every legacy mode name to its current target', () => {
+    expect(migrateModeName('tool-use')).toBe('default');
+    expect(migrateModeName('deep-research')).toBe('research');
+    expect(migrateModeName('plan-execute')).toBe('default');
+    expect(migrateModeName('bmad')).toBe('default');
+    expect(migrateModeName('developer')).toBe('default');
+  });
+
+  it('passes a current/unknown name through unchanged (identity)', () => {
+    expect(migrateModeName('default')).toBe('default');
+    expect(migrateModeName('goal')).toBe('goal');
+    expect(migrateModeName('research')).toBe('research');
+    expect(migrateModeName('some-future-mode')).toBe('some-future-mode');
+    expect(migrateModeName('')).toBe('');
+  });
+});

package/src/token-accounting.test.ts

@@ -4,6 +4,7 @@ import {
   asEventId,
   asSessionId,
   asTurnId,
+  summarizeSessionTokensFromEvents,
   summarizeTokensByModel,
   type ModelUsageTotals,
   type MoxxyEvent,
@@ -78,6 +79,95 @@ describe('summarizeTokensByModel', () => {
   });
 });
 
+describe('summarizeSessionTokensFromEvents — cost fold', () => {
+  it('counts only responses that reported usage', () => {
+    const s = summarizeSessionTokensFromEvents([
+      resp(0, {}), // no token fields → not counted
+      resp(1, { inputTokens: 100, outputTokens: 10 }),
+      resp(2, { cacheReadTokens: 50 }),
+    ]);
+    expect(s.calls).toBe(2);
+    expect(s.totalInput).toBe(100);
+    expect(s.totalCacheRead).toBe(50);
+    expect(s.totalOutput).toBe(10);
+    expect(s.totalPrompt).toBe(150);
+  });
+
+  it('applies the read 0.1x / write 1.25x billing multipliers', () => {
+    const s = summarizeSessionTokensFromEvents([
+      resp(0, { inputTokens: 100, cacheReadTokens: 1000, cacheCreationTokens: 200 }),
+    ]);
+    // totalPrompt = 100 + 1000 + 200 = 1300 (== uncachedInputEq)
+    expect(s.totalPrompt).toBe(1300);
+    expect(s.uncachedInputEq).toBe(1300);
+    // billedInputEq = 100 + 1000*0.1 + 200*1.25 = 100 + 100 + 250 = 450
+    expect(s.billedInputEq).toBeCloseTo(450, 6);
+    expect(s.cacheHitRate).toBeCloseTo(1000 / 1300, 6);
+    expect(s.savedRatio).toBeCloseTo(1 - 450 / 1300, 6);
+  });
+
+  it('guards divide-by-zero when no prompt tokens were reported', () => {
+    const s = summarizeSessionTokensFromEvents([resp(0, { outputTokens: 5 })]);
+    expect(s.totalPrompt).toBe(0);
+    expect(s.cacheHitRate).toBe(0);
+    expect(s.savedRatio).toBe(0);
+    // No writes → cache considered effective (deliberately-off cache never alarms).
+    expect(s.cacheEffective).toBe(true);
+  });
+
+  it('reports cacheEffective=true for a healthy cache (high read ratio)', () => {
+    const events = Array.from({ length: 6 }, (_, i) =>
+      resp(i, { inputTokens: 10, cacheReadTokens: 1000, cacheCreationTokens: 100 }),
+    );
+    const s = summarizeSessionTokensFromEvents(events);
+    expect(s.calls).toBe(6);
+    expect(s.cacheHitRate).toBeGreaterThan(0.05);
+    expect(s.savedRatio).toBeGreaterThan(0);
+    expect(s.cacheEffective).toBe(true);
+  });
+
+  it('trips cacheEffective=false on broken cache: >=5 calls, writes>0, near-zero reads', () => {
+    // 5 calls each writing cache but never reading it → cacheHitRate 0.
+    const events = Array.from({ length: 5 }, (_, i) =>
+      resp(i, { inputTokens: 100, cacheCreationTokens: 500, cacheReadTokens: 0 }),
+    );
+    const s = summarizeSessionTokensFromEvents(events);
+    expect(s.calls).toBe(5);
+    expect(s.totalCacheCreation).toBeGreaterThan(0);
+    expect(s.cacheHitRate).toBe(0);
+    expect(s.cacheEffective).toBe(false);
+  });
+
+  it('exempts the broken-cache trip below 5 calls (boundary at calls===4 vs 5)', () => {
+    const make = (n: number) =>
+      summarizeSessionTokensFromEvents(
+        Array.from({ length: n }, (_, i) =>
+          resp(i, { inputTokens: 100, cacheCreationTokens: 500, cacheReadTokens: 0 }),
+        ),
+      );
+    expect(make(4).cacheEffective).toBe(true); // < 5 → exempt
+    expect(make(5).cacheEffective).toBe(false); // >= 5 → trips
+  });
+
+  it('exempts when there are no cache writes even with zero reads over many calls', () => {
+    const events = Array.from({ length: 8 }, (_, i) =>
+      resp(i, { inputTokens: 100, cacheCreationTokens: 0, cacheReadTokens: 0 }),
+    );
+    expect(summarizeSessionTokensFromEvents(events).cacheEffective).toBe(true);
+  });
+
+  it('does not trip when cacheHitRate sits exactly at the 0.05 threshold', () => {
+    // hitRate === 0.05 is NOT < 0.05, so the cache stays effective.
+    // read/(input+read+write) = 125 / 2500 = 0.05.
+    const events = Array.from({ length: 5 }, (_, i) =>
+      resp(i, { inputTokens: 1875, cacheReadTokens: 125, cacheCreationTokens: 500 }),
+    );
+    const s = summarizeSessionTokensFromEvents(events);
+    expect(s.cacheHitRate).toBeCloseTo(0.05, 6);
+    expect(s.cacheEffective).toBe(true);
+  });
+});
+
 describe('addModelTotals', () => {
   it('adds field-wise', () => {
     const a: ModelUsageTotals = { calls: 1, inputTokens: 10, outputTokens: 2, cacheReadTokens: 3, cacheCreationTokens: 4 };

package/src/tunnel.test.ts

@@ -29,6 +29,27 @@ describe('spawnCliTunnel', () => {
     await handle.close();
   });
 
+  it('u125-1: resolves a URL split across two stdout chunks', async () => {
+    // Write the URL in two separate process.stdout.write calls, split
+    // mid-host, with a tick gap so they surface as distinct 'data' events.
+    // Matching each chunk in isolation would miss it; the rolling buffer must
+    // stitch them.
+    const handle = await spawnCliTunnel({
+      cmd: process.execPath,
+      args: [
+        '-e',
+        'process.stdout.write("ready https://abc-1");' +
+          'setTimeout(()=>{process.stdout.write("23.example.test\\n");},50);' +
+          'setInterval(()=>{}, 1000);',
+      ],
+      urlRegex: URL_RE,
+      name: 'splittunnel',
+      timeoutMs: 5_000,
+    });
+    expect(handle.url).toBe('https://abc-123.example.test');
+    await handle.close();
+  });
+
   it('rejects when the child exits before emitting a URL', async () => {
     await expect(
       spawnCliTunnel({

package/src/tunnel.ts

@@ -158,11 +158,20 @@ export function spawnCliTunnel(opts: SpawnCliTunnelOptions): Promise<CliTunnelHa
     }, timeoutMs);
     timer.unref?.();
 
+    // 'data' events are not line-buffered: the assigned URL can straddle two
+    // chunk boundaries (large URL, fragmented flush). Match against a rolling
+    // accumulation rather than each lone chunk, capped so a chatty tunnel that
+    // never prints a URL can't grow this unboundedly while we wait.
+    const MAX_BUF = 8192;
+    let acc = '';
     const onData = (buf: Buffer): void => {
       if (settled) return; // drain quietly once resolved so the pipe never fills
-      const url = urlRegex.exec(buf.toString('utf8'))?.[0] ?? null;
+      acc += buf.toString('utf8');
+      if (acc.length > MAX_BUF) acc = acc.slice(acc.length - MAX_BUF);
+      const url = urlRegex.exec(acc)?.[0] ?? null;
       if (!url) return;
       settled = true;
+      acc = '';
       clearTimeout(timer);
       resolve({ url, pid: child.pid ?? -1, close: untrack });
     };