@sheason/pi-coding-agent 0.74.1-sheason.0 → 0.78.0-sheason.0.6.0-alpha.2

package/dist/core/package-manager.js

@@ -1,4 +1,3 @@
-import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -26,9 +25,9 @@ import { globSync } from "glob";
 import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
-import { shouldUseWindowsShell } from "../utils/child-process.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;
@@ -578,8 +577,8 @@ export class DefaultPackageManager {
     globalNpmRootCommandKey;
     progressCallback;
     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) {
@@ -590,9 +589,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") {
@@ -802,14 +814,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,
@@ -845,7 +859,7 @@ export class DefaultPackageManager {
         await Promise.all(tasks);
     }
     async shouldUpdateNpmSource(source, scope) {
-        const installedPath = this.getNpmInstallPath(source, scope);
+        const installedPath = this.getManagedNpmInstallPath(source, scope);
         const installedVersion = existsSync(installedPath) ? this.getInstalledNpmVersion(installedPath) : undefined;
         if (!installedVersion) {
             return true;
@@ -871,13 +885,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()) {
@@ -963,13 +973,14 @@ export class DefaultPackageManager {
                 return true;
             };
             if (parsed.type === "npm") {
-                const installedPath = this.getNpmInstallPath(parsed, scope);
+                let installedPath = this.getNpmInstallPath(parsed, scope);
                 const needsInstall = !existsSync(installedPath) ||
                     (parsed.pinned && !(await this.installedNpmMatchesPinnedVersion(parsed, installedPath)));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
                         continue;
+                    installedPath = this.getNpmInstallPath(parsed, scope);
                 }
                 metadata.baseDir = installedPath;
                 this.collectPackageResources(installedPath, accumulator, filter, metadata);
@@ -1363,6 +1374,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);
@@ -1378,29 +1396,53 @@ 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 pi 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]);
     }
     async installGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
         if (existsSync(targetDir)) {
+            if (source.ref) {
+                await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "FETCH_HEAD");
+                return;
+            }
+            const target = await this.getLocalGitUpdateTarget(targetDir);
+            await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
             return;
         }
         const gitRoot = this.getGitInstallRoot(scope);
@@ -1423,21 +1465,29 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
+        if (source.ref) {
+            await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "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");
@@ -1492,6 +1542,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)) {
@@ -1515,7 +1566,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();
@@ -1523,8 +1574,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");
         }
@@ -1534,14 +1584,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") {
@@ -1578,24 +1657,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) {
@@ -1890,20 +1955,20 @@ export class DefaultPackageManager {
         };
     }
     spawnCommand(command, args, options) {
-        return spawn(command, args, {
+        const env = getEnv();
+        return spawnProcess(command, args, {
             cwd: options?.cwd,
             stdio: isStdoutTakenOver() ? ["ignore", 2, 2] : "inherit",
-            shell: shouldUseWindowsShell(command),
-            env: getEnv(),
+            env,
         });
     }
     spawnCaptureCommand(command, args, options) {
         const baseEnv = getEnv();
-        return spawn(command, args, {
+        const env = options?.env ? { ...baseEnv, ...options.env } : baseEnv;
+        return spawnProcess(command, args, {
             cwd: options?.cwd,
             stdio: ["ignore", "pipe", "pipe"],
-            shell: shouldUseWindowsShell(command),
-            env: options?.env ? { ...baseEnv, ...options.env } : baseEnv,
+            env,
         });
     }
     runCommandCapture(command, args, options) {
@@ -1960,11 +2025,11 @@ export class DefaultPackageManager {
         });
     }
     runCommandSync(command, args) {
-        const result = spawnSync(command, args, {
+        const env = getEnv();
+        const result = spawnProcessSync(command, args, {
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
-            shell: shouldUseWindowsShell(command),
-            env: getEnv(),
+            env,
         });
         if (result.error || result.status !== 0) {
             throw new Error(`Failed to run ${command} ${args.join(" ")}: ${result.error?.message || result.stderr || result.stdout}`);