spotifyplus 0.1.1 → 0.1.3

package/dev.cjs

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// tools/dev-cli.mjs
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+var import_esbuild = require("esbuild");
+var execFile = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var DEFAULT_PORT = 37846;
+var DEFAULT_MODULE_PACKAGE = "com.lenerd.spotifyplus";
+var START_BRIDGE_ACTION = "com.lenerd.spotifyplus.action.START_BRIDGE";
+var HOT_RELOAD_ACTION = "com.lenerd.spotifyplus.action.HOT_RELOAD";
+var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".json"]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".gradle"]);
+function parseArgs(argv) {
+  const options = {
+    scriptDir: process.cwd(),
+    adb: process.env.ADB || "adb",
+    device: "",
+    port: DEFAULT_PORT,
+    modulePackage: DEFAULT_MODULE_PACKAGE,
+    spotifyPackage: "com.spotify.music",
+    debounceMs: 150,
+    help: false
+  };
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const [rawName, inlineValue] = arg.slice(2).split("=", 2);
+    const value = inlineValue ?? argv[++i];
+    if (value == null) throw new Error(`Missing value for --${rawName}`);
+    switch (rawName) {
+      case "adb":
+        options.adb = value;
+        break;
+      case "device":
+        options.device = value;
+        break;
+      case "port":
+        options.port = parseInteger(value, "--port");
+        break;
+      case "module-package":
+        options.modulePackage = value;
+        break;
+      case "spotify-package":
+        options.spotifyPackage = value;
+        break;
+      case "debounce-ms":
+        options.debounceMs = parseInteger(value, "--debounce-ms");
+        break;
+      default:
+        throw new Error(`Unknown option --${rawName}`);
+    }
+  }
+  if (positional.length > 1) throw new Error("Expected at most one script directory");
+  if (positional.length === 1) options.scriptDir = positional[0];
+  options.scriptDir = import_node_path.default.resolve(options.scriptDir);
+  return options;
+}
+function parseInteger(value, name) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${name} must be a positive integer`);
+  return parsed;
+}
+function printHelp() {
+  console.log(`Usage: spotifyplus dev [scriptDir] [options]
+
+Options:
+  --adb <path>              adb executable to use (default: adb)
+  --device <serial>         adb device serial
+  --port <port>             local HTTP/reverse port (default: ${DEFAULT_PORT})
+  --module-package <name>   SpotifyPlus manager app package (default: ${DEFAULT_MODULE_PACKAGE})
+  --spotify-package <name>  Spotify app package, reserved for future checks (default: com.spotify.music)
+  --debounce-ms <ms>        file change debounce (default: 150)
+  --help, -h                show this help
+`);
+}
+async function readManifest(scriptDir) {
+  const manifestPath = import_node_path.default.join(scriptDir, "manifest.json");
+  const text = await import_node_fs.default.promises.readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(text);
+  if (!manifest || typeof manifest !== "object") throw new Error("manifest.json must contain an object");
+  if (typeof manifest.id !== "string" || manifest.id.length === 0) throw new Error("manifest.id must be a non-empty string");
+  if (typeof manifest.main !== "string" || manifest.main.length === 0) throw new Error("manifest.main must be a non-empty string");
+  return manifest;
+}
+async function bundleScript(scriptDir) {
+  const manifest = await readManifest(scriptDir);
+  const entryPath = await resolveEntryPath(scriptDir, manifest);
+  const result = await (0, import_esbuild.build)({
+    entryPoints: [entryPath],
+    bundle: true,
+    write: false,
+    platform: "node",
+    format: "cjs",
+    target: "es2020",
+    jsx: "automatic",
+    external: ["spotifyplus", "spotifyplus/*", "react"],
+    logLevel: "silent"
+  });
+  const source = result.outputFiles?.[0]?.text;
+  if (!source) throw new Error("esbuild did not produce an output bundle");
+  return {
+    buildId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    manifest,
+    source
+  };
+}
+async function resolveEntryPath(scriptDir, manifest) {
+  const manifestEntry = import_node_path.default.resolve(scriptDir, manifest.main);
+  if (import_node_fs.default.existsSync(manifestEntry)) return manifestEntry;
+  const candidates = [
+    "src/index.tsx",
+    "src/index.ts",
+    "src/index.jsx",
+    "src/index.js",
+    "index.tsx",
+    "index.ts",
+    "index.jsx"
+  ];
+  for (const candidate of candidates) {
+    const candidatePath = import_node_path.default.resolve(scriptDir, candidate);
+    if (import_node_fs.default.existsSync(candidatePath)) {
+      console.warn(`[spotifyplus] manifest.main points to missing ${manifest.main}; using ${candidate} as the dev entry`);
+      return candidatePath;
+    }
+  }
+  throw new Error(`Could not resolve ${manifestEntry}. Set manifest.main to a real source file, or add src/index.tsx.`);
+}
+function createReloadServer(state, port) {
+  const server = import_node_http.default.createServer((request, response) => {
+    const url = new URL(request.url ?? "/", `http://127.0.0.1:${port}`);
+    const match = /^\/reload\/([^/]+)\/([^/]+)\.json$/.exec(url.pathname);
+    if (!match) {
+      response.writeHead(404, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: "not found" }));
+      return;
+    }
+    const [, buildId, scriptId] = match;
+    const current = state.currentBuild;
+    if (!current || current.buildId !== buildId || current.manifest.id !== decodeURIComponent(scriptId)) {
+      response.writeHead(404, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: "build not found" }));
+      return;
+    }
+    response.writeHead(200, {
+      "content-type": "application/json; charset=utf-8",
+      "cache-control": "no-store"
+    });
+    response.end(JSON.stringify(current));
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve(server);
+    });
+  });
+}
+async function adb(options, args) {
+  const fullArgs = [];
+  if (options.device) fullArgs.push("-s", options.device);
+  fullArgs.push(...args);
+  try {
+    return await execFile(options.adb, fullArgs, { windowsHide: true });
+  } catch (error) {
+    const stderr = error?.stderr ? String(error.stderr).trim() : "";
+    const stdout = error?.stdout ? String(error.stdout).trim() : "";
+    const details = stderr || stdout || error?.message || "adb command failed";
+    throw new Error(`${options.adb} ${fullArgs.join(" ")} failed: ${details}`);
+  }
+}
+async function notifyDevice(options, buildInfo) {
+  const encodedScriptId = encodeURIComponent(buildInfo.manifest.id);
+  const url = `http://127.0.0.1:${options.port}/reload/${buildInfo.buildId}/${encodedScriptId}.json`;
+  await adb(options, ["reverse", `tcp:${options.port}`, `tcp:${options.port}`]);
+  await adb(options, [
+    "shell",
+    "am",
+    "broadcast",
+    "-a",
+    START_BRIDGE_ACTION,
+    "-n",
+    `${options.modulePackage}/.manager.bridge.BridgeStartReceiver`
+  ]);
+  await adb(options, [
+    "shell",
+    "am",
+    "broadcast",
+    "-a",
+    HOT_RELOAD_ACTION,
+    "-n",
+    `${options.modulePackage}/.manager.bridge.HotReloadReceiver`,
+    "--es",
+    "scriptId",
+    buildInfo.manifest.id,
+    "--es",
+    "buildId",
+    buildInfo.buildId,
+    "--es",
+    "url",
+    url
+  ]);
+  return url;
+}
+function shouldWatchFile(filePath) {
+  return WATCH_EXTENSIONS.has(import_node_path.default.extname(filePath).toLowerCase());
+}
+function shouldIgnoreDirectory(name) {
+  return IGNORED_DIRECTORIES.has(name);
+}
+function watchRecursively(root, onChange) {
+  const watchers = [];
+  const watchDirectory = (directory) => {
+    const watcher = import_node_fs.default.watch(directory, (eventType, fileName) => {
+      const changedPath = fileName ? import_node_path.default.join(directory, fileName.toString()) : directory;
+      if (shouldWatchFile(changedPath)) onChange(eventType, changedPath);
+      import_node_fs.default.promises.stat(changedPath).then((stats) => {
+        if (stats.isDirectory() && !shouldIgnoreDirectory(import_node_path.default.basename(changedPath))) {
+          watchDirectory(changedPath);
+        }
+      }).catch(() => {
+      });
+    });
+    watchers.push(watcher);
+  };
+  const walk = (directory) => {
+    watchDirectory(directory);
+    for (const entry of import_node_fs.default.readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory() || shouldIgnoreDirectory(entry.name)) continue;
+      walk(import_node_path.default.join(directory, entry.name));
+    }
+  };
+  try {
+    const watcher = import_node_fs.default.watch(root, { recursive: true }, (eventType, fileName) => {
+      const changedPath = fileName ? import_node_path.default.join(root, fileName.toString()) : root;
+      if (shouldWatchFile(changedPath)) onChange(eventType, changedPath);
+    });
+    watchers.push(watcher);
+  } catch {
+    walk(root);
+  }
+  return () => {
+    for (const watcher of watchers) watcher.close();
+  };
+}
+async function run() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  const state = { currentBuild: null };
+  const server = await createReloadServer(state, options.port);
+  console.log(`[spotifyplus] dev server listening on http://127.0.0.1:${options.port}`);
+  console.log(`[spotifyplus] watching ${options.scriptDir}`);
+  let buildInFlight = false;
+  let pendingBuild = false;
+  const rebuild = async (reason) => {
+    if (buildInFlight) {
+      pendingBuild = true;
+      return;
+    }
+    buildInFlight = true;
+    try {
+      const buildInfo = await bundleScript(options.scriptDir);
+      state.currentBuild = buildInfo;
+      const url = await notifyDevice(options, buildInfo);
+      console.log(`[spotifyplus] reloaded ${buildInfo.manifest.id} (${buildInfo.buildId})`);
+      console.log(`[spotifyplus] served ${url}`);
+    } catch (error) {
+      console.error(`[spotifyplus] ${reason} failed`);
+      console.error(error?.message ?? error);
+      if (Array.isArray(error?.errors)) {
+        for (const item of error.errors) console.error(item.text ?? item);
+      }
+    } finally {
+      buildInFlight = false;
+      if (pendingBuild) {
+        pendingBuild = false;
+        await rebuild("queued rebuild");
+      }
+    }
+  };
+  let debounceHandle = null;
+  const scheduleRebuild = (_eventType, filePath) => {
+    clearTimeout(debounceHandle);
+    debounceHandle = setTimeout(() => rebuild(`rebuild after ${import_node_path.default.relative(options.scriptDir, filePath)}`), options.debounceMs);
+  };
+  const closeWatchers = watchRecursively(options.scriptDir, scheduleRebuild);
+  await rebuild("initial build");
+  const close = () => {
+    closeWatchers();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", close);
+  process.on("SIGTERM", close);
+}
+run().catch((error) => {
+  console.error(error?.stack ?? error);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "spotifyplus",
-    "version": "0.1.1",
+    "version": "0.1.3",
     "type": "commonjs",
     "main": "./index.cjs",
     "types": "./index.d.ts",
@@ -56,6 +56,7 @@
     },
     "files": [
         "index.cjs",
+        "dev.cjs",
         "index.d.ts",
         "components.js",
         "components.d.ts",
@@ -66,6 +67,12 @@
         "package.json",
         "internal/*.d.ts"
     ],
+    "bin": {
+        "spotifyplus": "./dev.cjs"
+    },
+    "dependencies": {
+        "esbuild": "^0.27.5"
+    },
     "typesVersions": {
         "*": {
             "react": [