@specific.dev/spectest 0.89.0 → 0.90.0

package/dist/android.d.ts

@@ -0,0 +1,84 @@
+import { type Wrapped } from "./inspect.js";
+export interface AndroidRecordingOptions {
+    /** Maximum dimension of the video, default 1280. */
+    maxSize?: number;
+    /** Maximum frame rate, default 15. Static screens produce few frames. */
+    maxFps?: number;
+    /** H.264 bitrate target in bits/second, default 2,000,000. */
+    bitRate?: number;
+}
+export declare const ANDROID_APP: unique symbol;
+export interface AndroidApp {
+    readonly [ANDROID_APP]: true;
+    readonly name: string;
+    readonly endpoint: string;
+    readonly recorderEndpoint: string;
+    readonly serial: string;
+    readonly package: string;
+    readonly recording: false | AndroidRecordingOptions;
+    readonly showTouches?: boolean;
+}
+export declare function androidApp(options: Omit<AndroidApp, typeof ANDROID_APP>): AndroidApp;
+export declare function isAndroidApp(value: unknown): value is AndroidApp;
+export declare class AppiumError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface AndroidElement {
+    tap(): Promise<void>;
+    fill(text: string): Promise<void>;
+    text(): Promise<Wrapped<string>>;
+    isDisplayed(): Promise<Wrapped<boolean>>;
+    waitFor(options?: {
+        state?: "visible" | "hidden";
+        timeoutMs?: number;
+    }): Promise<void>;
+}
+export interface Android {
+    getByAccessibilityId(id: string): AndroidElement;
+    getById(resourceId: string): AndroidElement;
+    getByText(text: string): AndroidElement;
+    /** Appium selector, e.g. -android uiautomator or xpath. */
+    locator(using: string, value: string): AndroidElement;
+    tap(x: number, y: number): Promise<void>;
+    swipe(direction: "up" | "down" | "left" | "right"): Promise<void>;
+    back(): Promise<void>;
+    pageSource(): Promise<Wrapped<string>>;
+    /** PNG bytes. */
+    screenshot(): Promise<Uint8Array>;
+    /** Appium extension command, e.g. mobile: getDeviceInfo. */
+    execute<T = unknown>(script: string, args?: Record<string, unknown>): Promise<Wrapped<T>>;
+}
+export interface AndroidTap {
+    /** Milliseconds from the case start, in the same clock as the video manifest. */
+    offsetMs: number;
+    /** Normalized screen coordinates, independent of encoding resolution. */
+    x: number;
+    y: number;
+}
+export interface AndroidRecording {
+    id: string;
+    name: string;
+    package: string;
+    openedAtMs: number;
+    closedAtMs: number;
+    mediaDurationMs: number;
+    width: number;
+    height: number;
+    bytes: number;
+    taps?: AndroidTap[];
+    error?: string;
+}
+/** A case owns capture and handle lifetime; the Android/Appium processes outlive it. */
+export declare function androidScope(caseId: string, testStartedAt: number, options?: {
+    record?: boolean;
+}): {
+    begin: (apps?: Iterable<AndroidApp>) => Promise<void>;
+    open: (app: AndroidApp) => Promise<Android>;
+    finish: () => Promise<AndroidRecording[]>;
+    deactivate: () => void;
+};
+export declare function androidRecordingChunk(id: string, offset: unknown, limit: unknown): Promise<unknown>;
+export declare function releaseAndroidRecording(id: string): Promise<{
+    released: boolean;
+}>;

package/dist/android.js

@@ -0,0 +1,355 @@
+import { createHash } from "node:crypto";
+import { rawFetch } from "./harness/raw-fetch.js";
+import { recordStep, reserveEvent } from "./recorder.js";
+import { wrap } from "./inspect.js";
+export const ANDROID_APP = Symbol.for("spectest.androidApp");
+export function androidApp(options) {
+    return { ...options, [ANDROID_APP]: true };
+}
+export function isAndroidApp(value) {
+    return !!value && typeof value === "object" && value[ANDROID_APP] === true;
+}
+export class AppiumError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AppiumError";
+    }
+}
+async function request(url, method = "GET", body) {
+    const response = await rawFetch(url, {
+        method,
+        ...(body === undefined
+            ? {}
+            : { headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }),
+        signal: AbortSignal.timeout(120000),
+    });
+    const data = (await response.json());
+    if (!response.ok || data.value?.error || data.error)
+        throw new AppiumError(data.value?.error ?? "unknown error", data.value?.message ?? data.error ?? `Android request failed (${response.status})`);
+    return ("value" in data ? data.value : data);
+}
+// Both the Appium session and this registry are preserved by a VM snapshot.
+// Never reset/relaunch the app or delete its session at a case boundary.
+const sessions = new Map();
+async function session(app) {
+    const key = JSON.stringify([app.endpoint, app.serial, app.package]);
+    let pending = sessions.get(key);
+    if (!pending) {
+        pending = request(`${app.endpoint}/session`, "POST", {
+            capabilities: {
+                alwaysMatch: {
+                    platformName: "Android",
+                    "appium:automationName": "UiAutomator2",
+                    "appium:udid": app.serial,
+                    "appium:appPackage": app.package,
+                    "appium:noReset": true,
+                    "appium:autoLaunch": false,
+                    "appium:dontStopAppOnReset": true,
+                    "appium:newCommandTimeout": 0,
+                },
+            },
+        })
+            .then((result) => {
+            if (!result.sessionId)
+                throw new Error("Appium returned no session id");
+            return result.sessionId;
+        })
+            .catch((error) => {
+            sessions.delete(key);
+            throw error;
+        });
+        sessions.set(key, pending);
+    }
+    return pending;
+}
+const parked = new Map();
+let epoch = 0;
+/** A case owns capture and handle lifetime; the Android/Appium processes outlive it. */
+export function androidScope(caseId, testStartedAt, options = {}) {
+    let active = true;
+    const captures = new Map();
+    const handles = new Map();
+    const taps = new Map();
+    const assertActive = () => {
+        if (!active)
+            throw new Error("This Android handle belongs to a finished test");
+    };
+    async function capture(app) {
+        assertActive();
+        if (app.recording === false || options.record === false)
+            return;
+        let pending = captures.get(app.name);
+        if (!pending) {
+            if (captures.size >= 8)
+                throw new Error("A case can record at most eight Android devices");
+            const id = createHash("sha256").update(`${caseId}:${app.name}:${++epoch}`).digest("hex");
+            pending = request(`${app.recorderEndpoint}/recordings`, "POST", {
+                id,
+                ...app.recording,
+            }).then((result) => ({
+                app,
+                id,
+                openedAtMs: Math.max(0, result.startedAtMs - testStartedAt),
+            }));
+            captures.set(app.name, pending);
+        }
+        await pending;
+    }
+    async function begin(apps = []) {
+        assertActive();
+        // Previous artifacts were fetched before the VM was handed off. Forked
+        // children can discard their inherited copies without touching siblings.
+        for (const [id, previous] of parked) {
+            await request(`${previous.app.recorderEndpoint}/recordings/${id}`, "DELETE");
+            parked.delete(id);
+        }
+        for (const app of apps)
+            await capture(app);
+        assertActive();
+    }
+    async function open(app) {
+        assertActive();
+        if (!isAndroidApp(app))
+            throw new Error("ctx.android(): pass the handle from an android() service");
+        let pending = handles.get(app.name);
+        if (pending)
+            return pending;
+        pending = (async () => {
+            await capture(app);
+            assertActive();
+            const sid = await session(app);
+            assertActive();
+            const command = (method, path, body) => {
+                assertActive();
+                return request(`${app.endpoint}/session/${encodeURIComponent(sid)}${path}`, method, body);
+            };
+            async function tapMarker(point) {
+                if (!captures.has(app.name) || app.showTouches === false)
+                    return;
+                // Appium injects touches after Android's physical-touch visualizer.
+                // Keep markers alongside the video; never change tap semantics or fail
+                // a test just because optional visual feedback could not be measured.
+                try {
+                    const screen = await command("GET", "/window/rect");
+                    const rect = typeof point === "string"
+                        ? await command("GET", `${point}/rect`)
+                        : { ...point, width: 0, height: 0 };
+                    const x = (rect.x + rect.width / 2) / screen.width;
+                    const y = (rect.y + rect.height / 2) / screen.height;
+                    if (![x, y].every(v => Number.isFinite(v) && v >= 0 && v <= 1))
+                        return;
+                    return { x, y, offsetMs: Date.now() - testStartedAt };
+                }
+                catch {
+                    return;
+                }
+            }
+            function saveTap(marker) {
+                if (!marker || !active)
+                    return;
+                const list = taps.get(app.name) ?? [];
+                if (list.length < 10000)
+                    list.push(marker);
+                taps.set(app.name, list);
+            }
+            async function op(title, fn) {
+                assertActive();
+                const reservation = reserveEvent(), started = Date.now();
+                try {
+                    const result = await fn();
+                    const seq = recordStep({
+                        kind: "android",
+                        title: `${app.name}: ${title}`,
+                        durationMs: Date.now() - started,
+                        status: "passed",
+                    }, reservation);
+                    return wrap(result, seq);
+                }
+                catch (error) {
+                    recordStep({
+                        kind: "android",
+                        title: `${app.name}: ${title}`,
+                        durationMs: Date.now() - started,
+                        status: "failed",
+                        error: String(error),
+                    }, reservation);
+                    throw error;
+                }
+            }
+            const element = (using, value) => {
+                const label = `${using}=${value}`;
+                const find = async () => {
+                    const result = await command("POST", "/element", {
+                        using,
+                        value,
+                    });
+                    const id = result["element-6066-11e4-a52e-4f735466cecf"];
+                    if (!id)
+                        throw new Error("Appium returned no element id");
+                    return `/element/${encodeURIComponent(id)}`;
+                };
+                const displayed = async () => {
+                    try {
+                        return await command("GET", `${await find()}/displayed`);
+                    }
+                    catch (error) {
+                        if (error instanceof AppiumError &&
+                            ["no such element", "stale element reference"].includes(error.code))
+                            return false;
+                        throw error;
+                    }
+                };
+                return {
+                    async tap() {
+                        await op(`tap ${label}`, async () => {
+                            const path = await find();
+                            const marker = await tapMarker(path);
+                            await command("POST", `${path}/click`, {});
+                            saveTap(marker);
+                        });
+                    },
+                    async fill(text) {
+                        await op(`fill ${label}`, async () => {
+                            const path = await find();
+                            await command("POST", `${path}/clear`, {});
+                            await command("POST", `${path}/value`, { text });
+                        });
+                    },
+                    text: () => op(`text ${label}`, async () => command("GET", `${await find()}/text`)),
+                    isDisplayed: () => op(`visible ${label}`, displayed),
+                    async waitFor(options = {}) {
+                        const timeout = options.timeoutMs ?? 10000;
+                        if (!Number.isFinite(timeout) || timeout < 0)
+                            throw new Error("Invalid wait timeout");
+                        await op(`wait for ${options.state ?? "visible"} ${label}`, async () => {
+                            const end = Date.now() + timeout;
+                            do {
+                                if ((await displayed()) === (options.state !== "hidden"))
+                                    return;
+                                await new Promise((resolve) => setTimeout(resolve, 100));
+                            } while (Date.now() < end);
+                            throw new Error(`Timed out waiting for ${label}`);
+                        });
+                    },
+                };
+            };
+            return {
+                locator: element,
+                getByAccessibilityId: (id) => element("accessibility id", id),
+                getById: (id) => element("id", id),
+                getByText: (text) => element("-android uiautomator", `new UiSelector().text(${JSON.stringify(text)})`),
+                async tap(x, y) {
+                    await op(`tap (${x}, ${y})`, async () => {
+                        const marker = await tapMarker({ x, y });
+                        await command("POST", "/execute/sync", { script: "mobile: clickGesture", args: [{ x, y }] });
+                        saveTap(marker);
+                    });
+                },
+                async swipe(direction) {
+                    await op(`swipe ${direction}`, async () => {
+                        const rect = await command("GET", "/window/rect");
+                        await command("POST", "/execute/sync", {
+                            script: "mobile: swipeGesture",
+                            args: [
+                                {
+                                    left: rect.width * 0.1,
+                                    top: rect.height * 0.1,
+                                    width: rect.width * 0.8,
+                                    height: rect.height * 0.8,
+                                    direction,
+                                    percent: 0.75,
+                                },
+                            ],
+                        });
+                    });
+                },
+                async back() {
+                    await op("back", () => command("POST", "/back", {}));
+                },
+                pageSource: () => op("page source", () => command("GET", "/source")),
+                async screenshot() {
+                    const value = await op("screenshot", () => command("GET", "/screenshot"));
+                    return Buffer.from(value.unwrap(), "base64");
+                },
+                execute: (script, args = {}) => op(script, () => command("POST", "/execute/sync", { script, args: [args] })),
+            };
+        })();
+        handles.set(app.name, pending);
+        return pending;
+    }
+    async function finish() {
+        active = false;
+        const result = [];
+        for (const [name, pending] of captures) {
+            let owner;
+            let recording = {
+                id: "",
+                name,
+                package: "",
+                openedAtMs: 0,
+                closedAtMs: Date.now() - testStartedAt,
+                mediaDurationMs: 0,
+                width: 0,
+                height: 0,
+                bytes: 0,
+                taps: taps.get(name) ?? [],
+            };
+            try {
+                const { app, id, openedAtMs } = await pending;
+                owner = app;
+                recording = { ...recording, id, package: app.package, openedAtMs };
+                const stopped = await request(`${app.recorderEndpoint}/recordings/${id}/stop`, "POST");
+                recording = {
+                    ...recording,
+                    bytes: stopped.bytes,
+                    width: stopped.width,
+                    height: stopped.height,
+                    mediaDurationMs: stopped.mediaDurationMs,
+                    closedAtMs: Math.max(openedAtMs, stopped.closedAtMs - testStartedAt),
+                };
+                parked.set(id, { app, recording });
+            }
+            catch (error) {
+                recording.error = String(error);
+                // A failed finalization still owns a file in the tools container.
+                if (recording.id) {
+                    if (owner)
+                        await request(`${owner.recorderEndpoint}/recordings/${recording.id}`, "DELETE").catch(() => { });
+                }
+            }
+            result.push(recording);
+        }
+        return result;
+    }
+    return {
+        begin,
+        open,
+        finish,
+        deactivate: () => {
+            active = false;
+        },
+    };
+}
+export async function androidRecordingChunk(id, offset, limit) {
+    const entry = parked.get(id);
+    if (!entry)
+        throw new Error("Unknown Android recording");
+    const start = Number(offset ?? 0), count = Number(limit ?? 6291456);
+    if (!Number.isSafeInteger(start) ||
+        start < 0 ||
+        !Number.isSafeInteger(count) ||
+        count < 1 ||
+        count > 6291456)
+        throw new Error("Invalid recording chunk range");
+    return request(`${entry.app.recorderEndpoint}/recordings/${id}?offset=${start}&limit=${count}`);
+}
+export async function releaseAndroidRecording(id) {
+    const entry = parked.get(id);
+    if (entry) {
+        await request(`${entry.app.recorderEndpoint}/recordings/${id}`, "DELETE");
+        parked.delete(id);
+    }
+    return { released: true };
+}

package/dist/components/android-runtime.mjs

@@ -0,0 +1,257 @@
+// Runs inside the Android tools container, in the same snapshotted VM.
+import http from "node:http";
+import { spawn, execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir, stat, open, rm } from "node:fs/promises";
+const exec = promisify(execFile);
+const serial = process.env.ANDROID_SERIAL;
+const directory = "/recordings";
+const recordings = new Map();
+const maxBytes = 256 * 1024 * 1024;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const adb = (...args) =>
+  exec("adb", ["-s", serial, ...args], { timeout: 120000, maxBuffer: 1024 * 1024 });
+await mkdir(directory, { recursive: true });
+let ready = false;
+let bootError;
+async function bootstrap() {
+  const deadline = Date.now() + 180000;
+  while (Date.now() < deadline) {
+    try {
+      await exec("adb", ["connect", serial], { timeout: 10000 });
+      if ((await adb("shell", "getprop", "sys.boot_completed")).stdout.trim() === "1") break;
+    } catch {}
+    await sleep(500);
+  }
+  if ((await adb("shell", "getprop", "sys.boot_completed")).stdout.trim() !== "1") {
+    throw new Error(
+      "Android did not boot; the guest kernel needs Binder, DMA-BUF heaps and PSI enabled",
+    );
+  }
+  await adb("install", "-r", "/spectest/app.apk");
+  await adb("shell", "settings", "put", "global", "private_dns_mode", "off");
+  for (const setting of [
+    "window_animation_scale",
+    "transition_animation_scale",
+    "animator_duration_scale",
+  ]) {
+    await adb("shell", "settings", "put", "global", setting, "0");
+  }
+  // Native feedback covers physical input; injected Appium taps use replay metadata.
+  await adb("shell", "settings", "put", "system", "show_touches", process.env.ANDROID_SHOW_TOUCHES ?? "1");
+  await adb("shell", "svc", "power", "stayon", "true");
+  await adb("shell", "input", "keyevent", "82");
+  await adb("shell", "am", "start", "-W", "-n", process.env.ANDROID_ACTIVITY);
+  const appium = spawn(
+    "appium",
+    ["--address", "0.0.0.0", "--port", "4723", "--log-level", "warn"],
+    { stdio: "inherit" },
+  );
+  appium.on("exit", (code) => {
+    ready = false;
+    bootError = `Appium exited (${code})`;
+  });
+  appium.on("error", (error) => {
+    ready = false;
+    bootError = error.message;
+  });
+  for (let i = 0; i < 120; i++) {
+    try {
+      if ((await fetch("http://127.0.0.1:4723/status")).ok) {
+        ready = true;
+        return;
+      }
+    } catch {}
+    await sleep(250);
+  }
+  throw new Error("Appium did not become ready");
+}
+bootstrap().catch((error) => {
+  bootError = error.message;
+  console.error(error);
+});
+
+async function startRecording(body) {
+  if (!/^[a-z0-9-]{1,100}$/.test(body.id)) throw new Error("invalid recording id");
+  if (recordings.has(body.id)) throw new Error("recording already exists");
+  if ([...recordings.values()].some((r) => !r.stopped))
+    throw new Error("a recording is already active");
+  if (recordings.size >= 8) throw new Error("release older recordings before starting another");
+  const size = body.maxSize ?? 1280,
+    fps = body.maxFps ?? 15,
+    bitrate = body.bitRate ?? 2000000;
+  if (
+    !Number.isInteger(size) ||
+    size < 320 ||
+    size > 1920 ||
+    !Number.isInteger(fps) ||
+    fps < 1 ||
+    fps > 30 ||
+    !Number.isInteger(bitrate) ||
+    bitrate < 100000 ||
+    bitrate > 8000000
+  )
+    throw new Error("invalid recording settings");
+  const path = `${directory}/${body.id}.mp4`;
+  // scrcpy's stdout is otherwise block-buffered under Node's pipes: the
+  // readiness line may never flush on an idle screen.
+  const child = spawn("stdbuf", [
+    "-oL",
+    "-eL",
+    "scrcpy",
+    "--serial",
+    serial,
+    "--no-window",
+    "--no-playback",
+    "--no-control",
+    "--no-audio",
+    "--video-codec=h264",
+    "--video-encoder=c2.android.avc.encoder",
+    `--max-size=${size}`,
+    `--max-fps=${fps}`,
+    `--video-bit-rate=${bitrate}`,
+    `--record=${path}`,
+  ]);
+  const record = { child, path, stopped: false, log: "", error: null, startedAtMs: Date.now() };
+  recordings.set(body.id, record);
+  record.exit = new Promise((resolve) => {
+    child.on("error", (error) => {
+      record.error = error.message;
+      resolve(-1);
+    });
+    child.on("exit", (code) => {
+      if (!record.stopped) record.error = `Recorder exited early (${code})`;
+      resolve(code);
+    });
+  });
+  for (const output of [child.stdout, child.stderr])
+    output.on("data", (b) => {
+      record.log = (record.log + b).slice(-16000);
+      if (!record.started && record.log.includes("Recording started")) {
+        record.started = true;
+        record.startedAtMs = Date.now();
+      }
+    });
+  record.guard = setInterval(async () => {
+    if ((await stat(path).catch(() => ({ size: 0 }))).size > maxBytes) {
+      record.error = "Recording exceeded 256 MiB";
+      child.kill("SIGINT");
+    }
+  }, 1000);
+  try {
+    for (let i = 0; i < 200; i++) {
+      if (record.error) throw new Error(`${record.error}: ${record.log}`);
+      if (record.started) return { startedAtMs: record.startedAtMs };
+      await sleep(50);
+    }
+    throw new Error(`Recorder startup timed out: ${record.log}`);
+  } catch (error) {
+    clearInterval(record.guard);
+    record.stopped = true;
+    child.kill("SIGKILL");
+    await record.exit;
+    await rm(path, { force: true });
+    recordings.delete(body.id);
+    throw error;
+  }
+}
+async function stopRecording(record) {
+  if (record.result) return record.result;
+  record.stopped = true;
+  const closedAtMs = Date.now();
+  clearInterval(record.guard);
+  record.child.kill("SIGINT");
+  let timer;
+  const code = await Promise.race([
+    record.exit,
+    new Promise((resolve) => {
+      timer = setTimeout(() => {
+        record.error = "Recorder finalization timed out";
+        record.child.kill("SIGKILL");
+        resolve(-1);
+      }, 15000);
+    }),
+  ]);
+  clearTimeout(timer);
+  if (record.error || code !== 0)
+    throw new Error(`${record.error ?? "Recorder failed"}: ${record.log}`);
+  const bytes = (await stat(record.path)).size;
+  if (bytes > maxBytes) throw new Error("Recording exceeded 256 MiB");
+  const { stdout } = await exec("ffprobe", [
+    "-v",
+    "error",
+    "-show_format",
+    "-show_streams",
+    "-of",
+    "json",
+    record.path,
+  ]);
+  const probe = JSON.parse(stdout),
+    stream = probe.streams.find((s) => s.codec_type === "video");
+  if (!stream || !Number(stream.nb_frames)) throw new Error("Recording contains no video frames");
+  return (record.result = {
+    bytes,
+    startedAtMs: record.startedAtMs,
+    closedAtMs,
+    width: stream.width,
+    height: stream.height,
+    mediaDurationMs: Math.round(Number(probe.format.duration) * 1000),
+  });
+}
+const server = http.createServer(async (req, res) => {
+  const json = (status, body) => {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+  };
+  try {
+    const url = new URL(req.url, "http://localhost");
+    if (url.pathname === "/ready") return json(ready ? 200 : 503, { ready, error: bootError });
+    if (!ready) return json(503, { error: bootError ?? "Android is starting" });
+    if (req.method === "POST" && url.pathname === "/recordings") {
+      let body = "";
+      for await (const chunk of req) {
+        body += chunk;
+        if (body.length > 8192) throw new Error("request too large");
+      }
+      return json(200, await startRecording(JSON.parse(body)));
+    }
+    const match = url.pathname.match(/^\/recordings\/([a-z0-9-]{1,100})(\/stop)?$/);
+    const record = match && recordings.get(match[1]);
+    if (!record) return json(404, { error: "Unknown recording" });
+    if (req.method === "POST" && match[2]) return json(200, await stopRecording(record));
+    if (req.method === "DELETE") {
+      if (!record.stopped) throw new Error("Stop the recording before releasing it");
+      await rm(record.path, { force: true });
+      recordings.delete(match[1]);
+      return json(200, { released: true });
+    }
+    if (req.method === "GET" && record.result) {
+      const offset = Number(url.searchParams.get("offset") ?? 0),
+        limit = Number(url.searchParams.get("limit") ?? 6291456);
+      if (
+        !Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > 6291456
+      )
+        throw new Error("invalid chunk range");
+      const file = await open(record.path, "r");
+      try {
+        const buffer = Buffer.alloc(Math.min(limit, Math.max(0, record.result.bytes - offset)));
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, offset);
+        return json(200, {
+          total: record.result.bytes,
+          offset,
+          b64: buffer.subarray(0, bytesRead).toString("base64"),
+        });
+      } finally {
+        await file.close();
+      }
+    }
+    json(409, { error: "Recording is not finalized" });
+  } catch (error) {
+    json(500, { error: error.message });
+  }
+});
+server.listen(4725, "0.0.0.0");