@adunne09/waldo 0.0.0-dev-202603111643

package/bin/waldo

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function run(target) {
+  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+
+  process.exit(typeof result.status === "number" ? result.status : 0);
+}
+
+const envPath = process.env.WALDO_BIN_PATH;
+if (envPath) {
+  run(envPath);
+}
+
+const scriptPath = fs.realpathSync(fileURLToPath(import.meta.url));
+const scriptDir = path.dirname(scriptPath);
+const packageDir = path.dirname(scriptDir);
+const packageJsonPath = path.join(packageDir, "package.json");
+const configFileName = "config.env";
+const autoUpdateConfigKey = "WALDO_AUTOUPDATE";
+const defaultNpmRegistry = "https://registry.npmjs.org";
+const publicPackageName = "@adunne09/waldo";
+
+function resolveUserConfigRoot() {
+  const home = os.homedir();
+
+  if (os.platform() === "darwin") {
+    return path.join(home, "Library", "Application Support");
+  }
+
+  if (os.platform() === "win32") {
+    const appData = process.env.APPDATA && path.isAbsolute(process.env.APPDATA) ? process.env.APPDATA : undefined;
+    return appData || path.join(home, "AppData", "Roaming");
+  }
+
+  const xdgConfigHome =
+    process.env.XDG_CONFIG_HOME && path.isAbsolute(process.env.XDG_CONFIG_HOME)
+      ? process.env.XDG_CONFIG_HOME
+      : undefined;
+
+  return xdgConfigHome || path.join(home, ".config");
+}
+
+function parseDotEnv(text) {
+  const map = new Map();
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0) continue;
+
+    const key = trimmed.slice(0, separator).trim();
+    let value = trimmed.slice(separator + 1).trim();
+
+    if (
+      value.length >= 2 &&
+      ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'")))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    map.set(key, value);
+  }
+
+  return map;
+}
+
+function parseBoolean(value) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return undefined;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return undefined;
+}
+
+function resolveAutoUpdateEnabled() {
+  const explicit = parseBoolean(process.env[autoUpdateConfigKey]);
+  if (explicit !== undefined) {
+    return explicit;
+  }
+
+  try {
+    const configPath = path.join(resolveUserConfigRoot(), "waldo", configFileName);
+    if (!fs.existsSync(configPath)) {
+      return true;
+    }
+
+    const parsed = parseDotEnv(fs.readFileSync(configPath, "utf8"));
+    return parseBoolean(parsed.get(autoUpdateConfigKey)) ?? true;
+  } catch {
+    return true;
+  }
+}
+
+function resolveNpmGlobalRoot() {
+  const result = childProcess.spawnSync("npm", ["root", "-g"], {
+    encoding: "utf8",
+  });
+
+  if (result.error || result.status !== 0) {
+    return undefined;
+  }
+
+  const root = result.stdout.trim();
+  return root || undefined;
+}
+
+function isGlobalNpmInstall() {
+  const globalRoot = resolveNpmGlobalRoot();
+  if (!globalRoot) {
+    return false;
+  }
+
+  return packageDir === globalRoot || packageDir.startsWith(`${globalRoot}/`) || packageDir.startsWith(`${globalRoot}\\`);
+}
+
+function resolveCurrentVersion() {
+  const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
+
+function resolveNpmRegistry() {
+  const result = childProcess.spawnSync("npm", ["config", "get", "registry"], {
+    encoding: "utf8",
+  });
+
+  if (result.error || result.status !== 0) {
+    return defaultNpmRegistry;
+  }
+
+  const registry = result.stdout.trim() || defaultNpmRegistry;
+  return registry.endsWith("/") ? registry.slice(0, -1) : registry;
+}
+
+async function resolveLatestVersion() {
+  const registry = resolveNpmRegistry();
+  const response = await fetch(`${registry}/${encodeURIComponent(publicPackageName)}/latest`);
+  if (!response.ok) {
+    throw new Error(`Failed to resolve latest Waldo version (${response.status} ${response.statusText})`);
+  }
+
+  const data = await response.json();
+  if (!data || typeof data.version !== "string" || !data.version.trim()) {
+    throw new Error("npm registry did not return a Waldo version");
+  }
+
+  return data.version.trim();
+}
+
+function runGlobalUpgrade(target) {
+  const result = childProcess.spawnSync("npm", ["install", "-g", `${publicPackageName}@${target}`], {
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`npm install -g ${publicPackageName}@${target} failed`);
+  }
+}
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+};
+
+const platform = platformMap[os.platform()] || os.platform();
+const arch = archMap[os.arch()] || os.arch();
+const binaryName = platform === "windows" ? "waldo.exe" : "waldo";
+const packageName = `${publicPackageName}-${platform}-${arch}`;
+
+function findBinary(startDir) {
+  let current = startDir;
+
+  for (;;) {
+    const modules = path.join(current, "node_modules");
+    if (fs.existsSync(modules)) {
+      const candidate = path.join(modules, "@adunne09", `waldo-${platform}-${arch}`, "bin", binaryName);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+
+    current = parent;
+  }
+}
+
+function resolveBinary() {
+  const cachedBinary = path.join(scriptDir, ".waldo");
+  if (fs.existsSync(cachedBinary)) {
+    return cachedBinary;
+  }
+
+  return findBinary(scriptDir);
+}
+
+async function maybeAutoUpdate() {
+  if (!resolveAutoUpdateEnabled()) {
+    return;
+  }
+
+  if (!isGlobalNpmInstall()) {
+    return;
+  }
+
+  try {
+    const current = resolveCurrentVersion();
+    const latest = await resolveLatestVersion();
+    if (current === latest) {
+      return;
+    }
+
+    runGlobalUpgrade(latest);
+  } catch {
+    // Ignore update failures and continue launching the installed binary.
+  }
+}
+
+await maybeAutoUpdate();
+
+const resolved = resolveBinary();
+if (!resolved) {
+  console.error(
+    `Could not find the installed Waldo binary for ${packageName}. Try reinstalling ${packageName}.`,
+  );
+  process.exit(1);
+}
+
+run(resolved);

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@adunne09/waldo",
+  "version": "0.0.0-dev-202603111643",
+  "type": "module",
+  "bin": {
+    "waldo": "./bin/waldo"
+  },
+  "scripts": {
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@adunne09/waldo-darwin-arm64": "0.0.0-dev-202603111643",
+    "@adunne09/waldo-darwin-x64": "0.0.0-dev-202603111643",
+    "@adunne09/waldo-linux-arm64": "0.0.0-dev-202603111643",
+    "@adunne09/waldo-linux-x64": "0.0.0-dev-202603111643",
+    "@adunne09/waldo-windows-x64": "0.0.0-dev-202603111643"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const publicPackageName = "@adunne09/waldo";
+
+const detectPlatformAndArch = () => {
+  const platform =
+    os.platform() === "win32"
+      ? "windows"
+      : os.platform() === "darwin"
+        ? "darwin"
+        : os.platform() === "linux"
+          ? "linux"
+          : os.platform();
+
+  const arch = os.arch() === "arm64" ? "arm64" : os.arch() === "x64" ? "x64" : os.arch();
+
+  return { platform, arch };
+};
+
+const findBinary = () => {
+  const { platform, arch } = detectPlatformAndArch();
+  const packageName = `${publicPackageName}-${platform}-${arch}`;
+  const packageJsonPath = require.resolve(`${packageName}/package.json`);
+  const packageDir = path.dirname(packageJsonPath);
+  const binaryName = platform === "windows" ? "waldo.exe" : "waldo";
+  const binaryPath = path.join(packageDir, "bin", binaryName);
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at ${binaryPath}`);
+  }
+
+  return binaryPath;
+};
+
+const main = async () => {
+  try {
+    if (os.platform() === "win32") {
+      return;
+    }
+
+    const binaryPath = findBinary();
+    const target = path.join(__dirname, "bin", ".waldo");
+    if (fs.existsSync(target)) {
+      fs.unlinkSync(target);
+    }
+
+    try {
+      fs.linkSync(binaryPath, target);
+    } catch {
+      fs.copyFileSync(binaryPath, target);
+    }
+
+    fs.chmodSync(target, 0o755);
+  } catch (error) {
+    console.error(
+      `Failed to setup Waldo binary: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    process.exit(1);
+  }
+};
+
+try {
+  await main();
+} catch (error) {
+  console.error(
+    `Postinstall script error: ${error instanceof Error ? error.message : String(error)}`,
+  );
+  process.exit(0);
+}