windows-development-sandbox 1.4.1 → 1.4.3

package/dist/host/{port-forward.js → network/port-forward.js}

@@ -3,18 +3,21 @@
 // only to an address the sandbox published that is on this PC's Hyper-V network (isSandboxAddress). Bytes are passed
 // through, never looked at. No admin rights needed (no netsh portproxy).
 import net from 'node:net';
-import path from 'node:path';
 import { z } from 'zod';
-import { relayPort } from '../shared/netpolicy.js';
-import { readSandboxStatus, readValid, writeJsonAtomic } from '../shared/rundir.js';
-import { isSandboxAddress } from './attach.js';
-const Forwards = z.array(z.object({ pc: z.number().int().min(1).max(65535), sandbox: z.number().int().min(1).max(65535) })).max(64);
-const forwardsFile = (storageRoot, dataPath) => path.join(storageRoot, 'sync', path.basename(dataPath) + '-forwards.json');
+import { relayPort } from '../../shared/network/index.js';
+import { RunDir } from '../../shared/channel/index.js';
+import { JsonFile } from '../../shared/io/index.js';
+import { hostStateFile } from '../storage/index.js';
+import { isSandboxAddress } from '../channel/index.js';
+const ForwardsSchema = z
+    .array(z.object({ pc: z.number().int().min(1).max(65535), sandbox: z.number().int().min(1).max(65535) }))
+    .max(64);
+const forwardsFile = (storageRoot, dataPath) => new JsonFile(ForwardsSchema, hostStateFile(storageRoot, dataPath, '-forwards.json'));
 /** Host-only: the forwards of the running sandbox (written at launch, read by the watcher). */
-export const saveForwards = (storageRoot, dataPath, forwards) => writeJsonAtomic(forwardsFile(storageRoot, dataPath), forwards);
-export const readForwards = (storageRoot, dataPath) => readValid(Forwards, forwardsFile(storageRoot, dataPath)) ?? [];
+export const saveForwards = (storageRoot, dataPath, forwards) => forwardsFile(storageRoot, dataPath).write(forwards);
+export const readForwards = (storageRoot, dataPath) => forwardsFile(storageRoot, dataPath).read() ?? [];
 /** The sandbox's address on this PC's Hyper-V network, from its status (null until it has one). */
-export const sandboxAddress = (dataPath) => readSandboxStatus(dataPath)?.addresses?.find((a) => isSandboxAddress(a)) ?? null;
+export const sandboxAddress = (dataPath) => new RunDir(dataPath).readSandboxStatus()?.addresses?.find((a) => isSandboxAddress(a)) ?? null;
 /** Starts one listener per forward; returns a function that stops them. */
 export const startPortForwards = (forwards, address, note = () => undefined) => {
     const servers = forwards.map((f, i) => {
@@ -29,7 +32,10 @@ export const startPortForwards = (forwards, address, note = () => undefined) =>
             target.on('error', () => client.destroy());
             client.on('error', () => target.destroy());
         });
-        server.on('error', (e) => note('localhost:' + f.pc + ' could not be forwarded' + (e.code === 'EADDRINUSE' ? ': something on this PC already uses that port' : ': ' + e.message)));
+        server.on('error', (e) => note('localhost:' +
+            f.pc +
+            ' could not be forwarded' +
+            (e.code === 'EADDRINUSE' ? ': something on this PC already uses that port' : ': ' + e.message)));
         server.listen(f.pc, '127.0.0.1', () => note('localhost:' + f.pc + ' -> sandbox port ' + f.sandbox));
         return server;
     });

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

@@ -0,0 +1,37 @@
+import { type LoginFiles } from './claude-login.js';
+export interface Account {
+    readonly name: string;
+    readonly savedAt: string;
+    readonly email: string | null;
+    readonly credentials: unknown;
+    readonly oauthAccount: unknown;
+}
+export interface AccountRow {
+    readonly name: string;
+    readonly email: string | null;
+    readonly isDefault: boolean;
+    readonly isActive: boolean;
+    readonly savedAt: string;
+}
+export declare function accountsDir(storageRoot: string): string;
+/** The saved Claude logins under <storage>\accounts, and which one each sandbox data folder uses. */
+export declare class AccountStore {
+    private readonly storageRoot;
+    constructor(storageRoot: string);
+    private file;
+    private store;
+    read(name: string): Account | null;
+    defaultName(): string | null;
+    /** The account a data folder uses (kept in the index of the storage folder that data folder is in). */
+    activeFor(dataPath: string): string | null;
+    list(dataPath: string): AccountRow[];
+    /** Saves the sandbox's current login (or this PC's, with fromHost) under `name`. */
+    save(dataPath: string, name: string, fromHost: LoginFiles | null): Account;
+    /**
+     * Makes `name` the sandbox's login. Claude refreshes (rotates) tokens while it runs, so the outgoing account's
+     * current tokens are saved back first; otherwise its stored refresh token could already be invalid.
+     */
+    activate(dataPath: string, name: string): Account;
+    setDefault(name: string | null): void;
+    remove(name: string): void;
+}

package/dist/host/profile/accounts.js

@@ -0,0 +1,146 @@
+// Several Claude logins for the sandbox. Each account is a saved copy of Claude's .credentials.json plus the
+// `oauthAccount` block of .claude.json, kept in host-only storage (<storage>\accounts, never mapped into a sandbox).
+// Switching writes them into the sandbox's persistent Claude state; when the sandbox is running the agent is then
+// restarted in place with --continue so the conversation carries on.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { isSafeFileName } from '../../shared/paths/index.js';
+import { JsonFile } from '../../shared/io/index.js';
+import { storageOf } from '../storage/index.js';
+import { fail, fileExists } from '../../core/util/index.js';
+import { clearAccountCaches, emailOf, MAX_STATE_BYTES, readLogin, readUntrusted, sandboxLogin, writeSandboxJson, } from './claude-login.js';
+const NAME = /^[A-Za-z0-9_-]{1,40}$/;
+const AccountSchema = z.object({
+    name: z.string().regex(NAME),
+    savedAt: z.string().max(64),
+    email: z.string().max(200).nullable(),
+    credentials: z.looseObject({}),
+    oauthAccount: z.unknown(),
+});
+const IndexSchema = z.object({
+    default: z.string().regex(NAME).optional(),
+    active: z.record(z.string().max(200), z.string().regex(NAME)).optional(),
+});
+export function accountsDir(storageRoot) {
+    return path.join(storageRoot, 'accounts');
+}
+function dataName(dataPath) {
+    return path.basename(dataPath);
+}
+function indexFile(storageRoot) {
+    return new JsonFile(IndexSchema, path.join(accountsDir(storageRoot), 'index.json'));
+}
+function readIndex(storageRoot) {
+    return indexFile(storageRoot).read() ?? {};
+}
+function updateIndex(storageRoot, change) {
+    indexFile(storageRoot).write(change(readIndex(storageRoot)));
+}
+function setActive(dataPath, name) {
+    updateIndex(storageOf(dataPath), (i) => ({ ...i, active: { ...i.active, [dataName(dataPath)]: name } }));
+}
+/** A file name of its own: not "index" (the index file), not a Windows device name such as con or nul. */
+function validName(name) {
+    return NAME.test(name) && name.toLowerCase() !== 'index' && isSafeFileName(name + '.json');
+}
+function assertName(name) {
+    if (!validName(name))
+        fail('Invalid account name "' + name + '".', 'Use letters, numbers, - and _ only (max 40), e.g. work or personal.');
+}
+/** The saved Claude logins under <storage>\accounts, and which one each sandbox data folder uses. */
+export class AccountStore {
+    storageRoot;
+    constructor(storageRoot) {
+        this.storageRoot = storageRoot;
+    }
+    file(name) {
+        return new JsonFile(AccountSchema, path.join(accountsDir(this.storageRoot), name + '.json'));
+    }
+    store(name, login) {
+        const account = { name, savedAt: new Date().toISOString(), email: emailOf(login.oauthAccount), ...login };
+        this.file(name).write(account);
+        return account;
+    }
+    read(name) {
+        return validName(name) ? this.file(name).read() : null;
+    }
+    defaultName() {
+        return readIndex(this.storageRoot).default ?? null;
+    }
+    /** The account a data folder uses (kept in the index of the storage folder that data folder is in). */
+    activeFor(dataPath) {
+        return readIndex(storageOf(dataPath)).active?.[dataName(dataPath)] ?? null;
+    }
+    list(dataPath) {
+        const dir = accountsDir(this.storageRoot);
+        if (!fs.existsSync(dir))
+            return [];
+        const def = this.defaultName();
+        const active = this.activeFor(dataPath);
+        return fs
+            .readdirSync(dir)
+            .filter((f) => f.endsWith('.json') && f !== 'index.json')
+            .map((f) => this.read(f.slice(0, -5)))
+            .filter((a) => a !== null)
+            .map((a) => ({
+            name: a.name,
+            email: a.email,
+            isDefault: a.name === def,
+            isActive: a.name === active,
+            savedAt: a.savedAt,
+        }));
+    }
+    /** Saves the sandbox's current login (or this PC's, with fromHost) under `name`. */
+    save(dataPath, name, fromHost) {
+        assertName(name);
+        const source = fromHost ?? sandboxLogin(dataPath);
+        const account = this.store(name, readLogin(source.claudeDir, source.globalStateFile));
+        if (!fromHost)
+            setActive(dataPath, name);
+        if (!this.defaultName())
+            this.setDefault(name);
+        return account;
+    }
+    /**
+     * Makes `name` the sandbox's login. Claude refreshes (rotates) tokens while it runs, so the outgoing account's
+     * current tokens are saved back first; otherwise its stored refresh token could already be invalid.
+     */
+    activate(dataPath, name) {
+        const account = this.read(name) ??
+            fail('Unknown account "' + name + '".', 'Saved accounts: ' +
+                (this.list(dataPath)
+                    .map((a) => a.name)
+                    .join(', ') || 'none yet; save one with sandbox account save <name>'));
+        const { claudeDir, globalStateFile } = sandboxLogin(dataPath);
+        const outgoing = this.activeFor(dataPath);
+        if (outgoing && outgoing !== name && this.read(outgoing) && fileExists(path.join(claudeDir, '.credentials.json'))) {
+            try {
+                this.store(outgoing, readLogin(claudeDir, globalStateFile));
+            }
+            catch {
+                /* nothing usable to save back */
+            }
+        }
+        fs.mkdirSync(claudeDir, { recursive: true });
+        clearAccountCaches(claudeDir);
+        writeSandboxJson(path.join(claudeDir, '.credentials.json'), account.credentials);
+        const state = readUntrusted(globalStateFile, MAX_STATE_BYTES);
+        if (account.oauthAccount && (state || !fileExists(globalStateFile)))
+            writeSandboxJson(globalStateFile, { ...(state ?? {}), oauthAccount: account.oauthAccount });
+        setActive(dataPath, name);
+        return account;
+    }
+    setDefault(name) {
+        if (name !== null && !this.read(name))
+            fail('Unknown account "' + name + '".', 'See your accounts with: sandbox account list');
+        updateIndex(this.storageRoot, (i) => ({ ...i, default: name ?? undefined }));
+    }
+    remove(name) {
+        if (!this.read(name))
+            fail('Unknown account "' + name + '".', 'See your accounts with: sandbox account list');
+        fs.rmSync(this.file(name).file);
+        if (this.defaultName() === name)
+            this.setDefault(null);
+    }
+}

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

@@ -0,0 +1,22 @@
+export interface Login {
+    readonly credentials: unknown;
+    readonly oauthAccount: unknown;
+}
+export interface LoginFiles {
+    readonly claudeDir: string;
+    readonly globalStateFile: string;
+}
+/** .claude.json holds per-project state and can be large; still capped so a hostile file cannot exhaust memory. */
+export declare const MAX_STATE_BYTES: number;
+export declare function sandboxClaudeDir(dataPath: string): string;
+export declare function emailOf(oauthAccount: unknown): string | null;
+/** Reads a JSON file that may be sandbox-written: no links, size-capped. */
+export declare function readUntrusted(file: string, max: number): unknown;
+/** The login currently in a Claude config folder (+ its global state file). */
+export declare function readLogin(claudeDir: string, globalStateFile: string): Login;
+/** The sandbox's Claude login files (refuses when the data folder holds a link on the way). */
+export declare function sandboxLogin(dataPath: string): LoginFiles;
+/** Replaces a file that may be a sandbox-planted link instead of writing through it. */
+export declare function writeSandboxJson(file: string, value: unknown): void;
+/** Removes the previous account's caches; otherwise its org policy could linger. A link is removed, not followed. */
+export declare function clearAccountCaches(claudeDir: string): void;

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

@@ -0,0 +1,57 @@
+// A Claude login as files: .credentials.json plus the `oauthAccount` block of .claude.json. The sandbox's copies are
+// guest-written: read without following links and size-capped; links are replaced, never written through.
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertTestWritable } from '../test-guard.js';
+import { assertNoLinks, fail, fileExists, isLink, removeLink, tryReadJson, writeJson } from '../../core/util/index.js';
+const MAX_LOGIN_BYTES = 1024 * 1024;
+/** .claude.json holds per-project state and can be large; still capped so a hostile file cannot exhaust memory. */
+export const MAX_STATE_BYTES = 256 * 1024 * 1024;
+/** Caches tied to an account (Claude deletes these on /logout). */
+const ACCOUNT_CACHES = ['remote-settings.json', 'policy-limits.json', 'policy-limits.json.stamp.json'];
+export function sandboxClaudeDir(dataPath) {
+    return path.join(dataPath, 'state', 'claude');
+}
+export function emailOf(oauthAccount) {
+    const email = oauthAccount?.emailAddress;
+    return typeof email === 'string' ? email.slice(0, 200) : null;
+}
+/** Reads a JSON file that may be sandbox-written: no links, size-capped. */
+export function readUntrusted(file, max) {
+    return fileExists(file) && !isLink(file) && fs.statSync(file).size <= max ? tryReadJson(file) : null;
+}
+/** The login currently in a Claude config folder (+ its global state file). */
+export function readLogin(claudeDir, globalStateFile) {
+    const credentials = readUntrusted(path.join(claudeDir, '.credentials.json'), MAX_LOGIN_BYTES);
+    if (!credentials || typeof credentials !== 'object')
+        fail('No Claude login found in ' + claudeDir + '.', 'Sign in to Claude first (inside the sandbox, or on this PC with --from-host), then save it again.');
+    return {
+        credentials,
+        oauthAccount: readUntrusted(globalStateFile, MAX_STATE_BYTES)?.oauthAccount ?? null,
+    };
+}
+/** The sandbox's Claude login files (refuses when the data folder holds a link on the way). */
+export function sandboxLogin(dataPath) {
+    assertNoLinks(dataPath, sandboxClaudeDir(dataPath));
+    return {
+        claudeDir: sandboxClaudeDir(dataPath),
+        globalStateFile: path.join(sandboxClaudeDir(dataPath), '.claude.json'),
+    };
+}
+/** Replaces a file that may be a sandbox-planted link instead of writing through it. */
+export function writeSandboxJson(file, value) {
+    assertTestWritable(file);
+    if (isLink(file))
+        removeLink(file);
+    writeJson(file, value);
+}
+/** Removes the previous account's caches; otherwise its org policy could linger. A link is removed, not followed. */
+export function clearAccountCaches(claudeDir) {
+    for (const cache of ACCOUNT_CACHES) {
+        const file = path.join(claudeDir, cache);
+        if (isLink(file))
+            removeLink(file);
+        else
+            fs.rmSync(file, { force: true });
+    }
+}

package/dist/host/{claude-profile.d.ts → profile/claude-profile.d.ts}

@@ -1,15 +1,15 @@
-import type { ClaudeProfileConfig, ProfileResult } from '../core/types.js';
+import type { ClaudeProfileConfig, ProfileResult } from '../../core/types.js';
 import { type SecretsConfig } from './secrets.js';
-export declare const hostClaudeDir: (settings: ClaudeProfileConfig) => string;
-export declare const hostGlobalStateFile: (settings: ClaudeProfileConfig) => string;
-/**
- * Copies SELECTED Claude settings from this PC into the launch folder. Conversation history is handled
- * separately by history.ts (it needs path translation), and the login only travels when copyCredentials is on.
- */
+export declare function hostClaudeDir(settings: ClaudeProfileConfig): string;
+export declare function hostGlobalStateFile(settings: ClaudeProfileConfig): string;
 /**
  * What of your .claude.json the sandbox gets: everything except secrets and other projects. API keys and the account
  * block stay on this PC (logins travel only through `sandbox account`), and of the per-project entries only
  * this workspace's (with its MCP servers) is kept; other projects' entries can hold their MCP servers' tokens.
  */
-export declare const sandboxGlobalState: (state: Record<string, unknown>, workspaceHost: string) => Record<string, unknown>;
-export declare const stageClaudeProfile: (settings: ClaudeProfileConfig, launchPath: string, workspaceHost: string, secrets: SecretsConfig) => ProfileResult;
+export declare function sandboxGlobalState(state: Record<string, unknown>, workspaceHost: string): Record<string, unknown>;
+/**
+ * Copies SELECTED Claude settings from this PC into the launch folder. Conversation history is handled
+ * separately by history.ts (it needs path translation), and the login only travels when copyCredentials is on.
+ */
+export declare function stageClaudeProfile(settings: ClaudeProfileConfig, launchPath: string, workspaceHost: string, secrets: SecretsConfig): ProfileResult;

package/dist/host/{claude-profile.js → profile/claude-profile.js}

@@ -1,10 +1,11 @@
+// Your Claude settings from this PC, staged into the launch folder for the sandbox with secrets stripped.
 import fs from 'node:fs';
 import path from 'node:path';
+import { dirExists, ensureDir, fileExists, homeDir, isLink, readJson, writeJson } from '../../core/util/index.js';
 import { stripMcpServers, stripSettings } from './secrets.js';
-import { dirExists, ensureDir, fileExists, homeDir, isLink, readJson, writeJson } from '../core/util.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. */
-const directorySize = (dir) => {
+function directorySize(dir) {
     let total = 0;
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const full = path.join(dir, entry.name);
@@ -14,8 +15,8 @@ const directorySize = (dir) => {
             total += fs.statSync(full).size;
     }
     return total;
-};
-const validJson = (file) => {
+}
+function validJson(file) {
     try {
         JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
         return true;
@@ -23,31 +24,36 @@ const validJson = (file) => {
     catch {
         return false;
     }
-};
-export const hostClaudeDir = (settings) => {
-    return settings.hostDir === 'auto' ? (process.env.CLAUDE_CONFIG_DIR ?? path.join(homeDir(), '.claude')) : settings.hostDir;
-};
-export const hostGlobalStateFile = (settings) => {
+}
+export function hostClaudeDir(settings) {
+    return settings.hostDir === 'auto'
+        ? (process.env.CLAUDE_CONFIG_DIR ?? path.join(homeDir(), '.claude'))
+        : settings.hostDir;
+}
+export function hostGlobalStateFile(settings) {
     if (settings.globalStateFile !== 'auto')
         return settings.globalStateFile;
-    return process.env.CLAUDE_CONFIG_DIR ? path.join(process.env.CLAUDE_CONFIG_DIR, '.claude.json') : path.join(homeDir(), '.claude.json');
-};
-/**
- * Copies SELECTED Claude settings from this PC into the launch folder. Conversation history is handled
- * separately by history.ts (it needs path translation), and the login only travels when copyCredentials is on.
- */
+    return process.env.CLAUDE_CONFIG_DIR
+        ? path.join(process.env.CLAUDE_CONFIG_DIR, '.claude.json')
+        : path.join(homeDir(), '.claude.json');
+}
 /**
  * What of your .claude.json the sandbox gets: everything except secrets and other projects. API keys and the account
  * block stay on this PC (logins travel only through `sandbox account`), and of the per-project entries only
  * this workspace's (with its MCP servers) is kept; other projects' entries can hold their MCP servers' tokens.
  */
-export const sandboxGlobalState = (state, workspaceHost) => {
+export function sandboxGlobalState(state, workspaceHost) {
     const { primaryApiKey: _key, customApiKeyResponses: _responses, oauthAccount: _account, projects, ...rest } = state;
-    const same = (key) => key.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase() === workspaceHost.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+    const same = (key) => key.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase() ===
+        workspaceHost.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
     const own = Object.entries((projects ?? {})).filter(([key]) => same(key));
     return { ...rest, projects: Object.fromEntries(own) };
-};
-export const stageClaudeProfile = (settings, launchPath, workspaceHost, secrets) => {
+}
+/**
+ * Copies SELECTED Claude settings from this PC into the launch folder. Conversation history is handled
+ * separately by history.ts (it needs path translation), and the login only travels when copyCredentials is on.
+ */
+export function stageClaudeProfile(settings, launchPath, workspaceHost, secrets) {
     const result = { hostDir: null, staged: [], skipped: [], credentials: false, secretsRemoved: [] };
     if (!settings.enabled)
         return result;
@@ -55,7 +61,7 @@ export const stageClaudeProfile = (settings, launchPath, workspaceHost, secrets)
     result.hostDir = hostDir;
     const target = path.join(launchPath, 'claude-profile');
     ensureDir(target);
-    // The login file goes only through copyCredentials (a project file asking for it is flagged); include never copies it.
+    // The login goes only through copyCredentials (a project file asking for it is flagged); include never copies it.
     const items = settings.include.filter((name) => name.toLowerCase() !== '.credentials.json');
     if (settings.copyCredentials)
         items.push('.credentials.json');
@@ -82,7 +88,11 @@ export const stageClaudeProfile = (settings, launchPath, workspaceHost, secrets)
                 result.skipped.push(name + ' (over 250 MB)');
                 continue;
             }
-            fs.cpSync(source, destination, { recursive: true, force: true, filter: (from) => from === source || !isLink(from) });
+            fs.cpSync(source, destination, {
+                recursive: true,
+                force: true,
+                filter: (from) => from === source || !isLink(from),
+            });
         }
         else {
             result.skipped.push(name + ' (not found)');
@@ -104,4 +114,4 @@ export const stageClaudeProfile = (settings, launchPath, workspaceHost, secrets)
         }
     }
     return result;
-};
+}

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

@@ -0,0 +1,7 @@
+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 { capturePersonalization } from './personalize.js';
+export { toRegFile, type RegValue } from './reg-file.js';
+export { AccountStore, accountsDir, type Account, type AccountRow } from './accounts.js';
+export { sandboxClaudeDir } from './claude-login.js';

package/dist/host/profile/index.js

@@ -0,0 +1,7 @@
+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 { capturePersonalization } from './personalize.js';
+export { toRegFile } from './reg-file.js';
+export { AccountStore, accountsDir } from './accounts.js';
+export { sandboxClaudeDir } from './claude-login.js';

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

@@ -0,0 +1,2 @@
+/** Writes personalize.reg (+ the wallpaper image) into `<launch>\personalize`. Returns a short summary. */
+export declare function capturePersonalization(launchPath: string): string;

package/dist/host/profile/personalize.js

@@ -0,0 +1,127 @@
+// Captures the look of this desktop (theme, accent colour, taskbar, Explorer options, wallpaper, mouse/keyboard,
+// regional formats) from HKCU as a .reg file the sandbox imports at logon. Only an allow-list of values is read.
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensureDir, errMsg, fileExists, isWin, runPowerShell } from '../../core/util/index.js';
+import { toRegFile } from './reg-file.js';
+/** The HKCU values captured, by key. */
+const VALUES = {
+    'Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize': [
+        'AppsUseLightTheme',
+        'SystemUsesLightTheme',
+        'EnableTransparency',
+        'ColorPrevalence',
+    ],
+    'Software\\Microsoft\\Windows\\DWM': [
+        'AccentColor',
+        'AccentColorInactive',
+        'ColorizationColor',
+        'ColorizationAfterglow',
+        'ColorizationColorBalance',
+        'ColorPrevalence',
+        'EnableWindowColorization',
+    ],
+    'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Accent': [
+        'AccentPalette',
+        'AccentColorMenu',
+        'StartColorMenu',
+    ],
+    'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced': [
+        'TaskbarAl',
+        'TaskbarSi',
+        'TaskbarDa',
+        'TaskbarMn',
+        'TaskbarGlomLevel',
+        'ShowTaskViewButton',
+        'Hidden',
+        'HideFileExt',
+        'ShowSuperHidden',
+        'LaunchTo',
+        'NavPaneExpandToCurrentFolder',
+        'NavPaneShowAllFolders',
+        'ShowCopilotButton',
+        'Start_TrackDocs',
+        'Start_Layout',
+    ],
+    'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\StuckRects3': ['Settings'],
+    'Software\\Microsoft\\Windows\\CurrentVersion\\Search': ['SearchboxTaskbarMode'],
+    'Control Panel\\Desktop': [
+        'WallpaperStyle',
+        'TileWallpaper',
+        'MenuShowDelay',
+        'CursorBlinkRate',
+        'DragFullWindows',
+        'FontSmoothing',
+        'FontSmoothingType',
+        'UserPreferencesMask',
+    ],
+    'Control Panel\\Colors': ['Background', 'Hilight', 'HotTrackingColor'],
+    'Control Panel\\Mouse': [
+        'MouseSpeed',
+        'MouseSensitivity',
+        'MouseThreshold1',
+        'MouseThreshold2',
+        'DoubleClickSpeed',
+        'SwapMouseButtons',
+    ],
+    'Control Panel\\Keyboard': ['KeyboardDelay', 'KeyboardSpeed'],
+    'Control Panel\\International': [
+        'sShortDate',
+        'sLongDate',
+        'sShortTime',
+        'sTimeFormat',
+        'iFirstDayOfWeek',
+        'sDecimal',
+        'sThousand',
+        'sList',
+        'iMeasure',
+        'iTime',
+        'iTLZero',
+    ],
+    'Control Panel\\Accessibility\\StickyKeys': ['Flags'],
+};
+function captureScript(spec) {
+    return [
+        '$ErrorActionPreference = "SilentlyContinue"',
+        "$spec = '" + JSON.stringify(spec).replace(/'/g, "''") + "' | ConvertFrom-Json",
+        '$out = @()',
+        'foreach ($p in $spec.PSObject.Properties) {',
+        '  $key = Get-Item -LiteralPath ("HKCU:\\" + $p.Name)',
+        '  if (-not $key) { continue }',
+        '  foreach ($name in $p.Value) {',
+        '    $raw = $key.GetValue($name, $null, "DoNotExpandEnvironmentNames")',
+        '    if ($null -eq $raw) { continue }',
+        '    $kind = $key.GetValueKind($name).ToString()',
+        '    if ($kind -eq "Binary") { $raw = [Convert]::ToBase64String([byte[]]$raw) }',
+        '    $out += [pscustomobject]@{ key = $p.Name; name = $name; kind = $kind; value = $raw }',
+        '  }',
+        '}',
+        '$wall = (Get-ItemProperty -LiteralPath "HKCU:\\Control Panel\\Desktop").WallPaper',
+        '[pscustomobject]@{ values = $out; wallpaper = $wall } | ConvertTo-Json -Depth 5 -Compress',
+    ].join('\n');
+}
+/** Writes personalize.reg (+ the wallpaper image) into `<launch>\personalize`. Returns a short summary. */
+export function capturePersonalization(launchPath) {
+    if (!isWin)
+        return 'skipped (not Windows)';
+    try {
+        const { status, stdout } = runPowerShell(captureScript(VALUES), true);
+        if (status !== 0)
+            return 'skipped (registry read failed)';
+        // runPowerShell has PowerShell write UTF-8 (non-ASCII date formats and wallpaper paths survive); a BOM is allowed.
+        const parsed = JSON.parse(stdout.replace(/^\uFEFF/, '').trim());
+        const values = parsed.values === null ? [] : Array.isArray(parsed.values) ? parsed.values : [parsed.values];
+        const dir = path.join(launchPath, 'personalize');
+        ensureDir(dir);
+        fs.writeFileSync(path.join(dir, 'personalize.reg'), '\uFEFF' + toRegFile(values), 'utf16le');
+        const wallpaper = parsed.wallpaper ?? '';
+        const themesCopy = path.join(process.env.APPDATA ?? '', 'Microsoft', 'Windows', 'Themes', 'TranscodedWallpaper');
+        const source = fileExists(wallpaper) ? wallpaper : fileExists(themesCopy) ? themesCopy : null;
+        if (source)
+            fs.copyFileSync(source, path.join(dir, 'wallpaper' + (path.extname(source) || '.jpg')));
+        return values.length + ' settings' + (source ? ' + wallpaper' : '');
+    }
+    catch (e) {
+        return 'skipped (' + errMsg(e) + ')';
+    }
+}

package/dist/host/profile/reg-file.d.ts

@@ -0,0 +1,8 @@
+export interface RegValue {
+    readonly key: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly value: string | number | string[];
+}
+/** Formats captured values as a .reg file (UTF-16 friendly text; written as UTF-16LE with BOM). */
+export declare function toRegFile(values: RegValue[]): string;

package/dist/host/profile/reg-file.js

@@ -0,0 +1,45 @@
+// The .reg file format (as regedit imports it) for values captured from HKCU.
+function toHex(bytes) {
+    return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join(',');
+}
+function regString(s) {
+    return '"' + s.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+}
+/** Formats captured values as a .reg file (UTF-16 friendly text; written as UTF-16LE with BOM). */
+export function toRegFile(values) {
+    const byKey = new Map();
+    for (const v of values)
+        byKey.set(v.key, [...(byKey.get(v.key) ?? []), v]);
+    const lines = ['Windows Registry Editor Version 5.00', ''];
+    for (const [key, list] of byKey) {
+        lines.push('[HKEY_CURRENT_USER\\' + key + ']');
+        for (const v of list) {
+            const name = regString(v.name);
+            switch (v.kind) {
+                case 'DWord':
+                    lines.push(name + '=dword:' + (Number(v.value) >>> 0).toString(16).padStart(8, '0'));
+                    break;
+                case 'QWord':
+                    lines.push(name +
+                        '=hex(b):' +
+                        toHex(Buffer.from(BigInt.asUintN(64, BigInt(v.value))
+                            .toString(16)
+                            .padStart(16, '0'), 'hex').reverse()));
+                    break;
+                case 'Binary':
+                    lines.push(name + '=hex:' + toHex(Buffer.from(String(v.value), 'base64')));
+                    break;
+                case 'ExpandString':
+                    lines.push(name + '=hex(2):' + toHex(Buffer.from(String(v.value) + '\0', 'utf16le')));
+                    break;
+                case 'MultiString':
+                    lines.push(name + '=hex(7):' + toHex(Buffer.from(v.value.join('\0') + '\0\0', 'utf16le')));
+                    break;
+                default:
+                    lines.push(name + '=' + regString(String(v.value)));
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\r\n');
+}

package/dist/host/profile/secret-files.d.ts

@@ -0,0 +1,2 @@
+/** Secret-looking files in the workspace root and one folder down (skipping dependency folders). */
+export declare function findSecretFiles(workspace: string): string[];