@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/hearth/wake-proxy/__tests__/anthropic-oauth.test.js

@@ -0,0 +1,289 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+import { ANTHROPIC_AUTHORIZE_URL, ANTHROPIC_CLIENT_ID, ANTHROPIC_REDIRECT_URI, ANTHROPIC_SCOPES, ANTHROPIC_TOKEN_URL, finishAnthropicOAuthSession, redactAnthropicOAuthMessage, startAnthropicOAuthSession, } from '../anthropic-oauth.js';
+const PROVIDER_SOURCE_PATH = join(process.cwd(), 'node_modules/@earendil-works/pi-ai/dist/utils/oauth/anthropic.js');
+function makeRandomBytes(values) {
+    let index = 0;
+    return (size) => {
+        const value = values[index++];
+        assert.ok(value, `unexpected randomBytes call ${index} for size ${size}`);
+        return value;
+    };
+}
+function sha256Base64url(input) {
+    return createHash('sha256').update(input, 'utf8').digest('base64url');
+}
+function makeFetch(responseBody, calls) {
+    return async (input, init) => {
+        calls.push({ input, init });
+        return {
+            ok: true,
+            status: 200,
+            statusText: 'OK',
+            async text() {
+                return JSON.stringify(responseBody);
+            },
+        };
+    };
+}
+test('startAnthropicOAuthSession builds a PKCE auth URL with Claude Code state bound to the verifier', () => {
+    const sessionIdBytes = Buffer.alloc(16, 1);
+    const verifierBytes = Buffer.alloc(32, 3);
+    const verifier = verifierBytes.toString('base64url');
+    const shaInputs = [];
+    const started = startAnthropicOAuthSession('tenant-a', () => 1_000_000, {
+        randomBytes: makeRandomBytes([sessionIdBytes, verifierBytes]),
+        sha256: (input) => {
+            shaInputs.push(input);
+            return Buffer.alloc(32, 9);
+        },
+    });
+    assert.equal(started.ok, true);
+    if (!started.ok)
+        throw new Error('expected success');
+    assert.ok(started.authUrl.includes('response_type=code'));
+    assert.ok(started.authUrl.includes('code_challenge_method=S256'));
+    // Regression: claude.ai rejects the authorize request with "Invalid request
+    // format" without code=true (the Claude Code authorize flow param).
+    assert.ok(started.authUrl.includes('code=true'));
+    const authUrl = new URL(started.authUrl);
+    assert.equal(authUrl.origin + authUrl.pathname, ANTHROPIC_AUTHORIZE_URL);
+    assert.equal(authUrl.searchParams.get('client_id'), ANTHROPIC_CLIENT_ID);
+    assert.equal(authUrl.searchParams.get('redirect_uri'), ANTHROPIC_REDIRECT_URI);
+    assert.equal(authUrl.searchParams.get('scope'), ANTHROPIC_SCOPES);
+    assert.equal(authUrl.searchParams.get('response_type'), 'code');
+    assert.equal(authUrl.searchParams.get('code_challenge_method'), 'S256');
+    assert.equal(authUrl.searchParams.get('state'), verifier);
+    assert.equal(authUrl.searchParams.get('code_challenge'), Buffer.alloc(32, 9).toString('base64url'));
+    assert.ok(!started.authUrl.includes(sessionIdBytes.toString('base64url')));
+    assert.equal(shaInputs[0], verifier);
+});
+test('startAnthropicOAuthSession keeps Claude Code state coupled to the PKCE verifier', () => {
+    const sessionIdBytes = Buffer.alloc(16, 41);
+    const verifierBytes = Buffer.alloc(32, 42);
+    const verifier = verifierBytes.toString('base64url');
+    const started = startAnthropicOAuthSession('tenant-a-pkce', () => 2_000_000, {
+        randomBytes: makeRandomBytes([sessionIdBytes, verifierBytes]),
+    });
+    assert.equal(started.ok, true);
+    if (!started.ok)
+        throw new Error('expected success');
+    const authUrl = new URL(started.authUrl);
+    const state = authUrl.searchParams.get('state');
+    assert.ok(state);
+    assert.equal(state, verifier);
+    assert.equal(authUrl.searchParams.get('code_challenge'), sha256Base64url(state));
+});
+test('finishAnthropicOAuthSession rejects foreign state, unknown session, and expired sessions without token exchange', async () => {
+    const fetchCalls = [];
+    const started = startAnthropicOAuthSession('tenant-b', () => 10_000, {
+        randomBytes: makeRandomBytes([Buffer.alloc(16, 4), Buffer.alloc(32, 6)]),
+        sha256: () => Buffer.alloc(32, 7),
+    });
+    assert.equal(started.ok, true);
+    if (!started.ok)
+        throw new Error('expected success');
+    const foreignState = await finishAnthropicOAuthSession({
+        tenantId: 'tenant-b',
+        sessionId: started.sessionId,
+        redirectUrl: 'http://localhost:53692/callback?code=abc123&state=wrong-state',
+    }, {
+        now: () => 10_000,
+        fetch: makeFetch({ access_token: 'x', refresh_token: 'y', expires_in: 600 }, fetchCalls),
+    });
+    assert.equal(foreignState.ok, false);
+    assert.equal(foreignState.status, 400);
+    assert.equal(fetchCalls.length, 0);
+    const unknownSession = await finishAnthropicOAuthSession({
+        tenantId: 'tenant-c',
+        sessionId: 'missing-session',
+        redirectUrl: 'http://localhost:53692/callback?code=abc123&state=wrong-state',
+    }, {
+        now: () => 10_000,
+        fetch: makeFetch({ access_token: 'x', refresh_token: 'y', expires_in: 600 }, fetchCalls),
+    });
+    assert.equal(unknownSession.ok, false);
+    assert.equal(unknownSession.status, 400);
+    assert.equal(fetchCalls.length, 0);
+    const expiredStart = startAnthropicOAuthSession('tenant-d', () => 20_000, {
+        randomBytes: makeRandomBytes([Buffer.alloc(16, 8), Buffer.alloc(32, 10)]),
+        sha256: () => Buffer.alloc(32, 11),
+    });
+    assert.equal(expiredStart.ok, true);
+    if (!expiredStart.ok)
+        throw new Error('expected success');
+    const expired = await finishAnthropicOAuthSession({
+        tenantId: 'tenant-d',
+        sessionId: expiredStart.sessionId,
+        redirectUrl: 'http://localhost:53692/callback?code=abc123&state=whatever',
+    }, {
+        now: () => 20_000 + 10 * 60_000 + 1,
+        fetch: makeFetch({ access_token: 'x', refresh_token: 'y', expires_in: 600 }, fetchCalls),
+    });
+    assert.equal(expired.ok, false);
+    assert.equal(expired.status, 400);
+    assert.equal(fetchCalls.length, 0);
+});
+// Regression: a stale/zombie in-memory OAuth session used to make /start return
+// 409 "already in progress" for the whole 10-min TTL, trapping the user on an
+// about:blank popup with no usable authUrl (Hearth live triage 2026-06-29).
+// A fresh start must always supersede the prior session and hand back a usable,
+// distinct authUrl. Pre-fix this test would have failed on the second start.
+test('startAnthropicOAuthSession supersedes a stale pending session and returns a fresh usable authUrl', () => {
+    const now = 30_000;
+    const first = startAnthropicOAuthSession('tenant-e', () => now, {
+        randomBytes: makeRandomBytes([Buffer.alloc(16, 12), Buffer.alloc(32, 14)]),
+        sha256: () => Buffer.alloc(32, 15),
+    });
+    assert.equal(first.ok, true);
+    if (!first.ok)
+        throw new Error('expected success');
+    // Second click while the first session is still live (within TTL): no 409 lock.
+    const second = startAnthropicOAuthSession('tenant-e', () => now + 1_000, {
+        randomBytes: makeRandomBytes([Buffer.alloc(16, 16), Buffer.alloc(32, 18)]),
+        sha256: () => Buffer.alloc(32, 19),
+    });
+    assert.equal(second.ok, true);
+    if (!second.ok)
+        throw new Error('expected fresh start to succeed, not a 409 lock');
+    assert.ok(second.authUrl.includes('response_type=code'));
+    assert.notEqual(second.sessionId, first.sessionId);
+    // The superseded session's state must no longer be the active one.
+    assert.notEqual(new URL(second.authUrl).searchParams.get('state'), new URL(first.authUrl).searchParams.get('state'));
+});
+// Security companion to the supersede fix: after a fresh start replaces the
+// pending session, a callback carrying the OLD session's id/state must NOT be
+// able to complete auth — newest valid session wins, superseded state fails.
+test('finishAnthropicOAuthSession rejects a superseded callback after a fresh start', async () => {
+    const now = 50_000;
+    const firstSessionId = Buffer.alloc(16, 30);
+    const firstVerifierBytes = Buffer.alloc(32, 32);
+    const firstVerifier = firstVerifierBytes.toString('base64url');
+    const first = startAnthropicOAuthSession('tenant-g', () => now, {
+        randomBytes: makeRandomBytes([firstSessionId, firstVerifierBytes]),
+        sha256: () => Buffer.alloc(32, 33),
+    });
+    assert.equal(first.ok, true);
+    if (!first.ok)
+        throw new Error('expected success');
+    // User re-clicks; a new session supersedes the first.
+    const second = startAnthropicOAuthSession('tenant-g', () => now + 1_000, {
+        randomBytes: makeRandomBytes([Buffer.alloc(16, 34), Buffer.alloc(32, 36)]),
+        sha256: () => Buffer.alloc(32, 37),
+    });
+    assert.equal(second.ok, true);
+    if (!second.ok)
+        throw new Error('expected success');
+    // A late callback from the FIRST (superseded) session must fail without exchange.
+    const fetchCalls = [];
+    const stale = await finishAnthropicOAuthSession({
+        tenantId: 'tenant-g',
+        sessionId: first.sessionId,
+        redirectUrl: `http://localhost:53692/callback?code=stale-code&state=${firstVerifier}`,
+    }, {
+        now: () => now + 2_000,
+        fetch: makeFetch({ access_token: 'x', refresh_token: 'y', expires_in: 600 }, fetchCalls),
+    });
+    assert.equal(stale.ok, false);
+    if (stale.ok)
+        throw new Error('superseded callback must not complete auth');
+    assert.equal(stale.status, 400);
+    assert.equal(fetchCalls.length, 0);
+});
+test('finishAnthropicOAuthSession exchanges the stored verifier and returns Pi-compatible credentials with the skew applied', async () => {
+    const sessionIdBytes = Buffer.alloc(16, 24);
+    const verifierBytes = Buffer.alloc(32, 26);
+    const verifier = verifierBytes.toString('base64url');
+    const now = 40_000;
+    const started = startAnthropicOAuthSession('tenant-f', () => now, {
+        randomBytes: makeRandomBytes([sessionIdBytes, verifierBytes]),
+        sha256: (input) => {
+            assert.equal(input, verifier);
+            return Buffer.alloc(32, 27);
+        },
+    });
+    assert.equal(started.ok, true);
+    if (!started.ok)
+        throw new Error('expected success');
+    const fetchCalls = [];
+    const finished = await finishAnthropicOAuthSession({
+        tenantId: 'tenant-f',
+        sessionId: started.sessionId,
+        redirectUrl: `http://localhost:53692/callback?code=auth-code-123&state=${verifier}`,
+    }, {
+        now: () => now,
+        fetch: async (input, init) => {
+            fetchCalls.push({ input, init });
+            const request = new Request(String(input), init);
+            const body = JSON.parse(await request.text());
+            assert.equal(body.grant_type, 'authorization_code');
+            assert.equal(body.client_id, ANTHROPIC_CLIENT_ID);
+            assert.equal(body.code, 'auth-code-123');
+            assert.equal(body.state, verifier);
+            assert.equal(body.redirect_uri, ANTHROPIC_REDIRECT_URI);
+            assert.equal(body.code_verifier, verifier);
+            return {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                async text() {
+                    return JSON.stringify({
+                        access_token: 'access-token-1',
+                        refresh_token: 'refresh-token-1',
+                        expires_in: 600,
+                    });
+                },
+            };
+        },
+    });
+    assert.equal(fetchCalls.length, 1);
+    assert.equal(finished.ok, true);
+    if (!finished.ok)
+        throw new Error('expected success');
+    assert.deepEqual(finished.credential, {
+        type: 'oauth',
+        refresh: 'refresh-token-1',
+        access: 'access-token-1',
+        expires: now + 600_000 - 300_000,
+    });
+    assert.equal(finished.type, 'oauth');
+    assert.equal(finished.refresh, 'refresh-token-1');
+    assert.equal(finished.access, 'access-token-1');
+    assert.equal(finished.expires, now + 600_000 - 300_000);
+});
+test('contract guard: the installed Pi Anthropic OAuth source still matches the copied constants', () => {
+    const source = readFileSync(PROVIDER_SOURCE_PATH, 'utf8');
+    assert.match(source, /const CLIENT_ID = decode\("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl"\);/);
+    assert.match(source, /const AUTHORIZE_URL = "https:\/\/claude\.ai\/oauth\/authorize";/);
+    assert.match(source, /const TOKEN_URL = "https:\/\/platform\.claude\.com\/v1\/oauth\/token";/);
+    assert.match(source, /const CALLBACK_PORT = 53692;/);
+    assert.match(source, /const CALLBACK_PATH = "\/callback";/);
+    assert.match(source, /const REDIRECT_URI = `http:\/\/localhost:\$\{CALLBACK_PORT\}\$\{CALLBACK_PATH\}`;/);
+    assert.match(source, /const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";/);
+    assert.equal(ANTHROPIC_CLIENT_ID, '9d1c250a-e61b-44d9-88ed-5944d1962f5e');
+    assert.equal(ANTHROPIC_AUTHORIZE_URL, 'https://claude.ai/oauth/authorize');
+    assert.equal(ANTHROPIC_TOKEN_URL, 'https://platform.claude.com/v1/oauth/token');
+    assert.equal(ANTHROPIC_REDIRECT_URI, 'http://localhost:53692/callback');
+    assert.equal(ANTHROPIC_SCOPES, 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload');
+});
+test('redaction removes Anthropic OAuth and bearer/token material from log text', () => {
+    const redacted = redactAnthropicOAuthMessage('Authorization: Bearer owner-token https://localhost:53692/callback?code=auth-code&state=state-value&code_verifier=verifier-value {"access_token":"access-value","refresh_token":"refresh-value","access":"access-two","refresh":"refresh-two","code":"json-code","state":"json-state","code_verifier":"json-verifier"} code=assign-code state=assign-state code_verifier=assign-verifier hearth_owner=owner-cookie');
+    assert.ok(!redacted.includes('owner-token'));
+    assert.ok(!redacted.includes('auth-code'));
+    assert.ok(!redacted.includes('state-value'));
+    assert.ok(!redacted.includes('verifier-value'));
+    assert.ok(!redacted.includes('json-code'));
+    assert.ok(!redacted.includes('json-state'));
+    assert.ok(!redacted.includes('json-verifier'));
+    assert.ok(!redacted.includes('assign-code'));
+    assert.ok(!redacted.includes('assign-state'));
+    assert.ok(!redacted.includes('assign-verifier'));
+    assert.ok(!redacted.includes('access-value'));
+    assert.ok(!redacted.includes('refresh-value'));
+    assert.ok(!redacted.includes('owner-cookie'));
+    assert.match(redacted, /\[redacted redirect url\]/);
+    assert.match(redacted, /Bearer \[redacted\]/);
+});

package/dist/hearth/wake-proxy/__tests__/config-timeout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hearth/wake-proxy/__tests__/config-timeout.test.js

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { loadHearthProxyConfig } from '../config.js';
+import { proxyInternals } from '../proxy.js';
+function slowWork(ms) {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve('ok'), ms);
+    });
+}
+test('wake proxy defaults the wake timeout to 150s while leaving the readiness probe timeout at 30s', () => {
+    const config = loadHearthProxyConfig({
+        HEARTH_OWNER_TOKEN: 'owner-secret-token',
+        HEARTH_PROXY_HOST: '127.0.0.1',
+        HEARTH_PROXY_PORT: '8080',
+    });
+    assert.equal(config.wakeTimeoutMs, 150_000);
+    assert.equal(config.readyTimeoutMs, 30_000);
+});
+test('withWakeTimeout allows a recreate-sized wake to finish before 150s and rejects the old 30s budget', async (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] });
+    try {
+        const shortBudget = proxyInternals.withWakeTimeout(slowWork(120_000), 30_000, 'wake proxy request');
+        await Promise.resolve();
+        t.mock.timers.tick(30_000);
+        await assert.rejects(shortBudget, /timed out/);
+        const longBudget = proxyInternals.withWakeTimeout(slowWork(120_000), 150_000, 'wake proxy request');
+        await Promise.resolve();
+        t.mock.timers.tick(120_000);
+        await assert.doesNotReject(longBudget);
+    }
+    finally {
+        t.mock.timers.reset();
+    }
+});

package/dist/hearth/wake-proxy/__tests__/guest-source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hearth/wake-proxy/__tests__/guest-source.test.js

@@ -0,0 +1,203 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { requireSuccessfulExec, runGuestSource } from '../guest-source.js';
+const tenantId = 'tenant-1';
+const routeUrl = 'https://guest.example';
+const relayToken = 'relay-token';
+function awakenedHome() {
+    return {
+        tenantId,
+        nodeId: 'mqt64sus-e71caa94',
+        routeUrl,
+        relayToken,
+        machineId: 'igd2fkrn1y1ol3vw5i6mt',
+        webPort: 7878,
+    };
+}
+function activityHandle() {
+    return {
+        tenantId,
+        kind: 'wake',
+        acquiredAt: '2026-06-26T00:00:00.000Z',
+        closed: false,
+    };
+}
+function jsonResponse(raw, ok = true, status = 200, statusText = 'OK') {
+    return {
+        ok,
+        status,
+        statusText,
+        async text() {
+            return JSON.stringify(raw);
+        },
+    };
+}
+function makeDeps(overrides = {}) {
+    const fetchCalls = [];
+    const state = { acquired: 0, released: 0, releaseSnapshot: null };
+    const handle = activityHandle();
+    const defaultFetch = (async (url, init) => {
+        fetchCalls.push({ url: String(url), init: init ?? {} });
+        return jsonResponse({ ok: true, exitCode: 0, stdout: 'ok', stderr: '' });
+    });
+    const deps = {
+        ensureAwake: overrides.ensureAwake ?? (async () => awakenedHome()),
+        fetch: overrides.fetch ?? defaultFetch,
+        acquireActivity: overrides.acquireActivity ?? (() => {
+            state.acquired += 1;
+            return handle;
+        }),
+        releaseActivity: overrides.releaseActivity ?? (() => {
+            state.released += 1;
+            state.releaseSnapshot = { tenantId, counts: { wake: 0, http: 0, ws: 0 }, total: 0, idleDeadlineAt: null };
+            return state.releaseSnapshot;
+        }),
+        now: overrides.now ?? (() => 1_700_000_000_000),
+        wakeTimeoutMs: overrides.wakeTimeoutMs ?? 50,
+        bridgeTimeoutMs: overrides.bridgeTimeoutMs ?? 50,
+        redact: overrides.redact,
+        fetchCalls,
+    };
+    return { deps, state };
+}
+test('runGuestSource acquires and releases activity and forwards the exact server-side request', async () => {
+    const { deps, state } = makeDeps();
+    const request = {
+        kind: 'exec',
+        bin: 'crtr',
+        args: ['canvas', 'snapshot', '--json'],
+        cwd: '/opt/crouter',
+    };
+    const raw = await runGuestSource(tenantId, request, deps);
+    assert.equal(raw.ok, true);
+    assert.equal(raw.exitCode, 0);
+    assert.equal(raw.stdout, 'ok');
+    assert.equal(raw.stderr, '');
+    assert.equal(state.acquired, 1);
+    assert.equal(state.released, 1);
+    assert.equal(deps.fetchCalls.length, 1);
+    assert.equal(deps.fetchCalls[0].url, `${routeUrl}/__crtr/source`);
+    assert.deepEqual(deps.fetchCalls[0].init?.headers, {
+        authorization: `Bearer ${relayToken}`,
+        'content-type': 'application/json',
+    });
+    assert.equal(deps.fetchCalls[0].init?.body, JSON.stringify(request));
+});
+test('runGuestSource releases activity on wake timeout', async () => {
+    let resolved = false;
+    const { deps, state } = makeDeps({
+        ensureAwake: async () => await new Promise((resolve) => {
+            setTimeout(() => {
+                resolved = true;
+                resolve(awakenedHome());
+            }, 25);
+        }),
+        wakeTimeoutMs: 1,
+        fetch: async () => {
+            throw new Error('fetch should not run after wake timeout');
+        },
+    });
+    const raw = await runGuestSource(tenantId, { kind: 'exec', bin: 'crtr', args: ['surface', 'view', 'list'] }, deps);
+    assert.equal(raw.ok, false);
+    assert.equal(raw.stdout, '');
+    assert.match(raw.stderr, /timed out/i);
+    assert.equal(state.acquired, 1);
+    assert.equal(state.released, 1);
+    assert.equal(resolved, false);
+});
+test('runGuestSource releases activity when the bridge fetch aborts on timeout', async () => {
+    const { deps, state } = makeDeps({
+        bridgeTimeoutMs: 1,
+        fetch: (async (_url, init) => {
+            const signal = init?.signal;
+            assert.ok(signal instanceof AbortSignal);
+            await new Promise((_resolve, reject) => {
+                signal.addEventListener('abort', () => {
+                    reject(new Error('bridge fetch failed with Bearer secret https://localhost:53692/callback?code=abc&state=def access_token=tok refresh_token=ref'));
+                }, { once: true });
+            });
+        }),
+    });
+    const raw = await runGuestSource(tenantId, { kind: 'exec', bin: 'crtr', args: ['surface', 'view', 'list'] }, deps);
+    assert.equal(raw.ok, false);
+    assert.equal(raw.stdout, '');
+    assert.doesNotMatch(raw.stderr, /Bearer secret/);
+    assert.doesNotMatch(raw.stderr, /code=abc/);
+    assert.doesNotMatch(raw.stderr, /access_token/);
+    assert.doesNotMatch(raw.stderr, /refresh_token/);
+    assert.equal(state.acquired, 1);
+    assert.equal(state.released, 1);
+});
+test('runGuestSource normalizes HTTP and bridge-shape failures without throwing', async () => {
+    const { deps: httpDeps } = makeDeps({
+        fetch: (async () => ({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+            async text() {
+                return 'Authorization: Bearer secret-token code=abc&state=def access_token="tok" refresh_token="ref" https://localhost:53692/callback?code=abc&state=def';
+            },
+        })),
+    });
+    const { deps: malformedDeps } = makeDeps({
+        fetch: (async () => ({
+            ok: true,
+            status: 200,
+            statusText: 'OK',
+            async text() {
+                return 'this is not json Authorization: Bearer secret-token code=abc access_token=tok';
+            },
+        })),
+    });
+    const { deps: shapeDeps } = makeDeps({
+        fetch: (async () => ({
+            ok: true,
+            status: 200,
+            statusText: 'OK',
+            async text() {
+                return JSON.stringify({ ok: true, stdout: 1, stderr: '' });
+            },
+        })),
+    });
+    const httpRaw = await runGuestSource(tenantId, { kind: 'exec', bin: 'crtr', args: ['canvas', 'snapshot', '--json'] }, httpDeps);
+    const malformedRaw = await runGuestSource(tenantId, { kind: 'exec', bin: 'crtr', args: ['canvas', 'snapshot', '--json'] }, malformedDeps);
+    const shapeRaw = await runGuestSource(tenantId, { kind: 'exec', bin: 'crtr', args: ['canvas', 'snapshot', '--json'] }, shapeDeps);
+    assert.equal(httpRaw.ok, false);
+    assert.equal(httpRaw.stdout, '');
+    assert.match(httpRaw.stderr, /HTTP 500/);
+    assert.doesNotMatch(httpRaw.stderr, /Bearer secret-token/);
+    assert.doesNotMatch(httpRaw.stderr, /code=abc/);
+    assert.doesNotMatch(httpRaw.stderr, /access_token/);
+    assert.doesNotMatch(httpRaw.stderr, /refresh_token/);
+    assert.doesNotMatch(httpRaw.stderr, /localhost:53692\/callback\?code=abc/);
+    assert.equal(malformedRaw.ok, false);
+    assert.equal(malformedRaw.stdout, '');
+    assert.match(malformedRaw.stderr, /invalid RawResponse JSON/i);
+    assert.doesNotMatch(malformedRaw.stderr, /Bearer secret-token/);
+    assert.doesNotMatch(malformedRaw.stderr, /code=abc/);
+    assert.doesNotMatch(malformedRaw.stderr, /access_token/);
+    assert.equal(shapeRaw.ok, false);
+    assert.equal(shapeRaw.stdout, '');
+    assert.match(shapeRaw.stderr, /invalid RawResponse JSON/i);
+});
+test('requireSuccessfulExec accepts only ok=true with exitCode=0 and redacts stderr-bearing failures', () => {
+    const raw = { ok: true, exitCode: 0, stdout: 'ok', stderr: '' };
+    assert.equal(requireSuccessfulExec(raw, 'write anthropic auth'), raw);
+    assert.throws(() => requireSuccessfulExec({ ok: true, exitCode: 1, stdout: '', stderr: 'boom' }, 'write anthropic auth'));
+    assert.throws(() => requireSuccessfulExec({ ok: false, stdout: '', stderr: 'transport failed' }, 'write anthropic auth'));
+    assert.throws(() => requireSuccessfulExec({ ok: true, stdout: '', stderr: '' }, 'write anthropic auth'));
+    try {
+        requireSuccessfulExec({ ok: true, exitCode: 0, stdout: '', stderr: 'Authorization: Bearer secret-token access_token="tok" refresh_token="ref" code_verifier=verifier' }, 'write anthropic auth');
+        assert.fail('expected stderr-bearing success to fail');
+    }
+    catch (error) {
+        assert.ok(error instanceof Error);
+        const details = error.details;
+        assert.ok(details);
+        assert.equal(typeof details?.error, 'string');
+        assert.doesNotMatch(String(details?.error), /Bearer secret-token/);
+        assert.doesNotMatch(String(details?.error), /access_token/);
+        assert.doesNotMatch(String(details?.error), /refresh_token/);
+        assert.doesNotMatch(String(details?.error), /code_verifier=verifier/);
+    }
+});

package/dist/hearth/wake-proxy/__tests__/hardening.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hearth/wake-proxy/__tests__/hardening.test.js

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { test } from 'node:test';
+import { proxyInternals } from '../proxy.js';
+class FakeWs extends EventEmitter {
+    readyState = 1;
+    pingCount = 0;
+    terminateCount = 0;
+    ping() {
+        this.pingCount += 1;
+    }
+    terminate() {
+        this.terminateCount += 1;
+        this.readyState = 3;
+    }
+}
+test('attachWsKeepalive pings on cadence, resets on pong, and stops cleanly', async (t) => {
+    t.mock.timers.enable({ apis: ['setInterval'] });
+    try {
+        const socket = new FakeWs();
+        const stop = proxyInternals.attachWsKeepalive(socket, { nodeId: 'node-1', tenantId: 'tenant-1', leg: 'browser' }, { intervalMs: 1 });
+        assert.equal(socket.listenerCount('pong'), 1);
+        t.mock.timers.tick(1);
+        assert.equal(socket.pingCount, 1);
+        assert.equal(socket.terminateCount, 0);
+        socket.emit('pong');
+        t.mock.timers.tick(1);
+        assert.equal(socket.pingCount, 2);
+        assert.equal(socket.terminateCount, 0);
+        stop();
+        assert.equal(socket.listenerCount('pong'), 0);
+        t.mock.timers.tick(10);
+        assert.equal(socket.pingCount, 2);
+        assert.equal(socket.terminateCount, 0);
+    }
+    finally {
+        t.mock.timers.reset();
+    }
+});
+test('attachWsKeepalive terminates after a missed pong and clears its interval', async (t) => {
+    t.mock.timers.enable({ apis: ['setInterval'] });
+    try {
+        const socket = new FakeWs();
+        proxyInternals.attachWsKeepalive(socket, { nodeId: 'node-2', tenantId: 'tenant-2', leg: 'upstream' }, { intervalMs: 1 });
+        t.mock.timers.tick(1);
+        assert.equal(socket.pingCount, 1);
+        assert.equal(socket.terminateCount, 0);
+        t.mock.timers.tick(1);
+        assert.equal(socket.pingCount, 1);
+        assert.equal(socket.terminateCount, 1);
+        assert.equal(socket.listenerCount('pong'), 0);
+        t.mock.timers.tick(10);
+        assert.equal(socket.pingCount, 1);
+        assert.equal(socket.terminateCount, 1);
+    }
+    finally {
+        t.mock.timers.reset();
+    }
+});

package/dist/hearth/wake-proxy/__tests__/hearth-status-route.test.d.ts

@@ -0,0 +1 @@
+export {};