windows-development-sandbox 1.4.1 → 1.4.3

package/dist/host/{cleanup.js → storage/cleanup.js}

@@ -2,19 +2,21 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
-import { sizeOf } from '../core/disk.js';
-import { dirExists, isLink } from '../core/util.js';
-import { safeRemove } from '../shared/safe-remove.js';
+import { sizeOf } from '../../core/disk.js';
+import { dirExists, isLink } from '../../core/util/index.js';
+import { safeRemove } from '../../shared/io/index.js';
 const DAY = 24 * 60 * 60 * 1000;
 export const DEFAULT_PRUNE = { launchDays: 7, logDays: 14, conflictDays: 30, keep: [] };
-const ageMs = (p, now) => { try {
-    return now - fs.lstatSync(p).mtimeMs;
-}
-catch {
-    return 0;
-} };
+const ageMs = (p, now) => {
+    try {
+        return now - fs.lstatSync(p).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+};
 /** Entries of a real folder; a link in place of a folder yields nothing (it is never listed or entered). */
-const children = (dir) => (dirExists(dir) && !isLink(dir) ? fs.readdirSync(dir).map((name) => path.join(dir, name)) : []);
+const children = (dir) => dirExists(dir) && !isLink(dir) ? fs.readdirSync(dir).map((name) => path.join(dir, name)) : [];
 /**
  * Deletes, under the storage root:
  *  - launch folders older than `launchDays` (a launch folder is only used by the sandbox it started; `keep` protects the running one)
@@ -40,7 +42,11 @@ export const pruneStorage = (storageRoot, options = {}) => {
             if (ageMs(log, now) > o.logDays * DAY)
                 remove(log, 'logs');
         const runDir = path.join(data, 'run');
-        const dirs = [path.join(data, 'tools'), path.join(data, 'state'), ...(isLink(runDir) ? [] : [runDir, path.join(runDir, 'responses')])];
+        const dirs = [
+            path.join(data, 'tools'),
+            path.join(data, 'state'),
+            ...(isLink(runDir) ? [] : [runDir, path.join(runDir, 'responses')]),
+        ];
         for (const dir of dirs) {
             for (const entry of children(dir)) {
                 const name = path.basename(entry);
@@ -54,4 +60,13 @@ export const pruneStorage = (storageRoot, options = {}) => {
     }
     return result;
 };
-export const describePrune = (r) => r.launches + r.logs + r.leftovers === 0 ? 'nothing to clean' : _.compact([r.launches && r.launches + ' launch folder(s)', r.logs && r.logs + ' log(s)', r.leftovers && r.leftovers + ' leftover(s)']).join(', ') + ' removed (' + Math.round(r.bytes / 1048576) + ' MB)';
+export const describePrune = (r) => r.launches + r.logs + r.leftovers === 0
+    ? 'nothing to clean'
+    : _.compact([
+        r.launches && r.launches + ' launch folder(s)',
+        r.logs && r.logs + ' log(s)',
+        r.leftovers && r.leftovers + ' leftover(s)',
+    ]).join(', ') +
+        ' removed (' +
+        Math.round(r.bytes / 1048576) +
+        ' MB)';

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

@@ -0,0 +1,2 @@
+export * from './cleanup.js';
+export * from './state-files.js';

package/dist/host/storage/index.js

@@ -0,0 +1,2 @@
+export * from './cleanup.js';
+export * from './state-files.js';

package/dist/host/storage/state-files.d.ts

@@ -0,0 +1,4 @@
+export type StateFileSuffix = '.json' | '-audit.json' | '-forwards.json' | '-life.json' | '-mark.json' | '-repo.json' | '-repo-findings.json' | '-size.json' | '-views.json';
+/** The storage folder a data folder is in (<storage>\data\<name>); inside a sandbox it differs from the context's. */
+export declare function storageOf(dataPath: string): string;
+export declare function hostStateFile(storageRoot: string, dataPath: string, suffix: StateFileSuffix): string;

package/dist/host/storage/state-files.js

@@ -0,0 +1,10 @@
+// Host-only state of one data folder: <storage>\sync\<data name><suffix>, never in the data folder the sandbox can
+// write.
+import path from 'node:path';
+/** The storage folder a data folder is in (<storage>\data\<name>); inside a sandbox it differs from the context's. */
+export function storageOf(dataPath) {
+    return path.dirname(path.dirname(dataPath));
+}
+export function hostStateFile(storageRoot, dataPath, suffix) {
+    return path.join(storageRoot, 'sync', path.basename(dataPath) + suffix);
+}

package/dist/host/test-guard.js

@@ -1,6 +1,6 @@
 // Host side of the self-test guard (see shared/test-guard.ts): outward actions refuse, with a message the user can read.
 import { testWriteRefusal, selfTestRunning } from '../shared/test-guard.js';
-import { fail } from '../core/util.js';
+import { fail } from '../core/util/index.js';
 export { selfTestRunning };
 /** Refuses an action that reaches outside the test's own temp folder (a no-op outside the self-test). */
 export const refuseInSelfTest = (what) => {

package/dist/host/tools/conpty.d.ts

@@ -0,0 +1,8 @@
+/** Where the sandbox finds conpty.dll + OpenConsole.exe (guest/ptyhost.ts points ptyhost at it). */
+export declare const conptyDir: (dataPath: string) => string;
+/**
+ * Microsoft's newer pseudo console (the Microsoft.Windows.Console.ConPTY package: conpty.dll and OpenConsole.exe, the
+ * same one Windows Terminal and VS Code use), downloaded once and verified against the SHA-512 NuGet publishes. Agent
+ * sessions use it instead of the one built into Windows, which re-renders the screen and garbles it after resizes.
+ */
+export declare const ensureConpty: (dataPath: string, refresh: boolean) => Promise<string>;

package/dist/host/tools/conpty.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { downloader, extractArchive, fetchJson, moveIntoPlace, stagingFolder } from '../../shared/download/index.js';
+import { safeRemove } from '../../shared/io/index.js';
+import { assertTestWritable } from '../test-guard.js';
+import { z } from 'zod';
+import { assertNoLinks, errMsg, fileExists } from '../../core/util/index.js';
+// ---- conpty.dll -----------------------------------------------------------------------------------------------------
+/** Where the sandbox finds conpty.dll + OpenConsole.exe (guest/ptyhost.ts points ptyhost at it). */
+export const conptyDir = (dataPath) => path.join(dataPath, 'tools', 'conpty');
+const NUGET_CONPTY = 'https://api.nuget.org/v3-flatcontainer/microsoft.windows.console.conpty/';
+const NugetVersionsSchema = z.object({ versions: z.array(z.string()) });
+const NugetLeafSchema = z.object({ catalogEntry: z.string().url() });
+const NugetCatalogSchema = z.object({ packageHash: z.string(), packageHashAlgorithm: z.literal('SHA512') });
+/**
+ * Microsoft's newer pseudo console (the Microsoft.Windows.Console.ConPTY package: conpty.dll and OpenConsole.exe, the
+ * same one Windows Terminal and VS Code use), downloaded once and verified against the SHA-512 NuGet publishes. Agent
+ * sessions use it instead of the one built into Windows, which re-renders the screen and garbles it after resizes.
+ */
+export const ensureConpty = async (dataPath, refresh) => {
+    const dir = conptyDir(dataPath);
+    assertTestWritable(dir);
+    assertNoLinks(dataPath, dir);
+    if (fileExists(path.join(dir, 'conpty.dll')) && fileExists(path.join(dir, 'OpenConsole.exe')) && !refresh)
+        return 'cached';
+    const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+    const work = stagingFolder(dir);
+    try {
+        const version = NugetVersionsSchema.parse(await fetchJson(NUGET_CONPTY + 'index.json'))
+            .versions.filter((v) => !v.includes('-'))
+            .pop();
+        if (!version)
+            throw new Error('no release found');
+        const leaf = NugetLeafSchema.parse(await fetchJson('https://api.nuget.org/v3/registration5-gz-semver2/microsoft.windows.console.conpty/' + version + '.json'));
+        const sha512 = Buffer.from(NugetCatalogSchema.parse(await fetchJson(leaf.catalogEntry)).packageHash, 'base64').toString('hex');
+        const pkg = path.join(work, 'conpty.nupkg');
+        await downloader.file(NUGET_CONPTY + version + '/microsoft.windows.console.conpty.' + version + '.nupkg', pkg, {
+            sha512,
+        });
+        const files = {
+            'conpty.dll': 'runtimes/win-' + arch + '/native/conpty.dll',
+            'OpenConsole.exe': 'build/native/runtimes/' + arch + '/OpenConsole.exe',
+        };
+        await extractArchive(pkg, path.join(work, 'x'), Object.values(files));
+        fs.mkdirSync(path.join(work, 'out'));
+        for (const [name, member] of Object.entries(files))
+            fs.copyFileSync(path.join(work, 'x', ...member.split('/')), path.join(work, 'out', name));
+        fs.writeFileSync(path.join(work, 'out', 'VERSION'), version);
+        moveIntoPlace(path.join(work, 'out'), dir);
+        return 'downloaded ' + version;
+    }
+    catch (e) {
+        return "not downloaded, sessions use Windows' own pseudo console (" + errMsg(e) + ')';
+    }
+    finally {
+        safeRemove(work, path.dirname(work));
+    }
+};

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

@@ -0,0 +1,2 @@
+export * from './windows-terminal.js';
+export * from './conpty.js';

package/dist/host/tools/index.js

@@ -0,0 +1,2 @@
+export * from './windows-terminal.js';
+export * from './conpty.js';

package/dist/host/{terminal.d.ts → tools/windows-terminal.d.ts}

@@ -3,7 +3,7 @@ export declare const terminalDir: (dataPath: string) => string;
 export declare const terminalExe: (dataPath: string) => string;
 /** Our own profile id, so the profile is found again (and user edits to it are kept) on later launches. */
 export declare const PWSH_PROFILE_GUID = "{5f3a6c1e-7d2b-4e8a-9c41-0b6d2a8f7e93}";
-declare const TerminalSettings: z.ZodObject<{
+declare const TerminalSettingsSchema: z.ZodObject<{
     profiles: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
         guid: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>, z.ZodObject<{
@@ -16,7 +16,7 @@ declare const TerminalSettings: z.ZodObject<{
  * settings.json with the "PowerShell 7" profile shown when `visible`, else hidden (never deleted: a user's tweaks to it
  * survive turning pwsh off and on). Pure: returns null when nothing changes.
  */
-export declare const withPwshProfile: (settings: z.output<typeof TerminalSettings>, visible: boolean) => z.output<typeof TerminalSettings> | null;
+export declare const withPwshProfile: (settings: z.output<typeof TerminalSettingsSchema>, visible: boolean) => z.output<typeof TerminalSettingsSchema> | null;
 /**
  * Shows the PowerShell 7 profile once pwsh is installed in this data folder (and `allowed`, i.e. toolchains.pwsh is
  * not off), hides it otherwise. settings.json is written by the sandbox too: read with a size cap, through no links,
@@ -29,12 +29,4 @@ export declare const ensureTerminal: (dataPath: string, refresh: boolean, option
     exe: string | null;
     message: string;
 }>;
-/** Where the sandbox finds conpty.dll + OpenConsole.exe (guest/ptyhost.ts points ptyhost at it). */
-export declare const conptyDir: (dataPath: string) => string;
-/**
- * Microsoft's newer pseudo console (the Microsoft.Windows.Console.ConPTY package: conpty.dll and OpenConsole.exe, the
- * same one Windows Terminal and VS Code use), downloaded once and verified against the SHA-512 NuGet publishes. Agent
- * sessions use it instead of the one built into Windows, which re-renders the screen and garbles it after resizes.
- */
-export declare const ensureConpty: (dataPath: string, refresh: boolean) => Promise<string>;
 export {};

package/dist/host/{terminal.js → tools/windows-terminal.js}

@@ -2,11 +2,11 @@
 // logon.cmd can open it the moment the sandbox logs in (no PowerShell window first).
 import fs from 'node:fs';
 import path from 'node:path';
-import { download, extractArchive, fetchJson, githubAsset, installArchive, moveIntoPlace, stagingFolder } from '../shared/download.js';
-import { safeRemove } from '../shared/safe-remove.js';
-import { assertTestWritable } from './test-guard.js';
+import { downloader, githubAsset } from '../../shared/download/index.js';
+import { safeRemove } from '../../shared/io/index.js';
+import { assertTestWritable } from '../test-guard.js';
 import { z } from 'zod';
-import { assertNoLinks, errMsg, fileExists, parseJsonc, writeJson } from '../core/util.js';
+import { assertNoLinks, errMsg, fileExists, parseJsonc, writeJson } from '../../core/util/index.js';
 export const terminalDir = (dataPath) => path.join(dataPath, 'tools', 'terminal');
 export const terminalExe = (dataPath) => path.join(terminalDir(dataPath), 'WindowsTerminal.exe');
 /**
@@ -21,15 +21,22 @@ const SETTINGS = {
     // New tabs pick up the PATH and variables the runner writes machine-wide after the window opened.
     compatibility: { reloadEnvironmentVariables: true },
     warning: { confirmCloseAllTabs: false, largePaste: false, multiLinePaste: false },
-    profiles: { defaults: { font: { face: 'Cascadia Mono' }, startingDirectory: '%AGENT_WORKSPACE%', closeOnExit: 'graceful' } },
+    profiles: {
+        defaults: { font: { face: 'Cascadia Mono' }, startingDirectory: '%AGENT_WORKSPACE%', closeOnExit: 'graceful' },
+    },
 };
 /** Our own profile id, so the profile is found again (and user edits to it are kept) on later launches. */
 export const PWSH_PROFILE_GUID = '{5f3a6c1e-7d2b-4e8a-9c41-0b6d2a8f7e93}';
 /** pwsh.exe as the sandbox sees it (toolchains/pwsh.ts installs it to tools\pwsh). */
 const GUEST_PWSH = 'C:\\AgentData\\tools\\pwsh\\pwsh.exe';
 const MAX_SETTINGS_BYTES = 1024 * 1024;
-const TerminalSettings = z.looseObject({
-    profiles: z.union([z.array(z.looseObject({ guid: z.string().optional() })), z.looseObject({ list: z.array(z.looseObject({ guid: z.string().optional() })).optional() })]).optional(),
+const TerminalSettingsSchema = z.looseObject({
+    profiles: z
+        .union([
+        z.array(z.looseObject({ guid: z.string().optional() })),
+        z.looseObject({ list: z.array(z.looseObject({ guid: z.string().optional() })).optional() }),
+    ])
+        .optional(),
 });
 /**
  * settings.json with the "PowerShell 7" profile shown when `visible`, else hidden (never deleted: a user's tweaks to it
@@ -42,7 +49,13 @@ export const withPwshProfile = (settings, visible) => {
     if (at === -1 && !visible)
         return null;
     if (at === -1)
-        list.push({ guid: PWSH_PROFILE_GUID, name: 'PowerShell 7', commandline: '"' + GUEST_PWSH + '" -NoLogo', icon: GUEST_PWSH, hidden: false });
+        list.push({
+            guid: PWSH_PROFILE_GUID,
+            name: 'PowerShell 7',
+            commandline: '"' + GUEST_PWSH + '" -NoLogo',
+            icon: GUEST_PWSH,
+            hidden: false,
+        });
     else if ((list[at].hidden === true) === !visible)
         return null;
     else
@@ -63,7 +76,7 @@ export const syncPwshProfile = (dataPath, allowed) => {
     const visible = allowed && fileExists(path.join(dataPath, 'tools', 'pwsh', 'pwsh.exe'));
     let parsed;
     try {
-        const result = TerminalSettings.safeParse(parseJsonc(fs.readFileSync(file, 'utf8'), file));
+        const result = TerminalSettingsSchema.safeParse(parseJsonc(fs.readFileSync(file, 'utf8'), file));
         if (!result.success)
             return;
         parsed = result.data;
@@ -88,57 +101,13 @@ export const ensureTerminal = async (dataPath, refresh, options = {}) => {
     }
     return result;
 };
-// ---- conpty.dll ------------------------------------------------------------------------------------------------------
-/** Where the sandbox finds conpty.dll + OpenConsole.exe (guest/ptyhost.ts points ptyhost at it). */
-export const conptyDir = (dataPath) => path.join(dataPath, 'tools', 'conpty');
-const NUGET_CONPTY = 'https://api.nuget.org/v3-flatcontainer/microsoft.windows.console.conpty/';
-const NugetVersions = z.object({ versions: z.array(z.string()) });
-const NugetLeaf = z.object({ catalogEntry: z.string().url() });
-const NugetCatalog = z.object({ packageHash: z.string(), packageHashAlgorithm: z.literal('SHA512') });
-/**
- * Microsoft's newer pseudo console (the Microsoft.Windows.Console.ConPTY package: conpty.dll and OpenConsole.exe, the
- * same one Windows Terminal and VS Code use), downloaded once and verified against the SHA-512 NuGet publishes. Agent
- * sessions use it instead of the one built into Windows, which re-renders the screen and garbles it after resizes.
- */
-export const ensureConpty = async (dataPath, refresh) => {
-    const dir = conptyDir(dataPath);
-    assertTestWritable(dir);
-    assertNoLinks(dataPath, dir);
-    if (fileExists(path.join(dir, 'conpty.dll')) && fileExists(path.join(dir, 'OpenConsole.exe')) && !refresh)
-        return 'cached';
-    const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
-    const work = stagingFolder(dir);
-    try {
-        const version = NugetVersions.parse(await fetchJson(NUGET_CONPTY + 'index.json')).versions.filter((v) => !v.includes('-')).pop();
-        if (!version)
-            throw new Error('no release found');
-        const leaf = NugetLeaf.parse(await fetchJson('https://api.nuget.org/v3/registration5-gz-semver2/microsoft.windows.console.conpty/' + version + '.json'));
-        const sha512 = Buffer.from(NugetCatalog.parse(await fetchJson(leaf.catalogEntry)).packageHash, 'base64').toString('hex');
-        const pkg = path.join(work, 'conpty.nupkg');
-        await download(NUGET_CONPTY + version + '/microsoft.windows.console.conpty.' + version + '.nupkg', pkg, { sha512 });
-        const files = { 'conpty.dll': 'runtimes/win-' + arch + '/native/conpty.dll', 'OpenConsole.exe': 'build/native/runtimes/' + arch + '/OpenConsole.exe' };
-        await extractArchive(pkg, path.join(work, 'x'), Object.values(files));
-        fs.mkdirSync(path.join(work, 'out'));
-        for (const [name, member] of Object.entries(files))
-            fs.copyFileSync(path.join(work, 'x', ...member.split('/')), path.join(work, 'out', name));
-        fs.writeFileSync(path.join(work, 'out', 'VERSION'), version);
-        moveIntoPlace(path.join(work, 'out'), dir);
-        return 'downloaded ' + version;
-    }
-    catch (e) {
-        return 'not downloaded, sessions use Windows\' own pseudo console (' + errMsg(e) + ')';
-    }
-    finally {
-        safeRemove(work, path.dirname(work));
-    }
-};
 const installTerminal = async (dataPath, refresh) => {
     const exe = terminalExe(dataPath);
     const dir = terminalDir(dataPath);
     assertTestWritable(dir);
     const settings = path.join(dir, 'settings');
-    // installArchive replaces tools\terminal: the portable settings folder waits here meanwhile (and goes back also when
-    // the download fails). One still parked from an interrupted earlier run is the one to keep.
+    // downloader.archive replaces tools\terminal: the portable settings folder waits here meanwhile (and goes back also
+    // when the download fails). One still parked from an interrupted earlier run is the one to keep.
     const parked = path.join(dataPath, 'tools', 'terminal-settings.parked');
     assertNoLinks(dataPath, settings);
     assertNoLinks(dataPath, parked);
@@ -152,7 +121,11 @@ const installTerminal = async (dataPath, refresh) => {
         try {
             const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
             const asset = await githubAsset('microsoft/terminal', new RegExp('^Microsoft\\.WindowsTerminal_[\\d.]+_' + arch + '\\.zip$'));
-            await installArchive(asset.url, dir, { sha256: asset.sha256, locate: 'WindowsTerminal.exe', fileName: asset.name });
+            await downloader.archive(asset.url, dir, {
+                sha256: asset.sha256,
+                locate: 'WindowsTerminal.exe',
+                fileName: asset.name,
+            });
             fs.writeFileSync(path.join(dir, '.portable'), '');
             return { exe, message: 'downloaded ' + asset.name };
         }
@@ -169,6 +142,9 @@ const installTerminal = async (dataPath, refresh) => {
         }
     }
     catch (e) {
-        return { exe: null, message: 'download failed, the sandbox will use a plain PowerShell window (' + errMsg(e) + ')' };
+        return {
+            exe: null,
+            message: 'download failed, the sandbox will use a plain PowerShell window (' + errMsg(e) + ')',
+        };
     }
 };

package/dist/host/workspace-view/active-views.d.ts

@@ -0,0 +1,3 @@
+import { type ViewOptions } from './view.js';
+export declare const saveActiveViews: (storageRoot: string, dataPath: string, views: ViewOptions[]) => void;
+export declare const readActiveViews: (storageRoot: string, dataPath: string) => ViewOptions[];

package/dist/host/workspace-view/active-views.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { JsonFile } from '../../shared/io/index.js';
+import { hostStateFile } from '../storage/index.js';
+// ---- the views the watcher keeps in step (host-only, next to the sync state) ----------------------------------------
+const ActiveViewSchema = z.object({
+    host: z.string().max(1024),
+    view: z.string().max(1024),
+    state: z.string().max(1024),
+    exclude: z.array(z.string().max(500)).max(500),
+    include: z.array(z.string().max(500)).max(500),
+    guestGitDir: z.string().max(1024).nullable(),
+});
+const activeFile = (storageRoot, dataPath) => new JsonFile(z.array(ActiveViewSchema).max(64), hostStateFile(storageRoot, dataPath, '-views.json'));
+export const saveActiveViews = (storageRoot, dataPath, views) => activeFile(storageRoot, dataPath).write(views.map((v) => ({
+    host: v.host,
+    view: v.view,
+    state: v.state,
+    exclude: v.exclude ?? [],
+    include: v.include ?? [],
+    guestGitDir: v.guestGitDir ?? null,
+})));
+export const readActiveViews = (storageRoot, dataPath) => activeFile(storageRoot, dataPath).read() ?? [];

package/dist/host/workspace-view/index.d.ts

@@ -1,20 +1,4 @@
-import type { Config } from '../../core/types.js';
-import { type ViewOptions } from './view.js';
 export { IgnoreRules } from './rules.js';
 export { WorkspaceView, type SyncStats, type ViewOptions } from './view.js';
-/** The project's .git as the sandbox sees it: next to the workspace (C:\Workspace\app -> C:\Workspace\app.git). */
-export declare const guestGitDir: (guestWorkspace: string) => string;
-export interface ViewPlan {
-    options: ViewOptions; /** The project's real .git folder, mapped at options.guestGitDir (null: none). */
-    hostGit: string | null;
-    note?: string;
-}
-/**
- * The view for a launch, or null when the folder itself is mapped: workspaceFilter off, or a git worktree (its .git is
- * a file pointing elsewhere, which a view cannot follow; then the folder is mapped as before and a note says so).
- */
-export declare const planView: (config: Config, storageRoot: string, workspaceHost: string) => ViewPlan | null;
-/** Why a filtered launch maps the folder itself after all (for the launch notes). */
-export declare const viewSkipped: (config: Config, workspaceHost: string) => string | null;
-export declare const saveActiveViews: (storageRoot: string, dataPath: string, views: ViewOptions[]) => void;
-export declare const readActiveViews: (storageRoot: string, dataPath: string) => ViewOptions[];
+export * from './plan.js';
+export * from './active-views.js';

package/dist/host/workspace-view/index.js

@@ -1,53 +1,6 @@
 // workspaceFilter in practice: which view a launch maps instead of the project, the project's .git mapped beside it,
 // and the host-only list of views the background watcher keeps in step while the sandbox runs.
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-import { readValid, writeJsonAtomic } from '../../shared/rundir.js';
-import { WorkspaceView } from './view.js';
 export { IgnoreRules } from './rules.js';
 export { WorkspaceView } from './view.js';
-/** The project's .git as the sandbox sees it: next to the workspace (C:\Workspace\app -> C:\Workspace\app.git). */
-export const guestGitDir = (guestWorkspace) => guestWorkspace.replace(/[\\/]+$/, '') + '.git';
-/**
- * The view for a launch, or null when the folder itself is mapped: workspaceFilter off, or a git worktree (its .git is
- * a file pointing elsewhere, which a view cannot follow; then the folder is mapped as before and a note says so).
- */
-export const planView = (config, storageRoot, workspaceHost) => {
-    if (!config.workspaceFilter.enabled)
-        return null;
-    const git = path.join(workspaceHost, '.git');
-    let gitIsDir = false;
-    try {
-        const s = fs.lstatSync(git);
-        if (s.isFile())
-            return null;
-        gitIsDir = s.isDirectory() && !s.isSymbolicLink();
-    }
-    catch { /* no .git */ }
-    // git access "none": the agent gets no .git at all.
-    const hostGit = gitIsDir && config.provisioning.git.enabled && config.provisioning.git.access !== 'none' ? git : null;
-    return {
-        options: { ...WorkspaceView.pathsFor(storageRoot, workspaceHost), exclude: config.workspaceFilter.exclude, include: config.workspaceFilter.include, guestGitDir: hostGit ? guestGitDir(config.guestWorkspace) : null },
-        hostGit,
-    };
-};
-/** Why a filtered launch maps the folder itself after all (for the launch notes). */
-export const viewSkipped = (config, workspaceHost) => {
-    if (!config.workspaceFilter.enabled)
-        return null;
-    try {
-        if (fs.lstatSync(path.join(workspaceHost, '.git')).isFile())
-            return 'workspaceFilter: ' + workspaceHost + ' is a git worktree (.git is a file); the folder is mapped as it is, git-ignored files included.';
-    }
-    catch { /* fine */ }
-    return null;
-};
-// ---- the views the watcher keeps in step (host-only, next to the sync state) ------------------------------------------
-const ActiveView = z.object({
-    host: z.string().max(1024), view: z.string().max(1024), state: z.string().max(1024),
-    exclude: z.array(z.string().max(500)).max(500), include: z.array(z.string().max(500)).max(500), guestGitDir: z.string().max(1024).nullable(),
-});
-const activeFile = (storageRoot, dataPath) => path.join(storageRoot, 'sync', path.basename(dataPath) + '-views.json');
-export const saveActiveViews = (storageRoot, dataPath, views) => writeJsonAtomic(activeFile(storageRoot, dataPath), views.map((v) => ({ host: v.host, view: v.view, state: v.state, exclude: v.exclude ?? [], include: v.include ?? [], guestGitDir: v.guestGitDir ?? null })));
-export const readActiveViews = (storageRoot, dataPath) => readValid(z.array(ActiveView).max(64), activeFile(storageRoot, dataPath)) ?? [];
+export * from './plan.js';
+export * from './active-views.js';

package/dist/host/workspace-view/plan.d.ts

@@ -0,0 +1,16 @@
+import type { Config } from '../../core/types.js';
+import { type ViewOptions } from './view.js';
+/** The project's .git as the sandbox sees it: next to the workspace (C:\Workspace\app -> C:\Workspace\app.git). */
+export declare const guestGitDir: (guestWorkspace: string) => string;
+export interface ViewPlan {
+    options: ViewOptions;
+    /** The project's real .git folder, mapped at options.guestGitDir (null: none). */ hostGit: string | null;
+    note?: string;
+}
+/**
+ * The view for a launch, or null when the folder itself is mapped: workspaceFilter off, or a git worktree (its .git is
+ * a file pointing elsewhere, which a view cannot follow; then the folder is mapped as before and a note says so).
+ */
+export declare const planView: (config: Config, storageRoot: string, workspaceHost: string) => ViewPlan | null;
+/** Why a filtered launch maps the folder itself after all (for the launch notes). */
+export declare const viewSkipped: (config: Config, workspaceHost: string) => string | null;

package/dist/host/workspace-view/plan.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { WorkspaceView } from './view.js';
+/** The project's .git as the sandbox sees it: next to the workspace (C:\Workspace\app -> C:\Workspace\app.git). */
+export const guestGitDir = (guestWorkspace) => guestWorkspace.replace(/[\\/]+$/, '') + '.git';
+/**
+ * The view for a launch, or null when the folder itself is mapped: workspaceFilter off, or a git worktree (its .git is
+ * a file pointing elsewhere, which a view cannot follow; then the folder is mapped as before and a note says so).
+ */
+export const planView = (config, storageRoot, workspaceHost) => {
+    if (!config.workspaceFilter.enabled)
+        return null;
+    const git = path.join(workspaceHost, '.git');
+    let gitIsDir = false;
+    try {
+        const s = fs.lstatSync(git);
+        if (s.isFile())
+            return null;
+        gitIsDir = s.isDirectory() && !s.isSymbolicLink();
+    }
+    catch {
+        /* no .git */
+    }
+    // git access "none": the agent gets no .git at all.
+    const hostGit = gitIsDir && config.provisioning.git.enabled && config.provisioning.git.access !== 'none' ? git : null;
+    return {
+        options: {
+            ...WorkspaceView.pathsFor(storageRoot, workspaceHost),
+            exclude: config.workspaceFilter.exclude,
+            include: config.workspaceFilter.include,
+            guestGitDir: hostGit ? guestGitDir(config.guestWorkspace) : null,
+        },
+        hostGit,
+    };
+};
+/** Why a filtered launch maps the folder itself after all (for the launch notes). */
+export const viewSkipped = (config, workspaceHost) => {
+    if (!config.workspaceFilter.enabled)
+        return null;
+    try {
+        if (fs.lstatSync(path.join(workspaceHost, '.git')).isFile())
+            return ('workspaceFilter: ' +
+                workspaceHost +
+                ' is a git worktree (.git is a file); the folder is mapped as it is, git-ignored files included.');
+    }
+    catch {
+        /* fine */
+    }
+    return null;
+};

package/dist/host/workspace-view/rules.js

@@ -30,13 +30,20 @@ export class IgnoreRules {
         this.forced = ignore().add(include);
     }
     /** One of your include patterns lets this path in, whatever .gitignore says (even inside an ignored folder). */
-    isForced(rel) { return this.include.length > 0 && this.forced.ignores(rel); }
+    isForced(rel) {
+        return this.include.length > 0 && this.forced.ignores(rel);
+    }
     /** Could one of your include patterns match something inside this ignored folder (so a walk must look inside)? */
     mayIncludeInside(dir) {
-        return this.include.some((p) => { const clean = p.replace(/^\//, ''); return clean.startsWith('**') || clean.startsWith(dir + '/'); });
+        return this.include.some((p) => {
+            const clean = p.replace(/^\//, '');
+            return clean.startsWith('**') || clean.startsWith(dir + '/');
+        });
     }
     /** Forget the .gitignore files read so far (one of them changed). */
-    reset() { this.perFolder.clear(); }
+    reset() {
+        this.perFolder.clear();
+    }
     matcher(folder) {
         if (this.perFolder.has(folder))
             return this.perFolder.get(folder);

package/dist/host/workspace-view/view-state.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** [host size, host time, view size, view time] after the last sync; -1 = no such file. */
+export type Seen = [number, number, number, number];
+export declare const ManifestSchema: z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+/** Most entries one walk looks at: a sandbox can create files faster than they are worth syncing. */
+export declare const MAX_ENTRIES = 300000;
+export declare const stamp: (file: string) => [number, number];
+export declare const sameContent: (a: string, b: string) => boolean;
+/** A path from an event or the manifest: relative, forward slashes, no way out of the root. */
+export declare const safeRel: (rel: string) => string | null;

package/dist/host/workspace-view/view-state.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { z } from 'zod';
+export const ManifestSchema = z.record(z.string().max(1024), z.tuple([z.number(), z.number(), z.number(), z.number()]));
+/** Most entries one walk looks at: a sandbox can create files faster than they are worth syncing. */
+export const MAX_ENTRIES = 300000;
+export const stamp = (file) => {
+    try {
+        const s = fs.lstatSync(file);
+        return s.isFile() ? [s.size, Math.round(s.mtimeMs)] : [-1, -1];
+    }
+    catch {
+        return [-1, -1];
+    }
+};
+export const sameContent = (a, b) => {
+    const hash = (f) => crypto.createHash('sha256').update(fs.readFileSync(f)).digest('hex');
+    try {
+        return fs.statSync(a).size === fs.statSync(b).size && hash(a) === hash(b);
+    }
+    catch {
+        return false;
+    }
+};
+/** A path from an event or the manifest: relative, forward slashes, no way out of the root. */
+export const safeRel = (rel) => {
+    const clean = rel.replace(/\\/g, '/').replace(/^\/+/, '');
+    if (!clean || clean.length > 1000 || clean.split('/').some((p) => p === '..' || p === '' || p.includes(':')))
+        return null;
+    return clean;
+};

package/dist/host/workspace-view/view.d.ts

@@ -25,6 +25,7 @@ export declare class WorkspaceView {
     private readonly o;
     readonly rules: IgnoreRules;
     private seen;
+    private readonly stateFile;
     constructor(o: ViewOptions);
     /** Where a project's view and its sync state live: <storage>\views\<id> and <storage>\views\<id>.json. */
     static pathsFor(storageRoot: string, host: string): ViewPaths;