@nickname4th/pura-cli 0.1.0

package/server/dist/network.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+export function getLanAddress() {
+    for (const interfaces of Object.values(os.networkInterfaces())) {
+        for (const item of interfaces ?? []) {
+            if (item.family === "IPv4" && !item.internal) {
+                return item.address;
+            }
+        }
+    }
+    return "127.0.0.1";
+}
+export function normalizeHttpUrl(input) {
+    const value = input.trim();
+    if (!value)
+        throw new Error("Missing URL");
+    return /^https?:\/\//i.test(value) ? value.replace(/\/$/, "") : `http://${value.replace(/\/$/, "")}`;
+}
+export function httpToWs(input) {
+    return input.replace(/^http:/i, "ws:").replace(/^https:/i, "wss:");
+}

package/server/dist/presence.js

@@ -0,0 +1,92 @@
+import { WebSocket } from "ws";
+const rooms = new Map();
+export function attachPresenceClient(roomId, socket) {
+    const client = {
+        id: "",
+        name: "Viewer",
+        color: "#d6ff59",
+        socket
+    };
+    const room = rooms.get(roomId) ?? new Set();
+    room.add(client);
+    rooms.set(roomId, room);
+    socket.on("message", (data) => {
+        const message = parseCursorMessage(data);
+        if (!message)
+            return;
+        client.id = message.clientId ?? client.id;
+        client.name = (message.name ?? client.name).slice(0, 32);
+        client.color = normalizeColor(message.color ?? client.color);
+        if (message.type === "leave") {
+            broadcast(room, client, { type: "leave", clientId: client.id });
+            return;
+        }
+        if (message.type === "clear") {
+            broadcast(room, client, { type: "clear", clientId: client.id });
+            return;
+        }
+        if (message.type === "annotation") {
+            broadcast(room, client, {
+                type: "annotation",
+                clientId: client.id,
+                name: client.name,
+                color: client.color,
+                annotation: message.annotation && typeof message.annotation === "object"
+                    ? {
+                        ...message.annotation,
+                        name: client.name,
+                        color: client.color
+                    }
+                    : message.annotation,
+                seenAt: Date.now()
+            });
+            return;
+        }
+        if (message.type === "cursor") {
+            const xRatio = clamp(Number(message.xRatio), 0, 1);
+            const yRatio = clamp(Number(message.yRatio), 0, 1);
+            broadcast(room, client, {
+                type: "cursor",
+                clientId: client.id,
+                name: client.name,
+                color: client.color,
+                xRatio,
+                yRatio,
+                seenAt: Date.now()
+            });
+        }
+    });
+    socket.on("close", () => {
+        room.delete(client);
+        broadcast(room, client, { type: "leave", clientId: client.id });
+        if (room.size === 0)
+            rooms.delete(roomId);
+    });
+}
+function broadcast(room, sender, payload) {
+    const text = JSON.stringify(payload);
+    for (const client of room) {
+        if (client !== sender && client.socket.readyState === WebSocket.OPEN) {
+            client.socket.send(text);
+        }
+    }
+}
+function parseCursorMessage(data) {
+    try {
+        const message = JSON.parse(data.toString());
+        if (!["cursor", "leave", "annotation", "clear"].includes(message.type))
+            return null;
+        return message;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeColor(value) {
+    return /^#[0-9a-f]{6}$/i.test(value) ? value : "#d6ff59";
+}
+function clamp(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.max(min, Math.min(max, value));
+}

package/server/dist/registry.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+const dataDir = path.resolve(process.env.DATA_DIR ?? "data");
+const registryPath = path.join(dataDir, "devices.json");
+export function getPublication(serial) {
+    return readRegistry().publications[serial];
+}
+export function getPublications() {
+    return readRegistry().publications;
+}
+export function publishDevice(serial, input) {
+    const registry = readRegistry();
+    const current = registry.publications[serial];
+    const label = clean(input.label) || current?.label || serial;
+    const publication = {
+        serial,
+        label,
+        owner: clean(input.owner) || undefined,
+        note: clean(input.note) || undefined,
+        published: true,
+        updatedAt: new Date().toISOString()
+    };
+    registry.publications[serial] = publication;
+    writeRegistry(registry);
+    return publication;
+}
+export function unpublishDevice(serial) {
+    const registry = readRegistry();
+    const current = registry.publications[serial];
+    if (!current)
+        return undefined;
+    const publication = {
+        ...current,
+        published: false,
+        updatedAt: new Date().toISOString()
+    };
+    registry.publications[serial] = publication;
+    writeRegistry(registry);
+    return publication;
+}
+function readRegistry() {
+    try {
+        const text = fs.readFileSync(registryPath, "utf8");
+        const parsed = JSON.parse(text);
+        return {
+            publications: parsed.publications ?? {}
+        };
+    }
+    catch {
+        return { publications: {} };
+    }
+}
+function writeRegistry(registry) {
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`);
+}
+function clean(value) {
+    if (typeof value !== "string")
+        return "";
+    return value.trim().slice(0, 120);
+}

package/server/dist/screenshots.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+const dataDir = path.resolve(process.env.DATA_DIR ?? "data");
+const screenshotsDir = path.join(dataDir, "screenshots");
+const screenshotsIndexPath = path.join(screenshotsDir, "index.json");
+export function installScreenshotRoutes(app) {
+    app.get("/api/screenshots/:fileName", (req, res) => {
+        const safeName = path.basename(req.params.fileName);
+        const filePath = path.join(screenshotsDir, safeName);
+        if (!safeName.endsWith(".png") || !fs.existsSync(filePath)) {
+            res.status(404).json({ error: "Screenshot not found" });
+            return;
+        }
+        if (req.query.download === "1") {
+            res.download(filePath, safeName);
+            return;
+        }
+        res.setHeader("Content-Type", "image/png");
+        res.setHeader("Cache-Control", "private, max-age=86400");
+        fs.createReadStream(filePath).pipe(res);
+    });
+}
+export function listDeviceScreenshots(deviceSerial) {
+    return readIndex().screenshots.filter((screenshot) => screenshot.deviceSerial === deviceSerial).slice(0, 24);
+}
+export async function saveScreenshot(image, deviceSerial) {
+    await fs.promises.mkdir(screenshotsDir, { recursive: true });
+    const createdAt = new Date().toISOString();
+    const safeLabel = deviceSerial.replace(/[^a-zA-Z0-9_.-]/g, "-").slice(0, 48) || "device";
+    const id = randomUUID();
+    const fileName = `${createdAt.replace(/[:.]/g, "-")}-${safeLabel}-${id.slice(0, 8)}.png`;
+    const filePath = path.join(screenshotsDir, fileName);
+    await fs.promises.writeFile(filePath, image);
+    const screenshot = {
+        id,
+        deviceSerial,
+        fileName,
+        url: `/api/screenshots/${encodeURIComponent(fileName)}`,
+        downloadUrl: `/api/screenshots/${encodeURIComponent(fileName)}?download=1`,
+        createdAt,
+        sizeBytes: image.length
+    };
+    const index = readIndex();
+    index.screenshots = [screenshot, ...index.screenshots.filter((item) => item.id !== id)].slice(0, 500);
+    await fs.promises.writeFile(screenshotsIndexPath, `${JSON.stringify(index, null, 2)}\n`);
+    return screenshot;
+}
+function readIndex() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(screenshotsIndexPath, "utf8"));
+        return {
+            screenshots: Array.isArray(parsed.screenshots) ? parsed.screenshots : []
+        };
+    }
+    catch {
+        return { screenshots: [] };
+    }
+}

package/server/dist/sessions.js

@@ -0,0 +1,229 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { WebSocket } from "ws";
+import { adbCommand } from "./adb.js";
+const sessions = new Map();
+const sessionsBySerial = new Map();
+const STREAM_SIZE = process.env.STREAM_SIZE;
+const STREAM_BITRATE = process.env.STREAM_BITRATE ?? "8000000";
+const STREAM_TIME_LIMIT_SECONDS = process.env.STREAM_TIME_LIMIT_SECONDS ?? "180";
+export function getOrCreateSession(serial, options) {
+    const existingId = sessionsBySerial.get(serial);
+    if (existingId) {
+        const existing = sessions.get(existingId);
+        if (existing && !options?.restart)
+            return toPublicSession(existing);
+        if (existing)
+            cleanupSession(existing);
+    }
+    const session = {
+        id: randomUUID(),
+        serial,
+        clients: new Set(),
+        h264Config: [],
+        h264Replay: []
+    };
+    sessions.set(session.id, session);
+    sessionsBySerial.set(serial, session.id);
+    startStream(session);
+    return toPublicSession(session);
+}
+export function getSession(id) {
+    return sessions.get(id);
+}
+export function deleteSession(id) {
+    const session = sessions.get(id);
+    if (!session)
+        return false;
+    cleanupSession(session);
+    return true;
+}
+export function attachClient(id, socket) {
+    const session = sessions.get(id);
+    if (!session) {
+        socket.close(1008, "session not found");
+        return;
+    }
+    session.clients.add(socket);
+    if (session.stopTimer) {
+        clearTimeout(session.stopTimer);
+        session.stopTimer = undefined;
+    }
+    if (!session.process) {
+        startStream(session);
+    }
+    sendReplay(session, socket);
+    socket.on("close", () => {
+        session.clients.delete(socket);
+        scheduleStopIfIdle(session);
+    });
+}
+export function listSessions() {
+    return [...sessions.values()].map(toPublicSession);
+}
+function startStream(session) {
+    if (session.process || session.restartTimer)
+        return;
+    const args = [
+        "-s",
+        session.serial,
+        "exec-out",
+        "screenrecord",
+        "--output-format=h264",
+        "--bit-rate",
+        STREAM_BITRATE,
+        "--time-limit",
+        STREAM_TIME_LIMIT_SECONDS,
+        "-"
+    ];
+    if (STREAM_SIZE) {
+        args.splice(6, 0, "--size", STREAM_SIZE);
+    }
+    const adb = adbCommand(args);
+    const child = spawn(adb.command, adb.args, {
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    session.process = child;
+    session.startedAt = Date.now();
+    session.lastError = undefined;
+    child.stdout.on("data", (chunk) => {
+        recordReplay(session, chunk);
+        for (const client of session.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(chunk, { binary: true });
+            }
+        }
+    });
+    child.stderr.on("data", (chunk) => {
+        const text = chunk.toString("utf8").trim();
+        if (text)
+            session.lastError = text.slice(-800);
+    });
+    child.on("error", (error) => {
+        session.lastError = error.message;
+    });
+    child.on("close", () => {
+        session.process = undefined;
+        if (session.clients.size > 0) {
+            session.restartTimer = setTimeout(() => {
+                session.restartTimer = undefined;
+                startStream(session);
+            }, 600);
+        }
+        else {
+            scheduleStopIfIdle(session);
+        }
+    });
+}
+function scheduleStopIfIdle(session) {
+    if (session.clients.size > 0 || session.stopTimer)
+        return;
+    session.stopTimer = setTimeout(() => {
+        if (session.clients.size === 0)
+            cleanupSession(session);
+    }, 5000);
+}
+function cleanupSession(session) {
+    if (session.restartTimer)
+        clearTimeout(session.restartTimer);
+    if (session.stopTimer)
+        clearTimeout(session.stopTimer);
+    if (session.process && !session.process.killed) {
+        session.process.kill("SIGTERM");
+    }
+    for (const client of session.clients) {
+        client.close(1001, "session ended");
+    }
+    sessions.delete(session.id);
+    sessionsBySerial.delete(session.serial);
+}
+function sendReplay(session, socket) {
+    for (const chunk of session.h264Replay) {
+        if (socket.readyState === WebSocket.OPEN) {
+            socket.send(chunk, { binary: true });
+        }
+    }
+}
+function recordReplay(session, chunk) {
+    const data = session.h264Pending ? Buffer.concat([session.h264Pending, chunk]) : chunk;
+    const starts = findStartCodes(data);
+    if (starts.length < 2) {
+        session.h264Pending = starts.length === 1 ? data.subarray(starts[0]) : data.subarray(Math.max(0, data.length - 4));
+        return;
+    }
+    for (let index = 0; index < starts.length - 1; index += 1) {
+        const start = starts[index];
+        const nextStart = starts[index + 1];
+        if (nextStart <= start)
+            continue;
+        recordNalUnit(session, data.subarray(start, nextStart));
+    }
+    session.h264Pending = data.subarray(starts[starts.length - 1]);
+}
+function recordNalUnit(session, nal) {
+    const nalType = getNalType(nal);
+    if (!nalType)
+        return;
+    if (nalType === 7 || nalType === 8) {
+        const existingIndex = session.h264Config.findIndex((item) => getNalType(item) === nalType);
+        if (existingIndex >= 0) {
+            session.h264Config[existingIndex] = Buffer.from(nal);
+        }
+        else {
+            session.h264Config.push(Buffer.from(nal));
+        }
+    }
+    if (nalType === 5) {
+        session.h264Replay = [...session.h264Config.map((item) => Buffer.from(item)), Buffer.from(nal)];
+        return;
+    }
+    if (session.h264Replay.length > 0) {
+        session.h264Replay.push(Buffer.from(nal));
+        trimReplay(session);
+    }
+}
+function trimReplay(session) {
+    const maxBytes = 4 * 1024 * 1024;
+    let total = session.h264Replay.reduce((sum, item) => sum + item.length, 0);
+    while (session.h264Replay.length > session.h264Config.length + 1 && total > maxBytes) {
+        const removed = session.h264Replay.splice(session.h264Config.length, 1)[0];
+        total -= removed.length;
+    }
+}
+function getNalType(nal) {
+    const startCodeLength = nal[2] === 1 ? 3 : nal[3] === 1 ? 4 : 0;
+    if (!startCodeLength || nal.length <= startCodeLength)
+        return undefined;
+    return nal[startCodeLength] & 0x1f;
+}
+function findStartCodes(data) {
+    const starts = [];
+    for (let index = 0; index < data.length - 3; index += 1) {
+        if (data[index] !== 0 || data[index + 1] !== 0)
+            continue;
+        if (data[index + 2] === 1) {
+            starts.push(index);
+            index += 2;
+        }
+        else if (data[index + 2] === 0 && data[index + 3] === 1) {
+            starts.push(index);
+            index += 3;
+        }
+    }
+    return starts;
+}
+function toPublicSession(session) {
+    return {
+        id: session.id,
+        serial: session.serial,
+        viewerCount: session.clients.size,
+        startedAt: session.startedAt,
+        lastError: session.lastError,
+        stream: {
+            codec: "h264",
+            container: "annexb",
+            size: STREAM_SIZE ?? "native",
+            bitrate: STREAM_BITRATE
+        }
+    };
+}