@crouton-kit/crouter 0.3.33 → 0.3.35

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

@@ -1,34 +0,0 @@
-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

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

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

@@ -1,203 +0,0 @@
-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: ['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: ['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

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

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

@@ -1,59 +0,0 @@
-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

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

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

@@ -1,372 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Readable } from 'node:stream';
-import { test } from 'node:test';
-import { routeRequest } from '../server.js';
-const ownerToken = 'owner-secret-token';
-const ownerTokenHash = createHash('sha256').update(ownerToken, 'utf8').digest('hex');
-const publicOrigin = 'https://hearth.example';
-function makeRuntime(tenantId, statePath) {
-    return {
-        proxy: {
-            host: '127.0.0.1',
-            port: 7878,
-            publicOrigin,
-            statePath,
-            m0RegistryPath: join(statePath, 'homes.json'),
-            ownerUserId: 'owner-user',
-            defaultTenantId: tenantId,
-            ownerTokenHash,
-            idlePauseMs: 60_000,
-            wakeTimeoutMs: 30_000,
-            readyTimeoutMs: 2_000,
-            cookieSecure: true,
-            seedHome: null,
-        },
-        m0: {
-            providerName: 'none',
-            registryPath: join(statePath, 'homes.json'),
-            guestUser: 'agent',
-            guestHome: '/home/agent',
-            guestCodePath: '/opt/crouter',
-            webPort: 7878,
-            nodeKind: 'general',
-            piPackages: [],
-            piAuthJson: null,
-            relayToken: null,
-        },
-    };
-}
-function writeState(statePath, tenantId) {
-    mkdirSync(join(statePath, '..'), { recursive: true });
-    writeFileSync(statePath, `${JSON.stringify({
-        version: 1,
-        owner: {
-            ownerUserId: 'owner-user',
-            defaultTenantId: tenantId,
-            tokenHash: ownerTokenHash,
-            createdAt: '2026-06-26T00:00:00.000Z',
-        },
-        tenants: {},
-    }, null, 2)}\n`, 'utf8');
-}
-function writeHome(registryPath, home) {
-    mkdirSync(join(registryPath, '..'), { recursive: true });
-    writeFileSync(registryPath, `${JSON.stringify({
-        [home.tenantId]: home,
-    }, null, 2)}\n`, 'utf8');
-}
-function makeRequest(method, url, headers = {}, body = '') {
-    const req = new Readable({ read() { } });
-    req.method = method;
-    req.url = url;
-    req.headers = headers;
-    process.nextTick(() => {
-        if (body !== '')
-            req.push(body);
-        req.push(null);
-    });
-    return req;
-}
-function makeResponse() {
-    return {
-        statusCode: 200,
-        headersSent: false,
-        headers: {},
-        body: '',
-        writeHead(statusCode, headers) {
-            this.statusCode = statusCode;
-            this.headers = { ...this.headers, ...headers };
-            this.headersSent = true;
-            return this;
-        },
-        setHeader(name, value) {
-            this.headers[name.toLowerCase()] = value;
-        },
-        end(chunk) {
-            if (chunk !== undefined)
-                this.body += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk;
-            this.headersSent = true;
-            return this;
-        },
-        destroy() {
-            this.headersSent = true;
-        },
-    };
-}
-function parseJsonBody(res) {
-    return JSON.parse(res.body);
-}
-test('status route returns 401 without owner auth', async () => {
-    const tenantId = 'tenant-status-unauthenticated';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-unauth-'));
-    const statePath = join(tempDir, 'state.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    const res = makeResponse();
-    const handled = await routeRequest(makeRequest('GET', '/__hearth/status'), res, runtime, {});
-    assert.equal(handled, undefined);
-    assert.equal(res.statusCode, 401);
-});
-test('status route returns runtime stats when existing relay already serves', async () => {
-    const tenantId = 'tenant-status-runtime';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-runtime-'));
-    const statePath = join(tempDir, 'state.json');
-    const registryPath = join(tempDir, 'homes.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    runtime.proxy.m0RegistryPath = registryPath;
-    runtime.m0.registryPath = registryPath;
-    const capturedAt = new Date().toISOString();
-    const fetchCalls = [];
-    writeHome(registryPath, {
-        tenantId,
-        providerName: 'none',
-        machineId: 'test-machine',
-        homeStorage: {
-            kind: 'volume',
-            durability: 'durable-volume',
-            longTermContract: true,
-            ownerMachineId: 'test-machine',
-            guestHome: '/home/agent',
-            volumeId: 'volume-123',
-            mountPath: '/home/agent',
-        },
-        state: 'running',
-        nodeId: 'test-node',
-        relayToken: 'relay-token',
-        webRoute: {
-            routeId: 'https://relay.example',
-            machineId: 'test-machine',
-            targetPort: 7878,
-            url: 'https://relay.example',
-            concreteUrl: 'https://relay.example',
-            concreteUrlSource: 'config',
-            createdAt: '2026-06-26T00:00:00.000Z',
-            raw: null,
-        },
-        createdAt: '2026-06-26T00:00:00.000Z',
-        updatedAt: '2026-06-26T00:00:00.000Z',
-    });
-    const res = makeResponse();
-    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
-        status: {
-            fetch: (async (url, init) => {
-                fetchCalls.push({ url: String(url), init: init ?? {} });
-                return {
-                    ok: true,
-                    status: 200,
-                    statusText: 'OK',
-                    async text() {
-                        return JSON.stringify({
-                            ok: true,
-                            exitCode: 0,
-                            stdout: JSON.stringify({
-                                cpuPct: 17.5,
-                                memoryUsedMB: 612,
-                                memoryAvailableMB: 1436,
-                                crtrRssKB: 45000,
-                                piRssKB: 32000,
-                                nodeRssKB: 12000,
-                                totalRssKB: 89000,
-                                capturedAt,
-                            }),
-                            stderr: '',
-                        });
-                    },
-                };
-            }),
-        },
-    });
-    assert.equal(handled, undefined);
-    assert.equal(res.statusCode, 200);
-    const body = parseJsonBody(res);
-    assert.equal(body.runtimeStats?.cpuPct, 17.5);
-    assert.equal(body.machineResources, null);
-    assert.equal(fetchCalls.length, 1);
-    assert.equal(fetchCalls[0]?.url, 'https://relay.example/__crtr/source');
-    assert.deepEqual(fetchCalls[0]?.init?.headers, {
-        authorization: 'Bearer relay-token',
-        'content-type': 'application/json',
-    });
-});
-test('status miss does not start wake/restore', async () => {
-    const tenantId = 'tenant-status-probe-fail';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-probe-fail-'));
-    const statePath = join(tempDir, 'state.json');
-    const registryPath = join(tempDir, 'homes.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    runtime.proxy.m0RegistryPath = registryPath;
-    runtime.m0.registryPath = registryPath;
-    writeHome(registryPath, {
-        tenantId,
-        providerName: 'none',
-        machineId: 'test-machine',
-        homeStorage: {
-            kind: 'volume',
-            durability: 'durable-volume',
-            longTermContract: true,
-            ownerMachineId: 'test-machine',
-            guestHome: '/home/agent',
-            volumeId: 'volume-123',
-            mountPath: '/home/agent',
-        },
-        state: 'running',
-        nodeId: 'test-node',
-        relayToken: 'relay-token',
-        webRoute: {
-            routeId: 'https://relay.example',
-            machineId: 'test-machine',
-            targetPort: 7878,
-            url: 'https://relay.example',
-            concreteUrl: 'https://relay.example',
-            concreteUrlSource: 'config',
-            createdAt: '2026-06-26T00:00:00.000Z',
-            raw: null,
-        },
-        createdAt: '2026-06-26T00:00:00.000Z',
-        updatedAt: '2026-06-26T00:00:00.000Z',
-    });
-    let guestSourceCalls = 0;
-    const fetchCalls = [];
-    const res = makeResponse();
-    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
-        status: {
-            fetch: (async (url, init) => {
-                fetchCalls.push({ url: String(url), init: init ?? {} });
-                return {
-                    ok: false,
-                    status: 503,
-                    statusText: 'Service Unavailable',
-                    async text() {
-                        return 'relay is down';
-                    },
-                };
-            }),
-            guestSource: async () => {
-                guestSourceCalls += 1;
-                throw new Error('guestSource should not run on a status miss');
-            },
-        },
-    });
-    assert.equal(handled, undefined);
-    assert.equal(res.statusCode, 200);
-    const body = parseJsonBody(res);
-    assert.equal(body.runtimeStats, null);
-    assert.equal(fetchCalls.length, 1);
-    assert.equal(fetchCalls[0]?.url, 'https://relay.example/__crtr/source');
-    assert.equal(guestSourceCalls, 0);
-});
-test('status route returns null runtime stats when the probe output is invalid JSON', async () => {
-    const tenantId = 'tenant-status-parse-fail';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-parse-fail-'));
-    const statePath = join(tempDir, 'state.json');
-    const registryPath = join(tempDir, 'homes.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    runtime.proxy.m0RegistryPath = registryPath;
-    runtime.m0.registryPath = registryPath;
-    writeHome(registryPath, {
-        tenantId,
-        providerName: 'none',
-        machineId: 'test-machine',
-        homeStorage: {
-            kind: 'volume',
-            durability: 'durable-volume',
-            longTermContract: true,
-            ownerMachineId: 'test-machine',
-            guestHome: '/home/agent',
-            volumeId: 'volume-123',
-            mountPath: '/home/agent',
-        },
-        state: 'running',
-        nodeId: 'test-node',
-        relayToken: 'relay-token',
-        webRoute: {
-            routeId: 'https://relay.example',
-            machineId: 'test-machine',
-            targetPort: 7878,
-            url: 'https://relay.example',
-            concreteUrl: 'https://relay.example',
-            concreteUrlSource: 'config',
-            createdAt: '2026-06-26T00:00:00.000Z',
-            raw: null,
-        },
-        createdAt: '2026-06-26T00:00:00.000Z',
-        updatedAt: '2026-06-26T00:00:00.000Z',
-    });
-    const res = makeResponse();
-    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
-        status: {
-            fetch: (async () => ({
-                ok: true,
-                status: 200,
-                statusText: 'OK',
-                async text() {
-                    return 'not json';
-                },
-            })),
-        },
-    });
-    assert.equal(handled, undefined);
-    assert.equal(res.statusCode, 200);
-    const body = parseJsonBody(res);
-    assert.equal(body.runtimeStats, null);
-});
-test('status route returns machine resources from getMachine', async () => {
-    const tenantId = 'tenant-status-machine';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-machine-'));
-    const statePath = join(tempDir, 'state.json');
-    const registryPath = join(tempDir, 'homes.json');
-    writeState(statePath, tenantId);
-    writeFileSync(registryPath, `${JSON.stringify({
-        [tenantId]: {
-            tenantId,
-            providerName: 'none',
-            machineId: 'test-machine',
-            homeStorage: {
-                kind: 'volume',
-                durability: 'durable-volume',
-                longTermContract: true,
-                ownerMachineId: 'test-machine',
-                guestHome: '/home/agent',
-                volumeId: 'volume-123',
-                mountPath: '/home/agent',
-            },
-            state: 'running',
-            createdAt: '2026-06-26T00:00:00.000Z',
-            updatedAt: '2026-06-26T00:00:00.000Z',
-        },
-    }, null, 2)}\n`, 'utf8');
-    const runtime = makeRuntime(tenantId, statePath);
-    runtime.proxy.m0RegistryPath = registryPath;
-    runtime.m0.registryPath = registryPath;
-    const getMachine = async (machineId) => {
-        assert.equal(machineId, 'test-machine');
-        return {
-            providerName: 'none',
-            machineId: 'test-machine',
-            state: 'running',
-            raw: {
-                cpuCount: 2,
-                memoryMB: 2048,
-                status: 'running',
-            },
-        };
-    };
-    const res = makeResponse();
-    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
-        status: {
-            getMachine,
-            guestSource: async () => ({ ok: false, stdout: '', stderr: 'timeout' }),
-        },
-    });
-    assert.equal(handled, undefined);
-    assert.equal(res.statusCode, 200);
-    const body = parseJsonBody(res);
-    assert.deepEqual(body.machineResources, { cpuCount: 2, memoryMB: 2048 });
-});

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

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