@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/script-health-monitor.d.ts

@@ -0,0 +1,39 @@
+import type { ServiceProxySubsystem } from "./service-proxy.js";
+export type ScriptHealthState = "pending" | "healthy" | "unhealthy";
+export interface ScriptHealthEntry {
+    scriptName: string;
+    hostname: string;
+    port: number;
+    health: ScriptHealthState;
+}
+export declare class ScriptHealthMonitor {
+    private readonly serviceProxy;
+    private readonly onChange;
+    private readonly pollIntervalMs;
+    private readonly probeTimeoutMs;
+    private readonly graceMs;
+    private readonly failuresBeforeStopped;
+    private readonly routeStates;
+    private readonly lastEmittedSnapshots;
+    private intervalHandle;
+    private pollInFlight;
+    constructor({ serviceProxy, onChange, pollIntervalMs, probeTimeoutMs, graceMs, failuresBeforeStopped, }: {
+        serviceProxy: ServiceProxySubsystem;
+        onChange: (workspaceId: string, scripts: ScriptHealthEntry[]) => void;
+        pollIntervalMs?: number;
+        probeTimeoutMs?: number;
+        graceMs?: number;
+        failuresBeforeStopped?: number;
+    });
+    start(): void;
+    stop(): void;
+    invalidateWorkspace(workspaceId: string): void;
+    private poll;
+    private getOrCreateState;
+    private pruneRemovedRoutes;
+    private buildWorkspaceScriptList;
+    getHealthForHostname(hostname: string): ScriptHealthState | null;
+    private toScriptHealthEntry;
+    private probeRoute;
+}
+//# sourceMappingURL=script-health-monitor.d.ts.map

package/dist/server/server/script-health-monitor.js

@@ -0,0 +1,159 @@
+import net from "node:net";
+export class ScriptHealthMonitor {
+    constructor({ serviceProxy, onChange, pollIntervalMs = 3000, probeTimeoutMs = 500, graceMs = 5000, failuresBeforeStopped = 2, }) {
+        this.routeStates = new Map();
+        this.lastEmittedSnapshots = new Map();
+        this.intervalHandle = null;
+        this.pollInFlight = false;
+        this.serviceProxy = serviceProxy;
+        this.onChange = onChange;
+        this.pollIntervalMs = pollIntervalMs;
+        this.probeTimeoutMs = probeTimeoutMs;
+        this.graceMs = graceMs;
+        this.failuresBeforeStopped = failuresBeforeStopped;
+    }
+    start() {
+        if (this.intervalHandle) {
+            return;
+        }
+        const now = Date.now();
+        for (const route of this.serviceProxy.getHealthCheckTargets()) {
+            this.getOrCreateState(route, now);
+        }
+        this.intervalHandle = setInterval(() => {
+            void this.poll();
+        }, this.pollIntervalMs);
+    }
+    stop() {
+        if (this.intervalHandle) {
+            clearInterval(this.intervalHandle);
+            this.intervalHandle = null;
+        }
+    }
+    invalidateWorkspace(workspaceId) {
+        const scripts = this.buildWorkspaceScriptList(workspaceId);
+        const snapshot = JSON.stringify(scripts);
+        if (snapshot === this.lastEmittedSnapshots.get(workspaceId)) {
+            return;
+        }
+        this.lastEmittedSnapshots.set(workspaceId, snapshot);
+        this.onChange(workspaceId, scripts);
+    }
+    async poll() {
+        if (this.pollInFlight) {
+            return;
+        }
+        this.pollInFlight = true;
+        try {
+            const routes = this.serviceProxy.getHealthCheckTargets();
+            const activeHostnames = new Set(routes.map((route) => route.hostname));
+            const changedWorkspaceIds = new Set();
+            const now = Date.now();
+            const probeTargets = routes
+                .map((route) => ({ route, state: this.getOrCreateState(route, now) }))
+                .filter(({ state }) => now - state.registeredAt >= this.graceMs);
+            const healthResults = await Promise.all(probeTargets.map(({ route }) => this.probeRoute(route.port)));
+            for (let i = 0; i < probeTargets.length; i += 1) {
+                const { route, state } = probeTargets[i];
+                const isHealthy = healthResults[i];
+                const previousHealth = state.health;
+                if (isHealthy) {
+                    state.consecutiveFailures = 0;
+                    state.health = "healthy";
+                }
+                else {
+                    state.consecutiveFailures += 1;
+                    if (state.consecutiveFailures >= this.failuresBeforeStopped) {
+                        state.health = "unhealthy";
+                    }
+                }
+                if (state.health !== previousHealth) {
+                    changedWorkspaceIds.add(route.workspaceId);
+                }
+            }
+            this.pruneRemovedRoutes(activeHostnames);
+            for (const workspaceId of changedWorkspaceIds) {
+                const scripts = this.buildWorkspaceScriptList(workspaceId);
+                const snapshot = JSON.stringify(scripts);
+                if (snapshot === this.lastEmittedSnapshots.get(workspaceId)) {
+                    continue;
+                }
+                this.lastEmittedSnapshots.set(workspaceId, snapshot);
+                this.onChange(workspaceId, scripts);
+            }
+        }
+        finally {
+            this.pollInFlight = false;
+        }
+    }
+    getOrCreateState(route, registeredAt) {
+        const existing = this.routeStates.get(route.hostname);
+        if (existing) {
+            return existing;
+        }
+        const state = {
+            workspaceId: route.workspaceId,
+            health: "pending",
+            consecutiveFailures: 0,
+            registeredAt,
+        };
+        this.routeStates.set(route.hostname, state);
+        return state;
+    }
+    pruneRemovedRoutes(activeHostnames) {
+        for (const [hostname, state] of this.routeStates.entries()) {
+            if (activeHostnames.has(hostname)) {
+                continue;
+            }
+            this.routeStates.delete(hostname);
+            this.lastEmittedSnapshots.delete(state.workspaceId);
+        }
+    }
+    buildWorkspaceScriptList(workspaceId) {
+        return this.serviceProxy.getWorkspaceHealthTargets(workspaceId).flatMap((route) => {
+            const state = this.routeStates.get(route.hostname);
+            if (!state) {
+                return [];
+            }
+            return [this.toScriptHealthEntry(route, state.health)];
+        });
+    }
+    getHealthForHostname(hostname) {
+        const state = this.routeStates.get(hostname);
+        if (state) {
+            return state.health;
+        }
+        const route = this.serviceProxy.getHealthTargetForHostname(hostname);
+        if (!route) {
+            return null;
+        }
+        return this.getOrCreateState(route, Date.now()).health;
+    }
+    toScriptHealthEntry(route, health) {
+        return {
+            scriptName: route.scriptName,
+            hostname: route.hostname,
+            port: route.port,
+            health,
+        };
+    }
+    probeRoute(port) {
+        return new Promise((resolve) => {
+            const socket = net.connect({ host: "127.0.0.1", port });
+            let settled = false;
+            const finish = (healthy) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                socket.destroy();
+                resolve(healthy);
+            };
+            socket.setTimeout(this.probeTimeoutMs);
+            socket.once("connect", () => finish(true));
+            socket.once("timeout", () => finish(false));
+            socket.once("error", () => finish(false));
+        });
+    }
+}
+//# sourceMappingURL=script-health-monitor.js.map

package/dist/server/server/script-proxy.d.ts

@@ -0,0 +1,3 @@
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, ServiceProxyRouteCollisionError, } from "./service-proxy.js";
+export type { ScriptRoute, ScriptRouteEntry } from "./service-proxy.js";
+//# sourceMappingURL=script-proxy.d.ts.map

package/dist/server/server/script-proxy.js

@@ -0,0 +1,2 @@
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, ServiceProxyRouteCollisionError, } from "./service-proxy.js";
+//# sourceMappingURL=script-proxy.js.map

package/dist/server/server/script-route-branch-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "pino";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
+interface BranchChangeRouteHandlerOptions {
+    serviceProxy: ServiceProxySubsystem;
+    onRoutesChanged: (workspaceId: string) => void;
+    logger?: Logger;
+}
+export declare function createBranchChangeRouteHandler(options: BranchChangeRouteHandlerOptions): (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void;
+export {};
+//# sourceMappingURL=script-route-branch-handler.d.ts.map

package/dist/server/server/script-route-branch-handler.js

@@ -0,0 +1,11 @@
+export function createBranchChangeRouteHandler(options) {
+    return (workspaceId, _oldBranch, newBranch) => {
+        const changed = options.serviceProxy.replaceWorkspaceBranchRoutes({ workspaceId, newBranch });
+        if (!changed) {
+            return;
+        }
+        options.logger?.info({ workspaceId, newBranch }, "Updated service proxy routes for branch rename");
+        options.onRoutesChanged(workspaceId);
+    };
+}
+//# sourceMappingURL=script-route-branch-handler.js.map

package/dist/server/server/script-status-projection.d.ts

@@ -0,0 +1,36 @@
+import type { Logger } from "pino";
+import type { SessionOutboundMessage, WorkspaceScriptPayload } from "@hyperdrive.bot/paseo-protocol/messages";
+import type { PaseoConfig } from "@hyperdrive.bot/paseo-protocol/paseo-config-schema";
+import type { ScriptHealthEntry, ScriptHealthState } from "./script-health-monitor.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
+import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+interface SessionEmitter {
+    emit(message: SessionOutboundMessage): void;
+}
+interface BuildWorkspaceScriptPayloadsOptions {
+    workspaceId: string;
+    workspaceDirectory: string;
+    paseoConfig: PaseoConfig | null;
+    serviceProxy: ServiceProxySubsystem;
+    runtimeStore: WorkspaceScriptRuntimeStore;
+    daemonPort: number | null;
+    serviceProxyPublicBaseUrl?: string | null;
+    gitMetadata?: {
+        projectSlug: string;
+        currentBranch: string | null;
+    };
+    resolveHealth?: (hostname: string) => ScriptHealthState | null;
+}
+export declare function readPaseoConfigForProjection(workspaceDirectory: string, logger: Logger): PaseoConfig | null;
+export declare function buildWorkspaceScriptPayloads(options: BuildWorkspaceScriptPayloadsOptions): WorkspaceScriptPayload[];
+export declare function createScriptStatusEmitter({ sessions, serviceProxy, runtimeStore, daemonPort, serviceProxyPublicBaseUrl, resolveWorkspaceDirectory, logger, }: {
+    sessions: () => SessionEmitter[];
+    serviceProxy: ServiceProxySubsystem;
+    runtimeStore: WorkspaceScriptRuntimeStore;
+    daemonPort: number | null | (() => number | null);
+    serviceProxyPublicBaseUrl?: string | null;
+    resolveWorkspaceDirectory: (workspaceId: string) => string | null | Promise<string | null>;
+    logger: Logger;
+}): (workspaceId: string, scripts: ScriptHealthEntry[]) => void;
+export {};
+//# sourceMappingURL=script-status-projection.d.ts.map

package/dist/server/server/script-status-projection.js

@@ -0,0 +1,200 @@
+import { getScriptConfigs, isServiceScript, readPaseoConfig } from "../utils/worktree.js";
+import { deriveProjectSlug } from "./workspace-git-metadata.js";
+export function readPaseoConfigForProjection(workspaceDirectory, logger) {
+    const result = readPaseoConfig(workspaceDirectory);
+    if (result.ok) {
+        return result.config;
+    }
+    logger.warn({ configPath: result.configPath, workspaceDirectory, err: result.error }, "Failed to parse paseo.json; treating workspace as having no scripts");
+    return null;
+}
+function resolveDaemonPort(daemonPort) {
+    if (typeof daemonPort === "function") {
+        return daemonPort();
+    }
+    return daemonPort;
+}
+function toWireHealth(health) {
+    if (health === "pending" || health === null) {
+        return null;
+    }
+    return health;
+}
+function sortPayloads(payloads) {
+    return payloads.sort((left, right) => left.scriptName.localeCompare(right.scriptName, undefined, {
+        numeric: true,
+        sensitivity: "base",
+    }));
+}
+function projectWorkspaceServiceState(params) {
+    return params.ctx.serviceProxy.projectWorkspaceServiceState({
+        workspaceId: params.workspaceId,
+        projectSlug: params.ctx.projectSlug,
+        branchName: params.ctx.branchName,
+        scriptName: params.scriptName,
+        daemonPort: params.ctx.daemonPort,
+        publicBaseUrl: params.ctx.serviceProxyPublicBaseUrl,
+    });
+}
+function buildConfiguredPlainScriptPayload(scriptName, runtimeEntry) {
+    return {
+        scriptName,
+        type: "script",
+        hostname: scriptName,
+        port: null,
+        proxyUrl: null,
+        lifecycle: runtimeEntry?.lifecycle ?? "stopped",
+        health: null,
+        exitCode: runtimeEntry?.exitCode ?? null,
+        terminalId: runtimeEntry?.terminalId ?? null,
+    };
+}
+function buildConfiguredScriptPayload(scriptName, config, runtimeEntry, serviceState, ctx) {
+    const configIsService = isServiceScript(config);
+    if (!configIsService) {
+        return buildConfiguredPlainScriptPayload(scriptName, runtimeEntry);
+    }
+    const type = "service";
+    const configuredPort = config.port ?? null;
+    const hostname = (serviceState ??
+        ctx.serviceProxy.projectWorkspaceService({
+            projectSlug: ctx.projectSlug,
+            branchName: ctx.branchName,
+            scriptName,
+            daemonPort: ctx.daemonPort,
+            publicBaseUrl: ctx.serviceProxyPublicBaseUrl,
+        })).hostname;
+    const urls = serviceState ??
+        ctx.serviceProxy.projectUrls({
+            projectSlug: ctx.projectSlug,
+            branchName: ctx.branchName,
+            scriptName,
+            daemonPort: ctx.daemonPort,
+            publicBaseUrl: ctx.serviceProxyPublicBaseUrl,
+        });
+    return {
+        scriptName,
+        type,
+        hostname,
+        port: serviceState?.port ?? configuredPort,
+        localProxyUrl: urls.localProxyUrl,
+        publicProxyUrl: urls.publicProxyUrl,
+        proxyUrl: urls.proxyUrl,
+        lifecycle: runtimeEntry?.lifecycle ?? "stopped",
+        health: toWireHealth(ctx.resolveHealth?.(hostname) ?? null),
+        exitCode: runtimeEntry?.exitCode ?? null,
+        terminalId: runtimeEntry?.terminalId ?? null,
+    };
+}
+function buildOrphanRuntimePayload(runtimeEntry, serviceState, ctx) {
+    const type = runtimeEntry.type;
+    const hostname = type === "service"
+        ? (serviceState ??
+            ctx.serviceProxy.projectWorkspaceService({
+                projectSlug: ctx.projectSlug,
+                branchName: ctx.branchName,
+                scriptName: runtimeEntry.scriptName,
+                daemonPort: ctx.daemonPort,
+                publicBaseUrl: ctx.serviceProxyPublicBaseUrl,
+            })).hostname
+        : runtimeEntry.scriptName;
+    const urls = serviceState ??
+        ctx.serviceProxy.projectUrls({
+            projectSlug: ctx.projectSlug,
+            branchName: ctx.branchName,
+            scriptName: runtimeEntry.scriptName,
+            daemonPort: ctx.daemonPort,
+            publicBaseUrl: ctx.serviceProxyPublicBaseUrl,
+        });
+    return {
+        scriptName: runtimeEntry.scriptName,
+        type,
+        hostname,
+        port: type === "service" ? (serviceState?.port ?? null) : null,
+        ...(type === "service"
+            ? { localProxyUrl: urls.localProxyUrl, publicProxyUrl: urls.publicProxyUrl }
+            : {}),
+        proxyUrl: type === "service" ? urls.proxyUrl : null,
+        lifecycle: runtimeEntry.lifecycle,
+        health: type === "service" && serviceState?.port !== null
+            ? toWireHealth(ctx.resolveHealth?.(hostname) ?? null)
+            : null,
+        exitCode: runtimeEntry.exitCode,
+        terminalId: runtimeEntry.terminalId,
+    };
+}
+export function buildWorkspaceScriptPayloads(options) {
+    const workspaceId = options.workspaceId;
+    const workspaceDirectory = options.workspaceDirectory;
+    const projectSlug = options.gitMetadata?.projectSlug ?? deriveProjectSlug(workspaceDirectory);
+    const branchName = options.gitMetadata?.currentBranch ?? null;
+    const scriptConfigs = getScriptConfigs(options.paseoConfig);
+    const runtimeEntries = new Map(options.runtimeStore
+        .listForWorkspace(workspaceId)
+        .map((entry) => [entry.scriptName, entry]));
+    const ctx = {
+        projectSlug,
+        branchName,
+        daemonPort: options.daemonPort,
+        serviceProxyPublicBaseUrl: options.serviceProxyPublicBaseUrl,
+        serviceProxy: options.serviceProxy,
+        resolveHealth: options.resolveHealth,
+    };
+    const payloads = [];
+    for (const [scriptName, config] of scriptConfigs.entries()) {
+        const runtimeEntry = runtimeEntries.get(scriptName) ?? null;
+        const serviceState = isServiceScript(config)
+            ? projectWorkspaceServiceState({ workspaceId, scriptName, ctx })
+            : null;
+        payloads.push(buildConfiguredScriptPayload(scriptName, config, runtimeEntry, serviceState, ctx));
+    }
+    for (const runtimeEntry of runtimeEntries.values()) {
+        if (scriptConfigs.has(runtimeEntry.scriptName) || runtimeEntry.lifecycle !== "running") {
+            continue;
+        }
+        const serviceState = runtimeEntry.type === "service"
+            ? projectWorkspaceServiceState({ workspaceId, scriptName: runtimeEntry.scriptName, ctx })
+            : null;
+        payloads.push(buildOrphanRuntimePayload(runtimeEntry, serviceState, ctx));
+    }
+    return sortPayloads(payloads);
+}
+function buildScriptStatusUpdateMessage(params) {
+    return {
+        type: "script_status_update",
+        payload: {
+            workspaceId: params.workspaceId,
+            scripts: params.scripts,
+        },
+    };
+}
+export function createScriptStatusEmitter({ sessions, serviceProxy, runtimeStore, daemonPort, serviceProxyPublicBaseUrl, resolveWorkspaceDirectory, logger, }) {
+    return (workspaceId, scripts) => {
+        void (async () => {
+            const workspaceDirectory = await resolveWorkspaceDirectory(workspaceId);
+            if (!workspaceDirectory) {
+                return;
+            }
+            const resolvedDaemonPort = resolveDaemonPort(daemonPort);
+            const scriptHealthByHostname = new Map(scripts.map((script) => [script.hostname, script.health]));
+            const projected = buildWorkspaceScriptPayloads({
+                workspaceId,
+                workspaceDirectory,
+                paseoConfig: readPaseoConfigForProjection(workspaceDirectory, logger),
+                serviceProxy,
+                runtimeStore,
+                daemonPort: resolvedDaemonPort,
+                serviceProxyPublicBaseUrl,
+                resolveHealth: (hostname) => scriptHealthByHostname.get(hostname) ?? null,
+            });
+            const message = buildScriptStatusUpdateMessage({
+                workspaceId,
+                scripts: projected,
+            });
+            for (const session of sessions()) {
+                session.emit(message);
+            }
+        })();
+    };
+}
+//# sourceMappingURL=script-status-projection.js.map

package/dist/server/server/server-id.d.ts

@@ -0,0 +1,17 @@
+interface LoggerLike {
+    child(bindings: Record<string, unknown>): LoggerLike;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+}
+/**
+ * Stable daemon identifier scoped to a given $PASEO_HOME.
+ *
+ * - Persisted to `$PASEO_HOME/server-id`
+ * - Can be overridden via `PASEO_SERVER_ID` (useful for tests)
+ */
+export declare function getOrCreateServerId(paseoHome: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    logger?: LoggerLike;
+}): string;
+export {};
+//# sourceMappingURL=server-id.d.ts.map

package/dist/server/server/server-id.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
+const SERVER_ID_FILENAME = "server-id";
+function getLogger(logger) {
+    return logger?.child({ module: "server-id" });
+}
+function getServerIdPath(paseoHome) {
+    return path.join(paseoHome, SERVER_ID_FILENAME);
+}
+function generateServerId() {
+    // 9 bytes -> 12 base64url chars; keep it short + URL-safe.
+    const rand = randomBytes(9).toString("base64url");
+    return `srv_${rand}`;
+}
+/**
+ * Stable daemon identifier scoped to a given $PASEO_HOME.
+ *
+ * - Persisted to `$PASEO_HOME/server-id`
+ * - Can be overridden via `PASEO_SERVER_ID` (useful for tests)
+ */
+export function getOrCreateServerId(paseoHome, options) {
+    const env = options?.env ?? process.env;
+    const log = getLogger(options?.logger);
+    const serverIdPath = getServerIdPath(paseoHome);
+    const envOverride = typeof env.PASEO_SERVER_ID === "string" && env.PASEO_SERVER_ID.trim().length > 0
+        ? env.PASEO_SERVER_ID.trim()
+        : null;
+    if (envOverride) {
+        // Persist the override for consistent identity across restarts.
+        if (!existsSync(serverIdPath)) {
+            try {
+                writePrivateFileAtomicSync(serverIdPath, `${envOverride}\n`);
+                log?.info({ serverId: envOverride }, "Persisted PASEO_SERVER_ID override");
+            }
+            catch (error) {
+                log?.warn({ error }, "Failed to persist PASEO_SERVER_ID override");
+            }
+        }
+        else {
+            ensurePrivateFile(serverIdPath);
+        }
+        return envOverride;
+    }
+    if (existsSync(serverIdPath)) {
+        try {
+            ensurePrivateFile(serverIdPath);
+            const raw = readFileSync(serverIdPath, "utf8");
+            const parsed = raw.trim();
+            if (parsed.length > 0) {
+                return parsed;
+            }
+        }
+        catch (error) {
+            log?.warn({ error }, "Failed to read server-id file, regenerating");
+        }
+    }
+    const created = generateServerId();
+    try {
+        writePrivateFileAtomicSync(serverIdPath, `${created}\n`);
+    }
+    catch (error) {
+        log?.warn({ error }, "Failed to persist serverId (continuing with in-memory id)");
+    }
+    return created;
+}
+//# sourceMappingURL=server-id.js.map