@crouton-kit/crouter 0.3.34 → 0.3.35

package/dist/hearth/wake-proxy/__tests__/http-running-route-fast-path.test.js

@@ -1,258 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import { configureWakeProxyRuntime, wakeProxyInternals } from '../home.js';
-import { proxyHttpRequest } from '../proxy.js';
-// Regression for the HTTP wake-path 502/asset-timeout (hearth-soak-4a0dc43-report.md §4): every HTTP
-// forward routed through ensureAwake, so a single momentary slow `probeRelayServing` under guest
-// load false-negatived and escalated the request into the 150s wakeHome/waitForRelayReady
-// path (serial guest execs) — while the direct route was returning 200 in ~0.1s the whole
-// time. The fix: a home crtr already records `running` with a route+token is forwarded DIRECTLY (the
-// forward is the liveness check); ensureAwake/restore is reserved for missing/not-running state or a
-// clear upstream failure. These tests fail on the pre-fix code that gated all HTTP through ensureAwake.
-const tenantId = 'silas';
-const machineId = 'igd2fkrn1y1ol3vw5i6mt';
-const nodeId = 'mqt64sus-e71caa94';
-const routeUrl = 'https://7878-igd2fkrn1y1ol3vw5i6mt.example.dev';
-const ownerToken = 'owner-secret-token';
-const now = '2026-06-25T00:00:00.000Z';
-function makeHome(overrides = {}) {
-    return {
-        tenantId,
-        providerName: 'none',
-        machineId,
-        homeStorage: {
-            kind: 'volume',
-            durability: 'durable-volume',
-            longTermContract: true,
-            ownerMachineId: machineId,
-            guestHome: '/home/agent',
-            volumeId: '48b59d07-8cc9-46f9-bdfd-ac99a55dff40',
-            mountPath: '/home/agent',
-        },
-        state: 'running',
-        nodeId,
-        relayToken: 'relay-token',
-        webRoute: {
-            routeId: '7878-igd2fkrn1y1ol3vw5i6mt.example.dev',
-            machineId,
-            targetPort: 7878,
-            url: routeUrl,
-            concreteUrl: routeUrl,
-            concreteUrlSource: 'provider',
-            createdAt: now,
-            raw: null,
-        },
-        createdAt: now,
-        updatedAt: now,
-        ...overrides,
-    };
-}
-function makeRuntime(registryPath, statePath) {
-    return {
-        proxy: {
-            host: '127.0.0.1',
-            port: 7878,
-            publicOrigin: 'https://hearth-wake-proxy.fly.dev',
-            statePath,
-            m0RegistryPath: registryPath,
-            ownerUserId: 'owner-user',
-            defaultTenantId: tenantId,
-            ownerTokenHash: createHash('sha256').update(ownerToken, 'utf8').digest('hex'),
-            idlePauseMs: 0,
-            wakeTimeoutMs: 30_000,
-            readyTimeoutMs: 2_000,
-            cookieSecure: true,
-            seedHome: null,
-        },
-        m0: {
-            providerName: 'none',
-            registryPath,
-            guestUser: 'agent',
-            guestHome: '/home/agent',
-            guestCodePath: '/opt/crouter',
-            webPort: 7878,
-            nodeKind: 'general',
-            piPackages: [],
-            piAuthJson: null,
-            relayToken: null,
-        },
-    };
-}
-function setup(home = makeHome()) {
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-http-fast-'));
-    const registryPath = join(tempDir, 'homes.json');
-    const statePath = join(tempDir, 'state.json');
-    writeFileSync(registryPath, `${JSON.stringify({ [tenantId]: home }, null, 2)}\n`, 'utf8');
-    const runtime = makeRuntime(registryPath, statePath);
-    configureWakeProxyRuntime(runtime);
-    return runtime;
-}
-class FakeReq extends EventEmitter {
-    url;
-    method;
-    headers;
-    constructor(path, method = 'GET') {
-        super();
-        this.url = path;
-        this.method = method;
-        this.headers = { authorization: `Bearer ${ownerToken}`, host: 'hearth-wake-proxy.fly.dev' };
-    }
-}
-class FakeRes extends EventEmitter {
-    statusCode = 200;
-    statusMessage = '';
-    headersSent = false;
-    writableEnded = false;
-    headers = new Map();
-    chunks = [];
-    socket = { setNoDelay() { } };
-    setHeader(name, value) {
-        this.headers.set(name.toLowerCase(), value);
-    }
-    getHeader(name) {
-        return this.headers.get(name.toLowerCase());
-    }
-    hasHeader(name) {
-        return this.headers.has(name.toLowerCase());
-    }
-    writeHead(code, headers) {
-        this.statusCode = code;
-        this.headersSent = true;
-        if (headers)
-            for (const [k, v] of Object.entries(headers))
-                this.setHeader(k, v);
-    }
-    flushHeaders() {
-        this.headersSent = true;
-    }
-    write(chunk) {
-        this.headersSent = true;
-        this.chunks.push(Buffer.from(chunk));
-        return true;
-    }
-    end(chunk) {
-        this.headersSent = true;
-        if (chunk !== undefined)
-            this.chunks.push(Buffer.from(chunk));
-        this.writableEnded = true;
-        this.emit('finish');
-    }
-    destroy() {
-        this.writableEnded = true;
-    }
-    body() {
-        return Buffer.concat(this.chunks).toString('utf8');
-    }
-}
-function asReq(req) {
-    return req;
-}
-function asRes(res) {
-    return res;
-}
-function htmlResponse(text) {
-    return new Response(text, { status: 200, headers: { 'content-type': 'text/html; charset=utf-8' } });
-}
-function guardHeavyPath(t) {
-    const probe = t.mock.method(wakeProxyInternals, 'probeRelayServing', async () => {
-        throw new Error('probeRelayServing must not run on the running-route fast path');
-    });
-    const wake = t.mock.method(wakeProxyInternals, 'wakeHome', async () => {
-        throw new Error('wakeHome must not run on the running-route fast path');
-    });
-    return { probe, wake };
-}
-test('HTTP request against a known-running route forwards directly without the heavy wake/restore path', async (t) => {
-    const runtime = setup();
-    const { probe, wake } = guardHeavyPath(t);
-    const fetchMock = t.mock.method(globalThis, 'fetch', async () => htmlResponse('<html>chat</html>'));
-    const res = new FakeRes();
-    await proxyHttpRequest(asReq(new FakeReq('/views/chat')), asRes(res), runtime);
-    assert.equal(res.statusCode, 200);
-    assert.equal(res.body(), '<html>chat</html>');
-    assert.equal(fetchMock.mock.callCount(), 1);
-    // The forward went straight to the persisted route — never through ensureAwake's probe/wake.
-    assert.equal(probe.mock.callCount(), 0);
-    assert.equal(wake.mock.callCount(), 0);
-});
-test('concurrent asset/page requests forward in parallel without serializing behind a slow guest probe', async (t) => {
-    const runtime = setup();
-    const { probe, wake } = guardHeavyPath(t);
-    let inFlight = 0;
-    let maxInFlight = 0;
-    let release;
-    const gate = new Promise((resolve) => {
-        release = resolve;
-    });
-    const fetchMock = t.mock.method(globalThis, 'fetch', async () => {
-        inFlight += 1;
-        maxInFlight = Math.max(maxInFlight, inFlight);
-        await gate;
-        inFlight -= 1;
-        return htmlResponse('<html>asset</html>');
-    });
-    const paths = ['/views/chat', '/assets/index-a.css', '/assets/index-b.js', '/assets/index-c.js', '/favicon.svg'];
-    const responses = paths.map(() => new FakeRes());
-    const calls = paths.map((p, i) => proxyHttpRequest(asReq(new FakeReq(p)), asRes(responses[i]), runtime));
-    // Let all five enter forwardUpstream before any resolves; if they serialized behind a per-tenant
-    // wake lock/probe, only one would be in flight here.
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    const concurrentBeforeRelease = maxInFlight;
-    release();
-    await Promise.all(calls);
-    assert.equal(concurrentBeforeRelease, paths.length);
-    assert.equal(fetchMock.mock.callCount(), paths.length);
-    for (const res of responses) {
-        assert.equal(res.statusCode, 200);
-        assert.equal(res.body(), '<html>asset</html>');
-    }
-    assert.equal(probe.mock.callCount(), 0);
-    assert.equal(wake.mock.callCount(), 0);
-});
-test('a clear upstream failure against the running route invalidates the verdict and wakes deliberately', async (t) => {
-    const runtime = setup();
-    // ensureAwake's deliberate wake path: the route IS serving (probe true), so it confirms via the
-    // cheap probe and never restores — the point is that the failed direct forward ESCALATED into
-    // ensureAwake rather than silently 502ing.
-    const probe = t.mock.method(wakeProxyInternals, 'probeRelayServing', async () => true);
-    const wake = t.mock.method(wakeProxyInternals, 'wakeHome', async () => {
-        throw new Error('wakeHome must not run when the relay is serving');
-    });
-    t.mock.method(wakeProxyInternals, 'touchTenantWake', async () => undefined);
-    let fetchCalls = 0;
-    const fetchMock = t.mock.method(globalThis, 'fetch', async () => {
-        fetchCalls += 1;
-        if (fetchCalls === 1)
-            throw new TypeError('fetch failed'); // connection refused against stale route
-        return htmlResponse('<html>recovered</html>');
-    });
-    const res = new FakeRes();
-    await proxyHttpRequest(asReq(new FakeReq('/views/chat')), asRes(res), runtime);
-    assert.equal(res.statusCode, 200);
-    assert.equal(res.body(), '<html>recovered</html>');
-    assert.equal(fetchMock.mock.callCount(), 2); // direct forward failed, deliberate wake forward succeeded
-    assert.equal(probe.mock.callCount(), 1); // entered ensureAwake exactly once
-    assert.equal(wake.mock.callCount(), 0);
-});
-test('not-running home skips the fast path and goes straight to the deliberate wake', async (t) => {
-    const runtime = setup(makeHome({ state: 'paused' }));
-    const probe = t.mock.method(wakeProxyInternals, 'probeRelayServing', async () => true);
-    const wake = t.mock.method(wakeProxyInternals, 'wakeHome', async () => {
-        throw new Error('wakeHome must not run when the relay is serving');
-    });
-    t.mock.method(wakeProxyInternals, 'touchTenantWake', async () => undefined);
-    const fetchMock = t.mock.method(globalThis, 'fetch', async () => htmlResponse('<html>woke</html>'));
-    const res = new FakeRes();
-    await proxyHttpRequest(asReq(new FakeReq('/views/chat')), asRes(res), runtime);
-    assert.equal(res.statusCode, 200);
-    assert.equal(res.body(), '<html>woke</html>');
-    // Paused home is not trusted directly — it must enter ensureAwake (probe runs) before forwarding.
-    assert.equal(probe.mock.callCount(), 1);
-    assert.equal(wake.mock.callCount(), 0);
-    assert.equal(fetchMock.mock.callCount(), 1);
-});

package/dist/hearth/wake-proxy/__tests__/model-auth-routes.test.d.ts

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