@leonxin/meetgames 0.1.11 → 0.1.13

package/src/aab-converter/apksExtractor.ts

@@ -1,119 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import zlib from "node:zlib";
-import { UserFacingError } from "../shared/errors.js";
-import { assertCanWriteFile } from "../shared/fileUtils.js";
-
-interface ZipEntry {
-  name: string;
-  method: number;
-  compressedSize: number;
-  localHeaderOffset: number;
-}
-
-function readAt(fd: number, position: number, length: number): Buffer {
-  const buf = Buffer.alloc(length);
-  const bytesRead = fs.readSync(fd, buf, 0, length, position);
-  return bytesRead === length ? buf : buf.subarray(0, bytesRead);
-}
-
-function findEndOfCentralDirectory(buf: Buffer): number {
-  const signature = 0x06054b50;
-  for (let i = buf.length - 22; i >= 0; i -= 1) {
-    if (buf.readUInt32LE(i) === signature) return i;
-  }
-  throw new UserFacingError("APKS_INVALID", "Invalid .apks file: end of central directory not found");
-}
-
-function readZipEntries(apksPath: string): ZipEntry[] {
-  const fd = fs.openSync(apksPath, "r");
-  try {
-    const fileSize = fs.fstatSync(fd).size;
-    const tailSize = Math.min(fileSize, 0xffff + 22);
-    const tailStart = fileSize - tailSize;
-    const tail = readAt(fd, tailStart, tailSize);
-    const eocd = findEndOfCentralDirectory(tail);
-    const totalEntries = tail.readUInt16LE(eocd + 10);
-    const centralDirSize = tail.readUInt32LE(eocd + 12);
-    const centralDirOffset = tail.readUInt32LE(eocd + 16);
-    if (centralDirSize === 0xffffffff || centralDirOffset === 0xffffffff || totalEntries === 0xffff) {
-      throw new UserFacingError("APKS_ZIP64_UNSUPPORTED", "ZIP64 .apks files are not supported yet");
-    }
-    const buf = readAt(fd, centralDirOffset, centralDirSize);
-    return parseCentralDirectory(buf, totalEntries);
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-function parseCentralDirectory(buf: Buffer, totalEntries: number): ZipEntry[] {
-  const entries: ZipEntry[] = [];
-  let pos = 0;
-  for (let i = 0; i < totalEntries; i += 1) {
-    if (buf.readUInt32LE(pos) !== 0x02014b50) {
-      throw new UserFacingError("APKS_INVALID", "Invalid .apks file: central directory is corrupt");
-    }
-    const method = buf.readUInt16LE(pos + 10);
-    const compressedSize = buf.readUInt32LE(pos + 20);
-    const nameLength = buf.readUInt16LE(pos + 28);
-    const extraLength = buf.readUInt16LE(pos + 30);
-    const commentLength = buf.readUInt16LE(pos + 32);
-    const localHeaderOffset = buf.readUInt32LE(pos + 42);
-    const name = buf.subarray(pos + 46, pos + 46 + nameLength).toString("utf8");
-    entries.push({ name, method, compressedSize, localHeaderOffset });
-    pos += 46 + nameLength + extraLength + commentLength;
-  }
-  return entries;
-}
-
-async function extractEntryToFile(apksPath: string, entry: ZipEntry, outputApkPath: string): Promise<void> {
-  const fd = fs.openSync(apksPath, "r");
-  let dataStart: number;
-  try {
-    const localHeader = readAt(fd, entry.localHeaderOffset, 30);
-    if (localHeader.readUInt32LE(0) !== 0x04034b50) {
-      throw new UserFacingError("APKS_INVALID", `Invalid .apks file: local header not found for ${entry.name}`);
-    }
-    const nameLength = localHeader.readUInt16LE(26);
-    const extraLength = localHeader.readUInt16LE(28);
-    dataStart = entry.localHeaderOffset + 30 + nameLength + extraLength;
-  } finally {
-    fs.closeSync(fd);
-  }
-
-  await new Promise<void>((resolve, reject) => {
-    const input = fs.createReadStream(apksPath, {
-      start: dataStart,
-      end: dataStart + entry.compressedSize - 1,
-    });
-    const output = fs.createWriteStream(outputApkPath);
-    const source =
-      entry.method === 0
-        ? input
-        : entry.method === 8
-          ? input.pipe(zlib.createInflateRaw())
-          : null;
-    if (!source) {
-      input.destroy();
-      output.destroy();
-      reject(new UserFacingError("APKS_UNSUPPORTED_ZIP_METHOD", `Unsupported zip compression method ${entry.method}`));
-      return;
-    }
-    input.on("error", reject);
-    source.on("error", reject);
-    output.on("error", reject);
-    output.on("finish", resolve);
-    source.pipe(output);
-  });
-}
-
-export async function extractUniversalApk(apksPath: string, outputApkPath: string, overwrite: boolean): Promise<void> {
-  assertCanWriteFile(outputApkPath, overwrite, "Output APK");
-  const entries = readZipEntries(apksPath);
-  const universal = entries.find((entry) => entry.name === "universal.apk" || entry.name.endsWith("/universal.apk"));
-  if (!universal) {
-    throw new UserFacingError("UNIVERSAL_APK_NOT_FOUND", "universal.apk not found in .apks output");
-  }
-  fs.mkdirSync(path.dirname(outputApkPath), { recursive: true });
-  await extractEntryToFile(apksPath, universal, outputApkPath);
-}

package/src/aab-converter/bundletoolRunner.ts

@@ -1,63 +0,0 @@
-import path from "node:path";
-import { UserFacingError } from "../shared/errors.js";
-import { runProcess } from "../shared/processRunner.js";
-import type { Logger } from "../shared/logger.js";
-import type { SigningOptions } from "./types.js";
-
-export interface BuildApksOptions {
-  javaPath: string;
-  bundletoolPath: string;
-  aabPath: string;
-  apksPath: string;
-  signing: SigningOptions;
-  overwrite: boolean;
-  logger?: Logger;
-}
-
-export function buildBundletoolArgs(options: Omit<BuildApksOptions, "javaPath" | "logger">): string[] {
-  const args = [
-    "-jar",
-    options.bundletoolPath,
-    "build-apks",
-    `--bundle=${options.aabPath}`,
-    `--output=${options.apksPath}`,
-    "--mode=universal",
-    `--ks=${options.signing.keyStorePath}`,
-    `--ks-key-alias=${options.signing.keyAlias}`,
-    `--ks-pass=pass:${options.signing.keyStorePassword}`,
-  ];
-  if (options.signing.keyPassword) {
-    args.push(`--key-pass=pass:${options.signing.keyPassword}`);
-  }
-  if (options.overwrite) {
-    args.push("--overwrite");
-  }
-  return args;
-}
-
-function redactArg(arg: string): string {
-  if (arg.startsWith("--ks-pass=pass:")) return "--ks-pass=pass:******";
-  if (arg.startsWith("--key-pass=pass:")) return "--key-pass=pass:******";
-  return arg;
-}
-
-export function redactedBundletoolCommand(javaPath: string, args: string[]): string {
-  return [javaPath, ...args.map(redactArg)].map((part) => (part.includes(" ") ? `"${part}"` : part)).join(" ");
-}
-
-export async function buildUniversalApks(options: BuildApksOptions): Promise<void> {
-  const args = buildBundletoolArgs(options);
-  options.logger?.info(`Running bundletool: ${redactedBundletoolCommand(options.javaPath, args)}`);
-  const result = await runProcess(options.javaPath, args, {
-    cwd: path.dirname(options.apksPath),
-    onStdout: (chunk) => options.logger?.info(chunk.trimEnd()),
-    onStderr: (chunk) => options.logger?.warn(chunk.trimEnd()),
-  });
-  if (result.exitCode !== 0) {
-    throw new UserFacingError(
-      "BUNDLETOOL_FAILED",
-      "bundletool failed to build APK set",
-      (result.stderr || result.stdout).trim()
-    );
-  }
-}

package/src/aab-converter/cliArgs.ts

@@ -1,194 +0,0 @@
-import path from "node:path";
-import { UserFacingError } from "../shared/errors.js";
-import { toAbsolutePath } from "../shared/pathUtils.js";
-import { resolveSigningOptions } from "./signingOptions.js";
-import type { SigningOptions } from "./types.js";
-
-export interface ParsedAabCli {
-  help: boolean;
-  command: string;
-  aabPath: string;
-  outDir: string;
-  keyStorePath: string;
-  keyAlias: string;
-  keyStorePassword?: string;
-  keyPassword?: string;
-  apkName?: string;
-  keepApks: boolean;
-  overwrite: boolean;
-  verbose: boolean;
-}
-
-function valueAfter(args: string[], index: number, flag: string): string {
-  const value = args[index + 1] ?? "";
-  if (!value || value.startsWith("--")) {
-    throw new UserFacingError("INVALID_ARGS", `${flag} requires a value`);
-  }
-  return value;
-}
-
-function passwordFromEnv(envName: string, flag: string): string {
-  const value = process.env[envName];
-  if (!value) {
-    throw new UserFacingError("ENV_PASSWORD_MISSING", `${flag} points to an empty or missing environment variable: ${envName}`);
-  }
-  return value;
-}
-
-export function printAabHelp(): void {
-  console.log(`
-aab2apk — Convert Android App Bundle (.aab) to signed universal APK
-
-Usage:
-  aab2apk.cmd convert --aab <file.aab> --out-dir <dir> --ks <file.jks> --ks-key-alias <alias> [password options]
-
-Required:
-  --aab              AAB file path
-  --out-dir          Output directory
-  --ks               Keystore/JKS file path
-  --ks-key-alias     Key alias in keystore
-
-Password options:
-  --ks-pass-env      Read keystore password from environment variable (recommended)
-  --key-pass-env     Read key password from environment variable (recommended)
-  --ks-pass          Keystore password as command argument (not recommended)
-  --key-pass         Key password as command argument (not recommended)
-
-Other options:
-  --apk-name         Output APK file name
-  --keep-apks        Keep intermediate .apks file
-  --no-overwrite     Fail if output already exists (default is overwrite)
-  --verbose          Print detailed logs
-  --help, -h         Show help
-`);
-}
-
-export function parseAabCliArgv(argv: string[]): ParsedAabCli {
-  const rest = argv.slice(2);
-  if (!rest.length || rest[0] === "--help" || rest[0] === "-h") {
-    return {
-      help: true,
-      command: "",
-      aabPath: "",
-      outDir: "",
-      keyStorePath: "",
-      keyAlias: "",
-      keepApks: false,
-      overwrite: true,
-      verbose: false,
-    };
-  }
-  const parsed: ParsedAabCli = {
-    help: false,
-    command: rest[0] ?? "",
-    aabPath: "",
-    outDir: "",
-    keyStorePath: "",
-    keyAlias: "",
-    keepApks: false,
-    overwrite: true,
-    verbose: false,
-  };
-  if (parsed.command !== "convert") {
-    throw new UserFacingError("INVALID_COMMAND", `Unknown command: ${parsed.command}`);
-  }
-  for (let i = 1; i < rest.length; i += 1) {
-    const flag = rest[i];
-    if (flag === "--help" || flag === "-h") {
-      parsed.help = true;
-      return parsed;
-    }
-    if (flag === "--keep-apks") {
-      parsed.keepApks = true;
-      continue;
-    }
-    if (flag === "--verbose") {
-      parsed.verbose = true;
-      continue;
-    }
-    if (flag === "--no-overwrite") {
-      parsed.overwrite = false;
-      continue;
-    }
-    if (flag === "--overwrite") {
-      parsed.overwrite = true;
-      continue;
-    }
-    if (flag === "--aab") {
-      parsed.aabPath = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--out-dir") {
-      parsed.outDir = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--ks") {
-      parsed.keyStorePath = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--ks-key-alias") {
-      parsed.keyAlias = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--ks-pass-env") {
-      parsed.keyStorePassword = passwordFromEnv(valueAfter(rest, i, flag), flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--key-pass-env") {
-      parsed.keyPassword = passwordFromEnv(valueAfter(rest, i, flag), flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--ks-pass") {
-      parsed.keyStorePassword = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--key-pass") {
-      parsed.keyPassword = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    if (flag === "--apk-name") {
-      parsed.apkName = valueAfter(rest, i, flag);
-      i += 1;
-      continue;
-    }
-    throw new UserFacingError("INVALID_ARGS", `Unsupported argument: ${flag}`);
-  }
-  return parsed;
-}
-
-export function validateConvertArgs(parsed: ParsedAabCli): {
-  aabPath: string;
-  outDir: string;
-  signing: SigningOptions;
-  apkName?: string;
-  keepApks: boolean;
-  overwrite: boolean;
-  verbose: boolean;
-} {
-  if (!parsed.aabPath) throw new UserFacingError("INVALID_ARGS", "Missing --aab");
-  if (!parsed.outDir) throw new UserFacingError("INVALID_ARGS", "Missing --out-dir");
-  if (!parsed.keyStorePath) throw new UserFacingError("INVALID_ARGS", "Missing --ks");
-  if (!parsed.keyAlias) throw new UserFacingError("INVALID_ARGS", "Missing --ks-key-alias");
-  return {
-    aabPath: toAbsolutePath(parsed.aabPath),
-    outDir: path.resolve(parsed.outDir),
-    signing: resolveSigningOptions({
-      keyStorePath: parsed.keyStorePath,
-      keyAlias: parsed.keyAlias,
-      keyStorePassword: parsed.keyStorePassword,
-      keyPassword: parsed.keyPassword,
-    }),
-    apkName: parsed.apkName,
-    keepApks: parsed.keepApks,
-    overwrite: parsed.overwrite,
-    verbose: parsed.verbose,
-  };
-}

package/src/aab-converter/convertAabToApk.ts

@@ -1,81 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { UserFacingError } from "../shared/errors.js";
-import { assertCanWriteFile, assertFileExists, assertWritableDirectory } from "../shared/fileUtils.js";
-import { baseNameWithoutExt, toAbsolutePath, validateOutputFileName } from "../shared/pathUtils.js";
-import { buildUniversalApks } from "./bundletoolRunner.js";
-import { extractUniversalApk } from "./apksExtractor.js";
-import type { ConvertAabToApkOptions, ConvertAabToApkResult } from "./types.js";
-
-export function resolveOutputPaths(options: Pick<ConvertAabToApkOptions, "aabPath" | "outDir" | "apkName">): {
-  apksPath: string;
-  apkPath: string;
-} {
-  const aabBase = baseNameWithoutExt(options.aabPath, ".aab");
-  const apkName = options.apkName ? validateOutputFileName(options.apkName) : `${aabBase}_universal.apk`;
-  return {
-    apksPath: path.join(options.outDir, `${aabBase}.apks`),
-    apkPath: path.join(options.outDir, apkName),
-  };
-}
-
-export async function convertAabToApk(options: ConvertAabToApkOptions): Promise<ConvertAabToApkResult> {
-  const aabPath = toAbsolutePath(options.aabPath);
-  const outDir = toAbsolutePath(options.outDir);
-  const javaPath = options.javaPath;
-  const bundletoolPath = toAbsolutePath(options.bundletoolPath);
-  const signing = {
-    ...options.signing,
-    keyStorePath: toAbsolutePath(options.signing.keyStorePath),
-  };
-
-  assertFileExists(aabPath, "AAB_NOT_FOUND", "AAB file");
-  baseNameWithoutExt(aabPath, ".aab");
-  assertFileExists(signing.keyStorePath, "KEYSTORE_NOT_FOUND", "Keystore file");
-  assertFileExists(bundletoolPath, "BUNDLETOOL_NOT_FOUND", "bundletool.jar");
-  if (javaPath.includes("/") || javaPath.includes("\\")) {
-    assertFileExists(javaPath, "JAVA_NOT_FOUND", "Java executable");
-  }
-  assertWritableDirectory(outDir);
-
-  const { apksPath, apkPath } = resolveOutputPaths({ aabPath, outDir, apkName: options.apkName });
-  assertCanWriteFile(apksPath, options.overwrite, "APK set");
-  assertCanWriteFile(apkPath, options.overwrite, "Output APK");
-
-  options.logger?.info(`AAB: ${aabPath}`);
-  options.logger?.info(`Output directory: ${outDir}`);
-  options.logger?.info(`APK set: ${apksPath}`);
-  options.logger?.info(`Output APK: ${apkPath}`);
-
-  await buildUniversalApks({
-    javaPath,
-    bundletoolPath,
-    aabPath,
-    apksPath,
-    signing,
-    overwrite: options.overwrite,
-    logger: options.logger,
-  });
-
-  await extractUniversalApk(apksPath, apkPath, options.overwrite);
-  options.logger?.info(`Extracted universal APK: ${apkPath}`);
-
-  if (!options.keepApks) {
-    try {
-      fs.unlinkSync(apksPath);
-      options.logger?.info(`Removed intermediate APK set: ${apksPath}`);
-    } catch (e) {
-      options.logger?.warn(`Failed to remove intermediate APK set: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
-
-  if (!fs.existsSync(apkPath)) {
-    throw new UserFacingError("APK_OUTPUT_MISSING", `Output APK was not created: ${apkPath}`);
-  }
-
-  return {
-    apkPath,
-    apksPath: options.keepApks ? apksPath : undefined,
-    logPath: options.logger?.logPath,
-  };
-}

package/src/aab-converter/resourcePaths.ts

@@ -1,43 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { UserFacingError } from "../shared/errors.js";
-
-export function resolveToolRoot(metaUrl: string): string {
-  const here = path.dirname(fileURLToPath(metaUrl));
-  return path.resolve(here, "..", "..");
-}
-
-function firstExisting(candidates: string[]): string | null {
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-
-export function resolveBundletoolPath(toolRoot: string): string {
-  const envPath = process.env.AAB2APK_BUNDLETOOL_PATH?.trim();
-  if (envPath) return path.resolve(envPath);
-  const found = firstExisting([
-    path.join(toolRoot, "tools", "bundletool.jar"),
-    path.join(toolRoot, "bundled", "android", "bundletool.jar"),
-  ]);
-  if (found) return found;
-  throw new UserFacingError(
-    "BUNDLETOOL_NOT_FOUND",
-    `bundletool.jar not found. Expected ${path.join(toolRoot, "tools", "bundletool.jar")}`
-  );
-}
-
-export function resolveJavaPath(toolRoot: string): string {
-  const envPath = process.env.AAB2APK_JAVA_PATH?.trim();
-  if (envPath) return path.resolve(envPath);
-  const exe = process.platform === "win32" ? "java.exe" : "java";
-  const candidates = [path.join(toolRoot, "runtime", "jre", "bin", exe)];
-  if (process.platform === "win32") {
-    candidates.push(path.join(toolRoot, "runtime", "win-x64", "jre", "bin", "java.exe"));
-  }
-  const found = firstExisting(candidates);
-  if (found) return found;
-  return exe;
-}

package/src/aab-converter/signingOptions.ts

@@ -1,29 +0,0 @@
-import path from "node:path";
-import { UserFacingError } from "../shared/errors.js";
-import { assertFileExists } from "../shared/fileUtils.js";
-import { toAbsolutePath } from "../shared/pathUtils.js";
-import type { SigningOptions } from "./types.js";
-
-export interface SigningInput {
-  keyStorePath: string;
-  keyAlias: string;
-  keyStorePassword?: string;
-  keyPassword?: string;
-}
-
-export function resolveSigningOptions(input: SigningInput): SigningOptions {
-  const keyStorePath = toAbsolutePath(input.keyStorePath);
-  assertFileExists(keyStorePath, "KEYSTORE_NOT_FOUND", "Keystore file");
-  if (!input.keyAlias.trim()) {
-    throw new UserFacingError("SIGNING_ALIAS_MISSING", "Missing --ks-key-alias");
-  }
-  if (!input.keyStorePassword) {
-    throw new UserFacingError("SIGNING_PASSWORD_MISSING", "Missing keystore password");
-  }
-  return {
-    keyStorePath: path.resolve(keyStorePath),
-    keyAlias: input.keyAlias,
-    keyStorePassword: input.keyStorePassword,
-    keyPassword: input.keyPassword || undefined,
-  };
-}

package/src/aab-converter/types.ts

@@ -1,26 +0,0 @@
-import type { Logger } from "../shared/logger.js";
-
-export interface SigningOptions {
-  keyStorePath: string;
-  keyAlias: string;
-  keyStorePassword: string;
-  keyPassword?: string;
-}
-
-export interface ConvertAabToApkOptions {
-  aabPath: string;
-  outDir: string;
-  signing: SigningOptions;
-  javaPath: string;
-  bundletoolPath: string;
-  apkName?: string;
-  keepApks: boolean;
-  overwrite: boolean;
-  logger?: Logger;
-}
-
-export interface ConvertAabToApkResult {
-  apkPath: string;
-  apksPath?: string;
-  logPath?: string;
-}

package/src/shared/fileUtils.ts

@@ -1,41 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { UserFacingError } from "./errors.js";
-
-export function assertFileExists(filePath: string, code: string, label: string): void {
-  if (!fs.existsSync(filePath)) {
-    throw new UserFacingError(code, `${label} does not exist: ${filePath}`);
-  }
-  if (!fs.statSync(filePath).isFile()) {
-    throw new UserFacingError(code, `${label} is not a file: ${filePath}`);
-  }
-}
-
-export function ensureDirectory(dirPath: string): void {
-  fs.mkdirSync(dirPath, { recursive: true });
-  if (!fs.statSync(dirPath).isDirectory()) {
-    throw new UserFacingError("OUTPUT_DIR_INVALID", `Output path is not a directory: ${dirPath}`);
-  }
-}
-
-export function assertWritableDirectory(dirPath: string): void {
-  ensureDirectory(dirPath);
-  try {
-    const probe = path.join(dirPath, `.write-test-${Date.now()}-${Math.random().toString(16).slice(2)}`);
-    fs.writeFileSync(probe, "");
-    fs.unlinkSync(probe);
-  } catch (e) {
-    throw new UserFacingError(
-      "OUTPUT_DIR_NOT_WRITABLE",
-      `Output directory is not writable: ${dirPath}`,
-      e instanceof Error ? e.message : String(e)
-    );
-  }
-}
-
-export function assertCanWriteFile(filePath: string, overwrite: boolean, label: string): void {
-  if (!overwrite && fs.existsSync(filePath)) {
-    throw new UserFacingError("OUTPUT_EXISTS", `${label} already exists: ${filePath}`);
-  }
-  ensureDirectory(path.dirname(filePath));
-}

package/src/shared/logger.ts

@@ -1,49 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-export interface Logger {
-  readonly logPath?: string;
-  info(message: string): void;
-  warn(message: string): void;
-  error(message: string): void;
-  close(): void;
-}
-
-function timestamp(): string {
-  return new Date().toISOString();
-}
-
-function logFileName(): string {
-  const d = new Date();
-  const pad = (n: number) => String(n).padStart(2, "0");
-  return `convert-${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(
-    d.getMinutes()
-  )}${pad(d.getSeconds())}.log`;
-}
-
-export function createFileLogger(logDir: string): Logger {
-  fs.mkdirSync(logDir, { recursive: true });
-  const logPath = path.join(logDir, logFileName());
-  const stream = fs.createWriteStream(logPath, { flags: "a", encoding: "utf8" });
-  const write = (level: string, message: string) => {
-    stream.write(`[${timestamp()}] [${level}] ${message}\n`);
-  };
-  return {
-    logPath,
-    info: (message) => write("INFO", message),
-    warn: (message) => write("WARN", message),
-    error: (message) => write("ERROR", message),
-    close: () => stream.end(),
-  };
-}
-
-export function createConsoleLogger(verbose: boolean): Logger {
-  return {
-    info: (message) => {
-      if (verbose) console.log(message);
-    },
-    warn: (message) => console.warn(message),
-    error: (message) => console.error(message),
-    close: () => undefined,
-  };
-}

package/src/shared/pathUtils.ts

@@ -1,24 +0,0 @@
-import path from "node:path";
-import { UserFacingError } from "./errors.js";
-
-export function toAbsolutePath(value: string, baseDir = process.cwd()): string {
-  return path.resolve(baseDir, value);
-}
-
-export function baseNameWithoutExt(filePath: string, expectedExt: string): string {
-  const parsed = path.parse(filePath);
-  if (parsed.ext.toLowerCase() !== expectedExt.toLowerCase()) {
-    throw new UserFacingError("INVALID_EXTENSION", `Expected ${expectedExt} file: ${filePath}`);
-  }
-  return parsed.name;
-}
-
-export function validateOutputFileName(fileName: string): string {
-  if (!fileName.trim()) {
-    throw new UserFacingError("INVALID_APK_NAME", "--apk-name cannot be empty");
-  }
-  if (fileName.includes("/") || fileName.includes("\\") || path.basename(fileName) !== fileName) {
-    throw new UserFacingError("INVALID_APK_NAME", "--apk-name must be a file name, not a path");
-  }
-  return fileName.toLowerCase().endsWith(".apk") ? fileName : `${fileName}.apk`;
-}