windows-development-sandbox 1.0.5 → 1.1.0

package/dist/sync/history.js

@@ -12,12 +12,25 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
-import { guestWorkspaceAliases, projectFolderName, translatePaths } from '../shared/paths.js';
-import { dirExists, ensureDir, fileExists, isLink, removeLink, tryReadJson, writeJson } from '../core/util.js';
+import { z } from 'zod';
+import { guestWorkspaceAliases, isSafeFileName, projectFolderName, translatePaths } from '../shared/paths.js';
+import { readValid, writeJsonAtomic } from '../shared/rundir.js';
+import { assertTestWritable } from '../host/test-guard.js';
+import { dirExists, ensureDir, fileExists, isLink, removeLink } from '../core/util.js';
 export { projectFolderName, translatePaths };
 const SESSION_DIRS = ['todos', 'plans', 'file-history'];
 const DATA_FILE = /\.(jsonl?|txt|md)$/i;
 const MAX_FILE_BYTES = 100 * 1024 * 1024;
+/** Host-only record of the last launch: which folders map to each other and what syncs (from the effective config). */
+const AbsolutePath = z.string().max(1024).refine((p) => path.isAbsolute(p), 'must be an absolute path');
+const SyncStateSchema = z.object({
+    hostClaudeDir: AbsolutePath, hostWorkspace: AbsolutePath, guestWorkspace: z.string().max(1024),
+    syncHistory: z.boolean().optional(), syncClaudeMem: z.boolean().optional(),
+    /** Newest claude-mem database time on each side right after the last sync (detects edits on both sides). */
+    memHostStamp: z.number().optional(), memGuestStamp: z.number().optional(),
+    /** Projects registered while the sandbox ran (their history goes back to their own folders). */
+    projects: z.array(z.object({ hostWorkspace: AbsolutePath, guestWorkspace: z.string().max(1024) })).max(256).optional(),
+});
 const anyFile = () => true;
 const transcript = (name) => name.endsWith('.jsonl');
 const json = (name) => name.endsWith('.json');
@@ -43,6 +56,8 @@ const copyNewer = (from, to, options = {}) => {
         return 0;
     const accept = options.accept ?? anyFile;
     return _.sumBy(fs.readdirSync(from, { withFileTypes: true }), (entry) => {
+        if (!isSafeFileName(entry.name))
+            return 0;
         const source = path.join(from, entry.name);
         const destination = path.join(to, entry.name);
         if (entry.isDirectory())
@@ -69,23 +84,37 @@ const copyNewer = (from, to, options = {}) => {
     });
 };
 const readLines = (file) => fileExists(file) && !isLink(file) && fs.statSync(file).size <= MAX_FILE_BYTES ? fs.readFileSync(file, 'utf8').split(/\r?\n/).filter((l) => l.trim() !== '') : [];
+const isJsonObject = (line) => { try {
+    const v = JSON.parse(line);
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+catch {
+    return false;
+} };
 const lineTime = (line) => { try {
     return Number(JSON.parse(line).timestamp) || 0;
 }
 catch {
     return 0;
 } };
+/** Every workspace pair of the sandbox: the launch folder's, then the projects registered later (most specific first). */
+const pairsOf = (p) => _.sortBy([{ hostWorkspace: p.hostWorkspace, guestWorkspace: p.guestWorkspace }, ...(p.extra ?? [])], (x) => -x.hostWorkspace.length);
+const translateAll = (text, pairs) => pairs.reduce((out, [from, to]) => translatePaths(out, from, to), text);
 /** Brings this PC's history into the sandbox state (run before the sandbox starts). Returns files copied. */
-export const syncHistoryIn = (p) => {
-    const hostProject = projectFolderName(p.hostWorkspace);
-    const guestProject = projectFolderName(p.guestWorkspace);
-    const transform = (t) => translatePaths(t, p.hostWorkspace, p.guestWorkspace);
+export const syncHistoryIn = (p, options = {}) => {
+    assertTestWritable(p.guestClaudeDir);
+    const pairs = pairsOf(p);
+    const byHost = new Map(pairs.map((x) => [projectFolderName(x.hostWorkspace), projectFolderName(x.guestWorkspace)]));
+    const guestNames = new Set(pairs.map((x) => projectFolderName(x.guestWorkspace)));
+    const transform = (t) => translateAll(t, pairs.map((x) => [x.hostWorkspace, x.guestWorkspace]));
     const hostProjects = path.join(p.hostClaudeDir, 'projects');
-    const names = dirExists(hostProjects) ? fs.readdirSync(hostProjects).filter((name) => name !== guestProject || hostProject === guestProject) : [];
-    const projects = _.sumBy(names, (name) => name === hostProject
-        ? copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', guestProject), { transform })
+    const names = dirExists(hostProjects) ? fs.readdirSync(hostProjects).filter((name) => isSafeFileName(name) && (!guestNames.has(name) || byHost.has(name))) : [];
+    const projects = _.sumBy(names, (name) => byHost.has(name)
+        ? copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', byHost.get(name)), { transform })
         : copyNewer(path.join(hostProjects, name), path.join(p.guestClaudeDir, 'projects', name)));
     const sessions = _.sumBy(SESSION_DIRS, (dir) => copyNewer(path.join(p.hostClaudeDir, dir), path.join(p.guestClaudeDir, dir)));
+    if (options.promptHistory === false)
+        return projects + sessions;
     // Prompt history: rebuild the sandbox copy from this PC's file plus anything only the sandbox has.
     const target = path.join(p.guestClaudeDir, 'history.jsonl');
     const hostLines = readLines(path.join(p.hostClaudeDir, 'history.jsonl')).map(transform);
@@ -99,21 +128,23 @@ export const syncHistoryIn = (p) => {
 };
 /** Copies new sandbox history back to this PC (safe while the sandbox runs: transcripts are append-only). */
 export const syncHistoryOut = (p) => {
-    const hostProject = projectFolderName(p.hostWorkspace);
-    // A mirrored workspace on F: really lives at C:\Mirror\F\...; tools that resolve real paths record that one.
-    const guestNames = guestWorkspaceAliases(p.guestWorkspace);
-    const guestProjects = new Set(guestNames.map(projectFolderName));
-    const transform = (t) => guestNames.reduce((out, guest) => translatePaths(out, guest, p.hostWorkspace), t);
+    assertTestWritable(p.hostClaudeDir);
+    // A mirrored workspace on F: really lives at C:\Mirror\F\...; tools that resolve real paths record that one. A
+    // project registered later is in the hub (C:\Projects\<name>) and goes back to its real folder on this PC.
+    const pairs = pairsOf(p).flatMap((x) => guestWorkspaceAliases(x.guestWorkspace).map((guest) => [guest, x.hostWorkspace]));
+    const byGuest = new Map(pairs.map(([guest, host]) => [projectFolderName(guest), projectFolderName(host)]));
+    const transform = (t) => translateAll(t, pairs);
     const guestProjectsDir = path.join(p.guestClaudeDir, 'projects');
-    const names = dirExists(guestProjectsDir) && !isLink(guestProjectsDir) ? fs.readdirSync(guestProjectsDir) : [];
-    const projects = _.sumBy(names, (name) => guestProjects.has(name)
-        ? copyNewer(path.join(guestProjectsDir, name), path.join(p.hostClaudeDir, 'projects', hostProject), { accept: transcript, skipDirs: NO_MEMORY, transform })
+    const names = dirExists(guestProjectsDir) && !isLink(guestProjectsDir) ? fs.readdirSync(guestProjectsDir).filter(isSafeFileName) : [];
+    const projects = _.sumBy(names, (name) => byGuest.has(name)
+        ? copyNewer(path.join(guestProjectsDir, name), path.join(p.hostClaudeDir, 'projects', byGuest.get(name)), { accept: transcript, skipDirs: NO_MEMORY, transform })
         : copyNewer(path.join(guestProjectsDir, name), path.join(p.hostClaudeDir, 'projects', name), { accept: transcript, skipDirs: NO_MEMORY }));
     // Only to-do lists come back besides transcripts; plans and file backups stay in the sandbox.
     const sessions = copyNewer(path.join(p.guestClaudeDir, 'todos'), path.join(p.hostClaudeDir, 'todos'), { accept: json });
     const hostFile = path.join(p.hostClaudeDir, 'history.jsonl');
     const known = new Set(readLines(hostFile));
-    const missing = readLines(path.join(p.guestClaudeDir, 'history.jsonl')).map(transform).filter((l) => !known.has(l));
+    // Only prompt-history entries (one JSON object per line) come back, whatever else the sandbox wrote in that file.
+    const missing = readLines(path.join(p.guestClaudeDir, 'history.jsonl')).filter(isJsonObject).map(transform).filter((l) => !known.has(l));
     if (missing.length) {
         ensureDir(p.hostClaudeDir);
         fs.appendFileSync(hostFile, missing.join('\n') + '\n', 'utf8');
@@ -125,5 +156,6 @@ export const syncHistoryOut = (p) => {
  * never live in the data folder the sandbox can write (a forged copy could redirect writes anywhere on this PC).
  */
 export const syncStatePath = (dataPath) => path.join(path.dirname(path.dirname(dataPath)), 'sync', path.basename(dataPath) + '.json');
-export const readSyncState = (dataPath) => tryReadJson(syncStatePath(dataPath));
-export const writeSyncState = (dataPath, state) => writeJson(syncStatePath(dataPath), state);
+/** A state file that is missing, oversized or not in this shape counts as no state (nothing syncs back until the next launch). */
+export const readSyncState = (dataPath) => readValid(SyncStateSchema, syncStatePath(dataPath));
+export const writeSyncState = (dataPath, state) => writeJsonAtomic(syncStatePath(dataPath), state);

package/dist/sync/watcher.d.ts

@@ -1,5 +1,13 @@
 import type { Config } from '../core/types.js';
 import { type MemResult } from './claude-mem.js';
+/**
+ * A project registered while the sandbox runs: its history comes in now (the sandbox's copy only gains files), and
+ * from now on syncs back to its own folder on this PC.
+ */
+export declare const syncProjectIn: (dataPath: string, project: {
+    hostWorkspace: string;
+    guestWorkspace: string;
+}) => number;
 export interface SyncSummary {
     history: number;
     claudeMem: MemResult | 'disabled';

package/dist/sync/watcher.js

@@ -3,6 +3,8 @@
 // Its pid file and log live in host-only storage, never in the data folder the sandbox can write.
 import fs from 'node:fs';
 import path from 'node:path';
+import { writeFileAtomic } from '../shared/rundir.js';
+import { refuseInSelfTest } from '../host/test-guard.js';
 import { assertNoLinks, errMsg, sleep } from '../core/util.js';
 import { hostClaudeDir } from '../host/claude-profile.js';
 import { checkRepo } from '../host/repo-guard.js';
@@ -16,7 +18,21 @@ const guestMem = (dataPath) => path.join(dataPath, 'state', 'claude-mem');
 /** Sync paths for the sandbox side, after checking nothing on the way there is a link planted by the sandbox. */
 const toPaths = (state, dataPath) => {
     assertNoLinks(dataPath, guestClaude(dataPath));
-    return { hostClaudeDir: state.hostClaudeDir, guestClaudeDir: guestClaude(dataPath), hostWorkspace: state.hostWorkspace, guestWorkspace: state.guestWorkspace };
+    return { hostClaudeDir: state.hostClaudeDir, guestClaudeDir: guestClaude(dataPath), hostWorkspace: state.hostWorkspace, guestWorkspace: state.guestWorkspace, extra: state.projects ?? [] };
+};
+/**
+ * A project registered while the sandbox runs: its history comes in now (the sandbox's copy only gains files), and
+ * from now on syncs back to its own folder on this PC.
+ */
+export const syncProjectIn = (dataPath, project) => {
+    const state = readSyncState(dataPath);
+    if (!state)
+        return 0;
+    const projects = [...(state.projects ?? []).filter((p) => p.hostWorkspace.toLowerCase() !== project.hostWorkspace.toLowerCase()), project];
+    const next = { ...state, projects };
+    writeSyncState(dataPath, next);
+    // Prompt history is left alone: sessions are appending to the sandbox's copy right now.
+    return state.syncHistory ? syncHistoryIn(toPaths(next, dataPath), { promptHistory: false }) : 0;
 };
 const memSync = (dataPath, state, direction) => {
     assertNoLinks(dataPath, guestMem(dataPath));
@@ -31,7 +47,7 @@ export const syncBeforeLaunch = (config, dataPath, hostWorkspace) => {
     const previous = readSyncState(dataPath);
     if (previous?.syncHistory)
         syncHistoryOut(toPaths(previous, dataPath));
-    const state = { ...previous, hostClaudeDir: hostClaudeDir(profile), hostWorkspace, guestWorkspace: config.guestWorkspace, syncHistory: profile.syncHistory, syncClaudeMem: profile.syncClaudeMem };
+    const state = { ...previous, hostClaudeDir: hostClaudeDir(profile), hostWorkspace, guestWorkspace: config.guestWorkspace, syncHistory: profile.syncHistory, syncClaudeMem: profile.syncClaudeMem, projects: [] };
     if (profile.syncHistory)
         summary.history = syncHistoryIn(toPaths(state, dataPath));
     if (profile.syncClaudeMem) {
@@ -58,7 +74,9 @@ export const syncBack = (dataPath, final) => {
 const hostRunDir = (dataPath) => path.join(storageOf(dataPath), 'run');
 const watcherPidFile = (dataPath) => path.join(hostRunDir(dataPath), 'watcher-' + path.basename(dataPath) + '.pid');
 const watcherLog = (dataPath) => path.join(storageOf(dataPath), 'logs', 'host-sync-' + path.basename(dataPath) + '.log');
-const alive = (pid) => { try {
+// Signal 0 only asks whether the process exists. pid 0 would mean "my own process group", so it never counts.
+const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0)
+    return false; try {
     process.kill(pid, 0);
     return true;
 }
@@ -75,11 +93,12 @@ export const watcherRunning = (dataPath) => {
 };
 /** Body of the detached watcher process (`agent-sandbox _watch`). */
 export const watch = async (dataPath) => {
+    refuseInSelfTest('start the background sync');
     if (watcherRunning(dataPath))
         return;
     fs.mkdirSync(hostRunDir(dataPath), { recursive: true });
     fs.mkdirSync(path.dirname(watcherLog(dataPath)), { recursive: true });
-    fs.writeFileSync(watcherPidFile(dataPath), String(process.pid));
+    writeFileAtomic(watcherPidFile(dataPath), String(process.pid));
     const note = (message) => { try {
         fs.appendFileSync(watcherLog(dataPath), new Date().toISOString() + ' ' + message + '\n');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "A disposable Windows Sandbox for development, with or without an AI agent (Claude Code, Codex, Gemini, opencode, ...): the folder you run it from is the workspace, toolchains and databases for your project install themselves, and nothing else on your PC is reachable.",
   "type": "module",
   "license": "MIT",
@@ -37,14 +37,14 @@
     "hooks",
     "config.example.json",
     ".sandbox-config.example.json",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/bundle.mjs && node scripts/schemas.mjs",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "rebuild": "npm run clean && npm run build",
     "test": "npm run build && node dist/bin/agent-sandbox.js self-test",
-    "prepare": "npm run build",
     "prepack": "npm run rebuild",
     "release:patch": "npm version patch && git push --follow-tags",
     "release:minor": "npm version minor && git push --follow-tags",
@@ -84,10 +84,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/JoshDiDuca/agent-sandbox.git"
+    "url": "git+https://github.com/JoshDiDuca/windows-development-sandbox.git"
   },
-  "homepage": "https://github.com/JoshDiDuca/agent-sandbox#readme",
+  "homepage": "https://github.com/JoshDiDuca/windows-development-sandbox#readme",
   "bugs": {
-    "url": "https://github.com/JoshDiDuca/agent-sandbox/issues"
+    "url": "https://github.com/JoshDiDuca/windows-development-sandbox/issues"
   }
 }