@arenahito/droid-webscr 0.0.0 → 0.2.0

package/dist/bin.js

@@ -5,80 +5,80 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// package.json
-var package_default = {
-  name: "@arenahito/droid-webscr",
-  version: "0.0.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: {
-    "@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/dist/provider.js
+// ../../packages/adb/src/provider.ts
 import { Readable } from "stream";
-var AdbAuthorizationState;
-(function(AdbAuthorizationState2) {
-  AdbAuthorizationState2["Authorized"] = "authorized";
-  AdbAuthorizationState2["Offline"] = "offline";
-  AdbAuthorizationState2["Unauthorized"] = "unauthorized";
-})(AdbAuthorizationState || (AdbAuthorizationState = {}));
-var AdbTransportKind;
-(function(AdbTransportKind2) {
-  AdbTransportKind2["Emulator"] = "emulator";
-  AdbTransportKind2["Network"] = "network";
-  AdbTransportKind2["Usb"] = "usb";
-})(AdbTransportKind || (AdbTransportKind = {}));
 function isUsableDevice(device) {
-  return device.authorizationState === AdbAuthorizationState.Authorized && device.serial.length > 0;
+  return device.authorizationState === "authorized" /* Authorized */ && device.serial.length > 0;
 }
 
-// ../../packages/adb/dist/system-adb-provider.js
+// ../../packages/adb/src/system-adb-provider.ts
 import { spawn } from "child_process";
 import { createConnection, Server } from "net";
 import { Readable as Readable2 } from "stream";
 var SystemAdbProvider = class _SystemAdbProvider {
-  adbPath;
   constructor(adbPath = "adb") {
     this.adbPath = adbPath;
   }
+  adbPath;
   /* v8 ignore next 4 -- external adb process boundary; deterministic parsing is unit-tested */
   async listDevices() {
     const output = await runAndCollect(this.adbPath, ["devices", "-l"]);
@@ -117,16 +117,16 @@ var SystemAdbProvider = class _SystemAdbProvider {
   }
 };
 var SystemAdbDeviceSession = class {
+  constructor(adbPath, serial) {
+    this.adbPath = adbPath;
+    this.serial = serial;
+  }
   adbPath;
   serial;
   forwards = /* @__PURE__ */ new Set();
   sockets = /* @__PURE__ */ new Set();
   shellChildren = /* @__PURE__ */ new Set();
   shellCloses = /* @__PURE__ */ new Map();
-  constructor(adbPath, serial) {
-    this.adbPath = adbPath;
-    this.serial = serial;
-  }
   async push(localPath, remotePath) {
     await runAndCollect(this.adbPath, ["-s", this.serial, "push", localPath, remotePath]);
   }
@@ -172,10 +172,16 @@ var SystemAdbDeviceSession = class {
     this.forwards.add(forward.local);
     try {
       const socket = await connectLocalPortWithRetry(localPort);
-      const forwardedSocket = new ForwardedAdbSocket(this.adbPath, this.serial, forward.local, socket, () => {
-        this.forwards.delete(forward.local);
-        this.sockets.delete(forwardedSocket);
-      });
+      const forwardedSocket = new ForwardedAdbSocket(
+        this.adbPath,
+        this.serial,
+        forward.local,
+        socket,
+        () => {
+          this.forwards.delete(forward.local);
+          this.sockets.delete(forwardedSocket);
+        }
+      );
       this.sockets.add(forwardedSocket);
       return forwardedSocket;
     } catch (error51) {
@@ -191,7 +197,9 @@ var SystemAdbDeviceSession = class {
     await Promise.allSettled([
       ...this.shellCloses.values(),
       ...[...this.sockets].map((socket) => socket.close()),
-      ...[...this.forwards].map((forward) => runAndCollect(this.adbPath, ["-s", this.serial, "forward", "--remove", forward]))
+      ...[...this.forwards].map(
+        (forward) => runAndCollect(this.adbPath, ["-s", this.serial, "forward", "--remove", forward])
+      )
     ]);
     this.forwards.clear();
   }
@@ -220,24 +228,24 @@ function parseDeviceLine(line) {
 }
 function parseAuthorizationState(state) {
   if (state === "device") {
-    return AdbAuthorizationState.Authorized;
+    return "authorized" /* Authorized */;
   }
   if (state === "unauthorized") {
-    return AdbAuthorizationState.Unauthorized;
+    return "unauthorized" /* Unauthorized */;
   }
-  return AdbAuthorizationState.Offline;
+  return "offline" /* Offline */;
 }
 function inferTransportKind(serial, fields) {
   if (serial.startsWith("emulator-")) {
-    return AdbTransportKind.Emulator;
+    return "emulator" /* Emulator */;
   }
   if (serial.includes(":")) {
-    return AdbTransportKind.Network;
+    return "network" /* Network */;
   }
   if (fields.some((field) => field.startsWith("usb:"))) {
-    return AdbTransportKind.Usb;
+    return "usb" /* Usb */;
   }
-  return AdbTransportKind.Usb;
+  return "usb" /* Usb */;
 }
 function parseField(fields, key) {
   const prefix = `${key}:`;
@@ -260,7 +268,9 @@ async function runAndCollect(command, args) {
   return stdout;
 }
 async function startLogcatTail(command, serial) {
-  const epoch = Number((await runAndCollect(command, ["-s", serial, "shell", "date", "+%s"])).trim());
+  const epoch = Number(
+    (await runAndCollect(command, ["-s", serial, "shell", "date", "+%s"])).trim()
+  );
   if (!Number.isFinite(epoch)) {
     throw new Error("Failed to read device logcat start time.");
   }
@@ -369,12 +379,6 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 var ForwardedAdbSocket = class {
-  adbPath;
-  serial;
-  localForward;
-  socket;
-  onClose;
-  chunks;
   constructor(adbPath, serial, localForward, socket, onClose = () => {
   }) {
     this.adbPath = adbPath;
@@ -384,6 +388,12 @@ var ForwardedAdbSocket = class {
     this.onClose = onClose;
     this.chunks = socket;
   }
+  adbPath;
+  serial;
+  localForward;
+  socket;
+  onClose;
+  chunks;
   async write(chunk) {
     await new Promise((resolve, reject) => {
       this.socket.write(chunk, (error51) => {
@@ -411,7 +421,7 @@ var ForwardedAdbSocket = class {
   }
 };
 
-// ../../packages/shared/dist/index.js
+// ../../packages/shared/src/index.ts
 var AppError = class extends Error {
   code;
   constructor(code, message) {
@@ -14941,7 +14951,7 @@ function date4(params) {
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../packages/config/dist/schema.js
+// ../../packages/config/src/schema.ts
 var defaultAgentConfig = {
   authToken: void 0,
   bindHost: "127.0.0.1",
@@ -14964,7 +14974,9 @@ function validateAgentConfig(input) {
     return err(new ConfigError("CONFIG_INVALID", parsed.error.message));
   }
   if (!isLocalBind(parsed.data.bindHost) && !parsed.data.authToken) {
-    return err(new ConfigError("CONFIG_UNSAFE_BIND", "Non-local bind addresses require authToken."));
+    return err(
+      new ConfigError("CONFIG_UNSAFE_BIND", "Non-local bind addresses require authToken.")
+    );
   }
   return ok(parsed.data);
 }
@@ -14972,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;
@@ -15193,36 +15150,30 @@ 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/dist/streams.js
-var StreamId;
-(function(StreamId2) {
+// ../../packages/protocol/src/streams.ts
+var StreamId = /* @__PURE__ */ ((StreamId2) => {
   StreamId2[StreamId2["Session"] = 1] = "Session";
   StreamId2[StreamId2["Device"] = 2] = "Device";
   StreamId2[StreamId2["Video"] = 3] = "Video";
   StreamId2[StreamId2["Control"] = 4] = "Control";
   StreamId2[StreamId2["Log"] = 5] = "Log";
-})(StreamId || (StreamId = {}));
-var knownStreams = new Set(Object.values(StreamId).filter((value) => typeof value === "number"));
+  return StreamId2;
+})(StreamId || {});
+var knownStreams = new Set(
+  Object.values(StreamId).filter((value) => typeof value === "number")
+);
 
-// ../../packages/protocol/dist/frame.js
+// ../../packages/protocol/src/frame.ts
 var FRAME_MAGIC = 1146573635;
 var FRAME_HEADER_LENGTH = 40;
 var WIRE_VERSION = 1;
 var DEFAULT_MAX_PAYLOAD_LENGTH = 16 * 1024 * 1024;
 
-// ../../packages/protocol/dist/errors.js
-var ProtocolErrorCode;
-(function(ProtocolErrorCode2) {
-  ProtocolErrorCode2["FrameTooShort"] = "FRAME_TOO_SHORT";
-  ProtocolErrorCode2["InvalidMagic"] = "INVALID_MAGIC";
-  ProtocolErrorCode2["UnsupportedVersion"] = "UNSUPPORTED_VERSION";
-  ProtocolErrorCode2["UnsupportedHeaderLength"] = "UNSUPPORTED_HEADER_LENGTH";
-  ProtocolErrorCode2["PayloadLengthMismatch"] = "PAYLOAD_LENGTH_MISMATCH";
-  ProtocolErrorCode2["PayloadTooLarge"] = "PAYLOAD_TOO_LARGE";
-})(ProtocolErrorCode || (ProtocolErrorCode = {}));
+// ../../packages/protocol/src/errors.ts
 var ProtocolError = class extends Error {
   code;
   constructor(code, message) {
@@ -15232,7 +15183,7 @@ var ProtocolError = class extends Error {
   }
 };
 
-// ../../packages/protocol/dist/codec.js
+// ../../packages/protocol/src/codec.ts
 function encodeFrame(frame) {
   const payloadLength = frame.payload.byteLength;
   const output = new Uint8Array(FRAME_HEADER_LENGTH + payloadLength);
@@ -15253,28 +15204,37 @@ function encodeFrame(frame) {
 function decodeFrame(bytes, options = {}) {
   const maxPayloadLength = options.maxPayloadLength ?? DEFAULT_MAX_PAYLOAD_LENGTH;
   if (bytes.byteLength < FRAME_HEADER_LENGTH) {
-    return failure(ProtocolErrorCode.FrameTooShort, "Frame is shorter than the protocol header.");
+    return failure("FRAME_TOO_SHORT" /* FrameTooShort */, "Frame is shorter than the protocol header.");
   }
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const magic = view.getUint32(0, false);
   if (magic !== FRAME_MAGIC) {
-    return failure(ProtocolErrorCode.InvalidMagic, "Frame magic does not match DWSC.");
+    return failure("INVALID_MAGIC" /* InvalidMagic */, "Frame magic does not match DWSC.");
   }
   const version2 = view.getUint16(4, false);
   if (version2 !== WIRE_VERSION) {
-    return failure(ProtocolErrorCode.UnsupportedVersion, `Unsupported wire version: ${version2}.`);
+    return failure("UNSUPPORTED_VERSION" /* UnsupportedVersion */, `Unsupported wire version: ${version2}.`);
   }
   const headerLength = view.getUint16(6, false);
   if (headerLength !== FRAME_HEADER_LENGTH) {
-    return failure(ProtocolErrorCode.UnsupportedHeaderLength, `Unsupported header length: ${headerLength}.`);
+    return failure(
+      "UNSUPPORTED_HEADER_LENGTH" /* UnsupportedHeaderLength */,
+      `Unsupported header length: ${headerLength}.`
+    );
   }
   const payloadLength = view.getUint32(16, false);
   if (payloadLength > maxPayloadLength) {
-    return failure(ProtocolErrorCode.PayloadTooLarge, `Payload length ${payloadLength} exceeds limit ${maxPayloadLength}.`);
+    return failure(
+      "PAYLOAD_TOO_LARGE" /* PayloadTooLarge */,
+      `Payload length ${payloadLength} exceeds limit ${maxPayloadLength}.`
+    );
   }
   const expectedLength = FRAME_HEADER_LENGTH + payloadLength;
   if (bytes.byteLength !== expectedLength) {
-    return failure(ProtocolErrorCode.PayloadLengthMismatch, `Frame length ${bytes.byteLength} does not match declared length ${expectedLength}.`);
+    return failure(
+      "PAYLOAD_LENGTH_MISMATCH" /* PayloadLengthMismatch */,
+      `Frame length ${bytes.byteLength} does not match declared length ${expectedLength}.`
+    );
   }
   return {
     ok: true,
@@ -15302,9 +15262,8 @@ function failure(code, message) {
   };
 }
 
-// ../../packages/protocol/dist/messages.js
-var MessageType;
-(function(MessageType2) {
+// ../../packages/protocol/src/messages.ts
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2[MessageType2["SessionHello"] = 1] = "SessionHello";
   MessageType2[MessageType2["SessionHelloAck"] = 2] = "SessionHelloAck";
   MessageType2[MessageType2["SessionStart"] = 3] = "SessionStart";
@@ -15321,10 +15280,13 @@ var MessageType;
   MessageType2[MessageType2["ControlSystem"] = 772] = "ControlSystem";
   MessageType2[MessageType2["ControlClipboard"] = 773] = "ControlClipboard";
   MessageType2[MessageType2["LogRecord"] = 1025] = "LogRecord";
-})(MessageType || (MessageType = {}));
-var knownMessageTypes = new Set(Object.values(MessageType).filter((value) => typeof value === "number"));
+  return MessageType2;
+})(MessageType || {});
+var knownMessageTypes = new Set(
+  Object.values(MessageType).filter((value) => typeof value === "number")
+);
 
-// ../../packages/transport/dist/stream.js
+// ../../packages/transport/src/stream.ts
 var DEFAULT_MAX_BUFFERED_BYTES = 16 * 1024 * 1024;
 var FrameAssembler = class {
   buffer = new Uint8Array();
@@ -15393,13 +15355,16 @@ function readPayloadLength(bytes) {
   return view.getUint32(16, false);
 }
 
-// ../../packages/transport/dist/backpressure.js
+// ../../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;
@@ -15409,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;
     }
@@ -15454,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));
 }
@@ -15475,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 {
@@ -15487,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;
@@ -15573,7 +15532,7 @@ var SessionManager = class {
   }
 };
 
-// src/security/auth.ts
+// ../agent/src/security/auth.ts
 function validateAgentAuthHeader(authorization, config2) {
   if (!config2.authToken) {
     return true;
@@ -15582,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;
 };
@@ -15910,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",
@@ -15928,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
@@ -15970,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;
@@ -16117,6 +16083,7 @@ async function createFastifyApp(context) {
       });
     }
   );
+  registerWebUiRoutes(app, context.webUi);
   return app;
 }
 function selectBinaryWebSocketProtocol(protocols) {
@@ -16132,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;
@@ -16149,7 +16193,8 @@ async function startAgent(options = {}) {
     rebindRuntime,
     updateRuntimeConfig: (nextConfig) => {
       runtimeConfig = nextConfig;
-    }
+    },
+    webUi: options.webUi
   });
   const applyRuntimeRebind = async (bindHost, port) => {
     const previousApp = currentApp;
@@ -16194,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;
@@ -16238,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) {
@@ -16281,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;
     },
@@ -16293,7 +16421,6 @@ if (isDirectRun(import.meta.url, process.argv)) {
   );
 }
 export {
-  createCliHelp,
-  runCli
+  startPackagedRuntime
 };
 //# sourceMappingURL=bin.js.map