akm-cli 0.0.20 → 0.0.22

package/dist/registry-install.js

@@ -5,8 +5,10 @@ import path from "node:path";
 import { TYPE_DIRS } from "./asset-spec";
 import { fetchWithRetry, isWithin } from "./common";
 import { loadConfig, saveConfig } from "./config";
+import { copyIncludedPaths, findNearestIncludeConfig } from "./kit-include";
 import { getRegistryCacheDir as _getRegistryCacheDir } from "./paths";
-import { parseRegistryRef, resolveRegistryArtifact } from "./registry-resolve";
+import { parseRegistryRef, resolveRegistryArtifact, validateGitRef, validateGitUrl } from "./registry-resolve";
+import { warn } from "./warn";
 const REGISTRY_STASH_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
 export async function installRegistryRef(ref, options) {
     const parsed = parseRegistryRef(ref);
@@ -48,13 +50,30 @@ export async function installRegistryRef(ref, options) {
         }
     }
     fs.mkdirSync(cacheDir, { recursive: true });
-    await downloadArchive(resolved.artifactUrl, archivePath);
-    verifyArchiveIntegrity(archivePath, resolved.resolvedRevision, resolved.source);
-    const integrity = await computeFileHash(archivePath);
-    extractTarGzSecure(archivePath, extractedDir);
-    const provisionalKitRoot = detectStashRoot(extractedDir);
-    const installRoot = applyAgentikitIncludeConfig(provisionalKitRoot, cacheDir, extractedDir) ?? provisionalKitRoot;
-    const stashRoot = detectStashRoot(installRoot);
+    let integrity;
+    let provisionalKitRoot;
+    let installRoot;
+    let stashRoot;
+    try {
+        await downloadArchive(resolved.artifactUrl, archivePath);
+        verifyArchiveIntegrity(archivePath, resolved.resolvedRevision, resolved.source);
+        integrity = await computeFileHash(archivePath);
+        extractTarGzSecure(archivePath, extractedDir);
+        provisionalKitRoot = detectStashRoot(extractedDir);
+        installRoot = applyAgentikitIncludeConfig(provisionalKitRoot, cacheDir, extractedDir) ?? provisionalKitRoot;
+        stashRoot = detectStashRoot(installRoot);
+    }
+    catch (err) {
+        // Clean up the cache directory so stale or partially-extracted artifacts
+        // don't cause false cache hits on the next install attempt.
+        try {
+            fs.rmSync(cacheDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup; ignore errors
+        }
+        throw err;
+    }
     return {
         id: resolved.id,
         source: resolved.source,
@@ -121,24 +140,44 @@ async function installGitRegistryRef(parsed, options) {
         }
     }
     fs.mkdirSync(cacheDir, { recursive: true });
-    const cloneArgs = ["clone", "--depth", "1"];
-    if (parsed.requestedRef) {
-        cloneArgs.push("--branch", parsed.requestedRef);
+    // Validate URL and ref before passing to git to prevent command injection
+    validateGitUrl(parsed.url);
+    if (parsed.requestedRef)
+        validateGitRef(parsed.requestedRef);
+    let provisionalKitRoot;
+    let installRoot;
+    let stashRoot;
+    try {
+        const cloneArgs = ["clone", "--depth", "1"];
+        if (parsed.requestedRef) {
+            cloneArgs.push("--branch", parsed.requestedRef);
+        }
+        cloneArgs.push(parsed.url, cloneDir);
+        const cloneResult = spawnSync("git", cloneArgs, { encoding: "utf8", timeout: 120_000 });
+        if (cloneResult.status !== 0) {
+            const err = cloneResult.stderr?.trim() || cloneResult.error?.message || "unknown error";
+            throw new Error(`Failed to clone ${parsed.url}: ${err}`);
+        }
+        // Copy contents to extracted dir without .git
+        fs.mkdirSync(extractedDir, { recursive: true });
+        copyDirectoryContents(cloneDir, extractedDir);
+        // Clean up the clone dir
+        fs.rmSync(cloneDir, { recursive: true, force: true });
+        provisionalKitRoot = detectStashRoot(extractedDir);
+        installRoot = applyAgentikitIncludeConfig(provisionalKitRoot, cacheDir, extractedDir) ?? provisionalKitRoot;
+        stashRoot = detectStashRoot(installRoot);
     }
-    cloneArgs.push(parsed.url, cloneDir);
-    const cloneResult = spawnSync("git", cloneArgs, { encoding: "utf8", timeout: 120_000 });
-    if (cloneResult.status !== 0) {
-        const err = cloneResult.stderr?.trim() || cloneResult.error?.message || "unknown error";
-        throw new Error(`Failed to clone ${parsed.url}: ${err}`);
+    catch (err) {
+        // Clean up the cache directory so stale or partially-cloned artifacts
+        // don't cause false cache hits on the next install attempt.
+        try {
+            fs.rmSync(cacheDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup; ignore errors
+        }
+        throw err;
     }
-    // Copy contents to extracted dir without .git
-    fs.mkdirSync(extractedDir, { recursive: true });
-    copyDirectoryContents(cloneDir, extractedDir);
-    // Clean up the clone dir
-    fs.rmSync(cloneDir, { recursive: true, force: true });
-    const provisionalKitRoot = detectStashRoot(extractedDir);
-    const installRoot = applyAgentikitIncludeConfig(provisionalKitRoot, cacheDir, extractedDir) ?? provisionalKitRoot;
-    const stashRoot = detectStashRoot(installRoot);
     return {
         id: resolved.id,
         source: resolved.source,
@@ -204,13 +243,13 @@ function buildInstallCacheDir(cacheRootDir, source, id, version) {
     return path.join(cacheRootDir, slug || source, versionSlug);
 }
 function applyAgentikitIncludeConfig(sourceRoot, cacheDir, searchRoot = sourceRoot) {
-    const includeConfig = findNearestAgentikitIncludeConfig(sourceRoot, searchRoot);
+    const includeConfig = findNearestIncludeConfig(sourceRoot, searchRoot);
     if (!includeConfig)
         return undefined;
     const selectedDir = path.join(cacheDir, "selected");
     fs.rmSync(selectedDir, { recursive: true, force: true });
     fs.mkdirSync(selectedDir, { recursive: true });
-    copyIncludedPaths(includeConfig.baseDir, includeConfig.include, selectedDir);
+    copyIncludedPaths(includeConfig.include, includeConfig.baseDir, selectedDir);
     return selectedDir;
 }
 async function downloadArchive(url, destination) {
@@ -260,9 +299,10 @@ export function verifyArchiveIntegrity(archivePath, expected, source) {
         }
         return;
     }
-    // Unrecognized format — skip verification
+    // Unrecognized format — warn and skip verification
+    warn("Unrecognized integrity format: %s — verification skipped", expected);
 }
-function extractTarGzSecure(archivePath, destinationDir) {
+export function extractTarGzSecure(archivePath, destinationDir) {
     const listResult = spawnSync("tar", ["tzf", archivePath], { encoding: "utf8" });
     if (listResult.status !== 0) {
         const err = listResult.stderr?.trim() || listResult.error?.message || "unknown error";
@@ -271,15 +311,42 @@ function extractTarGzSecure(archivePath, destinationDir) {
     validateTarEntries(listResult.stdout);
     fs.rmSync(destinationDir, { recursive: true, force: true });
     fs.mkdirSync(destinationDir, { recursive: true });
-    const extractResult = spawnSync("tar", ["xzf", archivePath, "--strip-components=1", "-C", destinationDir], {
-        encoding: "utf8",
-    });
+    const extractResult = spawnSync("tar", ["xzf", archivePath, "--no-same-owner", "--strip-components=1", "-C", destinationDir], { encoding: "utf8" });
     if (extractResult.status !== 0) {
         const err = extractResult.stderr?.trim() || extractResult.error?.message || "unknown error";
         throw new Error(`Failed to extract archive ${archivePath}: ${err}`);
     }
+    // Post-extraction scan: verify all extracted files are within destinationDir
+    // This mitigates TOCTOU between validateTarEntries (list) and tar extract.
+    scanExtractedFiles(destinationDir, destinationDir);
+}
+function scanExtractedFiles(dir, root) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        // Check for ".." segments in names (e.g. symlink tricks or crafted filenames)
+        if (entry.name.includes("..")) {
+            throw new Error(`Post-extraction scan: suspicious entry name: ${fullPath}`);
+        }
+        // Resolve symlinks to detect escapes outside the destination directory
+        if (entry.isSymbolicLink()) {
+            const target = fs.realpathSync(fullPath);
+            if (!isWithin(target, root)) {
+                throw new Error(`Post-extraction scan: symlink escapes destination directory: ${fullPath} -> ${target}`);
+            }
+        }
+        if (entry.isDirectory()) {
+            scanExtractedFiles(fullPath, root);
+        }
+    }
 }
-function validateTarEntries(listOutput) {
+export function validateTarEntries(listOutput) {
     const lines = listOutput.split(/\r?\n/).filter(Boolean);
     for (const rawLine of lines) {
         const entry = rawLine.trim();
@@ -313,83 +380,6 @@ function isDirectory(target) {
         return false;
     }
 }
-function readAgentikitIncludeConfigAtDir(dirPath) {
-    const packageJsonPath = path.join(dirPath, "package.json");
-    if (!fs.existsSync(packageJsonPath))
-        return undefined;
-    let pkg;
-    try {
-        pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    }
-    catch {
-        return undefined;
-    }
-    if (typeof pkg !== "object" || pkg === null || Array.isArray(pkg))
-        return undefined;
-    const akmConfig = pkg.akm;
-    if (typeof akmConfig !== "object" || akmConfig === null || Array.isArray(akmConfig))
-        return undefined;
-    const include = akmConfig.include;
-    if (!Array.isArray(include))
-        return undefined;
-    const parsedInclude = include
-        .filter((value) => typeof value === "string")
-        .map((value) => value.trim())
-        .filter(Boolean);
-    return parsedInclude.length > 0 ? { baseDir: dirPath, include: parsedInclude } : undefined;
-}
-function findNearestAgentikitIncludeConfig(startDir, stopDir) {
-    let current = path.resolve(startDir);
-    const boundary = path.resolve(stopDir);
-    while (isWithin(current, boundary)) {
-        const config = readAgentikitIncludeConfigAtDir(current);
-        if (config)
-            return config;
-        if (current === boundary)
-            break;
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return undefined;
-}
-function copyIncludedPaths(baseDir, include, destinationDir) {
-    for (const entry of include) {
-        const resolvedSource = path.resolve(baseDir, entry);
-        if (!isWithin(resolvedSource, baseDir)) {
-            throw new Error(`Path in akm.include escapes the package root: ${entry}`);
-        }
-        if (!fs.existsSync(resolvedSource)) {
-            throw new Error(`Path in akm.include does not exist: ${entry}`);
-        }
-        if (path.basename(resolvedSource) === ".git") {
-            continue;
-        }
-        const relativePath = path.relative(baseDir, resolvedSource);
-        if (!relativePath || relativePath === ".") {
-            copyDirectoryContents(baseDir, destinationDir);
-            continue;
-        }
-        copyPath(resolvedSource, path.join(destinationDir, relativePath));
-    }
-}
-function copyDirectoryContents(sourceDir, destinationDir) {
-    for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
-        if (entry.name === ".git")
-            continue;
-        copyPath(path.join(sourceDir, entry.name), path.join(destinationDir, entry.name));
-    }
-}
-function copyPath(sourcePath, destinationPath) {
-    const stat = fs.statSync(sourcePath);
-    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-    if (stat.isDirectory()) {
-        fs.cpSync(sourcePath, destinationPath, { recursive: true, force: true });
-        return;
-    }
-    fs.copyFileSync(sourcePath, destinationPath);
-}
 function hasStashDirs(dirPath) {
     if (!isDirectory(dirPath))
         return false;
@@ -452,6 +442,21 @@ function normalizeInstalledEntry(entry) {
         cacheDir: path.resolve(entry.cacheDir),
     };
 }
+function copyDirectoryContents(sourceDir, destinationDir) {
+    for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+        if (entry.name === ".git")
+            continue;
+        const src = path.join(sourceDir, entry.name);
+        const dest = path.join(destinationDir, entry.name);
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        if (entry.isDirectory()) {
+            fs.cpSync(src, dest, { recursive: true, force: true });
+        }
+        else {
+            fs.copyFileSync(src, dest);
+        }
+    }
+}
 async function computeFileHash(filePath) {
     const data = fs.readFileSync(filePath);
     const hash = createHash("sha256").update(data).digest("hex");

package/dist/registry-resolve.js

@@ -2,9 +2,37 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { fetchWithRetry } from "./common";
+import { UsageError } from "./errors";
 import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "./github";
+/**
+ * Validate that a URL is safe to pass to git.
+ * Allowlists https:, http:, ssh:, git: schemes and git@ SSH shorthand.
+ * Rejects git protocol helpers (ext::, fd::) that can execute arbitrary commands.
+ */
+export function validateGitUrl(url) {
+    // git@ SSH shorthand: git@host:path
+    if (/^git@[^:]+:.+$/.test(url))
+        return;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new UsageError(`Invalid git URL: ${url}`);
+    }
+    const allowed = ["https:", "http:", "ssh:", "git:"];
+    if (!allowed.includes(parsed.protocol)) {
+        throw new UsageError(`Unsafe git URL scheme "${parsed.protocol}" in "${url}". Allowed: https, http, ssh, git, git@host:path`);
+    }
+}
+/** Validate that a git ref (branch/tag/commit) contains only safe characters. */
+export function validateGitRef(ref) {
+    if (!/^[a-zA-Z0-9._\-/]+$/.test(ref)) {
+        throw new UsageError(`Unsafe git ref "${ref}": only alphanumerics, '.', '_', '-', '/' are allowed`);
+    }
+}
 export function parseRegistryRef(rawRef) {
     const ref = rawRef.trim();
     if (!ref)
@@ -285,7 +313,10 @@ async function resolveGithubArtifact(parsed) {
     };
 }
 async function resolveGitArtifact(parsed) {
+    validateGitUrl(parsed.url);
     const ref = parsed.requestedRef ?? "HEAD";
+    if (parsed.requestedRef)
+        validateGitRef(parsed.requestedRef);
     const result = spawnSync("git", ["ls-remote", parsed.url, ref], { encoding: "utf8", timeout: 30_000 });
     let resolvedRevision;
     if (result.status === 0) {
@@ -370,19 +401,23 @@ function stripGitTransport(ref) {
 }
 /**
  * Convert a `file:` URI to a local filesystem path.
- * Supports `file:./relative`, `file:../relative`, and `file:///absolute`.
+ *
+ * Standard `file:///absolute` forms are handled by Node's `fileURLToPath`.
+ * Non-standard `file:./relative` and `file:../relative` shorthand forms
+ * (not a valid RFC 8089 URL) are handled with a custom fallback.
  */
 function fileUriToPath(ref) {
     const after = ref.slice(5); // strip "file:"
-    // file:///absolute/path or file:///C:/path
-    if (after.startsWith("///")) {
-        return after.slice(2); // keep one leading /
-    }
-    // file://hostname/path (rare, treat hostname/path as absolute)
+    // Standard file:///absolute/path — delegate to Node's implementation
     if (after.startsWith("//")) {
-        return after.slice(1);
+        try {
+            return fileURLToPath(ref);
+        }
+        catch {
+            // Fall through to custom handling
+        }
     }
-    // file:./relative or file:../relative or file:/absolute
+    // Non-standard file:./relative or file:../relative or file:/absolute
     return after;
 }
 /**

package/dist/registry-search.js

@@ -1,5 +1,6 @@
+import { toErrorMessage } from "./common";
 import { DEFAULT_CONFIG, loadConfig } from "./config";
-import { resolveProviderFactory } from "./provider-registry";
+import { resolveProviderFactory } from "./registry-factory";
 // ── Eagerly import providers to trigger self-registration ───────────────────
 import "./providers/static-index";
 import "./providers/skills-sh";
@@ -63,11 +64,18 @@ export function resolveRegistries(configRegistries) {
     // Allow env var override (comma-separated URLs) — CI escape hatch
     const envUrls = process.env.AKM_REGISTRY_URL?.trim();
     if (envUrls) {
-        return envUrls
-            .split(",")
-            .map((u) => u.trim())
-            .filter(Boolean)
-            .map((url) => ({ url }));
+        const entries = [];
+        for (const raw of envUrls.split(",")) {
+            const url = raw.trim();
+            if (!url)
+                continue;
+            if (!url.startsWith("http://") && !url.startsWith("https://")) {
+                console.warn(`[agentikit] Ignoring AKM_REGISTRY_URL entry: must start with http:// or https://, got "${url}"`);
+                continue;
+            }
+            entries.push({ url });
+        }
+        return entries;
     }
     const registries = configRegistries ?? loadConfig().registries ?? DEFAULT_CONFIG.registries ?? [];
     return registries.filter((r) => r.enabled !== false);
@@ -89,6 +97,3 @@ function clampLimit(limit) {
         return 20;
     return Math.min(100, Math.max(1, Math.trunc(limit)));
 }
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/renderers.js

@@ -54,7 +54,7 @@ export function extractCommentTags(filePath) {
     catch {
         return {};
     }
-    const lines = content.split(/\r?\n/).slice(0, 50);
+    const lines = content.split(/\r?\n/, 50);
     const hints = {};
     for (const line of lines) {
         const trimmed = line.trim();
@@ -89,10 +89,11 @@ export function extractCommentTags(filePath) {
 export function detectExecHints(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     const hints = {};
-    // Interpreter from extension
+    // Interpreter from extension — use basename so the run command is portable
+    // relative to the stash root (callers set cwd to the file's directory).
     const interpreter = INTERPRETER_MAP[ext];
     if (interpreter) {
-        hints.run = `${interpreter} ${filePath}`;
+        hints.run = `${interpreter} ${path.basename(filePath)}`;
     }
     // Setup from nearby dependency files
     const dir = path.dirname(filePath);
@@ -206,7 +207,7 @@ const commandMdRenderer = {
             action: "Fill $ARGUMENTS placeholders in the template, then dispatch",
             description: toStringOrUndefined(parsedMd.data.description),
             template,
-            modelHint: parsedMd.data.model,
+            modelHint: typeof parsedMd.data.model === "string" ? parsedMd.data.model : undefined,
             agent: toStringOrUndefined(parsedMd.data.agent),
             parameters: extractParameters(template),
         };
@@ -226,7 +227,7 @@ const agentMdRenderer = {
             description: toStringOrUndefined(parsedMd.data.description),
             prompt: parsedMd.content,
             toolPolicy: parsedMd.data.tools,
-            modelHint: parsedMd.data.model,
+            modelHint: typeof parsedMd.data.model === "string" ? parsedMd.data.model : undefined,
         };
     },
 };
@@ -308,7 +309,21 @@ const knowledgeMdRenderer = {
         }
     },
 };
-// ── 5. script-source ─────────────────────────────────────────────────────────
+// ── 5. memory-md ─────────────────────────────────────────────────────────────
+const memoryMdRenderer = {
+    name: "memory-md",
+    buildShowResponse(ctx) {
+        const name = deriveName(ctx);
+        return {
+            type: "memory",
+            name,
+            path: ctx.absPath,
+            action: "Recall context — read the content below",
+            content: ctx.content(),
+        };
+    },
+};
+// ── 6. script-source ─────────────────────────────────────────────────────────
 const scriptSourceRenderer = {
     name: "script-source",
     buildShowResponse(ctx) {
@@ -371,6 +386,7 @@ const builtinRenderers = [
     commandMdRenderer,
     agentMdRenderer,
     knowledgeMdRenderer,
+    memoryMdRenderer,
     scriptSourceRenderer,
 ];
 /**
@@ -383,4 +399,4 @@ export function registerBuiltinRenderers() {
     }
 }
 // ── Named exports for testing ────────────────────────────────────────────────
-export { skillMdRenderer, commandMdRenderer, agentMdRenderer, knowledgeMdRenderer, scriptSourceRenderer, INTERPRETER_MAP, SETUP_SIGNALS, };
+export { skillMdRenderer, commandMdRenderer, agentMdRenderer, knowledgeMdRenderer, memoryMdRenderer, scriptSourceRenderer, INTERPRETER_MAP, SETUP_SIGNALS, };

package/dist/ripgrep-install.js

@@ -118,9 +118,13 @@ function downloadAndExtractZip(url, archiveName, destBinary) {
         if (dlResult.status !== 0) {
             throw new Error(dlResult.stderr?.trim() || "download failed");
         }
-        // Extract the zip archive using separate spawnSync calls with argument arrays
-        // to avoid shell injection via path interpolation in PowerShell -Command strings
-        const expandResult = spawnSync("powershell", ["-Command", "Expand-Archive", "-Path", tmpZip, "-DestinationPath", destDir, "-Force"], {
+        // Extract the zip archive. Use a single-string -Command with quoted paths to
+        // prevent PowerShell from treating subsequent array elements as separate
+        // arguments to the interpreter itself (PowerShell -Command arg1 arg2 ... would
+        // concatenate them with spaces, causing unexpected evaluation on paths with
+        // backticks or semicolons).
+        const expandCmd = `Expand-Archive -Path '${tmpZip.replace(/'/g, "''")}' -DestinationPath '${destDir.replace(/'/g, "''")}' -Force`;
+        const expandResult = spawnSync("powershell", ["-NonInteractive", "-NoProfile", "-Command", expandCmd], {
             encoding: "utf8",
             timeout: 60_000,
             env: process.env,
@@ -129,7 +133,8 @@ function downloadAndExtractZip(url, archiveName, destBinary) {
             throw new Error(expandResult.stderr?.trim() || "extraction failed");
         }
         const srcRgExe = path.join(destDir, archiveName, "rg.exe");
-        const moveResult = spawnSync("powershell", ["-Command", "Move-Item", "-Force", "-Path", srcRgExe, "-Destination", destBinary], {
+        const moveCmd = `Move-Item -Force -Path '${srcRgExe.replace(/'/g, "''")}' -Destination '${destBinary.replace(/'/g, "''")}'`;
+        const moveResult = spawnSync("powershell", ["-NonInteractive", "-NoProfile", "-Command", moveCmd], {
             encoding: "utf8",
             timeout: 60_000,
             env: process.env,

package/dist/self-update.js

@@ -91,11 +91,21 @@ export async function performUpgrade(check, opts) {
         throw new Error(`Failed to download binary: ${binaryResponse.status} ${binaryResponse.statusText}`);
     }
     const binaryData = new Uint8Array(await binaryResponse.arrayBuffer());
-    // Download and verify checksum
+    // Download and verify checksum (mandatory — upgrade is blocked if checksums cannot be fetched)
     let checksumVerified = false;
+    const skipChecksum = opts?.skipChecksum === true;
     try {
         const checksumsResponse = await fetchWithRetry(checksumsUrl);
-        if (checksumsResponse.ok) {
+        if (!checksumsResponse.ok) {
+            if (skipChecksum) {
+                console.warn(`WARNING: checksums.txt fetch failed (HTTP ${checksumsResponse.status}). Proceeding without verification because --skip-checksum was provided.`);
+            }
+            else {
+                throw new Error(`Checksum verification failed: could not fetch ${checksumsUrl} (HTTP ${checksumsResponse.status}). ` +
+                    `Use --skip-checksum to bypass (not recommended).`);
+            }
+        }
+        else {
             const checksumsText = await checksumsResponse.text();
             const expectedHash = parseChecksumForFile(checksumsText, binaryName);
             if (expectedHash) {
@@ -105,13 +115,30 @@ export async function performUpgrade(check, opts) {
                 }
                 checksumVerified = true;
             }
+            else {
+                if (skipChecksum) {
+                    console.warn(`WARNING: ${binaryName} not found in checksums.txt. Proceeding without verification because --skip-checksum was provided.`);
+                }
+                else {
+                    throw new Error(`Checksum verification failed: ${binaryName} not listed in checksums.txt. ` +
+                        `Use --skip-checksum to bypass (not recommended).`);
+                }
+            }
         }
     }
     catch (err) {
-        if (err instanceof Error && err.message.includes("Checksum mismatch")) {
+        if (err instanceof Error &&
+            (err.message.includes("Checksum mismatch") || err.message.includes("Checksum verification failed"))) {
             throw err;
         }
-        // Non-fatal: checksum file missing or unparseable
+        // Network or parse failure
+        if (skipChecksum) {
+            console.warn(`WARNING: Could not fetch or parse checksums: ${err instanceof Error ? err.message : String(err)}. Proceeding because --skip-checksum was provided.`);
+        }
+        else {
+            throw new Error(`Checksum verification failed: ${err instanceof Error ? err.message : String(err)}. ` +
+                `Use --skip-checksum to bypass (not recommended).`);
+        }
     }
     const execPath = process.execPath;
     const execDir = path.dirname(execPath);