akm-cli 0.0.0 → 0.0.17

package/dist/self-update.js

@@ -0,0 +1,226 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fetchWithRetry, IS_WINDOWS } from "./common";
+import { githubHeaders } from "./github";
+const REPO = "itlackey/agentikit";
+export function detectInstallMethod() {
+    // Bun-compiled binaries: Bun.main equals process.execPath
+    if (typeof Bun !== "undefined" && Bun.main === process.execPath) {
+        return "binary";
+    }
+    // npm/bun global install: import.meta.dir contains node_modules
+    if (import.meta.dir?.includes("node_modules")) {
+        return "npm";
+    }
+    return "unknown";
+}
+export function getAkmBinaryName() {
+    const platform = process.platform;
+    const arch = process.arch;
+    if (platform === "linux" && arch === "x64")
+        return "akm-linux-x64";
+    if (platform === "linux" && arch === "arm64")
+        return "akm-linux-arm64";
+    if (platform === "darwin" && arch === "x64")
+        return "akm-darwin-x64";
+    if (platform === "darwin" && arch === "arm64")
+        return "akm-darwin-arm64";
+    if (platform === "win32" && arch === "x64")
+        return "akm-windows-x64.exe";
+    throw new Error(`Unsupported platform for binary upgrade: ${platform}/${arch}`);
+}
+export async function checkForUpdate(currentVersion) {
+    const installMethod = detectInstallMethod();
+    const url = `https://api.github.com/repos/${REPO}/releases/latest`;
+    const response = await fetchWithRetry(url, { headers: githubHeaders() });
+    if (!response.ok) {
+        throw new Error(`Failed to check for updates: ${response.status} ${response.statusText}`);
+    }
+    const release = (await response.json());
+    const latestTag = release.tag_name ?? "";
+    const latestVersion = latestTag.replace(/^v/, "");
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: latestVersion !== "" && Bun.semver.order(currentVersion, latestVersion) < 0,
+        installMethod,
+    };
+}
+export async function performUpgrade(check, opts) {
+    const { currentVersion, latestVersion, installMethod } = check;
+    const force = opts?.force === true;
+    if (installMethod === "npm") {
+        return {
+            currentVersion,
+            newVersion: latestVersion,
+            upgraded: false,
+            installMethod,
+            message: `akm installed via npm. Run: bun install -g akm-cli@latest`,
+        };
+    }
+    if (installMethod === "unknown") {
+        return {
+            currentVersion,
+            newVersion: latestVersion,
+            upgraded: false,
+            installMethod,
+            message: `Unable to detect install method. Upgrade manually from https://github.com/${REPO}/releases`,
+        };
+    }
+    // Binary install
+    if (!check.updateAvailable && !force) {
+        return {
+            currentVersion,
+            newVersion: latestVersion,
+            upgraded: false,
+            installMethod,
+            message: `akm v${currentVersion} is already the latest version`,
+        };
+    }
+    if (!latestVersion) {
+        throw new Error("Unable to determine latest version from GitHub releases. Check https://github.com/itlackey/agentikit/releases");
+    }
+    const tag = `v${latestVersion}`;
+    const binaryName = getAkmBinaryName();
+    const binaryUrl = `https://github.com/${REPO}/releases/download/${tag}/${binaryName}`;
+    const checksumsUrl = `https://github.com/${REPO}/releases/download/${tag}/checksums.txt`;
+    // Download binary
+    const binaryResponse = await fetchWithRetry(binaryUrl);
+    if (!binaryResponse.ok) {
+        throw new Error(`Failed to download binary: ${binaryResponse.status} ${binaryResponse.statusText}`);
+    }
+    const binaryData = new Uint8Array(await binaryResponse.arrayBuffer());
+    // Download and verify checksum
+    let checksumVerified = false;
+    try {
+        const checksumsResponse = await fetchWithRetry(checksumsUrl);
+        if (checksumsResponse.ok) {
+            const checksumsText = await checksumsResponse.text();
+            const expectedHash = parseChecksumForFile(checksumsText, binaryName);
+            if (expectedHash) {
+                const actualHash = createHash("sha256").update(binaryData).digest("hex");
+                if (actualHash !== expectedHash) {
+                    throw new Error(`Checksum mismatch for ${binaryName}.\n` + `Expected: ${expectedHash}\n` + `Got:      ${actualHash}`);
+                }
+                checksumVerified = true;
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes("Checksum mismatch")) {
+            throw err;
+        }
+        // Non-fatal: checksum file missing or unparseable
+    }
+    const execPath = process.execPath;
+    const execDir = path.dirname(execPath);
+    const execName = path.basename(execPath);
+    if (IS_WINDOWS) {
+        // Windows: rename running exe, write new one, clean up old on success
+        const oldPath = `${execPath}.old`;
+        try {
+            fs.renameSync(execPath, oldPath);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "EPERM" || code === "EACCES") {
+                throw new Error(`Permission denied. Cannot rename ${execPath}.\n` +
+                    `Try running as Administrator, or re-download from https://github.com/${REPO}/releases`);
+            }
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to rename ${execPath}: ${detail}`);
+        }
+        try {
+            fs.writeFileSync(execPath, binaryData);
+        }
+        catch (err) {
+            // Restore from old
+            fs.renameSync(oldPath, execPath);
+            throw err;
+        }
+        // Best-effort cleanup of .old
+        try {
+            fs.unlinkSync(oldPath);
+        }
+        catch {
+            // Windows may lock the old exe — it will be cleaned up on next startup or manually
+        }
+    }
+    else {
+        // Unix: write to temp file, chmod +x, atomic rename
+        const tmpPath = path.join(execDir, `.${execName}.tmp.${process.pid}`);
+        const bakPath = `${execPath}.bak`;
+        try {
+            fs.writeFileSync(tmpPath, binaryData);
+            fs.chmodSync(tmpPath, 0o755);
+        }
+        catch (err) {
+            // Clean up temp file on failure
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch {
+                /* ignore */
+            }
+            const code = err.code;
+            if (code === "EACCES" || code === "EPERM") {
+                throw new Error(`Permission denied writing to ${execDir}.\n` +
+                    `Run: sudo akm upgrade\n` +
+                    `Or re-run the install script: curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash`);
+            }
+            throw err;
+        }
+        // Backup current, then atomic rename
+        try {
+            fs.copyFileSync(execPath, bakPath);
+            fs.renameSync(tmpPath, execPath);
+        }
+        catch (err) {
+            // Restore from backup if rename failed
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                if (fs.existsSync(bakPath) && !fs.existsSync(execPath)) {
+                    fs.renameSync(bakPath, execPath);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+        // Cleanup backup
+        try {
+            fs.unlinkSync(bakPath);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return {
+        currentVersion,
+        newVersion: latestVersion,
+        upgraded: true,
+        installMethod,
+        binaryPath: execPath,
+        checksumVerified,
+    };
+}
+function parseChecksumForFile(checksumsText, filename) {
+    for (const line of checksumsText.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Format: <hash>  <filename>
+        const match = trimmed.match(/^([0-9a-f]{64})\s+(.+)$/);
+        if (match && match[2] === filename) {
+            return match[1];
+        }
+    }
+    return undefined;
+}

package/dist/stash-add.js

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import { resolveStashDir } from "./common";
+import { loadConfig } from "./config";
+import { UsageError } from "./errors";
+import { agentikitIndex } from "./indexer";
+import { upsertLockEntry } from "./lockfile";
+import { installRegistryRef, upsertInstalledRegistryEntry } from "./registry-install";
+export async function agentikitAdd(input) {
+    const ref = input.ref.trim();
+    if (!ref)
+        throw new UsageError("Install ref or local directory is required.");
+    const stashDir = resolveStashDir();
+    const installed = await installRegistryRef(ref);
+    const replaced = (loadConfig().installed ?? []).find((entry) => entry.id === installed.id);
+    const config = upsertInstalledRegistryEntry({
+        id: installed.id,
+        source: installed.source,
+        ref: installed.ref,
+        artifactUrl: installed.artifactUrl,
+        resolvedVersion: installed.resolvedVersion,
+        resolvedRevision: installed.resolvedRevision,
+        stashRoot: installed.stashRoot,
+        cacheDir: installed.cacheDir,
+        installedAt: installed.installedAt,
+    });
+    upsertLockEntry({
+        id: installed.id,
+        source: installed.source,
+        ref: installed.ref,
+        resolvedVersion: installed.resolvedVersion,
+        resolvedRevision: installed.resolvedRevision,
+        integrity: installed.integrity ?? (installed.source === "local" ? "local" : undefined),
+    });
+    // Clean up old cache directory on re-install (skip for local sources — no cache to clean)
+    if (replaced && replaced.source !== "local" && replaced.cacheDir !== installed.cacheDir) {
+        try {
+            fs.rmSync(replaced.cacheDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+    const index = await agentikitIndex({ stashDir });
+    return {
+        schemaVersion: 1,
+        stashDir,
+        ref,
+        installed: {
+            id: installed.id,
+            source: installed.source,
+            ref: installed.ref,
+            artifactUrl: installed.artifactUrl,
+            resolvedVersion: installed.resolvedVersion,
+            resolvedRevision: installed.resolvedRevision,
+            stashRoot: installed.stashRoot,
+            cacheDir: installed.cacheDir,
+            extractedDir: installed.extractedDir,
+            installedAt: installed.installedAt,
+        },
+        config: {
+            searchPaths: config.searchPaths,
+            installedKitCount: config.installed?.length ?? 0,
+        },
+        index: {
+            mode: index.mode,
+            totalEntries: index.totalEntries,
+            directoriesScanned: index.directoriesScanned,
+            directoriesSkipped: index.directoriesSkipped,
+        },
+    };
+}

package/dist/stash-clone.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { TYPE_DIRS } from "./asset-spec";
+import { isRemoteOrigin, resolveSourcesForOrigin } from "./origin-resolve";
+import { installRegistryRef } from "./registry-install";
+import { makeAssetRef, parseAssetRef } from "./stash-ref";
+import { resolveAssetPath } from "./stash-resolve";
+import { findSourceForPath, getPrimarySource, resolveStashSources } from "./stash-source";
+export async function agentikitClone(options) {
+    const parsed = parseAssetRef(options.sourceRef);
+    // When --dest is provided, the working stash is optional
+    let allSources;
+    try {
+        allSources = resolveStashSources();
+    }
+    catch (err) {
+        if (options.dest) {
+            allSources = [];
+        }
+        else {
+            throw err;
+        }
+    }
+    const primarySource = getPrimarySource(allSources);
+    const destRoot = options.dest ? path.resolve(options.dest) : primarySource?.path;
+    if (!destRoot) {
+        throw new Error("No working stash configured and no --dest provided. Run `akm init` or pass --dest.");
+    }
+    let searchSources = resolveSourcesForOrigin(parsed.origin, allSources);
+    // Remote fetch fallback: if no local source matched and origin looks remote, fetch it
+    let remoteFetched;
+    if (searchSources.length === 0 && parsed.origin && isRemoteOrigin(parsed.origin, allSources)) {
+        const installResult = await installRegistryRef(parsed.origin);
+        const syntheticSource = {
+            path: installResult.stashRoot,
+            registryId: installResult.id,
+        };
+        searchSources = [syntheticSource];
+        allSources = [...allSources, syntheticSource];
+        remoteFetched = {
+            origin: parsed.origin,
+            stashRoot: installResult.stashRoot,
+            cacheDir: installResult.cacheDir,
+        };
+    }
+    let sourcePath;
+    let lastError;
+    for (const source of searchSources) {
+        try {
+            sourcePath = resolveAssetPath(source.path, parsed.type, parsed.name);
+            break;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+        }
+    }
+    if (!sourcePath) {
+        const context = remoteFetched ? ` (remote package fetched but asset not found inside it)` : "";
+        throw lastError ?? new Error(`Source asset not found for ref: ${options.sourceRef}${context}`);
+    }
+    const sourceSource = findSourceForPath(sourcePath, allSources);
+    const destName = options.newName ?? parsed.name;
+    const typeDir = TYPE_DIRS[parsed.type];
+    const destLabel = options.dest ? "at destination" : "in working stash";
+    // Guard against self-clone
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.resolve(path.dirname(sourcePath));
+        const destSkillDir = path.resolve(path.join(destRoot, typeDir, destName));
+        if (sourceSkillDir === destSkillDir) {
+            throw new Error(`Source and destination are the same path. Use --name to provide a new name for the clone.`);
+        }
+    }
+    else {
+        const resolvedSource = path.resolve(sourcePath);
+        const resolvedDest = path.resolve(path.join(destRoot, typeDir, destName));
+        if (resolvedSource === resolvedDest) {
+            throw new Error(`Source and destination are the same path. Use --name to provide a new name for the clone.`);
+        }
+    }
+    let destPath;
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.dirname(sourcePath);
+        const destSkillDir = path.join(destRoot, typeDir, destName);
+        const overwritten = fs.existsSync(destSkillDir);
+        if (overwritten && !options.force) {
+            throw new Error(`Asset already exists ${destLabel}: ${destSkillDir}. Use --force to overwrite.`);
+        }
+        if (overwritten) {
+            fs.rmSync(destSkillDir, { recursive: true, force: true });
+        }
+        fs.cpSync(sourceSkillDir, destSkillDir, { recursive: true });
+        destPath = path.join(destSkillDir, "SKILL.md");
+        const ref = makeAssetRef(parsed.type, destName, "local");
+        return {
+            source: { path: sourcePath, registryId: sourceSource?.registryId },
+            destination: { path: destPath, ref },
+            overwritten,
+            ...(remoteFetched ? { remoteFetched } : {}),
+        };
+    }
+    destPath = path.join(destRoot, typeDir, destName);
+    const overwritten = fs.existsSync(destPath);
+    if (overwritten && !options.force) {
+        throw new Error(`Asset already exists ${destLabel}: ${destPath}. Use --force to overwrite.`);
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destPath);
+    const ref = makeAssetRef(parsed.type, destName, "local");
+    return {
+        source: { path: sourcePath, registryId: sourceSource?.registryId },
+        destination: { path: destPath, ref },
+        overwritten,
+        ...(remoteFetched ? { remoteFetched } : {}),
+    };
+}

package/dist/stash-ref.js

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { isAssetType } from "./common";
+import { UsageError } from "./errors";
+// ── Construction ────────────────────────────────────────────────────────────
+/**
+ * Build a ref string from components.
+ *
+ * Examples:
+ *   makeAssetRef("script", "deploy.sh")
+ *     → "script:deploy.sh"
+ *   makeAssetRef("script", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//script:deploy.sh"
+ *   makeAssetRef("skill", "code-review", "local")
+ *     → "local//skill:code-review"
+ *   makeAssetRef("script", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//script:db/migrate/run.sh"
+ */
+export function makeAssetRef(type, name, origin) {
+    validateName(name);
+    const normalized = normalizeName(name);
+    const asset = `${type}:${normalized}`;
+    if (!origin)
+        return asset;
+    return `${origin}//${asset}`;
+}
+// ── Parsing ─────────────────────────────────────────────────────────────────
+/**
+ * Parse a ref string in the format `[origin//]type:name`.
+ */
+export function parseAssetRef(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed)
+        throw new UsageError("Empty ref.");
+    let origin;
+    let body = trimmed;
+    const boundary = trimmed.indexOf("//");
+    if (boundary >= 0) {
+        origin = trimmed.slice(0, boundary);
+        body = trimmed.slice(boundary + 2);
+        if (!origin)
+            throw new UsageError("Empty origin in ref.");
+    }
+    const colon = body.indexOf(":");
+    if (colon <= 0) {
+        throw new UsageError(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
+    }
+    const rawType = body.slice(0, colon);
+    const rawName = body.slice(colon + 1);
+    if (!isAssetType(rawType)) {
+        throw new UsageError(`Invalid asset type: "${rawType}".`);
+    }
+    validateName(rawName);
+    const name = normalizeName(rawName);
+    return { type: rawType, name, origin: origin || undefined };
+}
+// ── Validation ──────────────────────────────────────────────────────────────
+function validateName(name) {
+    if (!name)
+        throw new UsageError("Empty asset name.");
+    if (name.includes("\0"))
+        throw new UsageError("Null byte in asset name.");
+    if (/^[A-Za-z]:/.test(name))
+        throw new UsageError("Windows drive path in asset name.");
+    const normalized = path.posix.normalize(name.replace(/\\/g, "/"));
+    if (path.posix.isAbsolute(normalized))
+        throw new UsageError("Absolute path in asset name.");
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new UsageError("Path traversal in asset name.");
+    }
+}
+function normalizeName(name) {
+    return path.posix.normalize(name.replace(/\\/g, "/"));
+}

package/dist/stash-registry.js

@@ -0,0 +1,206 @@
+import fs from "node:fs";
+import { resolveStashDir } from "./common";
+import { loadConfig } from "./config";
+import { NotFoundError, UsageError } from "./errors";
+import { agentikitIndex } from "./indexer";
+import { removeLockEntry, upsertLockEntry } from "./lockfile";
+import { installRegistryRef, removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./registry-install";
+import { parseRegistryRef } from "./registry-resolve";
+export async function agentikitList(input) {
+    const stashDir = input?.stashDir ?? resolveStashDir();
+    const config = loadConfig();
+    const installed = config.installed ?? [];
+    return {
+        schemaVersion: 1,
+        stashDir,
+        installed: installed.map((entry) => ({
+            ...entry,
+            status: {
+                cacheDirExists: directoryExists(entry.cacheDir),
+                stashRootExists: directoryExists(entry.stashRoot),
+            },
+        })),
+        totalInstalled: installed.length,
+    };
+}
+export async function agentikitRemove(input) {
+    const target = input.target.trim();
+    if (!target)
+        throw new UsageError("Target is required.");
+    const stashDir = input.stashDir ?? resolveStashDir();
+    const config = loadConfig();
+    const installed = config.installed ?? [];
+    const entry = resolveInstalledTarget(installed, target);
+    const updatedConfig = removeInstalledRegistryEntry(entry.id);
+    removeLockEntry(entry.id);
+    // Only clean up cache for non-local sources — local sources point to the
+    // user's real directory on disk and must never be deleted.
+    if (entry.source !== "local") {
+        cleanupDirectoryBestEffort(entry.cacheDir);
+    }
+    const index = await agentikitIndex({ stashDir });
+    return {
+        schemaVersion: 1,
+        stashDir,
+        target,
+        removed: {
+            id: entry.id,
+            source: entry.source,
+            ref: entry.ref,
+            cacheDir: entry.cacheDir,
+            stashRoot: entry.stashRoot,
+        },
+        config: {
+            searchPaths: updatedConfig.searchPaths,
+            installedKitCount: updatedConfig.installed?.length ?? 0,
+        },
+        index: {
+            mode: index.mode,
+            totalEntries: index.totalEntries,
+            directoriesScanned: index.directoriesScanned,
+            directoriesSkipped: index.directoriesSkipped,
+        },
+    };
+}
+export async function agentikitUpdate(input) {
+    const stashDir = input?.stashDir ?? resolveStashDir();
+    const target = input?.target?.trim();
+    const all = input?.all === true;
+    const force = input?.force === true;
+    const installedEntries = loadConfig().installed ?? [];
+    const selectedEntries = selectTargets(installedEntries, target, all);
+    const processed = [];
+    for (const entry of selectedEntries) {
+        if (force && shouldCleanupCache(entry)) {
+            cleanupDirectoryBestEffort(entry.cacheDir);
+        }
+        const installed = await installRegistryRef(entry.ref);
+        upsertInstalledRegistryEntry(toInstalledEntry(installed));
+        upsertLockEntry({
+            id: installed.id,
+            source: installed.source,
+            ref: installed.ref,
+            resolvedVersion: installed.resolvedVersion,
+            resolvedRevision: installed.resolvedRevision,
+            integrity: installed.integrity ?? (installed.source === "local" ? "local" : undefined),
+        });
+        if (entry.cacheDir !== installed.cacheDir && shouldCleanupCache(entry)) {
+            cleanupDirectoryBestEffort(entry.cacheDir);
+        }
+        const versionChanged = (entry.resolvedVersion ?? "") !== (installed.resolvedVersion ?? "");
+        const revisionChanged = (entry.resolvedRevision ?? "") !== (installed.resolvedRevision ?? "");
+        processed.push({
+            id: entry.id,
+            source: entry.source,
+            ref: entry.ref,
+            previous: {
+                resolvedVersion: entry.resolvedVersion,
+                resolvedRevision: entry.resolvedRevision,
+                cacheDir: entry.cacheDir,
+            },
+            installed: toInstallStatus(installed),
+            changed: {
+                version: versionChanged,
+                revision: revisionChanged,
+                any: versionChanged || revisionChanged,
+            },
+        });
+    }
+    const index = await agentikitIndex({ stashDir });
+    const config = loadConfig();
+    return {
+        schemaVersion: 1,
+        stashDir,
+        target,
+        all,
+        processed,
+        config: {
+            searchPaths: config.searchPaths,
+            installedKitCount: config.installed?.length ?? 0,
+        },
+        index: {
+            mode: index.mode,
+            totalEntries: index.totalEntries,
+            directoriesScanned: index.directoriesScanned,
+            directoriesSkipped: index.directoriesSkipped,
+        },
+    };
+}
+function selectTargets(installed, target, all) {
+    if (all && target) {
+        throw new UsageError("Specify either <target> or --all, not both.");
+    }
+    if (all)
+        return installed;
+    if (!target) {
+        throw new UsageError("Either <target> or --all is required.");
+    }
+    return [resolveInstalledTarget(installed, target)];
+}
+function resolveInstalledTarget(installed, target) {
+    const byId = installed.find((entry) => entry.id === target);
+    if (byId)
+        return byId;
+    const byRef = installed.find((entry) => entry.ref === target);
+    if (byRef)
+        return byRef;
+    let parsedId;
+    try {
+        parsedId = parseRegistryRef(target).id;
+    }
+    catch {
+        parsedId = undefined;
+    }
+    if (parsedId) {
+        const byParsedId = installed.find((entry) => entry.id === parsedId);
+        if (byParsedId)
+            return byParsedId;
+    }
+    throw new NotFoundError(`No installed kit matched target: ${target}`);
+}
+function toInstalledEntry(status) {
+    return {
+        id: status.id,
+        source: status.source,
+        ref: status.ref,
+        artifactUrl: status.artifactUrl,
+        resolvedVersion: status.resolvedVersion,
+        resolvedRevision: status.resolvedRevision,
+        stashRoot: status.stashRoot,
+        cacheDir: status.cacheDir,
+        installedAt: status.installedAt,
+    };
+}
+function toInstallStatus(status) {
+    return {
+        id: status.id,
+        source: status.source,
+        ref: status.ref,
+        artifactUrl: status.artifactUrl,
+        resolvedVersion: status.resolvedVersion,
+        resolvedRevision: status.resolvedRevision,
+        stashRoot: status.stashRoot,
+        cacheDir: status.cacheDir,
+        extractedDir: status.extractedDir,
+        installedAt: status.installedAt,
+    };
+}
+function cleanupDirectoryBestEffort(target) {
+    try {
+        fs.rmSync(target, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup only.
+    }
+}
+function shouldCleanupCache(entry) {
+    return entry.source !== "local";
+}
+function directoryExists(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}