@getpaseo/server 0.1.88 → 0.1.90

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

@@ -1,4 +1,3 @@
-import { buildScriptHostname } from "../utils/script-hostname.js";
 import { getScriptConfigs, isServiceScript, readPaseoConfig } from "../utils/worktree.js";
 import { deriveProjectSlug } from "./workspace-git-metadata.js";
 export function readPaseoConfigForProjection(workspaceDirectory, logger) {
@@ -15,12 +14,6 @@ function resolveDaemonPort(daemonPort) {
     }
     return daemonPort;
 }
-function toServiceProxyUrl(hostname, daemonPort) {
-    if (daemonPort === null) {
-        return null;
-    }
-    return `http://${hostname}:${daemonPort}`;
-}
 function toWireHealth(health) {
     if (health === "pending" || health === null) {
         return null;
@@ -33,48 +26,99 @@ function sortPayloads(payloads) {
         sensitivity: "base",
     }));
 }
-function buildConfiguredScriptPayload(scriptName, config, runtimeEntry, routeEntry, ctx) {
+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);
-    const type = configIsService ? "service" : "script";
-    const configuredPort = configIsService ? (config.port ?? null) : null;
-    const hostname = type === "service"
-        ? (routeEntry?.hostname ??
-            buildScriptHostname({
-                projectSlug: ctx.projectSlug,
-                branchName: ctx.branchName,
-                scriptName,
-            }))
-        : scriptName;
+    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: type === "service" ? (routeEntry?.port ?? configuredPort) : null,
-        proxyUrl: type === "service" ? toServiceProxyUrl(hostname, ctx.daemonPort) : null,
+        port: serviceState?.port ?? configuredPort,
+        localProxyUrl: urls.localProxyUrl,
+        publicProxyUrl: urls.publicProxyUrl,
+        proxyUrl: urls.proxyUrl,
         lifecycle: runtimeEntry?.lifecycle ?? "stopped",
-        health: type === "service" ? toWireHealth(ctx.resolveHealth?.(hostname) ?? null) : null,
+        health: toWireHealth(ctx.resolveHealth?.(hostname) ?? null),
         exitCode: runtimeEntry?.exitCode ?? null,
         terminalId: runtimeEntry?.terminalId ?? null,
     };
 }
-function buildOrphanRuntimePayload(runtimeEntry, routeEntry, ctx) {
+function buildOrphanRuntimePayload(runtimeEntry, serviceState, ctx) {
     const type = runtimeEntry.type;
     const hostname = type === "service"
-        ? (routeEntry?.hostname ??
-            buildScriptHostname({
+        ? (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" ? (routeEntry?.port ?? null) : null,
-        proxyUrl: type === "service" ? toServiceProxyUrl(hostname, ctx.daemonPort) : null,
+        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" && routeEntry ? toWireHealth(ctx.resolveHealth?.(hostname) ?? null) : null,
+        health: type === "service" && serviceState?.port !== null
+            ? toWireHealth(ctx.resolveHealth?.(hostname) ?? null)
+            : null,
         exitCode: runtimeEntry.exitCode,
         terminalId: runtimeEntry.terminalId,
     };
@@ -88,27 +132,30 @@ export function buildWorkspaceScriptPayloads(options) {
     const runtimeEntries = new Map(options.runtimeStore
         .listForWorkspace(workspaceId)
         .map((entry) => [entry.scriptName, entry]));
-    const routesByScriptName = new Map(options.routeStore
-        .listRoutesForWorkspace(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 routeEntry = routesByScriptName.get(scriptName) ?? null;
-        payloads.push(buildConfiguredScriptPayload(scriptName, config, runtimeEntry, routeEntry, ctx));
+        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 routeEntry = routesByScriptName.get(runtimeEntry.scriptName) ?? null;
-        payloads.push(buildOrphanRuntimePayload(runtimeEntry, routeEntry, ctx));
+        const serviceState = runtimeEntry.type === "service"
+            ? projectWorkspaceServiceState({ workspaceId, scriptName: runtimeEntry.scriptName, ctx })
+            : null;
+        payloads.push(buildOrphanRuntimePayload(runtimeEntry, serviceState, ctx));
     }
     return sortPayloads(payloads);
 }
@@ -121,7 +168,7 @@ function buildScriptStatusUpdateMessage(params) {
         },
     };
 }
-export function createScriptStatusEmitter({ sessions, routeStore, runtimeStore, daemonPort, resolveWorkspaceDirectory, logger, }) {
+export function createScriptStatusEmitter({ sessions, serviceProxy, runtimeStore, daemonPort, serviceProxyPublicBaseUrl, resolveWorkspaceDirectory, logger, }) {
     return (workspaceId, scripts) => {
         void (async () => {
             const workspaceDirectory = await resolveWorkspaceDirectory(workspaceId);
@@ -134,9 +181,10 @@ export function createScriptStatusEmitter({ sessions, routeStore, runtimeStore,
                 workspaceId,
                 workspaceDirectory,
                 paseoConfig: readPaseoConfigForProjection(workspaceDirectory, logger),
-                routeStore,
+                serviceProxy,
                 runtimeStore,
                 daemonPort: resolvedDaemonPort,
+                serviceProxyPublicBaseUrl,
                 resolveHealth: (hostname) => scriptHealthByHostname.get(hostname) ?? null,
             });
             const message = buildScriptStatusUpdateMessage({

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

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { ensurePrivateFile, writePrivateFileSync } from "./private-files.js";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
 const SERVER_ID_FILENAME = "server-id";
 function getLogger(logger) {
     return logger?.child({ module: "server-id" });
@@ -31,7 +31,7 @@ export function getOrCreateServerId(paseoHome, options) {
         // Persist the override for consistent identity across restarts.
         if (!existsSync(serverIdPath)) {
             try {
-                writePrivateFileSync(serverIdPath, `${envOverride}\n`);
+                writePrivateFileAtomicSync(serverIdPath, `${envOverride}\n`);
                 log?.info({ serverId: envOverride }, "Persisted PASEO_SERVER_ID override");
             }
             catch (error) {
@@ -58,7 +58,7 @@ export function getOrCreateServerId(paseoHome, options) {
     }
     const created = generateServerId();
     try {
-        writePrivateFileSync(serverIdPath, `${created}\n`);
+        writePrivateFileAtomicSync(serverIdPath, `${created}\n`);
     }
     catch (error) {
         log?.warn({ error }, "Failed to persist serverId (continuing with in-memory id)");

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

@@ -0,0 +1,237 @@
+import net from "node:net";
+import type { IncomingMessage } from "node:http";
+import { type RequestHandler } from "express";
+import type { Logger } from "pino";
+export type ServiceProxyListenTarget = {
+    type: "tcp";
+    host: string;
+    port: number;
+} | {
+    type: "socket";
+    path: string;
+} | {
+    type: "pipe";
+    path: string;
+};
+export interface ServiceProxyRoute {
+    hostname: string;
+    port: number;
+}
+export interface ServiceProxyRouteEntry extends ServiceProxyRoute {
+    workspaceId: string;
+    projectSlug: string;
+    scriptName: string;
+    localHostname?: string;
+    publicHostname?: string | null;
+    publicBaseUrl?: string | null;
+}
+export interface ServiceProxyUrlProjection {
+    localProxyUrl: string | null;
+    publicProxyUrl: string | null;
+    proxyUrl: string | null;
+}
+export interface ServiceProxyScriptProjection extends ServiceProxyUrlProjection {
+    hostname: string;
+}
+export interface ServiceProxyWorkspaceScriptProjection extends ServiceProxyScriptProjection {
+    port: number | null;
+}
+export interface ServiceProxyHealthTarget {
+    workspaceId: string;
+    scriptName: string;
+    hostname: string;
+    port: number;
+}
+export interface WorkspaceServiceIdentity {
+    workspaceId: string;
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+}
+export interface RegisterWorkspaceServiceInput extends WorkspaceServiceIdentity {
+    port: number;
+    publicBaseUrl?: string | null;
+}
+interface HostClassificationRegistered {
+    type: "registered-service";
+    route: ServiceProxyRoute;
+}
+interface HostClassificationKnownMiss {
+    type: "known-service-miss";
+}
+interface HostClassificationDaemon {
+    type: "daemon";
+}
+type HostClassification = HostClassificationRegistered | HostClassificationKnownMiss | HostClassificationDaemon;
+export declare function buildServiceProxyLabel({ projectSlug, branchName, scriptName, }: {
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+}): string;
+export declare function buildLocalServiceHostname(input: {
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+}): string;
+export declare function buildPublicServiceHostname({ publicBaseUrl, ...service }: {
+    publicBaseUrl: string;
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+}): string;
+export declare function buildPublicServiceProxyUrl(options: {
+    publicBaseUrl: string;
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+}): string;
+export declare function projectServiceProxyUrls(options: {
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+    daemonPort: number | null | undefined;
+    publicBaseUrl?: string | null;
+}): ServiceProxyUrlProjection;
+export declare function projectWorkspaceService(input: {
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+    daemonPort: number | null | undefined;
+    publicBaseUrl?: string | null;
+}): ServiceProxyScriptProjection;
+export declare function projectRegisteredServiceProxyUrls(options: {
+    route: Pick<ServiceProxyRouteEntry, "hostname" | "publicHostname" | "publicBaseUrl" | "projectSlug" | "scriptName">;
+    daemonPort: number | null | undefined;
+}): ServiceProxyUrlProjection;
+export declare class ServiceProxyRouteCollisionError extends Error {
+    readonly hostname: string;
+    readonly existing: Pick<ServiceProxyRouteEntry, "workspaceId" | "scriptName">;
+    readonly incoming: Pick<ServiceProxyRouteEntry, "workspaceId" | "scriptName">;
+    constructor(hostname: string, existing: Pick<ServiceProxyRouteEntry, "workspaceId" | "scriptName">, incoming: Pick<ServiceProxyRouteEntry, "workspaceId" | "scriptName">);
+}
+export declare class ServiceProxyRouteRegistry {
+    private routes;
+    private hostnameAliases;
+    private workspaceHostnames;
+    private configuredPublicBaseHostnames;
+    private publicBaseHostnames;
+    constructor(publicBaseUrl?: string | null);
+    registerWorkspaceService(input: RegisterWorkspaceServiceInput): ServiceProxyRouteEntry;
+    registerRoute(entry: ServiceProxyRouteEntry): void;
+    replaceWorkspaceBranchRoutes(params: {
+        workspaceId: string;
+        newBranch: string | null;
+    }): boolean;
+    removeRoute(hostname: string): void;
+    removeRouteForWorkspaceScript(params: {
+        workspaceId: string;
+        scriptName: string;
+    }): void;
+    removeWorkspaceService(params: {
+        workspaceId: string;
+        scriptName: string;
+    }): void;
+    projectUrls(input: {
+        projectSlug: string;
+        branchName: string | null;
+        scriptName: string;
+        daemonPort: number | null | undefined;
+        publicBaseUrl?: string | null;
+    }): ServiceProxyUrlProjection;
+    projectWorkspaceService(input: {
+        projectSlug: string;
+        branchName: string | null;
+        scriptName: string;
+        daemonPort: number | null | undefined;
+        publicBaseUrl?: string | null;
+    }): ServiceProxyScriptProjection;
+    projectWorkspaceServiceState(input: {
+        workspaceId: string;
+        projectSlug: string;
+        branchName: string | null;
+        scriptName: string;
+        daemonPort: number | null | undefined;
+        publicBaseUrl?: string | null;
+    }): ServiceProxyWorkspaceScriptProjection;
+    getHealthCheckTargets(): ServiceProxyHealthTarget[];
+    getWorkspaceHealthTargets(workspaceId: string): ServiceProxyHealthTarget[];
+    getHealthTargetForHostname(hostname: string): ServiceProxyHealthTarget | null;
+    removeServiceRoutesByHostnames(hostnames: string[]): void;
+    removeRoutesForPort(port: number): void;
+    classifyHost(host: string | undefined): HostClassification;
+    findRoute(host: string): ServiceProxyRoute | null;
+    getRouteEntry(hostname: string): ServiceProxyRouteEntry | null;
+    listRoutes(): ServiceProxyRouteEntry[];
+    listRoutesForWorkspace(workspaceId: string): ServiceProxyRouteEntry[];
+    private assertCanRegister;
+    private assertNoInternalCollisions;
+    private toStoredEntry;
+    private getRouteByHostname;
+    private getRouteHostnames;
+    private addHostnameToWorkspaceIndex;
+    private removeHostnameFromWorkspaceIndex;
+    private rebuildPublicBaseHostnames;
+}
+export { ServiceProxyRouteRegistry as ScriptRouteStore };
+export type ScriptRoute = ServiceProxyRoute;
+export type ScriptRouteEntry = ServiceProxyRouteEntry;
+export declare function createScriptProxyMiddleware({ routeStore, logger, }: {
+    routeStore: ServiceProxyRouteRegistry;
+    logger: Logger;
+}): RequestHandler;
+export declare function createScriptProxyUpgradeHandler({ routeStore, logger, passthroughUnknown, }: {
+    routeStore: ServiceProxyRouteRegistry;
+    logger: Logger;
+    passthroughUnknown?: boolean;
+}): (req: IncomingMessage, socket: net.Socket, head: Buffer) => void;
+export interface ServiceProxySubsystem {
+    registerWorkspaceService(input: RegisterWorkspaceServiceInput): ServiceProxyRouteEntry;
+    removeWorkspaceService(params: {
+        workspaceId: string;
+        scriptName: string;
+    }): void;
+    removeServiceRoutesByHostnames(hostnames: string[]): void;
+    replaceWorkspaceBranchRoutes(params: {
+        workspaceId: string;
+        newBranch: string | null;
+    }): boolean;
+    getHealthCheckTargets(): ServiceProxyHealthTarget[];
+    getWorkspaceHealthTargets(workspaceId: string): ServiceProxyHealthTarget[];
+    getHealthTargetForHostname(hostname: string): ServiceProxyHealthTarget | null;
+    projectUrls(input: {
+        projectSlug: string;
+        branchName: string | null;
+        scriptName: string;
+        daemonPort: number | null | undefined;
+        publicBaseUrl?: string | null;
+    }): ServiceProxyUrlProjection;
+    projectWorkspaceService(input: {
+        projectSlug: string;
+        branchName: string | null;
+        scriptName: string;
+        daemonPort: number | null | undefined;
+        publicBaseUrl?: string | null;
+    }): ServiceProxyScriptProjection;
+    projectWorkspaceServiceState(input: {
+        workspaceId: string;
+        projectSlug: string;
+        branchName: string | null;
+        scriptName: string;
+        daemonPort: number | null | undefined;
+        publicBaseUrl?: string | null;
+    }): ServiceProxyWorkspaceScriptProjection;
+    middleware(): RequestHandler;
+    upgradeHandler(options: {
+        passthroughUnknown: boolean;
+    }): (req: IncomingMessage, socket: net.Socket, head: Buffer) => void;
+    startStandalone(options: {
+        listenTarget: ServiceProxyListenTarget;
+    }): Promise<ServiceProxyListenTarget>;
+    stopStandalone(): Promise<void>;
+}
+export declare function createServiceProxySubsystem({ logger, publicBaseUrl, }: {
+    logger: Logger;
+    publicBaseUrl?: string | null;
+}): ServiceProxySubsystem;
+export declare function findFreePort(): Promise<number>;
+//# sourceMappingURL=service-proxy.d.ts.map