@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/infra/control-ui-assets.js

@@ -1,17 +1,34 @@
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { defaultRuntime } from "../runtime.js";
+import { resolvePoolBotPackageRoot, resolvePoolBotPackageRootSync } from "./poolbot-root.js";
+const CONTROL_UI_DIST_PATH_SEGMENTS = ["dist", "control-ui", "index.html"];
+export function resolveControlUiDistIndexPathForRoot(root) {
+    return path.join(root, ...CONTROL_UI_DIST_PATH_SEGMENTS);
+}
+export async function resolveControlUiDistIndexHealth(opts = {}) {
+    const indexPath = opts.root
+        ? resolveControlUiDistIndexPathForRoot(opts.root)
+        : await resolveControlUiDistIndexPath(opts.argv1 ?? process.argv[1]);
+    return {
+        indexPath,
+        exists: Boolean(indexPath && fs.existsSync(indexPath)),
+    };
+}
 export function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
-    if (!argv1)
+    if (!argv1) {
         return null;
+    }
     const normalized = path.resolve(argv1);
     const parts = normalized.split(path.sep);
     const srcIndex = parts.lastIndexOf("src");
     if (srcIndex !== -1) {
         const root = parts.slice(0, srcIndex).join(path.sep);
-        if (fs.existsSync(path.join(root, "ui", "vite.config.ts")))
+        if (fs.existsSync(path.join(root, "ui", "vite.config.ts"))) {
             return root;
+        }
     }
     let dir = path.dirname(normalized);
     for (let i = 0; i < 8; i++) {
@@ -20,36 +37,141 @@ export function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
             return dir;
         }
         const parent = path.dirname(dir);
-        if (parent === dir)
+        if (parent === dir) {
             break;
+        }
         dir = parent;
     }
     return null;
 }
-export function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
-    if (!argv1)
+export async function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
+    if (!argv1) {
         return null;
+    }
     const normalized = path.resolve(argv1);
+    // Case 1: entrypoint is directly inside dist/ (e.g., dist/entry.js)
     const distDir = path.dirname(normalized);
-    if (path.basename(distDir) !== "dist")
+    if (path.basename(distDir) === "dist") {
+        return path.join(distDir, "control-ui", "index.html");
+    }
+    const packageRoot = await resolvePoolBotPackageRoot({ argv1: normalized });
+    if (packageRoot) {
+        return path.join(packageRoot, "dist", "control-ui", "index.html");
+    }
+    // Fallback: traverse up and find package.json with name "poolbot" + dist/control-ui/index.html
+    // This handles global installs where path-based resolution might fail.
+    let dir = path.dirname(normalized);
+    for (let i = 0; i < 8; i++) {
+        const pkgJsonPath = path.join(dir, "package.json");
+        const indexPath = path.join(dir, "dist", "control-ui", "index.html");
+        if (fs.existsSync(pkgJsonPath) && fs.existsSync(indexPath)) {
+            try {
+                const raw = fs.readFileSync(pkgJsonPath, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (parsed.name === "poolbot") {
+                    return indexPath;
+                }
+            }
+            catch {
+                // Invalid package.json, continue searching
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return null;
+}
+function addCandidate(candidates, value) {
+    if (!value) {
+        return;
+    }
+    candidates.add(path.resolve(value));
+}
+export function resolveControlUiRootOverrideSync(rootOverride) {
+    const resolved = path.resolve(rootOverride);
+    try {
+        const stats = fs.statSync(resolved);
+        if (stats.isFile()) {
+            return path.basename(resolved) === "index.html" ? path.dirname(resolved) : null;
+        }
+        if (stats.isDirectory()) {
+            const indexPath = path.join(resolved, "index.html");
+            return fs.existsSync(indexPath) ? resolved : null;
+        }
+    }
+    catch {
         return null;
-    return path.join(distDir, "control-ui", "index.html");
+    }
+    return null;
+}
+export function resolveControlUiRootSync(opts = {}) {
+    const candidates = new Set();
+    const argv1 = opts.argv1 ?? process.argv[1];
+    const cwd = opts.cwd ?? process.cwd();
+    const moduleDir = opts.moduleUrl ? path.dirname(fileURLToPath(opts.moduleUrl)) : null;
+    const argv1Dir = argv1 ? path.dirname(path.resolve(argv1)) : null;
+    const execDir = (() => {
+        try {
+            const execPath = opts.execPath ?? process.execPath;
+            return path.dirname(fs.realpathSync(execPath));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const packageRoot = resolvePoolBotPackageRootSync({
+        argv1,
+        moduleUrl: opts.moduleUrl,
+        cwd,
+    });
+    // Packaged app: control-ui lives alongside the executable.
+    addCandidate(candidates, execDir ? path.join(execDir, "control-ui") : null);
+    if (moduleDir) {
+        // dist/<bundle>.js -> dist/control-ui
+        addCandidate(candidates, path.join(moduleDir, "control-ui"));
+        // dist/gateway/control-ui.js -> dist/control-ui
+        addCandidate(candidates, path.join(moduleDir, "../control-ui"));
+        // src/gateway/control-ui.ts -> dist/control-ui
+        addCandidate(candidates, path.join(moduleDir, "../../dist/control-ui"));
+    }
+    if (argv1Dir) {
+        // poolbot.mjs or dist/<bundle>.js
+        addCandidate(candidates, path.join(argv1Dir, "dist", "control-ui"));
+        addCandidate(candidates, path.join(argv1Dir, "control-ui"));
+    }
+    if (packageRoot) {
+        addCandidate(candidates, path.join(packageRoot, "dist", "control-ui"));
+    }
+    addCandidate(candidates, path.join(cwd, "dist", "control-ui"));
+    for (const dir of candidates) {
+        const indexPath = path.join(dir, "index.html");
+        if (fs.existsSync(indexPath)) {
+            return dir;
+        }
+    }
+    return null;
 }
 function summarizeCommandOutput(text) {
     const lines = text
         .split(/\r?\n/g)
         .map((l) => l.trim())
         .filter(Boolean);
-    if (!lines.length)
+    if (!lines.length) {
         return undefined;
+    }
     const last = lines.at(-1);
-    if (!last)
+    if (!last) {
         return undefined;
+    }
     return last.length > 240 ? `${last.slice(0, 239)}…` : last;
 }
 export async function ensureControlUiAssetsBuilt(runtime = defaultRuntime, opts) {
-    const indexFromDist = resolveControlUiDistIndexPath(process.argv[1]);
-    if (indexFromDist && fs.existsSync(indexFromDist)) {
+    const health = await resolveControlUiDistIndexHealth({ argv1: process.argv[1] });
+    const indexFromDist = health.indexPath;
+    if (health.exists) {
         return { ok: true, built: false };
     }
     const repoRoot = resolveControlUiRepoRoot(process.argv[1]);
@@ -63,7 +185,7 @@ export async function ensureControlUiAssetsBuilt(runtime = defaultRuntime, opts)
             message: `${hint}. Build them with \`pnpm ui:build\` (auto-installs UI deps).`,
         };
     }
-    const indexPath = path.join(repoRoot, "dist", "control-ui", "index.html");
+    const indexPath = resolveControlUiDistIndexPathForRoot(repoRoot);
     if (fs.existsSync(indexPath)) {
         return { ok: true, built: false };
     }

package/dist/infra/errors.js

@@ -8,6 +8,18 @@ export function extractErrorCode(err) {
         return String(code);
     return undefined;
 }
+/**
+ * Type guard for NodeJS.ErrnoException (any error with a `code` property).
+ */
+export function isErrno(err) {
+    return Boolean(err && typeof err === "object" && "code" in err);
+}
+/**
+ * Check if an error has a specific errno code.
+ */
+export function hasErrnoCode(err, code) {
+    return isErrno(err) && err.code === code;
+}
 export function formatErrorMessage(err) {
     if (err instanceof Error) {
         return err.message || err.name || "Error";