@crouton-kit/crouter 0.3.33 → 0.3.35

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

@@ -1,437 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import { 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 { AUTH_STORAGE_STATUS_SCRIPT, AUTH_STORAGE_WRITE_SCRIPT, handleModelAuthRequest } from '../model-auth.js';
-import { finishAnthropicOAuthSession, startAnthropicOAuthSession } from '../anthropic-oauth.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) {
-    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 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);
-}
-function extractState(authUrl) {
-    return new URL(authUrl).searchParams.get('state') ?? '';
-}
-test('model-auth routes enforce auth, routing, and method guards', async () => {
-    const tenantId = 'tenant-auth-gates';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-model-auth-'));
-    const statePath = join(tempDir, 'state.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    for (const [method, url] of [
-        ['GET', '/__hearth/model-auth/anthropic/status'],
-        ['POST', '/__hearth/model-auth/anthropic/start'],
-        ['POST', '/__hearth/model-auth/anthropic/finish'],
-    ]) {
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest(method, url, {}, '{}'), res, runtime, { guestSource: async () => ({ ok: true, stdout: '{}', stderr: '', exitCode: 0 }) });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 401);
-    }
-    {
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', {
-            cookie: `hearth_owner=${encodeURIComponent(ownerToken)}`,
-            origin: 'https://evil.example',
-        }), res, runtime, { startSession: () => ({ ok: true, sessionId: 's', authUrl: 'https://example.test', expiresAt: 1 }) });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 403);
-    }
-    {
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start?token=' + encodeURIComponent(ownerToken)), res, runtime, { startSession: () => ({ ok: true, sessionId: 's', authUrl: 'https://example.test', expiresAt: 1 }) });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 401);
-    }
-    {
-        let called = 0;
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', {
-            authorization: `Bearer ${ownerToken}`,
-        }), res, runtime, {
-            startSession: (tenant) => {
-                called += 1;
-                assert.equal(tenant, tenantId);
-                return { ok: true, sessionId: 'sess-123', authUrl: 'https://example.test', expiresAt: 2 };
-            },
-        });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 200);
-        assert.equal(called, 1);
-        assert.deepEqual(parseJsonBody(res), {
-            provider: 'anthropic',
-            sessionId: 'sess-123',
-            authUrl: 'https://example.test',
-            expiresAt: 2,
-        });
-    }
-    {
-        const wrongMethodRes = makeResponse();
-        const wrongMethodHandled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/status', { authorization: `Bearer ${ownerToken}` }), wrongMethodRes, runtime);
-        assert.equal(wrongMethodHandled, true);
-        assert.equal(wrongMethodRes.statusCode, 405);
-        const unknownRes = makeResponse();
-        const unknownHandled = await handleModelAuthRequest(makeRequest('GET', '/__hearth/model-auth/anthropic/unknown', { authorization: `Bearer ${ownerToken}` }), unknownRes, runtime);
-        assert.equal(unknownHandled, true);
-        assert.equal(unknownRes.statusCode, 404);
-        const falseRes = makeResponse();
-        const falseHandled = await handleModelAuthRequest(makeRequest('GET', '/__hearth/not-model-auth', { authorization: `Bearer ${ownerToken}` }), falseRes, runtime);
-        assert.equal(falseHandled, false);
-        assert.equal(falseRes.headersSent, false);
-    }
-});
-test('model-auth start uses the bounded JSON reader and rejects oversized bodies', async () => {
-    const tenantId = 'tenant-start-body';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-model-auth-start-body-'));
-    const statePath = join(tempDir, 'state.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    let called = 0;
-    {
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', { authorization: `Bearer ${ownerToken}` }, ''), res, runtime, {
-            startSession: (tenant) => {
-                called += 1;
-                assert.equal(tenant, tenantId);
-                return { ok: true, sessionId: 'sess-empty', authUrl: 'https://example.test/empty', expiresAt: 1 };
-            },
-        });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 200);
-    }
-    {
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', { authorization: `Bearer ${ownerToken}` }, JSON.stringify({ note: 'allowed' })), res, runtime, {
-            startSession: (tenant) => {
-                called += 1;
-                assert.equal(tenant, tenantId);
-                return { ok: true, sessionId: 'sess-json', authUrl: 'https://example.test/json', expiresAt: 2 };
-            },
-        });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 200);
-    }
-    {
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', { authorization: `Bearer ${ownerToken}` }, `{}${' '.repeat(17 * 1024)}`), res, runtime, { startSession: () => { throw new Error('should not be called for oversized bodies'); } });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 400);
-    }
-    assert.equal(called, 2);
-});
-test('model-auth status uses the fixed guest script and returns only redacted status data', async () => {
-    const tenantId = 'tenant-status';
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-model-auth-status-'));
-    const statePath = join(tempDir, 'state.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    const calls = [];
-    const res = makeResponse();
-    const handled = await handleModelAuthRequest(makeRequest('GET', '/__hearth/model-auth/anthropic/status', {
-        authorization: `Bearer ${ownerToken}`,
-    }), res, runtime, {
-        guestSource: async (tenantId, request) => {
-            calls.push({ tenantId, request });
-            return {
-                ok: true,
-                exitCode: 0,
-                stdout: JSON.stringify({
-                    storedOauth: true,
-                    expiresAt: 12345,
-                    adapterConfigured: true,
-                    access_token: 'raw-access-token',
-                    refresh_token: 'raw-refresh-token',
-                    auth_json: '/home/agent/.pi/agent/auth.json',
-                }),
-                stderr: '',
-            };
-        },
-    });
-    assert.equal(handled, true);
-    assert.equal(res.statusCode, 200);
-    assert.deepEqual(parseJsonBody(res), {
-        storedOauth: true,
-        expiresAt: 12345,
-        adapterConfigured: true,
-    });
-    assert.deepEqual(calls, [{
-            tenantId,
-            request: {
-                kind: 'exec',
-                bin: 'node',
-                args: ['--input-type=module', '-e', AUTH_STORAGE_STATUS_SCRIPT],
-                cwd: '/opt/crouter',
-            },
-        }]);
-});
-test('model-auth finish uses the fixed guest write script, consumes the session, and redacts tokens', async () => {
-    const tenantId = 'tenant-finish';
-    const now = 1_700_000_000_000;
-    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-model-auth-finish-'));
-    const statePath = join(tempDir, 'state.json');
-    writeState(statePath, tenantId);
-    const runtime = makeRuntime(tenantId, statePath);
-    const calls = [];
-    const startRes = makeResponse();
-    const startHandled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', {
-        authorization: `Bearer ${ownerToken}`,
-    }), startRes, runtime, {
-        now: () => now,
-        startSession: (tenant) => startAnthropicOAuthSession(tenant, () => now),
-    });
-    assert.equal(startHandled, true);
-    assert.equal(startRes.statusCode, 200);
-    const startBody = parseJsonBody(startRes);
-    const state = extractState(startBody.authUrl);
-    assert.notEqual(state, '');
-    const finishSession = async (input) => {
-        return await finishAnthropicOAuthSession(input, {
-            now: () => now,
-            fetch: async () => ({
-                ok: true,
-                status: 200,
-                statusText: 'OK',
-                text: async () => JSON.stringify({
-                    access_token: 'live-access-token',
-                    refresh_token: 'live-refresh-token',
-                    expires_in: 3600,
-                }),
-            }),
-        });
-    };
-    const finishRes = makeResponse();
-    const finishHandled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/finish', {
-        authorization: `Bearer ${ownerToken}`,
-    }, JSON.stringify({
-        sessionId: startBody.sessionId,
-        redirectUrl: `http://localhost:53692/callback?code=code-123&state=${state}`,
-    })), finishRes, runtime, {
-        now: () => now,
-        finishSession,
-        guestSource: async (tenantId, request) => {
-            calls.push({ tenantId, request });
-            return {
-                ok: true,
-                exitCode: 0,
-                stdout: JSON.stringify({
-                    ok: true,
-                    provider: 'anthropic',
-                    storedOauth: true,
-                    expiresAt: now + 3_300_000,
-                    access_token: 'write-access-token',
-                    refresh_token: 'write-refresh-token',
-                }),
-                stderr: '',
-            };
-        },
-    });
-    assert.equal(finishHandled, true);
-    assert.equal(finishRes.statusCode, 200);
-    assert.deepEqual(parseJsonBody(finishRes), {
-        ok: true,
-        provider: 'anthropic',
-        sessionId: startBody.sessionId,
-        storedOauth: true,
-        expiresAt: now + 3_300_000,
-    });
-    assert.equal(JSON.stringify(parseJsonBody(finishRes)).includes('access'), false);
-    assert.equal(JSON.stringify(parseJsonBody(finishRes)).includes('refresh'), false);
-    assert.deepEqual(calls, [{
-            tenantId,
-            request: {
-                kind: 'exec',
-                bin: 'node',
-                args: ['--input-type=module', '-e', AUTH_STORAGE_WRITE_SCRIPT],
-                stdin: JSON.stringify({
-                    provider: 'anthropic',
-                    credential: {
-                        type: 'oauth',
-                        access: 'live-access-token',
-                        refresh: 'live-refresh-token',
-                        expires: now + 3_300_000,
-                    },
-                }),
-                cwd: '/opt/crouter',
-            },
-        }]);
-    const secondRes = makeResponse();
-    const secondHandled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/finish', {
-        authorization: `Bearer ${ownerToken}`,
-    }, JSON.stringify({
-        sessionId: startBody.sessionId,
-        redirectUrl: `http://localhost:53692/callback?code=code-123&state=${state}`,
-    })), secondRes, runtime, {
-        now: () => now,
-        finishSession,
-        guestSource: async () => ({ ok: true, exitCode: 0, stdout: '{}', stderr: '' }),
-    });
-    assert.equal(secondHandled, true);
-    assert.equal(secondRes.statusCode, 400);
-});
-test('model-auth finish rejects guest failures and strict body validation', async () => {
-    const now = 1_700_000_000_000;
-    async function makeContext(tenantId) {
-        const tempDir = mkdtempSync(join(tmpdir(), `crouter-model-auth-${tenantId}-`));
-        const statePath = join(tempDir, 'state.json');
-        writeState(statePath, tenantId);
-        const runtime = makeRuntime(tenantId, statePath);
-        async function startSession() {
-            const startRes = makeResponse();
-            const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/start', { authorization: `Bearer ${ownerToken}` }), startRes, runtime, { now: () => now, startSession: (tenant) => startAnthropicOAuthSession(tenant, () => now) });
-            assert.equal(handled, true);
-            assert.equal(startRes.statusCode, 200);
-            return parseJsonBody(startRes);
-        }
-        const finishSession = async (input) => {
-            return await finishAnthropicOAuthSession(input, {
-                now: () => now,
-                fetch: async () => ({
-                    ok: true,
-                    status: 200,
-                    statusText: 'OK',
-                    text: async () => JSON.stringify({ access_token: 'a', refresh_token: 'b', expires_in: 3600 }),
-                }),
-            });
-        };
-        return { runtime, startSession, finishSession };
-    }
-    {
-        const { runtime, startSession, finishSession } = await makeContext('tenant-finish-bridge');
-        const { sessionId, authUrl } = await startSession();
-        const state = extractState(authUrl);
-        const callbackUrl = `http://localhost:53692/callback?code=code-456&state=${state}`;
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/finish', { authorization: `Bearer ${ownerToken}` }, JSON.stringify({ sessionId, redirectUrl: callbackUrl })), res, runtime, {
-            now: () => now,
-            finishSession,
-            guestSource: async () => ({ ok: true, exitCode: 1, stdout: '', stderr: 'boom' }),
-        });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 502);
-    }
-    {
-        const { runtime, startSession, finishSession } = await makeContext('tenant-finish-status');
-        const { sessionId, authUrl } = await startSession();
-        const state = extractState(authUrl);
-        const callbackUrl = `http://localhost:53692/callback?code=code-456&state=${state}`;
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/finish', { authorization: `Bearer ${ownerToken}` }, JSON.stringify({ sessionId, redirectUrl: callbackUrl })), res, runtime, {
-            now: () => now,
-            finishSession,
-            guestSource: async () => ({
-                ok: true,
-                exitCode: 0,
-                stdout: JSON.stringify({ ok: true, provider: 'anthropic', storedOauth: false, expiresAt: now }),
-                stderr: '',
-            }),
-        });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 502);
-    }
-    {
-        const { runtime, startSession, finishSession } = await makeContext('tenant-finish-body-limit');
-        const { sessionId, authUrl } = await startSession();
-        const state = extractState(authUrl);
-        const callbackUrl = `http://localhost:53692/callback?code=code-456&state=${state}`;
-        const overLimitBody = `${JSON.stringify({ sessionId, redirectUrl: callbackUrl })}${' '.repeat(17 * 1024)}`;
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/finish', { authorization: `Bearer ${ownerToken}` }, overLimitBody), res, runtime, { now: () => now, finishSession, guestSource: async () => ({ ok: true, exitCode: 0, stdout: '{}', stderr: '' }) });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 400);
-    }
-    {
-        const { runtime, startSession, finishSession } = await makeContext('tenant-finish-body-extra');
-        const { sessionId, authUrl } = await startSession();
-        const state = extractState(authUrl);
-        const callbackUrl = `http://localhost:53692/callback?code=code-456&state=${state}`;
-        const res = makeResponse();
-        const handled = await handleModelAuthRequest(makeRequest('POST', '/__hearth/model-auth/anthropic/finish', { authorization: `Bearer ${ownerToken}` }, JSON.stringify({ sessionId, redirectUrl: callbackUrl, extra: true })), res, runtime, { now: () => now, finishSession, guestSource: async () => ({ ok: true, exitCode: 0, stdout: '{}', stderr: '' }) });
-        assert.equal(handled, true);
-        assert.equal(res.statusCode, 400);
-    }
-});

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

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