@crouton-kit/crouter 0.3.32 → 0.3.34

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

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

@@ -0,0 +1,35 @@
+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 {};