npm - @nickname4th/pura-cli - Versions diffs - 0.1.0 - Mend

@nickname4th/pura-cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/LICENSE +21 -0
package/README.md +224 -0
package/dist/client/assets/index-0nO8CWi5.css +1 -0
package/dist/client/assets/index-BI4BBLE6.js +12 -0
package/dist/client/index.html +13 -0
package/package.json +69 -0
package/server/dist/adb.js +183 -0
package/server/dist/agent.js +179 -0
package/server/dist/cli.js +286 -0
package/server/dist/config.js +17 -0
package/server/dist/device-id.js +13 -0
package/server/dist/hub.js +287 -0
package/server/dist/index.js +67 -0
package/server/dist/network.js +20 -0
package/server/dist/presence.js +92 -0
package/server/dist/registry.js +61 -0
package/server/dist/screenshots.js +59 -0
package/server/dist/sessions.js +229 -0

package/dist/client/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>LAN Android Mirror</title>
+    <script type="module" crossorigin src="/assets/index-BI4BBLE6.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-0nO8CWi5.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,69 @@
+{
+  "name": "@nickname4th/pura-cli",
+  "version": "0.1.0",
+  "description": "LAN Android device mirroring hub and developer CLI for distributed teams.",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/LiuTianjie/pura#readme",
+  "bugs": {
+    "url": "https://github.com/LiuTianjie/pura/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LiuTianjie/pura.git"
+  },
+  "keywords": [
+    "android",
+    "adb",
+    "screen-mirroring",
+    "lan",
+    "device-lab",
+    "cli",
+    "webrtc",
+    "h264"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/client",
+    "server/dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "pura-cli": "server/dist/cli.js"
+  },
+  "scripts": {
+    "dev": "concurrently -k -n server,client -c blue,green \"tsx watch server/src/index.ts\" \"vite --host 0.0.0.0\"",
+    "dev:server": "tsx watch server/src/index.ts",
+    "dev:client": "vite --host 0.0.0.0",
+    "dev:hub": "ROLE=hub tsx watch server/src/index.ts",
+    "dev:agent": "ROLE=agent HUB_URL=http://127.0.0.1:8787 PORT=8788 DATA_DIR=data-agent tsx watch server/src/index.ts",
+    "build": "vite build && tsc -p server/tsconfig.json",
+    "start": "node server/dist/index.js",
+    "hub": "ROLE=hub node server/dist/index.js",
+    "check": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p server/tsconfig.json",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "express": "^5.2.1",
+    "jmuxer": "^2.1.0",
+    "lucide-react": "^0.562.0",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^5.1.1",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
+    "concurrently": "^10.0.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.7"
+  }
+}

package/server/dist/adb.js ADDED Viewed

@@ -0,0 +1,183 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const ADB = process.env.ADB_PATH ?? "adb";
+const INCLUDE_TCP_DEVICES = process.env.INCLUDE_TCP_DEVICES === "true";
+export function adbCommand(args) {
+    return {
+        command: ADB,
+        args
+    };
+}
+export async function listDevices() {
+    const { stdout } = await execFileAsync(ADB, ["devices", "-l"], {
+        timeout: 5000,
+        maxBuffer: 1024 * 1024
+    });
+    const baseDevices = stdout
+        .split("\n")
+        .slice(1)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map(parseDeviceLine)
+        .filter((device) => Boolean(device))
+        .filter((device) => INCLUDE_TCP_DEVICES || device.transport === "usb");
+    return Promise.all(baseDevices.map(enrichDevice));
+}
+export async function tapDevice(serial, xRatio, yRatio) {
+    const size = await getDisplaySize(serial);
+    const x = clamp(Math.round(xRatio * size.width), 0, size.width - 1);
+    const y = clamp(Math.round(yRatio * size.height), 0, size.height - 1);
+    await execFileAsync(ADB, ["-s", serial, "shell", "input", "tap", String(x), String(y)], {
+        timeout: 3000,
+        maxBuffer: 64 * 1024
+    });
+    return { x, y, width: size.width, height: size.height };
+}
+export async function longPressDevice(serial, xRatio, yRatio, durationMs = 650) {
+    const size = await getDisplaySize(serial);
+    const x = clamp(Math.round(xRatio * size.width), 0, size.width - 1);
+    const y = clamp(Math.round(yRatio * size.height), 0, size.height - 1);
+    const duration = clamp(Math.round(durationMs), 350, 2500);
+    await execFileAsync(ADB, ["-s", serial, "shell", "input", "swipe", String(x), String(y), String(x), String(y), String(duration)], {
+        timeout: 4000,
+        maxBuffer: 64 * 1024
+    });
+    return { x, y, width: size.width, height: size.height, duration };
+}
+export async function swipeDevice(serial, input) {
+    const size = await getDisplaySize(serial);
+    const x1 = clamp(Math.round(input.xStartRatio * size.width), 0, size.width - 1);
+    const y1 = clamp(Math.round(input.yStartRatio * size.height), 0, size.height - 1);
+    const x2 = clamp(Math.round(input.xEndRatio * size.width), 0, size.width - 1);
+    const y2 = clamp(Math.round(input.yEndRatio * size.height), 0, size.height - 1);
+    const duration = clamp(Math.round(input.durationMs ?? 320), 80, 2500);
+    await execFileAsync(ADB, ["-s", serial, "shell", "input", "swipe", String(x1), String(y1), String(x2), String(y2), String(duration)], {
+        timeout: 5000,
+        maxBuffer: 64 * 1024
+    });
+    return { from: { x: x1, y: y1 }, to: { x: x2, y: y2 }, width: size.width, height: size.height, duration };
+}
+export async function captureScreenshot(serial) {
+    const { stdout } = await execFileAsync(ADB, ["-s", serial, "exec-out", "screencap", "-p"], {
+        encoding: "buffer",
+        timeout: 5000,
+        maxBuffer: 20 * 1024 * 1024
+    });
+    return stdout;
+}
+export async function controlDevice(serial, action, value) {
+    if (action === "text") {
+        const text = sanitizeInputText(value ?? "");
+        if (!text)
+            throw new Error("Text input is empty");
+        await execFileAsync(ADB, ["-s", serial, "shell", "input", "text", text], {
+            timeout: 5000,
+            maxBuffer: 64 * 1024
+        });
+        return { action, text };
+    }
+    const keyCode = keyEvents[action];
+    if (keyCode) {
+        await execFileAsync(ADB, ["-s", serial, "shell", "input", "keyevent", keyCode], {
+            timeout: 3000,
+            maxBuffer: 64 * 1024
+        });
+        return { action, keyCode };
+    }
+    if (action.startsWith("swipe_")) {
+        const size = await getDisplaySize(serial);
+        const [x1, y1, x2, y2] = swipePoints(action, size);
+        await execFileAsync(ADB, ["-s", serial, "shell", "input", "swipe", String(x1), String(y1), String(x2), String(y2), "280"], {
+            timeout: 4000,
+            maxBuffer: 64 * 1024
+        });
+        return { action, from: { x: x1, y: y1 }, to: { x: x2, y: y2 }, width: size.width, height: size.height };
+    }
+    throw new Error(`Unsupported control action: ${action}`);
+}
+function parseDeviceLine(line) {
+    const [serial, state] = line.split(/\s+/, 2);
+    if (!serial || !state)
+        return null;
+    if (!["device", "unauthorized", "offline"].includes(state))
+        return null;
+    return {
+        serial,
+        state: state,
+        transport: serial.includes(":") ? "tcp" : "usb"
+    };
+}
+async function enrichDevice(device) {
+    if (device.state !== "device")
+        return device;
+    const [manufacturer, model, androidVersion, size] = await Promise.all([
+        getProp(device.serial, "ro.product.manufacturer"),
+        getProp(device.serial, "ro.product.model"),
+        getProp(device.serial, "ro.build.version.release"),
+        getDisplaySize(device.serial).catch(() => undefined)
+    ]);
+    return {
+        ...device,
+        manufacturer: manufacturer || undefined,
+        model: model || undefined,
+        androidVersion: androidVersion || undefined,
+        size
+    };
+}
+async function getProp(serial, prop) {
+    const { stdout } = await execFileAsync(ADB, ["-s", serial, "shell", "getprop", prop], {
+        timeout: 2500,
+        maxBuffer: 64 * 1024
+    });
+    return stdout.trim();
+}
+export async function getDisplaySize(serial) {
+    const { stdout } = await execFileAsync(ADB, ["-s", serial, "shell", "wm", "size"], {
+        timeout: 2500,
+        maxBuffer: 64 * 1024
+    });
+    const overrideMatch = stdout.match(/Override size:\s*(\d+)x(\d+)/i);
+    const physicalMatch = stdout.match(/Physical size:\s*(\d+)x(\d+)/i);
+    const match = overrideMatch ?? physicalMatch;
+    if (!match) {
+        throw new Error(`Unable to parse display size: ${stdout.trim() || "empty output"}`);
+    }
+    return {
+        width: Number(match[1]),
+        height: Number(match[2])
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+const keyEvents = {
+    back: "KEYCODE_BACK",
+    home: "KEYCODE_HOME",
+    recents: "KEYCODE_APP_SWITCH",
+    menu: "KEYCODE_MENU",
+    power: "KEYCODE_POWER",
+    volume_up: "KEYCODE_VOLUME_UP",
+    volume_down: "KEYCODE_VOLUME_DOWN",
+    mute: "KEYCODE_VOLUME_MUTE",
+    enter: "KEYCODE_ENTER",
+    delete: "KEYCODE_DEL"
+};
+function swipePoints(action, size) {
+    const left = Math.round(size.width * 0.22);
+    const right = Math.round(size.width * 0.78);
+    const centerX = Math.round(size.width * 0.5);
+    const top = Math.round(size.height * 0.24);
+    const bottom = Math.round(size.height * 0.78);
+    const centerY = Math.round(size.height * 0.5);
+    if (action === "swipe_up")
+        return [centerX, bottom, centerX, top];
+    if (action === "swipe_down")
+        return [centerX, top, centerX, bottom];
+    if (action === "swipe_left")
+        return [right, centerY, left, centerY];
+    return [left, centerY, right, centerY];
+}
+function sanitizeInputText(value) {
+    return value.trim().replaceAll("%", "%25").replace(/\s/g, "%s").slice(0, 500);
+}

package/server/dist/agent.js ADDED Viewed

@@ -0,0 +1,179 @@
+import { captureScreenshot, controlDevice, listDevices, longPressDevice, swipeDevice, tapDevice } from "./adb.js";
+import { getLanAddress, normalizeHttpUrl } from "./network.js";
+import { getPublications, publishDevice, unpublishDevice } from "./registry.js";
+import { listDeviceScreenshots, saveScreenshot } from "./screenshots.js";
+import { deleteSession, getOrCreateSession, listSessions } from "./sessions.js";
+export function installAgentRoutes(app) {
+    app.get("/api/devices", async (_req, res) => {
+        try {
+            res.json({ devices: await listAgentDevices(), sessions: listSessions() });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to list devices"
+            });
+        }
+    });
+    app.put("/api/devices/:serial/publication", (req, res) => {
+        res.json({
+            publication: publishDevice(req.params.serial, {
+                label: req.body?.label,
+                owner: req.body?.owner,
+                note: req.body?.note
+            })
+        });
+    });
+    app.delete("/api/devices/:serial/publication", (req, res) => {
+        res.json({ publication: unpublishDevice(req.params.serial) });
+    });
+    app.post("/api/devices/:serial/session", (req, res) => {
+        res.json({ session: getOrCreateSession(req.params.serial, { restart: req.body?.restart === true }) });
+    });
+    app.get("/api/devices/:serial/screenshot", async (req, res) => {
+        try {
+            const image = await captureScreenshot(req.params.serial);
+            res.setHeader("Content-Type", "image/png");
+            res.setHeader("Cache-Control", "no-store");
+            res.end(image);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to capture device screenshot"
+            });
+        }
+    });
+    app.post("/api/devices/:serial/screenshots", async (req, res) => {
+        try {
+            const image = await captureScreenshot(req.params.serial);
+            res.json({ screenshot: await saveScreenshot(image, req.params.serial) });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to save device screenshot"
+            });
+        }
+    });
+    app.get("/api/devices/:serial/screenshots", (req, res) => {
+        res.json({ screenshots: listDeviceScreenshots(req.params.serial) });
+    });
+    app.post("/api/devices/:serial/tap", async (req, res) => {
+        const xRatio = Number(req.body?.xRatio);
+        const yRatio = Number(req.body?.yRatio);
+        if (!Number.isFinite(xRatio) || !Number.isFinite(yRatio) || xRatio < 0 || xRatio > 1 || yRatio < 0 || yRatio > 1) {
+            res.status(400).json({ error: "xRatio and yRatio must be numbers between 0 and 1" });
+            return;
+        }
+        try {
+            res.json({ tap: await tapDevice(req.params.serial, xRatio, yRatio) });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to tap device"
+            });
+        }
+    });
+    app.post("/api/devices/:serial/long-press", async (req, res) => {
+        const xRatio = Number(req.body?.xRatio);
+        const yRatio = Number(req.body?.yRatio);
+        const durationMs = Number(req.body?.durationMs ?? 650);
+        if (!Number.isFinite(xRatio) || !Number.isFinite(yRatio) || xRatio < 0 || xRatio > 1 || yRatio < 0 || yRatio > 1) {
+            res.status(400).json({ error: "xRatio and yRatio must be numbers between 0 and 1" });
+            return;
+        }
+        try {
+            res.json({ longPress: await longPressDevice(req.params.serial, xRatio, yRatio, durationMs) });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to long press device"
+            });
+        }
+    });
+    app.post("/api/devices/:serial/swipe", async (req, res) => {
+        const xStartRatio = Number(req.body?.xStartRatio);
+        const yStartRatio = Number(req.body?.yStartRatio);
+        const xEndRatio = Number(req.body?.xEndRatio);
+        const yEndRatio = Number(req.body?.yEndRatio);
+        const durationMs = Number(req.body?.durationMs ?? 320);
+        if (![xStartRatio, yStartRatio, xEndRatio, yEndRatio].every((value) => Number.isFinite(value) && value >= 0 && value <= 1)) {
+            res.status(400).json({ error: "Swipe ratios must be numbers between 0 and 1" });
+            return;
+        }
+        try {
+            res.json({ swipe: await swipeDevice(req.params.serial, { xStartRatio, yStartRatio, xEndRatio, yEndRatio, durationMs }) });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to swipe device"
+            });
+        }
+    });
+    app.post("/api/devices/:serial/control", async (req, res) => {
+        const action = req.body?.action;
+        if (!action || !controlActions.includes(action)) {
+            res.status(400).json({ error: "A supported control action is required" });
+            return;
+        }
+        try {
+            res.json({ control: await controlDevice(req.params.serial, action, req.body?.value) });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Failed to control device"
+            });
+        }
+    });
+    app.delete("/api/sessions/:id", (req, res) => {
+        res.json({ deleted: deleteSession(req.params.id) });
+    });
+}
+const controlActions = [
+    "back",
+    "home",
+    "recents",
+    "menu",
+    "power",
+    "volume_up",
+    "volume_down",
+    "mute",
+    "enter",
+    "delete",
+    "swipe_up",
+    "swipe_down",
+    "swipe_left",
+    "swipe_right",
+    "text"
+];
+export function startAgentHeartbeat(options) {
+    if (!options.hubUrl)
+        return;
+    const hubUrl = normalizeHttpUrl(options.hubUrl);
+    const publicUrl = options.publicUrl ?? `http://${getLanAddress()}:${options.port}`;
+    const tick = async () => {
+        try {
+            const devices = await listAgentDevices();
+            await fetch(`${hubUrl}/api/agents/heartbeat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    agentId: options.agentId,
+                    agentName: options.agentName,
+                    url: publicUrl,
+                    devices
+                })
+            });
+        }
+        catch (error) {
+            console.error(`Hub heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    void tick();
+    setInterval(tick, Number(process.env.HEARTBEAT_MS ?? 3000));
+}
+async function listAgentDevices() {
+    const publications = getPublications();
+    return (await listDevices()).map((device) => ({
+        ...device,
+        publication: publications[device.serial]
+    }));
+}