@codex-infinity/pi-infinity 0.52.4 → 0.60.2

package/dist/core/package-manager.js

@@ -7,6 +7,14 @@ import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { parseGitUrl } from "../utils/git.js";
+const NETWORK_TIMEOUT_MS = 10000;
+const UPDATE_CHECK_CONCURRENCY = 4;
+function isOfflineModeEnabled() {
+    const value = process.env.PI_OFFLINE;
+    if (!value)
+        return false;
+    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
 const RESOURCE_TYPES = ["extensions", "skills", "prompts", "themes"];
 const FILE_PATTERNS = {
     extensions: /\.(ts|js)$/,
@@ -18,6 +26,9 @@ const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
 function toPosixPath(p) {
     return p.split(sep).join("/");
 }
+function getHomeDir() {
+    return process.env.HOME || homedir();
+}
 function prefixIgnorePattern(line, prefix) {
     const trimmed = line.trim();
     if (!trimmed)
@@ -376,43 +387,50 @@ function collectResourceFiles(dir, resourceType) {
     return collectFiles(dir, FILE_PATTERNS[resourceType]);
 }
 function matchesAnyPattern(filePath, patterns, baseDir) {
-    const rel = relative(baseDir, filePath);
+    const rel = toPosixPath(relative(baseDir, filePath));
     const name = basename(filePath);
+    const filePathPosix = toPosixPath(filePath);
     const isSkillFile = name === "SKILL.md";
     const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
+    const parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : undefined;
     const parentName = isSkillFile ? basename(parentDir) : undefined;
+    const parentDirPosix = isSkillFile ? toPosixPath(parentDir) : undefined;
     return patterns.some((pattern) => {
-        if (minimatch(rel, pattern) || minimatch(name, pattern) || minimatch(filePath, pattern)) {
+        const normalizedPattern = toPosixPath(pattern);
+        if (minimatch(rel, normalizedPattern) ||
+            minimatch(name, normalizedPattern) ||
+            minimatch(filePathPosix, normalizedPattern)) {
             return true;
         }
         if (!isSkillFile)
             return false;
-        return minimatch(parentRel, pattern) || minimatch(parentName, pattern) || minimatch(parentDir, pattern);
+        return (minimatch(parentRel, normalizedPattern) ||
+            minimatch(parentName, normalizedPattern) ||
+            minimatch(parentDirPosix, normalizedPattern));
     });
 }
 function normalizeExactPattern(pattern) {
-    if (pattern.startsWith("./") || pattern.startsWith(".\\")) {
-        return pattern.slice(2);
-    }
-    return pattern;
+    const normalized = pattern.startsWith("./") || pattern.startsWith(".\\") ? pattern.slice(2) : pattern;
+    return toPosixPath(normalized);
 }
 function matchesAnyExactPattern(filePath, patterns, baseDir) {
     if (patterns.length === 0)
         return false;
-    const rel = relative(baseDir, filePath);
+    const rel = toPosixPath(relative(baseDir, filePath));
     const name = basename(filePath);
+    const filePathPosix = toPosixPath(filePath);
     const isSkillFile = name === "SKILL.md";
     const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
+    const parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : undefined;
+    const parentDirPosix = isSkillFile ? toPosixPath(parentDir) : undefined;
     return patterns.some((pattern) => {
         const normalized = normalizeExactPattern(pattern);
-        if (normalized === rel || normalized === filePath) {
+        if (normalized === rel || normalized === filePathPosix) {
             return true;
         }
         if (!isSkillFile)
             return false;
-        return normalized === parentRel || normalized === parentDir;
+        return normalized === parentRel || normalized === parentDirPosix;
     });
 }
 function getOverridePatterns(entries) {
@@ -493,6 +511,7 @@ export class DefaultPackageManager {
     agentDir;
     settingsManager;
     globalNpmRoot;
+    globalNpmRootCommandKey;
     progressCallback;
     constructor(options) {
         this.cwd = options.cwd;
@@ -573,14 +592,14 @@ export class DefaultPackageManager {
         const accumulator = this.createAccumulator();
         const globalSettings = this.settingsManager.getGlobalSettings();
         const projectSettings = this.settingsManager.getProjectSettings();
-        // Collect all packages with scope
+        // Collect all packages with scope (project first so cwd resources win collisions)
         const allPackages = [];
-        for (const pkg of globalSettings.packages ?? []) {
-            allPackages.push({ pkg, scope: "user" });
-        }
         for (const pkg of projectSettings.packages ?? []) {
             allPackages.push({ pkg, scope: "project" });
         }
+        for (const pkg of globalSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "user" });
+        }
         // Dedupe: project scope wins over global for same package identity
         const packageSources = this.dedupePackages(allPackages);
         await this.resolvePackageSources(packageSources, accumulator, onMissing);
@@ -590,16 +609,16 @@ export class DefaultPackageManager {
             const target = this.getTargetMap(accumulator, resourceType);
             const globalEntries = (globalSettings[resourceType] ?? []);
             const projectEntries = (projectSettings[resourceType] ?? []);
-            this.resolveLocalEntries(globalEntries, resourceType, target, {
-                source: "local",
-                scope: "user",
-                origin: "top-level",
-            }, globalBaseDir);
             this.resolveLocalEntries(projectEntries, resourceType, target, {
                 source: "local",
                 scope: "project",
                 origin: "top-level",
             }, projectBaseDir);
+            this.resolveLocalEntries(globalEntries, resourceType, target, {
+                source: "local",
+                scope: "user",
+                origin: "top-level",
+            }, globalBaseDir);
         }
         this.addAutoDiscoveredResources(accumulator, globalSettings, projectSettings, globalBaseDir, projectBaseDir);
         return this.toResolvedPaths(accumulator);
@@ -669,6 +688,9 @@ export class DefaultPackageManager {
         }
     }
     async updateSourceForScope(source, scope) {
+        if (isOfflineModeEnabled()) {
+            return;
+        }
         const parsed = this.parseSource(source);
         if (parsed.type === "npm") {
             if (parsed.pinned)
@@ -687,6 +709,62 @@ export class DefaultPackageManager {
             return;
         }
     }
+    async checkForAvailableUpdates() {
+        if (isOfflineModeEnabled()) {
+            return [];
+        }
+        const globalSettings = this.settingsManager.getGlobalSettings();
+        const projectSettings = this.settingsManager.getProjectSettings();
+        const allPackages = [];
+        for (const pkg of projectSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "project" });
+        }
+        for (const pkg of globalSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "user" });
+        }
+        const packageSources = this.dedupePackages(allPackages);
+        const checks = packageSources
+            .filter((entry) => entry.scope !== "temporary")
+            .map((entry) => async () => {
+            const source = typeof entry.pkg === "string" ? entry.pkg : entry.pkg.source;
+            const parsed = this.parseSource(source);
+            if (parsed.type === "local" || parsed.pinned) {
+                return undefined;
+            }
+            if (parsed.type === "npm") {
+                const installedPath = this.getNpmInstallPath(parsed, entry.scope);
+                if (!existsSync(installedPath)) {
+                    return undefined;
+                }
+                const hasUpdate = await this.npmHasAvailableUpdate(parsed, installedPath);
+                if (!hasUpdate) {
+                    return undefined;
+                }
+                return {
+                    source,
+                    displayName: parsed.name,
+                    type: "npm",
+                    scope: entry.scope,
+                };
+            }
+            const installedPath = this.getGitInstallPath(parsed, entry.scope);
+            if (!existsSync(installedPath)) {
+                return undefined;
+            }
+            const hasUpdate = await this.gitHasAvailableUpdate(installedPath);
+            if (!hasUpdate) {
+                return undefined;
+            }
+            return {
+                source,
+                displayName: `${parsed.host}/${parsed.path}`,
+                type: "git",
+                scope: entry.scope,
+            };
+        });
+        const results = await this.runWithConcurrency(checks, UPDATE_CHECK_CONCURRENCY);
+        return results.filter((result) => result !== undefined);
+    }
     async resolvePackageSources(sources, accumulator, onMissing) {
         for (const { pkg, scope } of sources) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
@@ -699,6 +777,9 @@ export class DefaultPackageManager {
                 continue;
             }
             const installMissing = async () => {
+                if (isOfflineModeEnabled()) {
+                    return false;
+                }
                 if (!onMissing) {
                     await this.installParsedSource(parsed, scope);
                     return true;
@@ -713,7 +794,8 @@ export class DefaultPackageManager {
             };
             if (parsed.type === "npm") {
                 const installedPath = this.getNpmInstallPath(parsed, scope);
-                const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
+                const needsInstall = !existsSync(installedPath) ||
+                    (parsed.pinned && !(await this.installedNpmMatchesPinnedVersion(parsed, installedPath)));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
@@ -730,7 +812,7 @@ export class DefaultPackageManager {
                     if (!installed)
                         continue;
                 }
-                else if (scope === "temporary" && !parsed.pinned) {
+                else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
                     await this.refreshTemporaryGitSource(parsed, sourceStr);
                 }
                 metadata.baseDir = installedPath;
@@ -839,27 +921,30 @@ export class DefaultPackageManager {
         }
         return { type: "local", path: source };
     }
-    /**
-     * Check if an npm package needs to be updated.
-     * - For unpinned packages: check if registry has a newer version
-     * - For pinned packages: check if installed version matches the pinned version
-     */
-    async npmNeedsUpdate(source, installedPath) {
+    async installedNpmMatchesPinnedVersion(source, installedPath) {
         const installedVersion = this.getInstalledNpmVersion(installedPath);
-        if (!installedVersion)
-            return true;
+        if (!installedVersion) {
+            return false;
+        }
         const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
-        if (pinnedVersion) {
-            // Pinned: check if installed matches pinned (exact match for now)
-            return installedVersion !== pinnedVersion;
+        if (!pinnedVersion) {
+            return true;
+        }
+        return installedVersion === pinnedVersion;
+    }
+    async npmHasAvailableUpdate(source, installedPath) {
+        if (isOfflineModeEnabled()) {
+            return false;
+        }
+        const installedVersion = this.getInstalledNpmVersion(installedPath);
+        if (!installedVersion) {
+            return false;
         }
-        // Unpinned: check registry for latest version
         try {
             const latestVersion = await this.getLatestNpmVersion(source.name);
             return latestVersion !== installedVersion;
         }
         catch {
-            // If we can't check registry, assume it's fine
             return false;
         }
     }
@@ -877,12 +962,92 @@ export class DefaultPackageManager {
         }
     }
     async getLatestNpmVersion(packageName) {
-        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+        });
         if (!response.ok)
             throw new Error(`Failed to fetch npm registry: ${response.status}`);
         const data = (await response.json());
         return data.version;
     }
+    async gitHasAvailableUpdate(installedPath) {
+        if (isOfflineModeEnabled()) {
+            return false;
+        }
+        try {
+            const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const remoteHead = await this.getRemoteGitHead(installedPath);
+            return localHead.trim() !== remoteHead.trim();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getRemoteGitHead(installedPath) {
+        const upstreamRef = await this.getGitUpstreamRef(installedPath);
+        if (upstreamRef) {
+            const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", upstreamRef]);
+            const match = remoteHead.match(/^([0-9a-f]{40})\s+/m);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+        const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", "HEAD"]);
+        const match = remoteHead.match(/^([0-9a-f]{40})\s+HEAD$/m);
+        if (!match?.[1]) {
+            throw new Error("Failed to determine remote HEAD");
+        }
+        return match[1];
+    }
+    async getGitUpstreamRef(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmed = upstream.trim();
+            if (!trimmed.startsWith("origin/")) {
+                return undefined;
+            }
+            const branch = trimmed.slice("origin/".length);
+            return branch ? `refs/heads/${branch}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    runGitRemoteCommand(installedPath, args) {
+        return this.runCommandCapture("git", args, {
+            cwd: installedPath,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+            env: {
+                GIT_TERMINAL_PROMPT: "0",
+            },
+        });
+    }
+    async runWithConcurrency(tasks, limit) {
+        if (tasks.length === 0) {
+            return [];
+        }
+        const results = new Array(tasks.length);
+        let nextIndex = 0;
+        const workerCount = Math.max(1, Math.min(limit, tasks.length));
+        const worker = async () => {
+            while (true) {
+                const index = nextIndex;
+                nextIndex += 1;
+                if (index >= tasks.length) {
+                    return;
+                }
+                results[index] = await tasks[index]();
+            }
+        };
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        return results;
+    }
     /**
      * Get a unique identity for a package, ignoring version/ref.
      * Used to detect when the same package is in both global and project settings.
@@ -935,25 +1100,44 @@ export class DefaultPackageManager {
         const version = match[2];
         return { name, version };
     }
+    getNpmCommand() {
+        const configuredCommand = this.settingsManager.getNpmCommand();
+        if (!configuredCommand || configuredCommand.length === 0) {
+            return { command: "npm", args: [] };
+        }
+        const [command, ...args] = configuredCommand;
+        if (!command) {
+            throw new Error("Invalid npmCommand: first array entry must be a non-empty command");
+        }
+        return { command, args };
+    }
+    async runNpmCommand(args, options) {
+        const npmCommand = this.getNpmCommand();
+        await this.runCommand(npmCommand.command, [...npmCommand.args, ...args], options);
+    }
+    runNpmCommandSync(args) {
+        const npmCommand = this.getNpmCommand();
+        return this.runCommandSync(npmCommand.command, [...npmCommand.args, ...args]);
+    }
     async installNpm(source, scope, temporary) {
         if (scope === "user" && !temporary) {
-            await this.runCommand("npm", ["install", "-g", source.spec]);
+            await this.runNpmCommand(["install", "-g", source.spec]);
             return;
         }
         const installRoot = this.getNpmInstallRoot(scope, temporary);
         this.ensureNpmProject(installRoot);
-        await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot]);
+        await this.runNpmCommand(["install", source.spec, "--prefix", installRoot]);
     }
     async uninstallNpm(source, scope) {
         if (scope === "user") {
-            await this.runCommand("npm", ["uninstall", "-g", source.name]);
+            await this.runNpmCommand(["uninstall", "-g", source.name]);
             return;
         }
         const installRoot = this.getNpmInstallRoot(scope, false);
         if (!existsSync(installRoot)) {
             return;
         }
-        await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
+        await this.runNpmCommand(["uninstall", source.name, "--prefix", installRoot]);
     }
     async installGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
@@ -971,7 +1155,7 @@ export class DefaultPackageManager {
         }
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
-            await this.runCommand("npm", ["install"], { cwd: targetDir });
+            await this.runNpmCommand(["install"], { cwd: targetDir });
         }
     }
     async updateGit(source, scope) {
@@ -994,10 +1178,13 @@ export class DefaultPackageManager {
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
-            await this.runCommand("npm", ["install"], { cwd: targetDir });
+            await this.runNpmCommand(["install"], { cwd: targetDir });
         }
     }
     async refreshTemporaryGitSource(source, sourceStr) {
+        if (isOfflineModeEnabled()) {
+            return;
+        }
         try {
             await this.withProgress("pull", sourceStr, `Refreshing ${sourceStr}...`, async () => {
                 await this.updateGit(source, "temporary");
@@ -1067,11 +1254,14 @@ export class DefaultPackageManager {
         return join(this.getGlobalNpmRoot(), "..");
     }
     getGlobalNpmRoot() {
-        if (this.globalNpmRoot) {
+        const npmCommand = this.getNpmCommand();
+        const commandKey = [npmCommand.command, ...npmCommand.args].join("\0");
+        if (this.globalNpmRoot && this.globalNpmRootCommandKey === commandKey) {
             return this.globalNpmRoot;
         }
-        const result = this.runCommandSync("npm", ["root", "-g"]);
+        const result = this.runNpmCommandSync(["root", "-g"]);
         this.globalNpmRoot = result.trim();
+        this.globalNpmRootCommandKey = commandKey;
         return this.globalNpmRoot;
     }
     getNpmInstallPath(source, scope) {
@@ -1120,21 +1310,21 @@ export class DefaultPackageManager {
     resolvePath(input) {
         const trimmed = input.trim();
         if (trimmed === "~")
-            return homedir();
+            return getHomeDir();
         if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
+            return join(getHomeDir(), trimmed.slice(2));
         if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
+            return join(getHomeDir(), trimmed.slice(1));
         return resolve(this.cwd, trimmed);
     }
     resolvePathFromBase(input, baseDir) {
         const trimmed = input.trim();
         if (trimmed === "~")
-            return homedir();
+            return getHomeDir();
         if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
+            return join(getHomeDir(), trimmed.slice(2));
         if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
+            return join(getHomeDir(), trimmed.slice(1));
         return resolve(baseDir, trimmed);
     }
     collectPackageResources(packageRoot, accumulator, filter, metadata) {
@@ -1308,8 +1498,8 @@ export class DefaultPackageManager {
             prompts: join(projectBaseDir, "prompts"),
             themes: join(projectBaseDir, "themes"),
         };
-        const userAgentsSkillsDir = join(homedir(), ".agents", "skills");
-        const projectAgentsSkillDirs = collectAncestorAgentsSkillDirs(this.cwd);
+        const userAgentsSkillsDir = join(getHomeDir(), ".agents", "skills");
+        const projectAgentsSkillDirs = collectAncestorAgentsSkillDirs(this.cwd).filter((dir) => resolve(dir) !== resolve(userAgentsSkillsDir));
         const addResources = (resourceType, paths, metadata, overrides, baseDir) => {
             const target = this.getTargetMap(accumulator, resourceType);
             for (const path of paths) {
@@ -1317,10 +1507,6 @@ export class DefaultPackageManager {
                 this.addResource(target, path, metadata, enabled);
             }
         };
-        addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
-        addResources("skills", [...collectAutoSkillEntries(userDirs.skills), ...collectAutoSkillEntries(userAgentsSkillsDir)], userMetadata, userOverrides.skills, globalBaseDir);
-        addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
-        addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
         addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
         addResources("skills", [
             ...collectAutoSkillEntries(projectDirs.skills),
@@ -1328,6 +1514,10 @@ export class DefaultPackageManager {
         ], projectMetadata, projectOverrides.skills, projectBaseDir);
         addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
         addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir);
+        addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
+        addResources("skills", [...collectAutoSkillEntries(userDirs.skills), ...collectAutoSkillEntries(userAgentsSkillsDir)], userMetadata, userOverrides.skills, globalBaseDir);
+        addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
+        addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
     }
     collectFilesFromPaths(paths, resourceType) {
         const files = [];
@@ -1393,6 +1583,49 @@ export class DefaultPackageManager {
             themes: toResolved(accumulator.themes),
         };
     }
+    runCommandCapture(command, args, options) {
+        return new Promise((resolvePromise, reject) => {
+            const child = spawn(command, args, {
+                cwd: options?.cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                shell: process.platform === "win32",
+                env: options?.env ? { ...process.env, ...options.env } : process.env,
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timeout = typeof options?.timeoutMs === "number"
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill();
+                }, options.timeoutMs)
+                : undefined;
+            child.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            child.on("error", (error) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(error);
+            });
+            child.on("exit", (code) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                if (timedOut) {
+                    reject(new Error(`${command} ${args.join(" ")} timed out after ${options?.timeoutMs}ms`));
+                    return;
+                }
+                if (code === 0) {
+                    resolvePromise(stdout.trim());
+                    return;
+                }
+                reject(new Error(`${command} ${args.join(" ")} failed with code ${code}: ${stderr || stdout}`));
+            });
+        });
+    }
     runCommand(command, args, options) {
         return new Promise((resolvePromise, reject) => {
             const child = spawn(command, args, {