@devosurf/vynt 0.1.2

package/src/bridge.ts

@@ -0,0 +1,858 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http"
+import { watch, type FSWatcher } from "node:fs"
+import { readFile } from "node:fs/promises"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { applySelectionsToWorkspace, getLatestSnapshot, rollbackWorkspaceToSnapshot } from "./switch.js"
+import { loadState, saveState } from "./state.js"
+import type { Objective, PreviewProfile, VariantArtifact, VariantStore } from "./types.js"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const TOOLBAR_SCRIPT_PATH = resolve(__dirname, "..", "web", "vynt-toolbar.js")
+
+type BridgeEventType =
+  | "server.started"
+  | "apply.started"
+  | "apply.succeeded"
+  | "apply.failed"
+  | "finalize.started"
+  | "finalize.succeeded"
+  | "finalize.failed"
+  | "rollback.started"
+  | "rollback.succeeded"
+  | "rollback.failed"
+  | "state.changed"
+
+interface BridgeEvent {
+  id: number
+  type: BridgeEventType
+  timestamp: string
+  payload: Record<string, unknown>
+}
+
+export interface StartBridgeServerOptions {
+  host: string
+  port: number
+  projectRoot: string
+}
+
+export interface BridgeServerHandle {
+  close: () => Promise<void>
+  host: string
+  port: number
+  url: string
+}
+
+interface BridgeStatus {
+  initialized: boolean
+  latestSnapshot: null | {
+    baseRef: string
+    createdAt: string
+    filePath: string
+    head: string
+    id: string
+    selections: Array<{ objectiveId: string; patchFile: string; variantId: string }>
+  }
+  state: null | {
+    activeProfileId: string | null
+    baseRef: string
+    objectives: Array<{
+      activeVariantId: string | null
+      id: string
+      name: string
+      status: string
+      variants: Array<{ changedFiles: string[]; id: string; name: string; status: string; updatedAt: string }>
+      winnerVariantId: string | null
+    }>
+    profiles: Array<{
+      id: string
+      lastAppliedAt: string | null
+      name: string
+      selections: Record<string, string>
+      updatedAt: string
+    }>
+  }
+}
+
+function findObjective(state: VariantStore, objectiveId: string): Objective {
+  const found = state.objectives.find((objective) => objective.id === objectiveId)
+  if (!found) {
+    throw new Error(`Objective not found: ${objectiveId}`)
+  }
+  return found
+}
+
+function findVariant(objective: Objective, variantId: string): VariantArtifact {
+  const found = objective.variants.find((variant) => variant.id === variantId)
+  if (!found) {
+    throw new Error(`Variant not found in objective ${objective.id}: ${variantId}`)
+  }
+  return found
+}
+
+function findVariantAcrossObjectives(
+  state: VariantStore,
+  variantId: string,
+): { objective: Objective; variant: VariantArtifact } {
+  const matches: Array<{ objective: Objective; variant: VariantArtifact }> = []
+
+  for (const objective of state.objectives) {
+    const variant = objective.variants.find((item) => item.id === variantId)
+    if (variant) {
+      matches.push({ objective, variant })
+    }
+  }
+
+  if (matches.length === 0) {
+    throw new Error(`Variant not found: ${variantId}`)
+  }
+
+  if (matches.length > 1) {
+    const objectiveIds = matches.map((item) => item.objective.id).join(", ")
+    throw new Error(
+      `Variant id ${variantId} is ambiguous across objectives (${objectiveIds}). Use objectiveId + variantId.`,
+    )
+  }
+
+  return matches[0] as { objective: Objective; variant: VariantArtifact }
+}
+
+function findProfile(state: VariantStore, profileId: string): PreviewProfile {
+  const found = state.profiles.find((profile) => profile.id === profileId)
+  if (!found) {
+    throw new Error(`Profile not found: ${profileId}`)
+  }
+  return found
+}
+
+function clearActiveSelections(state: VariantStore): VariantStore {
+  const now = new Date().toISOString()
+
+  return {
+    ...state,
+    activeProfileId: undefined,
+    objectives: state.objectives.map((objectiveItem) => ({
+      ...objectiveItem,
+      activeVariantId: undefined,
+      updatedAt: now,
+      variants: objectiveItem.variants.map((variant) => {
+        if (variant.status !== "selected") return variant
+        return {
+          ...variant,
+          status: "ready" as const,
+          updatedAt: now,
+        }
+      }),
+    })),
+  }
+}
+
+function markVariantSelectedInState(state: VariantStore, objectiveId: string, variantId: string): VariantStore {
+  const objectiveItem = findObjective(state, objectiveId)
+  const now = new Date().toISOString()
+
+  return {
+    ...state,
+    activeProfileId: undefined,
+    objectives: state.objectives.map((item) => {
+      if (item.id !== objectiveId) return item
+
+      return {
+        ...objectiveItem,
+        activeVariantId: variantId,
+        status: objectiveItem.status === "open" ? "review" : objectiveItem.status,
+        updatedAt: now,
+        variants: objectiveItem.variants.map((variant) => {
+          if (variant.id === variantId) {
+            return {
+              ...variant,
+              status: "selected" as const,
+              updatedAt: now,
+            }
+          }
+
+          if (variant.status === "selected") {
+            return {
+              ...variant,
+              status: "ready" as const,
+              updatedAt: now,
+            }
+          }
+
+          return variant
+        }),
+      }
+    }),
+  }
+}
+
+function finalizeVariantInObjectiveState(state: VariantStore, objectiveId: string, variantId: string): VariantStore {
+  const objectiveItem = findObjective(state, objectiveId)
+  findVariant(objectiveItem, variantId)
+  const now = new Date().toISOString()
+
+  return {
+    ...state,
+    activeProfileId: undefined,
+    objectives: state.objectives.map((item) => {
+      if (item.id !== objectiveId) return item
+
+      return {
+        ...objectiveItem,
+        activeVariantId: variantId,
+        winnerVariantId: variantId,
+        status: "finalized" as const,
+        updatedAt: now,
+        variants: objectiveItem.variants.map((variant) => {
+          if (variant.id === variantId) {
+            return {
+              ...variant,
+              status: "selected" as const,
+              updatedAt: now,
+            }
+          }
+
+          return {
+            ...variant,
+            status: "archived" as const,
+            updatedAt: now,
+          }
+        }),
+      }
+    }),
+  }
+}
+
+function resolveSingleApplyTarget(
+  state: VariantStore,
+  variantId: string,
+  objectiveId?: string,
+): { objective: Objective; variant: VariantArtifact } {
+  if (objectiveId) {
+    const objectiveItem = findObjective(state, objectiveId)
+    const variantItem = findVariant(objectiveItem, variantId)
+    return { objective: objectiveItem, variant: variantItem }
+  }
+
+  return findVariantAcrossObjectives(state, variantId)
+}
+
+function applyProfileSelectionsInState(state: VariantStore, profileId: string): VariantStore {
+  const profileItem = findProfile(state, profileId)
+  const selectionEntries = Object.entries(profileItem.selections)
+  if (selectionEntries.length === 0) {
+    throw new Error(`Profile ${profileId} has no selections`)
+  }
+
+  const resolved = selectionEntries.map(([objectiveId, variantId]) => {
+    const objectiveItem = findObjective(state, objectiveId)
+    const variant = findVariant(objectiveItem, variantId)
+    return {
+      objective: objectiveItem,
+      variant,
+    }
+  })
+
+  const fileOwners = new Map<string, string[]>()
+  for (const item of resolved) {
+    for (const file of item.variant.changedFiles) {
+      const owners = fileOwners.get(file) ?? []
+      owners.push(`${item.objective.id}:${item.variant.id}`)
+      fileOwners.set(file, owners)
+    }
+  }
+
+  const conflicts = Array.from(fileOwners.entries()).filter(([, owners]) => owners.length > 1)
+  if (conflicts.length > 0) {
+    const conflictText = conflicts
+      .map(([file, owners]) => `${file} -> ${owners.join(", ")}`)
+      .join("\n")
+    throw new Error(`Profile ${profileId} has overlapping file selections:\n${conflictText}`)
+  }
+
+  const now = new Date().toISOString()
+  const selectionByObjective = new Map(selectionEntries)
+
+  const nextObjectives = state.objectives.map((objectiveItem) => {
+    const selectedVariantId = selectionByObjective.get(objectiveItem.id)
+    if (!selectedVariantId) return objectiveItem
+
+    return {
+      ...objectiveItem,
+      activeVariantId: selectedVariantId,
+      status: objectiveItem.status === "open" ? "review" : objectiveItem.status,
+      updatedAt: now,
+      variants: objectiveItem.variants.map((variant) => {
+        if (variant.id === selectedVariantId) {
+          return {
+            ...variant,
+            status: "selected" as const,
+            updatedAt: now,
+          }
+        }
+
+        if (variant.status === "selected") {
+          return {
+            ...variant,
+            status: "ready" as const,
+            updatedAt: now,
+          }
+        }
+
+        return variant
+      }),
+    }
+  })
+
+  const nextProfiles = state.profiles.map((current) => {
+    if (current.id !== profileId) return current
+    return {
+      ...current,
+      lastAppliedAt: now,
+      updatedAt: now,
+    }
+  })
+
+  return {
+    ...state,
+    activeProfileId: profileId,
+    objectives: nextObjectives,
+    profiles: nextProfiles,
+  }
+}
+
+function collectActiveSelectionChangedFiles(state: VariantStore): string[] {
+  const files = new Set<string>()
+
+  for (const objective of state.objectives) {
+    if (!objective.activeVariantId) continue
+    const activeVariant = objective.variants.find((variant) => variant.id === objective.activeVariantId)
+    if (!activeVariant) continue
+
+    for (const file of activeVariant.changedFiles) {
+      files.add(file)
+    }
+  }
+
+  return [...files]
+}
+
+async function applySelectionsWithActiveRollback(
+  projectRoot: string,
+  state: VariantStore,
+  selections: Array<{ objectiveId: string; patchFile: string; variantId: string; changedFiles?: string[] }>,
+): Promise<{ snapshotPath: string }> {
+  try {
+    return await applySelectionsToWorkspace(projectRoot, state.baseRef, selections)
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (!message.includes("Workspace has uncommitted changes")) {
+      throw error
+    }
+
+    const allowDirtyFiles = collectActiveSelectionChangedFiles(state)
+    if (allowDirtyFiles.length === 0) {
+      throw new Error(
+        `${message}. No active changedFiles available for safe auto-rollback; run rollback first or register variants with changed files.`,
+      )
+    }
+
+    await rollbackWorkspaceToSnapshot(projectRoot, undefined, { allowDirtyFiles })
+    return applySelectionsToWorkspace(projectRoot, state.baseRef, selections)
+  }
+}
+
+function readPort(value: string | undefined, fallback: number): number {
+  const candidate = Number(value)
+  if (!Number.isInteger(candidate) || candidate < 0 || candidate > 65535) {
+    return fallback
+  }
+  return candidate
+}
+
+async function parseBody<T>(req: IncomingMessage): Promise<T> {
+  return new Promise((resolve, reject) => {
+    let body = ""
+    req.on("data", (chunk) => {
+      body += chunk
+    })
+    req.on("end", () => {
+      if (!body.trim()) {
+        resolve({} as T)
+        return
+      }
+
+      try {
+        resolve(JSON.parse(body) as T)
+      } catch {
+        reject(new Error("Invalid JSON body"))
+      }
+    })
+    req.on("error", reject)
+  })
+}
+
+function sendJson(res: ServerResponse, status: number, data: unknown): void {
+  res.writeHead(status, {
+    "Access-Control-Allow-Headers": "Content-Type, Accept",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Origin": "*",
+    "Cache-Control": "no-store",
+    "Content-Type": "application/json",
+  })
+  res.end(JSON.stringify(data))
+}
+
+function sendScript(res: ServerResponse, content: string): void {
+  res.writeHead(200, {
+    "Access-Control-Allow-Origin": "*",
+    "Cache-Control": "no-store",
+    "Content-Type": "application/javascript; charset=utf-8",
+  })
+  res.end(content)
+}
+
+function sendCors(res: ServerResponse): void {
+  res.writeHead(204, {
+    "Access-Control-Allow-Headers": "Content-Type, Accept",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Max-Age": "86400",
+  })
+  res.end()
+}
+
+function summarizeState(state: VariantStore | undefined, latestSnapshot: Awaited<ReturnType<typeof getLatestSnapshot>>): BridgeStatus {
+  if (!state) {
+    return {
+      initialized: false,
+      latestSnapshot: null,
+      state: null,
+    }
+  }
+
+  return {
+    initialized: true,
+    latestSnapshot: latestSnapshot
+      ? {
+          baseRef: latestSnapshot.baseRef,
+          createdAt: latestSnapshot.createdAt,
+          filePath: latestSnapshot.filePath,
+          head: latestSnapshot.head,
+          id: latestSnapshot.id,
+          selections: latestSnapshot.selections,
+        }
+      : null,
+    state: {
+      activeProfileId: state.activeProfileId ?? null,
+      baseRef: state.baseRef,
+      objectives: state.objectives.map((objective) => ({
+        activeVariantId: objective.activeVariantId ?? null,
+        id: objective.id,
+        name: objective.name,
+        status: objective.status,
+        variants: objective.variants.map((variant) => ({
+          changedFiles: variant.changedFiles,
+          id: variant.id,
+          name: variant.name,
+          status: variant.status,
+          updatedAt: variant.updatedAt,
+        })),
+        winnerVariantId: objective.winnerVariantId ?? null,
+      })),
+      profiles: state.profiles.map((profile) => ({
+        id: profile.id,
+        lastAppliedAt: profile.lastAppliedAt ?? null,
+        name: profile.name,
+        selections: profile.selections,
+        updatedAt: profile.updatedAt,
+      })),
+    },
+  }
+}
+
+function sendSseEvent(res: ServerResponse, event: BridgeEvent): void {
+  res.write(`id: ${event.id}\n`)
+  res.write(`event: ${event.type}\n`)
+  res.write(`data: ${JSON.stringify(event)}\n\n`)
+}
+
+function getServerAddress(server: Server): { host: string; port: number; url: string } {
+  const address = server.address()
+  if (!address || typeof address === "string") {
+    throw new Error("Unable to determine bridge server address")
+  }
+
+  const host = address.address === "::" ? "127.0.0.1" : address.address
+  return {
+    host,
+    port: address.port,
+    url: `http://${host}:${address.port}`,
+  }
+}
+
+export async function startBridgeServer(options: StartBridgeServerOptions): Promise<BridgeServerHandle> {
+  const projectRoot = resolve(options.projectRoot)
+  const host = options.host || "127.0.0.1"
+  const requestedPort = readPort(String(options.port), 4173)
+
+  const sseClients = new Set<ServerResponse>()
+  let sequence = 0
+  let stateWatcher: FSWatcher | null = null
+  let stateWatchTimer: ReturnType<typeof setTimeout> | null = null
+
+  const emitEvent = (type: BridgeEventType, payload: Record<string, unknown>) => {
+    const event: BridgeEvent = {
+      id: ++sequence,
+      payload,
+      timestamp: new Date().toISOString(),
+      type,
+    }
+
+    for (const client of sseClients) {
+      sendSseEvent(client, event)
+    }
+  }
+
+  const scheduleExternalStateChangeEvent = () => {
+    if (stateWatchTimer) {
+      clearTimeout(stateWatchTimer)
+    }
+
+    stateWatchTimer = setTimeout(() => {
+      emitEvent("state.changed", { reason: "external-state-change" })
+    }, 120)
+  }
+
+  const startStateWatcher = () => {
+    const vyntDir = resolve(projectRoot, ".vynt")
+    try {
+      stateWatcher = watch(vyntDir, { persistent: false }, (_eventType, filename) => {
+        const fileName = typeof filename === "string" ? filename : ""
+        if (fileName.length > 0 && fileName !== "state.json") {
+          return
+        }
+        scheduleExternalStateChangeEvent()
+      })
+    } catch {
+      stateWatcher = null
+    }
+  }
+
+  const server = createServer(async (req, res) => {
+    const method = req.method ?? "GET"
+    const url = new URL(req.url ?? "/", "http://localhost")
+
+    if (method === "OPTIONS") {
+      sendCors(res)
+      return
+    }
+
+    if (method === "GET" && url.pathname === "/events") {
+      res.writeHead(200, {
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Content-Type": "text/event-stream",
+      })
+
+      res.write(": connected\n\n")
+      sseClients.add(res)
+
+      req.on("close", () => {
+        sseClients.delete(res)
+      })
+
+      return
+    }
+
+    if (method === "GET" && url.pathname === "/toolbar.js") {
+      try {
+        const scriptContent = await readFile(TOOLBAR_SCRIPT_PATH, "utf8")
+        sendScript(res, scriptContent)
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        sendJson(res, 500, { error: `Failed to load toolbar script: ${message}` })
+      }
+      return
+    }
+
+    if (method === "GET" && url.pathname === "/health") {
+      sendJson(res, 200, {
+        projectRoot,
+        status: "ok",
+      })
+      return
+    }
+
+    if (method === "GET" && url.pathname === "/status") {
+      const state = await loadState(projectRoot)
+      const latestSnapshot = await getLatestSnapshot(projectRoot)
+      sendJson(res, 200, summarizeState(state, latestSnapshot))
+      return
+    }
+
+    if (method === "GET" && url.pathname === "/state") {
+      const state = await loadState(projectRoot)
+      if (!state) {
+        sendJson(res, 409, { error: "Variant store not initialized. Run: vynt init <base-ref>" })
+        return
+      }
+      sendJson(res, 200, state)
+      return
+    }
+
+    if (method === "POST" && url.pathname === "/apply") {
+      try {
+        const state = await loadState(projectRoot)
+        if (!state) {
+          sendJson(res, 409, { error: "Variant store not initialized. Run: vynt init <base-ref>" })
+          return
+        }
+
+        const body = await parseBody<{ objectiveId?: string; profileId?: string; variantId?: string }>(req)
+
+        if (body.profileId && body.variantId) {
+          throw new Error("Use either profileId or variantId, not both")
+        }
+
+        if (!body.profileId && !body.variantId) {
+          throw new Error("apply requires profileId or variantId")
+        }
+
+        emitEvent("apply.started", {
+          mode: body.profileId ? "profile" : "single",
+          objectiveId: body.objectiveId,
+          profileId: body.profileId,
+          variantId: body.variantId,
+        })
+
+        if (body.profileId) {
+          const profileItem = findProfile(state, body.profileId)
+          const selectionEntries = Object.entries(profileItem.selections)
+          if (selectionEntries.length === 0) {
+            throw new Error(`Profile ${body.profileId} has no selections`)
+          }
+
+          const resolved = selectionEntries.map(([objectiveId, variantId]) => {
+            const objectiveItem = findObjective(state, objectiveId)
+            const variant = findVariant(objectiveItem, variantId)
+            return {
+              objective: objectiveItem,
+              variant,
+            }
+          })
+
+          const { snapshotPath } = await applySelectionsWithActiveRollback(
+            projectRoot,
+            state,
+            resolved.map((item) => ({
+              objectiveId: item.objective.id,
+              patchFile: item.variant.patchFile,
+              variantId: item.variant.id,
+              changedFiles: item.variant.changedFiles,
+            })),
+          )
+
+          const nextState = applyProfileSelectionsInState(state, body.profileId)
+          await saveState(projectRoot, nextState)
+
+          emitEvent("apply.succeeded", {
+            mode: "profile",
+            profileId: body.profileId,
+            snapshotPath,
+          })
+          emitEvent("state.changed", {
+            reason: "apply-profile",
+          })
+
+          sendJson(res, 200, {
+            mode: "profile",
+            profileId: body.profileId,
+            snapshotPath,
+          })
+          return
+        }
+
+        const variantId = body.variantId as string
+        const target = resolveSingleApplyTarget(state, variantId, body.objectiveId)
+
+        const { snapshotPath } = await applySelectionsWithActiveRollback(projectRoot, state, [
+          {
+            objectiveId: target.objective.id,
+            patchFile: target.variant.patchFile,
+            variantId: target.variant.id,
+            changedFiles: target.variant.changedFiles,
+          },
+        ])
+
+        const nextState = markVariantSelectedInState(state, target.objective.id, target.variant.id)
+        await saveState(projectRoot, nextState)
+
+        emitEvent("apply.succeeded", {
+          mode: "single",
+          objectiveId: target.objective.id,
+          snapshotPath,
+          variantId: target.variant.id,
+        })
+        emitEvent("state.changed", {
+          reason: "apply-single",
+        })
+
+        sendJson(res, 200, {
+          mode: "single",
+          objectiveId: target.objective.id,
+          snapshotPath,
+          variantId: target.variant.id,
+        })
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        emitEvent("apply.failed", { error: message })
+        sendJson(res, 400, { error: message })
+      }
+      return
+    }
+
+    if (method === "POST" && url.pathname === "/finalize") {
+      try {
+        const state = await loadState(projectRoot)
+        if (!state) {
+          sendJson(res, 409, { error: "Variant store not initialized. Run: vynt init <base-ref>" })
+          return
+        }
+
+        const body = await parseBody<{ objectiveId?: string; variantId?: string }>(req)
+        if (!body.objectiveId || !body.variantId) {
+          throw new Error("finalize requires objectiveId and variantId")
+        }
+
+        const target = resolveSingleApplyTarget(state, body.variantId, body.objectiveId)
+
+        emitEvent("finalize.started", {
+          objectiveId: target.objective.id,
+          variantId: target.variant.id,
+        })
+
+        const { snapshotPath } = await applySelectionsWithActiveRollback(projectRoot, state, [
+          {
+            objectiveId: target.objective.id,
+            patchFile: target.variant.patchFile,
+            variantId: target.variant.id,
+            changedFiles: target.variant.changedFiles,
+          },
+        ])
+
+        const nextState = finalizeVariantInObjectiveState(state, target.objective.id, target.variant.id)
+        await saveState(projectRoot, nextState)
+
+        emitEvent("finalize.succeeded", {
+          objectiveId: target.objective.id,
+          snapshotPath,
+          variantId: target.variant.id,
+        })
+        emitEvent("state.changed", {
+          reason: "finalize-objective",
+        })
+
+        sendJson(res, 200, {
+          objectiveId: target.objective.id,
+          snapshotPath,
+          variantId: target.variant.id,
+        })
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        emitEvent("finalize.failed", { error: message })
+        sendJson(res, 400, { error: message })
+      }
+      return
+    }
+
+    if (method === "POST" && url.pathname === "/rollback") {
+      try {
+        const state = await loadState(projectRoot)
+        if (!state) {
+          sendJson(res, 409, { error: "Variant store not initialized. Run: vynt init <base-ref>" })
+          return
+        }
+
+        const body = await parseBody<{ snapshotId?: string }>(req)
+        emitEvent("rollback.started", { snapshotId: body.snapshotId ?? null })
+
+        const { snapshot } = await rollbackWorkspaceToSnapshot(projectRoot, body.snapshotId, {
+          allowDirtyFiles: collectActiveSelectionChangedFiles(state),
+        })
+        const nextState = clearActiveSelections(state)
+        await saveState(projectRoot, nextState)
+
+        emitEvent("rollback.succeeded", {
+          snapshotHead: snapshot.head,
+          snapshotId: snapshot.id,
+        })
+        emitEvent("state.changed", {
+          reason: "rollback",
+          snapshotId: snapshot.id,
+        })
+
+        sendJson(res, 200, {
+          snapshotHead: snapshot.head,
+          snapshotId: snapshot.id,
+        })
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        emitEvent("rollback.failed", { error: message })
+        sendJson(res, 400, { error: message })
+      }
+      return
+    }
+
+    sendJson(res, 404, { error: "Not found" })
+  })
+
+  await new Promise<void>((resolveListen, rejectListen) => {
+    server.once("error", rejectListen)
+    server.listen(requestedPort, host, () => {
+      server.removeListener("error", rejectListen)
+      resolveListen()
+    })
+  })
+
+  const address = getServerAddress(server)
+  startStateWatcher()
+  emitEvent("server.started", {
+    host: address.host,
+    port: address.port,
+    projectRoot,
+    url: address.url,
+  })
+
+  return {
+    close: async () => {
+      if (stateWatchTimer) {
+        clearTimeout(stateWatchTimer)
+        stateWatchTimer = null
+      }
+      if (stateWatcher) {
+        stateWatcher.close()
+        stateWatcher = null
+      }
+
+      for (const client of sseClients) {
+        client.end()
+      }
+
+      await new Promise<void>((resolveClose, rejectClose) => {
+        server.close((error) => {
+          if (error) {
+            rejectClose(error)
+            return
+          }
+          resolveClose()
+        })
+      })
+    },
+    host: address.host,
+    port: address.port,
+    url: address.url,
+  }
+}