@fitlab-ai/agent-infra 0.9.6 → 0.9.8

package/dist/lib/sandbox/recovery.js

@@ -11,13 +11,28 @@ import { sandboxCoreBindMounts } from './mounts.js';
 import { assertSandboxTaskSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
 import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { inspectWorktree } from './worktree-safety.js';
-import { runEngine, runOkEngine, runVerboseEngine } from './shell.js';
+import { commandForEngine, runEngine, runOkEngine, runProbe, runVerboseEngine } from './shell.js';
 import { declaredTmpfsSeedEntries, resolveTools, toolConfigDirCandidates } from './tools.js';
 import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
-import { getProcessStartTime, processIdentityMatches, removePidFileIfMatches } from '../server/process-state.js';
-import { acquireSandboxControlBrokerStartup, isSandboxControlRootQuiescing } from './control/lifecycle.js';
+import { getProcessIdentityState, getProcessStartTime, removePidFileIfMatches } from '../server/process-state.js';
+import { acquireSandboxControlBrokerStartup, garbageCollectSandboxControlRoot, isSandboxControlRootQuiescing, readSandboxControlManifest } from './control/lifecycle.js';
 import { appendSandboxControlAudit, readSandboxControlStatus } from './control/state.js';
+import { inspectSandboxControlContainer } from './control/container-identity.js';
 import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from './control/protocol.js';
+export function worktreeProbeForEngine(engine, probe = runProbe) {
+    return (cmd, args, opts = {}) => {
+        const engineArgs = [...args];
+        if (engine === 'wsl2' && cmd === 'git') {
+            for (let index = 0; index < engineArgs.length - 1; index += 1) {
+                if (engineArgs[index] === '-C') {
+                    engineArgs[index + 1] = toEnginePath(engine, engineArgs[index + 1]);
+                }
+            }
+        }
+        const command = commandForEngine(engine, cmd, engineArgs);
+        return probe(command.cmd, command.args, opts);
+    };
+}
 async function waitForSandboxControlBrokerStatus(params, timeoutMs = 5_000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -42,7 +57,7 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
     const directory = path.dirname(fileURLToPath(import.meta.url));
     const extension = path.extname(fileURLToPath(import.meta.url));
     const internalCli = path.resolve(directory, '..', '..', 'bin', `internal-cli${extension}`);
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const manifest = readSandboxControlManifest(manifestPath);
     const root = path.dirname(manifestPath);
     if (isSandboxControlRootQuiescing(root))
         throw new Error('SANDBOX_CONTROL_QUIESCING');
@@ -64,14 +79,24 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
         catch {
             // Malformed owner records are stale and replaced below.
         }
-        const owner = broker !== null && typeof broker.pid === 'number' && typeof broker.startTime === 'string'
-            ? { version: 1, pid: broker.pid, startTime: broker.startTime }
+        const owner = broker !== null && broker.version === 3 && typeof broker.pid === 'number'
+            && Number.isSafeInteger(broker.pid) && broker.pid > 0 && typeof broker.startTime === 'number'
+            && Number.isSafeInteger(broker.startTime) && typeof broker.brokerId === 'string'
+            && broker.brokerId.length > 0 && typeof broker.token === 'string'
+            && typeof broker.generation === 'string'
+            ? broker
             : null;
-        const live = owner !== null && processIdentityMatches(owner);
+        if (broker === null || broker.version !== 3 || owner === null) {
+            throw new Error('SANDBOX_CONTROL_BROKER_VERSION_INVALID: rebuild the sandbox container before starting a new broker');
+        }
+        const ownerState = getProcessIdentityState({ pid: owner.pid, startTime: owner.startTime });
+        if (ownerState === 'unknown')
+            throw new Error('SANDBOX_CONTROL_BROKER_OWNER_UNAVAILABLE');
+        const live = ownerState === 'alive';
         if (live
             && owner !== null
             && broker !== null
-            && broker.version === 2
+            && broker.version === 3
             && broker.token === manifest.token
             && broker.generation === manifest.generation) {
             await waitForSandboxControlBrokerStatus({
@@ -83,28 +108,6 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
             });
             return;
         }
-        if (live && owner) {
-            const deadline = Date.now() + 5_000;
-            while (Date.now() < deadline) {
-                await new Promise((resolve) => setTimeout(resolve, 25));
-                try {
-                    if (fs.readFileSync(brokerPath, 'utf8') !== brokerSnapshot) {
-                        return startSandboxControlBroker(repoRoot, manifestPath);
-                    }
-                }
-                catch (error) {
-                    if (error.code === 'ENOENT') {
-                        return startSandboxControlBroker(repoRoot, manifestPath);
-                    }
-                    throw error;
-                }
-                if (!processIdentityMatches(owner)) {
-                    removePidFileIfMatches(brokerPath, brokerSnapshot);
-                    return startSandboxControlBroker(repoRoot, manifestPath);
-                }
-            }
-            throw new Error('SANDBOX_CONTROL_BROKER_OWNER_ACTIVE');
-        }
     }
     const startupStartTime = getProcessStartTime(process.pid);
     if (!startupStartTime)
@@ -162,22 +165,42 @@ async function ensureSandboxControlBroker(params) {
     });
     if (!fs.existsSync(control.manifestPath))
         return;
-    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
-    if (manifest.version !== 3) {
-        throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 3; container-only recreation is required');
+    const validatedManifest = readSandboxControlManifest(control.manifestPath);
+    const containerObservation = await inspectSandboxControlContainer(validatedManifest);
+    if (containerObservation.state === 'unknown') {
+        throw new Error(`SANDBOX_CONTROL_CONTAINER_UNKNOWN: ${containerObservation.reason}`);
+    }
+    if (containerObservation.state === 'absent') {
+        await garbageCollectSandboxControlRoot(control.root, {
+            inspectContainer: (timeoutMs) => inspectSandboxControlContainer(validatedManifest, { timeoutMs })
+        });
+        throw new Error('SANDBOX_CONTROL_CONTAINER_ABSENT: recreate the sandbox container before broker recovery');
     }
     const brokerPath = path.join(control.root, 'broker.json');
     try {
         const broker = JSON.parse(fs.readFileSync(brokerPath, 'utf8'));
-        if (broker.version === 2
+        const validIdentity = typeof broker.pid === 'number'
+            && Number.isSafeInteger(broker.pid)
+            && typeof broker.startTime === 'number'
+            && Number.isSafeInteger(broker.startTime);
+        const ownerState = validIdentity
+            ? getProcessIdentityState({ pid: broker.pid, startTime: broker.startTime })
+            : 'dead';
+        if (ownerState === 'unknown')
+            throw new Error('SANDBOX_CONTROL_BROKER_OWNER_UNAVAILABLE');
+        if (broker.version === 3
             && typeof broker.pid === 'number'
-            && typeof broker.startTime === 'string'
-            && broker.token === manifest.token
-            && broker.generation === manifest.generation
-            && processIdentityMatches({ version: 1, pid: broker.pid, startTime: broker.startTime })) {
+            && Number.isSafeInteger(broker.pid)
+            && typeof broker.startTime === 'number'
+            && Number.isSafeInteger(broker.startTime)
+            && typeof broker.brokerId === 'string'
+            && broker.brokerId.length > 0
+            && broker.token === validatedManifest.token
+            && broker.generation === validatedManifest.generation
+            && ownerState === 'alive') {
             try {
                 const status = readSandboxControlStatus(control.statusDir);
-                if (status.generation === manifest.generation && status.broker.pid === broker.pid
+                if (status.generation === validatedManifest.generation && status.broker.pid === broker.pid
                     && status.broker.startTime === broker.startTime
                     && Date.now() - status.updatedAt <= SANDBOX_CONTROL_STATUS_STALE_MS
                     && status.updatedAt <= Date.now() + SANDBOX_CONTROL_FUTURE_SKEW_MS)
@@ -189,14 +212,16 @@ async function ensureSandboxControlBroker(params) {
             await waitForSandboxControlBrokerStatus({
                 root: control.root,
                 statusDir: control.statusDir,
-                generation: manifest.generation,
+                generation: validatedManifest.generation,
                 pid: broker.pid,
                 startTime: broker.startTime
             });
             return;
         }
     }
-    catch {
+    catch (error) {
+        if (error instanceof Error && error.message === 'SANDBOX_CONTROL_BROKER_OWNER_UNAVAILABLE')
+            throw error;
         // A missing, stale, or malformed broker record is replaced below.
     }
     await startSandboxControlBroker(params.config.repoRoot, control.manifestPath);
@@ -231,6 +256,30 @@ export function classifySandboxRecovery(snapshot) {
             message: 'Container runtime capability signature does not match the current sandbox plan.'
         });
     }
+    if (snapshot.workspaceTopology === 'legacy-parent') {
+        findings.push({
+            repairKind: 'hard-failure',
+            code: 'SANDBOX_WORKSPACE_TOPOLOGY_MISMATCH',
+            message: 'Sandbox uses the legacy workspace parent-mount topology; recreate the container explicitly to migrate it.',
+            path: '/workspace/.agents/workspace'
+        });
+    }
+    if (snapshot.taskView && !snapshot.taskView.readable) {
+        findings.push({
+            repairKind: 'hard-failure',
+            code: 'SANDBOX_TASK_VIEW_UNREADABLE',
+            message: `Bound task view is not readable at ${snapshot.taskView.path}.`,
+            path: snapshot.taskView.path
+        });
+    }
+    if (snapshot.runtimeStoreOk === false) {
+        findings.push({
+            repairKind: 'hard-failure',
+            code: 'SANDBOX_RUNTIME_STORE_UNAVAILABLE',
+            message: 'Task-bound runtime store is not writable and readable by devuser.',
+            path: '/run/agent-infra/runtime'
+        });
+    }
     for (const mountPath of snapshot.unexpectedCapabilityMounts ?? []) {
         findings.push({
             repairKind: 'hard-failure',
@@ -239,6 +288,9 @@ export function classifySandboxRecovery(snapshot) {
         });
     }
     for (const mount of snapshot.mounts) {
+        if (snapshot.workspaceTopology === 'legacy-parent'
+            && mount.path.startsWith('/workspace/.agents/workspace'))
+            continue;
         if (mount.actualType !== mount.expectedType
             || !mount.sourceMatches
             || mount.actualRW !== mount.expectedRW
@@ -320,6 +372,20 @@ function inspectContainer(engine, container, runFn) {
     }
     return parsed[0];
 }
+function workspaceTopology(mountsByDestination) {
+    if (mountsByDestination.has('/workspace/.agents/workspace'))
+        return 'legacy-parent';
+    const perState = [
+        '/workspace/.agents/workspace/active',
+        '/workspace/.agents/workspace/active/.short-ids.json',
+        '/workspace/.agents/workspace/completed',
+        '/workspace/.agents/workspace/blocked',
+        '/workspace/.agents/workspace/archive'
+    ];
+    return perState.some((destination) => mountsByDestination.has(destination))
+        ? 'per-state'
+        : 'unknown';
+}
 function probe(engine, container, script, args, runOkFn, user = 'devuser') {
     return runOkFn(engine, 'docker', [
         'exec', '--user', user, container, 'sh', '-c', script, 'agent-infra-recovery', ...args
@@ -380,6 +446,7 @@ function expectedMounts(params) {
         controlStatusDir: control.statusDir,
         ...(params.workspace.mode === 'task-bound'
             ? {
+                runtimeDir: control.runtimeDir,
                 taskSource: assertSandboxTaskSource(config.repoRoot, params.workspace.taskId),
                 taskId: params.workspace.taskId
             }
@@ -478,6 +545,10 @@ export function collectSandboxRecoverySnapshot(params) {
     const capabilityPlan = createSandboxCapabilityPlan(params.config);
     const workspace = params.workspace ?? { mode: 'branch-only' };
     const tools = [...capabilityPlan.tools];
+    const topology = workspaceTopology(mountsByDestination);
+    const taskViewPath = workspace.mode === 'task-bound'
+        ? `/workspace/.agents/workspace/active/${workspace.taskId}/task.md`
+        : null;
     const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
         const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
         return {
@@ -496,6 +567,9 @@ export function collectSandboxRecoverySnapshot(params) {
         permissionsOk: probe(params.engine, params.container, 'test "$(stat -c %u:%g:%a -- "$1")" = "$(id -u devuser):$(id -g devuser):700"', [tool.containerMount], runOkFn),
         writable: probe(params.engine, params.container, 'probe="$1/.agent-infra-ready-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"', [tool.containerMount], runOkFn)
     }));
+    const runtimeStoreOk = workspace.mode === 'task-bound'
+        ? probe(params.engine, params.container, 'probe="$1/.agent-infra-runtime-$$"; trap \'rm -f -- "$probe"\' EXIT; printf runtime-probe > "$probe" && test "$(cat -- "$probe")" = runtime-probe', ['/run/agent-infra/runtime'], runOkFn)
+        : undefined;
     const labels = inspection.Config?.Labels ?? {};
     const branchLabel = labels[sandboxBranchLabel(params.config)];
     const containerWorkspace = parseSandboxWorkspaceIdentity(labels, {
@@ -551,6 +625,14 @@ export function collectSandboxRecoverySnapshot(params) {
         actualBranch: typeof branchLabel === 'string' ? branchLabel : null,
         expectedWorkspace: workspace,
         actualWorkspace: containerWorkspace,
+        workspaceTopology: topology,
+        ...(taskViewPath === null ? {} : {
+            taskView: {
+                path: taskViewPath,
+                readable: probe(params.engine, params.container, 'test -r "$1"', [taskViewPath], runOkFn)
+            }
+        }),
+        ...(runtimeStoreOk === undefined ? {} : { runtimeStoreOk }),
         identityOk: typeof inspection.Id === 'string' && inspection.Id.length > 0
             && branchLabel === params.branch
             && sameSandboxWorkspaceIdentity(containerWorkspace, workspace),
@@ -666,10 +748,12 @@ function assess(params) {
 }
 function canRetryFreshReadiness(findings) {
     return findings.length > 0 && findings.every((finding) => finding.repairKind === 'hard-failure'
+        && finding.code !== 'SANDBOX_WORKSPACE_TOPOLOGY_MISMATCH'
         && finding.path !== undefined
         && (finding.path.startsWith('/workspace/.agents/workspace')
             || finding.path === '/home/devuser/.host-shell-config'
-            || finding.path === '/home/devuser/.bash_aliases'));
+            || finding.path === '/home/devuser/.bash_aliases'
+            || finding.path === '/run/agent-infra/runtime'));
 }
 export async function assertFreshSandboxReady(params) {
     validateTmpfsSeedEntries({
@@ -729,6 +813,9 @@ export async function ensureSandboxReady(params) {
                 workspace: params.workspace ?? { mode: 'branch-only' }
             });
         }
+        if (params.forceRecreate) {
+            throw new Error('Explicit container recreation requested.');
+        }
         if (!params.row.running) {
             startFn(params.engine, params.row.name);
             const initial = assess({
@@ -862,7 +949,8 @@ export async function ensureSandboxReady(params) {
                 + 'keep the worktree in use, remove the stale directory, then retry.';
         throw new Error(`SANDBOX_RECOVERY_WORKTREE_SNAPSHOT_INVALID: expected exactly one existing worktree for '${params.branch}', found ${existingWorktrees.length}. ${remediation}`);
     }
-    const beforeInspection = inspectWorktree(existingWorktrees[0]);
+    const worktreeProbe = worktreeProbeForEngine(params.engine, deps?.probe);
+    const beforeInspection = inspectWorktree(existingWorktrees[0], { probe: worktreeProbe });
     if (beforeInspection.status === 'failed') {
         throw new Error(`SANDBOX_RECOVERY_WORKTREE_SNAPSHOT_INVALID: ${beforeInspection.message}`);
     }
@@ -871,17 +959,14 @@ export async function ensureSandboxReady(params) {
         throw new Error(`SANDBOX_RECOVERY_WORKTREE_SNAPSHOT_INVALID: expected branch '${params.branch}', found '${before.branch}'. `
             + `Run 'git -C ${JSON.stringify(before.worktree)} checkout ${params.branch}' to restore the expected branch, then retry.`);
     }
-    const warning = `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
+    const warning = params.forceRecreate
+        ? `Explicit sandbox recreation requested. Replacing only the container. ${dataBoundary}`
+        : `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
     warnings.push(warning);
     (params.writeWarning ?? ((message) => process.stderr.write(`${message}\n`)))(warning);
-    const runVerboseFn = deps?.runVerbose ?? runVerboseEngine;
     let replacementResult = null;
     let replacementFailure = null;
     try {
-        if (params.row.running) {
-            runVerboseFn(params.engine, 'docker', ['stop', params.row.name]);
-        }
-        runVerboseFn(params.engine, 'docker', ['rm', params.row.name]);
         await params.recreate(params.branch);
         const rows = (deps?.fetchRows ?? fetchSandboxRows)(params.engine, sandboxLabel(params.config), sandboxBranchLabel(params.config));
         const replacement = selectSandboxContainer([...rows.running, ...rows.nonRunning], containerNameCandidates(params.config, params.branch));
@@ -904,7 +989,7 @@ export async function ensureSandboxReady(params) {
     catch (error) {
         replacementFailure = error;
     }
-    const afterInspection = inspectWorktree(before.worktree);
+    const afterInspection = inspectWorktree(before.worktree, { probe: worktreeProbe });
     if (afterInspection.status === 'failed' || afterInspection.snapshot.identity !== before.identity) {
         const detail = afterInspection.status === 'failed'
             ? afterInspection.message

package/dist/lib/sandbox/workspace-view.js

@@ -38,6 +38,7 @@ export function sandboxControlPaths(params) {
         channelDir: path.join(root, 'channel'),
         statusDir: path.join(root, 'public'),
         processingDir: path.join(root, 'processing'),
+        runtimeDir: path.join(root, 'runtime'),
         manifestPath: path.join(root, 'manifest.json')
     };
 }
@@ -73,21 +74,6 @@ function assertSafeMountTargetPath(target, worktreeRoot, canonicalWorktreeRoot)
         }
     }
 }
-export function prepareSandboxWorkspaceMountTargets(worktreeRoot) {
-    const resolvedWorktreeRoot = path.resolve(worktreeRoot);
-    const canonicalWorktreeRoot = fs.realpathSync.native(resolvedWorktreeRoot);
-    const workspaceRoot = path.resolve(resolvedWorktreeRoot, '.agents', 'workspace');
-    const statePaths = sandboxWorkspaceViewStatePaths(workspaceRoot);
-    const registryTarget = path.join(workspaceRoot, 'active', '.short-ids.json');
-    for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget]) {
-        assertSafeMountTargetPath(target, resolvedWorktreeRoot, canonicalWorktreeRoot);
-    }
-    fs.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
-    for (const { hostPath } of statePaths) {
-        fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
-    }
-    fs.closeSync(fs.openSync(registryTarget, 'a', 0o600));
-}
 export function assertSandboxTaskSource(repoRoot, taskId) {
     if (!/^TASK-\d{8}-\d{6}$/.test(taskId))
         throw new Error('SANDBOX_TASK_SOURCE_INVALID');
@@ -103,6 +89,23 @@ export function assertSandboxTaskSource(repoRoot, taskId) {
     }
     return canonical;
 }
+export function prepareSandboxWorkspaceMountTargets(worktreeRoot) {
+    const resolvedWorktreeRoot = path.resolve(worktreeRoot);
+    const canonicalWorktreeRoot = fs.realpathSync.native(resolvedWorktreeRoot);
+    const workspaceRoot = path.resolve(resolvedWorktreeRoot, '.agents', 'workspace');
+    const statePaths = sandboxWorkspaceViewStatePaths(workspaceRoot);
+    const registryTarget = path.join(workspaceRoot, 'active', '.short-ids.json');
+    for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget]) {
+        assertSafeMountTargetPath(target, resolvedWorktreeRoot, canonicalWorktreeRoot);
+    }
+    fs.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
+    for (const { hostPath } of statePaths) {
+        fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
+        fs.chmodSync(hostPath, 0o700);
+    }
+    fs.chmodSync(workspaceRoot, 0o700);
+    fs.closeSync(fs.openSync(registryTarget, 'a', 0o600));
+}
 export function materializeSandboxWorkspaceView(params) {
     const projectRoot = path.resolve(params.base, params.project);
     const { root, taskMountPath } = sandboxWorkspaceViewPaths(params);
@@ -132,16 +135,33 @@ export function materializeSandboxWorkspaceView(params) {
     return { root, taskMountPath };
 }
 export function materializeSandboxControl(params) {
-    const { root, channelDir, statusDir, processingDir, manifestPath } = sandboxControlPaths(params);
+    const { root, channelDir, statusDir, processingDir, runtimeDir, manifestPath } = sandboxControlPaths(params);
     assertSafeDirectory(root, path.resolve(params.base));
+    if (fs.existsSync(root)) {
+        if (!params.replacementLease || path.resolve(params.replacementLease.root) !== root) {
+            throw new Error('SANDBOX_CONTROL_REPLACEMENT_REQUIRED');
+        }
+        params.replacementLease.assertOwned();
+    }
     const consumedDir = path.join(root, 'consumed');
     assertSafeDirectory(consumedDir, root);
     fs.rmSync(consumedDir, { recursive: true, force: true });
     fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
-    for (const directory of [statusDir, processingDir]) {
+    for (const directory of [statusDir, processingDir, runtimeDir]) {
         assertSafeDirectory(directory, root);
+        if (directory === runtimeDir)
+            fs.rmSync(directory, { recursive: true, force: true });
         fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
     }
+    for (const directory of [
+        path.join(runtimeDir, 'clients'),
+        path.join(runtimeDir, 'clients', 'codex', 'capabilities'),
+        path.join(runtimeDir, 'clients', 'codex', 'lifecycle')
+    ]) {
+        assertSafeDirectory(directory, runtimeDir);
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        fs.chmodSync(directory, 0o700);
+    }
     for (const queue of ['requests', 'responses']) {
         const directory = path.join(channelDir, queue);
         assertSafeDirectory(directory, root);
@@ -152,11 +172,13 @@ export function materializeSandboxControl(params) {
     const generation = randomBytes(16).toString('hex');
     const repoRoot = fs.realpathSync.native(params.repoRoot);
     const manifest = {
-        version: 3,
+        version: 5,
+        engine: params.engine ?? 'docker',
         repoRoot,
         worktreeRoot: fs.realpathSync.native(params.worktreeRoot),
         project: params.project,
         container: params.container,
+        containerIdentity: { id: '', labels: {} },
         branch: params.branch,
         mode: params.identity.mode,
         taskId: params.identity.mode === 'task-bound' ? params.identity.taskId : null,
@@ -164,9 +186,26 @@ export function materializeSandboxControl(params) {
         generation,
         channelDir,
         publicStatusDir: statusDir,
-        processingDir
+        processingDir,
+        runtimeDir
     };
     fs.writeFileSync(manifestPath, `${JSON.stringify(manifest)}\n`, { mode: 0o600 });
-    return { channelDir, statusDir, manifestPath, token, generation };
+    return { root, channelDir, statusDir, runtimeDir, manifestPath, token, generation };
+}
+export function finalizeSandboxControlManifest(setup, identity) {
+    if (!identity.engine || !identity.id)
+        throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
+    const manifest = JSON.parse(fs.readFileSync(setup.manifestPath, 'utf8'));
+    manifest.version = 5;
+    manifest.engine = identity.engine;
+    manifest.containerIdentity = { id: identity.id, labels: { ...identity.labels } };
+    const temporary = `${setup.manifestPath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(manifest)}\n`, { mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporary, setup.manifestPath);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
 }
 //# sourceMappingURL=workspace-view.js.map

package/dist/lib/server/daemon.js

@@ -110,7 +110,7 @@ export async function runDaemon() {
             logger.close();
             if (ownStartTime !== null) {
                 removePidRecordIfMatches(config.pidFile, {
-                    version: 1,
+                    version: 2,
                     pid: process.pid,
                     startTime: ownStartTime
                 });

package/dist/lib/server/process-control.js

@@ -26,7 +26,7 @@ async function waitForProcessIdentity(pid, timeoutMs = 2000) {
     while (Date.now() < deadline) {
         const startTime = getProcessStartTime(pid);
         if (startTime !== null)
-            return { version: 1, pid, startTime };
+            return { version: 2, pid, startTime };
         await delay(25);
     }
     return null;
@@ -58,6 +58,9 @@ export async function start({ foreground = false } = {}) {
         process.stdout.write(`server already running (pid ${existing.record.pid})\n`);
         return;
     }
+    if (existing.kind === 'legacy-json' || existing.kind === 'legacy-pid-only' || existing.kind === 'legacy-unknown') {
+        throw new Error('server: legacy pid record requires the matching previous version to stop it before starting');
+    }
     if (existing.kind !== 'missing') {
         removePidFileIfMatches(pidPath, existing.snapshot);
     }
@@ -104,6 +107,9 @@ export async function stop() {
         return;
     }
     if (state.kind !== 'running') {
+        if (state.kind === 'legacy-json' || state.kind === 'legacy-pid-only' || state.kind === 'legacy-unknown') {
+            throw new Error('server: legacy pid record requires the matching previous version to stop it');
+        }
         removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server is not running (removed stale pid file)\n');
         return;
@@ -135,6 +141,10 @@ export function status() {
     const config = loadServerConfig();
     const state = readProcessState(config.pidFile);
     if (state.kind !== 'running') {
+        if (state.kind === 'legacy-json' || state.kind === 'legacy-pid-only' || state.kind === 'legacy-unknown') {
+            process.stdout.write('server: legacy pid record requires the matching previous version to stop it\n');
+            return;
+        }
         if (state.kind !== 'missing')
             removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server: stopped\n');