newmark-agent 0.3.8 → 0.3.11

package/dist/core/electronUtilityAgentClient.js

@@ -473,6 +473,70 @@ async function snapshotWindowsProcessTree(rootPid, timeoutMs = WINDOWS_TREE_SNAP
 function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, Math.max(0, ms)));
 }
+function processRootIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A graceful utility shutdown can make Electron's UtilityProcess.kill() return
+ * false before the child exit event is delivered.  On Windows the captured
+ * root creation identity lets us prove that the root and every owned
+ * descendant are gone without falling back to an unscoped PID kill.
+ */
+async function confirmWindowsUtilityProcessTreeStopped(pid, expectedRootCreationIdentity, options, ownerKey) {
+    if (process.platform !== 'win32' || !Number.isInteger(pid) || pid <= 0 || !/^\d+$/.test(expectedRootCreationIdentity))
+        return false;
+    const snapshotter = options.snapshot || snapshotWindowsProcessTree;
+    const deadline = Date.now() + Math.min(WINDOWS_TREE_FORCE_STOP_DEADLINE_MS, Math.max(1, Math.floor(options.forceStopDeadlineMs ?? WINDOWS_TREE_FORCE_STOP_DEADLINE_MS)));
+    const maxRescans = Math.max(2, Math.floor(options.maxRescans ?? WINDOWS_TREE_MAX_RESCANS));
+    const stableRequired = Math.max(2, Math.min(maxRescans, Math.floor(options.stableEmptyRescans ?? WINDOWS_TREE_STABLE_EMPTY_RESCANS)));
+    const syntheticRoot = {
+        pid,
+        parentPid: 0,
+        depth: 0,
+        creationIdentity: expectedRootCreationIdentity,
+    };
+    let stableEmpty = 0;
+    for (let scan = 0; scan < maxRescans; scan++) {
+        try {
+            if (scan > 0)
+                await withinWindowsTreeDeadline(delay(options.rescanDelayMs ?? WINDOWS_TREE_RESCAN_DELAY_MS), deadline, 'graceful-stop rescan delay');
+            const snapshot = await withinWindowsTreeDeadline(snapshotter(pid, remainingWindowsTreeBudget(deadline, options.rescanTimeoutMs ?? WINDOWS_TREE_RESCAN_TIMEOUT_MS, 'graceful-stop rescan', !options.snapshot), [pid], ownerKey), deadline, 'graceful-stop rescan');
+            const root = snapshot.entries.find(entry => entry.pid === pid);
+            if (root && root.creationIdentity !== expectedRootCreationIdentity)
+                return false;
+            if (!snapshot.entries.length) {
+                stableEmpty += 1;
+                if (stableEmpty >= stableRequired)
+                    return true;
+                continue;
+            }
+            // The root may have exited while a child was still observable through
+            // its parent PID. Add only the already-captured root identity so the
+            // normal identity/quiescence gate can safely terminate the survivor.
+            const captured = root
+                ? snapshot
+                : { rootPid: pid, entries: [syntheticRoot, ...snapshot.entries] };
+            await terminateCapturedWindowsProcessTree(captured, {
+                ...options,
+                helperOwnerKey: ownerKey,
+                forceStopDeadlineMs: Math.max(1, deadline - Date.now()),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
 function remainingWindowsTreeBudget(deadline, capMs, label, reserveHelperClose = false) {
     const remaining = deadline - Date.now() - (reserveHelperClose ? WINDOWS_HELPER_CLOSE_GRACE_MS + 75 : 0);
     if (remaining < 100)
@@ -1014,6 +1078,20 @@ class ElectronUtilityAgentClient {
             if (exited && this.child === child)
                 this.detachChild(child, new Error('Electron utility runtime stopped'));
             else if (!exited) {
+                const rootIdentity = this.childRootIdentity;
+                if (!this.restartQuarantine
+                    && rootIdentity
+                    && rootIdentity.generation === this.childGeneration
+                    && rootIdentity.pid === Number(child.pid || 0)
+                    && rootIdentity.creationIdentity) {
+                    const helperOwnerKey = this.windowsHelperOwnerKey(rootIdentity.generation);
+                    const quiescent = await confirmWindowsUtilityProcessTreeStopped(rootIdentity.pid, rootIdentity.creationIdentity, { ...this.options.windowsProcessTree, helperOwnerKey }, helperOwnerKey);
+                    if (quiescent) {
+                        if (this.child === child)
+                            this.detachChild(child, new Error('Electron utility runtime stopped'));
+                        return;
+                    }
+                }
                 this.enterRestartQuarantine(failure);
                 // Retain the UtilityProcess object and surface the failure.  The pool
                 // must not evict the only identity-safe handle to a still-live child.
@@ -1071,8 +1149,12 @@ class ElectronUtilityAgentClient {
             // killing through it is identity-safe even when PID-tree discovery is
             // uncertain. Descendants remain unknown, hence quarantine is still
             // permanent and replacement remains forbidden.
-            const exited = await this.killChildHandleAndAwaitExit(child, 1_000);
-            if (exited && this.child === child)
+            const rootAlreadyGone = process.platform === 'win32' && !processRootIsAlive(pid);
+            const exited = await this.killChildHandleAndAwaitExit(child, 5_000);
+            // The root handle can outlive the OS process after a tree proof fails.
+            // Detach that dead root handle, but keep the sticky quarantine because
+            // the failed tree proof still leaves descendant ownership unknown.
+            if ((exited || rootAlreadyGone) && this.child === child)
                 this.detachChild(child, failure);
             throw failure;
         }

package/dist/core/electronUtilityRuntimePool.js

@@ -247,7 +247,7 @@ class ElectronUtilityRuntimePool {
         }
     }
     async toggleGoalPause(target) {
-        const entry = await this.acquireExisting((0, conversationTarget_1.normalizeConversationTarget)(target));
+        const entry = await this.acquire((0, conversationTarget_1.normalizeConversationTarget)(target));
         if (!entry?.client.toggleGoalPause)
             return null;
         try {
@@ -630,12 +630,11 @@ class ElectronUtilityRuntimePool {
                 }
                 const finalized = !!kernelForce && kernelForce.action === 'force';
                 const checkpointed = finalized ? (kernelForce.checkpointed || intent.checkpointed) : intent.checkpointed;
-                if (!finalized) {
-                    // The worker event loop is wedged: hard-kill the process tree without
-                    // starting a replacement. The first-stop checkpoint preserves the
-                    // conversation; only the latest run is discarded.
-                    await entry.client.forceStop();
-                }
+                // The acknowledgement only gives the kernel a chance to persist its
+                // force_interrupted settlement. A second Stop still owns a process-level
+                // termination boundary and must leave the target runtime down until the
+                // next prompt, even when the worker acknowledged the force request.
+                await entry.client.forceStop();
                 entry.lastSnapshot = null;
                 entry.workEvents = [];
                 entry.lastRunId = '';

package/dist/core/runtimeLifecycle.d.ts

@@ -0,0 +1,23 @@
+export type RuntimeLifecycleRole = 'main' | 'utility' | 'wsl';
+export interface RuntimeLifecycleState {
+    role: RuntimeLifecycleRole;
+    ownerId: string;
+    pid: number;
+    startedAt: string;
+    previousOwnerAlive: boolean;
+    unexpectedExit: boolean;
+    active: true;
+}
+export declare function isRuntimeProcessAlive(pid: number): boolean;
+/**
+ * Claim this process/role as the current runtime owner.
+ *
+ * A frontend cold runner in the same process gets the same in-memory claim and
+ * therefore does not look like a restart. A genuinely new process sees the
+ * previous active claim and can pause orphaned Goal/Flow state once.
+ */
+export declare function beginRuntimeLifecycle(root: string, role?: RuntimeLifecycleRole): RuntimeLifecycleState;
+/** Mark only this owner clean; a hard kill leaves the active marker intact. */
+export declare function markRuntimeLifecycleClean(root: string, role?: RuntimeLifecycleRole): void;
+export declare function runtimeLifecycleState(root: string, role?: RuntimeLifecycleRole): RuntimeLifecycleState | null;
+//# sourceMappingURL=runtimeLifecycle.d.ts.map

package/dist/core/runtimeLifecycle.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeProcessAlive = isRuntimeProcessAlive;
+exports.beginRuntimeLifecycle = beginRuntimeLifecycle;
+exports.markRuntimeLifecycleClean = markRuntimeLifecycleClean;
+exports.runtimeLifecycleState = runtimeLifecycleState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const processStates = new Map();
+function stateKey(root, role) {
+    return `${path.resolve(root)}\u0000${role}`;
+}
+function statePath(root, role, ownerId = '') {
+    return path.join(root, '.newmark-runtime', ownerId ? `lifecycle-${role}-${ownerId}.json` : `lifecycle-${role}.json`);
+}
+function readState(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRuntimeProcessAlive(pid) {
+    const candidate = Math.floor(Number(pid) || 0);
+    if (candidate <= 0)
+        return false;
+    try {
+        process.kill(candidate, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function writeState(root, role, state) {
+    const ownerId = typeof state.ownerId === 'string' ? state.ownerId : '';
+    const file = statePath(root, role, ownerId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${(0, crypto_1.randomUUID)()}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(state, null, 2), 'utf-8');
+    fs.renameSync(temporary, file);
+}
+function readActiveStates(root, role) {
+    const directory = path.join(root, '.newmark-runtime');
+    try {
+        const prefix = `lifecycle-${role}`;
+        return fs.readdirSync(directory)
+            .filter(file => file.startsWith(prefix) && file.endsWith('.json'))
+            .map(file => readState(path.join(directory, file)))
+            .filter((state) => !!state && state.active === true);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Claim this process/role as the current runtime owner.
+ *
+ * A frontend cold runner in the same process gets the same in-memory claim and
+ * therefore does not look like a restart. A genuinely new process sees the
+ * previous active claim and can pause orphaned Goal/Flow state once.
+ */
+function beginRuntimeLifecycle(root, role = 'main') {
+    const key = stateKey(root, role);
+    const existingProcessState = processStates.get(key);
+    if (existingProcessState)
+        return existingProcessState;
+    const previousStates = readActiveStates(root, role);
+    const previousOwnerAlive = previousStates.some(previous => isRuntimeProcessAlive(Number(previous.pid)));
+    const state = {
+        role,
+        ownerId: (0, crypto_1.randomUUID)(),
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        previousOwnerAlive,
+        unexpectedExit: previousStates.length > 0 && !previousOwnerAlive,
+        active: true,
+    };
+    try {
+        writeState(root, role, state);
+    }
+    catch {
+        // Recovery remains conservative when the marker cannot be written. The
+        // persisted WorkRun timestamp still protects a live backend cold read.
+    }
+    processStates.set(key, state);
+    return state;
+}
+/** Mark only this owner clean; a hard kill leaves the active marker intact. */
+function markRuntimeLifecycleClean(root, role = 'main') {
+    const key = stateKey(root, role);
+    const current = processStates.get(key);
+    if (!current)
+        return;
+    try {
+        writeState(root, role, {
+            ...current,
+            active: false,
+            cleanExitAt: new Date().toISOString(),
+        });
+    }
+    catch {
+        // Leaving the marker active is safer than claiming a clean exit after a
+        // failed durable write.
+    }
+}
+function runtimeLifecycleState(root, role = 'main') {
+    return processStates.get(stateKey(root, role)) || null;
+}
+//# sourceMappingURL=runtimeLifecycle.js.map

package/dist/core/types.d.ts

@@ -129,6 +129,9 @@ export interface ConversationWorkRun {
     runId: string;
     target: ConversationTarget;
     runtimeKey: string;
+    runtimeOwnerId?: string;
+    runtimeOwnerPid?: number;
+    runtimeLifecycleRole?: 'main' | 'utility' | 'wsl';
     status: ConversationWorkRunStatus;
     startedAt: string;
     endedAt?: string;

package/dist/core/utilityHostToolRouter.d.ts

@@ -2,6 +2,7 @@ import { BrowserControl } from './browserControl';
 import { BrowserUseReceipt, BrowserUseRequest } from './browserUse';
 import { UtilityHostToolRequest } from './utilityAgentProtocol';
 import { runComputerUse } from '../tools/computerUse';
+import { ComputerUseSessionState } from './computerUseSession';
 import { runTerminalTakeover } from '../tools/terminalTakeover';
 export interface UtilityHostToolRouterOptions {
     persistenceRoot: string;
@@ -15,6 +16,12 @@ export interface UtilityHostToolRouterOptions {
 }
 export type RoutedUtilityHostToolHandler = ((request: UtilityHostToolRequest, signal?: AbortSignal) => Promise<unknown>) & {
     cancelTarget(runtimeKey: string): void;
+    computerUseState(runtimeKey: string): ComputerUseSessionState;
+    setComputerUseEnabled(runtimeKey: string, enabled: boolean, ownerLabel?: string): {
+        ok: boolean;
+        state: ComputerUseSessionState;
+        error?: string;
+    };
 };
 /**
  * Routes every desktop-global capability in the Electron main process.

package/dist/core/utilityHostToolRouter.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("fs"));
 const browserUse_1 = require("./browserUse");
 const toolPolicy_1 = require("./toolPolicy");
 const computerUse_1 = require("../tools/computerUse");
+const computerUseSession_1 = require("./computerUseSession");
 const terminalTakeover_1 = require("../tools/terminalTakeover");
 const ROOT_AGENT_ACTOR_ID = '00000000-0000-4000-8000-000000000001';
 const AUTOMATION_TOOLS = new Set([
@@ -54,10 +55,8 @@ const AUTOMATION_TOOLS = new Set([
  * one authoritative owner lock rather than one lock per child process.
  */
 function createUtilityHostToolHandler(options) {
-    let computerUseLease = null;
     const terminalOwners = new Map();
     const ephemeralScreenshots = new Map();
-    const lockTtlMs = 10 * 60 * 1000;
     const handler = async (request, signal) => {
         throwIfAborted(signal);
         validateTargetContext(request);
@@ -73,7 +72,14 @@ function createUtilityHostToolHandler(options) {
         if (request.tool === 'browser_control') {
             if (request.args.action === 'use')
                 throw new Error('Isolated Browser-Use must use the target-bound browser_use host RPC');
-            const result = await (options.runBrowser || browserControl_1.BrowserControl.run.bind(browserControl_1.BrowserControl))(request.args, signal);
+            const result = await (options.runBrowser || browserControl_1.BrowserControl.run.bind(browserControl_1.BrowserControl))({
+                ...request.args,
+                target: {
+                    workspaceId: request.target.workspaceId,
+                    conversationId: request.target.conversationId,
+                    runtimeKey: request.target.runtimeKey,
+                },
+            }, signal);
             throwIfAborted(signal);
             return result;
         }
@@ -124,20 +130,14 @@ function createUtilityHostToolHandler(options) {
         const action = String(args.action || '').trim().toLowerCase();
         const trustedComputerUseContext = request.context;
         const owner = `${request.target.runtimeKey}:${String(request.context.actorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID)}`;
-        const now = Date.now();
-        if (computerUseLease && now - computerUseLease.updatedAt > lockTtlMs)
-            computerUseLease = null;
-        if (action === 'takeover_stop') {
-            if (computerUseLease && computerUseLease.owner !== owner) {
-                return computerUseLockError(action, owner, computerUseLease.owner);
-            }
-        }
-        else if (computerUseLease && computerUseLease.owner !== owner) {
-            return computerUseLockError(action, owner, computerUseLease.owner);
-        }
-        else {
-            computerUseLease = { owner, runtimeKey: request.target.runtimeKey, workspacePath: request.target.workspacePath, updatedAt: now };
-        }
+        const sessionScope = {
+            runtimeKey: request.target.runtimeKey,
+            ownerLabel: owner,
+            workspacePath: request.target.workspacePath,
+        };
+        const lockGuard = computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, sessionScope, args.dry_run === true || args.dryRun === true);
+        if (lockGuard)
+            return lockGuard;
         let retainedScreenshotPath = '';
         try {
             const result = await (options.runComputer || computerUse_1.runComputerUse)({
@@ -214,10 +214,7 @@ function createUtilityHostToolHandler(options) {
                 }
                 catch { }
             }
-            if (action === 'takeover_stop' && (!computerUseLease || computerUseLease.owner === owner))
-                computerUseLease = null;
-            else if (computerUseLease?.owner === owner)
-                computerUseLease.updatedAt = Date.now();
+            computerUseSession_1.defaultComputerUseSessionRegistry.complete(action, sessionScope);
         }
     };
     handler.cancelTarget = (runtimeKey) => {
@@ -238,9 +235,9 @@ function createUtilityHostToolHandler(options) {
                     (0, terminalTakeover_1.stopTerminalTakeoverSession)(session.id, terminalOwner, 'runtime-force-restart');
             }
         }
-        if (computerUseLease?.runtimeKey === runtimeKey) {
-            const lease = computerUseLease;
-            computerUseLease = null;
+        const hadComputerUseLease = computerUseSession_1.defaultComputerUseSessionRegistry.cancelTarget(runtimeKey);
+        if (hadComputerUseLease) {
+            const lease = { workspacePath: options.persistenceRoot, owner: runtimeKey };
             void (options.runComputer || computerUse_1.runComputerUse)({
                 action: 'takeover_stop',
                 workspacePath: lease.workspacePath,
@@ -249,6 +246,10 @@ function createUtilityHostToolHandler(options) {
             }).catch(() => undefined);
         }
     };
+    handler.computerUseState = (runtimeKey) => computerUseSession_1.defaultComputerUseSessionRegistry.state(runtimeKey);
+    handler.setComputerUseEnabled = (runtimeKey, enabled, ownerLabel = `conversation:${runtimeKey}`) => {
+        return computerUseSession_1.defaultComputerUseSessionRegistry.setEnabled({ runtimeKey, ownerLabel, workspacePath: options.persistenceRoot }, enabled);
+    };
     return handler;
 }
 function throwIfAborted(signal) {
@@ -307,13 +308,4 @@ function evaluateUtilityHostToolPolicy(request) {
         args,
     });
 }
-function computerUseLockError(action, requestedOwner, activeOwner) {
-    return JSON.stringify({
-        ok: false,
-        action,
-        error: `Computer Use is already active in ${activeOwner}. Stop it with computer_use takeover_stop or wait before another conversation takes control.`,
-        lock_owner: activeOwner,
-        requested_owner: requestedOwner,
-    }, null, 2);
-}
 //# sourceMappingURL=utilityHostToolRouter.js.map

package/dist/core/wslAgentRuntimePool.js

@@ -262,7 +262,7 @@ class WslAgentRuntimePool {
     }
     async toggleGoalPause(target) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
-        const entry = await this.acquireExisting(normalized);
+        const entry = await this.acquire(normalized);
         if (!entry?.client.toggleGoalPause)
             return null;
         try {
@@ -616,15 +616,14 @@ class WslAgentRuntimePool {
                 }
                 const finalized = !!kernelForce && kernelForce.action === 'force';
                 const checkpointed = finalized ? (kernelForce.checkpointed || intent.checkpointed) : intent.checkpointed;
-                if (!finalized) {
-                    // The worker event loop is wedged: hard-kill the process group without
-                    // starting a replacement. The first-stop checkpoint preserves the
-                    // conversation; only the latest run is discarded.
-                    if (entry.client.forceStopRuntimeGroup)
-                        await entry.client.forceStopRuntimeGroup();
-                    else
-                        await entry.client.forceRestartRuntimeGroup();
-                }
+                // The acknowledgement only gives the kernel a chance to persist its
+                // force_interrupted settlement. A second Stop still owns a process-group
+                // termination boundary and must leave the target runtime down until the
+                // next prompt, even when the worker acknowledged the force request.
+                if (entry.client.forceStopRuntimeGroup)
+                    await entry.client.forceStopRuntimeGroup();
+                else
+                    await entry.client.forceRestartRuntimeGroup();
                 entry.lastSnapshot = null;
                 entry.workEvents = [];
                 entry.lastRunId = '';

package/dist/launcher.js

@@ -43,7 +43,12 @@ const agent_1 = require("./core/agent");
 const flow_1 = require("./core/flow");
 const flow_runner_1 = require("./core/flow-runner");
 const cli_commands_1 = require("./cli-commands");
+const installUpdate_1 = require("./core/installUpdate");
+const cli_help_1 = require("./cli-help");
 const args = process.argv.slice(2);
+const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
+const isVersionArg = !hasCliCommand && args.some(arg => ['--version', '-v'].includes(arg.toLowerCase()));
 const isTui = args.some(arg => arg.toLowerCase() === '--tui');
 const isGui = args.some(arg => arg.toLowerCase() === '--gui');
 const isCli = args.includes('--cli');
@@ -51,7 +56,6 @@ const isServer = args.includes('--server');
 const isEdit = args[0] === 'edit';
 const editFile = isEdit ? args[1] : '';
 const isFlow = args[0] === 'flow';
-const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
 function pathArgValue(values, key) {
     const prefix = `${key}=`;
     const inlineIdx = values.findIndex(a => a.startsWith(prefix));
@@ -169,6 +173,14 @@ function writableRuntimeRoot(candidate) {
 }
 const explicitRoot = pathArgValue(args, '--root');
 const root = explicitRoot ? writableRuntimeRoot(explicitRoot) : userRuntimeRoot();
+if (isHelpArg) {
+    console.log((0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    process.exit(0);
+}
+if (isVersionArg) {
+    console.log((0, installUpdate_1.currentAppVersion)());
+    process.exit(0);
+}
 function firstRunInit(r) {
     fs.mkdirSync(r, { recursive: true });
     migrateLegacyRuntimeRoot(r);