Function startServer

src/server/server.ts:372–569

(
  port = getDefaultPort(),
  browserBehavior: BrowserBehavior = BrowserBehavior.ASK,
)

}

export async function startServer(
  port = getDefaultPort(),
  browserBehavior: BrowserBehavior = BrowserBehavior.ASK,
) {
  const app = createApp();

  const httpServer = http.createServer(app);
  const io = new SocketIOServer(httpServer, {
    cors: {
      origin: '*',
    },
  });

  await runDbMigrations();

  const watcher = setupSignalWatcher(() => {
    const handleSignalUpdate = async () => {
      // A new eval signal can change /api/prompts output. Invalidate first — before this handler
      // awaits any DB lookups and regardless of which emit branches below run — so every signal
      // drops the cache and the next /api/prompts request re-reads it from the DB.
      promptCacheService.invalidate();

      const signal = readSignalFile();
      // A coalesced signal can carry several scoped updates (back-to-back eval saves in the
      // debounce window), an unscoped "refresh latest" component, and a delete component.
      const scopedUpdateIds = updateEvalIds(signal);

      // Mutations can happen in a separate CLI process, so clear this server's process-local caches
      // before serving the next request. A delete-all or an unscoped update (whose latest eval is
      // not known here) can touch any eval's cached count, so clear them all; otherwise scope the
      // clear to exactly the evals this signal updates and/or deletes.
      if (
        (hasDeleteComponent(signal) && isAllEvalsDeleted(signal.deletedEvalIds)) ||
        hasUnscopedUpdate(signal)
      ) {
        invalidateEvaluationCache();
      } else {
        invalidateEvaluationCaches([...scopedUpdateIds, ...(signal.deletedEvalIds ?? [])]);
      }

      // Emit each component independently (not else-if) so no coalesced refresh is lost.
      if (hasDeleteComponent(signal)) {
        io.emit('update', { deletedEvalIds: signal.deletedEvalIds ?? [] });
      }

      // Emit one refresh per surviving scoped eval so a client pinned to any of them updates.
      if (scopedUpdateIds.length > 0) {
        const updatedEvals = await Promise.all(scopedUpdateIds.map((id) => Eval.findById(id)));
        for (const updatedEval of updatedEvals) {
          if (updatedEval) {
            logger.debug(
              `Emitting update for eval: ${updatedEval.config?.description || updatedEval.id}`,
            );
            io.emit('update', { evalId: updatedEval.id });
          }
          // Else: a scoped update whose eval no longer exists (e.g. it won the debounce race
          // against its own delete). Emit nothing — clients reconcile on the next signal.
        }