@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/schedule/source-prompt.d.ts

@@ -0,0 +1,42 @@
+import type { StoredFilter } from "@hyperdrive.bot/fleet-protocol/ingestion/filter-types";
+import type { MatchedItem } from "../ingestion/types.js";
+/**
+ * Which verb this prompt briefs.
+ *
+ * `"apply"` is today's prompt, unchanged and default. `"dry-run"` is the same
+ * prompt with the mode named in the heading (so the Inbox row is distinguishable
+ * at 60 characters on a phone) and the instruction block appended last.
+ */
+export type SourceRunPromptMode = "apply" | "dry-run";
+/**
+ * The dry-run contract, verbatim and exported so the test compares against THIS
+ * string rather than a re-typed copy that can drift away from it.
+ *
+ * It names what must not happen in concrete nouns (draft, branch, merge request)
+ * rather than as an abstraction, and it fixes the report's shape so two dry runs
+ * over the same backlog are readable side by side.
+ */
+export declare const DRY_RUN_INSTRUCTION_BLOCK = "--- dry run ---\nThis is a DRY RUN. Do not create, modify, send or open anything, anywhere.\nNo file write, no draft, no branch, no merge request, no message, no state-changing\nAPI call. You have no source tools in this session, on purpose.\n\nReport a plan, in this order, and nothing else:\n1. WOULD READ: the records you would open, named specifically.\n2. WOULD PRODUCE: the artifact you would leave behind, and where it would live.\n3. WOULD STOP AT: the last undoable step you would reach and then refuse.\n4. UNCERTAIN: anything in the brief you could not act on without guessing.\n--- end dry run ---";
+/**
+ * The prompt a source-filter run hands to the session it mints: the filter's brief
+ * verbatim, followed by the items that triggered the run.
+ *
+ * Two properties this function is responsible for, both pinned by tests:
+ *
+ * 1. The FIRST LINE IS THE SESSION TITLE. `resolveCreateAgentTitles` derives the
+ *    provisional title from the first non-empty line, so the heading leads with the
+ *    filter's human name and nothing else. A delimiter, banner or run id on line 1
+ *    would silently degrade every Inbox row.
+ * 2. Pure and synchronous — no I/O, no clock, no randomness. Two calls with the same
+ *    arguments return the same string.
+ *
+ * The brief is emitted verbatim: no re-wrapping, no truncation, no trimming beyond
+ * the `.trim()` `StoredFilterSchema` already applied. What the user wrote is the job.
+ */
+export declare function buildSourceRunPrompt(params: {
+    filter: StoredFilter;
+    items: MatchedItem[];
+    runId: string;
+    mode?: SourceRunPromptMode;
+}): string;
+//# sourceMappingURL=source-prompt.d.ts.map

package/dist/server/server/schedule/source-prompt.js

@@ -0,0 +1,87 @@
+const EMPTY_ITEMS_MESSAGE = "buildSourceRunPrompt requires at least one matched item";
+function buildItemBlock(item, index, total) {
+    const marker = `item ${index + 1} of ${total}`;
+    return [
+        `--- ${marker} ---`,
+        `key: ${item.key}`,
+        `contentHash: ${item.contentHash}`,
+        "payload:",
+        JSON.stringify(item.payload, null, 2),
+        `--- end ${marker} ---`,
+    ].join("\n");
+}
+/**
+ * The dry-run contract, verbatim and exported so the test compares against THIS
+ * string rather than a re-typed copy that can drift away from it.
+ *
+ * It names what must not happen in concrete nouns (draft, branch, merge request)
+ * rather than as an abstraction, and it fixes the report's shape so two dry runs
+ * over the same backlog are readable side by side.
+ */
+export const DRY_RUN_INSTRUCTION_BLOCK = `--- dry run ---
+This is a DRY RUN. Do not create, modify, send or open anything, anywhere.
+No file write, no draft, no branch, no merge request, no message, no state-changing
+API call. You have no source tools in this session, on purpose.
+
+Report a plan, in this order, and nothing else:
+1. WOULD READ: the records you would open, named specifically.
+2. WOULD PRODUCE: the artifact you would leave behind, and where it would live.
+3. WOULD STOP AT: the last undoable step you would reach and then refuse.
+4. UNCERTAIN: anything in the brief you could not act on without guessing.
+--- end dry run ---`;
+/**
+ * The first line, which `resolveCreateAgentTitles` turns into the session title.
+ *
+ * The dry-run shape names the MODE first and the filter second, on purpose: an
+ * Inbox row truncated to 60 characters must still say "this was a rehearsal".
+ * Both shapes keep the literal `item(s)` for every count - one format string, no
+ * singular/plural branch to disagree with itself.
+ */
+function buildHeading(filter, count, runId, mode) {
+    if (mode === "dry-run") {
+        return filter.name
+            ? `Dry run: filter "${filter.name}" would match ${count} item(s) (filter=${filter.id}, run=${runId}).`
+            : `Dry run: filter ${filter.id} would match ${count} item(s) (run=${runId}).`;
+    }
+    // Mirrors buildScheduleFireBody's null-name ternary rather than inventing a
+    // second null-handling idiom in the same file's neighbourhood.
+    return filter.name
+        ? `Filter "${filter.name}" matched ${count} item(s) (filter=${filter.id}, run=${runId}).`
+        : `Filter ${filter.id} matched ${count} item(s) (run=${runId}).`;
+}
+/**
+ * The prompt a source-filter run hands to the session it mints: the filter's brief
+ * verbatim, followed by the items that triggered the run.
+ *
+ * Two properties this function is responsible for, both pinned by tests:
+ *
+ * 1. The FIRST LINE IS THE SESSION TITLE. `resolveCreateAgentTitles` derives the
+ *    provisional title from the first non-empty line, so the heading leads with the
+ *    filter's human name and nothing else. A delimiter, banner or run id on line 1
+ *    would silently degrade every Inbox row.
+ * 2. Pure and synchronous — no I/O, no clock, no randomness. Two calls with the same
+ *    arguments return the same string.
+ *
+ * The brief is emitted verbatim: no re-wrapping, no truncation, no trimming beyond
+ * the `.trim()` `StoredFilterSchema` already applied. What the user wrote is the job.
+ */
+export function buildSourceRunPrompt(params) {
+    // The default lives HERE and nowhere else. Every caller that omits `mode` gets a
+    // byte-identical string to the one it got before this parameter existed, which is
+    // what the strict-equality test in `source-prompt.test.ts` exists to keep true.
+    const { filter, items, runId, mode = "apply" } = params;
+    // An empty match must never mint a session. Zero items is a dispatch bug, and a
+    // throw surfaces it instead of briefing an agent about nothing.
+    if (items.length === 0) {
+        throw new Error(EMPTY_ITEMS_MESSAGE);
+    }
+    const heading = buildHeading(filter, items.length, runId, mode);
+    const blocks = items.map((item, index) => buildItemBlock(item, index, items.length));
+    const body = `${heading}\n\n${filter.brief}\n\n${blocks.join("\n\n")}`;
+    // The block goes LAST, after the item blocks, because it is the last instruction
+    // read before the model acts. The heading is the other anchor; between them the
+    // mode is stated at both ends of the prompt. Separated by one blank line, the same
+    // separator every other section of this prompt uses.
+    return mode === "dry-run" ? `${body}\n\n${DRY_RUN_INSTRUCTION_BLOCK}` : body;
+}
+//# sourceMappingURL=source-prompt.js.map

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

@@ -0,0 +1,13 @@
+import { type StoredSchedule } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+export declare class ScheduleStore {
+    private readonly dir;
+    constructor(dir: string);
+    private filePath;
+    private ensureDir;
+    list(): Promise<StoredSchedule[]>;
+    get(id: string): Promise<StoredSchedule | null>;
+    create(schedule: Omit<StoredSchedule, "id">): Promise<StoredSchedule>;
+    put(schedule: StoredSchedule): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1,57 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { StoredScheduleSchema, } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+import { writeJsonFileAtomic } from "../atomic-file.js";
+function generateScheduleId() {
+    return randomBytes(4).toString("hex");
+}
+export class ScheduleStore {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    filePath(id) {
+        return join(this.dir, `${id}.json`);
+    }
+    async ensureDir() {
+        await mkdir(this.dir, { recursive: true });
+    }
+    async list() {
+        await this.ensureDir();
+        const entries = await readdir(this.dir, { withFileTypes: true });
+        const schedules = await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map(async (entry) => {
+            const content = await readFile(join(this.dir, entry.name), "utf-8");
+            return StoredScheduleSchema.parse(JSON.parse(content));
+        }));
+        return schedules.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    }
+    async get(id) {
+        await this.ensureDir();
+        try {
+            const content = await readFile(this.filePath(id), "utf-8");
+            return StoredScheduleSchema.parse(JSON.parse(content));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async create(schedule) {
+        const created = { ...schedule, id: generateScheduleId() };
+        await this.put(created);
+        return created;
+    }
+    async put(schedule) {
+        await this.ensureDir();
+        await writeJsonFileAtomic(this.filePath(schedule.id), schedule);
+    }
+    async delete(id) {
+        await this.ensureDir();
+        await rm(this.filePath(id), { force: true });
+    }
+}
+//# sourceMappingURL=store.js.map

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/fleet-protocol/messages";
+import type { PaseoConfig } from "@hyperdrive.bot/fleet-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