@crouton-kit/crouter 0.3.34 → 0.3.35

package/dist/hearth/wake-proxy/model-auth.js

@@ -1,345 +0,0 @@
-import { general } from '../../core/errors.js';
-import { currentProxyState, resolveOwnerAuth, resolveOwnerWriteAuth } from './auth.js';
-import { finishAnthropicOAuthSession, startAnthropicOAuthSession } from './anthropic-oauth.js';
-import { redactWakeProxyMessage } from './redact.js';
-import { requireSuccessfulExec, runGuestSource } from './guest-source.js';
-const MODEL_AUTH_PREFIX = '/__hearth/model-auth/anthropic/';
-const BODY_LIMIT_BYTES = 16 * 1024;
-export const AUTH_STORAGE_STATUS_SCRIPT = `import { AuthStorage } from '@earendil-works/pi-coding-agent';
-
-const storage = AuthStorage.create();
-const credential = storage.get('anthropic');
-const firstErrors = storage.drainErrors();
-if (firstErrors.length > 0) {
-  throw new Error(firstErrors.map((error) => error.message).join('; '));
-}
-const adapterConfigured = storage.getOAuthProviders().some((provider) => provider.id === 'anthropic');
-const storedOauth = credential?.type === 'oauth';
-const expiresAt = storedOauth ? credential.expires : null;
-console.log(JSON.stringify({ storedOauth, expiresAt, adapterConfigured }));
-`;
-export const AUTH_STORAGE_WRITE_SCRIPT = `import { AuthStorage } from '@earendil-works/pi-coding-agent';
-
-const input = JSON.parse(await new Promise((resolve, reject) => {
-  let value = '';
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', (chunk) => { value += chunk; });
-  process.stdin.on('end', () => resolve(value));
-  process.stdin.on('error', reject);
-}));
-if (!input || typeof input !== 'object') throw new Error('expected stdin JSON object');
-if (input.provider !== 'anthropic') throw new Error('expected anthropic provider');
-const credential = input.credential;
-if (!credential || typeof credential !== 'object' || credential.type !== 'oauth') throw new Error('expected oauth credential');
-if (typeof credential.refresh !== 'string' || typeof credential.access !== 'string' || typeof credential.expires !== 'number') throw new Error('expected oauth credential fields');
-const storage = AuthStorage.create();
-storage.set('anthropic', credential);
-const firstErrors = storage.drainErrors();
-if (firstErrors.length > 0) {
-  throw new Error(firstErrors.map((error) => error.message).join('; '));
-}
-const reread = AuthStorage.create();
-const stored = reread.get('anthropic');
-const rereadErrors = reread.drainErrors();
-if (rereadErrors.length > 0) {
-  throw new Error(rereadErrors.map((error) => error.message).join('; '));
-}
-if (!stored || stored.type !== 'oauth' || stored.refresh !== credential.refresh || stored.access !== credential.access || stored.expires !== credential.expires) {
-  throw new Error('stored anthropic oauth credential did not round-trip');
-}
-console.log(JSON.stringify({ ok: true, provider: 'anthropic', storedOauth: true, expiresAt: stored.expires }));
-`;
-function requestPathname(req) {
-    return new URL(req.url ?? '/', 'http://127.0.0.1').pathname;
-}
-function respondJson(res, statusCode, value) {
-    const body = `${JSON.stringify(value, null, 2)}\n`;
-    res.writeHead(statusCode, {
-        'content-type': 'application/json; charset=utf-8',
-        'content-length': Buffer.byteLength(body),
-        'cache-control': 'no-store',
-    });
-    res.end(body);
-}
-function respondText(res, statusCode, message) {
-    const body = `${redactWakeProxyMessage(message)}\n`;
-    res.writeHead(statusCode, {
-        'content-type': 'text/plain; charset=utf-8',
-        'content-length': Buffer.byteLength(body),
-        'cache-control': 'no-store',
-    });
-    res.end(body);
-}
-async function readJsonBody(req, limitBytes) {
-    return await new Promise((resolve, reject) => {
-        const chunks = [];
-        let bytes = 0;
-        const cleanup = () => {
-            req.off('data', onData);
-            req.off('end', onEnd);
-            req.off('error', onError);
-            req.off('aborted', onAbort);
-        };
-        const onData = (chunk) => {
-            bytes += chunk.byteLength;
-            if (bytes > limitBytes) {
-                cleanup();
-                req.destroy();
-                reject(general('request body too large', { limitBytes }));
-                return;
-            }
-            chunks.push(chunk);
-        };
-        const onEnd = () => {
-            cleanup();
-            try {
-                const text = Buffer.concat(chunks).toString('utf8');
-                resolve(text === '' ? {} : JSON.parse(text));
-            }
-            catch (error) {
-                reject(error);
-            }
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error instanceof Error ? error : new Error(String(error)));
-        };
-        const onAbort = () => {
-            cleanup();
-            reject(general('request aborted while reading body'));
-        };
-        req.on('data', onData);
-        req.once('end', onEnd);
-        req.once('error', onError);
-        req.once('aborted', onAbort);
-    });
-}
-function isPlainObject(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function isAnthropicModelAuthPath(pathname) {
-    return pathname === '/__hearth/model-auth/anthropic/status'
-        || pathname === '/__hearth/model-auth/anthropic/start'
-        || pathname === '/__hearth/model-auth/anthropic/finish'
-        || pathname.startsWith(MODEL_AUTH_PREFIX);
-}
-function parseFinishBody(body) {
-    if (body === null || typeof body !== 'object' || Array.isArray(body))
-        return null;
-    const value = body;
-    if (Object.keys(value).length !== 2)
-        return null;
-    const sessionId = typeof value.sessionId === 'string' ? value.sessionId.trim() : '';
-    const redirectUrl = typeof value.redirectUrl === 'string' ? value.redirectUrl.trim() : '';
-    if (sessionId === '' || redirectUrl === '')
-        return null;
-    return { sessionId, redirectUrl };
-}
-function sendAnthropicStatusError(res, status, error) {
-    respondText(res, status, error);
-}
-function resolveModelAuth(req, runtime, write) {
-    try {
-        const state = currentProxyState(runtime);
-        const auth = write ? resolveOwnerWriteAuth(req, runtime.proxy, state) : resolveOwnerAuth(req, runtime.proxy, state);
-        if (auth === null)
-            return null;
-        return { ownerUserId: auth.ownerUserId, tenantId: auth.tenantId };
-    }
-    catch (error) {
-        throw error instanceof Error ? error : new Error(String(error));
-    }
-}
-function parseAnthropicOAuthStatus(stdout) {
-    try {
-        const parsed = JSON.parse(stdout);
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
-            return null;
-        const value = parsed;
-        if (typeof value.storedOauth !== 'boolean' || typeof value.adapterConfigured !== 'boolean')
-            return null;
-        if (value.expiresAt !== null && typeof value.expiresAt !== 'number')
-            return null;
-        return {
-            storedOauth: value.storedOauth,
-            expiresAt: value.expiresAt === null ? null : value.expiresAt,
-            adapterConfigured: value.adapterConfigured,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function parseAnthropicOAuthFinishStatus(stdout) {
-    try {
-        const parsed = JSON.parse(stdout);
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
-            return null;
-        const value = parsed;
-        if (value.ok !== true || value.provider !== 'anthropic' || value.storedOauth !== true || typeof value.expiresAt !== 'number')
-            return null;
-        return { ok: true, provider: 'anthropic', storedOauth: true, expiresAt: value.expiresAt };
-    }
-    catch {
-        return null;
-    }
-}
-async function handleAnthropicStatus(req, res, runtime, deps) {
-    let auth;
-    try {
-        auth = resolveModelAuth(req, runtime, false);
-    }
-    catch {
-        sendAnthropicStatusError(res, 403, 'forbidden');
-        return;
-    }
-    if (auth === null) {
-        sendAnthropicStatusError(res, 401, 'owner token required');
-        return;
-    }
-    try {
-        const raw = await (deps.guestSource ?? runGuestSource)(auth.tenantId, {
-            kind: 'exec',
-            bin: 'node',
-            args: ['--input-type=module', '-e', AUTH_STORAGE_STATUS_SCRIPT],
-            cwd: runtime.m0.guestCodePath,
-        }, {
-            now: deps.now,
-            wakeTimeoutMs: runtime.proxy.wakeTimeoutMs,
-            bridgeTimeoutMs: runtime.proxy.wakeTimeoutMs,
-        });
-        const successful = requireSuccessfulExec(raw, 'read anthropic auth');
-        const parsed = parseAnthropicOAuthStatus(successful.stdout);
-        if (parsed === null) {
-            throw general('anthropic auth status returned invalid data');
-        }
-        respondJson(res, 200, parsed);
-    }
-    catch (error) {
-        respondJson(res, 502, { error: redactWakeProxyMessage(error instanceof Error ? error.message : String(error)) });
-    }
-}
-async function handleAnthropicStart(req, res, runtime, deps) {
-    let auth;
-    try {
-        auth = resolveModelAuth(req, runtime, true);
-    }
-    catch {
-        sendAnthropicStatusError(res, 403, 'forbidden');
-        return;
-    }
-    if (auth === null) {
-        sendAnthropicStatusError(res, 401, 'owner token required');
-        return;
-    }
-    let body;
-    try {
-        body = await readJsonBody(req, BODY_LIMIT_BYTES);
-    }
-    catch (error) {
-        respondJson(res, 400, { error: redactWakeProxyMessage(error instanceof Error ? error.message : String(error)) });
-        return;
-    }
-    if (!isPlainObject(body)) {
-        respondJson(res, 400, { error: 'start request must be empty or a JSON object' });
-        return;
-    }
-    const started = (deps.startSession ?? startAnthropicOAuthSession)(auth.tenantId, deps.now ?? Date.now);
-    respondJson(res, 200, {
-        provider: 'anthropic',
-        sessionId: started.sessionId,
-        authUrl: started.authUrl,
-        expiresAt: started.expiresAt,
-    });
-}
-async function handleAnthropicFinish(req, res, runtime, deps) {
-    let auth;
-    try {
-        auth = resolveModelAuth(req, runtime, true);
-    }
-    catch {
-        sendAnthropicStatusError(res, 403, 'forbidden');
-        return;
-    }
-    if (auth === null) {
-        sendAnthropicStatusError(res, 401, 'owner token required');
-        return;
-    }
-    let body;
-    try {
-        body = await readJsonBody(req, BODY_LIMIT_BYTES);
-    }
-    catch (error) {
-        respondJson(res, 400, { error: redactWakeProxyMessage(error instanceof Error ? error.message : String(error)) });
-        return;
-    }
-    const parsed = parseFinishBody(body);
-    if (parsed === null) {
-        respondJson(res, 400, { error: 'finish request must be { sessionId, redirectUrl }' });
-        return;
-    }
-    try {
-        const finished = await (deps.finishSession ?? finishAnthropicOAuthSession)({ tenantId: auth.tenantId, sessionId: parsed.sessionId, redirectUrl: parsed.redirectUrl });
-        if (!finished.ok) {
-            respondJson(res, finished.status, { error: finished.error });
-            return;
-        }
-        const raw = await (deps.guestSource ?? runGuestSource)(auth.tenantId, {
-            kind: 'exec',
-            bin: 'node',
-            args: ['--input-type=module', '-e', AUTH_STORAGE_WRITE_SCRIPT],
-            stdin: JSON.stringify({ provider: 'anthropic', credential: finished.credential }),
-            cwd: runtime.m0.guestCodePath,
-        }, {
-            now: deps.now,
-            wakeTimeoutMs: runtime.proxy.wakeTimeoutMs,
-            bridgeTimeoutMs: runtime.proxy.wakeTimeoutMs,
-        });
-        const successful = requireSuccessfulExec(raw, 'write anthropic auth');
-        const parsedStatus = parseAnthropicOAuthFinishStatus(successful.stdout);
-        if (parsedStatus === null) {
-            throw general('anthropic auth write returned invalid data');
-        }
-        respondJson(res, 200, {
-            ok: true,
-            provider: parsedStatus.provider,
-            sessionId: finished.sessionId,
-            storedOauth: parsedStatus.storedOauth,
-            expiresAt: parsedStatus.expiresAt,
-        });
-    }
-    catch (error) {
-        respondJson(res, 502, { error: redactWakeProxyMessage(error instanceof Error ? error.message : String(error)) });
-    }
-}
-export async function handleModelAuthRequest(req, res, runtime, deps = {}) {
-    const pathname = requestPathname(req);
-    if (!isAnthropicModelAuthPath(pathname))
-        return false;
-    if (pathname === '/__hearth/model-auth/anthropic/status') {
-        if (req.method !== 'GET') {
-            respondText(res, 405, 'method not allowed');
-            return true;
-        }
-        await handleAnthropicStatus(req, res, runtime, deps);
-        return true;
-    }
-    if (pathname === '/__hearth/model-auth/anthropic/start') {
-        if (req.method !== 'POST') {
-            respondText(res, 405, 'method not allowed');
-            return true;
-        }
-        await handleAnthropicStart(req, res, runtime, deps);
-        return true;
-    }
-    if (pathname === '/__hearth/model-auth/anthropic/finish') {
-        if (req.method !== 'POST') {
-            respondText(res, 405, 'method not allowed');
-            return true;
-        }
-        await handleAnthropicFinish(req, res, runtime, deps);
-        return true;
-    }
-    respondText(res, 404, 'not found');
-    return true;
-}

package/dist/hearth/wake-proxy/proxy.d.ts

@@ -1,35 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Socket } from 'node:net';
-import { WebSocket } from 'ws';
-import type { HearthWakeProxyRuntime } from './types.js';
-export declare function serializeWakeProxyError(error: unknown): Record<string, unknown>;
-export declare function isPublicStaticAssetPath(pathname: string): boolean;
-export declare function buildUpstreamHttpUrl(routeUrl: string, rawRequestUrl: string | undefined): URL;
-declare function withWakeTimeout<T>(work: Promise<T>, timeoutMs: number, label: string): Promise<T>;
-export declare const proxyInternals: {
-    withWakeTimeout: typeof withWakeTimeout;
-    attachWsKeepalive: typeof attachWsKeepalive;
-    proxyWebSocketBrowser: typeof proxyWebSocketBrowser;
-};
-export declare function proxyHttpRequest(req: IncomingMessage, res: ServerResponse, runtime: HearthWakeProxyRuntime): Promise<void>;
-type WsLeg = 'browser' | 'upstream';
-type WsKeepaliveContext = {
-    nodeId: string;
-    tenantId: string;
-    leg: WsLeg;
-};
-type AttachWsKeepaliveOptions = {
-    intervalMs?: number;
-    onStale?: () => void;
-};
-declare function attachWsKeepalive(socket: WebSocket, context: WsKeepaliveContext, options?: AttachWsKeepaliveOptions): () => void;
-export interface ProxyWebSocketDeps {
-    ensureAwake?: (tenantId: string) => Promise<{
-        routeUrl: string;
-        relayToken: string;
-    }>;
-    createUpstream?: (url: string, relayToken: string) => WebSocket;
-}
-declare function proxyWebSocketBrowser(browserWs: WebSocket, nodeId: string, tenantId: string, runtime: HearthWakeProxyRuntime, deps?: ProxyWebSocketDeps): Promise<void>;
-export declare function proxyUpgrade(req: IncomingMessage, socket: Socket, head: Buffer, runtime: HearthWakeProxyRuntime): void;
-export {};