@bastani/atomic 0.8.13-0 → 0.8.14-0

package/dist/core/package-manager.js

@@ -27,7 +27,7 @@ import { minimatch } from "minimatch";
 import { APP_NAME, CONFIG_DIR_NAME, ENV_OFFLINE, getAgentDir, getAgentDirs, getEnvValue, getProjectConfigDirs } from "../config.js";
 import { spawnProcess, spawnProcessSync } from "../utils/child-process.js";
 import { parseGitUrl } from "../utils/git.js";
-import { canonicalizePath, isLocalPath } from "../utils/paths.js";
+import { canonicalizePath, isLocalPath, markPathIgnoredByCloudSync, resolvePath } from "../utils/paths.js";
 import { isStdoutTakenOver } from "./output-guard.js";
 const NETWORK_TIMEOUT_MS = 10000;
 const UPDATE_CHECK_CONCURRENCY = 4;
@@ -596,8 +596,8 @@ function applyPatterns(allPaths, patterns, baseDir) {
 }
 export class DefaultPackageManager {
     constructor(options) {
-        this.cwd = options.cwd;
-        this.agentDir = options.agentDir;
+        this.cwd = resolvePath(options.cwd);
+        this.agentDir = resolvePath(options.agentDir);
         this.settingsManager = options.settingsManager;
     }
     setProgressCallback(callback) {
@@ -608,9 +608,22 @@ export class DefaultPackageManager {
         const currentSettings = scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings();
         const currentPackages = currentSettings.packages ?? [];
         const normalizedSource = this.normalizePackageSourceForSettings(source, scope);
-        const exists = currentPackages.some((existing) => this.packageSourcesMatch(existing, source, scope));
-        if (exists) {
-            return false;
+        const matchIndex = currentPackages.findIndex((existing) => this.packageSourcesMatch(existing, source, scope));
+        if (matchIndex !== -1) {
+            const existing = currentPackages[matchIndex];
+            if (this.getPackageSourceString(existing) === normalizedSource) {
+                return false;
+            }
+            const nextPackages = [...currentPackages];
+            nextPackages[matchIndex] =
+                typeof existing === "string" ? normalizedSource : { ...existing, source: normalizedSource };
+            if (scope === "project") {
+                this.settingsManager.setProjectPackages(nextPackages);
+            }
+            else {
+                this.settingsManager.setPackages(nextPackages);
+            }
+            return true;
         }
         const nextPackages = [...currentPackages, normalizedSource];
         if (scope === "project") {
@@ -859,14 +872,16 @@ export class DefaultPackageManager {
         const gitCandidates = [];
         for (const entry of sources) {
             const parsed = this.parseSource(entry.source);
-            if (parsed.type === "local" || parsed.pinned) {
-                continue;
-            }
+            // Pinned npm versions are fixed. Pinned git refs are configured checkout targets,
+            // so include them to reconcile an existing clone when the configured ref changes.
             if (parsed.type === "npm") {
-                npmCandidates.push({ ...entry, parsed });
-                continue;
+                if (!parsed.pinned) {
+                    npmCandidates.push({ ...entry, parsed });
+                }
+            }
+            else if (parsed.type === "git") {
+                gitCandidates.push({ ...entry, parsed });
             }
-            gitCandidates.push({ ...entry, parsed });
         }
         const npmCheckTasks = npmCandidates.map((entry) => async () => ({
             entry,
@@ -902,8 +917,8 @@ export class DefaultPackageManager {
         await Promise.all(tasks);
     }
     async shouldUpdateNpmSource(source, scope) {
-        const installedPath = this.getExistingNpmInstallPath(source, scope);
-        const installedVersion = installedPath ? this.getInstalledNpmVersion(installedPath) : undefined;
+        const installedPath = this.getManagedNpmInstallPath(source, scope);
+        const installedVersion = existsSync(installedPath) ? this.getInstalledNpmVersion(installedPath) : undefined;
         if (!installedVersion) {
             return true;
         }
@@ -928,13 +943,9 @@ export class DefaultPackageManager {
         });
     }
     async installNpmBatch(specs, scope) {
-        if (scope === "user") {
-            await this.runNpmCommand(["install", "-g", ...specs]);
-            return;
-        }
         const installRoot = this.getNpmInstallRoot(scope, false);
         this.ensureNpmProject(installRoot);
-        await this.runNpmCommand(["install", ...specs, "--prefix", installRoot]);
+        await this.runNpmCommand(this.getNpmInstallArgs(specs, installRoot));
     }
     async checkForAvailableUpdates() {
         if (isOfflineModeEnabled()) {
@@ -959,8 +970,8 @@ export class DefaultPackageManager {
                 return undefined;
             }
             if (parsed.type === "npm") {
-                const installedPath = this.getExistingNpmInstallPath(parsed, entry.scope);
-                if (!installedPath) {
+                const installedPath = this.getNpmInstallPath(parsed, entry.scope);
+                if (!existsSync(installedPath)) {
                     return undefined;
                 }
                 const hasUpdate = await this.npmHasAvailableUpdate(parsed, installedPath);
@@ -1426,6 +1437,13 @@ export class DefaultPackageManager {
         }
         return { command, args };
     }
+    getPackageManagerName() {
+        const npmCommand = this.getNpmCommand();
+        const commandParts = [npmCommand.command, ...npmCommand.args];
+        const separatorIndex = commandParts.lastIndexOf("--");
+        const packageManagerCommand = separatorIndex >= 0 ? commandParts[separatorIndex + 1] : npmCommand.command;
+        return packageManagerCommand ? basename(packageManagerCommand).replace(/\.(cmd|exe)$/i, "") : "";
+    }
     async runNpmCommand(args, options) {
         const npmCommand = this.getNpmCommand();
         await this.runCommand(npmCommand.command, [...npmCommand.args, ...args], options);
@@ -1441,29 +1459,74 @@ export class DefaultPackageManager {
         const npmCommand = this.getNpmCommand();
         return this.runCommandSync(npmCommand.command, [...npmCommand.args, ...args]);
     }
+    getNpmInstallArgs(specs, installRoot) {
+        const packageManagerName = this.getPackageManagerName();
+        // Extension packages run inside Atomic and resolve pi APIs through loader aliases/virtual modules.
+        // Disable peer dependency resolution for managed installs (npm's --legacy-peer-deps, and
+        // equivalent bun/pnpm settings) so package managers do not install or solve host-provided
+        // @earendil-works/pi-* peers. Stale auto-installed pi peers can otherwise block updates.
+        if (packageManagerName === "bun") {
+            return ["install", ...specs, "--cwd", installRoot, "--omit=peer"];
+        }
+        if (packageManagerName === "pnpm") {
+            return [
+                "install",
+                ...specs,
+                "--prefix",
+                installRoot,
+                "--config.auto-install-peers=false",
+                "--config.strict-peer-dependencies=false",
+                "--config.strict-dep-builds=false",
+            ];
+        }
+        return ["install", ...specs, "--prefix", installRoot, "--legacy-peer-deps"];
+    }
     async installNpm(source, scope, temporary) {
-        if (scope === "user" && !temporary) {
-            await this.runNpmCommand(["install", "-g", source.spec]);
-            return;
-        }
         const installRoot = this.getNpmInstallRoot(scope, temporary);
         this.ensureNpmProject(installRoot);
-        await this.runNpmCommand(["install", source.spec, "--prefix", installRoot]);
+        await this.runNpmCommand(this.getNpmInstallArgs([source.spec], installRoot));
     }
     async uninstallNpm(source, scope) {
-        if (scope === "user") {
-            await this.runNpmCommand(["uninstall", "-g", source.name]);
-            return;
-        }
         const installRoot = this.getNpmInstallRoot(scope, false);
         if (!existsSync(installRoot)) {
             return;
         }
+        if (this.getPackageManagerName() === "bun") {
+            await this.runNpmCommand(["uninstall", source.name, "--cwd", installRoot]);
+            return;
+        }
         await this.runNpmCommand(["uninstall", source.name, "--prefix", installRoot]);
     }
+    getSafeGitRef(ref) {
+        if (!this.isSafeGitRef(ref)) {
+            throw new Error(`Invalid git ref: ${JSON.stringify(ref)}`);
+        }
+        return ref;
+    }
+    isSafeGitRef(ref) {
+        if (!ref || ref === "@" || ref.startsWith("-") || ref.endsWith(".") || ref.endsWith("/")) {
+            return false;
+        }
+        if (/[\x00-\x1f\x7f\s~^:?*\[\]\\]/u.test(ref)) {
+            return false;
+        }
+        if (ref.includes("..") || ref.includes("@{") || ref.includes("//")) {
+            return false;
+        }
+        return ref
+            .split("/")
+            .every((part) => part && part !== "." && part !== ".." && !part.startsWith(".") && !part.endsWith(".lock"));
+    }
     async installGit(source, scope) {
+        const safeRef = source.ref ? this.getSafeGitRef(source.ref) : undefined;
         const targetDir = this.getGitInstallPath(source, scope);
         if (existsSync(targetDir)) {
+            if (safeRef) {
+                await this.ensureGitRef(targetDir, ["fetch", "origin", "--", safeRef], "FETCH_HEAD");
+                return;
+            }
+            const target = await this.getLocalGitUpdateTarget(targetDir);
+            await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
             return;
         }
         const gitRoot = this.getGitInstallRoot(scope);
@@ -1472,8 +1535,8 @@ export class DefaultPackageManager {
         }
         mkdirSync(dirname(targetDir), { recursive: true });
         await this.runCommand("git", ["clone", "--", source.repo, targetDir]);
-        if (source.ref) {
-            await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir });
+        if (safeRef) {
+            await this.runCommand("git", ["checkout", safeRef], { cwd: targetDir });
         }
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
@@ -1481,26 +1544,35 @@ export class DefaultPackageManager {
         }
     }
     async updateGit(source, scope) {
+        const safeRef = source.ref ? this.getSafeGitRef(source.ref) : undefined;
         const targetDir = this.getExistingGitInstallPath(source, scope) ?? this.getGitInstallPath(source, scope);
         if (!existsSync(targetDir)) {
             await this.installGit(source, scope);
             return;
         }
+        if (safeRef) {
+            await this.ensureGitRef(targetDir, ["fetch", "origin", "--", safeRef], "FETCH_HEAD");
+            return;
+        }
         const target = await this.getLocalGitUpdateTarget(targetDir);
+        await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
+    }
+    async ensureGitRef(targetDir, fetchArgs, ref) {
         // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
-        await this.runCommand("git", target.fetchArgs, { cwd: targetDir });
+        await this.runCommand("git", fetchArgs, { cwd: targetDir });
         const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        const refreshedTargetHead = await this.runCommandCapture("git", ["rev-parse", target.ref], {
+        const commitRef = `${ref}^{commit}`;
+        const targetHead = await this.runCommandCapture("git", ["rev-parse", commitRef], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        if (localHead.trim() === refreshedTargetHead.trim()) {
+        if (localHead.trim() === targetHead.trim()) {
             return;
         }
-        await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });
+        await this.runCommand("git", ["reset", "--hard", commitRef], { cwd: targetDir });
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
@@ -1555,6 +1627,7 @@ export class DefaultPackageManager {
         if (!existsSync(installRoot)) {
             mkdirSync(installRoot, { recursive: true });
         }
+        markPathIgnoredByCloudSync(installRoot);
         this.ensureGitIgnore(installRoot);
         const packageJsonPath = join(installRoot, "package.json");
         if (!existsSync(packageJsonPath)) {
@@ -1578,7 +1651,7 @@ export class DefaultPackageManager {
         if (scope === "project") {
             return join(this.cwd, CONFIG_DIR_NAME, "npm");
         }
-        return join(this.getGlobalNpmRoot(), "..");
+        return join(this.agentDir, "npm");
     }
     getGlobalNpmRoot() {
         const npmCommand = this.getNpmCommand();
@@ -1586,8 +1659,7 @@ export class DefaultPackageManager {
         if (this.globalNpmRoot && this.globalNpmRootCommandKey === commandKey) {
             return this.globalNpmRoot;
         }
-        const isBunPackageManager = npmCommand.command === "bun";
-        if (isBunPackageManager) {
+        if (this.getPackageManagerName() === "bun") {
             const binDir = this.runNpmCommandSync(["pm", "bin", "-g"]).trim();
             this.globalNpmRoot = join(dirname(binDir), "install", "global", "node_modules");
         }
@@ -1597,14 +1669,43 @@ export class DefaultPackageManager {
         this.globalNpmRootCommandKey = commandKey;
         return this.globalNpmRoot;
     }
-    getNpmInstallPath(source, scope) {
+    getPnpmGlobalPackagePath(packageName) {
+        if (this.getPackageManagerName() !== "pnpm") {
+            return undefined;
+        }
+        const output = this.runNpmCommandSync(["list", "-g", "--depth", "0", "--json"]);
+        const entries = JSON.parse(output);
+        for (const entry of entries) {
+            const path = entry.dependencies?.[packageName]?.path;
+            if (path)
+                return path;
+        }
+        return undefined;
+    }
+    getManagedNpmInstallPath(source, scope) {
         if (scope === "temporary") {
             return join(this.getTemporaryDir("npm"), "node_modules", source.name);
         }
         if (scope === "project") {
             return join(this.cwd, CONFIG_DIR_NAME, "npm", "node_modules", source.name);
         }
-        return join(this.getGlobalNpmRoot(), source.name);
+        return join(this.agentDir, "npm", "node_modules", source.name);
+    }
+    getLegacyGlobalNpmInstallPath(source) {
+        try {
+            return this.getPnpmGlobalPackagePath(source.name) ?? join(this.getGlobalNpmRoot(), source.name);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getNpmInstallPath(source, scope) {
+        const managedPath = this.getManagedNpmInstallPath(source, scope);
+        if (scope !== "user" || existsSync(managedPath)) {
+            return managedPath;
+        }
+        const legacyPath = this.getLegacyGlobalNpmInstallPath(source);
+        return legacyPath && existsSync(legacyPath) ? legacyPath : managedPath;
     }
     getGitInstallPath(source, scope) {
         if (scope === "temporary") {
@@ -1629,7 +1730,7 @@ export class DefaultPackageManager {
             .update(`${prefix}-${suffix ?? ""}`)
             .digest("hex")
             .slice(0, 8);
-        return join(tmpdir(), "pi-extensions", prefix, hash, suffix ?? "");
+        return join(tmpdir(), `${APP_NAME}-extensions`, prefix, hash, suffix ?? "");
     }
     getBaseDirForScope(scope) {
         return this.getBaseDirsForScope(scope)[0];
@@ -1644,24 +1745,10 @@ export class DefaultPackageManager {
         return [this.cwd];
     }
     resolvePath(input) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return getHomeDir();
-        if (trimmed.startsWith("~/"))
-            return join(getHomeDir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(getHomeDir(), trimmed.slice(1));
-        return resolve(this.cwd, trimmed);
+        return resolvePath(input, this.cwd, { homeDir: getHomeDir(), trim: true });
     }
     resolvePathFromBase(input, baseDir) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return getHomeDir();
-        if (trimmed.startsWith("~/"))
-            return join(getHomeDir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(getHomeDir(), trimmed.slice(1));
-        return resolve(baseDir, trimmed);
+        return resolvePath(input, baseDir, { homeDir: getHomeDir(), trim: true });
     }
     collectPackageResources(packageRoot, accumulator, filter, metadata) {
         if (filter) {