akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/tasks/resolve-akm-bin.js

@@ -9,79 +9,172 @@
  *
  * Resolution order:
  *
- *   1. `$AKM_BIN` (explicit override; takes precedence everywhere).
- *   2. `process.execPath` + the resolved CLI script — works when running
- *      from a development checkout (`bun /repo/src/cli.ts`) and from a
- *      compiled install (`bun /opt/akm/dist/cli.js`).
- *   3. `which akm` / `where akm` — last resort when the binary is on PATH
- *      but neither override applies.
+ *   1. `process.execPath` alone for a Bun standalone executable.
+ *   2. Absolute Node plus the public `dist/akm` package launcher.
+ *   3. Absolute runtime plus the source/build CLI entry, classified as a
+ *      checkout that requires explicit `--rebind` for scheduler writes.
  *
  * Returns the argv array the scheduler should execute (e.g.
- * `["/usr/local/bin/bun", "/repo/dist/cli.js"]`). The caller appends
- * subcommand args (`"tasks", "run", "<id>"`).
+ * `["/usr/local/bin/node", "/repo/dist/cli-node.mjs"]`). The caller appends
+ * subcommand args (`"task", "run", "<id>"`).
  */
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ConfigError } from "../core/errors.js";
+import { mainPath as runtimeMainPath } from "../runtime.js";
 export function resolveAkmInvocation(options = {}) {
     const env = options.env ?? process.env;
-    const override = env.AKM_BIN?.trim();
-    if (override) {
-        return { argv: [override], via: "AKM_BIN" };
+    const runtime = options.runtime ?? (process.versions.bun ? "bun" : "node");
+    const execPath = options.execPath ?? process.execPath;
+    const mainPath = options.mainPath ?? runtimeMainPath;
+    const isStandaloneMain = mainPath?.startsWith("/$bunfs/") || (mainPath !== undefined && /^[A-Za-z]:[\\/]~BUN[\\/]/i.test(mainPath));
+    if (runtime === "bun" && isStandaloneMain && execPath) {
+        return { argv: [absoluteInvocationPath(execPath)], via: "standalone", kind: "standalone", eligible: true };
     }
-    const cliPath = resolveCliEntry(options.cliEntryUrl ?? import.meta.url);
-    if (cliPath && process.execPath) {
-        return { argv: [process.execPath, cliPath], via: "execPath" };
+    const launcherPath = options.launcherPath ?? env.AKM_LAUNCHER_PATH?.trim();
+    const nodePath = options.nodePath ?? env.AKM_LAUNCHER_NODE?.trim() ?? (runtime === "node" ? execPath : undefined);
+    if (launcherPath && nodePath && isPublicPackageLauncher(launcherPath)) {
+        const checkout = isCheckoutLauncher(launcherPath);
+        let npmGlobalRoot;
+        if (!checkout) {
+            try {
+                npmGlobalRoot = (options.resolveNpmGlobalRoot ?? ((node) => resolveNpmGlobalRoot(node, env)))(nodePath);
+            }
+            catch {
+                // An unprovable package installation is intentionally ineligible.
+            }
+        }
+        const npmGlobal = !checkout && packageBelongsToNpmGlobalRoot(launcherPath, npmGlobalRoot);
+        const kind = checkout ? "checkout" : npmGlobal ? "npm" : "package-local";
+        return {
+            argv: [absoluteInvocationPath(nodePath), absoluteInvocationPath(launcherPath)],
+            via: kind,
+            kind,
+            eligible: npmGlobal,
+        };
     }
-    const whichBin = findOnPath("akm", env);
-    if (whichBin) {
-        return { argv: [whichBin], via: "which" };
+    const checkoutEntry = resolveCheckoutEntry(options.cliEntryUrl ?? import.meta.url, runtime, mainPath);
+    if (checkoutEntry && execPath) {
+        return {
+            argv: [absoluteInvocationPath(execPath), absoluteInvocationPath(checkoutEntry)],
+            via: "checkout",
+            kind: "checkout",
+            eligible: false,
+        };
     }
-    throw new ConfigError("Cannot resolve absolute path to the akm binary for scheduler registration.", "INVALID_CONFIG_FILE", "Set AKM_BIN to the absolute path of the akm binary, or ensure `akm` is on PATH.");
+    throw new ConfigError("Cannot resolve absolute path to the akm binary for scheduler registration.", "INVALID_CONFIG_FILE", "Run the npm-global launcher or a standalone akm executable.");
 }
-/**
- * From the URL of a module inside `src/tasks/` figure out the CLI entry.
- *
- *   • dev      `…/src/tasks/resolve-akm-bin.ts`   → `…/src/cli.ts`
- *   • build    `…/dist/tasks/resolve-akm-bin.js`  → `…/dist/cli.js`
- */
-function resolveCliEntry(moduleUrl) {
-    let modulePath;
+function resolveCheckoutEntry(moduleUrl, runtime, mainPath) {
     try {
-        modulePath = fileURLToPath(moduleUrl);
+        const modulePath = fileURLToPath(moduleUrl);
+        const parent = path.dirname(path.dirname(modulePath));
+        if (runtime === "node") {
+            const wrapper = path.join(parent, "cli-node.mjs");
+            if (fs.existsSync(wrapper))
+                return wrapper;
+            if (mainPath) {
+                if (path.basename(mainPath) === "cli-node.mjs" && fs.existsSync(mainPath))
+                    return mainPath;
+                const siblingWrapper = path.join(path.dirname(mainPath), "cli-node.mjs");
+                if (fs.existsSync(siblingWrapper))
+                    return siblingWrapper;
+            }
+            return undefined;
+        }
+        const extension = path.extname(modulePath);
+        const candidate = path.join(parent, `cli${extension}`);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const alternate = path.join(parent, extension === ".ts" ? "cli.js" : "cli.ts");
+        return fs.existsSync(alternate) ? alternate : undefined;
     }
     catch {
-        return undefined;
+        return runtime === "bun" ? mainPath : undefined;
     }
-    const dir = path.dirname(modulePath); // .../tasks
-    const parent = path.dirname(dir); // .../src or .../dist
-    const ext = path.extname(modulePath); // .ts | .js
-    const candidate = path.join(parent, `cli${ext}`);
-    if (fs.existsSync(candidate))
-        return candidate;
-    // Fallback: try the other extension.
-    const alt = path.join(parent, ext === ".ts" ? "cli.js" : "cli.ts");
-    if (fs.existsSync(alt))
-        return alt;
-    return undefined;
 }
-function findOnPath(bin, env) {
-    const tool = process.platform === "win32" ? "where" : "which";
+function absoluteInvocationPath(value) {
+    return path.win32.isAbsolute(value) || path.posix.isAbsolute(value) ? value : path.resolve(value);
+}
+function isPublicPackageLauncher(file) {
+    return (path.basename(file).toLowerCase() === "akm" &&
+        path.basename(path.dirname(file)).toLowerCase() === "dist" &&
+        fs.existsSync(file));
+}
+function isCheckoutLauncher(file) {
+    let launcher = path.resolve(file);
     try {
-        const out = spawnSync(tool, [bin], { encoding: "utf8", env });
-        if (out.status === 0 && typeof out.stdout === "string") {
-            const first = out.stdout
-                .split(/\r?\n/)
-                .map((s) => s.trim())
-                .find(Boolean);
-            if (first && fs.existsSync(first))
-                return first;
-        }
+        launcher = fs.realpathSync(file);
     }
     catch {
-        // ignore — caller will throw a ConfigError
+        // The caller gets a missing-path diagnostic from doctor.
+    }
+    const packageRoot = path.dirname(path.dirname(launcher));
+    return fs.existsSync(path.join(packageRoot, ".git"));
+}
+function packageBelongsToNpmGlobalRoot(launcherPath, npmGlobalRoot) {
+    if (!npmGlobalRoot)
+        return false;
+    try {
+        const packageRoot = path.dirname(path.dirname(fs.realpathSync(launcherPath)));
+        const globalRoot = fs.realpathSync(npmGlobalRoot);
+        const metadata = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+        return metadata.name === "akm-cli" && samePath(path.dirname(packageRoot), globalRoot);
+    }
+    catch {
+        return false;
+    }
+}
+function samePath(left, right) {
+    const normalize = (value) => {
+        const resolved = path.resolve(value);
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    };
+    return normalize(left) === normalize(right);
+}
+function resolveNpmGlobalRoot(nodePath, env) {
+    const npmCli = resolveAssociatedNpmCli(nodePath);
+    if (!npmCli)
+        return undefined;
+    const result = spawnSync(absoluteInvocationPath(nodePath), [npmCli, "root", "--global"], {
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5_000,
+        windowsHide: true,
+    });
+    if (result.status !== 0)
+        return undefined;
+    const lines = result.stdout.trim().split(/\r?\n/);
+    if (lines.length !== 1 || !lines[0] || !path.isAbsolute(lines[0]))
+        return undefined;
+    return lines[0];
+}
+function resolveAssociatedNpmCli(nodePath) {
+    const nodeDirs = new Set([path.dirname(absoluteInvocationPath(nodePath))]);
+    try {
+        nodeDirs.add(path.dirname(fs.realpathSync(nodePath)));
+    }
+    catch {
+        // The scheduler binding will separately report a missing Node path.
+    }
+    for (const binDir of nodeDirs) {
+        const candidates = [
+            ...(process.platform === "win32" ? [] : [path.join(binDir, "npm")]),
+            path.join(binDir, "node_modules", "npm", "bin", "npm-cli.js"),
+            path.join(path.dirname(binDir), "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+        ];
+        for (const candidate of candidates) {
+            try {
+                const resolved = fs.realpathSync(candidate);
+                if (fs.statSync(resolved).isFile())
+                    return resolved;
+            }
+            catch {
+                // Try the next layout associated with this Node installation.
+            }
+        }
     }
     return undefined;
 }