windows-development-sandbox 1.17.0 → 1.18.0

package/dist/shared/io/text.js

@@ -0,0 +1,18 @@
+// Text files Windows programs write in either UTF-8 or UTF-16LE (the Epic launcher's ini, Unity's files): decoded by
+// their byte-order mark, and written back in the encoding they were read in.
+/** The text of a file's bytes: UTF-16LE with its mark, UTF-8 with or without one (the mark is not part of the text). */
+export function decodeText(bytes) {
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe)
+        return { text: bytes.subarray(2).toString('utf16le'), encoding: 'utf16le' };
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf)
+        return { text: bytes.subarray(3).toString('utf8'), encoding: 'utf8bom' };
+    return { text: bytes.toString('utf8'), encoding: 'utf8' };
+}
+/** The bytes of a text in an encoding (with its mark for UTF-16LE and UTF-8 with a mark). */
+export function encodeText(text, encoding) {
+    if (encoding === 'utf16le')
+        return Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(text, 'utf16le')]);
+    if (encoding === 'utf8bom')
+        return Buffer.concat([Buffer.from([0xef, 0xbb, 0xbf]), Buffer.from(text, 'utf8')]);
+    return Buffer.from(text, 'utf8');
+}

package/dist/shared/paths/guest-paths.js

@@ -4,7 +4,7 @@
 // Pure functions only: used by the schema, the host (.wsb, session.json) and history sync.
 import { win32 } from 'node:path';
 /** Guest folders no mapping may use: the OS, the sandbox's own folders and the mirror root. */
-export const RESERVED_GUEST = /^C:\\(?:Windows|Program Files|Program Files \(x86\)|ProgramData|Users|AgentLaunch|AgentData|HostTools|nvm|Mirror)(?:\\|$)/i;
+export const RESERVED_GUEST = /^C:\\(?:Windows|Program Files|Program Files \(x86\)|ProgramData|Users|AgentLaunch|AgentData|HostTools|nvm|Mirror|PcInstalls)(?:\\|$)/i;
 /** Where folders for other drive letters really live inside the sandbox: C:\Mirror\<letter>. */
 export const MIRROR_ROOT = 'C:\\Mirror';
 /** Letters a mirrored path may use. Never C: (the sandbox's own disk); A:/B: are left alone (floppy-era tools). */

package/dist/shared/paths/index.d.ts

@@ -3,3 +3,4 @@ export * from './claude-paths.js';
 export * from './agent-profile.js';
 export * from './conversation.js';
 export * from './projects.js';
+export * from './pc-installs.js';

package/dist/shared/paths/index.js

@@ -3,3 +3,4 @@ export * from './claude-paths.js';
 export * from './agent-profile.js';
 export * from './conversation.js';
 export * from './projects.js';
+export * from './pc-installs.js';

package/dist/shared/paths/pc-installs.d.ts

@@ -0,0 +1,20 @@
+/** Where this PC's installs appear in the sandbox (reserved: RESERVED_GUEST). */
+export declare const PC_INSTALLS_GUEST = "C:\\PcInstalls";
+export type PcInstallKind = 'steam-game' | 'steam-library' | 'epic-game' | 'unreal' | 'unity';
+export interface PcInstall {
+    readonly kind: PcInstallKind;
+    /** The Steam app ID or library (library1), the Epic app name, the engine (UE_5.4) or editor version. */
+    readonly id: string;
+    readonly name: string;
+    readonly version?: string;
+    /** The folder on this PC (never sent to the sandbox). */
+    readonly host: string;
+    /** Where it appears in the sandbox, read-only. */
+    readonly guest: string;
+}
+/** What session.json says about them: no host paths. */
+export interface PcInstallManifest {
+    readonly items: readonly Omit<PcInstall, 'host'>[];
+}
+/** The guest folder of one install: C:\PcInstalls\steam\<appid>, \epic\<AppName>, \unreal\UE_5.4, \unity\<ver>. */
+export declare function pcInstallGuest(kind: PcInstallKind, id: string): string;

package/dist/shared/paths/pc-installs.js

@@ -0,0 +1,19 @@
+// Read-only installs of this PC (pcInstalls: Steam and Epic games, Unreal engines, Unity editors) as the sandbox sees
+// them: each one under C:\PcInstalls, which no other mapping may use. Pure: the host places them, the sandbox reads
+// the manifest (paths only) from session.json.
+/** Where this PC's installs appear in the sandbox (reserved: RESERVED_GUEST). */
+export const PC_INSTALLS_GUEST = 'C:\\PcInstalls';
+const SAFE_ID = /^[A-Za-z0-9._-]{1,100}$/;
+const AREA = {
+    'steam-game': 'steam',
+    'steam-library': 'steam',
+    'epic-game': 'epic',
+    unreal: 'unreal',
+    unity: 'unity',
+};
+/** The guest folder of one install: C:\PcInstalls\steam\<appid>, \epic\<AppName>, \unreal\UE_5.4, \unity\<ver>. */
+export function pcInstallGuest(kind, id) {
+    if (!SAFE_ID.test(id) || /^\.+$/.test(id))
+        throw new Error('not a usable install id: ' + id);
+    return PC_INSTALLS_GUEST + '\\' + AREA[kind] + '\\' + id;
+}

package/dist/shared/vdf.d.ts

@@ -0,0 +1,25 @@
+export type VdfValue = string | VdfObject;
+export interface VdfObject {
+    readonly [key: string]: VdfValue;
+}
+export interface VdfLimits {
+    /** The most characters read (default 1 MB). */
+    readonly maxBytes?: number;
+    /** The deepest nesting of { } (default 32). */
+    readonly maxDepth?: number;
+    /** The most keys in the whole text (default 100000). */
+    readonly maxKeys?: number;
+    /**
+     * Backslash escapes in quoted text (\\ \" \n \t; default true), as Steam writes libraryfolders.vdf and config.vdf.
+     * Hand-written build scripts ("ContentRoot" "..\content\") need false.
+     */
+    readonly escapes?: boolean;
+}
+/** The root object of a .vdf text, or null when it is not one (or breaks a limit). */
+export declare function parseVdf(text: string, limits?: VdfLimits): VdfObject | null;
+/** The value at a path of keys (any case), or undefined. */
+export declare function vdfGet(root: VdfValue | null | undefined, ...keys: readonly string[]): VdfValue | undefined;
+/** The text at a path of keys (any case), or undefined when it is missing or a block. */
+export declare function vdfText(root: VdfValue | null | undefined, ...keys: readonly string[]): string | undefined;
+/** The block at a path of keys (any case), or undefined when it is missing or a text. */
+export declare function vdfObject(root: VdfValue | null | undefined, ...keys: readonly string[]): VdfObject | undefined;

package/dist/shared/vdf.js

@@ -0,0 +1,151 @@
+// Valve's KeyValues text format (.vdf: libraryfolders.vdf, appmanifest_*.acf, config.vdf, app_build and
+// workshop_item scripts), parsed with hard limits on size, depth and keys (the files may come from a sandbox or a
+// repo). One pass over the text, no regular expressions on it, no recursion, objects without a prototype. Pure.
+const DEFAULT_MAX_BYTES = 1024 * 1024;
+const DEFAULT_MAX_DEPTH = 32;
+const DEFAULT_MAX_KEYS = 100_000;
+const isSpace = (c) => c === ' ' || c === '\t' || c === '\r' || c === '\n' || c === '\f';
+const ESCAPED = { '\\': '\\', '"': '"', n: '\n', t: '\t' };
+/** The tokens of a text, or null when a quote or a [condition] is not closed. */
+function tokenize(text, escapes) {
+    const tokens = [];
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        const c = text[i];
+        if (isSpace(c)) {
+            i++;
+        }
+        else if (c === '/' && text[i + 1] === '/') {
+            while (i < n && text[i] !== '\n')
+                i++;
+        }
+        else if (c === '{') {
+            tokens.push({ kind: 'open' });
+            i++;
+        }
+        else if (c === '}') {
+            tokens.push({ kind: 'close' });
+            i++;
+        }
+        else if (c === '[') {
+            // A platform condition ([$WIN32]) after a value: not used here, skipped.
+            const end = text.indexOf(']', i);
+            if (end < 0)
+                return null;
+            i = end + 1;
+        }
+        else if (c === '"') {
+            let out = '';
+            let start = ++i;
+            for (;;) {
+                if (i >= n)
+                    return null;
+                const d = text[i];
+                if (d === '"')
+                    break;
+                if (escapes && d === '\\' && i + 1 < n && ESCAPED[text[i + 1]] !== undefined) {
+                    out += text.slice(start, i) + ESCAPED[text[i + 1]];
+                    i += 2;
+                    start = i;
+                    continue;
+                }
+                i++;
+            }
+            tokens.push({ kind: 'text', text: out + text.slice(start, i) });
+            i++;
+        }
+        else {
+            const start = i;
+            while (i < n && !isSpace(text[i]) && text[i] !== '{' && text[i] !== '}' && text[i] !== '"')
+                i++;
+            tokens.push({ kind: 'text', text: text.slice(start, i) });
+        }
+    }
+    return tokens;
+}
+function open() {
+    return { target: Object.create(null), seen: new Set() };
+}
+/** Sets a key unless the object has it already in any case (the first one wins); false when it was there. */
+function setFirst(o, key, value) {
+    const lower = key.toLowerCase();
+    if (o.seen.has(lower))
+        return false;
+    o.seen.add(lower);
+    o.target[key] = value;
+    return true;
+}
+/** The root object of a .vdf text, or null when it is not one (or breaks a limit). */
+export function parseVdf(text, limits = {}) {
+    const maxBytes = limits.maxBytes ?? DEFAULT_MAX_BYTES;
+    const maxDepth = limits.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const maxKeys = limits.maxKeys ?? DEFAULT_MAX_KEYS;
+    if (typeof text !== 'string' || text.length > maxBytes)
+        return null;
+    const tokens = tokenize(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text, limits.escapes ?? true);
+    if (!tokens)
+        return null;
+    const root = open();
+    const stack = [root];
+    let keys = 0;
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        const current = stack[stack.length - 1];
+        if (token.kind === 'close') {
+            if (stack.length === 1)
+                return null;
+            stack.pop();
+            i++;
+            continue;
+        }
+        if (token.kind === 'open')
+            return null;
+        if (++keys > maxKeys)
+            return null;
+        const next = tokens[i + 1];
+        if (!next || next.kind === 'close')
+            return null;
+        if (next.kind === 'open') {
+            if (stack.length > maxDepth)
+                return null;
+            const child = open();
+            // A duplicate key's block is still read (into one that is dropped) so the braces stay balanced.
+            setFirst(current, token.text, child.target);
+            stack.push(child);
+        }
+        else {
+            setFirst(current, token.text, next.text);
+        }
+        i += 2;
+    }
+    return stack.length === 1 ? root.target : null;
+}
+/** The value at a path of keys (any case), or undefined. */
+export function vdfGet(root, ...keys) {
+    let at = root ?? undefined;
+    for (const key of keys) {
+        if (at === undefined || typeof at === 'string')
+            return undefined;
+        const lower = key.toLowerCase();
+        let found;
+        for (const k in at)
+            if (k.toLowerCase() === lower) {
+                found = at[k];
+                break;
+            }
+        at = found;
+    }
+    return at;
+}
+/** The text at a path of keys (any case), or undefined when it is missing or a block. */
+export function vdfText(root, ...keys) {
+    const value = vdfGet(root, ...keys);
+    return typeof value === 'string' ? value : undefined;
+}
+/** The block at a path of keys (any case), or undefined when it is missing or a text. */
+export function vdfObject(root, ...keys) {
+    const value = vdfGet(root, ...keys);
+    return value !== undefined && typeof value !== 'string' ? value : undefined;
+}

package/dist/sync/sync-cycle.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { assertNoLinks } from '../core/util/index.js';
+import { takeHandoffs } from '../host/accounts/index.js';
 import { hostClaudeDir, PluginShare } from '../host/profile/index.js';
 import { hostDataFolder, hostDataRoot, storageOf } from '../host/storage/index.js';
 import { hostClaudeMemDir, syncClaudeMem } from './claude-mem.js';
@@ -74,6 +75,14 @@ export function syncBeforeLaunch(config, dataPath, hostWorkspace) {
 }
 /** Syncs the sandbox's history (and, when `final`, claude-mem) back to this PC, as configured for the last launch. */
 export function syncBack(dataPath, final) {
+    // Service sign-ins the sandbox renewed or you made there (accounts.<kind>.share): sealed here, the plain copy gone;
+    // the last sync of a sandbox lets go of its leases.
+    try {
+        takeHandoffs(dataPath, final);
+    }
+    catch {
+        // Never stops a sync: a sign-in that could not be taken stays in the data folder for the next cycle.
+    }
     const state = readSyncState(dataPath);
     const summary = { history: 0, claudeMem: 'disabled' };
     if (!state)

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-XT7T6ODM.css" />
-    <script type="module" src="/main-JTH3FT4O.js"></script>
+    <script type="module" src="/main-CWIF4VQI.js"></script>
   </head>
   <body>
     <div id="root"></div>