iosm-cli 0.2.14 → 0.2.16

package/dist/core/package-manager.js

@@ -7,6 +7,7 @@ import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME, ENV_OFFLINE } from "../config.js";
 import { parseGitUrl } from "../utils/git.js";
+import { SourceSecurityManager } from "./security/index.js";
 const NETWORK_TIMEOUT_MS = 10000;
 function isOfflineModeEnabled() {
     const value = process.env[ENV_OFFLINE] || process.env.PI_OFFLINE;
@@ -500,6 +501,14 @@ export class DefaultPackageManager {
         this.cwd = options.cwd;
         this.agentDir = options.agentDir;
         this.settingsManager = options.settingsManager;
+        this.sourceSecurityManager =
+            options.sourceSecurityManager ??
+                new SourceSecurityManager({
+                    agentDir: this.agentDir,
+                    allowedHosts: options.allowedSourceHosts,
+                    consentProvider: options.trustConsentProvider,
+                });
+        this.allowNonInteractiveTrustOverride = options.allowNonInteractiveTrustOverride ?? false;
     }
     setProgressCallback(callback) {
         this.progressCallback = callback;
@@ -679,7 +688,7 @@ export class DefaultPackageManager {
             if (parsed.pinned)
                 return;
             await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.installNpm(parsed, scope, false);
+                await this.installNpm(parsed, scope, false, "update");
             });
             return;
         }
@@ -948,7 +957,92 @@ export class DefaultPackageManager {
         const version = match[2];
         return { name, version };
     }
-    async installNpm(source, scope, temporary) {
+    async ensureSourceTrust(sourceRaw, parsed, action, options) {
+        if (parsed.type === "local") {
+            return;
+        }
+        if (parsed.type === "npm") {
+            const fingerprint = await this.resolveNpmFingerprint(parsed);
+            await this.sourceSecurityManager.verify({
+                action,
+                sourceType: "npm",
+                source: sourceRaw,
+                identity: fingerprint.identity,
+                host: fingerprint.host,
+                fingerprint: fingerprint.fingerprint,
+                allowOverride: this.allowNonInteractiveTrustOverride,
+            });
+            return;
+        }
+        const gitFingerprint = this.resolveGitFingerprint(parsed, options?.repositoryDir);
+        await this.sourceSecurityManager.verify({
+            action,
+            sourceType: "git",
+            source: sourceRaw,
+            identity: gitFingerprint.identity,
+            host: gitFingerprint.host,
+            fingerprint: gitFingerprint.fingerprint,
+            allowOverride: this.allowNonInteractiveTrustOverride,
+        });
+    }
+    async resolveNpmFingerprint(source) {
+        const { name, version } = this.parseNpmSpec(source.spec);
+        const encodedName = encodeURIComponent(name).replace("%40", "@");
+        const endpoint = version
+            ? `https://registry.npmjs.org/${encodedName}/${encodeURIComponent(version)}`
+            : `https://registry.npmjs.org/${encodedName}/latest`;
+        const response = await fetch(endpoint, {
+            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to resolve npm package metadata for ${name}: ${response.status}`);
+        }
+        const payload = (await response.json());
+        const resolvedName = payload.name ?? name;
+        const resolvedVersion = payload.version ?? version ?? "unknown";
+        const integrity = payload.dist?.integrity?.trim();
+        const tarball = payload.dist?.tarball?.trim();
+        if (!integrity && !tarball) {
+            throw new Error(`npm integrity metadata is missing for ${resolvedName}@${resolvedVersion}`);
+        }
+        return {
+            identity: `${resolvedName}@${resolvedVersion}`,
+            fingerprint: integrity ?? `tarball:${tarball}`,
+            host: "registry.npmjs.org",
+        };
+    }
+    resolveGitFingerprint(source, repositoryDir) {
+        let lsRemote;
+        if (repositoryDir && existsSync(join(repositoryDir, ".git"))) {
+            lsRemote = spawnSync("git", ["ls-remote", "origin", "HEAD"], {
+                encoding: "utf8",
+                timeout: NETWORK_TIMEOUT_MS,
+                cwd: repositoryDir,
+            });
+        }
+        if (!lsRemote || lsRemote.status !== 0) {
+            lsRemote = spawnSync("git", ["ls-remote", source.repo, "HEAD"], {
+                encoding: "utf8",
+                timeout: NETWORK_TIMEOUT_MS,
+            });
+        }
+        if (lsRemote.status !== 0) {
+            const stderr = typeof lsRemote.stderr === "string" ? lsRemote.stderr.trim() : "";
+            throw new Error(`Failed to resolve git fingerprint for ${source.repo}: ${stderr || "git ls-remote failed"}`);
+        }
+        const output = typeof lsRemote.stdout === "string" ? lsRemote.stdout.trim() : "";
+        const commit = output.split(/\s+/)[0];
+        if (!commit) {
+            throw new Error(`Failed to parse git fingerprint for ${source.repo}`);
+        }
+        return {
+            identity: `${source.host}/${source.path}`,
+            fingerprint: commit,
+            host: source.host.toLowerCase(),
+        };
+    }
+    async installNpm(source, scope, temporary, action = "install") {
+        await this.ensureSourceTrust(`npm:${source.spec}`, source, action);
         if (scope === "user" && !temporary) {
             await this.runCommand("npm", ["install", "-g", source.spec]);
             return;
@@ -969,6 +1063,7 @@ export class DefaultPackageManager {
         await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
     }
     async installGit(source, scope) {
+        await this.ensureSourceTrust(source.repo, source, "install");
         const targetDir = this.getGitInstallPath(source, scope);
         if (existsSync(targetDir)) {
             return;
@@ -993,6 +1088,9 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
+        if (scope !== "temporary") {
+            await this.ensureSourceTrust(source.repo, source, "update", { repositoryDir: targetDir });
+        }
         // Fetch latest from remote (handles force-push by getting new history)
         await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
         // Reset to tracking branch. Fall back to origin/HEAD when no upstream is configured.