feat: browser notifications for scenario runs

- add RunEventsService and emit run.started / run.finished from the scheduler
- stream run events over SSE at GET /api/v1/scenarios/runs/events with a heartbeat
- add useRunNotifications hook and NotificationToggle (opt-in bell in the side panel footer)
- refresh runs lists when a run finishes
- document the events stream and notifications

Closes #12
This commit is contained in:
ars9 committed 2026-10-07 18:20:30 +03:00
1 parent 968a8e470b
commit d7eb018245
18 files changed
+503 -6

No files matched your search

+31
View File
@@ -0,0 +1,31 @@
import { Injectable } from "@nestjs/common";
import { Observable, Subject } from "rxjs";
export type RunEventStatus = "pending" | "in_progress" | "pass" | "fail";
export interface RunEvent {
type: "run.started" | "run.finished";
runId: string;
scenarioId: string;
scenarioName: string;
status: RunEventStatus;
/** ISO timestamp of the transition. */
at: string;
}
/**
* In-process event bus for scenario run lifecycle transitions. The scheduler
* emits; the SSE endpoint (and tests) subscribe.
*/
@Injectable()
export class RunEventsService {
private readonly subject = new Subject<RunEvent>();
emit(event: RunEvent): void {
this.subject.next(event);
}
stream(): Observable<RunEvent> {
return this.subject.asObservable();
}
}
@@ -30,6 +30,7 @@ import { SnippetService } from "../snippet/snippet.service";
import { ScenarioRunLogEntity } from "./scenario-run-log.entity";
import { ScenarioRunStepEntity } from "./scenario-run-step.entity";
import { ScenarioRunEntity } from "./scenario-run.entity";
import { RunEventsService } from "./run-events.service";
import { ScenarioService } from "./scenario.service";
interface BrowserHandle {
@@ -80,6 +81,7 @@ export class ScenarioSchedulerService implements OnModuleInit {
private readonly sessionService: SessionService,
private readonly sessionContextService: SessionContextService,
private readonly fileStorageService: FileStorageService,
private readonly runEvents: RunEventsService,
configService: ConfigService<AppConfig, true>,
) {
this.defaultTraceMode = configService.get("PLAYWRIGHT_TRACE_MODE");
@@ -109,7 +111,7 @@ export class ScenarioSchedulerService implements OnModuleInit {
this.failRun(
run.id,
"Run aborted: server restarted and playwright session could not be recovered",
),
).then(() => this.emitFinished(run.id)),
).pipe(
Effect.catchAll((err) =>
Effect.sync(() =>
@@ -149,6 +151,48 @@ export class ScenarioSchedulerService implements OnModuleInit {
this.persistLog(runId, null, "error", reason, "run");
}
/**
* Publishes a run lifecycle event. Never throws: a notification problem
* must not affect the run itself.
*/
private async emitRunEvent(
type: "run.started" | "run.finished",
runId: string,
): Promise<void> {
try {
const run = await this.runRepo.findOneBy({ id: runId });
if (!run) return;
if (type === "run.finished" && run.status !== "pass" && run.status !== "fail") {
return;
}
const scenario = await this.scenarioService
.findOne(run.scenarioId)
.catch(() => null);
this.runEvents.emit({
type,
runId,
scenarioId: run.scenarioId,
scenarioName: scenario?.name ?? run.scenarioId,
status: run.status,
at: new Date().toISOString(),
});
} catch (err) {
this.logger.warn(
`Run #${runId}: failed to emit ${type} event — ${String(err)}`,
);
}
}
/**
* Emits `run.finished` with the run's final status. Called exactly once per
* run, from the single exit point of each run's lifecycle (the `finally` of
* processRunToCompletion, setup failure, stale-run cleanup), never from the
* individual pass/fail transitions.
*/
private emitFinished(runId: string): Promise<void> {
return this.emitRunEvent("run.finished", runId);
}
private persistLog(
runId: string,
stepRunId: string | null,
@@ -214,6 +258,7 @@ export class ScenarioSchedulerService implements OnModuleInit {
run.status = "in_progress";
await this.runRepo.save(run);
this.logger.log(`Run #${run.id} → in_progress`);
await this.emitRunEvent("run.started", run.id);
const credMap = await this.scenarioService
.buildCredentialMap(run.scenarioId)
.catch(() => ({}) as Record<string, unknown>);
@@ -267,6 +312,7 @@ export class ScenarioSchedulerService implements OnModuleInit {
run.id,
`Run setup failed: ${String(err)}`,
).catch(() => {});
await this.emitFinished(run.id);
}),
),
);
@@ -315,6 +361,7 @@ export class ScenarioSchedulerService implements OnModuleInit {
);
await this.failRun(runId, `Unexpected error: ${(err as Error).message}`);
} finally {
await this.emitFinished(runId);
// Before runLogSeq is cleared, so the trace log entry keeps its order
await this.saveTrace(runId);
this.activeRuns.delete(runId);
@@ -11,12 +11,14 @@ import {
Post,
Query,
Res,
Sse,
UseInterceptors,
UploadedFile,
} from "@nestjs/common";
import { FileInterceptor } from "@nestjs/platform-express";
import { ApiOperation, ApiResponse, ApiTags } from "@nestjs/swagger";
import { Response } from "express";
import { interval, map, merge, type Observable } from "rxjs";
import type { File as MulterFile } from "multer";
import { stringify as yamlStringify } from "yaml";
import { AddScenarioCredentialDto } from "./dto/add-scenario-credential.dto";
@@ -28,15 +30,24 @@ import { RunsQueryDto } from "./dto/runs-query.dto";
import { ExportEntity, ScenarioExportDto } from "./dto/scenario-export.dto";
import { UpdateScenarioStepDto } from "./dto/update-scenario-step.dto";
import { UpdateScenarioDto } from "./dto/update-scenario.dto";
import { RunEventsService } from "./run-events.service";
import { ScenarioService } from "./scenario.service";
import { E2eExportService } from "./e2e-export.service";
interface SseMessage {
type: string;
data: object;
}
@ApiTags("scenarios")
@Controller("scenarios")
export class ScenarioController {
private static readonly HEARTBEAT_MS = 25_000;
constructor(
private readonly scenarioService: ScenarioService,
private readonly e2eExportService: E2eExportService,
private readonly runEvents: RunEventsService,
) {}
// ── Scenarios ─────────────────────────────────────────────────────────────
@@ -73,6 +84,23 @@ export class ScenarioController {
return this.scenarioService.findAllRuns(query);
}
@Sse("runs/events")
@ApiOperation({
summary:
"Server-sent events stream of run lifecycle events (run.started, run.finished) for all scenarios",
})
@ApiResponse({ status: 200, description: "text/event-stream" })
streamRunEvents(): Observable<SseMessage> {
const events = this.runEvents
.stream()
.pipe(map((event): SseMessage => ({ type: event.type, data: event })));
// Periodic named event so proxies don't drop an idle connection
const heartbeat = interval(ScenarioController.HEARTBEAT_MS).pipe(
map((): SseMessage => ({ type: "ping", data: {} })),
);
return merge(events, heartbeat);
}
@Get("run-defaults")
@ApiOperation({ summary: "Get server-configured defaults for new runs" })
@ApiResponse({ status: 200 })
+7 -1
View File
@@ -13,6 +13,7 @@ import { ScenarioCredentialEntity } from "./scenario-credential.entity";
import { ScenarioRunLogEntity } from "./scenario-run-log.entity";
import { ScenarioRunStepEntity } from "./scenario-run-step.entity";
import { ScenarioRunEntity } from "./scenario-run.entity";
import { RunEventsService } from "./run-events.service";
import { ScenarioSchedulerService } from "./scenario-scheduler.service";
import { ScenarioVersionEntity } from "./scenario-version.entity";
import { ScenarioStepEntity } from "./scenario-step.entity";
@@ -43,7 +44,12 @@ import { E2eExportService } from "./e2e-export.service";
FileModule,
],
controllers: [ScenarioController],
providers: [ScenarioService, ScenarioSchedulerService, E2eExportService],
providers: [
ScenarioService,
ScenarioSchedulerService,
E2eExportService,
RunEventsService,
],
exports: [ScenarioService, E2eExportService],
})
export class ScenarioModule {}