@arenahito/droid-webscr 0.1.0 → 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # droid-webscr
 
-droid-webscr is a local Android screen streaming and control tool. It runs a small
-Node.js agent on your machine, pushes a temporary Android-side server through ADB,
-and opens a browser UI for viewing and controlling an authorized Android device.
+droid-webscr is a local Android screen streaming and control tool. It runs a local
+Node.js server on your machine, pushes a temporary Android-side server through ADB,
+and serves a browser UI for viewing and controlling an authorized Android device.
 
 The project is under active development. Expect CLI and protocol details to keep
 moving until the first stable release.
@@ -44,21 +44,21 @@ droid-webscr
 
 ## Usage
 
-Start the local agent:
+Start the local server and web UI:
 
 ```sh
 droid-webscr
 ```
 
-By default the agent listens on:
+By default the integrated server listens on:
 
 ```text
 http://127.0.0.1:7391
 ```
 
-Open the web UI, select an authorized device, and start a session. The session
+Open the printed URL, select an authorized device, and start a session. The session
 streams the Android display into the browser and sends control frames back to the
-device through the local agent.
+device through the local server.
 
 The UI supports:
 

package/dist/bin.d.ts

@@ -1,19 +1,7 @@
 #!/usr/bin/env node
-import { AgentRuntime } from './main.js';
-import '@droid-webscr/adb';
-import '@droid-webscr/config';
+declare function startPackagedRuntime(): Promise<{
+    close: () => Promise<void>;
+    readonly url: string;
+}>;
 
-interface CliIo {
-    stderr(value: string): void;
-    stdout(value: string): void;
-}
-interface CliRuntime {
-    readonly packageVersion?: string | undefined;
-    readonly startAgent?: (() => Promise<AgentRuntime>) | undefined;
-    readonly stderr?: ((value: string) => void) | undefined;
-    readonly stdout?: ((value: string) => void) | undefined;
-}
-declare function runCli(argv: readonly string[], runtime?: CliRuntime): Promise<number>;
-declare function createCliHelp(): string;
-
-export { type CliIo, type CliRuntime, createCliHelp, runCli };
+export { startPackagedRuntime };

package/dist/bin.js

@@ -5,56 +5,64 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// package.json
-var package_default = {
-  name: "@arenahito/droid-webscr",
-  version: "0.1.0",
-  private: false,
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/arenahito/droid-webscr.git",
-    directory: "apps/agent"
-  },
-  bin: {
-    "droid-webscr": "dist/bin.js"
-  },
-  files: [
-    "dist",
-    "android",
-    "README.md",
-    "LICENSE"
-  ],
-  type: "module",
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      default: "./dist/index.js"
+// src/bin.ts
+import { dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../agent/src/device-server/artifact.ts
+import { access } from "fs/promises";
+import { constants } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var deviceServerArtifactFileName = "droid-webscr-server-android.jar";
+var deviceServerArtifactRemotePath = "/data/local/tmp/droid-webscr-server.jar";
+var defaultDeviceServerArtifact = {
+  localPath: `android/server/build/${deviceServerArtifactFileName}`,
+  remotePath: deviceServerArtifactRemotePath
+};
+async function resolveDeviceServerArtifact(moduleUrl = import.meta.url, startDirectory = dirname(fileURLToPath(moduleUrl))) {
+  const candidates = ancestorDirectories(startDirectory).flatMap((directory) => [
+    join(directory, "android", deviceServerArtifactFileName),
+    join(directory, "android", "server", "build", deviceServerArtifactFileName)
+  ]);
+  const checks = await Promise.all(
+    candidates.map(async (candidate) => ({
+      candidate,
+      exists: await isReadableFile(candidate)
+    }))
+  );
+  for (const check2 of checks) {
+    if (check2.exists) {
+      return {
+        localPath: check2.candidate,
+        remotePath: deviceServerArtifactRemotePath
+      };
     }
-  },
-  publishConfig: {
-    access: "public"
-  },
-  scripts: {
-    build: "tsup && node ../../tools/package-agent.mjs",
-    dev: "tsc -p tsconfig.build.json --watch",
-    lint: "oxlint --config ../../oxlint.json src",
-    test: "vitest run",
-    "type-check": "tsc -p tsconfig.json --noEmit"
-  },
-  dependencies: {
-    "@fastify/websocket": "11.2.0",
-    fastify: "5.8.5",
-    pino: "10.3.1"
-  },
-  devDependencies: {
-    "@droid-webscr/adb": "workspace:*",
-    "@droid-webscr/config": "workspace:*",
-    "@droid-webscr/protocol": "workspace:*",
-    "@droid-webscr/transport": "workspace:*",
-    "@types/ws": "8.18.1"
   }
-};
+  throw new Error(
+    `Android server artifact was not found. Run pnpm android:build before starting droid-webscr.`
+  );
+}
+function ancestorDirectories(startDirectory) {
+  const directories = [];
+  let current = startDirectory;
+  while (true) {
+    directories.push(current);
+    const parent = dirname(current);
+    if (parent === current) {
+      return directories;
+    }
+    current = parent;
+  }
+}
+async function isReadableFile(path) {
+  try {
+    await access(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // ../../packages/adb/src/provider.ts
 import { Readable } from "stream";
@@ -14976,70 +14984,15 @@ function isLocalBind(host) {
   return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
 
-// src/runtime.ts
+// ../agent/src/runtime.ts
 import { pathToFileURL } from "url";
 
-// src/device-server/artifact.ts
-import { access } from "fs/promises";
-import { constants } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-var deviceServerArtifactFileName = "droid-webscr-server-android.jar";
-var deviceServerArtifactRemotePath = "/data/local/tmp/droid-webscr-server.jar";
-var defaultDeviceServerArtifact = {
-  localPath: `android/server/build/${deviceServerArtifactFileName}`,
-  remotePath: deviceServerArtifactRemotePath
-};
-async function resolveDeviceServerArtifact(moduleUrl = import.meta.url, startDirectory = dirname(fileURLToPath(moduleUrl))) {
-  const candidates = ancestorDirectories(startDirectory).flatMap((directory) => [
-    join(directory, "android", deviceServerArtifactFileName),
-    join(directory, "android", "server", "build", deviceServerArtifactFileName)
-  ]);
-  const checks = await Promise.all(
-    candidates.map(async (candidate) => ({
-      candidate,
-      exists: await isReadableFile(candidate)
-    }))
-  );
-  for (const check2 of checks) {
-    if (check2.exists) {
-      return {
-        localPath: check2.candidate,
-        remotePath: deviceServerArtifactRemotePath
-      };
-    }
-  }
-  throw new Error(
-    `Android server artifact was not found. Run pnpm android:build before starting droid-webscr.`
-  );
-}
-function ancestorDirectories(startDirectory) {
-  const directories = [];
-  let current = startDirectory;
-  while (true) {
-    directories.push(current);
-    const parent = dirname(current);
-    if (parent === current) {
-      return directories;
-    }
-    current = parent;
-  }
-}
-async function isReadableFile(path) {
-  try {
-    await access(path, constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/device-server/deploy.ts
+// ../agent/src/device-server/deploy.ts
 async function deployDeviceServer(session, artifact) {
   await session.push(artifact.localPath, artifact.remotePath);
 }
 
-// src/device-server/start.ts
+// ../agent/src/device-server/start.ts
 var AdbDeviceServer = class {
   constructor(adbProvider, artifact = defaultDeviceServerArtifact) {
     this.adbProvider = adbProvider;
@@ -15197,8 +15150,9 @@ async function collectTextUntil(chunks, expected) {
   return output + decoder.decode();
 }
 
-// src/server/create-fastify-app.ts
+// ../agent/src/server/create-fastify-app.ts
 import websocket from "@fastify/websocket";
+import middie from "@fastify/middie";
 
 // ../../packages/protocol/src/streams.ts
 var StreamId = /* @__PURE__ */ ((StreamId2) => {
@@ -15404,10 +15358,13 @@ function readPayloadLength(bytes) {
 // ../../packages/transport/src/backpressure.ts
 var VIDEO_KEYFRAME_FLAG = 1 << 0;
 
-// src/server/create-fastify-app.ts
+// ../agent/src/server/create-fastify-app.ts
 import Fastify from "fastify";
+import { constants as constants2 } from "fs";
+import { access as access2, readFile } from "fs/promises";
+import { extname, join as join2, normalize, relative, sep } from "path";
 
-// src/security/origin.ts
+// ../agent/src/security/origin.ts
 function isAllowedOrigin(origin, config2, requestHost) {
   if (!origin) {
     return true;
@@ -15417,9 +15374,6 @@ function isAllowedOrigin(origin, config2, requestHost) {
     if (url2.protocol !== "http:") {
       return false;
     }
-    if (requestHost !== void 0 && isLocalDevUiOrigin(url2) && isAllowedHost(requestHost, config2)) {
-      return true;
-    }
     if (!isAllowedHost(url2.host, config2)) {
       return false;
     }
@@ -15462,9 +15416,6 @@ function isLocalHost(host) {
   const normalized = normalizeHost(host);
   return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1";
 }
-function isLocalDevUiOrigin(url2) {
-  return url2.port === "5173" && isLocalHost(url2.host);
-}
 function samePort(url2, host) {
   return (url2.port || defaultPort(url2.protocol)) === (extractPort(host) || defaultPort(url2.protocol));
 }
@@ -15483,7 +15434,7 @@ function extractPort(host) {
   return parts.length === 2 ? parts[1] ?? "" : "";
 }
 
-// src/security/session-token.ts
+// ../agent/src/security/session-token.ts
 import { randomBytes } from "crypto";
 function createSessionToken(sessionId, deviceSerial, nowMs, ttlMs, video) {
   return {
@@ -15495,7 +15446,7 @@ function createSessionToken(sessionId, deviceSerial, nowMs, ttlMs, video) {
   };
 }
 
-// src/session/session-manager.ts
+// ../agent/src/session/session-manager.ts
 var SessionManager = class {
   constructor(adbProvider, now = () => Date.now(), ttlMs = 6e4) {
     this.adbProvider = adbProvider;
@@ -15581,7 +15532,7 @@ var SessionManager = class {
   }
 };
 
-// src/security/auth.ts
+// ../agent/src/security/auth.ts
 function validateAgentAuthHeader(authorization, config2) {
   if (!config2.authToken) {
     return true;
@@ -15590,7 +15541,7 @@ function validateAgentAuthHeader(authorization, config2) {
   return values.some((value) => value === `Bearer ${config2.authToken}`);
 }
 
-// src/server/routes.ts
+// ../agent/src/server/routes.ts
 var noopUpdateRuntimeConfig = () => {
   return;
 };
@@ -15918,10 +15869,10 @@ function createShareUrl(bindHost, port) {
   return `http://${host}:${port}`;
 }
 
-// src/server/websocket.ts
+// ../agent/src/server/websocket.ts
 var binaryWebSocketProtocol = "droid-webscr.v1";
 
-// src/server/create-fastify-app.ts
+// ../agent/src/server/create-fastify-app.ts
 function createLoggerOptions(enabled) {
   return enabled === false ? false : {
     level: "info",
@@ -15936,6 +15887,12 @@ async function createFastifyApp(context) {
   const app = Fastify({
     logger: createLoggerOptions(context.logger)
   });
+  if (context.webUi?.devMiddleware) {
+    await app.register(middie);
+    app.use(
+      context.webUi.devMiddleware
+    );
+  }
   await app.register(websocket, {
     options: {
       handleProtocols: selectBinaryWebSocketProtocol
@@ -15978,6 +15935,7 @@ async function createFastifyApp(context) {
   app.closeActiveDeviceSessions = closeActiveSessions;
   app.addHook("preClose", async () => {
     await closeActiveSessions({ waitForStartup: true });
+    await context.webUi?.close?.();
   });
   app.addHook("onRequest", async (request, reply) => {
     const origin = request.headers.origin;
@@ -16125,6 +16083,7 @@ async function createFastifyApp(context) {
       });
     }
   );
+  registerWebUiRoutes(app, context.webUi);
   return app;
 }
 function selectBinaryWebSocketProtocol(protocols) {
@@ -16140,8 +16099,85 @@ function ignoreAsyncError2() {
 function closeBrowserSocket(socket, code, reason) {
   socket.close?.(code, reason);
 }
+function registerWebUiRoutes(app, webUi) {
+  if (!webUi) {
+    return;
+  }
+  app.get("/*", async (request, reply) => {
+    const path = request.url.split("?")[0] ?? "/";
+    if (path.startsWith("/api/") || path === "/api" || path.startsWith("/ws/") || path === "/ws") {
+      return reply.code(404).send({ error: "Not found" });
+    }
+    const file2 = await readWebUiFile(webUi, path);
+    if (file2) {
+      return reply.type(file2.contentType).send(file2.content);
+    }
+    if (webUi.renderIndex) {
+      return reply.type("text/html; charset=utf-8").send(await webUi.renderIndex(request.url));
+    }
+    const index = await readWebUiFile(webUi, "/");
+    if (index) {
+      return reply.type(index.contentType).send(index.content);
+    }
+    return reply.code(404).send({ error: "Not found" });
+  });
+}
+async function readWebUiFile(webUi, path) {
+  const staticFile = webUi.staticFiles?.[path] ?? (path === "/" ? webUi.staticFiles?.["/"] : void 0);
+  if (staticFile) {
+    return staticFile;
+  }
+  if (!webUi.staticRoot) {
+    return void 0;
+  }
+  const filePath = resolveStaticFilePath(webUi.staticRoot, path);
+  if (!filePath || !await isReadableFile2(filePath)) {
+    return void 0;
+  }
+  return {
+    content: await readFile(filePath),
+    contentType: contentTypeForPath(filePath)
+  };
+}
+function resolveStaticFilePath(root, path) {
+  const normalizedPath = path === "/" ? "/index.html" : path;
+  const decodedPath = decodeURIComponent(normalizedPath);
+  const relativePath = decodedPath.replace(/^\/+/, "");
+  const resolvedPath = normalize(join2(root, relativePath));
+  const relativeToRoot = relative(root, resolvedPath);
+  if (relativeToRoot.startsWith("..") || relativeToRoot.includes(`..${sep}`)) {
+    return void 0;
+  }
+  return resolvedPath;
+}
+async function isReadableFile2(path) {
+  try {
+    await access2(path, constants2.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function contentTypeForPath(path) {
+  switch (extname(path)) {
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".js":
+      return "text/javascript; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".wasm":
+      return "application/wasm";
+    default:
+      return "application/octet-stream";
+  }
+}
 
-// src/runtime.ts
+// ../agent/src/runtime.ts
 async function startAgent(options = {}) {
   const adbProvider = options.adbProvider ?? new SystemAdbProvider();
   let runtimeConfig = options.config ?? defaultAgentConfig;
@@ -16157,7 +16193,8 @@ async function startAgent(options = {}) {
     rebindRuntime,
     updateRuntimeConfig: (nextConfig) => {
       runtimeConfig = nextConfig;
-    }
+    },
+    webUi: options.webUi
   });
   const applyRuntimeRebind = async (bindHost, port) => {
     const previousApp = currentApp;
@@ -16202,9 +16239,17 @@ async function startAgent(options = {}) {
       await currentApp?.close();
       await Promise.all(closingPorts.values());
       currentApp = void 0;
+    },
+    get url() {
+      return createRuntimeUrl(runtimeConfig.bindHost, runtimeConfig.port);
     }
   };
 }
+function createRuntimeUrl(bindHost, port) {
+  const host = bindHost === "0.0.0.0" || bindHost === "::" ? "127.0.0.1" : bindHost;
+  const formattedHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${formattedHost}:${port}`;
+}
 function isDirectRun(moduleUrl, argv) {
   const entrypoint = argv[1];
   return entrypoint !== void 0 && pathToFileURL(entrypoint).href === moduleUrl;
@@ -16246,41 +16291,89 @@ function ignoreAsyncError3() {
   return void 0;
 }
 
-// src/bin.ts
+// package.json
+var package_default = {
+  name: "@arenahito/droid-webscr",
+  version: "0.2.0",
+  private: false,
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/arenahito/droid-webscr.git",
+    directory: "apps/cli"
+  },
+  bin: {
+    "droid-webscr": "dist/bin.js"
+  },
+  files: [
+    "dist",
+    "web",
+    "android",
+    "README.md",
+    "LICENSE"
+  ],
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup && node ../../tools/package-cli.mjs",
+    "build:dev": "tsup --config tsup.dev.config.ts",
+    lint: "oxlint --config ../../oxlint.json src",
+    test: "vitest run",
+    "type-check": "tsc -p tsconfig.json --noEmit"
+  },
+  dependencies: {
+    "@droid-webscr/agent": "workspace:*",
+    "@fastify/middie": "9.3.2",
+    "@fastify/websocket": "11.2.0",
+    fastify: "5.8.5",
+    pino: "10.3.1"
+  },
+  devDependencies: {
+    vite: "^8.0.16"
+  }
+};
+
+// src/cli.ts
 async function runCli(argv, runtime = {}) {
   const args = argv.slice(2);
   const io = createCliIo(runtime);
-  const packageVersion = runtime.packageVersion ?? package_default.version;
-  const start = runtime.startAgent ?? startAgent;
-  if (args.length === 0) {
-    await start();
-    return 0;
-  }
   if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
     io.stdout(createCliHelp());
     return 0;
   }
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
-    io.stdout(`${packageVersion}
+    io.stdout(`${runtime.packageVersion ?? "0.0.0"}
 `);
     return 0;
   }
-  io.stderr(`Unknown option: ${args.join(" ")}
+  if (args.length > 0) {
+    io.stderr(`Unknown option: ${args.join(" ")}
 
 `);
-  io.stderr(createCliHelp());
-  return 1;
+    io.stderr(createCliHelp());
+    return 1;
+  }
+  const startRuntime = runtime.startRuntime;
+  if (!startRuntime) {
+    throw new Error("No droid-webscr runtime was configured.");
+  }
+  const started = await startRuntime();
+  io.stdout(`droid-webscr is running at ${started.url}
+`);
+  return 0;
 }
 function createCliHelp() {
   return `Usage: droid-webscr [options]
 
-Starts the local droid-webscr agent.
+Starts the integrated droid-webscr local server and web UI.
 
 Options:
   -h, --help       Show this help text
   -v, --version    Show the package version
 
-The agent listens on http://127.0.0.1:7391 by default.
+The web UI and agent API share http://127.0.0.1:7391 by default.
 `;
 }
 function createCliIo(runtime) {
@@ -16289,8 +16382,35 @@ function createCliIo(runtime) {
     stdout: runtime.stdout ?? ((value) => process.stdout.write(value))
   };
 }
+
+// src/package-paths.ts
+import { join as join3 } from "path";
+var packagedAndroidArtifactFileName = "droid-webscr-server-android.jar";
+function resolvePackagedWebRoot(packageRoot2) {
+  return join3(packageRoot2, "web");
+}
+function resolvePackagedAndroidArtifact(packageRoot2) {
+  return {
+    localPath: join3(packageRoot2, "android", packagedAndroidArtifactFileName),
+    remotePath: deviceServerArtifactRemotePath
+  };
+}
+
+// src/bin.ts
+var packageRoot = dirname2(dirname2(fileURLToPath2(import.meta.url)));
+async function startPackagedRuntime() {
+  return startAgent({
+    deviceServerArtifact: resolvePackagedAndroidArtifact(packageRoot),
+    webUi: {
+      staticRoot: resolvePackagedWebRoot(packageRoot)
+    }
+  });
+}
 if (isDirectRun(import.meta.url, process.argv)) {
-  runCli(process.argv).then(
+  runCli(process.argv, {
+    packageVersion: package_default.version,
+    startRuntime: startPackagedRuntime
+  }).then(
     (exitCode) => {
       process.exitCode = exitCode;
     },
@@ -16301,7 +16421,6 @@ if (isDirectRun(import.meta.url, process.argv)) {
   );
 }
 export {
-  createCliHelp,
-  runCli
+  startPackagedRuntime
 };
 //# sourceMappingURL=bin.js.map