windows-development-sandbox 1.25.0 → 1.27.0

package/dist/selftest/github.test.js

@@ -9,7 +9,7 @@ import { pageLines } from '../cli/output/index.js';
 import { DEFAULTS } from '../core/config/index.js';
 import { applyOverrides, normalizeOverrides } from '../core/local-config/index.js';
 import { ConfigSchema, LocalOverridesSchema } from '../core/schema/index.js';
-import { checkGithubToken, GithubToken, githubTokenAllowed, prepareGithubToken, verifyGithubToken, } from '../host/github/index.js';
+import { checkGithubToken, GithubToken, githubTokenAllowed, parseHostsYml, prepareGithubToken, readPcGhLogin, verifyGithubToken, } from '../host/github/index.js';
 import { UserError } from '../core/util/index.js';
 import { report } from '../cli/report.js';
 import { toWireError, fromWireError } from '../app/kernel/index.js';
@@ -288,6 +288,69 @@ export const githubSuite = {
         shareOn.github.shareToken = true;
         t.check(prepareGithubToken(shareOn, shareOn.storage.root, expiring, [], Date.parse('2027-01-30T00:00:00.000Z')).notes.some((n) => n.includes('expires in 5 days')) &&
             !prepareGithubToken(shareOn, shareOn.storage.root, expiring, [], Date.parse('2026-12-01T00:00:00.000Z')).notes.some((n) => n.includes('expires')), 'a launch mentions a token that ends within 7 days, and only then');
+        t.section('the gh login on this PC (github.usePcLogin)');
+        const PC_TOKEN = 'gho_' + 'a'.repeat(36);
+        const KEYRING_TOKEN = 'gho_' + 'b'.repeat(36);
+        const hosts = (token) => [
+            'github.com:',
+            '    users:',
+            '        other:',
+            '            oauth_token: gho_' + 'z'.repeat(36),
+            '        josh:',
+            ...(token ? ['            oauth_token: ' + token] : []),
+            '    git_protocol: https',
+            '    user: josh',
+            '',
+        ].join('\r\n');
+        t.equal(parseHostsYml(hosts(PC_TOKEN)), { signedIn: true, token: PC_TOKEN }, 'hosts.yml: the active user token');
+        t.equal(parseHostsYml('github.com:\n    oauth_token: ' + PC_TOKEN + '\n    user: josh\n'), { signedIn: true, token: PC_TOKEN }, 'hosts.yml: an older file with the token under the host');
+        t.equal(parseHostsYml('ghe.corp:\n    oauth_token: ' + PC_TOKEN + '\n'), { signedIn: false, token: null }, 'hosts.yml: other hosts are not read');
+        t.equal(parseHostsYml(hosts(null)), { signedIn: true, token: null }, 'hosts.yml: a login kept in Credential Manager');
+        t.equal(parseHostsYml(''), { signedIn: false, token: null }, 'hosts.yml: empty');
+        const pcDir = t.dir('github-pc');
+        const pcEnv = { GH_CONFIG_DIR: pcDir, GH_TOKEN: 'x'.repeat(30) };
+        t.check(readPcGhLogin({ env: pcEnv, run: () => 'never' }) === null, 'no hosts.yml: no login, quietly');
+        fs.writeFileSync(path.join(pcDir, 'hosts.yml'), hosts(PC_TOKEN));
+        t.check(readPcGhLogin({ env: pcEnv, run: () => 'never' }) === PC_TOKEN, 'the token is read from hosts.yml');
+        fs.writeFileSync(path.join(pcDir, 'hosts.yml'), hosts(null));
+        t.check(readPcGhLogin({ env: pcEnv, run: () => KEYRING_TOKEN }) === null, 'a keyring login with no gh.exe found: none');
+        const exeDir = t.dir('github-pc-programs');
+        fs.mkdirSync(path.join(exeDir, 'GitHub CLI'), { recursive: true });
+        fs.writeFileSync(path.join(exeDir, 'GitHub CLI', 'gh.exe'), '');
+        const seen = [];
+        const keyring = readPcGhLogin({
+            env: { ...pcEnv, ProgramFiles: exeDir },
+            run: (exe) => (seen.push(exe), KEYRING_TOKEN + '\n'),
+        });
+        t.check(keyring === KEYRING_TOKEN && seen.length === 1 && path.isAbsolute(seen[0] ?? ''), 'a keyring login is read with the PC gh.exe, by absolute path', JSON.stringify([keyring, seen]));
+        t.check(readPcGhLogin({ env: { ...pcEnv, ProgramFiles: exeDir }, run: () => 'not a token' }) === null, 'whatever gh prints must look like a token');
+        const pcConfig = f.makeConfig();
+        pcConfig.github.usePcLogin = true;
+        const pcStore = new GithubToken(pcConfig.storage.root, SecretStore.memory());
+        const pcNoLogin = prepareGithubToken(pcConfig, pcConfig.storage.root, pcStore, [], 0, {
+            env: { GH_CONFIG_DIR: t.dir('github-pc-empty') },
+        });
+        t.equal(pcNoLogin, { notes: [] }, 'on, but the PC has no gh login: nothing is delivered, nothing is said');
+        fs.writeFileSync(path.join(pcDir, 'hosts.yml'), hosts(PC_TOKEN));
+        const pcEnvOnly = { env: { GH_CONFIG_DIR: pcDir } };
+        const pcOn = prepareGithubToken(pcConfig, pcConfig.storage.root, pcStore, [], 0, pcEnvOnly);
+        t.check(pcOn.token === PC_TOKEN && pcOn.notes.length === 1 && !JSON.stringify(pcOn.notes).includes(PC_TOKEN), 'on with a gh login: delivered, and the notes never hold it');
+        pcConfig.github.usePcLogin = false;
+        t.equal(prepareGithubToken(pcConfig, pcConfig.storage.root, pcStore, [], 0, pcEnvOnly), { notes: [] }, 'off: the PC login is not even read');
+        pcConfig.github.usePcLogin = true;
+        pcConfig.github.shareToken = true;
+        pcStore.save(FINE);
+        t.check(prepareGithubToken(pcConfig, pcConfig.storage.root, pcStore, [], 0, pcEnvOnly).token === FINE, 'a token saved for sandboxes wins over the PC login');
+        pcStore.remove();
+        t.check(prepareGithubToken(pcConfig, pcConfig.storage.root, pcStore, [], 0, pcEnvOnly).token === PC_TOKEN, 'with none saved, the PC login is used');
+        pcConfig.provisioning.git.access = 'readonly';
+        const pcStrict = prepareGithubToken(pcConfig, pcConfig.storage.root, pcStore, [], 0, pcEnvOnly);
+        t.check(pcStrict.token === undefined &&
+            !githubTokenAllowed(pcConfig) &&
+            pcStrict.notes.some((n) => n.includes('"readonly"')), 'git access readonly: the PC login is not handed over');
+        const pcSecrets = SecretsFileSchema.safeParse({ githubToken: PC_TOKEN });
+        t.check(pcSecrets.success, 'an OAuth token from the PC passes the secrets file limits');
+        t.check(DEFAULTS.github.usePcLogin === false, 'the PC login is off by default');
         t.section('errors with an action');
         const fixable = new UserError('Broke.', 'Do it.', { op: 'sandbox.stop', label: 'Stop it', cli: 'sandbox stop' });
         const wire = toWireError(fixable);

package/dist/selftest/heavy-load.test.js

@@ -8,7 +8,7 @@ import { DEFAULTS } from '../core/config/index.js';
 import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
 import { GuestRequestSchema, PressureStatusSchema } from '../shared/channel/index.js';
-import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, chooseTargetDir, } from '../shared/memory/index.js';
+import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, chooseTargetDir, cargoLinkerVar, } from '../shared/memory/index.js';
 import { HeartbeatSchema } from '../shared/channel/index.js';
 import { heartbeatLine, lastEndOf, vanishedCause, stopWarning } from '../host/life/index.js';
 import { cappedMemoryMb, decideMemory, memoryNote, residentCapMb, residentNote, resolveMemoryMb, } from '../host/launch/index.js';
@@ -240,6 +240,8 @@ export const heavyLoadSuite = {
             chooseTargetDir('auto', 10 * 1024 ** 3).targetDir === 'separate' &&
             Boolean(chooseTargetDir('auto', 10 * 1024 ** 3).warning) &&
             chooseTargetDir('shared', 1).targetDir === 'shared', 'targetDir "auto": local with 25 GB free on C:, else separate with a warning; other values stay');
+        t.check(cargoLinkerVar('x86_64-pc-windows-msvc') === 'CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER' &&
+            cargoLinkerVar('aarch64-pc-windows-msvc') === 'CARGO_TARGET_AARCH64_PC_WINDOWS_MSVC_LINKER', 'cargo linker variable names the host triple (the msvc host links with lld, not link.exe)');
         const beat = {
             at: '2026-11-02T21:31:00.000Z',
             uptimeS: 2800,

package/dist/selftest/hostile-input.test.js

@@ -8,7 +8,7 @@ import { assertSafeMapping } from '../core/safe-paths.js';
 import { safeText } from '../core/util/index.js';
 import { isSafeFileName } from '../shared/paths/index.js';
 import { removeRefusal, safeRemove } from '../shared/io/index.js';
-import { writeJsonAtomic } from '../shared/io/index.js';
+import { rotateLog, writeJsonAtomic } from '../shared/io/index.js';
 export const hostileInputSuite = {
     name: 'hostile-input',
     title: 'file names, deletes, printed text, mappings and state files from an untrusted sandbox',
@@ -63,5 +63,15 @@ export const hostileInputSuite = {
         fs.writeFileSync(path.join(repoDir, '.sandbox-config.json'), '{"readOnly": true}' + ' '.repeat(1100 * 1024));
         await t.throws(() => f.run({ cwd: repoDir, trustConfig: true }), 'over 1 MB', 'a .sandbox-config.json over 1 MB is refused before it is parsed');
         fs.rmSync(path.join(repoDir, '.sandbox-config.json'));
+        t.section('a log that grows for ever (Headroom appends to one on the data disk)');
+        const logFile = t.at('rotate', 'proxy.log');
+        fs.mkdirSync(path.dirname(logFile), { recursive: true });
+        t.check(!rotateLog(logFile, 10), 'no log yet: nothing to rotate');
+        fs.writeFileSync(logFile, 'x'.repeat(10));
+        t.check(!rotateLog(logFile, 10) && fs.existsSync(logFile), 'a log at the limit stays');
+        fs.writeFileSync(logFile + '.1', 'old');
+        fs.writeFileSync(logFile, 'y'.repeat(11));
+        t.check(rotateLog(logFile, 10), 'a log over the limit is rotated');
+        t.check(!fs.existsSync(logFile) && fs.readFileSync(logFile + '.1', 'utf8') === 'y'.repeat(11), 'it replaces the older copy');
     },
 };

package/dist/selftest/index.js

@@ -16,11 +16,17 @@ import { persistedInstallsSuite } from './persisted-installs.test.js';
 import { pcInstallsSuite } from './pc-installs.test.js';
 import { steamSuite } from './steam.test.js';
 import { enginesSuite } from './engines.test.js';
+import { mixamoSuite } from './mixamo.test.js';
 import { unitySuite } from './unity.test.js';
+import { unitySetupSuite } from './unity-setup.test.js';
+import { unityAccountsSuite } from './unity-accounts.test.js';
+import { unityPageSuite } from './unity-page.test.js';
+import { unityAgentSuite } from './unity-agent.test.js';
 import { fivemSuite } from './fivem.test.js';
 import { androidSuite } from './android.test.js';
 import { mobileSuite } from './mobile.test.js';
 import { agentsWebSuite } from './agents-web.test.js';
+import { storeAppSuite } from './store-app.test.js';
 import { credentialsSuite } from './credentials.test.js';
 import { vpnSuite } from './vpn.test.js';
 import { githubSuite } from './github.test.js';
@@ -139,11 +145,17 @@ export const SUITES = [
     persistedInstallsSuite,
     steamSuite,
     enginesSuite,
+    mixamoSuite,
     unitySuite,
+    unitySetupSuite,
+    unityAccountsSuite,
+    unityPageSuite,
+    unityAgentSuite,
     fivemSuite,
     androidSuite,
     mobileSuite,
     agentsWebSuite,
+    storeAppSuite,
     detectSuite,
     networkSuite,
     personalizationSuite,

package/dist/selftest/menu-screens.js

@@ -10,6 +10,8 @@ import { appsOptions, stageTicks } from '../cli/menu/pages/apps-page.js';
 import { maintenanceOptions } from '../cli/menu/pages/maintenance-page.js';
 import { sandboxOptions } from '../cli/menu/pages/sandbox-page.js';
 import { sessionsOptions } from '../cli/menu/pages/sessions-page.js';
+import { UNREAL_SAMPLE } from './support/unreal-sample.js';
+import { UNITY_SAMPLE } from './support/unity-sample.js';
 import { settingsOf, settingsOptions } from '../cli/menu/pages/settings-page.js';
 import { CATEGORIES } from '../app/features/settings/index.js';
 import { agentsOptions } from '../cli/menu/pages/agents-page.js';
@@ -199,6 +201,8 @@ export function renderScreens(dir) {
             { name: 'redis', running: false, port: 6379, title: 'Redis' },
         ],
         defaultAgent: 'claude',
+        unreal: UNREAL_SAMPLE,
+        unity: UNITY_SAMPLE,
     };
     const stopped = {
         ...sandbox,
@@ -399,7 +403,7 @@ export function renderScreens(dir) {
         out.push(block('1 Agents · Start', draw(0, { ...agentsOptions(agentsModel, API_FOLDER), startCategory: 'start' }, size, status), size), block('1 Agents · Options (navigation focused)', draw(0, { ...agentsOptions(agentsModel, API_FOLDER), startCategory: 'options' }, size, status, 0, true), size), block('1 Agents · On this PC', draw(0, { ...agentsOptions(agentsModel, API_FOLDER), startCategory: 'host' }, size, status), size), block('2 Sessions', draw(1, sessionsOptions({ sandboxRunning: true, sessions: SESSIONS, defaultAgent: 'claude' }), size, status), size), block('2 Sessions (no sandbox)', draw(1, sessionsOptions({ sandboxRunning: false, sessions: [], defaultAgent: 'claude' }), size), size));
         for (const category of ['status', 'databases'])
             out.push(block('3 Sandbox (stopped) · ' + category, draw(2, { ...sandboxOptions(stopped), startCategory: category }, size), size));
-        for (const category of ['status', 'projects', 'databases'])
+        for (const category of ['status', 'projects', 'databases', 'unreal', 'unity'])
             out.push(block('3 Sandbox · ' + category, draw(2, { ...sandboxOptions(sandbox), startCategory: category }, size, status), size));
         out.push(block('4 Apps (1 unsaved)', draw(3, appsOptions(user, appsData, appsDraft, 'user'), size, status, appsDraft.count()), size));
         for (const category of CATEGORIES)

package/dist/selftest/mixamo.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const mixamoSuite: Suite;

package/dist/selftest/mixamo.test.js

@@ -0,0 +1,60 @@
+// Mixamo: the browser policy table (downloads folder, no GPU) and the guide's Mixamo lines and editor names.
+import { browserPolicies } from '../shared/browser-policy.js';
+import { unrealGuideLines } from '../shared/unreal/guide.js';
+const DOWNLOADS = 'C:\\AgentData\\downloads';
+const PROJECT = { workspace: 'C:\\P\\Game', uproject: 'C:\\P\\Game\\Game.uproject' };
+function statusWith(version) {
+    return {
+        updatedAt: 'now',
+        engines: [
+            {
+                id: 'UE_' + version,
+                dir: 'C:\\E',
+                version,
+                build: 'installed',
+                origin: 'pc',
+                writable: true,
+                sizeBytes: null,
+            },
+        ],
+        projects: [{ workspace: PROJECT.workspace, engine: 'C:\\E', reason: 'test' }],
+        launcher: { installed: false, installLocation: null, problem: null, freeBytes: null, needBytes: 1 },
+        visualStudio: { version: '17.14', path: 'C:/VS', how: 'kept', check: 'ok', ok: true },
+        debugger: null,
+        ddc: { mode: 'persisted', dir: null },
+        vaults: [],
+        mcpUrl: null,
+    };
+}
+export const mixamoSuite = {
+    name: 'mixamo',
+    title: 'Mixamo: browser downloads folder and the guide lines for bringing characters into Unreal',
+    run: async (t) => {
+        t.section('browser policies');
+        const four = browserPolicies({ downloads: DOWNLOADS });
+        t.equal(four.length, 4, 'two browsers, two policies each');
+        t.equal(four.filter((p) => p.name === 'DefaultDownloadDirectory').map((p) => p.data), [DOWNLOADS, DOWNLOADS], 'both browsers download to the data disk');
+        t.equal(browserPolicies({ downloads: null }).length, 2, 'no folder: only the GPU policy');
+        await t.throws(() => browserPolicies({ downloads: 'C:\\a"b' }), 'not a folder', 'a quote in the folder is refused');
+        await t.throws(() => browserPolicies({ downloads: 'downloads' }), 'not a folder', 'a relative folder is refused');
+        t.section('the guide');
+        const on = { mixamo: { downloads: DOWNLOADS, script: null } };
+        const guide = unrealGuideLines(statusWith('5.4.4'), [PROJECT], on).join('\n');
+        t.includes(guide, 'https://www.mixamo.com', 'the Mixamo line is there');
+        t.includes(guide, DOWNLOADS, 'it names the downloads folder');
+        t.includes(guide, 'Mixamo into Unreal', 'and the import line');
+        t.excludes(guide, 'Mixamo import script', 'no script line without a script');
+        const withScript = unrealGuideLines(statusWith('5.4.4'), [PROJECT], {
+            mixamo: { downloads: DOWNLOADS, script: 'C:\\x\\import_mixamo.py' },
+        }).join('\n');
+        t.includes(withScript, 'Mixamo import script', 'a script adds its line');
+        t.excludes(unrealGuideLines(statusWith('5.4.4'), [PROJECT]).join('\n'), 'Mixamo', 'off by default');
+        const noEngine = { ...statusWith('5.4.4'), engines: [] };
+        t.excludes(unrealGuideLines(noEngine, [PROJECT], on).join('\n'), 'Mixamo', 'no engine: no Mixamo lines');
+        t.section('UE4 names');
+        const ue4 = unrealGuideLines(statusWith('4.27.2'), [PROJECT]).join('\n');
+        t.includes(ue4, 'UE4Editor-Cmd.exe', 'a UE4 engine uses UE4Editor-Cmd.exe');
+        t.excludes(ue4, 'UnrealEditor', 'and not the UE5 names');
+        t.includes(unrealGuideLines(statusWith('5.4.4'), [PROJECT]).join('\n'), 'UnrealEditor-Cmd.exe', 'UE5 keeps its names');
+    },
+};

package/dist/selftest/persisted-installs.test.js

@@ -309,7 +309,7 @@ export const persistedInstallsSuite = {
         const found = decideToolchains(everything, ['ProjectVersion.txt', 'project.godot', 'fxmanifest.lua'], ['unity']);
         t.check(NOT_READY.toolchains.every((n) => !found[n].on), '"auto" never turns on a toolchain that is not written yet, whatever the project holds');
         const shown = settingsOf(ConfigFile.user(t.at('settings', 'config.json'))).map((r) => r.key.join('.'));
-        t.check(!shown.some((k) => /^toolchains\.(unity|godot|android|flutter|dart|reactNative)\./.test(k)) &&
+        t.check(!shown.some((k) => /^toolchains\.(godot|android|flutter|dart|reactNative)\./.test(k)) &&
             shown.includes('toolchains.unreal.visualStudio') &&
             shown.some((k) => k.startsWith('toolchains.fivem.')), 'settings do not list the toolchains that are not written yet');
     },

package/dist/selftest/secrets.test.js

@@ -1,7 +1,9 @@
 // What reaches the sandbox from this PC's Claude files, and what is stripped first: API keys, cloud credentials, tokens
 // in MCP server definitions. Also the secret-looking files in a workspace that the launch warns about.
 import path from 'node:path';
-import { findSecretFiles, sandboxGlobalState, stripMcpServers, stripSettings } from '../host/profile/index.js';
+import fs from 'node:fs';
+import { DEFAULTS } from '../core/config/index.js';
+import { findSecretFiles, pluginFilter, pluginTrimLevel, sandboxGlobalState, stageClaudeProfile, stripMcpServers, stripSettings, } from '../host/profile/index.js';
 const REMOVED = '[removed by agent-sandbox]';
 export const secretsSuite = {
     name: 'secrets',
@@ -111,5 +113,38 @@ export const secretsSuite = {
         ])
             t.write(path.join(workspace, file), 'x');
         t.equal(findSecretFiles(workspace).sort(), ['.env', 'api\\credentials.json', 'server.pem'], 'secret-looking workspace files are found for the launch warning (templates and dependencies ignored)');
+        t.section('plugins staged from this PC');
+        const hostClaude = t.at('plugins-host');
+        const plugins = path.join(hostClaude, 'plugins');
+        t.write(path.join(plugins, 'installed_plugins.json'), '{"version":2,"plugins":{}}');
+        t.write(path.join(plugins, 'known_marketplaces.json'), '{}');
+        t.write(path.join(plugins, 'cache', 'm', 'p', '1.0', 'plugin.json'), '{}');
+        t.write(path.join(plugins, 'cache', 'm', 'p', '1.0', 'node_modules', 'dep', 'index.js'), 'x');
+        t.write(path.join(plugins, 'cache', 'temp_git_1_abc', 'junk.txt'), 'x');
+        t.write(path.join(plugins, 'marketplaces', 'm', 'marketplace.json'), '{}');
+        t.write(path.join(plugins, 'marketplaces', 'm', '.git', 'HEAD'), 'ref');
+        t.write(path.join(plugins, 'marketplaces', 'm.backup', 'old.txt'), 'x');
+        t.write(path.join(plugins, 'marketplaces', 'temp_subdir_2.clone', 'junk.txt'), 'x');
+        t.write(path.join(hostClaude, 'settings.json'), '{"enabledPlugins":{"p@m":true}}');
+        const launch = t.at('plugins-launch');
+        const profile = { ...DEFAULTS.claudeProfile, hostDir: hostClaude, globalStateFile: '' };
+        const staged = stageClaudeProfile(profile, launch, 'D:/Code/app', DEFAULTS.secrets);
+        const out = path.join(launch, 'claude-profile', 'plugins');
+        t.check(staged.staged.includes('plugins'), 'plugins are staged');
+        t.check(fs.existsSync(path.join(out, 'cache', 'm', 'p', '1.0', 'plugin.json')) &&
+            fs.existsSync(path.join(out, 'marketplaces', 'm', 'marketplace.json')) &&
+            fs.existsSync(path.join(out, 'marketplaces', 'm', '.git', 'HEAD')) &&
+            fs.existsSync(path.join(out, 'cache', 'm', 'p', '1.0', 'node_modules', 'dep', 'index.js')), 'the plugin cache, marketplaces and (when they fit) their git folders and dependencies are copied');
+        t.check(!fs.existsSync(path.join(out, 'cache', 'temp_git_1_abc')) &&
+            !fs.existsSync(path.join(out, 'marketplaces', 'm.backup')) &&
+            !fs.existsSync(path.join(out, 'marketplaces', 'temp_subdir_2.clone')), 'interrupted clones, backups and staging folders of plugins are left out');
+        t.check(pluginTrimLevel(plugins) === 0, 'a plugins folder under the cap is not trimmed');
+        const git = path.join(plugins, 'marketplaces', 'm', '.git');
+        const deps = path.join(plugins, 'cache', 'm', 'p', '1.0', 'node_modules');
+        t.check(pluginFilter(plugins, 0)(git) &&
+            !pluginFilter(plugins, 1)(git) &&
+            pluginFilter(plugins, 1)(deps) &&
+            !pluginFilter(plugins, 2)(deps), 'a plugins folder over the cap loses git history first, then node_modules');
+        t.check(fs.readFileSync(path.join(launch, 'claude-profile', 'settings.json'), 'utf8').includes('p@m'), 'enabledPlugins reach the sandbox');
     },
 };

package/dist/selftest/service-accounts.test.js

@@ -274,7 +274,7 @@ export const serviceAccountsSuite = {
                 process.env.LOCALAPPDATA = oldLocal;
         }
         t.section('the account command');
-        t.check(!COMMANDS.some((c) => ['epic', 'steam', 'unity'].includes(c.name)), 'no command of its own for a service');
+        t.check(!COMMANDS.some((c) => ['epic', 'steam'].includes(c.name)), 'no command of its own for a service');
         const account = buildProgram(() => undefined).commands.find((c) => c.name() === 'account');
         const help = account.helpInformation();
         t.check(['status', 'import', 'login', 'logout', '--from', '--yes'].every((w) => help.includes(w)), 'sandbox account --help lists status, import, login, logout, --from and --yes', help);

package/dist/selftest/store-app.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const storeAppSuite: Suite;

package/dist/selftest/store-app.test.js

@@ -0,0 +1,162 @@
+// The Perplexity desktop app, a Microsoft Store package: the catalogue entry, the sign-in kind (sandbox only, like
+// Comet), the package manifest, the PC's fetch and staging with a fake Store tool (no download, nothing run), the
+// sandbox's check of the kept files and the shortcut's command line. Temp folders only.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULTS } from '../core/config/index.js';
+import { OFF_IS_SAFER } from '../core/local-config/index.js';
+import { HOST_SOURCES } from '../host/accounts/index.js';
+import { prepareStorePackages, stagedPackageDir, StorePackages } from '../host/apps/index.js';
+import { checkedPackage } from '../guest/apps/store-check.js';
+import { peekPendingPerplexityApp, perplexityAppPendingFile } from '../guest/accounts/kinds/perplexityapp.js';
+import { perplexityAppShortcutArgs, restoreAppSignIn } from '../guest/browser/perplexity-app.js';
+import { appsToInstall, appById, isStorePackageFile, PERPLEXITY_DESKTOP_FAMILY, PERPLEXITY_DESKTOP_PACKAGE, PERPLEXITY_DESKTOP_PRODUCT_ID, storeApps, StorePackageManifestSchema, storePackageRole, } from '../shared/apps/index.js';
+import { appUsersOn, PAYLOADS, SERVICE_SPECS, serviceWanted, usedByText, } from '../shared/accounts/index.js';
+const MAIN = 'PerplexityAI.PerplexityApp_1.2.3.0_x64__3jh4kjrg4dzr2.msix';
+const FRAMEWORK = 'Microsoft.VCLibs.140.00_14.0.33519.0_x64__8wekyb3d8bbwe.appx';
+const sha = (text) => crypto.createHash('sha256').update(text).digest('hex');
+/** A fake Store tool: writes the given files into -OutDir and answers like get-store-package.ps1. */
+function fakeStore(files, ok = true) {
+    let calls = 0;
+    const run = (_exe, args) => {
+        calls++;
+        if (!ok)
+            return Promise.resolve({
+                status: 0,
+                stdout: JSON.stringify({ ok: false, message: 'no Store access', files: [] }),
+                stderr: '',
+            });
+        const out = args[args.indexOf('-OutDir') + 1];
+        fs.mkdirSync(out, { recursive: true });
+        for (const [name, text] of Object.entries(files))
+            if (path.basename(name) === name)
+                fs.writeFileSync(path.join(out, name), text);
+        return Promise.resolve({
+            status: 0,
+            stdout: 'progress\n' + JSON.stringify({ ok: true, message: 'ok', files: Object.keys(files) }),
+            stderr: '',
+        });
+    };
+    return { run, calls: () => calls };
+}
+export const storeAppSuite = {
+    name: 'store-app',
+    title: 'Perplexity desktop app: Store package fetched on the PC, installed in the sandbox, sign-in kept like Comet',
+    run: async (t) => {
+        t.section('the catalogue entry');
+        const entry = appById('perplexity-desktop');
+        t.check(entry !== undefined &&
+            'store' in entry.source &&
+            entry.source.store.productId === PERPLEXITY_DESKTOP_PRODUCT_ID &&
+            entry.source.store.family === PERPLEXITY_DESKTOP_FAMILY &&
+            PERPLEXITY_DESKTOP_FAMILY.startsWith(PERPLEXITY_DESKTOP_PACKAGE + '_') &&
+            entry.userOnly === true, 'a Store source with the product and the package family, yours only');
+        t.equal(storeApps(['rtk', 'perplexity-desktop']).map((a) => a.productId), ['9P9XG917PWCJ'], 'only Store apps are fetched');
+        t.check(appsToInstall({ ...DEFAULTS.apps, install: ['perplexity-desktop'] }, 'none').entries.length === 1, 'it needs no 7-Zip and no other app');
+        t.section('the sign-in kind');
+        const spec = SERVICE_SPECS.perplexityapp;
+        t.check(spec.sources.join() === 'sandbox' &&
+            spec.returns &&
+            !spec.singleHolder &&
+            DEFAULTS.accounts.perplexityapp.share === false &&
+            OFF_IS_SAFER.includes('accounts.perplexityapp.share') &&
+            spec.warnings.some((w) => w.includes("can't be copied from this PC")), 'only from a sandbox, handed back, not shared by default, a project file can only turn it off');
+        const source = HOST_SOURCES.perplexityapp;
+        t.check(!source.fromPc && !source.fromFile && !source.fromAnswers, 'nothing is read from this PC (the cookies are sealed to it)');
+        t.check(appUsersOn(['perplexity-desktop']).join() === 'perplexityapp' &&
+            serviceWanted('perplexityapp', new Set(['perplexityapp'])) &&
+            !serviceWanted('perplexityapp', new Set(['comet'])) &&
+            usedByText(['perplexityapp']) === 'the Perplexity desktop app', 'handed over only where the app is on');
+        const cookie = { name: 's', value: 'v', domain: '.perplexity.ai', path: '/', secure: true, httpOnly: true };
+        t.check(PAYLOADS.perplexityapp.safeParse({ cookies: [cookie] }).success &&
+            !PAYLOADS.perplexityapp.safeParse({ cookies: [{ ...cookie, domain: 'example.com' }] }).success, 'the payload is the perplexity.ai cookie allow-list');
+        const pendingRoot = t.dir('pending');
+        t.write(perplexityAppPendingFile(pendingRoot), JSON.stringify({ cookies: [cookie] }));
+        t.check(peekPendingPerplexityApp(pendingRoot)?.cookies.length === 1, 'a waiting sign-in is read and left in place');
+        t.write(perplexityAppPendingFile(pendingRoot), '{"cookies":[{"domain":"example.com"}]}');
+        t.check(peekPendingPerplexityApp(pendingRoot) === null, 'one that is not the allow-listed shape is not used');
+        t.check(!(await restoreAppSignIn({ cookies: [{ ...cookie, expires: 4_000_000_000 }] }, t.dir('no-app-profile'))), 'with the app not running, nothing is written');
+        t.section('the package manifest');
+        const file = (name, role) => ({ name, role, sha256: sha(name), bytes: 10 });
+        const manifest = (files) => ({
+            productId: '9P9XG917PWCJ',
+            fetchedAt: '2026-01-01T00:00:00Z',
+            files,
+        });
+        t.check(StorePackageManifestSchema.safeParse(manifest([file(MAIN, 'main'), file(FRAMEWORK, 'dependency')])).success &&
+            !StorePackageManifestSchema.safeParse(manifest([file(FRAMEWORK, 'dependency')])).success &&
+            !StorePackageManifestSchema.safeParse(manifest([file(MAIN, 'main'), file(MAIN.toUpperCase().replace('.MSIX', '.msix'), 'main')])).success &&
+            !StorePackageManifestSchema.safeParse(manifest([file('..\\evil.msix', 'main')])).success &&
+            !StorePackageManifestSchema.safeParse(manifest([file('x.exe', 'main')])).success, 'exactly one app file, and only .msix/.appx names (no paths, no programs)');
+        t.check(storePackageRole(MAIN, PERPLEXITY_DESKTOP_PACKAGE) === 'main' &&
+            storePackageRole(FRAMEWORK, PERPLEXITY_DESKTOP_PACKAGE) === 'dependency' &&
+            isStorePackageFile(MAIN) &&
+            !isStorePackageFile('a/b.msix'), 'the app is told from its frameworks by name');
+        t.section('this PC fetches and stages the package');
+        const storageRoot = t.dir('pc', 'storage');
+        const dataPath = t.dir('pc', 'storage', 'data', 'set');
+        const app = {
+            id: 'perplexity-desktop',
+            productId: PERPLEXITY_DESKTOP_PRODUCT_ID,
+            packageName: PERPLEXITY_DESKTOP_PACKAGE,
+        };
+        const store = fakeStore({
+            [MAIN]: 'app-bytes',
+            [FRAMEWORK]: 'framework-bytes',
+            '..evil.txt': 'x',
+            '../escape.msix': 'x',
+        });
+        let now = Date.parse('2026-06-01T00:00:00Z');
+        const packages = new StorePackages({ storageRoot, dataPath, run: store.run, now: () => now });
+        const first = await packages.ensure(app);
+        t.check(first.note === 'downloaded' &&
+            first.manifest.files.length === 2 &&
+            first.manifest.files.find((f) => f.role === 'main')?.sha256 === sha('app-bytes') &&
+            packages.cached(app.productId) !== null &&
+            !fs.existsSync(packages.cacheDir(app.productId) + '.new'), "the files are hashed here, not taken on the script's word; names that are not packages are ignored");
+        const second = await packages.ensure(app);
+        t.check(store.calls() === 1 && second.note.startsWith('kept'), 'a fresh cache is not fetched again');
+        const staged = packages.stage(app, first.manifest);
+        t.check(staged === stagedPackageDir(dataPath, app.id) &&
+            fs.readFileSync(path.join(staged, MAIN), 'utf8') === 'app-bytes' &&
+            fs.existsSync(path.join(staged, 'store-package.json')), 'the package is copied into the data folder with its manifest');
+        fs.writeFileSync(path.join(staged, 'stale.msix'), 'old');
+        packages.stage(app, first.manifest);
+        t.check(!fs.existsSync(path.join(staged, 'stale.msix')), 'a file the manifest does not list is removed');
+        t.section('an old cache and a failing Store');
+        now += 40 * 24 * 3600 * 1000;
+        const failing = new StorePackages({ storageRoot, dataPath, run: fakeStore({}, false).run, now: () => now });
+        const kept = await failing.ensure(app);
+        t.check(kept.note.includes('could not be fetched') && kept.note.includes('no Store access'), 'the old package stands, and says why');
+        const emptyRoot = t.dir('pc2', 'storage');
+        const emptyData = t.dir('pc2', 'storage', 'data', 'set');
+        const outcome = await prepareStorePackages([app], {
+            storageRoot: emptyRoot,
+            dataPath: emptyData,
+            run: fakeStore({}, false).run,
+        });
+        t.check(outcome.notes.length === 1 &&
+            outcome.notes[0].includes('is not prepared') &&
+            outcome.notes[0].includes('winget download --id 9P9XG917PWCJ'), 'with nothing kept the launch goes on, with a note that says what to fix');
+        const good = await prepareStorePackages([app], {
+            storageRoot: emptyRoot,
+            dataPath: emptyData,
+            run: fakeStore({ [MAIN]: 'a' }).run,
+        });
+        t.check(good.notes[0].includes('downloaded') && fs.existsSync(path.join(stagedPackageDir(emptyData, app.id), MAIN)), 'and a working Store stages it');
+        t.section('the sandbox checks the kept files');
+        const checked = await checkedPackage(staged);
+        t.check(path.basename(checked.main) === MAIN && checked.dependencies.map((d) => path.basename(d)).join() === FRAMEWORK, 'the app and its frameworks, in order');
+        fs.writeFileSync(path.join(staged, FRAMEWORK), 'tampered');
+        t.check((await t.thrownMessage(() => checkedPackage(staged))).includes('missing or changed'), 'a changed file stops the install');
+        t.check((await t.thrownMessage(() => checkedPackage(t.dir('nothing')))).includes('not handed over'), 'no package says so');
+        t.section('the shortcut');
+        const args = perplexityAppShortcutArgs('C:\\AgentLaunch\\sandbox\\scripts\\start-store-app.ps1', 'C:\\Users\\X\\profile');
+        t.check(args.includes('-File "C:\\AgentLaunch\\sandbox\\scripts\\start-store-app.ps1"') &&
+            args.includes('-PackageName PerplexityAI.PerplexityApp') &&
+            args.includes('-UserDataDir "C:\\Users\\X\\profile"') &&
+            args.includes('-Port 0') &&
+            args.includes('-WindowStyle Hidden'), 'a hidden PowerShell start with the package, its own profile and a free DevTools port');
+    },
+};

package/dist/selftest/support/engine-golden.js

@@ -44,10 +44,14 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/addons/context7/package.json',
     'sandbox/addons/headroom/requirements.in',
     'sandbox/addons/headroom/requirements.txt',
+    'sandbox/addons/openupm-cli/package-lock.json',
+    'sandbox/addons/openupm-cli/package.json',
     'sandbox/addons/perplexity-mcp/package-lock.json',
     'sandbox/addons/perplexity-mcp/package.json',
     'sandbox/addons/playwright-mcp/package-lock.json',
     'sandbox/addons/playwright-mcp/package.json',
+    'sandbox/addons/unity-mcp/requirements.in',
+    'sandbox/addons/unity-mcp/requirements.txt',
     'sandbox/boot/bootstrap.ps1',
     'sandbox/boot/bootstrap/drives.ps1',
     'sandbox/boot/bootstrap/files.ps1',
@@ -55,6 +59,7 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/boot/bootstrap/status.ps1',
     'sandbox/boot/logon.cmd',
     'sandbox/boot/trust.cmd',
+    'sandbox/csharp/AppActivation.cs',
     'sandbox/csharp/BindMount.cs',
     'sandbox/csharp/CargoShim.cs',
     'sandbox/csharp/Desktop.cs',
@@ -69,6 +74,7 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/csharp/SandboxTools/MemoryLog.cs',
     'sandbox/csharp/SandboxTools/PageFile.cs',
     'sandbox/csharp/SandboxTools/Program.cs',
+    'sandbox/csharp/VsSetup.cs',
     'sandbox/csharp/VsWhere.cs',
     'sandbox/csharp/VtInput.cs',
     'sandbox/scripts/add-firewall-port.ps1',
@@ -76,7 +82,9 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/scripts/expand-archive.ps1',
     'sandbox/scripts/get-gpu-names.ps1',
     'sandbox/scripts/get-signature.ps1',
+    'sandbox/scripts/get-vs-setup.ps1',
     'sandbox/scripts/install-shell-path.ps1',
+    'sandbox/scripts/install-store-package.ps1',
     'sandbox/scripts/link-profile-dirs.ps1',
     'sandbox/scripts/new-shortcuts.ps1',
     'sandbox/scripts/repair-wmi-services.ps1',
@@ -85,6 +93,8 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/scripts/set-desktop.ps1',
     'sandbox/scripts/set-dns-servers.ps1',
     'sandbox/scripts/set-machine-environment.ps1',
+    'sandbox/scripts/set-registry-values.ps1',
+    'sandbox/scripts/start-store-app.ps1',
     'sandbox/templates/fivem/README.txt',
     'sandbox/templates/fivem/cs/Client/Client.csproj',
     'sandbox/templates/fivem/cs/Client/ClientMain.cs',

package/dist/selftest/support/fixtures.d.ts

@@ -106,6 +106,7 @@ export declare function createFixtures(t: Harness): {
         };
         github: {
             shareToken: boolean;
+            usePcLogin: boolean;
         };
         accounts: {
             epic: {
@@ -138,12 +139,18 @@ export declare function createFixtures(t: Harness): {
             comet: {
                 share: boolean;
             };
+            perplexityapp: {
+                share: boolean;
+            };
         };
         pcInstalls: {
             steamGames: boolean | number[];
             epicGames: boolean | string[];
-            unrealEngines: boolean | string[];
-            unityEditors: boolean | string[];
+            unrealEngines: boolean | string[] | "auto";
+            unrealEngineFolders: string[];
+            unrealAssets: boolean | "auto";
+            unityEditors: boolean | string[] | "auto";
+            unityAssets: boolean | "auto";
         };
         provisioning: {
             copyFromHost: boolean;
@@ -210,6 +217,10 @@ export declare function createFixtures(t: Harness): {
                 modules: string[];
                 hub: boolean;
                 keepVersions: number;
+                mcp: boolean;
+                agentSkills: boolean;
+                cliVersion: string;
+                assetCache: "pc" | "persisted" | "local";
             };
             godot: {
                 enabled: boolean | "auto";

package/dist/selftest/support/unity-sample.d.ts

@@ -0,0 +1,2 @@
+import type { UnityOverview } from '../../app/features/unity/index.js';
+export declare const UNITY_SAMPLE: UnityOverview;