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 {}
+109
View File
@@ -0,0 +1,109 @@
import { INestApplication } from "@nestjs/common";
import { DataSource } from "typeorm";
import { buildTestApp } from "./app.harness";
import { EnvironmentEntity } from "../src/environment/environment.entity";
import {
RunEvent,
RunEventsService,
} from "../src/scenario/run-events.service";
import { ScenarioController } from "../src/scenario/scenario.controller";
import { ScenarioSchedulerService } from "../src/scenario/scenario-scheduler.service";
import { ScenarioService } from "../src/scenario/scenario.service";
describe("run events", () => {
let app: INestApplication;
let dataSource: DataSource;
let scenarioService: ScenarioService;
let scheduler: ScenarioSchedulerService;
let events: RunEvent[];
let subscription: { unsubscribe(): void };
beforeAll(async () => {
app = await buildTestApp();
dataSource = app.get(DataSource);
scenarioService = app.get(ScenarioService);
scheduler = app.get(ScenarioSchedulerService);
});
beforeEach(() => {
events = [];
subscription = app
.get(RunEventsService)
.stream()
.subscribe((e) => events.push(e));
});
afterEach(() => subscription.unsubscribe());
afterAll(async () => {
await app.close();
});
async function runScenario(name: string, codes: string[]) {
const scenario = await scenarioService.create({ name });
for (const execCode of codes) {
await scenarioService.createStep(scenario.id, { execCode });
}
const repo = dataSource.getRepository(EnvironmentEntity);
const env = await repo.save(
repo.create({ name: `env-${Math.random()}`, data: {} }),
);
const run = await scenarioService.createRun(scenario.id, env.id);
await scheduler.pickUpPendingRuns();
await scenarioService.waitForRun(scenario.id, run.id, 10_000);
// run.finished is emitted just after the status becomes terminal
await waitFor(() => events.some((e) => e.type === "run.finished"));
// give a double emit the chance to show up
await new Promise((r) => setTimeout(r, 200));
return { scenario, run };
}
async function waitFor(cond: () => boolean) {
for (let i = 0; i < 100 && !cond(); i++) {
await new Promise((r) => setTimeout(r, 50));
}
}
it("emits started then finished(pass) for a passing run", async () => {
const { scenario, run } = await runScenario("events-pass", ["return 1;"]);
expect(events.map((e) => [e.type, e.status])).toEqual([
["run.started", "in_progress"],
["run.finished", "pass"],
]);
expect(events[0]).toMatchObject({
runId: run.id,
scenarioId: scenario.id,
scenarioName: "events-pass",
});
expect(Number.isNaN(Date.parse(events[1].at))).toBe(false);
});
it("emits finished(fail) exactly once for a failing run", async () => {
await runScenario("events-fail", ["throw new Error('boom');", "return 2;"]);
expect(events.map((e) => [e.type, e.status])).toEqual([
["run.started", "in_progress"],
["run.finished", "fail"],
]);
});
it("exposes events through the SSE controller stream", () => {
const received: { type: string; data: object }[] = [];
const sub = app
.get(ScenarioController)
.streamRunEvents()
.subscribe((m) => received.push(m));
app.get(RunEventsService).emit({
type: "run.started",
runId: "r",
scenarioId: "s",
scenarioName: "n",
status: "in_progress",
at: new Date().toISOString(),
});
sub.unsubscribe();
expect(received).toHaveLength(1);
expect(received[0].type).toBe("run.started");
});
});