windows-development-sandbox 1.13.2 → 1.15.0

package/dist/host/projects/registry.d.ts

@@ -10,6 +10,7 @@ declare const RegistryEntrySchema: z.ZodObject<{
     guest: z.ZodString;
     primary: z.ZodBoolean;
     mechanism: z.ZodCatch<z.ZodEnum<{
+        hcs: "hcs";
         root: "root";
         launch: "launch";
         boot: "boot";
@@ -30,6 +31,7 @@ declare const RegistrySchema: z.ZodObject<{
         guest: z.ZodString;
         primary: z.ZodBoolean;
         mechanism: z.ZodCatch<z.ZodEnum<{
+            hcs: "hcs";
             root: "root";
             launch: "launch";
             boot: "boot";

package/dist/host/projects/registry.js

@@ -22,7 +22,7 @@ const RegistryEntrySchema = z.object({
     host: AbsolutePathSchema,
     guest: z.string().max(1024),
     primary: z.boolean(),
-    mechanism: z.enum(['launch', 'root', 'boot', 'wsb']).catch('root'),
+    mechanism: z.enum(['launch', 'root', 'boot', 'wsb', 'hcs']).catch('root'),
     registeredAt: z.string().max(64),
 });
 const RegistrySchema = z.object({

package/dist/host/sandbox/contained-deps.d.ts

@@ -1,2 +1,3 @@
 import { type ContainedDeps } from '../storage/index.js';
-export declare function realContainedDeps(storageRoot: string, maxGb: number): ContainedDeps;
+/** `configOverridden`: the command runs with --config (the helper reads only your usual settings: it is not asked). */
+export declare function realContainedDeps(storageRoot: string, maxGb: number, configOverridden?: boolean): ContainedDeps;

package/dist/host/sandbox/contained-deps.js

@@ -1,17 +1,19 @@
-// The real wiring of contained storage on this PC: the permission-prompt scripts, protectPrivateFolder for new
+// The real wiring of contained storage on this PC: the storage helper when an all-users install added it, else the
+// permission-prompt scripts, protectPrivateFolder for new
 // folders, your SID, and whether a sandbox runs. Lives here (not in host/storage) so storage never imports the
 // sandbox or sharing folders, which import storage. The self-test never reaches a disk through it: the disk port
 // refuses there.
-import { ScriptDiskPort } from '../storage/index.js';
+import { HelperDiskPort, helperApplies, ScriptDiskPort } from '../storage/index.js';
 import { currentUserSid, protectPrivateFolder } from '../sharing/index.js';
 import { isSandboxRunning } from './platform.js';
-export function realContainedDeps(storageRoot, maxGb) {
+/** `configOverridden`: the command runs with --config (the helper reads only your usual settings: it is not asked). */
+export function realContainedDeps(storageRoot, maxGb, configOverridden = false) {
     return {
         storageRoot,
         maxGb,
         protect: (dir) => protectPrivateFolder(dir),
         userSid: currentUserSid,
-        port: new ScriptDiskPort(),
+        port: new HelperDiskPort(new ScriptDiskPort(), helperApplies(process.env, configOverridden)),
         sandboxRunning: isSandboxRunning,
     };
 }

package/dist/host/secrets/launch-secrets.js

@@ -13,7 +13,8 @@ export function writeSecrets(dataPath, id, secrets) {
         !secrets.claudeCredentials &&
         !secrets.vpn &&
         !secrets.wireguardConfig &&
-        !secrets.githubToken;
+        !secrets.githubToken &&
+        !secrets.liveFoldersKey;
     if (empty)
         return null;
     const run = new RunDir(dataPath);

package/dist/host/sharing/lifecycle.js

@@ -43,7 +43,15 @@ export function beginSharing(deps, start, now = new Date()) {
     // The owner creates the run folder and every channel folder in it before others may write there: a folder another
     // user created would stay theirs, and writable by them, after sharing is turned off.
     const run = new RunDir(start.dataPath);
-    for (const dir of [run.root, run.requestsDir, run.responsesDir, run.sessionsDir, run.projectsDir, run.auditDir])
+    for (const dir of [
+        run.root,
+        run.requestsDir,
+        run.responsesDir,
+        run.sessionsDir,
+        run.projectsDir,
+        run.auditDir,
+        run.treesDir,
+    ])
         fs.mkdirSync(dir, { recursive: true });
     const plan = sharingAclPlan({
         storageUserDir: storageOf(start.dataPath),

package/dist/host/storage/contained/contained-storage.js

@@ -76,6 +76,19 @@ export class ContainedStorage {
             });
             this.requireOk(outcome, 'mount');
         }
+        else {
+            // Another holder vouches for the mount, but the folder could be a mount point of some other disk (one left after
+            // a restart, whose volume name an image of someone else's now has). A port that can check it without a prompt
+            // (the storage helper) is asked: it only says "mounted already" for a mount of this very image.
+            const confirmed = await this.deps.port.confirmMounted?.({
+                paths,
+                maxGb: this.deps.maxGb,
+                create: false,
+                userSid: this.deps.userSid(),
+            });
+            if (confirmed)
+                this.requireOk(confirmed, 'mount');
+        }
         this.assertReallyMounted();
         for (const name of CONTAINED_FOLDERS)
             fs.mkdirSync(path.join(paths.mount, name), { recursive: true });

package/dist/host/storage/contained/disk-port.d.ts

@@ -22,6 +22,11 @@ export interface DismountRequest {
 }
 export interface DiskPort {
     mount(request: MountRequest): Promise<ScriptOutcome>;
+    /**
+     * A mount that should be there already, checked without a permission prompt: the outcome of a mount (which, for a
+     * mount of this image, changes nothing), or null when this port cannot check without a prompt.
+     */
+    confirmMounted?(request: MountRequest): Promise<ScriptOutcome | null>;
     dismount(request: DismountRequest): Promise<ScriptOutcome>;
     reality(paths: ContainedPaths): Promise<MountReality>;
 }

package/dist/host/storage/contained/helper-port.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import type { ContainedPaths } from './layout.js';
+import type { DiskPort, DismountRequest, MountRequest, ScriptOutcome } from './disk-port.js';
+import type { MountReality } from './state.js';
+export declare const HELPER_PIPE = "\\\\.\\pipe\\AgentSandboxStorage";
+export declare const HELPER_PROTOCOL = 1;
+/** What goes to the service: exactly the verb and the data set (the service refuses anything else). */
+export declare const HelperRequestSchema: z.ZodObject<{
+    verb: z.ZodEnum<{
+        mount: "mount";
+        dismount: "dismount";
+    }>;
+    set: z.ZodString;
+}, z.core.$strict>;
+export type HelperRequest = z.infer<typeof HelperRequestSchema>;
+/** The service's answer (Protocol.Answer in Protocol.cs). */
+export declare const HelperAnswerSchema: z.ZodObject<{
+    protocol: z.ZodNumber;
+    ok: z.ZodBoolean;
+    message: z.ZodString;
+    created: z.ZodBoolean;
+    alreadyMounted: z.ZodBoolean;
+    fallback: z.ZodBoolean;
+    image: z.ZodString;
+    mount: z.ZodString;
+    notes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type HelperAnswer = z.infer<typeof HelperAnswerSchema>;
+/** One call: the text of the answer, or why there was none. `absent`: no helper here (or not for you). */
+export type PipeResult = {
+    readonly kind: 'answer';
+    readonly text: string;
+} | {
+    readonly kind: 'absent';
+    readonly reason: string;
+} | {
+    readonly kind: 'failed';
+    readonly reason: string;
+};
+export type PipeConnector = (pipe: string, line: string, timeoutMs: number) => Promise<PipeResult>;
+export declare const pipeConnector: PipeConnector;
+/**
+ * Whether the helper may be asked at all. It reads your settings from the usual place (your profile's
+ * .agent-sandbox\config.json and the machine file), so a run with other settings (--config, AGENT_SANDBOX_CONFIG,
+ * AGENT_SANDBOX_HOME) would get other folders: those use the permission prompt.
+ */
+export declare function helperApplies(env: NodeJS.ProcessEnv, configOverridden: boolean): boolean;
+/** The answer's paths are ours (Windows paths: case does not matter, a trailing backslash neither). */
+export declare function samePaths(answer: Pick<HelperAnswer, 'image' | 'mount'>, paths: ContainedPaths): boolean;
+/** What one answer means: an outcome, or "use the permission prompt instead". */
+export declare function readAnswer(result: PipeResult, paths: ContainedPaths): {
+    readonly use: 'outcome';
+    readonly outcome: ScriptOutcome;
+} | {
+    readonly use: 'fallback';
+    readonly why: string;
+};
+/** The helper when it is there and applies, else (and whenever it says so) the permission-prompt scripts. */
+export declare class HelperDiskPort implements DiskPort {
+    private readonly fallback;
+    private readonly applies;
+    private readonly connect;
+    private readonly pipe;
+    constructor(fallback: DiskPort, applies: boolean, connect?: PipeConnector, pipe?: string);
+    mount(request: MountRequest): Promise<ScriptOutcome>;
+    /** The helper checks a mount without a prompt (it is "mounted already" only for this image); null without it. */
+    confirmMounted(request: MountRequest): Promise<ScriptOutcome | null>;
+    dismount(request: DismountRequest): Promise<ScriptOutcome>;
+    reality(paths: ContainedPaths): Promise<MountReality>;
+    /** The helper's outcome, or null to use the permission prompt. */
+    private ask;
+}

package/dist/host/storage/contained/helper-port.js

@@ -0,0 +1,162 @@
+// The storage helper (native\csharp\StorageHelper, the Windows service AgentSandboxStorage that an all-users install
+// can add): mounting and dismounting go to its pipe instead of a Windows permission prompt. The request names only the
+// data set; the service works out the folders itself from your settings, so the answer's paths must equal ours. When
+// the helper is not installed, cannot be reached, or says to (an image it leaves alone), the permission-prompt scripts
+// run as before. Looking (reality) never needs either.
+import net from 'node:net';
+import { z } from 'zod';
+import { SET_NAME_RULE } from './layout.js';
+import { refuseInSelfTest } from '../../test-guard.js';
+export const HELPER_PIPE = '\\\\.\\pipe\\AgentSandboxStorage';
+export const HELPER_PROTOCOL = 1;
+const MOUNT_TIMEOUT_MS = 10 * 60_000;
+const MAX_ANSWER_BYTES = 64 * 1024;
+/** What goes to the service: exactly the verb and the data set (the service refuses anything else). */
+export const HelperRequestSchema = z
+    .object({ verb: z.enum(['mount', 'dismount']), set: z.string().regex(SET_NAME_RULE) })
+    .strict();
+/** The service's answer (Protocol.Answer in Protocol.cs). */
+export const HelperAnswerSchema = z.object({
+    protocol: z.number().int(),
+    ok: z.boolean(),
+    message: z.string().max(4000),
+    created: z.boolean(),
+    alreadyMounted: z.boolean(),
+    fallback: z.boolean(),
+    image: z.string().max(1000),
+    mount: z.string().max(1000),
+    notes: z.array(z.string().max(1000)).max(50),
+});
+/** Errors that mean "no helper to talk to": not installed (or stopped), or this user may not open it. */
+const ABSENT_CODES = new Set(['ENOENT', 'EACCES', 'EPERM', 'ECONNREFUSED']);
+export const pipeConnector = (pipe, line, timeoutMs) => new Promise((resolve) => {
+    let text = '';
+    let connected = false;
+    let settled = false;
+    const done = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(result);
+    };
+    const socket = net.connect(pipe);
+    const timer = setTimeout(() => done({ kind: 'failed', reason: 'the storage helper did not answer in time' }), timeoutMs);
+    socket.setEncoding('utf8');
+    socket.on('connect', () => {
+        connected = true;
+        socket.write(line + '\n');
+    });
+    socket.on('data', (chunk) => {
+        text += chunk;
+        const end = text.indexOf('\n');
+        if (end >= 0)
+            done({ kind: 'answer', text: text.slice(0, end) });
+        else if (text.length > MAX_ANSWER_BYTES)
+            done({ kind: 'failed', reason: 'the storage helper answered too much' });
+    });
+    socket.on('error', (e) => {
+        if (!connected && ABSENT_CODES.has(e.code ?? ''))
+            done({ kind: 'absent', reason: e.code ?? 'no pipe' });
+        else
+            done({ kind: 'failed', reason: e.message });
+    });
+    socket.on('close', () => done({ kind: 'failed', reason: 'the storage helper closed the connection' }));
+});
+/**
+ * Whether the helper may be asked at all. It reads your settings from the usual place (your profile's
+ * .agent-sandbox\config.json and the machine file), so a run with other settings (--config, AGENT_SANDBOX_CONFIG,
+ * AGENT_SANDBOX_HOME) would get other folders: those use the permission prompt.
+ */
+export function helperApplies(env, configOverridden) {
+    if (configOverridden)
+        return false;
+    return !env.AGENT_SANDBOX_CONFIG && !env.AGENT_SANDBOX_HOME;
+}
+/** The answer's paths are ours (Windows paths: case does not matter, a trailing backslash neither). */
+export function samePaths(answer, paths) {
+    const norm = (p) => p.replace(/\\+$/, '').toLowerCase();
+    return norm(answer.image) === norm(paths.image) && norm(answer.mount) === norm(paths.mount);
+}
+/** What one answer means: an outcome, or "use the permission prompt instead". */
+export function readAnswer(result, paths) {
+    if (result.kind === 'absent')
+        return { use: 'fallback', why: 'no storage helper (' + result.reason + ')' };
+    if (result.kind === 'failed')
+        return { use: 'outcome', outcome: failed('The storage helper did not finish: ' + result.reason + '.') };
+    let raw;
+    try {
+        raw = JSON.parse(result.text);
+    }
+    catch {
+        return { use: 'fallback', why: 'the storage helper gave an answer that is not JSON' };
+    }
+    const parsed = HelperAnswerSchema.safeParse(raw);
+    if (!parsed.success || parsed.data.protocol !== HELPER_PROTOCOL)
+        return { use: 'fallback', why: 'the storage helper speaks another version' };
+    const answer = parsed.data;
+    if (answer.fallback)
+        return { use: 'fallback', why: answer.message };
+    if (answer.ok && !samePaths(answer, paths))
+        return {
+            use: 'outcome',
+            outcome: failed('The storage helper used other folders (' +
+                answer.mount +
+                ') than this command (' +
+                paths.mount +
+                '): your settings differ from what it reads. Run sandbox doctor.'),
+        };
+    return {
+        use: 'outcome',
+        outcome: {
+            ok: answer.ok,
+            message: answer.message,
+            created: answer.created,
+            alreadyMounted: answer.alreadyMounted,
+            notes: answer.notes,
+        },
+    };
+}
+function failed(message) {
+    return { ok: false, message, created: false, alreadyMounted: false, notes: [] };
+}
+/** The helper when it is there and applies, else (and whenever it says so) the permission-prompt scripts. */
+export class HelperDiskPort {
+    fallback;
+    applies;
+    connect;
+    pipe;
+    constructor(fallback, applies, connect = pipeConnector, pipe = HELPER_PIPE) {
+        this.fallback = fallback;
+        this.applies = applies;
+        this.connect = connect;
+        this.pipe = pipe;
+    }
+    async mount(request) {
+        const answer = await this.ask({ verb: 'mount', set: request.paths.set }, request.paths);
+        return answer ?? this.fallback.mount(request);
+    }
+    /** The helper checks a mount without a prompt (it is "mounted already" only for this image); null without it. */
+    confirmMounted(request) {
+        return this.ask({ verb: 'mount', set: request.paths.set }, request.paths);
+    }
+    async dismount(request) {
+        const answer = await this.ask({ verb: 'dismount', set: request.paths.set }, request.paths);
+        return answer ?? this.fallback.dismount(request);
+    }
+    reality(paths) {
+        return this.fallback.reality(paths);
+    }
+    /** The helper's outcome, or null to use the permission prompt. */
+    async ask(request, paths) {
+        if (!this.applies)
+            return null;
+        // A test talks to a helper of its own (another pipe name); the real one could mount a real disk.
+        if (this.pipe === HELPER_PIPE)
+            refuseInSelfTest('mount or dismount a disk image');
+        const line = JSON.stringify(HelperRequestSchema.parse(request));
+        const read = readAnswer(await this.connect(this.pipe, line, MOUNT_TIMEOUT_MS), paths);
+        return read.use === 'outcome' ? read.outcome : null;
+    }
+}

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

@@ -2,6 +2,7 @@ export { CONTAINED_FOLDERS, containedMappings, containedPaths, setNameOf, type C
 export type { ContainedPaths } from './layout.js';
 export { ContainedStorage, type ContainedDeps, type HolderId, type ReleaseResult } from './contained-storage.js';
 export { ScriptDiskPort, spawnRunner, type DiskPort, type MountRequest, type ScriptOutcome } from './disk-port.js';
+export { HELPER_PIPE, HelperAnswerSchema, HelperDiskPort, helperApplies, HelperRequestSchema, pipeConnector, readAnswer, samePaths, type PipeConnector, type PipeResult, } from './helper-port.js';
 export { containedAvailability, containedFacts, type ContainedFacts } from './check.js';
 export { hostDataFolder, hostDataRoot } from './resolve.js';
 export { writeContainedSetting } from './setting.js';

package/dist/host/storage/contained/index.js

@@ -1,6 +1,7 @@
 export { CONTAINED_FOLDERS, containedMappings, containedPaths, setNameOf } from './layout.js';
 export { ContainedStorage } from './contained-storage.js';
 export { ScriptDiskPort, spawnRunner } from './disk-port.js';
+export { HELPER_PIPE, HelperAnswerSchema, HelperDiskPort, helperApplies, HelperRequestSchema, pipeConnector, readAnswer, samePaths, } from './helper-port.js';
 export { containedAvailability, containedFacts } from './check.js';
 export { hostDataFolder, hostDataRoot } from './resolve.js';
 export { writeContainedSetting } from './setting.js';

package/dist/host/web/bridge.d.ts

@@ -23,6 +23,11 @@ export declare class TerminalBridge {
     start(): Promise<void>;
     private fromBrowser;
     private fromSession;
+    /**
+     * The program's mouse tracking ends with it: the browser's terminal stops sending clicks and moves, and a drag
+     * selects text again (an ended terminal stays on screen).
+     */
+    private mouseOff;
     /** Stops reading from the session until the browser has taken what it was sent. */
     private hold;
     private tell;

package/dist/host/web/bridge.js

@@ -1,5 +1,5 @@
 import { safeText } from '../../core/util/index.js';
-import { connect, encodeFrame, FrameReader, FrameType, helloFrame, OutputFilter, PING_INTERVAL_MS, resizeFrame, } from '../../shared/pty/index.js';
+import { connect, encodeFrame, FrameReader, FrameType, helloFrame, MOUSE_OFF, OutputFilter, PING_INTERVAL_MS, resizeFrame, } from '../../shared/pty/index.js';
 import { parseClientMessage } from '../../shared/web/index.js';
 /** The browser is slower than the sandbox: past this much waiting to be sent, output is held back in the socket. */
 const MAX_BUFFERED_BYTES = 4 * 1024 * 1024;
@@ -94,9 +94,11 @@ export class TerminalBridge {
                     break;
                 }
                 case FrameType.Restarting:
+                    this.mouseOff();
                     this.tell({ t: 'restarting' });
                     break;
                 case FrameType.Exit:
+                    this.mouseOff();
                     this.tell({ t: 'exit', code: frame.payload.length >= 4 ? frame.payload.readInt32LE(0) : 1 });
                     this.finish(1000, 'exit');
                     return;
@@ -111,6 +113,14 @@ export class TerminalBridge {
         if (this.ws.bufferedAmount > MAX_BUFFERED_BYTES)
             this.hold();
     }
+    /**
+     * The program's mouse tracking ends with it: the browser's terminal stops sending clicks and moves, and a drag
+     * selects text again (an ended terminal stays on screen).
+     */
+    mouseOff() {
+        if (this.ws.readyState === this.ws.OPEN)
+            this.ws.send(Buffer.from(MOUSE_OFF, 'latin1'), { binary: true });
+    }
     /** Stops reading from the session until the browser has taken what it was sent. */
     hold() {
         if (this.drain || !this.socket)

package/dist/host/web/server.d.ts

@@ -55,6 +55,7 @@ export declare class WebServer {
     private readonly live;
     private actualPort;
     private lastUsed;
+    private lastCheck;
     private heartbeat;
     private idleCheck;
     constructor(options: WebServerOptions);
@@ -69,6 +70,7 @@ export declare class WebServer {
     private beat;
     /** No browser has used the server for a while: it ends (sooner when no sandbox runs). */
     private checkIdle;
+    private checkEveryMs;
     /** How long unused before it ends when no sandbox runs. */
     private quietMs;
     /** Counts a new socket; at the limit, the oldest of its kind makes room (a new tab always works). */

package/dist/host/web/server.js

@@ -55,6 +55,7 @@ export class WebServer {
     live;
     actualPort = 0;
     lastUsed = Date.now();
+    lastCheck = Date.now();
     heartbeat;
     idleCheck;
     constructor(options) {
@@ -82,7 +83,8 @@ export class WebServer {
                 this.heartbeat = setInterval(() => this.beat(), this.options.heartbeatMs ?? HEARTBEAT_MS);
                 this.heartbeat.unref();
                 if (this.options.idleExitMs) {
-                    this.idleCheck = setInterval(() => void this.checkIdle(), Math.min(60_000, this.quietMs()));
+                    this.lastCheck = Date.now();
+                    this.idleCheck = setInterval(() => void this.checkIdle(), this.checkEveryMs());
                     this.idleCheck.unref();
                 }
                 const gate = this.options.gate;
@@ -127,6 +129,11 @@ export class WebServer {
     /** No browser has used the server for a while: it ends (sooner when no sandbox runs). */
     async checkIdle() {
         const limit = this.options.idleExitMs ?? 0;
+        const now = Date.now();
+        // A check much later than planned: the PC slept. Its tabs get time to reconnect before anything counts as idle.
+        if (now - this.lastCheck > 3 * this.checkEveryMs())
+            this.lastUsed = now;
+        this.lastCheck = now;
         if (!limit || this.tracked.size > 0)
             return;
         const idle = Date.now() - this.lastUsed;
@@ -143,6 +150,9 @@ export class WebServer {
         }
         this.options.onStop?.();
     }
+    checkEveryMs() {
+        return Math.min(60_000, this.quietMs());
+    }
     /** How long unused before it ends when no sandbox runs. */
     quietMs() {
         return Math.min(this.options.idleExitMs ?? 0, this.options.idleNoSandboxMs ?? IDLE_NO_SANDBOX_MS);

package/dist/runtime/agent.js

@@ -26645,6 +26645,9 @@ var ProjectsSchema = external_exports.strictObject({
   ),
   wsbShare: external_exports.boolean().describe(
     "On Windows 11 24H2+ with the Windows Sandbox command line (wsb), add other folders to the running sandbox with `wsb share` (untested). Otherwise starting a project outside every root offers a restart."
+  ),
+  liveFolders: external_exports.enum(["off", "hcs"]).describe(
+    'ALPHA, UNTESTED ON A REAL PC: "hcs" adds a project folder to the running sandbox through the Host Compute Service where `wsb share` is missing (one administrator prompt per add or remove; always read-only in this alpha). If it fails, the sandbox may close: save your work first. Turn it on before the sandbox starts. "off" (default) offers a restart instead. The real-PC tests still to pass are in docs/design/hcs-live-folders.md ("Test plan").'
   )
 });
 
@@ -27173,8 +27176,16 @@ var RunDir = class {
   projectsDir;
   /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
   auditDir;
+  /**
+   * Each running session's process tree, recorded by its ptyhost (guest only: the daemon ends what a ptyhost that was
+   * itself ended left running).
+   */
+  treesDir;
   /** One-shot secrets the host hands over (see secrets.ts). Next to run, not in it: shared-use users can change run. */
   secretsDir;
+  /** Live folders (live.ts): signed host requests, and the daemon's replies. */
+  liveDir;
+  liveRepliesDir;
   constructor(dataDir2) {
     this.root = path5.join(dataDir2, "run");
     this.sandboxFile = path5.join(this.root, "sandbox.json");
@@ -27186,7 +27197,16 @@ var RunDir = class {
     this.sessionsDir = path5.join(this.root, "sessions");
     this.projectsDir = path5.join(this.root, "projects");
     this.auditDir = path5.join(this.root, "audit");
+    this.treesDir = path5.join(this.root, "trees");
     this.secretsDir = path5.join(dataDir2, "secrets");
+    this.liveDir = path5.join(this.root, "live");
+    this.liveRepliesDir = path5.join(this.root, "live-replies");
+  }
+  liveFile(id) {
+    return path5.join(this.liveDir, safeId(id) + ".json");
+  }
+  liveReplyFile(id) {
+    return path5.join(this.liveRepliesDir, safeId(id) + ".json");
   }
   requestFile(id) {
     return path5.join(this.requestsDir, safeId(id) + ".json");
@@ -27197,6 +27217,9 @@ var RunDir = class {
   sessionFile(id) {
     return path5.join(this.sessionsDir, safeId(id) + ".json");
   }
+  treeFile(id) {
+    return path5.join(this.treesDir, safeId(id) + ".json");
+  }
   projectFile(name) {
     return path5.join(this.projectsDir, safeId(name) + ".json");
   }