loadout-ai 0.1.0

package/dist/src/core/source.js

@@ -0,0 +1,305 @@
+import { lstat, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { loadoutHome, ensureDirectory } from "./paths.js";
+const execFileAsync = promisify(execFile);
+async function enforceRepositoryBounds(root, options) {
+    if (options.maxBytes === undefined && options.maxFiles === undefined)
+        return;
+    let bytes = 0;
+    let files = 0;
+    const pending = [root];
+    while (pending.length) {
+        const directory = pending.pop();
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                pending.push(path);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const info = await lstat(path);
+            bytes += info.size;
+            files++;
+            if (options.maxBytes !== undefined && bytes > options.maxBytes)
+                throw new Error(`Repository exceeds the ${options.maxBytes} byte inspection limit`);
+            if (options.maxFiles !== undefined && files > options.maxFiles)
+                throw new Error(`Repository exceeds the ${options.maxFiles} file inspection limit`);
+        }
+    }
+}
+export function validateGitHubTreeBounds(value, options) {
+    if (options.maxBytes === undefined && options.maxFiles === undefined)
+        return;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("GitHub tree preflight returned an invalid response");
+    const response = value;
+    if (response.truncated)
+        throw new Error("GitHub tree preflight was truncated; refusing checkout");
+    if (!Array.isArray(response.tree))
+        throw new Error("GitHub tree preflight has no tree entries");
+    let bytes = 0;
+    let files = 0;
+    for (const entry of response.tree) {
+        if (entry.type !== "blob")
+            continue;
+        if (typeof entry.path !== "string" ||
+            typeof entry.size !== "number" ||
+            !Number.isSafeInteger(entry.size) ||
+            entry.size < 0)
+            throw new Error("GitHub tree preflight contains invalid blob evidence");
+        files++;
+        bytes += entry.size;
+        if (options.maxBytes !== undefined && bytes > options.maxBytes)
+            throw new Error(`Repository exceeds the ${options.maxBytes} byte inspection limit`);
+        if (options.maxFiles !== undefined && files > options.maxFiles)
+            throw new Error(`Repository exceeds the ${options.maxFiles} file inspection limit`);
+    }
+}
+async function enforceGitHubTreeBounds(repository, commit, options) {
+    if (options.maxBytes === undefined && options.maxFiles === undefined)
+        return;
+    const signal = AbortSignal.timeout(options.timeoutMs ?? 120_000);
+    const token = process.env.GITHUB_TOKEN?.trim();
+    const response = await (options.fetcher ?? fetch)(`https://api.github.com/repos/${repository}/git/trees/${commit}?recursive=1`, {
+        headers: {
+            accept: "application/vnd.github+json",
+            "user-agent": "loadout-ai",
+            ...(token ? { authorization: `Bearer ${token}` } : {}),
+        },
+        signal,
+    });
+    if (!response.ok)
+        throw new Error(`GitHub tree preflight failed with HTTP ${response.status}; refusing an unbounded checkout`);
+    const length = Number(response.headers.get("content-length") ?? 0);
+    if (length > 25 * 1024 * 1024)
+        throw new Error("GitHub tree preflight response exceeds 25 MiB");
+    if (!response.body)
+        throw new Error("GitHub tree preflight response has no body");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > 25 * 1024 * 1024) {
+            await reader.cancel();
+            throw new Error("GitHub tree preflight response exceeds 25 MiB");
+        }
+        chunks.push(value);
+    }
+    const bytes = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+    let value;
+    try {
+        value = JSON.parse(bytes.toString("utf8"));
+    }
+    catch {
+        throw new Error("GitHub tree preflight returned invalid JSON");
+    }
+    validateGitHubTreeBounds(value, options);
+}
+async function isolatedGitEnvironment(root) {
+    const sandbox = join(root, ".loadout-git-sandbox");
+    const hooks = join(sandbox, "hooks");
+    const templates = join(sandbox, "templates");
+    const config = join(sandbox, "empty.gitconfig");
+    await Promise.all([ensureDirectory(hooks), ensureDirectory(templates)]);
+    await writeFile(config, "", { flag: "a", mode: 0o600 });
+    const inherited = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+    return {
+        ...inherited,
+        GIT_CONFIG_NOSYSTEM: "1",
+        GIT_CONFIG_SYSTEM: config,
+        GIT_CONFIG_GLOBAL: config,
+        GIT_TEMPLATE_DIR: templates,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_LFS_SKIP_SMUDGE: "1",
+        GIT_CONFIG_COUNT: "2",
+        GIT_CONFIG_KEY_0: "core.hooksPath",
+        GIT_CONFIG_VALUE_0: hooks,
+        GIT_CONFIG_KEY_1: "credential.helper",
+        GIT_CONFIG_VALUE_1: "",
+    };
+}
+/** Stable on-disk location used to retain fetched repository revisions. */
+export function repositoryCachePath(repository, commit) {
+    return join(loadoutHome(), "cache", repository.replace("/", "__"), commit);
+}
+export function normalizeRepository(input) {
+    const value = input
+        .replace(/^https?:\/\/github\.com\//, "")
+        .replace(/^git@github\.com:/, "")
+        .replace(/\.git$/, "")
+        .replace(/\/$/, "");
+    if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(value)) {
+        throw new Error(`Expected a public GitHub repository like owner/repo, received: ${input}`);
+    }
+    return value;
+}
+function normalizeRef(ref) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(ref) ||
+        ref.includes("..") ||
+        ref.endsWith("/"))
+        throw new Error(`Invalid Git ref: ${ref}`);
+    return ref;
+}
+export async function fetchRepositorySnapshot(input, options = {}) {
+    const repository = normalizeRepository(input);
+    const gitEnvironment = await isolatedGitEnvironment(loadoutHome());
+    const ref = options.ref ? normalizeRef(options.ref) : undefined;
+    if (ref && /^[0-9a-f]{40}$/i.test(ref)) {
+        const cached = repositoryCachePath(repository, ref);
+        let reusable = false;
+        try {
+            const [{ stdout: head }, { stdout: status }] = await Promise.all([
+                execFileAsync("git", ["-C", cached, "rev-parse", "HEAD"], {
+                    timeout: options.timeoutMs,
+                    env: gitEnvironment,
+                }),
+                execFileAsync("git", ["-C", cached, "status", "--porcelain"], {
+                    timeout: options.timeoutMs,
+                    env: gitEnvironment,
+                }),
+            ]);
+            reusable =
+                head.trim().toLowerCase() === ref.toLowerCase() && status.trim() === "";
+        }
+        catch {
+            /* missing or modified cache: fetch a clean reviewed snapshot below */
+        }
+        if (reusable) {
+            await enforceRepositoryBounds(cached, options);
+            return { repository, commit: ref, path: cached };
+        }
+    }
+    const temporary = await mkdtemp(join(tmpdir(), "loadout-repository-"));
+    try {
+        const url = `https://github.com/${repository}.git`;
+        const gitOptions = {
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: options.timeoutMs,
+            env: {
+                ...gitEnvironment,
+            },
+        };
+        if (ref && /^[0-9a-f]{40}$/i.test(ref)) {
+            // `git clone --branch` accepts branch or tag names, not an arbitrary
+            // reviewed commit. Fetch the immutable catalog commit directly so a
+            // later default-branch change cannot alter what Loadout installs.
+            await execFileAsync("git", ["init", "--quiet", temporary], gitOptions);
+            await execFileAsync("git", ["-C", temporary, "remote", "add", "origin", url], gitOptions);
+            await execFileAsync("git", [
+                "-C",
+                temporary,
+                "fetch",
+                "--depth",
+                "1",
+                ...(options.maxBytes !== undefined || options.maxFiles !== undefined
+                    ? ["--filter=blob:none"]
+                    : []),
+                "origin",
+                ref,
+            ], gitOptions);
+            const { stdout: fetchedCommit } = await execFileAsync("git", ["-C", temporary, "rev-parse", "FETCH_HEAD"], gitOptions);
+            await enforceGitHubTreeBounds(repository, fetchedCommit.trim(), options);
+            await execFileAsync("git", ["-C", temporary, "checkout", "--quiet", "--detach", "FETCH_HEAD"], gitOptions);
+        }
+        else {
+            const refArgs = ref ? ["--branch", ref] : [];
+            await execFileAsync("git", [
+                "clone",
+                "--depth",
+                "1",
+                ...refArgs,
+                ...(options.maxBytes !== undefined || options.maxFiles !== undefined
+                    ? ["--filter=blob:none", "--no-checkout"]
+                    : []),
+                "--",
+                url,
+                temporary,
+            ], gitOptions);
+            if (options.maxBytes !== undefined || options.maxFiles !== undefined) {
+                const { stdout: headCommit } = await execFileAsync("git", ["-C", temporary, "rev-parse", "HEAD"], gitOptions);
+                await enforceGitHubTreeBounds(repository, headCommit.trim(), options);
+                await execFileAsync("git", ["-C", temporary, "checkout", "--quiet", "HEAD"], gitOptions);
+            }
+        }
+        const { stdout } = await execFileAsync("git", ["-C", temporary, "rev-parse", "HEAD"], { timeout: options.timeoutMs, env: gitEnvironment });
+        const commit = stdout.trim();
+        if (!/^[0-9a-f]{40}$/i.test(commit))
+            throw new Error(`Git returned an invalid commit for ${repository}`);
+        await enforceRepositoryBounds(temporary, options);
+        const cachePath = repositoryCachePath(repository, commit);
+        await ensureDirectory(join(loadoutHome(), "cache", repository.replace("/", "__")));
+        await rm(cachePath, { recursive: true, force: true });
+        await rename(temporary, cachePath);
+        return { repository, commit, path: cachePath };
+    }
+    catch (error) {
+        await rm(temporary, { recursive: true, force: true });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not fetch ${repository}: ${message}`);
+    }
+}
+function normalizeGitUrl(input) {
+    const value = input.trim();
+    if (value !== input || /[\0\r\n]/.test(value) || value.startsWith("-"))
+        throw new Error("Invalid Git URL");
+    const httpsOrSsh = /^(?:https|ssh):\/\/[^\s]+$/i.test(value);
+    const scp = /^[A-Za-z0-9._-]+@[A-Za-z0-9.-]+:[A-Za-z0-9._~/-]+(?:\.git)?$/.test(value);
+    if (!httpsOrSsh && !scp)
+        throw new Error("Generic Git sources require an HTTPS or SSH URL");
+    if (httpsOrSsh) {
+        const parsed = new URL(value);
+        // Git includes failing command arguments in its error text. Reject URLs
+        // that can embed a token before invoking Git, rather than leaking one in
+        // a clone failure.
+        if (parsed.password || (parsed.protocol === "https:" && parsed.username)) {
+            throw new Error("Git URLs must not embed credentials; use an SSH agent or credential helper");
+        }
+        if (parsed.search || parsed.hash)
+            throw new Error("Git URLs must not include query strings or fragments");
+    }
+    return value;
+}
+/** Fetch a generic Git source without running repository hooks or lifecycle scripts. */
+export async function fetchGitSnapshot(input, options = {}) {
+    if (options.maxBytes !== undefined || options.maxFiles !== undefined)
+        throw new Error("Pre-check size/file bounds are supported only for public GitHub owner/repository sources; refusing an unbounded generic Git clone");
+    const url = normalizeGitUrl(input);
+    const temporary = await mkdtemp(join(tmpdir(), "loadout-git-"));
+    try {
+        const gitEnvironment = await isolatedGitEnvironment(loadoutHome());
+        const refArgs = options.ref ? ["--branch", normalizeRef(options.ref)] : [];
+        await execFileAsync("git", ["clone", "--depth", "1", ...refArgs, "--", url, temporary], {
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: options.timeoutMs,
+            env: {
+                ...gitEnvironment,
+            },
+        });
+        const { stdout } = await execFileAsync("git", ["-C", temporary, "rev-parse", "HEAD"], { timeout: options.timeoutMs, env: gitEnvironment });
+        const commit = stdout.trim();
+        if (!/^[0-9a-f]{40}$/i.test(commit))
+            throw new Error("Git returned an invalid commit");
+        await enforceRepositoryBounds(temporary, options);
+        const key = createHash("sha256").update(url).digest("hex");
+        const cachePath = join(loadoutHome(), "cache", "git", key, commit);
+        await ensureDirectory(join(loadoutHome(), "cache", "git", key));
+        await rm(cachePath, { recursive: true, force: true });
+        await rename(temporary, cachePath);
+        return { repository: url, commit, path: cachePath };
+    }
+    catch (error) {
+        await rm(temporary, { recursive: true, force: true });
+        throw new Error(`Could not fetch Git source: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/src/core/state.js

@@ -0,0 +1,300 @@
+import { createHash } from "node:crypto";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { basename, join, relative, sep } from "node:path";
+import { formatSchemaError, installStateSchema } from "../shared/schemas.js";
+import { ensureDirectory, loadoutHome } from "./paths.js";
+import { writeFileAtomically } from "./atomic-file.js";
+const stateFile = () => join(loadoutHome(), "state.json");
+export const installStatePath = () => stateFile();
+export async function writeInstallState(state) {
+    await ensureDirectory(loadoutHome());
+    await writeFileAtomically(stateFile(), `${JSON.stringify(state, null, 2)}\n`);
+}
+export async function readInstallState() {
+    try {
+        const parsed = JSON.parse(await readFile(stateFile(), "utf8"));
+        const result = installStateSchema.safeParse(parsed);
+        if (!result.success)
+            throw new Error(formatSchemaError(result.error));
+        return result.data;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return { version: 1, installs: [], mcpInstalls: [], activations: [] };
+        }
+        throw new Error(`Loadout state is invalid at ${stateFile()}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function activationLibraryPath(packageId, agent, unitId) {
+    const safe = packageId.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 80);
+    const suffix = createHash("sha256")
+        .update(packageId)
+        .digest("hex")
+        .slice(0, 10);
+    const base = join(loadoutHome(), "library", `${safe || "package"}-${suffix}`, agent);
+    if (!unitId)
+        return base;
+    const safeUnit = unitId.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 80);
+    const unitSuffix = createHash("sha256")
+        .update(unitId)
+        .digest("hex")
+        .slice(0, 8);
+    return join(base, `${safeUnit || "skill"}-${unitSuffix}`);
+}
+function activationRecordsForPlan(plan, metadata = {}) {
+    const now = new Date().toISOString();
+    return plan.targetAgents.flatMap((agent) => {
+        const targets = [
+            ...new Set(plan.files
+                .filter((file) => (file.componentType === undefined ||
+                file.componentType === "skill") &&
+                (file.targetAgent === agent ||
+                    (!file.targetAgent && plan.targetAgents.length === 1)))
+                .map((file) => file.target)),
+        ];
+        return targets.map((activePath) => {
+            const unitId = basename(activePath);
+            return {
+                packageId: plan.packageId,
+                unitId,
+                agent,
+                cacheState: "missing",
+                reviewState: metadata.reviewed ? "reviewed" : "unreviewed",
+                installationState: "installed",
+                activationState: "active",
+                libraryPath: activationLibraryPath(plan.packageId, agent, unitId),
+                targets: [
+                    {
+                        activePath,
+                        libraryRelativePath: unitId,
+                    },
+                ],
+                libraryFiles: [],
+                updatedAt: now,
+            };
+        });
+    });
+}
+function mergeActivationRecords(current, records) {
+    const keys = new Set(records.map((item) => `${item.packageId}\0${item.agent}\0${item.unitId ?? ""}`));
+    return [
+        ...(current ?? []).filter((item) => !keys.has(`${item.packageId}\0${item.agent}\0${item.unitId ?? ""}`)),
+        ...records,
+    ].sort((left, right) => left.packageId.localeCompare(right.packageId) ||
+        left.agent.localeCompare(right.agent) ||
+        (left.unitId ?? "").localeCompare(right.unitId ?? ""));
+}
+export async function hashDirectory(root) {
+    const files = [];
+    async function visit(directory) {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                throw new Error(`Refusing symlink while hashing installed files: ${path}`);
+            if (entry.isDirectory())
+                await visit(path);
+            else if (entry.isFile()) {
+                const content = await readFile(path);
+                files.push({
+                    path,
+                    sha256: createHash("sha256").update(content).digest("hex"),
+                });
+            }
+        }
+    }
+    let rootInfo;
+    try {
+        rootInfo = await stat(root);
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    if (!rootInfo.isDirectory())
+        return [];
+    await visit(root);
+    return files;
+}
+export async function recordInstall(plan, snapshotId, metadata = {}) {
+    const record = await createInstallRecord(plan, snapshotId, metadata);
+    const state = await readInstallState();
+    state.installs = [
+        ...state.installs.filter((entry) => entry.packageId !== record.packageId),
+        record,
+    ];
+    state.activations = mergeActivationRecords(state.activations, activationRecordsForPlan(plan, metadata));
+    await writeInstallState(state);
+    return record;
+}
+async function createInstallRecord(plan, snapshotId, metadata = {}) {
+    const files = (await Promise.all([...new Set(plan.files.map((file) => file.target))].map(hashDirectory))).flat();
+    return {
+        packageId: plan.packageId,
+        ...metadata,
+        targetAgents: [...plan.targetAgents],
+        files,
+        snapshotId,
+        installedAt: new Date().toISOString(),
+    };
+}
+export async function recordInstallBatch(entries, snapshotId) {
+    const records = await Promise.all(entries.map((entry) => createInstallRecord(entry.plan, snapshotId, entry.metadata)));
+    const state = await readInstallState();
+    const ids = new Set(records.map((record) => record.packageId));
+    state.installs = [
+        ...state.installs.filter((entry) => !ids.has(entry.packageId)),
+        ...records,
+    ];
+    state.activations = mergeActivationRecords(state.activations, entries.flatMap((entry) => activationRecordsForPlan(entry.plan, entry.metadata)));
+    await writeInstallState(state);
+    return records;
+}
+/**
+ * Record reviewed skills that were copied into Loadout's library but were not
+ * activated. Install hashes deliberately use their future active paths so the
+ * existing enable/disable verifier can prove the same bytes end to end.
+ */
+export async function recordLibraryInstallBatch(entries, snapshotId) {
+    const now = new Date().toISOString();
+    const activationRecords = [];
+    const records = [];
+    for (const entry of entries) {
+        const installFiles = [];
+        const targetAgents = [];
+        for (const agent of entry.plan.targetAgents) {
+            const planned = entry.plan.files.filter((file) => (file.componentType === undefined ||
+                file.componentType === "skill") &&
+                (file.targetAgent === agent ||
+                    (!file.targetAgent && entry.plan.targetAgents.length === 1)));
+            if (!planned.length)
+                continue;
+            targetAgents.push(agent);
+            const targets = [
+                ...new Map(planned.map((file) => [
+                    file.target,
+                    {
+                        activePath: file.target,
+                        libraryRelativePath: basename(file.target),
+                    },
+                ])).values(),
+            ];
+            for (const target of targets) {
+                const unitId = target.libraryRelativePath;
+                const libraryPath = activationLibraryPath(entry.plan.packageId, agent, unitId);
+                const libraryFiles = [];
+                const libraryTarget = join(libraryPath, target.libraryRelativePath);
+                for (const file of await hashDirectory(libraryTarget)) {
+                    const child = relative(libraryTarget, file.path);
+                    installFiles.push({
+                        path: join(target.activePath, child),
+                        sha256: file.sha256,
+                    });
+                    libraryFiles.push({
+                        path: join(target.libraryRelativePath, child).split(sep).join("/"),
+                        sha256: file.sha256,
+                    });
+                }
+                activationRecords.push({
+                    packageId: entry.plan.packageId,
+                    unitId,
+                    agent,
+                    cacheState: "downloaded",
+                    reviewState: entry.metadata?.reviewed ? "reviewed" : "unreviewed",
+                    installationState: "installed",
+                    activationState: "disabled",
+                    libraryPath,
+                    targets: [target],
+                    libraryFiles: libraryFiles.sort((left, right) => left.path.localeCompare(right.path)),
+                    updatedAt: now,
+                    snapshotId,
+                });
+            }
+        }
+        records.push({
+            packageId: entry.plan.packageId,
+            ...(entry.metadata?.repository
+                ? { repository: entry.metadata.repository }
+                : {}),
+            ...(entry.metadata?.resolvedCommit
+                ? { resolvedCommit: entry.metadata.resolvedCommit }
+                : {}),
+            targetAgents,
+            files: installFiles.sort((left, right) => left.path.localeCompare(right.path)),
+            snapshotId,
+            installedAt: now,
+        });
+    }
+    const state = await readInstallState();
+    const ids = new Set(records.map((record) => record.packageId));
+    state.installs = [
+        ...state.installs.filter((record) => !ids.has(record.packageId)),
+        ...records,
+    ];
+    state.activations = mergeActivationRecords(state.activations, activationRecords);
+    await writeInstallState(state);
+    return records;
+}
+function mcpFingerprint(plan) {
+    const servers = (plan.proposed.mcpServers ?? {});
+    return createHash("sha256")
+        .update(JSON.stringify(servers[plan.serverName] ?? null))
+        .digest("hex");
+}
+export async function recordInstallTransaction(entries, mcpEntries, snapshotId) {
+    const installs = await Promise.all(entries.map((entry) => createInstallRecord(entry.plan, snapshotId, entry.metadata)));
+    const now = new Date().toISOString();
+    const mcpInstalls = mcpEntries.flatMap((entry) => entry.plan.changes.map((change) => ({
+        packageId: entry.packageId,
+        configPath: entry.plan.path,
+        serverName: change.serverName,
+        fingerprint: mcpFingerprint({
+            ...entry.plan,
+            serverName: change.serverName,
+        }),
+        snapshotId,
+        installedAt: now,
+    })));
+    const state = await readInstallState();
+    const ids = new Set([
+        ...installs.map((entry) => entry.packageId),
+        ...mcpInstalls.map((entry) => entry.packageId),
+    ]);
+    state.installs = [
+        ...state.installs.filter((entry) => !ids.has(entry.packageId)),
+        ...installs,
+    ];
+    state.mcpInstalls = [
+        ...(state.mcpInstalls ?? []).filter((entry) => !ids.has(entry.packageId)),
+        ...mcpInstalls,
+    ];
+    state.activations = mergeActivationRecords(state.activations, entries.flatMap((entry) => activationRecordsForPlan(entry.plan, entry.metadata)));
+    await writeInstallState(state);
+    return { installs, mcpInstalls };
+}
+export async function forgetInstall(packageId) {
+    const state = await readInstallState();
+    const installs = state.installs.filter((entry) => entry.packageId !== packageId);
+    if (installs.length === state.installs.length)
+        throw new Error(`Package is not managed by Loadout: ${packageId}`);
+    await writeInstallState({
+        version: 1,
+        installs,
+        mcpInstalls: (state.mcpInstalls ?? []).filter((entry) => entry.packageId !== packageId),
+        activations: (state.activations ?? []).map((entry) => entry.packageId === packageId
+            ? {
+                ...entry,
+                installationState: "removed",
+                activationState: "disabled",
+                updatedAt: new Date().toISOString(),
+            }
+            : entry),
+    });
+}