windows-development-sandbox 1.5.0 → 1.9.0

package/dist/sync/sync-state.d.ts

@@ -6,6 +6,7 @@ declare const SyncStateSchema: z.ZodObject<{
     syncHistory: z.ZodOptional<z.ZodBoolean>;
     syncClaudeMem: z.ZodOptional<z.ZodBoolean>;
     syncClaudeMemBack: z.ZodOptional<z.ZodBoolean>;
+    sharePlugins: z.ZodOptional<z.ZodBoolean>;
     historyScope: z.ZodOptional<z.ZodEnum<{
         project: "project";
         all: "all";

package/dist/sync/sync-state.js

@@ -14,6 +14,7 @@ const SyncStateSchema = z.object({
     syncHistory: z.boolean().optional(),
     syncClaudeMem: z.boolean().optional(),
     syncClaudeMemBack: z.boolean().optional(),
+    sharePlugins: z.boolean().optional(),
     historyScope: z.enum(['project', 'all']).optional(),
     /** Newest claude-mem database time on each side right after the last sync (detects edits on both sides). */
     memHostStamp: z.number().optional(),

package/dist/sync/watcher.d.ts

@@ -22,12 +22,25 @@ export declare class Watcher {
     private awake;
     private views;
     private stops;
+    private watchdogTimer;
+    private watchdog;
+    private watchdogBusy;
+    private lastCpu;
+    private lastHostLog;
     constructor(dataPath: string, resume?: WatcherResume);
     /** Runs until the sandbox has closed and the final sync is done (or the end deadline passed). */
     run(): Promise<void>;
+    /** Contained storage of this data set (only when a mounted image is on record), else null. */
+    private contained;
+    /** The mounted image stays mounted until the sandbox is gone: this watcher holds it. */
+    private holdContained;
+    /** The sandbox is gone and the last sync done: let go of the image, which dismounts it when nothing else holds it. */
+    private releaseContained;
     private note;
     /** Everything that runs alongside the sandbox, in this order. */
     private start;
+    /** One watchdog sample: this PC's memory and CPU; asks the sandbox to slow down while the PC is low. Never throws. */
+    private watchHost;
     /** The repo guard, then history and (at the end) claude-mem back to this PC. */
     private sync;
     /** The running sessions and their conversations, for the next launch (resume.sessions). */

package/dist/sync/watcher.js

@@ -7,23 +7,29 @@ import { writeFileAtomic } from '../shared/io/index.js';
 import { refuseInSelfTest } from '../host/test-guard.js';
 import { errMsg, sleep } from '../core/util/index.js';
 import { RepoGuardStore } from '../host/guard/index.js';
-import { isSandboxRunning, spawnDetached } from '../host/sandbox/index.js';
+import { isSandboxRunning, realContainedDeps, spawnDetached } from '../host/sandbox/index.js';
 import { readActiveViews, WorkspaceView } from '../host/workspace-view/index.js';
 import { readForwards, sandboxAddress, startPortForwards } from '../host/network/index.js';
 import { AuditCollector, readAuditSettings } from '../host/audit/collect.js';
 import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/guard/index.js';
 import { sizeWithin } from '../core/disk.js';
-import { autoRestartAllowed, causeSince, KeepAwake, LifeRecord, saveCrashReport, SessionLedger, } from '../host/life/index.js';
+import { autoRestartAllowed, causeSince, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
 import { SandboxChannel } from '../host/channel/index.js';
 import { ProjectRegistry } from '../host/projects/registry.js';
-import { storageOf } from '../host/storage/index.js';
+import { ContainedStorage, setNameOf, storageOf } from '../host/storage/index.js';
+import { clearSecrets } from '../host/secrets/index.js';
 import { endSharing, sharingDeps } from '../host/sharing/index.js';
 import { PACKAGE_ROOT } from '../core/package-info.js';
 import { syncBack } from './sync-cycle.js';
+import os from 'node:os';
 const WATCH_INTERVAL_MS = 60 * 1000;
 /** The first sync waits this long: the sandbox is still booting. */
 const FIRST_SYNC_MS = 30000;
 const AUDIT_FLUSH_MS = 10000;
+/** How often this PC's memory and CPU are sampled (the sample runs asynchronously: it never holds anything up). */
+const WATCHDOG_MS = 10000;
+/** The host memory log gets a line this often, and at every sample while the PC is low. */
+const HOST_LOG_EVERY_MS = 60000;
 /** After the sandbox closed: a moment for its last writes to land before the final sync. */
 const SETTLE_MS = 3000;
 /** The longest the watcher may take after the sandbox closed (final syncs) before it stops anyway. */
@@ -78,6 +84,11 @@ export class Watcher {
     awake = null;
     views = [];
     stops = [];
+    watchdogTimer = null;
+    watchdog = WATCHDOG_START;
+    watchdogBusy = false;
+    lastCpu = os.cpus();
+    lastHostLog = 0;
     constructor(dataPath, resume = { restartAfterCrash: false }) {
         this.dataPath = dataPath;
         this.resume = resume;
@@ -94,6 +105,7 @@ export class Watcher {
         fs.mkdirSync(path.dirname(watcherLog(this.dataPath)), { recursive: true });
         writeFileAtomic(watcherPidFile(this.dataPath), String(process.pid));
         this.start();
+        this.holdContained();
         try {
             await sleep(FIRST_SYNC_MS);
             while (isSandboxRunning()) {
@@ -115,10 +127,44 @@ export class Watcher {
         }
         finally {
             this.stop();
+            await this.releaseContained();
         }
         // After stop(): its pid file is gone, so the sandbox started again gets a watcher of its own.
         this.restartAfterCrash();
     }
+    /** Contained storage of this data set (only when a mounted image is on record), else null. */
+    contained() {
+        try {
+            const storage = new ContainedStorage(realContainedDeps(this.storageRoot, 64), setNameOf(this.dataPath));
+            return storage.isRecorded() ? storage : null;
+        }
+        catch {
+            // Not a name contained storage can use: there is none.
+            return null;
+        }
+    }
+    /** The mounted image stays mounted until the sandbox is gone: this watcher holds it. */
+    holdContained() {
+        try {
+            this.contained()?.hold({ id: 'watcher', pid: process.pid });
+        }
+        catch (e) {
+            this.note('contained storage: could not record the watcher: ' + errMsg(e));
+        }
+    }
+    /** The sandbox is gone and the last sync done: let go of the image, which dismounts it when nothing else holds it. */
+    async releaseContained() {
+        try {
+            const result = await this.contained()?.release('watcher');
+            if (result)
+                this.note(result.dismounted
+                    ? 'contained storage dismounted'
+                    : 'contained storage stays mounted: ' + (result.note ?? ''));
+        }
+        catch (e) {
+            this.note('contained storage: ' + errMsg(e));
+        }
+    }
     note(message) {
         try {
             fs.appendFileSync(watcherLog(this.dataPath), new Date().toISOString() + ' ' + message + '\n');
@@ -161,9 +207,51 @@ export class Watcher {
             }
         });
         this.stops = [...viewStops, stopForwards, stopMarking];
+        // Memory and CPU of this PC: when low, the sandbox is asked to slow its builds down (host/life/watchdog.ts).
+        this.watchdogTimer = setInterval(() => void this.watchHost(), WATCHDOG_MS);
+        this.watchdogTimer.unref();
         // sandbox.keepAwake, and the life record that tells the next launch how this run ended (host/life).
         this.awake = this.life.read()?.keepAwake ? KeepAwake.start(process.pid, storageRoot) : null;
     }
+    /** One watchdog sample: this PC's memory and CPU; asks the sandbox to slow down while the PC is low. Never throws. */
+    async watchHost() {
+        if (this.watchdogBusy)
+            return;
+        this.watchdogBusy = true;
+        try {
+            const settings = readLoadSettings(this.storageRoot, this.dataPath);
+            const memory = await readHostMemoryAsync(this.storageRoot);
+            const cpus = os.cpus();
+            const cpuPercent = cpuPercentBetween(this.lastCpu, cpus);
+            this.lastCpu = cpus;
+            const nowMs = Date.now();
+            const step = watchdogStep(this.watchdog, {
+                memory,
+                cpuPercent,
+                intervalSeconds: WATCHDOG_MS / 1000,
+                nowMs,
+                reserveHostMb: settings.reserveHostMb,
+                profile: settings.profile,
+            });
+            this.watchdog = step.state;
+            if (memory && (step.state.low || nowMs - this.lastHostLog >= HOST_LOG_EVERY_MS)) {
+                this.lastHostLog = nowMs;
+                appendHostMemory(path.join(this.storageRoot, 'logs', 'host-memory-' + path.basename(this.dataPath) + '.log'), memory, cpuPercent);
+            }
+            if (step.changed)
+                this.note(step.state.low
+                    ? 'this PC is low (' + step.reason + '): asking the sandbox to slow its builds down'
+                    : 'this PC has recovered: no longer asking the sandbox to slow down');
+            if (step.send)
+                new SandboxChannel(this.dataPath).pressure(step.reason, REQUEST_SECONDS);
+        }
+        catch (e) {
+            this.note('host watchdog: ' + errMsg(e));
+        }
+        finally {
+            this.watchdogBusy = false;
+        }
+    }
     /** The repo guard, then history and (at the end) claude-mem back to this PC. */
     sync(final) {
         try {
@@ -234,6 +322,8 @@ export class Watcher {
     /** Stops what start() started, syncs the filtered workspaces a last time and records the data folder's size. */
     stop() {
         this.awake?.stop();
+        if (this.watchdogTimer)
+            clearInterval(this.watchdogTimer);
         this.stops.forEach((stop) => stop());
         if (this.auditTimer)
             clearInterval(this.auditTimer);
@@ -261,6 +351,15 @@ export class Watcher {
         catch {
             /* best effort */
         }
+        // One-shot secrets the sandbox never read (it stopped early) and any login copy left in a launch folder.
+        try {
+            // Not when a new sandbox already started: its own files are there.
+            if (!isSandboxRunning())
+                clearSecrets(this.storageRoot, this.dataPath);
+        }
+        catch (e) {
+            this.note('could not remove the one-shot secrets: ' + errMsg(e));
+        }
         // An all-users install: the record of whose sandbox this was goes, and the group loses access to the folders.
         const sharing = sharingDeps(PACKAGE_ROOT);
         if (sharing)

package/dist/web/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Sandbox</title>
+    <link rel="icon" href="data:," />
+    <link rel="stylesheet" href="/main-T5DMCHYV.css" />
+    <script type="module" src="/main-NRRS5O6Z.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>