@getpaseo/server 0.1.87 → 0.1.89

package/dist/server/server/schedule/cron.js

@@ -71,9 +71,59 @@ function parseCronExpression(expression) {
 function startOfNextMinute(date) {
     return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes() + 1, 0, 0));
 }
+function assertValidTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone }).format(new Date(0));
+    }
+    catch {
+        throw new Error(`Invalid cron time zone: ${timeZone}`);
+    }
+}
+function createCronDatePartsReader(timeZone) {
+    if (timeZone === undefined) {
+        return (date) => ({
+            minute: date.getUTCMinutes(),
+            hour: date.getUTCHours(),
+            dayOfMonth: date.getUTCDate(),
+            month: date.getUTCMonth() + 1,
+            dayOfWeek: date.getUTCDay(),
+        });
+    }
+    assertValidTimeZone(timeZone);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+    return (date) => {
+        const values = {};
+        for (const part of formatter.formatToParts(date)) {
+            if (part.type !== "literal") {
+                values[part.type] = part.value;
+            }
+        }
+        const year = Number.parseInt(values.year, 10);
+        const month = Number.parseInt(values.month, 10);
+        const dayOfMonth = Number.parseInt(values.day, 10);
+        return {
+            minute: Number.parseInt(values.minute, 10),
+            hour: Number.parseInt(values.hour, 10),
+            dayOfMonth,
+            month,
+            dayOfWeek: new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay(),
+        };
+    };
+}
 export function validateScheduleCadence(cadence) {
     if (cadence.type === "cron") {
         parseCronExpression(cadence.expression);
+        if (cadence.timezone !== undefined) {
+            assertValidTimeZone(cadence.timezone);
+        }
     }
 }
 export function computeNextRunAt(cadence, after) {
@@ -81,14 +131,11 @@ export function computeNextRunAt(cadence, after) {
         return new Date(after.getTime() + cadence.everyMs);
     }
     const cron = parseCronExpression(cadence.expression);
+    const readDateParts = createCronDatePartsReader(cadence.timezone);
     const limit = 366 * 24 * 60;
     let cursor = startOfNextMinute(after);
     for (let index = 0; index < limit; index += 1) {
-        const minute = cursor.getUTCMinutes();
-        const hour = cursor.getUTCHours();
-        const dayOfMonth = cursor.getUTCDate();
-        const month = cursor.getUTCMonth() + 1;
-        const dayOfWeek = cursor.getUTCDay();
+        const { minute, hour, dayOfMonth, month, dayOfWeek } = readDateParts(cursor);
         if (cron.minute.matches(minute) &&
             cron.hour.matches(hour) &&
             cron.dayOfMonth.matches(dayOfMonth) &&

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

@@ -1,4 +1,4 @@
-import type { ScriptRouteStore } from "./script-proxy.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
 export type ScriptHealthState = "pending" | "healthy" | "unhealthy";
 export interface ScriptHealthEntry {
     scriptName: string;
@@ -7,7 +7,7 @@ export interface ScriptHealthEntry {
     health: ScriptHealthState;
 }
 export declare class ScriptHealthMonitor {
-    private readonly routeStore;
+    private readonly serviceProxy;
     private readonly onChange;
     private readonly pollIntervalMs;
     private readonly probeTimeoutMs;
@@ -17,8 +17,8 @@ export declare class ScriptHealthMonitor {
     private readonly lastEmittedSnapshots;
     private intervalHandle;
     private pollInFlight;
-    constructor({ routeStore, onChange, pollIntervalMs, probeTimeoutMs, graceMs, failuresBeforeStopped, }: {
-        routeStore: ScriptRouteStore;
+    constructor({ serviceProxy, onChange, pollIntervalMs, probeTimeoutMs, graceMs, failuresBeforeStopped, }: {
+        serviceProxy: ServiceProxySubsystem;
         onChange: (workspaceId: string, scripts: ScriptHealthEntry[]) => void;
         pollIntervalMs?: number;
         probeTimeoutMs?: number;

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

@@ -1,11 +1,11 @@
 import net from "node:net";
 export class ScriptHealthMonitor {
-    constructor({ routeStore, onChange, pollIntervalMs = 3000, probeTimeoutMs = 500, graceMs = 5000, failuresBeforeStopped = 2, }) {
+    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.routeStore = routeStore;
+        this.serviceProxy = serviceProxy;
         this.onChange = onChange;
         this.pollIntervalMs = pollIntervalMs;
         this.probeTimeoutMs = probeTimeoutMs;
@@ -17,7 +17,7 @@ export class ScriptHealthMonitor {
             return;
         }
         const now = Date.now();
-        for (const route of this.routeStore.listRoutes()) {
+        for (const route of this.serviceProxy.getHealthCheckTargets()) {
             this.getOrCreateState(route, now);
         }
         this.intervalHandle = setInterval(() => {
@@ -45,7 +45,7 @@ export class ScriptHealthMonitor {
         }
         this.pollInFlight = true;
         try {
-            const routes = this.routeStore.listRoutes();
+            const routes = this.serviceProxy.getHealthCheckTargets();
             const activeHostnames = new Set(routes.map((route) => route.hostname));
             const changedWorkspaceIds = new Set();
             const now = Date.now();
@@ -110,7 +110,7 @@ export class ScriptHealthMonitor {
         }
     }
     buildWorkspaceScriptList(workspaceId) {
-        return this.routeStore.listRoutesForWorkspace(workspaceId).flatMap((route) => {
+        return this.serviceProxy.getWorkspaceHealthTargets(workspaceId).flatMap((route) => {
             const state = this.routeStates.get(route.hostname);
             if (!state) {
                 return [];
@@ -123,7 +123,7 @@ export class ScriptHealthMonitor {
         if (state) {
             return state.health;
         }
-        const route = this.routeStore.getRouteEntry(hostname);
+        const route = this.serviceProxy.getHealthTargetForHostname(hostname);
         if (!route) {
             return null;
         }

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

@@ -1,40 +1,3 @@
-import net from "node:net";
-import type { IncomingMessage } from "node:http";
-import type { Logger } from "pino";
-import type { RequestHandler } from "express";
-export interface ScriptRoute {
-    hostname: string;
-    port: number;
-}
-export interface ScriptRouteEntry extends ScriptRoute {
-    workspaceId: string;
-    projectSlug: string;
-    scriptName: string;
-}
-export declare class ScriptRouteStore {
-    private routes;
-    private workspaceHostnames;
-    registerRoute(entry: ScriptRouteEntry): void;
-    removeRoute(hostname: string): void;
-    removeRouteForWorkspaceScript(params: {
-        workspaceId: string;
-        scriptName: string;
-    }): void;
-    removeRoutesForPort(port: number): void;
-    findRoute(host: string): ScriptRoute | null;
-    getRouteEntry(hostname: string): ScriptRouteEntry | null;
-    listRoutes(): ScriptRouteEntry[];
-    listRoutesForWorkspace(workspaceId: string): ScriptRouteEntry[];
-    private addHostnameToWorkspaceIndex;
-    private removeHostnameFromWorkspaceIndex;
-}
-export declare function createScriptProxyMiddleware({ routeStore, logger, }: {
-    routeStore: ScriptRouteStore;
-    logger: Logger;
-}): RequestHandler;
-export declare function createScriptProxyUpgradeHandler({ routeStore, logger, }: {
-    routeStore: ScriptRouteStore;
-    logger: Logger;
-}): (req: IncomingMessage, socket: net.Socket, head: Buffer) => void;
-export declare function findFreePort(): Promise<number>;
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, } 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

@@ -1,245 +1,2 @@
-import http from "node:http";
-import net from "node:net";
-// ---------------------------------------------------------------------------
-// Hop-by-hop headers that must not be forwarded
-// ---------------------------------------------------------------------------
-const HOP_BY_HOP_HEADERS = new Set([
-    "connection",
-    "transfer-encoding",
-    "keep-alive",
-    "upgrade",
-    "proxy-connection",
-    "proxy-authenticate",
-    "proxy-authorization",
-    "te",
-    "trailer",
-]);
-export class ScriptRouteStore {
-    constructor() {
-        this.routes = new Map();
-        this.workspaceHostnames = new Map();
-    }
-    registerRoute(entry) {
-        const previous = this.routes.get(entry.hostname);
-        if (previous) {
-            this.removeHostnameFromWorkspaceIndex(previous.workspaceId, previous.hostname);
-        }
-        const storedEntry = { ...entry };
-        this.routes.set(storedEntry.hostname, storedEntry);
-        this.addHostnameToWorkspaceIndex(storedEntry.workspaceId, storedEntry.hostname);
-    }
-    removeRoute(hostname) {
-        const entry = this.routes.get(hostname);
-        if (!entry) {
-            return;
-        }
-        this.routes.delete(hostname);
-        this.removeHostnameFromWorkspaceIndex(entry.workspaceId, hostname);
-    }
-    removeRouteForWorkspaceScript(params) {
-        const routes = this.listRoutesForWorkspace(params.workspaceId);
-        const route = routes.find((entry) => entry.scriptName === params.scriptName);
-        if (!route) {
-            return;
-        }
-        this.removeRoute(route.hostname);
-    }
-    removeRoutesForPort(port) {
-        for (const [hostname, entry] of this.routes) {
-            if (entry.port === port) {
-                this.routes.delete(hostname);
-                this.removeHostnameFromWorkspaceIndex(entry.workspaceId, hostname);
-            }
-        }
-    }
-    findRoute(host) {
-        // Strip port suffix from the Host header value
-        const hostname = host.replace(/:\d+$/, "");
-        // 1. Exact match
-        const exactRoute = this.routes.get(hostname);
-        if (exactRoute !== undefined) {
-            return { hostname: exactRoute.hostname, port: exactRoute.port };
-        }
-        // 2. Subdomain match — walk up the labels looking for a registered parent
-        const parts = hostname.split(".");
-        for (let i = 1; i < parts.length; i++) {
-            const candidate = parts.slice(i).join(".");
-            const candidateRoute = this.routes.get(candidate);
-            if (candidateRoute !== undefined) {
-                return { hostname: candidateRoute.hostname, port: candidateRoute.port };
-            }
-        }
-        return null;
-    }
-    getRouteEntry(hostname) {
-        const entry = this.routes.get(hostname);
-        return entry ? { ...entry } : null;
-    }
-    listRoutes() {
-        return Array.from(this.routes.values()).map((entry) => Object.assign({}, entry));
-    }
-    listRoutesForWorkspace(workspaceId) {
-        const hostnames = this.workspaceHostnames.get(workspaceId);
-        if (!hostnames) {
-            return [];
-        }
-        const routes = [];
-        for (const hostname of hostnames) {
-            const entry = this.routes.get(hostname);
-            if (entry) {
-                routes.push({ ...entry });
-            }
-        }
-        return routes;
-    }
-    addHostnameToWorkspaceIndex(workspaceId, hostname) {
-        const hostnames = this.workspaceHostnames.get(workspaceId) ?? new Set();
-        hostnames.add(hostname);
-        this.workspaceHostnames.set(workspaceId, hostnames);
-    }
-    removeHostnameFromWorkspaceIndex(workspaceId, hostname) {
-        const hostnames = this.workspaceHostnames.get(workspaceId);
-        if (!hostnames) {
-            return;
-        }
-        hostnames.delete(hostname);
-        if (hostnames.size === 0) {
-            this.workspaceHostnames.delete(workspaceId);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function stripHopByHopHeaders(rawHeaders) {
-    const out = {};
-    for (const [key, value] of Object.entries(rawHeaders)) {
-        if (value === undefined)
-            continue;
-        if (HOP_BY_HOP_HEADERS.has(key.toLowerCase()))
-            continue;
-        out[key] = value;
-    }
-    return out;
-}
-// ---------------------------------------------------------------------------
-// createScriptProxyMiddleware
-// ---------------------------------------------------------------------------
-export function createScriptProxyMiddleware({ routeStore, logger, }) {
-    return (req, res, next) => {
-        const hostHeader = req.headers.host;
-        if (!hostHeader) {
-            next();
-            return;
-        }
-        const route = routeStore.findRoute(hostHeader);
-        if (!route) {
-            next();
-            return;
-        }
-        const forwardedHeaders = stripHopByHopHeaders(req.headers);
-        forwardedHeaders["x-forwarded-for"] = req.socket.remoteAddress ?? "127.0.0.1";
-        forwardedHeaders["x-forwarded-host"] = hostHeader.replace(/:\d+$/, "");
-        forwardedHeaders["x-forwarded-proto"] = req.protocol;
-        const proxyReq = http.request({
-            hostname: "127.0.0.1",
-            port: route.port,
-            path: req.originalUrl,
-            method: req.method,
-            headers: forwardedHeaders,
-        }, (proxyRes) => {
-            const responseHeaders = stripHopByHopHeaders(proxyRes.headers);
-            res.writeHead(proxyRes.statusCode ?? 502, responseHeaders);
-            proxyRes.pipe(res, { end: true });
-        });
-        proxyReq.on("error", (err) => {
-            logger.warn({ err, hostname: route.hostname, port: route.port }, "Script proxy: upstream unreachable");
-            if (!res.headersSent) {
-                res.writeHead(502, { "content-type": "text/plain" });
-                res.end("502 Bad Gateway");
-            }
-        });
-        req.pipe(proxyReq, { end: true });
-    };
-}
-// ---------------------------------------------------------------------------
-// createScriptProxyUpgradeHandler
-// ---------------------------------------------------------------------------
-export function createScriptProxyUpgradeHandler({ routeStore, logger, }) {
-    return (req, socket, head) => {
-        const hostHeader = req.headers.host;
-        if (!hostHeader) {
-            return;
-        }
-        const route = routeStore.findRoute(hostHeader);
-        if (!route) {
-            return;
-        }
-        const targetSocket = net.connect({ host: "127.0.0.1", port: route.port }, () => {
-            // Reconstruct the raw HTTP upgrade request to send to the target
-            const forwardedHeaders = stripHopByHopHeaders(req.headers);
-            forwardedHeaders["x-forwarded-for"] = req.socket.remoteAddress ?? "127.0.0.1";
-            forwardedHeaders["x-forwarded-host"] = hostHeader.replace(/:\d+$/, "");
-            forwardedHeaders["x-forwarded-proto"] = "http";
-            // Re-include upgrade and connection headers — they are required for
-            // WebSocket handshake even though they are hop-by-hop.
-            forwardedHeaders["connection"] = "Upgrade";
-            forwardedHeaders["upgrade"] = req.headers.upgrade ?? "websocket";
-            const headerLines = [];
-            headerLines.push(`${req.method ?? "GET"} ${req.url ?? "/"} HTTP/${req.httpVersion}`);
-            for (const [key, value] of Object.entries(forwardedHeaders)) {
-                if (Array.isArray(value)) {
-                    for (const v of value) {
-                        headerLines.push(`${key}: ${v}`);
-                    }
-                }
-                else {
-                    headerLines.push(`${key}: ${value}`);
-                }
-            }
-            headerLines.push("\r\n");
-            targetSocket.write(headerLines.join("\r\n"));
-            if (head.length > 0) {
-                targetSocket.write(head);
-            }
-            // Pipe in both directions
-            targetSocket.pipe(socket);
-            socket.pipe(targetSocket);
-        });
-        targetSocket.on("error", (err) => {
-            logger.warn({ err, hostname: route.hostname, port: route.port }, "Script proxy: WebSocket upstream unreachable");
-            socket.end();
-        });
-        socket.on("error", () => {
-            targetSocket.destroy();
-        });
-    };
-}
-// ---------------------------------------------------------------------------
-// findFreePort
-// ---------------------------------------------------------------------------
-export function findFreePort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.unref();
-        server.listen(0, "127.0.0.1", () => {
-            const address = server.address();
-            if (!address || typeof address === "string") {
-                server.close();
-                reject(new Error("Failed to get assigned port"));
-                return;
-            }
-            const { port } = address;
-            server.close((err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(port);
-                }
-            });
-        });
-        server.on("error", reject);
-    });
-}
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, } from "./service-proxy.js";
 //# sourceMappingURL=script-proxy.js.map

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

@@ -1,7 +1,7 @@
 import type { Logger } from "pino";
-import type { ScriptRouteStore } from "./script-proxy.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
 interface BranchChangeRouteHandlerOptions {
-    routeStore: ScriptRouteStore;
+    serviceProxy: ServiceProxySubsystem;
     onRoutesChanged: (workspaceId: string) => void;
     logger?: Logger;
 }

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

@@ -1,44 +1,10 @@
-import { buildScriptHostname } from "../utils/script-hostname.js";
 export function createBranchChangeRouteHandler(options) {
     return (workspaceId, _oldBranch, newBranch) => {
-        // Only service scripts register routes, so branch renames only touch services.
-        const routes = options.routeStore.listRoutesForWorkspace(workspaceId);
-        if (routes.length === 0) {
+        const changed = options.serviceProxy.replaceWorkspaceBranchRoutes({ workspaceId, newBranch });
+        if (!changed) {
             return;
         }
-        const updates = [];
-        for (const route of routes) {
-            const newHostname = buildScriptHostname({
-                projectSlug: route.projectSlug,
-                branchName: newBranch,
-                scriptName: route.scriptName,
-            });
-            if (newHostname !== route.hostname) {
-                updates.push({
-                    oldHostname: route.hostname,
-                    newHostname,
-                    route,
-                });
-            }
-        }
-        if (updates.length === 0) {
-            return;
-        }
-        for (const { oldHostname, newHostname, route } of updates) {
-            options.routeStore.removeRoute(oldHostname);
-            options.routeStore.registerRoute({
-                hostname: newHostname,
-                port: route.port,
-                workspaceId: route.workspaceId,
-                projectSlug: route.projectSlug,
-                scriptName: route.scriptName,
-            });
-            options.logger?.info({
-                oldHostname,
-                newHostname,
-                scriptName: route.scriptName,
-            }, "Updated script route for branch rename");
-        }
+        options.logger?.info({ workspaceId, newBranch }, "Updated service proxy routes for branch rename");
         options.onRoutesChanged(workspaceId);
     };
 }

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

@@ -2,7 +2,7 @@ import type { Logger } from "pino";
 import type { SessionOutboundMessage, WorkspaceScriptPayload } from "@getpaseo/protocol/messages";
 import type { PaseoConfig } from "@getpaseo/protocol/paseo-config-schema";
 import type { ScriptHealthEntry, ScriptHealthState } from "./script-health-monitor.js";
-import type { ScriptRouteStore } from "./script-proxy.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
 import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
 interface SessionEmitter {
     emit(message: SessionOutboundMessage): void;
@@ -11,9 +11,10 @@ interface BuildWorkspaceScriptPayloadsOptions {
     workspaceId: string;
     workspaceDirectory: string;
     paseoConfig: PaseoConfig | null;
-    routeStore: ScriptRouteStore;
+    serviceProxy: ServiceProxySubsystem;
     runtimeStore: WorkspaceScriptRuntimeStore;
     daemonPort: number | null;
+    serviceProxyPublicBaseUrl?: string | null;
     gitMetadata?: {
         projectSlug: string;
         currentBranch: string | null;
@@ -22,11 +23,12 @@ interface BuildWorkspaceScriptPayloadsOptions {
 }
 export declare function readPaseoConfigForProjection(workspaceDirectory: string, logger: Logger): PaseoConfig | null;
 export declare function buildWorkspaceScriptPayloads(options: BuildWorkspaceScriptPayloadsOptions): WorkspaceScriptPayload[];
-export declare function createScriptStatusEmitter({ sessions, routeStore, runtimeStore, daemonPort, resolveWorkspaceDirectory, logger, }: {
+export declare function createScriptStatusEmitter({ sessions, serviceProxy, runtimeStore, daemonPort, serviceProxyPublicBaseUrl, resolveWorkspaceDirectory, logger, }: {
     sessions: () => SessionEmitter[];
-    routeStore: ScriptRouteStore;
+    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;