@jasonews/agent-squad-gateway 1.0.0

package/dist/provider-runtime/workspaces.js

@@ -0,0 +1,814 @@
+import { chmodSync, closeSync, constants, fchmodSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { GatewayError } from '../server/errors.js';
+const MARKER = '.gateway-workspace';
+const OWNER_KEY = '.gateway-owner-key';
+const QUARANTINE = '.gateway-quarantine';
+const STAGING = '.gateway-staging';
+const COMPONENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const RECOVERY_ENTRY = /^[a-f0-9]{48}$/;
+const OWNER_KEY_BYTES = 32;
+const NOFOLLOW = process.platform === 'win32' ? 0 : constants.O_NOFOLLOW;
+export class WorkspaceManager {
+    configuredRoot;
+    getFixedWorkspaces;
+    testHooks;
+    rootPromise;
+    mutationTail = Promise.resolve();
+    active = new Map();
+    constructor(workspacesDir, options) {
+        this.configuredRoot = resolve(workspacesDir);
+        this.getFixedWorkspaces = options.getFixedWorkspaces;
+        this.testHooks = options.testHooks ?? {};
+    }
+    acquireChat(target, runId) {
+        return this.exclusive(async () => {
+            validateComponent('target', target.id);
+            validateComponent('run', runId);
+            if (target.fixedWorkspace !== null)
+                return this.fixedLease(target.fixedWorkspace);
+            return target.isolationLevel === 'strict'
+                ? this.acquireStrict(target)
+                : this.acquireTemporary(runId);
+        });
+    }
+    createResponse(target, responseId) {
+        return this.exclusive(async () => {
+            validateComponent('target', target.id);
+            const id = validateComponent('response', responseId);
+            if (target.fixedWorkspace !== null)
+                return this.fixedLease(target.fixedWorkspace);
+            const state = await this.root();
+            const responses = this.ensureDirectory(state, ['responses']).path;
+            const path = join(responses, id);
+            const identity = this.managedDirectoryIdentity(path);
+            if (identity === undefined)
+                await this.replaceDirectory(state, path, 'response', 'cleanup');
+            else
+                this.requireMarker(state, path, 'response');
+            return this.persistentLease(path);
+        });
+    }
+    openResponse(path) {
+        return this.exclusive(async () => {
+            const state = await this.root();
+            const canonical = this.validateResponsePath(state, path);
+            return this.persistentLease(canonical);
+        });
+    }
+    cleanupExpired(paths) {
+        return this.cleanupForRetention(paths).then(() => undefined);
+    }
+    cleanupForRetention(paths) {
+        return this.exclusive(async () => {
+            const state = await this.root();
+            try {
+                this.sweepRecovery(state);
+            }
+            catch (error) {
+                if (error instanceof FixedWorkspaceConfigurationError)
+                    throw error;
+                return paths.map((path) => ({
+                    path,
+                    status: this.cleanupCandidate(state, path) === null ? 'unmanaged' : 'retry',
+                }));
+            }
+            const outcomes = [];
+            for (const path of paths) {
+                const candidate = this.cleanupCandidate(state, path);
+                if (candidate === null) {
+                    outcomes.push({ path, status: 'unmanaged' });
+                    continue;
+                }
+                if (this.active.has(candidate.path)) {
+                    outcomes.push({ path, status: 'retry' });
+                    continue;
+                }
+                let identity;
+                try {
+                    identity = this.requireMarker(state, candidate.path, candidate.kind);
+                }
+                catch (error) {
+                    outcomes.push({
+                        path,
+                        status: isMissingWorkspacePath(candidate.path, error) ? 'absent' : 'retry',
+                    });
+                    continue;
+                }
+                try {
+                    this.sweepRecovery(state);
+                    const detached = this.atomicDetach(state, candidate.path, identity, 'cleanup');
+                    this.removeQuarantined(state, detached, 'cleanup');
+                    outcomes.push({ path, status: 'removed' });
+                }
+                catch (error) {
+                    if (error instanceof FixedWorkspaceConfigurationError)
+                        throw error;
+                    outcomes.push({
+                        path,
+                        status: isMissingWorkspacePath(candidate.path, error) ? 'absent' : 'retry',
+                    });
+                }
+            }
+            return outcomes;
+        });
+    }
+    async acquireStrict(target) {
+        const targetId = validateComponent('target', target.id);
+        if (!Number.isSafeInteger(target.maxConcurrency) || target.maxConcurrency < 1) {
+            throw new Error('invalid target maxConcurrency');
+        }
+        const state = await this.root();
+        for (let index = 0; index < target.maxConcurrency; index += 1) {
+            const slots = this.ensureDirectory(state, ['targets', targetId, 'slots']).path;
+            const path = join(slots, String(index));
+            if (this.active.has(path))
+                continue;
+            const detached = await this.replaceDirectory(state, path, 'strict', 'strict-acquire');
+            if (detached !== null)
+                this.removeQuarantined(state, detached, 'strict-acquire');
+            this.active.set(path, 1);
+            let pendingRelease;
+            return this.destructiveLease(path, async () => {
+                if (pendingRelease === undefined) {
+                    pendingRelease = await this.replaceDirectory(state, path, 'strict', 'strict-release');
+                }
+                if (pendingRelease !== null)
+                    this.removeQuarantined(state, pendingRelease, 'strict-release');
+                pendingRelease = null;
+            });
+        }
+        throw new GatewayError(429, 'target_busy', `target ${target.id} has no free workspace slots`);
+    }
+    async acquireTemporary(runId) {
+        const id = validateComponent('run', runId);
+        const state = await this.root();
+        const temporary = this.ensureDirectory(state, ['temporary']).path;
+        const path = join(temporary, id);
+        if (this.active.has(path)) {
+            throw new GatewayError(429, 'target_busy', `run ${runId} already has a workspace lease`);
+        }
+        const detached = await this.replaceDirectory(state, path, 'temporary', 'temporary-acquire');
+        if (detached !== null)
+            this.removeQuarantined(state, detached, 'temporary-acquire');
+        this.active.set(path, 1);
+        let pendingRelease;
+        return this.destructiveLease(path, async () => {
+            if (pendingRelease === undefined) {
+                this.sweepRecovery(state);
+                pendingRelease = this.removeManagedPath(state, path, 'temporary', 'temporary-release');
+            }
+            if (pendingRelease !== null) {
+                this.removeQuarantined(state, pendingRelease, 'temporary-release');
+            }
+            pendingRelease = null;
+        });
+    }
+    async fixedLease(path) {
+        const canonical = realpathSync(path);
+        if (!statSync(canonical).isDirectory())
+            throw new Error('fixed workspace must be a directory');
+        const prospectiveRoot = canonicalizeProspectivePath(this.configuredRoot);
+        const configured = this.authoritativeFixedWorkspaces(prospectiveRoot);
+        if (!configured.includes(canonical))
+            throw new Error('fixed workspace is not configured');
+        return { path: canonical, release: async () => undefined };
+    }
+    destructiveLease(path, cleanup) {
+        let released = false;
+        return {
+            path,
+            release: () => this.exclusive(async () => {
+                if (released)
+                    return;
+                await cleanup();
+                this.active.delete(path);
+                released = true;
+            }),
+        };
+    }
+    persistentLease(path) {
+        this.active.set(path, (this.active.get(path) ?? 0) + 1);
+        let released = false;
+        return {
+            path,
+            release: () => this.exclusive(async () => {
+                if (released)
+                    return;
+                const remaining = (this.active.get(path) ?? 1) - 1;
+                if (remaining === 0)
+                    this.active.delete(path);
+                else
+                    this.active.set(path, remaining);
+                released = true;
+            }),
+        };
+    }
+    root() {
+        if (this.rootPromise === undefined) {
+            const pending = Promise.resolve().then(() => this.initializeRoot());
+            this.rootPromise = pending;
+            void pending.catch(() => {
+                if (this.rootPromise === pending)
+                    this.rootPromise = undefined;
+            });
+        }
+        return this.rootPromise;
+    }
+    async initializeRoot() {
+        const prospectiveRoot = canonicalizeProspectivePath(this.configuredRoot);
+        this.authoritativeFixedWorkspaces(prospectiveRoot);
+        mkdirSync(this.configuredRoot, { recursive: true, mode: 0o700 });
+        const root = realpathSync(this.configuredRoot);
+        this.authoritativeFixedWorkspaces(root);
+        chmodSync(root, 0o700);
+        const rootIdentity = directoryIdentity(root);
+        const ownerKey = loadOrCreateOwnerKey(root);
+        const quarantine = join(root, QUARANTINE);
+        ensurePrivateDirectory(quarantine);
+        const quarantineIdentity = directoryIdentity(quarantine);
+        const staging = join(root, STAGING);
+        ensurePrivateDirectory(staging);
+        const stagingIdentity = directoryIdentity(staging);
+        const state = { root, rootIdentity, quarantine, quarantineIdentity, staging, stagingIdentity, ownerKey };
+        this.sweepRecovery(state);
+        return state;
+    }
+    ensureDirectory(state, parts) {
+        this.requireRootIdentity(state);
+        let current = state.root;
+        let finalCreated = false;
+        for (let index = 0; index < parts.length; index += 1) {
+            const candidate = join(current, parts[index]);
+            let created = false;
+            try {
+                const entry = lstatSync(candidate);
+                if (entry.isSymbolicLink())
+                    throw new Error(`managed workspace contains symbolic link: ${candidate}`);
+                if (!entry.isDirectory())
+                    throw new Error(`managed workspace path is not a directory: ${candidate}`);
+            }
+            catch (error) {
+                if (!isErrorCode(error, 'ENOENT'))
+                    throw error;
+                try {
+                    mkdirSync(candidate, { mode: 0o700 });
+                    created = true;
+                }
+                catch (mkdirError) {
+                    if (!isErrorCode(mkdirError, 'EEXIST'))
+                        throw mkdirError;
+                    const winner = lstatSync(candidate);
+                    if (winner.isSymbolicLink() || !winner.isDirectory()) {
+                        throw new Error(`unsafe managed workspace path: ${candidate}`);
+                    }
+                }
+            }
+            const canonical = realpathSync(candidate);
+            assertContained(state.root, canonical, false);
+            if (canonical !== candidate)
+                throw new Error(`managed workspace path is not canonical: ${candidate}`);
+            current = canonical;
+            if (index === parts.length - 1)
+                finalCreated = created;
+        }
+        return { path: current, created: finalCreated, identity: directoryIdentity(current) };
+    }
+    async replaceDirectory(state, path, kind, reason) {
+        this.sweepRecovery(state);
+        const existingIdentity = this.managedDirectoryIdentity(path);
+        const expectedIdentity = existingIdentity === undefined ? undefined : this.requireMarker(state, path, kind);
+        const staged = join(state.staging, randomBytes(24).toString('hex'));
+        mkdirSync(staged, { mode: 0o700 });
+        const stagedIdentity = directoryIdentity(staged);
+        try {
+            this.writeMarker(state, staged, path, kind, stagedIdentity);
+            return this.publishStagedDirectory(state, staged, stagedIdentity, path, kind, reason, expectedIdentity);
+        }
+        catch (error) {
+            try {
+                this.removeStaged(state, { path: staged, identity: stagedIdentity }, 'transaction-cleanup');
+            }
+            catch (cleanupError) {
+                throw combinedError(error, cleanupError, `failed to clean staged workspace for ${path}`);
+            }
+            throw error;
+        }
+    }
+    removeManagedPath(state, path, kind, reason) {
+        let identity;
+        try {
+            identity = this.requireMarker(state, path, kind);
+        }
+        catch (error) {
+            if (isErrorCode(error, 'ENOENT'))
+                return null;
+            throw error;
+        }
+        const detached = this.atomicDetach(state, path, identity, reason);
+        return detached;
+    }
+    removeQuarantined(state, entry, reason) {
+        this.testHooks.beforeQuarantineRemove?.({ path: entry.path, reason });
+        const fixedWorkspaces = this.canonicalFixedWorkspaceSnapshot();
+        this.requireRootIdentity(state);
+        this.validateRecoveryEntry(state, state.quarantine, state.quarantineIdentity, entry);
+        this.assertFixedWorkspaceSnapshotSafe(state.root, fixedWorkspaces);
+        rmSync(entry.path, { recursive: true, force: true });
+    }
+    removeStaged(state, entry, reason) {
+        this.testHooks.beforeStagingRemove?.({ path: entry.path, reason });
+        const fixedWorkspaces = this.canonicalFixedWorkspaceSnapshot();
+        this.requireRootIdentity(state);
+        this.validateRecoveryEntry(state, state.staging, state.stagingIdentity, entry);
+        this.assertFixedWorkspaceSnapshotSafe(state.root, fixedWorkspaces);
+        rmSync(entry.path, { recursive: true, force: true });
+    }
+    sweepRecovery(state) {
+        this.sweepDirectory(state, state.quarantine, state.quarantineIdentity, (entry) => this.removeQuarantined(state, entry, 'recovery'));
+        this.sweepDirectory(state, state.staging, state.stagingIdentity, (entry) => this.removeStaged(state, entry, 'recovery'));
+    }
+    sweepDirectory(state, directory, expectedIdentity, removeEntry) {
+        this.validateRecoveryDirectory(state, directory, expectedIdentity);
+        const entries = readdirSync(directory).sort();
+        for (const name of entries) {
+            const path = join(directory, name);
+            if (!RECOVERY_ENTRY.test(name))
+                throw new Error(`unsafe recovery entry: ${path}`);
+            removeEntry({ path, identity: identityOf(lstatSync(path)) });
+        }
+    }
+    atomicDetach(state, path, expectedIdentity, reason) {
+        this.testHooks.beforeAtomicDetach?.({ path, reason });
+        // Node has no dirfd/openat API. Keep the final ancestor checks and rename in
+        // one synchronous sequence so no same-process task can interleave a swap.
+        this.assertFixedWorkspacesSafe(state);
+        this.requireRootIdentity(state);
+        const parent = dirname(path);
+        const destinationParentIdentity = this.validateManagedDirectory(state, parent);
+        this.validateRecoveryDirectory(state, state.quarantine, state.quarantineIdentity);
+        if (readdirSync(state.quarantine).length !== 0)
+            throw new Error('pending quarantine cleanup');
+        const current = lstatSync(path);
+        if (!current.isSymbolicLink()) {
+            if (!current.isDirectory() || !sameIdentity(identityOf(current), expectedIdentity)) {
+                throw new Error(`managed workspace changed before detach: ${path}`);
+            }
+        }
+        const quarantined = join(state.quarantine, randomBytes(24).toString('hex'));
+        renameSync(path, quarantined);
+        return { path: quarantined, identity: identityOf(current), destinationParentIdentity };
+    }
+    publishStagedDirectory(state, staged, stagedIdentity, path, kind, reason, expectedIdentity) {
+        if (expectedIdentity === undefined) {
+            this.testHooks.beforeMarkerOperation?.({
+                markerPath: join(staged, MARKER),
+                path,
+                kind,
+                phase: 'directory-commit',
+            });
+            this.assertFixedWorkspacesSafe(state);
+            this.validateManagedDirectory(state, dirname(path));
+            if (this.managedDirectoryIdentity(path) !== undefined)
+                throw new Error(`managed workspace already exists: ${path}`);
+            if (!sameIdentity(this.validateManagedDirectory(state, staged), stagedIdentity)) {
+                throw new Error(`staged managed workspace changed before commit: ${path}`);
+            }
+            renameSync(staged, path);
+            return null;
+        }
+        const detached = this.atomicDetach(state, path, expectedIdentity, reason);
+        try {
+            this.testHooks.beforeMarkerOperation?.({
+                markerPath: join(staged, MARKER),
+                path,
+                kind,
+                phase: 'directory-commit',
+            });
+            this.assertFixedWorkspacesSafe(state);
+            this.validateManagedDirectory(state, dirname(path));
+            if (!sameIdentity(this.validateManagedDirectory(state, staged), stagedIdentity)) {
+                throw new Error(`staged managed workspace changed before commit: ${path}`);
+            }
+            renameSync(staged, path);
+            return detached;
+        }
+        catch (error) {
+            try {
+                this.testHooks.beforeDirectoryRollback?.({ path, kind });
+                const fixedWorkspaces = this.canonicalFixedWorkspaceSnapshot();
+                this.requireRootIdentity(state);
+                this.validateRecoveryEntry(state, state.quarantine, state.quarantineIdentity, detached);
+                const destinationParentIdentity = this.validateManagedDirectory(state, dirname(path));
+                if (!sameIdentity(destinationParentIdentity, detached.destinationParentIdentity)) {
+                    throw new Error(`managed workspace parent changed during rollback: ${path}`);
+                }
+                if (this.managedDirectoryIdentity(path) !== undefined) {
+                    throw new Error(`managed workspace occupied during rollback: ${path}`);
+                }
+                this.assertFixedWorkspaceSnapshotSafe(state.root, fixedWorkspaces);
+                renameSync(detached.path, path);
+            }
+            catch (rollbackError) {
+                throw combinedError(error, rollbackError, `failed to roll back managed workspace ${path}`);
+            }
+            throw error;
+        }
+    }
+    managedDirectoryIdentity(path) {
+        try {
+            const entry = lstatSync(path);
+            if (entry.isSymbolicLink() || !entry.isDirectory())
+                throw new Error(`unsafe managed workspace: ${path}`);
+            if (realpathSync(path) !== path)
+                throw new Error(`managed workspace is not canonical: ${path}`);
+            return identityOf(entry);
+        }
+        catch (error) {
+            if (isErrorCode(error, 'ENOENT'))
+                return undefined;
+            throw error;
+        }
+    }
+    validateRecoveryDirectory(state, path, expectedIdentity) {
+        const identity = this.validateManagedDirectory(state, path);
+        if (!sameIdentity(identity, expectedIdentity))
+            throw new Error(`unsafe recovery directory: ${path}`);
+    }
+    validateRecoveryEntry(state, directory, directoryIdentity, entry) {
+        this.validateRecoveryDirectory(state, directory, directoryIdentity);
+        if (dirname(entry.path) !== directory || !RECOVERY_ENTRY.test(basename(entry.path))) {
+            throw new Error(`unsafe recovery entry: ${entry.path}`);
+        }
+        const current = lstatSync(entry.path);
+        if (!sameIdentity(identityOf(current), entry.identity)) {
+            throw new Error(`recovery entry changed before removal: ${entry.path}`);
+        }
+    }
+    validateManagedDirectory(state, path) {
+        this.requireRootIdentity(state);
+        if (!isAbsolute(path) || path !== resolve(path))
+            throw new Error(`unsafe managed workspace: ${path}`);
+        assertContained(state.root, path, true);
+        const relation = relative(state.root, path);
+        let current = state.root;
+        if (relation !== '') {
+            for (const part of relation.split(sep)) {
+                current = join(current, part);
+                const entry = lstatSync(current);
+                if (entry.isSymbolicLink() || !entry.isDirectory()) {
+                    throw new Error(`managed workspace ancestor is unsafe: ${current}`);
+                }
+                if (realpathSync(current) !== current) {
+                    throw new Error(`managed workspace ancestor is not canonical: ${current}`);
+                }
+            }
+        }
+        return directoryIdentity(path);
+    }
+    validateResponsePath(state, path) {
+        if (!isAbsolute(path) || path !== resolve(path))
+            throw new Error('path is not a canonical managed response');
+        const candidate = resolve(path);
+        if (!isContained(state.root, candidate, false))
+            throw new Error('path is not a managed response');
+        const parts = relative(state.root, candidate).split(sep);
+        if (parts.length !== 2 || parts[0] !== 'responses')
+            throw new Error('path is not a managed response');
+        validateComponent('response', parts[1]);
+        try {
+            this.requireMarker(state, candidate, 'response');
+        }
+        catch {
+            throw new Error('path is not a managed response or has an invalid marker');
+        }
+        return candidate;
+    }
+    cleanupCandidate(state, path) {
+        if (!isAbsolute(path) || path !== resolve(path))
+            return null;
+        const candidate = resolve(path);
+        if (!isContained(state.root, candidate, false))
+            return null;
+        const parts = relative(state.root, candidate).split(sep);
+        try {
+            const kind = cleanupKind(parts);
+            return kind === null ? null : { path: candidate, kind };
+        }
+        catch {
+            return null;
+        }
+    }
+    writeMarker(state, directory, path, kind, expectedIdentity) {
+        const identity = this.validateManagedDirectory(state, directory);
+        if (!sameIdentity(identity, expectedIdentity))
+            throw new Error(`managed workspace changed before marking: ${path}`);
+        const markerPath = join(directory, MARKER);
+        const temporaryPath = join(directory, `.${MARKER}.${randomBytes(24).toString('hex')}.tmp`);
+        const marker = expectedMarker(state, path, kind);
+        let descriptor;
+        let failure;
+        try {
+            descriptor = openSync(temporaryPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | NOFOLLOW, 0o600);
+            this.testHooks.beforeMarkerOperation?.({ markerPath, path, kind, phase: 'temporary-write' });
+            writeFileSync(descriptor, marker);
+            this.testHooks.beforeMarkerOperation?.({ markerPath, path, kind, phase: 'temporary-fsync' });
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = undefined;
+            this.testHooks.beforeMarkerCommit?.({ markerPath, path, kind });
+            const currentIdentity = this.validateManagedDirectory(state, directory);
+            if (!sameIdentity(currentIdentity, expectedIdentity)) {
+                throw new Error(`managed workspace changed before marker commit: ${path}`);
+            }
+            this.testHooks.beforeMarkerOperation?.({ markerPath, path, kind, phase: 'temporary-rename' });
+            renameSync(temporaryPath, markerPath);
+            syncDirectory(directory);
+        }
+        catch (error) {
+            failure = error;
+        }
+        finally {
+            if (descriptor !== undefined) {
+                try {
+                    closeSync(descriptor);
+                }
+                catch (closeError) {
+                    failure = failure === undefined
+                        ? closeError
+                        : combinedError(failure, closeError, `failed to close marker temporary file for ${path}`);
+                }
+            }
+            try {
+                unlinkSync(temporaryPath);
+            }
+            catch (cleanupError) {
+                if (!isErrorCode(cleanupError, 'ENOENT')) {
+                    failure = failure === undefined
+                        ? cleanupError
+                        : combinedError(failure, cleanupError, `failed to clean marker temporary file for ${path}`);
+                }
+            }
+        }
+        if (failure !== undefined)
+            throw failure;
+    }
+    requireMarker(state, path, kind) {
+        const identity = this.validateManagedDirectory(state, path);
+        const markerPath = join(path, MARKER);
+        this.testHooks.beforeMarkerOpen?.({ markerPath, path, kind });
+        const currentIdentity = this.validateManagedDirectory(state, path);
+        if (!sameIdentity(currentIdentity, identity))
+            throw new Error(`invalid managed workspace marker: ${path}`);
+        let descriptor;
+        try {
+            descriptor = openSync(markerPath, constants.O_RDONLY | NOFOLLOW);
+            const markerStat = fstatSync(descriptor);
+            if (!markerStat.isFile() || markerStat.size > 256)
+                throw new Error('invalid marker file');
+            const actual = readFileSync(descriptor);
+            const expected = expectedMarker(state, path, kind);
+            if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+                throw new Error('invalid marker contents');
+            }
+            return identity;
+        }
+        catch {
+            throw new Error(`invalid managed workspace marker: ${path}`);
+        }
+        finally {
+            if (descriptor !== undefined)
+                closeSync(descriptor);
+        }
+    }
+    authoritativeFixedWorkspaces(root) {
+        const configured = this.canonicalFixedWorkspaceSnapshot();
+        this.assertFixedWorkspaceSnapshotSafe(root, configured);
+        return configured;
+    }
+    canonicalFixedWorkspaceSnapshot() {
+        try {
+            const configured = this.getFixedWorkspaces();
+            if (!Array.isArray(configured))
+                throw new Error('fixed workspace provider must return an array');
+            return Array.from(configured, (path) => {
+                const canonical = realpathSync(path);
+                if (!statSync(canonical).isDirectory())
+                    throw new Error('fixed workspace must be a directory');
+                return canonical;
+            });
+        }
+        catch (error) {
+            if (error instanceof FixedWorkspaceConfigurationError)
+                throw error;
+            throw new FixedWorkspaceConfigurationError('invalid fixed workspace configuration', { cause: error });
+        }
+    }
+    assertFixedWorkspaceSnapshotSafe(root, configured) {
+        for (const canonical of configured) {
+            if (pathsOverlap(root, canonical)) {
+                throw new FixedWorkspaceConfigurationError('fixed workspace overlaps managed root');
+            }
+        }
+    }
+    assertFixedWorkspacesSafe(state) {
+        this.authoritativeFixedWorkspaces(state.root);
+    }
+    requireRootIdentity(state) {
+        const entry = lstatSync(state.root);
+        if (entry.isSymbolicLink() || !entry.isDirectory() || !sameIdentity(identityOf(entry), state.rootIdentity)) {
+            throw new Error('managed workspace root changed');
+        }
+        if (realpathSync(state.root) !== state.root)
+            throw new Error('managed workspace root is not canonical');
+    }
+    exclusive(operation) {
+        const result = this.mutationTail.then(operation);
+        this.mutationTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}
+class FixedWorkspaceConfigurationError extends Error {
+    name = 'FixedWorkspaceConfigurationError';
+}
+function combinedError(primary, cleanup, message) {
+    return new AggregateError([primary, cleanup], `${message}: ${String(primary)}; cleanup: ${String(cleanup)}`, { cause: primary });
+}
+function loadOrCreateOwnerKey(root) {
+    const keyPath = join(root, OWNER_KEY);
+    const candidatePath = join(root, `.${OWNER_KEY}.${randomBytes(24).toString('hex')}.tmp`);
+    const candidateKey = randomBytes(OWNER_KEY_BYTES);
+    let descriptor;
+    let candidateCreated = false;
+    try {
+        descriptor = openSync(candidatePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | NOFOLLOW, 0o600);
+        candidateCreated = true;
+        writeFileSync(descriptor, candidateKey);
+        fchmodSync(descriptor, 0o600);
+        fsyncSync(descriptor);
+        closeSync(descriptor);
+        descriptor = undefined;
+        try {
+            linkSync(candidatePath, keyPath);
+            syncDirectory(root);
+            return candidateKey;
+        }
+        catch (error) {
+            if (!isErrorCode(error, 'EEXIST'))
+                throw error;
+        }
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+        if (candidateCreated) {
+            try {
+                unlinkSync(candidatePath);
+            }
+            catch (error) {
+                if (!isErrorCode(error, 'ENOENT'))
+                    throw error;
+            }
+        }
+    }
+    try {
+        const entry = lstatSync(keyPath);
+        if (entry.isSymbolicLink() || !entry.isFile())
+            throw new Error('invalid owner key');
+        descriptor = openSync(keyPath, constants.O_RDONLY | NOFOLLOW);
+        const opened = fstatSync(descriptor);
+        if (!opened.isFile() || opened.size !== OWNER_KEY_BYTES)
+            throw new Error('invalid owner key');
+        fchmodSync(descriptor, 0o600);
+        return readFileSync(descriptor);
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function expectedMarker(state, path, kind) {
+    const relativePath = relative(state.root, path).split(sep).join('/');
+    const digest = createHmac('sha256', state.ownerKey)
+        .update('gateway-workspace-v1\0')
+        .update(kind)
+        .update('\0')
+        .update(relativePath)
+        .digest('hex');
+    return Buffer.from(`v1:${digest}\n`, 'utf8');
+}
+function ensurePrivateDirectory(path) {
+    try {
+        mkdirSync(path, { mode: 0o700 });
+    }
+    catch (error) {
+        if (!isErrorCode(error, 'EEXIST'))
+            throw error;
+        const entry = lstatSync(path);
+        if (entry.isSymbolicLink() || !entry.isDirectory())
+            throw new Error(`unsafe private directory: ${path}`);
+    }
+    chmodSync(path, 0o700);
+    if (realpathSync(path) !== path)
+        throw new Error(`private directory is not canonical: ${path}`);
+}
+function syncDirectory(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY);
+        fsyncSync(descriptor);
+    }
+    catch (error) {
+        if (!isErrorCode(error, 'EINVAL') && !isErrorCode(error, 'ENOTSUP'))
+            throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function canonicalizeProspectivePath(path) {
+    let current = resolve(path);
+    const missing = [];
+    while (true) {
+        try {
+            return resolve(realpathSync(current), ...missing);
+        }
+        catch (error) {
+            if (!isErrorCode(error, 'ENOENT'))
+                throw error;
+            const parent = dirname(current);
+            if (parent === current)
+                throw error;
+            missing.unshift(basename(current));
+            current = parent;
+        }
+    }
+}
+function directoryIdentity(path) {
+    const entry = lstatSync(path);
+    if (entry.isSymbolicLink() || !entry.isDirectory())
+        throw new Error(`unsafe managed workspace: ${path}`);
+    return identityOf(entry);
+}
+function identityOf(entry) {
+    return { dev: entry.dev, ino: entry.ino };
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function validateComponent(kind, value) {
+    if (!COMPONENT.test(value))
+        throw new Error(`invalid ${kind} id`);
+    return value;
+}
+function cleanupKind(parts) {
+    if (parts.length === 2 && parts[0] === 'responses') {
+        validateComponent('response', parts[1]);
+        return 'response';
+    }
+    if (parts.length === 2 && parts[0] === 'temporary') {
+        validateComponent('run', parts[1]);
+        return 'temporary';
+    }
+    if (parts.length === 4
+        && parts[0] === 'targets'
+        && parts[2] === 'slots'
+        && /^(0|[1-9][0-9]*)$/.test(parts[3])) {
+        validateComponent('target', parts[1]);
+        return 'strict';
+    }
+    return null;
+}
+function isMissingPath(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+function isMissingWorkspacePath(path, error) {
+    if (!isMissingPath(error))
+        return false;
+    try {
+        lstatSync(path);
+        return false;
+    }
+    catch (pathError) {
+        return isMissingPath(pathError);
+    }
+}
+function assertContained(root, path, allowRoot) {
+    if (!isContained(root, path, allowRoot))
+        throw new Error(`workspace path resolves outside managed root: ${path}`);
+}
+function pathsOverlap(left, right) {
+    return isContained(left, right, true) || isContained(right, left, true);
+}
+function isContained(root, path, allowRoot) {
+    const relation = relative(root, path);
+    if (relation === '')
+        return allowRoot;
+    return !isAbsolute(relation) && relation !== '..' && !relation.startsWith(`..${sep}`);
+}
+function isErrorCode(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}
+//# sourceMappingURL=workspaces.js.map