@crouton-kit/crouter 0.3.34 → 0.3.35

package/dist/hearth/wake-proxy/state.js

@@ -1,342 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { general } from '../../core/errors.js';
-import { getHome, putHome, updateHome } from '../../core/hearth/registry.js';
-import { nowIso } from '../../core/fs-utils.js';
-const LOCK_STALE_MS = 2 * 60_000;
-const DEFAULT_VERSION = 1;
-const tenantLocks = new Map();
-const tenantRuntimes = new Map();
-function ensureParentDir(path) {
-    mkdirSync(dirname(path), { recursive: true });
-}
-function atomicWriteJson(path, value) {
-    ensureParentDir(path);
-    const tmp = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-    writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
-    try {
-        renameSync(tmp, path);
-    }
-    catch (error) {
-        try {
-            rmSync(tmp, { force: true });
-        }
-        catch {
-            /* ignore */
-        }
-        throw error;
-    }
-}
-function readJsonFile(path) {
-    return JSON.parse(readFileSync(path, 'utf8'));
-}
-function normalizeProxyState(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        throw general('invalid hearth proxy state file', { valueType: value === null ? 'null' : typeof value });
-    }
-    const obj = value;
-    const owner = obj.owner;
-    if (owner === null || typeof owner !== 'object' || Array.isArray(owner)) {
-        throw general('invalid hearth proxy state owner', { valueType: typeof owner });
-    }
-    const ownerObj = owner;
-    if (typeof ownerObj.ownerUserId !== 'string' || typeof ownerObj.defaultTenantId !== 'string' || typeof ownerObj.tokenHash !== 'string') {
-        throw general('invalid hearth proxy state owner fields', { owner });
-    }
-    const tenantsRaw = obj.tenants;
-    const tenants = {};
-    if (tenantsRaw !== undefined) {
-        if (tenantsRaw === null || typeof tenantsRaw !== 'object' || Array.isArray(tenantsRaw)) {
-            throw general('invalid hearth proxy tenants map', { tenantsRaw });
-        }
-        for (const [tenantId, tenant] of Object.entries(tenantsRaw)) {
-            if (tenant === null || typeof tenant !== 'object' || Array.isArray(tenant))
-                continue;
-            const draft = tenant;
-            if (typeof draft.tenantId !== 'string' || typeof draft.ownerUserId !== 'string' || typeof draft.m0RegistryPath !== 'string' || typeof draft.idleAfterMs !== 'number' || typeof draft.updatedAt !== 'string') {
-                continue;
-            }
-            tenants[tenantId] = {
-                tenantId: draft.tenantId,
-                ownerUserId: draft.ownerUserId,
-                m0RegistryPath: draft.m0RegistryPath,
-                idleAfterMs: draft.idleAfterMs,
-                lastActivityAt: typeof draft.lastActivityAt === 'string' ? draft.lastActivityAt : null,
-                lastWakeAt: typeof draft.lastWakeAt === 'string' ? draft.lastWakeAt : null,
-                lastPauseAt: typeof draft.lastPauseAt === 'string' ? draft.lastPauseAt : null,
-                updatedAt: draft.updatedAt,
-            };
-        }
-    }
-    return {
-        version: DEFAULT_VERSION,
-        owner: {
-            ownerUserId: ownerObj.ownerUserId,
-            defaultTenantId: ownerObj.defaultTenantId,
-            tokenHash: ownerObj.tokenHash,
-            createdAt: typeof ownerObj.createdAt === 'string' ? ownerObj.createdAt : nowIso(),
-        },
-        tenants,
-    };
-}
-export function loadProxyState(statePath) {
-    if (!existsSync(statePath))
-        return null;
-    return normalizeProxyState(readJsonFile(statePath));
-}
-export function saveProxyState(statePath, state) {
-    atomicWriteJson(statePath, state);
-    return state;
-}
-export function ensureProxyState(config) {
-    const existing = loadProxyState(config.statePath);
-    const now = nowIso();
-    const base = existing ?? {
-        version: DEFAULT_VERSION,
-        owner: {
-            ownerUserId: config.ownerUserId,
-            defaultTenantId: config.defaultTenantId,
-            tokenHash: config.ownerTokenHash,
-            createdAt: now,
-        },
-        tenants: {},
-    };
-    base.owner.ownerUserId = config.ownerUserId;
-    base.owner.defaultTenantId = config.defaultTenantId;
-    base.owner.tokenHash = config.ownerTokenHash;
-    if (base.owner.createdAt.trim() === '')
-        base.owner.createdAt = now;
-    base.tenants[config.defaultTenantId] = ensureTenantState(base.tenants[config.defaultTenantId], config, now);
-    return saveProxyState(config.statePath, base);
-}
-export function getTenantState(state, tenantId) {
-    return state.tenants[tenantId] ?? null;
-}
-function ensureTenantState(existing, config, now = nowIso()) {
-    return {
-        tenantId: existing?.tenantId ?? config.defaultTenantId,
-        ownerUserId: existing?.ownerUserId ?? config.ownerUserId,
-        m0RegistryPath: existing?.m0RegistryPath ?? config.m0RegistryPath,
-        idleAfterMs: existing?.idleAfterMs ?? config.idlePauseMs,
-        lastActivityAt: existing?.lastActivityAt ?? null,
-        lastWakeAt: existing?.lastWakeAt ?? null,
-        lastPauseAt: existing?.lastPauseAt ?? null,
-        updatedAt: now,
-    };
-}
-export function updateTenantState(config, tenantId, mutate) {
-    const state = ensureProxyState(config);
-    const current = state.tenants[tenantId] ?? ensureTenantState(undefined, config);
-    const draft = { ...current, tenantId, ownerUserId: config.ownerUserId, m0RegistryPath: config.m0RegistryPath, idleAfterMs: config.idlePauseMs };
-    const next = mutate(draft) ?? draft;
-    next.updatedAt = nowIso();
-    state.tenants[tenantId] = next;
-    return saveProxyState(config.statePath, state).tenants[tenantId];
-}
-export function touchTenantActivity(config, tenantId) {
-    return updateTenantState(config, tenantId, (tenant) => {
-        tenant.lastActivityAt = nowIso();
-    });
-}
-export function touchTenantWake(config, tenantId) {
-    return updateTenantState(config, tenantId, (tenant) => {
-        tenant.lastWakeAt = nowIso();
-    });
-}
-export function touchTenantPause(config, tenantId) {
-    return updateTenantState(config, tenantId, (tenant) => {
-        tenant.lastPauseAt = nowIso();
-    });
-}
-export function withTenantLock(tenantId, fn) {
-    const previous = tenantLocks.get(tenantId) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => {
-        release = resolve;
-    });
-    const tail = previous.then(() => current, () => current);
-    tenantLocks.set(tenantId, tail);
-    return previous
-        .catch(() => undefined)
-        .then(() => Promise.resolve(fn()))
-        .finally(() => {
-        release();
-        if (tenantLocks.get(tenantId) === tail) {
-            tenantLocks.delete(tenantId);
-        }
-    });
-}
-function runtimeFor(tenantId) {
-    const existing = tenantRuntimes.get(tenantId);
-    if (existing !== undefined)
-        return existing;
-    const created = {
-        counts: { http: 0, ws: 0, wake: 0 },
-        idleDeadlineAt: null,
-        timer: null,
-    };
-    tenantRuntimes.set(tenantId, created);
-    return created;
-}
-function clearTimer(runtime) {
-    if (runtime.timer !== null) {
-        clearTimeout(runtime.timer);
-        runtime.timer = null;
-    }
-    runtime.idleDeadlineAt = null;
-}
-export function beginActivity(config, tenantId, kind) {
-    const runtime = runtimeFor(tenantId);
-    runtime.counts[kind] += 1;
-    clearTimer(runtime);
-    touchTenantActivity(config, tenantId);
-    return {
-        tenantId,
-        kind,
-        acquiredAt: nowIso(),
-        closed: false,
-    };
-}
-export function endActivity(handle) {
-    const runtime = runtimeFor(handle.tenantId);
-    if (!handle.closed) {
-        handle.closed = true;
-        runtime.counts[handle.kind] = Math.max(0, runtime.counts[handle.kind] - 1);
-    }
-    const total = runtime.counts.http + runtime.counts.ws + runtime.counts.wake;
-    return {
-        tenantId: handle.tenantId,
-        counts: { ...runtime.counts },
-        total,
-        idleDeadlineAt: runtime.idleDeadlineAt,
-    };
-}
-export function getTenantActivitySnapshot(tenantId) {
-    const runtime = runtimeFor(tenantId);
-    return {
-        tenantId,
-        counts: { ...runtime.counts },
-        total: runtime.counts.http + runtime.counts.ws + runtime.counts.wake,
-        idleDeadlineAt: runtime.idleDeadlineAt,
-    };
-}
-export function setTenantIdleTimer(tenantId, deadlineAt, timer) {
-    const runtime = runtimeFor(tenantId);
-    clearTimer(runtime);
-    runtime.idleDeadlineAt = deadlineAt;
-    runtime.timer = timer;
-}
-export function clearTenantIdleTimer(tenantId) {
-    clearTimer(runtimeFor(tenantId));
-}
-export function readTenantHome(config, tenantId) {
-    return getHome(config.m0RegistryPath, tenantId);
-}
-function mergeHomeStorage(home, m0Config, volumeId) {
-    const next = { ...home };
-    next.providerName = m0Config.providerName;
-    next.homeStorage = {
-        kind: 'volume',
-        durability: 'durable-volume',
-        longTermContract: true,
-        ownerMachineId: home.machineId,
-        guestHome: m0Config.guestHome,
-        volumeId,
-        mountPath: m0Config.guestHome,
-    };
-    return next;
-}
-export function ensureSeededM0Registry(config, m0Config) {
-    const existing = getHome(config.m0RegistryPath, config.defaultTenantId);
-    if (existing !== null) {
-        if (typeof existing.machineId !== 'string' || existing.machineId.trim() === '') {
-            throw general('hearth m0 registry is missing machineId — run the existing M0 provision/bootstrap flow before starting the wake proxy', {
-                tenantId: config.defaultTenantId,
-                registryPath: config.m0RegistryPath,
-            });
-        }
-        const updated = updateHome(config.m0RegistryPath, config.defaultTenantId, (home) => {
-            if (home.providerName !== m0Config.providerName)
-                home.providerName = m0Config.providerName;
-            if (!home.homeStorage || home.homeStorage.volumeId.trim() === '') {
-                if (config.seedHome === null) {
-                    throw general('hearth m0 registry is missing homeStorage.volumeId and no seed home was provided', {
-                        tenantId: config.defaultTenantId,
-                        registryPath: config.m0RegistryPath,
-                    });
-                }
-                home.homeStorage = mergeHomeStorage(home, m0Config, config.seedHome.volumeId).homeStorage;
-            }
-            else {
-                home.homeStorage = {
-                    ...home.homeStorage,
-                    ownerMachineId: home.machineId,
-                    guestHome: m0Config.guestHome,
-                    mountPath: m0Config.guestHome,
-                };
-            }
-            if ((typeof home.nodeId !== 'string' || home.nodeId.trim() === '') && config.seedHome?.nodeId) {
-                home.nodeId = config.seedHome.nodeId;
-            }
-            if ((typeof home.relayToken !== 'string' || home.relayToken.trim() === '') && config.seedHome?.relayToken) {
-                home.relayToken = config.seedHome.relayToken;
-            }
-            if (home.state === undefined || home.state === null || home.state === '') {
-                home.state = config.seedHome?.state ?? 'running';
-            }
-            if ((home.webRoute === undefined || home.webRoute === null) && config.seedHome?.webRouteUrl) {
-                home.webRoute = {
-                    routeId: config.seedHome.webRouteUrl,
-                    machineId: home.machineId,
-                    targetPort: m0Config.webPort,
-                    url: config.seedHome.webRouteUrl,
-                    concreteUrl: config.seedHome.webRouteUrl,
-                    concreteUrlSource: 'config',
-                    createdAt: nowIso(),
-                    raw: null,
-                };
-            }
-            home.updatedAt = nowIso();
-        });
-        return updated;
-    }
-    if (config.seedHome === null) {
-        throw general('hearth m0 registry is empty and no HEARTH_SEED_* values were provided — run the existing M0 provision/bootstrap flow before starting the wake proxy', {
-            registryPath: config.m0RegistryPath,
-            tenantId: config.defaultTenantId,
-        });
-    }
-    const now = nowIso();
-    const home = {
-        tenantId: config.seedHome.tenantId,
-        providerName: m0Config.providerName,
-        machineId: config.seedHome.machineId,
-        homeStorage: {
-            kind: 'volume',
-            durability: 'durable-volume',
-            longTermContract: true,
-            ownerMachineId: config.seedHome.machineId,
-            guestHome: m0Config.guestHome,
-            volumeId: config.seedHome.volumeId,
-            mountPath: m0Config.guestHome,
-        },
-        state: config.seedHome.state ?? 'running',
-        nodeId: config.seedHome.nodeId,
-        relayToken: config.seedHome.relayToken,
-        webRoute: config.seedHome.webRouteUrl
-            ? {
-                routeId: config.seedHome.webRouteUrl,
-                machineId: config.seedHome.machineId,
-                targetPort: m0Config.webPort,
-                url: config.seedHome.webRouteUrl,
-                concreteUrl: config.seedHome.webRouteUrl,
-                concreteUrlSource: 'config',
-                createdAt: now,
-                raw: null,
-            }
-            : null,
-        createdAt: now,
-        updatedAt: now,
-    };
-    return putHome(config.m0RegistryPath, home);
-}

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

@@ -1,76 +0,0 @@
-import type { GuestNodeId, MachineId, MachineState, M0Config, RelayToken, TenantId } from '../../core/hearth/types.js';
-export interface HearthProxyOwnerState {
-    ownerUserId: string;
-    defaultTenantId: TenantId;
-    tokenHash: string;
-    createdAt: string;
-}
-export interface HearthProxyTenantState {
-    tenantId: TenantId;
-    ownerUserId: string;
-    m0RegistryPath: string;
-    idleAfterMs: number;
-    lastActivityAt: string | null;
-    lastWakeAt: string | null;
-    lastPauseAt: string | null;
-    updatedAt: string;
-}
-export interface HearthProxyState {
-    version: 1;
-    owner: HearthProxyOwnerState;
-    tenants: Record<TenantId, HearthProxyTenantState>;
-}
-export interface HearthProxySeedHome {
-    tenantId: TenantId;
-    machineId: MachineId;
-    nodeId: GuestNodeId;
-    relayToken: RelayToken;
-    volumeId: string;
-    state?: MachineState | null;
-    webRouteUrl?: string | null;
-}
-export interface HearthProxyConfig {
-    host: string;
-    port: number;
-    publicOrigin: string;
-    statePath: string;
-    m0RegistryPath: string;
-    ownerUserId: string;
-    defaultTenantId: TenantId;
-    ownerTokenHash: string;
-    idlePauseMs: number;
-    wakeTimeoutMs: number;
-    readyTimeoutMs: number;
-    cookieSecure: boolean;
-    seedHome: HearthProxySeedHome | null;
-}
-export interface HearthWakeProxyRuntime {
-    proxy: HearthProxyConfig;
-    m0: M0Config;
-}
-export type ActivityKind = 'http' | 'ws' | 'wake';
-export interface TenantActivitySnapshot {
-    tenantId: TenantId;
-    counts: Record<ActivityKind, number>;
-    total: number;
-    idleDeadlineAt: string | null;
-}
-export interface ActivityHandle {
-    tenantId: TenantId;
-    kind: ActivityKind;
-    acquiredAt: string;
-    closed: boolean;
-}
-export interface AwakenedHome {
-    tenantId: TenantId;
-    nodeId: GuestNodeId;
-    routeUrl: string;
-    relayToken: RelayToken;
-    machineId: MachineId;
-    webPort: number;
-}
-export interface WakeProxyLogger {
-    info(message: string, details?: Record<string, unknown>): void;
-    warn(message: string, details?: Record<string, unknown>): void;
-    error(message: string, details?: Record<string, unknown>): void;
-}

package/dist/hearth/wake-proxy/types.js

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