windows-development-sandbox 1.25.0 → 1.27.0

package/dist/host/pc-installs/unity-assets.d.ts

@@ -0,0 +1,5 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import type { PcInstallSource } from './source.js';
+/** The Asset Store folders as installs to map. */
+export declare function unityAssetInstalls(dirs: readonly string[]): PcInstall[];
+export declare const unityAssets: PcInstallSource;

package/dist/host/pc-installs/unity-assets.js

@@ -0,0 +1,18 @@
+import { assetCacheEnv, unityAssetCacheDirs, unityPcFiles } from './unity.js';
+/** The Asset Store folders as installs to map. */
+export function unityAssetInstalls(dirs) {
+    return dirs.map((dir, i) => ({
+        kind: 'unity-assets',
+        id: i ? 'AssetStore' + (i + 1) : 'AssetStore',
+        name: 'Unity Asset Store downloads' + (i ? ' ' + (i + 1) : ''),
+        host: dir,
+        guest: '',
+    }));
+}
+export const unityAssets = {
+    kind: 'unity-assets',
+    setting: 'unityAssets',
+    find(_wanted, pc) {
+        return unityAssetInstalls(unityAssetCacheDirs(unityPcFiles(pc), assetCacheEnv(pc)));
+    },
+};

package/dist/host/pc-installs/unity.d.ts

@@ -1,2 +1,22 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import type { PcEnv } from '../accounts/index.js';
 import type { PcInstallSource } from './source.js';
+/** At most this many editors of this PC are mapped. */
+export declare const MAX_PC_EDITORS = 12;
+/** The files and folders of this PC the search reads (the self-test passes its own). */
+export interface UnityPcFiles {
+    read(file: string, max: number): Buffer | null;
+    isDir(dir: string): boolean;
+    list(dir: string): string[];
+    readonly appData: string;
+    readonly programFiles: string;
+}
+/** The editors of this PC: all of them (true) or the listed versions. Each version once, each folder once. */
+export declare function findUnityEditorsOnPc(files: UnityPcFiles, wanted: true | readonly string[]): PcInstall[];
+/** The Asset Store-5.x folders of this PC (the environment's cache root first, then %APPDATA%\Unity), to map. */
+export declare function unityAssetCacheDirs(files: UnityPcFiles, envValue: string | undefined): string[];
+/** This PC's disk for the search. */
+export declare function unityPcFiles(pc: PcEnv): UnityPcFiles;
+/** The cache root the environment names: this terminal's variable, else the saved user one. */
+export declare function assetCacheEnv(pc: PcEnv): string | undefined;
 export declare const unityInstalls: PcInstallSource;

package/dist/host/pc-installs/unity.js

@@ -1,7 +1,140 @@
+// Unity editors of this PC (pcInstalls.unityEditors): Unity Hub's default folder (<Program Files>\Unity\Hub\Editor),
+// the folder named by %APPDATA%\UnityHub\secondaryInstallPath.json and the editors in editors-v2.json. An editor counts
+// only with Editor\Unity.exe; its folder is mapped read-only at C:\PcInstalls\unity\<version>. Every file is read
+// bounded and every name is checked: what Hub wrote is data, never trusted.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { readBoundedFile } from '../../shared/io/index.js';
+import { assetStoreDir, pcAssetCacheDirs, UNITY_VERSION } from '../../shared/unity/index.js';
+const win = path.win32;
+/** At most this many editors of this PC are mapped. */
+export const MAX_PC_EDITORS = 12;
+const MAX_SECONDARY_BYTES = 4 * 1024;
+const MAX_EDITORS_FILE_BYTES = 1024 * 1024;
+const MAX_EDITOR_ENTRIES = 200;
+const MAX_LISTED = 500;
+const EditorsFileSchema = z.union([
+    z.array(z.unknown()).max(MAX_EDITOR_ENTRIES),
+    z.object({ data: z.array(z.unknown()).max(MAX_EDITOR_ENTRIES) }).passthrough(),
+]);
+const EditorEntrySchema = z
+    .object({
+    version: z.string().max(40),
+    location: z.union([z.string().max(1000), z.array(z.string().max(1000)).max(8)]),
+})
+    .passthrough();
+function jsonOf(files, file, max) {
+    const bytes = files.read(file, max);
+    if (!bytes)
+        return null;
+    try {
+        return JSON.parse(bytes.toString('utf8').replace(/^\uFEFF/, ''));
+    }
+    catch {
+        return null; // Not JSON: Hub's file is ignored.
+    }
+}
+/** The folder in secondaryInstallPath.json (a JSON string, absolute only), or null. */
+function secondaryRoot(files) {
+    const json = jsonOf(files, win.join(files.appData, 'UnityHub', 'secondaryInstallPath.json'), MAX_SECONDARY_BYTES);
+    return typeof json === 'string' && json.length < 1000 && win.isAbsolute(json) ? win.normalize(json) : null;
+}
+const hasEditorExe = (root, files) => files.list(win.join(root, 'Editor')).some((n) => n.toLowerCase() === 'unity.exe');
+/** The editors editors-v2.json lists: only `...\Editor\Unity.exe`, the root two levels up. */
+function listedEditors(files) {
+    const parsed = EditorsFileSchema.safeParse(jsonOf(files, win.join(files.appData, 'UnityHub', 'editors-v2.json'), MAX_EDITORS_FILE_BYTES));
+    if (!parsed.success)
+        return [];
+    const entries = Array.isArray(parsed.data) ? parsed.data : parsed.data.data;
+    const out = [];
+    for (const raw of entries) {
+        const e = EditorEntrySchema.safeParse(raw);
+        if (!e.success)
+            continue;
+        for (const location of [e.data.location].flat()) {
+            const exe = win.normalize(location);
+            if (!win.isAbsolute(exe) || win.basename(exe).toLowerCase() !== 'unity.exe')
+                continue;
+            const editorDir = win.dirname(exe);
+            if (win.basename(editorDir).toLowerCase() !== 'editor')
+                continue;
+            out.push({ version: e.data.version, root: win.dirname(editorDir) });
+        }
+    }
+    return out;
+}
+/** The editors of this PC: all of them (true) or the listed versions. Each version once, each folder once. */
+export function findUnityEditorsOnPc(files, wanted) {
+    const candidates = [];
+    const hubFolders = [win.join(files.programFiles, 'Unity', 'Hub', 'Editor'), secondaryRoot(files)].filter((d) => d !== null);
+    for (const folder of hubFolders)
+        for (const name of files.list(folder).slice(0, MAX_LISTED).sort())
+            if (UNITY_VERSION.test(name))
+                candidates.push({ version: name, root: win.join(folder, name) });
+    candidates.push(...listedEditors(files));
+    const found = [];
+    for (const c of candidates) {
+        if (found.length >= MAX_PC_EDITORS)
+            break;
+        if (!UNITY_VERSION.test(c.version))
+            continue;
+        if (wanted !== true && !wanted.includes(c.version))
+            continue;
+        const key = c.root.toLowerCase();
+        if (found.some((f) => f.id === c.version || f.host.toLowerCase() === key))
+            continue;
+        if (!files.isDir(c.root) || !hasEditorExe(c.root, files))
+            continue;
+        found.push({
+            kind: 'unity',
+            id: c.version,
+            name: 'Unity ' + c.version,
+            version: c.version,
+            host: c.root,
+            guest: '',
+        });
+    }
+    return found;
+}
+/** The Asset Store-5.x folders of this PC (the environment's cache root first, then %APPDATA%\Unity), to map. */
+export function unityAssetCacheDirs(files, envValue) {
+    return pcAssetCacheDirs({ appData: files.appData, envValue }, files.isDir).map(assetStoreDir);
+}
+function listDir(dir) {
+    try {
+        return fs.readdirSync(dir).slice(0, MAX_LISTED);
+    }
+    catch {
+        return []; // Not a folder: nothing in it.
+    }
+}
+function isDir(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** This PC's disk for the search. */
+export function unityPcFiles(pc) {
+    return {
+        read: readBoundedFile,
+        isDir,
+        list: listDir,
+        appData: pc.appData,
+        programFiles: pc.programFiles ?? 'C:\\Program Files',
+    };
+}
+/** The cache root the environment names: this terminal's variable, else the saved user one. */
+export function assetCacheEnv(pc) {
+    return pc.env?.ASSETSTORE_CACHE_PATH ?? pc.userVariable?.('ASSETSTORE_CACHE_PATH') ?? undefined;
+}
 export const unityInstalls = {
     kind: 'unity',
     setting: 'unityEditors',
-    find(_wanted, _pc) {
-        return [];
+    find(wanted, pc) {
+        return findUnityEditorsOnPc(unityPcFiles(pc), wanted === true ? true : wanted.map(String));
     },
 };

package/dist/host/pc-installs/unreal-vault.d.ts

@@ -0,0 +1,11 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import { type VaultFs } from '../../shared/unreal/index.js';
+import type { PcEnv } from '../accounts/index.js';
+import type { PcInstallSource } from './source.js';
+/** The vault cache folders of this PC: the ones its launcher settings name, else the default. */
+export declare function vaultDirs(pc: Pick<PcEnv, 'localAppData' | 'programData'>, isDir: (dir: string) => boolean): string[];
+/** The vault folders as installs to map (read-only). */
+export declare function vaultInstalls(dirs: readonly string[]): PcInstall[];
+/** This PC's disk for vaultPacks (bounded lists). */
+export declare const PC_VAULT_FS: VaultFs;
+export declare const unrealVault: PcInstallSource;

package/dist/host/pc-installs/unreal-vault.js

@@ -0,0 +1,78 @@
+// The Epic Games Launcher's vault cache of this PC (pcInstalls.unrealAssets): the Fab and Marketplace packs you
+// downloaded, mapped read-only at C:\PcInstalls\unreal\Vault (Vault2 ... for more folders), so what you download on the
+// PC is in the sandbox at once. Its folders come from the launcher's settings (shared/unreal/vault.ts), else the
+// default one; only folders that exist are mapped.
+import fs from 'node:fs';
+import path from 'node:path';
+import { epicSettingsFiles, MAX_EPIC_INI_BYTES } from '../../shared/accounts/index.js';
+import { decodeText, readBoundedFile } from '../../shared/io/index.js';
+import { defaultVaultDir, vaultDirsFromIni } from '../../shared/unreal/index.js';
+const MAX_VAULTS = 4;
+/** The vault cache folders of this PC: the ones its launcher settings name, else the default. */
+export function vaultDirs(pc, isDir) {
+    const named = pc.localAppData
+        ? epicSettingsFiles(pc.localAppData).flatMap((file) => {
+            const bytes = readBoundedFile(file, MAX_EPIC_INI_BYTES);
+            return bytes ? vaultDirsFromIni(decodeText(bytes).text) : [];
+        })
+        : [];
+    const all = [...named, defaultVaultDir(pc.programData)];
+    return all
+        .filter((d, i) => all.findIndex((o) => o.toLowerCase() === d.toLowerCase()) === i)
+        .filter(isDir)
+        .slice(0, MAX_VAULTS);
+}
+/** The vault folders as installs to map (read-only). */
+export function vaultInstalls(dirs) {
+    return dirs.map((dir, i) => ({
+        kind: 'unreal-vault',
+        id: i ? 'Vault' + (i + 1) : 'Vault',
+        name: 'Epic Games Launcher vault cache' + (i ? ' ' + (i + 1) : ''),
+        host: dir,
+        guest: '',
+    }));
+}
+const isDir = (dir) => {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+/** This PC's disk for vaultPacks (bounded lists). */
+export const PC_VAULT_FS = {
+    exists: (file) => fs.existsSync(file),
+    list: (dir) => {
+        try {
+            return fs.readdirSync(dir).slice(0, 5000);
+        }
+        catch {
+            return []; // Not a folder: nothing in it.
+        }
+    },
+    size: (file) => {
+        try {
+            const s = fs.lstatSync(file);
+            return s.isFile() ? s.size : null;
+        }
+        catch {
+            return null;
+        }
+    },
+    isDir: (dir) => {
+        try {
+            return fs.lstatSync(dir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+};
+export const unrealVault = {
+    kind: 'unreal-vault',
+    setting: 'unrealAssets',
+    find(_wanted, pc) {
+        return vaultInstalls(vaultDirs(pc, isDir)).map((v) => ({ ...v, host: path.win32.normalize(v.host) }));
+    },
+};

package/dist/host/pc-installs/unreal.d.ts

@@ -1,2 +1,38 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import type { PcEnv } from '../accounts/index.js';
 import type { PcInstallSource } from './source.js';
+/** At most this many engines of this PC are mapped. */
+export declare const MAX_PC_ENGINES = 8;
+/** What discovery reads on this PC (the self-test passes fixtures). */
+export interface UnrealPcFiles {
+    /** LauncherInstalled.dat's text, or null. */
+    readonly launcherInstalled: string | null;
+    /** `reg query HKCU\Software\Epic Games\Unreal Engine\Builds` output ('' when the key is missing). */
+    readonly builds: string;
+    /** The launcher's default engines folder (<Program Files>\Epic Games). */
+    readonly defaultRoot: string;
+    readonly list: (dir: string) => string[];
+    readonly read: (file: string, max: number) => Buffer | null;
+}
+/** The values of `reg query <key>` output: the name and string of each REG_SZ / REG_EXPAND_SZ line. */
+export declare function regValues(text: string): {
+    name: string;
+    value: string;
+}[];
+/** The engines of this PC that `wanted` maps, each folder once, at most MAX_PC_ENGINES. */
+export declare function findUnrealInstalls(files: UnrealPcFiles, wanted: true | readonly (string | number)[]): PcInstall[];
+/** A source build of this PC's Builds key. */
+export interface PcSourceBuild {
+    readonly buildId: string;
+    readonly version: string;
+    readonly host: string;
+}
+/** Source builds this PC registered (the Builds key). They are not mapped by themselves: UBT writes inside them. */
+export declare function pcSourceBuilds(files: Pick<UnrealPcFiles, 'read' | 'builds'>): PcSourceBuild[];
+/** The engine folders you registered (pcInstalls.unrealEngineFolders), mapped writable. A folder that is a source
+ * build of this PC keeps the PC's build id. */
+export declare function findEngineFolders(files: Pick<UnrealPcFiles, 'read' | 'builds'>, folders: readonly (string | number)[]): PcInstall[];
+/** This PC's files (reg.exe through system32, bounded reads). */
+export declare function unrealPcFiles(pc: PcEnv): UnrealPcFiles;
 export declare const unrealInstalls: PcInstallSource;
+export declare const unrealFolders: PcInstallSource;

package/dist/host/pc-installs/unreal.js

@@ -1,7 +1,150 @@
+// Unreal Engine versions of this PC (pcInstalls.unrealEngines): the launcher's LauncherInstalled.dat (engines it
+// installed, with its own ids) and the launcher's default folders (<Program Files>\Epic Games\UE_*, for an install
+// whose LauncherInstalled.dat is gone). Each must hold Engine\Build\Build.version; it is mapped read-only at
+// C:\PcInstalls\unreal\UE_5.4. Source builds (HKCU\Software\Epic Games\Unreal Engine\Builds) are NOT mapped by
+// themselves, as UBT writes inside an engine. pcInstalls.unrealEngineFolders: folders you registered, mapped writable
+// (dir-<name>; a source build of this PC keeps its build id). Every file is read bounded.
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { readBoundedFile } from '../../shared/io/index.js';
+import { SYSTEM } from '../../shared/system.js';
+import { BUILDS_KEY, launcherInstallations, launcherInstalledFile, MAX_LAUNCHER_FILE_BYTES, parseBuildVersion, versionText, } from '../../shared/unreal/index.js';
+const win = path.win32;
+/** At most this many engines of this PC are mapped. */
+export const MAX_PC_ENGINES = 8;
+const APP_NAME = /^UE_(\d{1,2}\.\d{1,2})$/;
+/** The values of `reg query <key>` output: the name and string of each REG_SZ / REG_EXPAND_SZ line. */
+export function regValues(text) {
+    return text
+        .split(/\r?\n/)
+        .slice(0, 500)
+        .flatMap((line) => {
+        const m = /^\s{2,}(\S(?:.{0,200}?\S)?)\s{2,}REG_(?:EXPAND_)?SZ\s{2,}(.{1,1000})$/.exec(line);
+        return m ? [{ name: m[1], value: m[2].trim() }] : [];
+    });
+}
+const versionOf = (dir, files) => {
+    const bytes = files.read(win.join(dir, 'Engine', 'Build', 'Build.version'), 64 * 1024);
+    return bytes ? parseBuildVersion(bytes.toString('utf8')) : null;
+};
+const isWanted = (wanted, v) => wanted === true || wanted.map((w) => String(w).replace(/^UE_/i, '')).includes(v.major + '.' + v.minor);
+/** The engines of this PC that `wanted` maps, each folder once, at most MAX_PC_ENGINES. */
+export function findUnrealInstalls(files, wanted) {
+    const found = [];
+    const add = (install) => {
+        const key = win.resolve(install.host).toLowerCase();
+        if (found.length >= MAX_PC_ENGINES)
+            return;
+        if (found.some((f) => f.id === install.id || win.resolve(f.host).toLowerCase() === key))
+            return;
+        found.push(install);
+    };
+    const installed = (dir, ids) => {
+        const v = versionOf(dir, files);
+        if (!v || !isWanted(wanted, v))
+            return;
+        add({
+            kind: 'unreal',
+            id: 'UE_' + v.major + '.' + v.minor,
+            name: 'Unreal Engine ' + versionText(v),
+            version: versionText(v),
+            host: win.normalize(dir),
+            guest: '',
+            ...(ids ? { launcher: ids } : {}),
+        });
+    };
+    for (const i of files.launcherInstalled ? launcherInstallations(files.launcherInstalled) : [])
+        if (APP_NAME.test(i.appName))
+            installed(i.installLocation, i.ids ?? undefined);
+    for (const name of files
+        .list(files.defaultRoot)
+        .filter((n) => APP_NAME.test(n))
+        .sort())
+        installed(win.join(files.defaultRoot, name));
+    return found;
+}
+/** Source builds this PC registered (the Builds key). They are not mapped by themselves: UBT writes inside them. */
+export function pcSourceBuilds(files) {
+    const found = [];
+    for (const { name, value } of regValues(files.builds)) {
+        const dir = value.replace(/\//g, '\\');
+        if (!win.isAbsolute(dir) || found.length >= MAX_PC_ENGINES)
+            continue;
+        const v = versionOf(dir, files);
+        if (v)
+            found.push({ buildId: name.slice(0, 64), version: versionText(v), host: win.normalize(dir) });
+    }
+    return found;
+}
+/** The engine folders you registered (pcInstalls.unrealEngineFolders), mapped writable. A folder that is a source
+ * build of this PC keeps the PC's build id. */
+export function findEngineFolders(files, folders) {
+    const found = [];
+    const sources = pcSourceBuilds(files);
+    for (const raw of folders.map(String)) {
+        const dir = win.normalize(raw);
+        if (!win.isAbsolute(dir) || found.some((f) => f.host.toLowerCase() === dir.toLowerCase()))
+            continue;
+        const v = versionOf(dir, files);
+        if (!v)
+            continue;
+        const base = win
+            .basename(dir)
+            .replace(/[^A-Za-z0-9._-]/g, '')
+            .replace(/^\.+/, '')
+            .slice(0, 40) || 'engine';
+        const id = 'dir-' + base;
+        const source = sources.find((b) => b.host.toLowerCase() === dir.toLowerCase());
+        found.push({
+            kind: 'unreal',
+            id: found.some((f) => f.id === id) ? id + '-' + (found.length + 1) : id,
+            name: 'Unreal Engine ' + versionText(v) + ' (' + win.basename(dir).slice(0, 60) + ')',
+            version: versionText(v),
+            host: dir,
+            guest: '',
+            writable: true,
+            ...(source ? { buildId: source.buildId } : {}),
+        });
+    }
+    return found;
+}
+function listDir(dir) {
+    try {
+        return fs.readdirSync(dir).slice(0, 500);
+    }
+    catch {
+        return []; // Not there: nothing in it.
+    }
+}
+/** This PC's files (reg.exe through system32, bounded reads). */
+export function unrealPcFiles(pc) {
+    const query = spawnSync(SYSTEM.reg(), ['query', 'HKCU\\' + BUILDS_KEY], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 15_000,
+        maxBuffer: 256 * 1024,
+    });
+    const dat = readBoundedFile(launcherInstalledFile(pc.programData), MAX_LAUNCHER_FILE_BYTES);
+    return {
+        launcherInstalled: dat ? dat.toString('utf8') : null,
+        builds: query.status === 0 ? String(query.stdout ?? '') : '',
+        defaultRoot: win.join(pc.programFiles ?? 'C:\\Program Files', 'Epic Games'),
+        list: listDir,
+        read: readBoundedFile,
+    };
+}
 export const unrealInstalls = {
     kind: 'unreal',
     setting: 'unrealEngines',
-    find(_wanted, _pc) {
-        return [];
+    find(wanted, pc) {
+        return findUnrealInstalls(unrealPcFiles(pc), wanted);
+    },
+};
+export const unrealFolders = {
+    kind: 'unreal',
+    setting: 'unrealEngineFolders',
+    find(wanted, pc) {
+        return wanted === true ? [] : findEngineFolders(unrealPcFiles(pc), wanted);
     },
 };

package/dist/host/profile/claude-profile.d.ts

@@ -1,5 +1,13 @@
 import type { ClaudeProfileConfig, ProfileResult } from '../../core/types.js';
 import { type SecretsConfig } from './secrets.js';
+/**
+ * Which parts of your plugins folder are staged, as a filter over full paths. Everything Claude needs to load a plugin
+ * (installed_plugins.json, marketplaces, the plugin cache) is kept; when that is over the size cap, git history
+ * (`.git`) and then `node_modules` are left out, and the guest's plugins restore what they need on first use.
+ */
+export declare function pluginFilter(source: string, level: 0 | 1 | 2): (full: string) => boolean;
+/** The least trimmed level at which the plugins folder fits the cap, or null when even the most trimmed does not. */
+export declare function pluginTrimLevel(source: string): 0 | 1 | 2 | null;
 export declare function hostClaudeDir(settings: ClaudeProfileConfig): string;
 export declare function hostGlobalStateFile(settings: ClaudeProfileConfig): string;
 /**

package/dist/host/profile/claude-profile.js

@@ -5,17 +5,54 @@ import { dirExists, ensureDir, fileExists, homeDir, isLink, readJson, writeJson
 import { stripMcpServers, stripSettings } from './secrets.js';
 const MAX_BYTES = 250 * 1024 * 1024;
 /** Real files only: a link inside ~/.claude (even a loop or a dead one) is neither followed nor counted nor copied. */
-function directorySize(dir) {
+function directorySize(dir, keep = () => true) {
     let total = 0;
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const full = path.join(dir, entry.name);
+        if (!keep(full))
+            continue;
         if (entry.isDirectory())
-            total += directorySize(full);
+            total += directorySize(full, keep);
         else if (entry.isFile())
             total += fs.statSync(full).size;
     }
     return total;
 }
+/** Plugin leftovers Claude never reads: interrupted clones (temp_*) and marketplace backups. */
+function isPluginJunk(parts) {
+    const top = parts[0]?.toLowerCase();
+    const name = parts[1]?.toLowerCase() ?? '';
+    return (parts.length >= 2 &&
+        (top === 'cache' || top === 'marketplaces') &&
+        (name.startsWith('temp_') || name.endsWith('.backup') || name.endsWith('.staging')));
+}
+/**
+ * Which parts of your plugins folder are staged, as a filter over full paths. Everything Claude needs to load a plugin
+ * (installed_plugins.json, marketplaces, the plugin cache) is kept; when that is over the size cap, git history
+ * (`.git`) and then `node_modules` are left out, and the guest's plugins restore what they need on first use.
+ */
+export function pluginFilter(source, level) {
+    return (full) => {
+        if (full === source)
+            return true;
+        const parts = path.relative(source, full).split(path.sep);
+        if (isPluginJunk(parts))
+            return false;
+        if (level >= 1 && parts.includes('.git'))
+            return false;
+        if (level >= 2 && parts.includes('node_modules'))
+            return false;
+        return true;
+    };
+}
+/** The least trimmed level at which the plugins folder fits the cap, or null when even the most trimmed does not. */
+export function pluginTrimLevel(source) {
+    for (const level of [0, 1, 2]) {
+        if (directorySize(source, pluginFilter(source, level)) <= MAX_BYTES)
+            return level;
+    }
+    return null;
+}
 function validJson(file) {
     try {
         JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
@@ -84,14 +121,16 @@ export function stageClaudeProfile(settings, launchPath, workspaceHost, secrets)
                 fs.copyFileSync(source, destination);
         }
         else if (dirExists(source)) {
-            if (directorySize(source) > MAX_BYTES) {
+            const level = name === 'plugins' ? pluginTrimLevel(source) : directorySize(source) > MAX_BYTES ? null : 0;
+            if (level === null) {
                 result.skipped.push(name + ' (over 250 MB)');
                 continue;
             }
+            const keep = name === 'plugins' ? pluginFilter(source, level) : () => true;
             fs.cpSync(source, destination, {
                 recursive: true,
                 force: true,
-                filter: (from) => from === source || !isLink(from),
+                filter: (from) => from === source || (!isLink(from) && keep(from)),
             });
         }
         else {

package/dist/host/profile/index.d.ts

@@ -1,6 +1,6 @@
 export { isSecretName, isSecretValue, mayPass, stripMcpServers, stripSettings, stripVariables, type SecretsConfig, } from './secrets.js';
 export { findSecretFiles } from './secret-files.js';
-export { hostClaudeDir, hostGlobalStateFile, sandboxGlobalState, stageClaudeProfile } from './claude-profile.js';
+export { hostClaudeDir, hostGlobalStateFile, pluginFilter, pluginTrimLevel, sandboxGlobalState, stageClaudeProfile, } from './claude-profile.js';
 export { capturePersonalization } from './personalize.js';
 export { toRegFile, type RegValue } from './reg-file.js';
 export { AccountStore, accountsDir, type Account, type AccountMeta, type AccountRow } from './accounts.js';

package/dist/host/profile/index.js

@@ -1,6 +1,6 @@
 export { isSecretName, isSecretValue, mayPass, stripMcpServers, stripSettings, stripVariables, } from './secrets.js';
 export { findSecretFiles } from './secret-files.js';
-export { hostClaudeDir, hostGlobalStateFile, sandboxGlobalState, stageClaudeProfile } from './claude-profile.js';
+export { hostClaudeDir, hostGlobalStateFile, pluginFilter, pluginTrimLevel, sandboxGlobalState, stageClaudeProfile, } from './claude-profile.js';
 export { capturePersonalization } from './personalize.js';
 export { toRegFile } from './reg-file.js';
 export { AccountStore, accountsDir } from './accounts.js';