@nickname4th/pura-cli 0.1.0

package/server/dist/cli.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import { listDevices } from "./adb.js";
+import { readConfig, writeConfig } from "./config.js";
+import { getLanAddress, normalizeHttpUrl } from "./network.js";
+const args = process.argv.slice(2);
+const command = args[0];
+const launchAgentLabel = "tech.itool.pura.agent";
+const launchAgentPath = path.join(os.homedir(), "Library", "LaunchAgents", `${launchAgentLabel}.plist`);
+if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+}
+if (command === "hub") {
+    startServer({
+        ROLE: "hub",
+        PORT: readFlag("--port") ?? "8787",
+        HOST: readFlag("--host") ?? "0.0.0.0"
+    });
+}
+else if (command === "connect") {
+    await handleConnect();
+}
+else if (command === "auto-connect") {
+    await handleAutoConnect();
+}
+else if (command === "devices") {
+    console.table(await listDevices());
+}
+else {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+}
+async function handleConnect() {
+    const target = args[1];
+    if (!target) {
+        console.error("Missing hub address or subcommand.");
+        printHelp();
+        process.exit(1);
+    }
+    if (target === "device") {
+        await publishLocalDevice();
+        return;
+    }
+    const hubUrl = normalizeHttpUrl(target);
+    const config = readConfig();
+    const agentId = readFlag("--id") ?? config.agentId ?? randomUUID();
+    const agentName = readFlag("--name") ?? config.agentName ?? process.env.USER ?? "developer";
+    const port = readFlag("--port") ?? "8788";
+    const publicUrl = readFlag("--public-url") ?? `http://${getLanAddress()}:${port}`;
+    const host = readFlag("--host") ?? "0.0.0.0";
+    const dataDir = resolveAgentDataDir(readFlag("--data-dir") ?? config.dataDir);
+    writeConfig({ hubUrl, agentId, agentName, agentPort: port, publicUrl, host, dataDir });
+    console.log(`pura-cli saved hub: ${hubUrl}`);
+    console.log(`agent URL announced to hub: ${publicUrl}`);
+    if (hasFlag("--background") || hasFlag("--install")) {
+        installLaunchAgent();
+        return;
+    }
+    console.log(`pura-cli starting agent: ${agentName} (${agentId})`);
+    console.log("Tip: use `--background` to keep the Agent running after this terminal closes.");
+    startServer({
+        ROLE: "agent",
+        HUB_URL: hubUrl,
+        AGENT_ID: agentId,
+        AGENT_NAME: agentName,
+        PUBLIC_URL: publicUrl,
+        PORT: port,
+        HOST: host,
+        DATA_DIR: dataDir
+    });
+}
+async function handleAutoConnect() {
+    if (hasFlag("--install")) {
+        installLaunchAgent();
+        return;
+    }
+    if (hasFlag("--uninstall")) {
+        uninstallLaunchAgent();
+        return;
+    }
+    if (hasFlag("--status")) {
+        printLaunchAgentStatus();
+        return;
+    }
+    const config = readConfig();
+    if (!config.hubUrl) {
+        console.error("No saved hub found. Run `pura-cli connect <hub-url> --name <name>` once first.");
+        process.exit(1);
+    }
+    startSavedAgent(config);
+}
+async function publishLocalDevice() {
+    const config = readConfig();
+    const agentPort = readFlag("--port") ?? config.agentPort ?? "8788";
+    const devices = await listDevices();
+    const serial = readFlag("--serial") ?? devices.find((device) => device.state === "device")?.serial;
+    if (!serial) {
+        console.error("No ready ADB device found. Run `adb devices -l` and authorize USB debugging first.");
+        process.exit(1);
+    }
+    const device = devices.find((item) => item.serial === serial);
+    const fallbackName = [device?.manufacturer, device?.model].filter(Boolean).join(" ") || serial;
+    const label = readFlag("--name") ?? fallbackName;
+    const owner = readFlag("--owner") ?? config.agentName ?? process.env.USER;
+    const note = readFlag("--note") ?? "";
+    const response = await fetch(`http://127.0.0.1:${agentPort}/api/devices/${encodeURIComponent(serial)}/publication`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ label, owner, note })
+    });
+    if (!response.ok) {
+        console.error(`Failed to publish device: ${await response.text()}`);
+        process.exit(1);
+    }
+    console.log(`Published ${label} (${serial}) to ${config.hubUrl ?? "configured hub"}`);
+}
+function startSavedAgent(config) {
+    const port = readFlag("--port") ?? config.agentPort ?? "8788";
+    const publicUrl = readFlag("--public-url") ?? config.publicUrl ?? `http://${getLanAddress()}:${port}`;
+    const agentId = readFlag("--id") ?? config.agentId ?? randomUUID();
+    const agentName = readFlag("--name") ?? config.agentName ?? process.env.USER ?? "developer";
+    const host = readFlag("--host") ?? config.host ?? "0.0.0.0";
+    const dataDir = resolveAgentDataDir(readFlag("--data-dir") ?? config.dataDir);
+    writeConfig({
+        hubUrl: config.hubUrl,
+        agentId,
+        agentName,
+        agentPort: port,
+        publicUrl,
+        host,
+        dataDir
+    });
+    console.log(`pura-cli auto-connecting agent: ${agentName} (${agentId})`);
+    console.log(`hub: ${config.hubUrl}`);
+    console.log(`agent URL announced to hub: ${publicUrl}`);
+    startServer({
+        ROLE: "agent",
+        HUB_URL: config.hubUrl,
+        AGENT_ID: agentId,
+        AGENT_NAME: agentName,
+        PUBLIC_URL: publicUrl,
+        PORT: port,
+        HOST: host,
+        DATA_DIR: dataDir
+    });
+}
+function installLaunchAgent() {
+    const config = readConfig();
+    if (!config.hubUrl) {
+        console.error("No saved hub found. Run `pura-cli connect <hub-url> --name <name>` once first.");
+        process.exit(1);
+    }
+    if (process.platform !== "darwin") {
+        console.error("`pura-cli auto-connect --install` currently supports macOS launchd only.");
+        process.exit(1);
+    }
+    const cliPath = path.resolve(process.argv[1]);
+    fs.mkdirSync(path.dirname(launchAgentPath), { recursive: true });
+    fs.writeFileSync(launchAgentPath, makeLaunchAgentPlist(process.execPath, cliPath));
+    const guiTarget = getLaunchdGuiTarget();
+    const serviceTarget = `${guiTarget}/${launchAgentLabel}`;
+    runLaunchctl(["bootout", serviceTarget], { allowFailure: true });
+    runLaunchctl(["bootstrap", guiTarget, launchAgentPath]);
+    runLaunchctl(["enable", serviceTarget], { allowFailure: true });
+    runLaunchctl(["kickstart", "-k", serviceTarget], { allowFailure: true });
+    console.log(`Installed pura auto-connect LaunchAgent: ${launchAgentPath}`);
+    console.log(`It will start on login and keep the Agent connected to ${config.hubUrl}.`);
+    if (cliPath.includes(`${path.sep}_npx${path.sep}`)) {
+        console.warn("This was installed from an npx cache path. For long-term use, install pura-cli globally and run the install command again.");
+    }
+}
+function uninstallLaunchAgent() {
+    if (process.platform !== "darwin") {
+        console.error("`pura-cli auto-connect --uninstall` currently supports macOS launchd only.");
+        process.exit(1);
+    }
+    runLaunchctl(["bootout", `${getLaunchdGuiTarget()}/${launchAgentLabel}`], { allowFailure: true });
+    if (fs.existsSync(launchAgentPath)) {
+        fs.unlinkSync(launchAgentPath);
+    }
+    console.log("Removed pura auto-connect LaunchAgent.");
+}
+function printLaunchAgentStatus() {
+    if (process.platform !== "darwin") {
+        console.log("pura auto-connect status is only available for macOS launchd.");
+        return;
+    }
+    const result = spawnSync("launchctl", ["print", `${getLaunchdGuiTarget()}/${launchAgentLabel}`], {
+        encoding: "utf8"
+    });
+    if (result.status === 0) {
+        console.log(result.stdout.trim());
+    }
+    else {
+        console.log("pura auto-connect is not installed or not loaded.");
+    }
+}
+function makeLaunchAgentPlist(nodePath, cliPath) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(launchAgentLabel)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(cliPath)}</string>
+    <string>auto-connect</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(path.join(os.homedir(), "Library", "Logs", "pura-agent.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(path.join(os.homedir(), "Library", "Logs", "pura-agent.err.log"))}</string>
+</dict>
+</plist>
+`;
+}
+function runLaunchctl(args, options) {
+    const result = spawnSync("launchctl", args, { encoding: "utf8" });
+    if (result.status !== 0 && !options?.allowFailure) {
+        const message = result.stderr.trim() || result.stdout.trim() || `launchctl ${args.join(" ")} failed`;
+        console.error(message);
+        process.exit(result.status ?? 1);
+    }
+}
+function getLaunchdGuiTarget() {
+    if (!process.getuid) {
+        console.error("Could not determine the current macOS user id.");
+        process.exit(1);
+    }
+    return `gui/${process.getuid()}`;
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function resolveAgentDataDir(value) {
+    if (!value)
+        return path.join(os.homedir(), ".pura", "agent-data");
+    return path.isAbsolute(value) ? value : path.resolve(value);
+}
+function startServer(env) {
+    const child = spawn(process.execPath, [new URL("./index.js", import.meta.url).pathname], {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            ...env
+        }
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+}
+function readFlag(name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function hasFlag(name) {
+    return args.includes(name);
+}
+function printHelp() {
+    console.log(`pura-cli
+
+Usage:
+  pura-cli hub [--host 0.0.0.0] [--port 8787]
+  pura-cli connect <hub-ip-or-url> [--name developer] [--port 8788] [--public-url http://lan-ip:8788] [--background]
+  pura-cli auto-connect [--install|--uninstall|--status]
+  pura-cli connect device [--serial adb-serial] [--name device-name] [--owner developer] [--note text]
+  pura-cli devices
+`);
+}

package/server/dist/config.js

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const configDir = path.join(os.homedir(), ".pura");
+const configPath = path.join(configDir, "config.json");
+export function readConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(config) {
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(configPath, `${JSON.stringify({ ...readConfig(), ...config }, null, 2)}\n`);
+}

package/server/dist/device-id.js

@@ -0,0 +1,13 @@
+export function makeDeviceId(agentId, serial) {
+    return `${encodeURIComponent(agentId)}.${Buffer.from(serial, "utf8").toString("base64url")}`;
+}
+export function parseDeviceId(deviceId) {
+    const [encodedAgentId, encodedSerial] = deviceId.split(".", 2);
+    if (!encodedAgentId || !encodedSerial) {
+        throw new Error("Invalid device id");
+    }
+    return {
+        agentId: decodeURIComponent(encodedAgentId),
+        serial: Buffer.from(encodedSerial, "base64url").toString("utf8")
+    };
+}

package/server/dist/hub.js

@@ -0,0 +1,287 @@
+import { randomUUID } from "node:crypto";
+import { WebSocket } from "ws";
+import { makeDeviceId, parseDeviceId } from "./device-id.js";
+import { httpToWs } from "./network.js";
+import { listDeviceScreenshots, saveScreenshot } from "./screenshots.js";
+const agents = new Map();
+const sessions = new Map();
+const AGENT_TTL_MS = Number(process.env.AGENT_TTL_MS ?? 15_000);
+export function installHubRoutes(app) {
+    app.post("/api/agents/heartbeat", (req, res) => {
+        const body = req.body;
+        if (!body.agentId || !body.url || !Array.isArray(body.devices)) {
+            res.status(400).json({ error: "agentId, url and devices are required" });
+            return;
+        }
+        agents.set(body.agentId, {
+            agentId: body.agentId,
+            agentName: body.agentName,
+            url: body.url.replace(/\/$/, ""),
+            devices: body.devices,
+            lastSeen: Date.now()
+        });
+        res.json({ ok: true });
+    });
+    app.get("/api/devices", (_req, res) => {
+        res.json({ devices: listHubDevices(), sessions: listHubSessions() });
+    });
+    app.put("/api/devices/:deviceId/publication", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/publication`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(req.body ?? {})
+            });
+            res.status(response.status).json(await response.json());
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to publish device" });
+        }
+    });
+    app.delete("/api/devices/:deviceId/publication", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/publication`, {
+                method: "DELETE"
+            });
+            res.status(response.status).json(await response.json());
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to unpublish device" });
+        }
+    });
+    app.post("/api/devices/:deviceId/session", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const restart = req.body?.restart === true;
+            if (restart) {
+                await deleteHubSessionsForDevice(req.params.deviceId);
+            }
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/session`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ restart })
+            });
+            if (!response.ok) {
+                res.status(response.status).json(await response.json());
+                return;
+            }
+            const body = (await response.json());
+            const session = {
+                id: randomUUID(),
+                deviceId: req.params.deviceId,
+                agentId: target.agent.agentId,
+                agentUrl: target.agent.url,
+                agentSessionId: body.session.id,
+                serial: target.remoteSerial,
+                startedAt: Date.now()
+            };
+            sessions.set(session.id, session);
+            res.json({
+                session: {
+                    ...body.session,
+                    id: session.id,
+                    serial: req.params.deviceId
+                }
+            });
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to start remote session" });
+        }
+    });
+    app.get("/api/devices/:deviceId/screenshot", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/screenshot`);
+            if (!response.ok) {
+                res.status(response.status).json({ error: await response.text() });
+                return;
+            }
+            const image = Buffer.from(await response.arrayBuffer());
+            res.setHeader("Content-Type", response.headers.get("content-type") ?? "image/png");
+            res.setHeader("Cache-Control", "no-store");
+            res.end(image);
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to capture remote device screenshot" });
+        }
+    });
+    app.post("/api/devices/:deviceId/screenshots", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/screenshot`);
+            if (!response.ok) {
+                res.status(response.status).json({ error: await response.text() });
+                return;
+            }
+            const image = Buffer.from(await response.arrayBuffer());
+            res.json({ screenshot: await saveScreenshot(image, req.params.deviceId) });
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to save remote device screenshot" });
+        }
+    });
+    app.get("/api/devices/:deviceId/screenshots", (req, res) => {
+        try {
+            findDevice(req.params.deviceId);
+            res.json({ screenshots: listDeviceScreenshots(req.params.deviceId) });
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to list device screenshots" });
+        }
+    });
+    app.post("/api/devices/:deviceId/tap", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/tap`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(req.body ?? {})
+            });
+            res.status(response.status).json(await response.json());
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to tap remote device" });
+        }
+    });
+    app.post("/api/devices/:deviceId/long-press", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/long-press`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(req.body ?? {})
+            });
+            res.status(response.status).json(await response.json());
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to long press remote device" });
+        }
+    });
+    app.post("/api/devices/:deviceId/swipe", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/swipe`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(req.body ?? {})
+            });
+            res.status(response.status).json(await response.json());
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to swipe remote device" });
+        }
+    });
+    app.post("/api/devices/:deviceId/control", async (req, res) => {
+        try {
+            const target = findDevice(req.params.deviceId);
+            const response = await fetch(`${target.agent.url}/api/devices/${encodeURIComponent(target.remoteSerial)}/control`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(req.body ?? {})
+            });
+            res.status(response.status).json(await response.json());
+        }
+        catch (error) {
+            res.status(502).json({ error: error instanceof Error ? error.message : "Failed to control remote device" });
+        }
+    });
+    app.delete("/api/sessions/:id", async (req, res) => {
+        const session = sessions.get(req.params.id);
+        sessions.delete(req.params.id);
+        if (!session) {
+            res.json({ deleted: false });
+            return;
+        }
+        await fetch(`${session.agentUrl}/api/sessions/${encodeURIComponent(session.agentSessionId)}`, {
+            method: "DELETE"
+        }).catch(() => undefined);
+        res.json({ deleted: true });
+    });
+}
+async function deleteHubSessionsForDevice(deviceId) {
+    const staleSessions = [...sessions.values()].filter((session) => session.deviceId === deviceId);
+    await Promise.all(staleSessions.map(async (session) => {
+        sessions.delete(session.id);
+        await fetch(`${session.agentUrl}/api/sessions/${encodeURIComponent(session.agentSessionId)}`, {
+            method: "DELETE"
+        }).catch(() => undefined);
+    }));
+}
+export function attachHubVideoClient(sessionId, client) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+        client.close(1008, "session not found");
+        return;
+    }
+    const remote = new WebSocket(`${httpToWs(session.agentUrl)}/ws/sessions/${session.agentSessionId}/video`);
+    remote.on("message", (data, isBinary) => {
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(data, { binary: isBinary });
+        }
+    });
+    remote.on("error", () => {
+        client.close(1011, "remote stream error");
+    });
+    remote.on("close", () => {
+        client.close(1001, "remote stream closed");
+    });
+    client.on("close", () => {
+        remote.close();
+    });
+}
+function listHubDevices() {
+    pruneAgents();
+    return [...agents.values()].flatMap((agent) => agent.devices.map((device) => ({
+        ...device,
+        serial: makeDeviceId(agent.agentId, device.serial),
+        remoteSerial: device.serial,
+        agentId: agent.agentId,
+        agentName: agent.agentName,
+        agentUrl: agent.url,
+        publication: device.publication
+            ? {
+                ...device.publication,
+                serial: makeDeviceId(agent.agentId, device.serial)
+            }
+            : undefined
+    })));
+}
+function listHubSessions() {
+    return [...sessions.values()].map((session) => ({
+        id: session.id,
+        serial: session.deviceId,
+        viewerCount: 0,
+        startedAt: session.startedAt,
+        stream: {
+            codec: "h264",
+            container: "annexb",
+            size: process.env.STREAM_SIZE ?? "native",
+            bitrate: process.env.STREAM_BITRATE ?? "8000000"
+        }
+    }));
+}
+function findDevice(deviceId) {
+    pruneAgents();
+    const parsed = parseDeviceId(deviceId);
+    const agent = agents.get(parsed.agentId);
+    if (!agent)
+        throw new Error("Agent is offline");
+    const device = agent.devices.find((item) => item.serial === parsed.serial);
+    if (!device)
+        throw new Error("Device is offline");
+    return {
+        agent,
+        device,
+        remoteSerial: parsed.serial
+    };
+}
+function pruneAgents() {
+    const now = Date.now();
+    for (const [agentId, agent] of agents.entries()) {
+        if (now - agent.lastSeen > AGENT_TTL_MS) {
+            agents.delete(agentId);
+        }
+    }
+}

package/server/dist/index.js

@@ -0,0 +1,67 @@
+import express from "express";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer } from "ws";
+import { installAgentRoutes, startAgentHeartbeat } from "./agent.js";
+import { attachHubVideoClient, installHubRoutes } from "./hub.js";
+import { getLanAddress } from "./network.js";
+import { attachPresenceClient } from "./presence.js";
+import { installScreenshotRoutes } from "./screenshots.js";
+import { attachClient } from "./sessions.js";
+const app = express();
+const port = Number(process.env.PORT ?? process.env.API_PORT ?? 8787);
+const host = process.env.HOST ?? "0.0.0.0";
+const role = (process.env.ROLE ?? "standalone").toLowerCase();
+const agentId = process.env.AGENT_ID ?? `${process.env.USER ?? "dev"}-${getLanAddress()}`.replace(/[^a-zA-Z0-9_.-]/g, "-");
+const agentName = process.env.AGENT_NAME ?? process.env.USER;
+const publicUrl = process.env.PUBLIC_URL;
+const hubUrl = process.env.HUB_URL;
+app.use(express.json());
+app.get("/api/health", (_req, res) => {
+    res.json({ ok: true, name: "pura", role, agentId: role === "agent" ? agentId : undefined });
+});
+installScreenshotRoutes(app);
+if (role === "hub") {
+    installHubRoutes(app);
+}
+else {
+    installAgentRoutes(app);
+    if (role === "agent") {
+        startAgentHeartbeat({ hubUrl, agentId, agentName, publicUrl, port });
+    }
+}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const clientDist = path.resolve(__dirname, "../../dist/client");
+app.use(express.static(clientDist));
+app.get(/.*/, (_req, res) => {
+    res.sendFile(path.join(clientDist, "index.html"));
+});
+const server = app.listen(port, host, () => {
+    console.log(`pura ${role} listening on http://${host}:${port}`);
+    if (role === "agent" && hubUrl) {
+        console.log(`pura agent ${agentId} connecting to ${hubUrl}`);
+        console.log(`agent public URL: ${publicUrl ?? `http://${getLanAddress()}:${port}`}`);
+    }
+});
+const wss = new WebSocketServer({ noServer: true });
+server.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+    const videoMatch = url.pathname.match(/^\/ws\/sessions\/([^/]+)\/video$/);
+    const presenceMatch = url.pathname.match(/^\/ws\/presence\/([^/]+)$/);
+    if (!videoMatch && !presenceMatch) {
+        socket.destroy();
+        return;
+    }
+    wss.handleUpgrade(request, socket, head, (ws) => {
+        if (presenceMatch) {
+            attachPresenceClient(decodeURIComponent(presenceMatch[1]), ws);
+        }
+        else if (role === "hub") {
+            attachHubVideoClient(videoMatch[1], ws);
+        }
+        else {
+            attachClient(videoMatch[1], ws);
+        }
+    });
+});