@getpaseo/server 0.1.88 → 0.1.90

package/dist/server/server/pid-lock.d.ts

@@ -7,15 +7,15 @@ export declare const pidLockInfoSchema: z.ZodObject<{
     listen: z.ZodNullable<z.ZodString>;
     desktopManaged: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    uid: number;
     hostname: string;
+    uid: number;
     startedAt: string;
     listen: string | null;
     pid: number;
     desktopManaged?: boolean | undefined;
 }, {
-    uid: number;
     hostname: string;
+    uid: number;
     startedAt: string;
     listen: string | null;
     pid: number;

package/dist/server/server/private-files.d.ts

@@ -2,6 +2,5 @@ export declare const PRIVATE_DIRECTORY_MODE = 448;
 export declare const PRIVATE_FILE_MODE = 384;
 export declare function ensurePrivateDirectory(directoryPath: string): void;
 export declare function ensurePrivateFile(filePath: string): void;
-export declare function writePrivateFileSync(filePath: string, data: string | NodeJS.ArrayBufferView): void;
 export declare function writePrivateFileAtomicSync(filePath: string, data: string | NodeJS.ArrayBufferView): void;
 //# sourceMappingURL=private-files.d.ts.map

package/dist/server/server/private-files.js

@@ -21,11 +21,6 @@ export function ensurePrivateDirectory(directoryPath) {
 export function ensurePrivateFile(filePath) {
     chmodBestEffort(filePath, PRIVATE_FILE_MODE);
 }
-export function writePrivateFileSync(filePath, data) {
-    ensurePrivateDirectory(path.dirname(filePath));
-    writeFileSync(filePath, data, { mode: PRIVATE_FILE_MODE });
-    ensurePrivateFile(filePath);
-}
 export function writePrivateFileAtomicSync(filePath, data) {
     ensurePrivateDirectory(path.dirname(filePath));
     const tmpPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);

package/dist/server/server/schedule/service.d.ts

@@ -1,12 +1,15 @@
 import type { Logger } from "pino";
 import { AgentManager } from "../agent/agent-manager.js";
 import type { AgentStorage } from "../agent/agent-storage.js";
+import type { ProviderSnapshotManager } from "../agent/provider-snapshot-manager.js";
 import type { CreateScheduleInput, ScheduleExecutionResult, ScheduleRun, StoredSchedule, UpdateScheduleInput } from "@getpaseo/protocol/schedule/types";
+type CreateConfigResolver = Pick<ProviderSnapshotManager, "resolveCreateConfig">;
 export interface ScheduleServiceOptions {
     paseoHome: string;
     logger: Logger;
     agentManager: AgentManager;
     agentStorage: AgentStorage;
+    providerSnapshotManager: CreateConfigResolver;
     now?: () => Date;
     runner?: (schedule: StoredSchedule, runId: string) => Promise<ScheduleExecutionResult>;
 }
@@ -15,6 +18,7 @@ export declare class ScheduleService {
     private readonly logger;
     private readonly agentManager;
     private readonly agentStorage;
+    private readonly createConfigResolver;
     private readonly now;
     private readonly runner;
     private readonly runningScheduleIds;
@@ -37,5 +41,7 @@ export declare class ScheduleService {
     private runSchedule;
     private finishRun;
     private executeSchedule;
+    private resolveProviderCreateConfig;
 }
+export {};
 //# sourceMappingURL=service.d.ts.map

package/dist/server/server/schedule/service.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { curateAgentActivity } from "../agent/activity-curator.js";
 import { ensureAgentLoaded } from "../agent/agent-loading.js";
 import { formatSystemNotificationPrompt } from "../agent/agent-prompt.js";
-import { getUnattendedModeId } from "@getpaseo/protocol/provider-manifest";
+import { resolveCreateAgentTitles } from "../agent/create-agent-title.js";
 import { ScheduleStore } from "./store.js";
 import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
 const SCHEDULE_TICK_INTERVAL_MS = 1000;
@@ -113,6 +113,7 @@ export class ScheduleService {
         this.logger = options.logger.child({ module: "schedule-service" });
         this.agentManager = options.agentManager;
         this.agentStorage = options.agentStorage;
+        this.createConfigResolver = options.providerSnapshotManager;
         this.now = options.now ?? (() => new Date());
         this.runner = options.runner ?? ((schedule, runId) => this.executeSchedule(schedule, runId));
     }
@@ -418,8 +419,8 @@ export class ScheduleService {
         await this.store.put(updated);
     }
     async executeSchedule(schedule, runId) {
-        const wrappedPrompt = formatSystemNotificationPrompt(buildScheduleFireBody(schedule, runId));
         if (schedule.target.type === "agent") {
+            const wrappedPrompt = formatSystemNotificationPrompt(buildScheduleFireBody(schedule, runId));
             const record = await this.agentStorage.get(schedule.target.agentId);
             if (record?.archivedAt) {
                 throw new Error(`Agent ${schedule.target.agentId} is archived`);
@@ -443,30 +444,49 @@ export class ScheduleService {
                 }),
             };
         }
+        const targetConfig = schedule.target.config;
+        const resolvedUnattendedConfig = targetConfig.modeId
+            ? { modeId: targetConfig.modeId, featureValues: targetConfig.featureValues }
+            : await this.resolveProviderCreateConfig({
+                provider: targetConfig.provider,
+                cwd: targetConfig.cwd,
+                requestedMode: undefined,
+                featureValues: targetConfig.featureValues,
+                parent: null,
+                unattended: true,
+            });
         const config = {
-            provider: schedule.target.config.provider,
-            cwd: schedule.target.config.cwd,
-            modeId: schedule.target.config.modeId ?? getUnattendedModeId(schedule.target.config.provider),
-            model: schedule.target.config.model,
-            thinkingOptionId: schedule.target.config.thinkingOptionId,
-            title: schedule.target.config.title,
-            approvalPolicy: schedule.target.config.approvalPolicy,
-            sandboxMode: schedule.target.config.sandboxMode,
-            networkAccess: schedule.target.config.networkAccess,
-            webSearch: schedule.target.config.webSearch,
-            featureValues: schedule.target.config.featureValues,
-            extra: schedule.target.config.extra,
-            systemPrompt: schedule.target.config.systemPrompt,
-            mcpServers: schedule.target.config.mcpServers,
+            provider: targetConfig.provider,
+            cwd: targetConfig.cwd,
+            modeId: resolvedUnattendedConfig.modeId,
+            model: targetConfig.model,
+            thinkingOptionId: targetConfig.thinkingOptionId,
+            title: targetConfig.title,
+            approvalPolicy: targetConfig.approvalPolicy,
+            sandboxMode: targetConfig.sandboxMode,
+            networkAccess: targetConfig.networkAccess,
+            webSearch: targetConfig.webSearch,
+            featureValues: resolvedUnattendedConfig.featureValues,
+            extra: targetConfig.extra,
+            systemPrompt: targetConfig.systemPrompt,
+            mcpServers: targetConfig.mcpServers,
         };
+        const { provisionalTitle } = resolveCreateAgentTitles({
+            configTitle: config.title,
+            initialPrompt: schedule.prompt,
+        });
         const labels = {
             "paseo.schedule-id": schedule.id,
             "paseo.schedule-run": runId,
         };
-        const agent = await this.agentManager.createAgent(config, undefined, { labels });
+        const agent = await this.agentManager.createAgent(config, undefined, {
+            labels,
+            initialPrompt: schedule.prompt,
+            initialTitle: provisionalTitle,
+        });
         let result;
         try {
-            result = await this.agentManager.runAgent(agent.id, wrappedPrompt);
+            result = await this.agentManager.runAgent(agent.id, schedule.prompt);
         }
         catch (error) {
             try {
@@ -488,5 +508,8 @@ export class ScheduleService {
             }),
         };
     }
+    async resolveProviderCreateConfig(input) {
+        return this.createConfigResolver.resolveCreateConfig(input);
+    }
 }
 //# sourceMappingURL=service.js.map

package/dist/server/server/schedule/store.js

@@ -1,7 +1,8 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { StoredScheduleSchema } from "@getpaseo/protocol/schedule/types";
+import { writeJsonFileAtomic } from "../atomic-file.js";
 function generateScheduleId() {
     return randomBytes(4).toString("hex");
 }
@@ -46,7 +47,7 @@ export class ScheduleStore {
     }
     async put(schedule) {
         await this.ensureDir();
-        await writeFile(this.filePath(schedule.id), JSON.stringify(schedule, null, 2), "utf-8");
+        await writeJsonFileAtomic(this.filePath(schedule.id), schedule);
     }
     async delete(id) {
         await this.ensureDir();

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;