@atolis-hq/wake 0.4.49 → 0.4.50

package/dist/src/bootstrap/composition-root.js

@@ -1,3 +1,4 @@
+import { acquireFileLock } from '@atolis-hq/eventing-filesystem';
 import { createPullRequestService } from '../activities/index.js';
 import { FileArtifactMcpSessionStore, FileArtifactStore, createArtifactService, } from '../artifacts/index.js';
 import { DispatchPolicy, createActivationScheduler, createActivationSchedulerSubscriber, createControlPlaneService, createDurableRunnerIneligibility, createRunnerControlService, } from '../control-plane/index.js';
@@ -63,6 +64,11 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
                 throw new Error('Workspace resource ' + id + ' does not identify a GitHub repository');
             return 'https://github.com/' + match[1] + '.git';
         },
+    }, {
+        tryAcquire: (path) => acquireFileLock(path, {
+            staleAfterMs: 0,
+            staleRequiresDeadProcess: true,
+        }),
     }, undefined, undefined, config.execution.workspaceHooks?.prepare);
     const transcriptStore = config.transcripts.enabled
         ? (options.transcriptStore ?? new TranscriptStore(paths.transcriptsRoot))

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.49";
+export const wakeVersion = "v0.4.50";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/execution/application/execution-validation.js

@@ -7,12 +7,26 @@ export async function acquireWorkspace(runId, mode, workItemId, resources, provi
     if (provider === undefined)
         throw new Error('Workspace provider is required');
     const repositoryResource = resources.find((resource) => resource.kind === BuiltInResourceKind.Repository) ??
-        resources.find((resource) => resource.kind === BuiltInResourceKind.Issue ||
-            resource.kind === BuiltInResourceKind.PullRequest);
+        resources.find((resource) => resource.kind === BuiltInResourceKind.PullRequest) ??
+        resources.find((resource) => resource.kind === BuiltInResourceKind.Issue);
     if (repositoryResource === undefined)
         throw new Error('Repository Resource is required');
     signal.throwIfAborted();
-    return provider.acquire({ runId, signal, mode, workItemId, repositoryResource });
+    const revision = repositoryResource.revision;
+    const checkoutRevision = repositoryResource.kind === BuiltInResourceKind.Repository ||
+        (repositoryResource.kind === BuiltInResourceKind.PullRequest &&
+            revision !== undefined &&
+            /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(revision))
+        ? revision
+        : undefined;
+    return provider.acquire({
+        runId,
+        signal,
+        mode,
+        workItemId,
+        repositoryResource,
+        ...(checkoutRevision === undefined ? {} : { checkoutRevision }),
+    });
 }
 export function validateResourceRequirements(requirements, resources) {
     for (const requirement of requirements) {

package/dist/src/execution/contracts/workspace.d.ts

@@ -9,6 +9,8 @@ export interface WorkspaceRequest {
     readonly mode: typeof WorkspaceMode.ReadOnly | typeof WorkspaceMode.Branch;
     readonly workItemId: WorkItemId;
     readonly repositoryResource: ResourceView;
+    /** Git checkout target, independent of the resource observation revision. */
+    readonly checkoutRevision?: string;
 }
 export interface WorkspaceLease {
     readonly workspaceId: string;
@@ -16,7 +18,7 @@ export interface WorkspaceLease {
     /** Branch actually checked out for this lease, when the provider can attest it. */
     readonly branch?: string | undefined;
     readonly mode: WorkspaceRequest['mode'];
-    /** Ends this Run's use of the workspace; branch-workspace disposal is WorkItem-scoped recovery. */
+    /** Ends this Run's use of the workspace; workspace disposal is WorkItem-scoped recovery. */
     release(): Promise<void>;
 }
 export interface WorkspaceProvider {
@@ -46,3 +48,11 @@ export interface WorkspaceRecoveryFailure {
     readonly path: string;
     readonly message: string;
 }
+/** Process-owned exclusion shared by acquisition and recovery. */
+export interface WorkspaceLockProvider {
+    tryAcquire(path: string): Promise<WorkspaceLock>;
+}
+export interface WorkspaceLock {
+    readonly acquired: boolean;
+    release(): Promise<void>;
+}

package/dist/src/execution/infrastructure/workspace/git-workspace.d.ts

@@ -1,11 +1,10 @@
-import type { WorkItemId } from '../../../work/index.js';
 import type { RunView } from '../../contracts/views.js';
-import type { WorkspaceProvider, WorkspaceRecovery, WorkspaceRecoveryOptions, WorkspaceRecoveryResult, WorkspaceRequest } from '../../contracts/workspace.js';
+import type { WorkspaceLockProvider, WorkspaceProvider, WorkspaceRecovery, WorkspaceRecoveryOptions, WorkspaceRecoveryResult, WorkspaceRequest } from '../../contracts/workspace.js';
 import { type WorkspacePrepareHook } from './prepare-workspace.js';
 export interface RepositoryCloneResolver {
     cloneLocator(resourceId: string, signal: AbortSignal): Promise<string>;
 }
-export type GitRunner = (arguments_: readonly string[], signal: AbortSignal) => Promise<void>;
+export type GitRunner = (arguments_: readonly string[], signal: AbortSignal) => Promise<string | void>;
 export interface WorkspaceRecoveryFileSystem {
     remove(path: string): Promise<void>;
     canonicalize(path: string): Promise<string>;
@@ -13,17 +12,23 @@ export interface WorkspaceRecoveryFileSystem {
 export declare class GitWorkspaceProvider implements WorkspaceProvider, WorkspaceRecovery {
     private readonly root;
     private readonly resolver;
+    private readonly locks;
     private readonly git;
     private readonly prepareHook?;
     private readonly markerRoot;
     private readonly recoveryFileSystem;
-    constructor(root: string, resolver: RepositoryCloneResolver, git?: GitRunner, recoveryFileSystem?: WorkspaceRecoveryFileSystem, prepareHook?: WorkspacePrepareHook);
+    private readonly pendingReleases;
+    constructor(root: string, resolver: RepositoryCloneResolver, locks: WorkspaceLockProvider, git?: GitRunner, recoveryFileSystem?: WorkspaceRecoveryFileSystem, prepareHook?: WorkspacePrepareHook);
     acquire(request: WorkspaceRequest): Promise<{
         release: () => Promise<void>;
-        branch?: WorkItemId;
+        branch?: string;
         workspaceId: string;
         path: string;
         mode: "read-only" | "branch";
     }>;
+    private releaseWorkspaceLock;
+    private prepareCheckout;
+    private reuseCheckout;
+    private validateLegacyCheckout;
     recover(runs: readonly RunView[], options?: WorkspaceRecoveryOptions): Promise<WorkspaceRecoveryResult>;
 }

package/dist/src/execution/infrastructure/workspace/git-workspace.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import { execFile } from 'node:child_process';
-import { access, mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { access, mkdir, readdir, readFile, realpath, rename, rm, rmdir, unlink, writeFile, } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { isActiveRunStatus, RunStatus, WorkspaceMode } from '../../contracts/vocabulary.js';
@@ -9,18 +9,21 @@ const exec = promisify(execFile);
 export class GitWorkspaceProvider {
     root;
     resolver;
+    locks;
     git;
     prepareHook;
     markerRoot;
     recoveryFileSystem;
-    constructor(root, resolver, git = async (arguments_, signal) => {
-        await exec('git', arguments_, { signal });
+    pendingReleases = new Map();
+    constructor(root, resolver, locks, git = async (arguments_, signal) => {
+        return (await exec('git', arguments_, { signal })).stdout.trim();
     }, recoveryFileSystem = {
         remove: async (path) => rm(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }),
         canonicalize: realpath,
     }, prepareHook) {
         this.root = root;
         this.resolver = resolver;
+        this.locks = locks;
         this.git = git;
         this.prepareHook = prepareHook;
         this.markerRoot = join(this.root, '.wake-workspace-ownership');
@@ -34,59 +37,161 @@ export class GitWorkspaceProvider {
         const name = `${request.workItemId}-${request.mode}-${slug(locator)}`;
         const path = resolve(this.root, name);
         const markerPath = join(this.markerRoot, `${name}.json`);
+        const lockPath = join(this.markerRoot, `${name}.lease`);
         await mkdir(dirname(markerPath), { recursive: true });
+        const scope = await recoveryScope(this.root, this.markerRoot);
+        if (scope === null)
+            throw new Error('Workspace ownership directory is outside the managed root');
+        await validateLeasePaths(scope, lockPath);
+        const lock = await acquireWorkspaceLock(this.locks, lockPath, signal);
+        try {
+            const branch = await this.prepareCheckout(request, locator, name, path, markerPath);
+            if (this.prepareHook !== undefined)
+                await prepareWorkspace(path, this.prepareHook, signal);
+            signal.throwIfAborted();
+            let released = false;
+            return {
+                workspaceId: name,
+                path,
+                mode: request.mode,
+                ...(branch === undefined ? {} : { branch }),
+                release: async () => {
+                    if (released)
+                        return;
+                    await this.releaseWorkspaceLock(lockPath, lock);
+                    released = true;
+                },
+            };
+        }
+        catch (error) {
+            await this.releaseWorkspaceLock(lockPath, lock);
+            throw error;
+        }
+    }
+    async releaseWorkspaceLock(path, lock) {
+        try {
+            await lock.release();
+            if (this.pendingReleases.get(path) === lock)
+                this.pendingReleases.delete(path);
+        }
+        catch (error) {
+            this.pendingReleases.set(path, lock);
+            throw error;
+        }
+    }
+    async prepareCheckout(request, locator, name, path, markerPath) {
+        const { signal } = request;
+        const previousMarker = await readMarker(markerPath);
+        if (await exists(join(this.markerRoot, `${name}.lock`), signal))
+            throw new Error('Legacy workspace lock requires recovery before acquisition');
+        let initialRevision = previousMarker?.initialRevision;
+        let checkoutReady;
         signal.throwIfAborted();
-        await writeFile(markerPath, JSON.stringify({
+        const writeMarker = () => writeOwnershipMarker(markerPath, {
             runId: request.runId,
             workItemId: request.workItemId,
             repositoryResourceId: request.repositoryResource.resourceId,
             mode: request.mode,
             workspaceId: name,
             path,
-        }), { encoding: 'utf8', signal });
-        const existingWorkspace = await exists(join(path, '.git'), signal);
+            checkoutReady,
+            ...(initialRevision === undefined ? {} : { initialRevision }),
+        }, signal);
+        const existingWorkspace = await this.reuseCheckout(previousMarker, markerPath, path, request.mode, signal);
+        checkoutReady = previousMarker?.checkoutReady ?? existingWorkspace;
+        if (!existingWorkspace) {
+            initialRevision = undefined;
+            checkoutReady = false;
+        }
+        await writeMarker();
         if (!existingWorkspace) {
             await mkdir(dirname(path), { recursive: true });
             signal.throwIfAborted();
             await this.git(['clone', locator, path], signal);
         }
+        if (initialRevision === undefined)
+            initialRevision = await readCheckoutRevision(path, this.git, signal);
         const branch = request.mode === WorkspaceMode.Branch ? request.workItemId : undefined;
-        if (branch !== undefined)
+        if (branch !== undefined) {
             await this.git(['-C', path, 'switch', ...(existingWorkspace ? [] : ['--create']), branch], signal);
-        if (this.prepareHook !== undefined)
-            await prepareWorkspace(path, this.prepareHook, signal);
-        signal.throwIfAborted();
-        return {
-            workspaceId: name,
-            path,
-            mode: request.mode,
-            ...(branch === undefined ? {} : { branch }),
-            release: async () => {
-                if (request.mode !== WorkspaceMode.ReadOnly)
-                    return;
-                await rm(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
-                await rm(markerPath, { force: true });
-            },
-        };
+        }
+        checkoutReady = true;
+        await writeMarker();
+        if (branch === undefined) {
+            await restoreReadOnlyWorkspace(path, request.checkoutRevision, initialRevision, this.git, signal);
+        }
+        return branch;
+    }
+    async reuseCheckout(marker, markerPath, path, mode, signal) {
+        if (!(await exists(path, signal)))
+            return false;
+        const scope = await recoveryScope(this.root, this.markerRoot);
+        if (scope === null ||
+            marker === null ||
+            !(await isOwnedWorkspace(scope, markerPath, marker, this.recoveryFileSystem)) ||
+            !(await canRemoveOwnedWorkspace(scope, path)))
+            throw new Error('Cannot acquire an unvalidated existing workspace');
+        if (marker.checkoutReady === false) {
+            await this.recoveryFileSystem.remove(path);
+            return false;
+        }
+        if (!(await exists(join(path, '.git'), signal))) {
+            if (mode === WorkspaceMode.Branch)
+                throw new Error('Cannot reuse a branch checkout without Git metadata');
+            await this.recoveryFileSystem.remove(path);
+            return false;
+        }
+        return this.validateLegacyCheckout(marker, path, mode, signal);
+    }
+    async validateLegacyCheckout(marker, path, mode, signal) {
+        if (marker.checkoutReady !== undefined || mode !== WorkspaceMode.ReadOnly)
+            return true;
+        try {
+            await readCheckoutRevision(path, this.git, signal);
+            return true;
+        }
+        catch {
+            signal.throwIfAborted();
+            // Legacy read-only clones may predate the durable completion flag.
+            await this.recoveryFileSystem.remove(path);
+            return false;
+        }
     }
     async recover(runs, options = {}) {
         const scope = await recoveryScope(this.root, this.markerRoot);
         if (scope === null)
             return emptyRecovery();
-        const markers = await recoveryMarkerNames(this.markerRoot);
+        const releaseFailures = [];
+        for (const [path, lock] of this.pendingReleases) {
+            if (await options.isPaused?.())
+                break;
+            try {
+                await this.releaseWorkspaceLock(path, lock);
+            }
+            catch (error) {
+                releaseFailures.push({ markerPath: path, path, message: errorMessage(error) });
+            }
+        }
+        const names = await recoveryMarkerNames(this.markerRoot);
+        const workspaceIds = new Set(names.flatMap((name) => {
+            const match = /^(.*)\.(?:json(?:\.pending)?|lock|lease(?:\.owners)?)$/.exec(name);
+            return match !== null && isSafeWorkspaceId(match[1]) ? [match[1]] : [];
+        }));
         let reclaimed = 0;
         const reclaimedWorkItemIds = [];
-        const failures = [];
-        for (const filename of markers) {
+        const failures = [...releaseFailures];
+        for (const workspaceId of workspaceIds) {
             if (await options.isPaused?.())
                 break;
-            const result = await recoverMarker({
-                filename,
+            const result = await recoverWorkspace({
+                workspaceId,
                 markerRoot: this.markerRoot,
                 scope,
                 runs,
                 fileSystem: this.recoveryFileSystem,
                 options,
+                locks: this.locks,
+                releaseLock: (path, lock) => this.releaseWorkspaceLock(path, lock),
             });
             reclaimed += result.reclaimed;
             reclaimedWorkItemIds.push(...(result.reclaimedWorkItemIds ?? []));
@@ -113,13 +218,40 @@ async function recoveryMarkerNames(markerRoot) {
         return [];
     }
 }
-async function recoverMarker(input) {
-    if (!input.filename.endsWith('.json'))
-        return emptyRecovery();
-    const markerPath = join(input.markerRoot, input.filename);
-    const marker = await readMarker(markerPath);
+async function validateLeasePaths(scope, path) {
+    for (const target of [
+        path,
+        `${path}.owners`,
+        `${path.slice(0, -'.lease'.length)}.lock`,
+        `${path.slice(0, -'.lease'.length)}.json.pending`,
+    ]) {
+        const canonical = await canonicalPath(target);
+        if (canonical !== null && canonical !== join(scope.markerRoot, basename(target)))
+            throw new Error('Workspace lease artifacts must not be symbolic links');
+    }
+}
+async function recoverWorkspace(input) {
+    const markerPath = join(input.markerRoot, `${input.workspaceId}.json`);
+    let marker = null;
     try {
-        return await reclaimOwnedMarker(input, markerPath, marker);
+        const lockPath = join(input.markerRoot, `${input.workspaceId}.lease`);
+        await validateLeasePaths(input.scope, lockPath);
+        const lock = await input.locks.tryAcquire(lockPath);
+        if (!lock.acquired)
+            return emptyRecovery();
+        try {
+            if (!(await recoverLegacyLock(join(input.markerRoot, `${input.workspaceId}.lock`), input.runs)))
+                return emptyRecovery();
+            await rm(`${markerPath}.pending`, { force: true });
+            marker = await readMarker(markerPath);
+            if (marker === null ||
+                !(await isOwnedWorkspace(input.scope, markerPath, marker, input.fileSystem)))
+                return emptyRecovery();
+            return await reclaimUnlockedMarker(input, markerPath, marker);
+        }
+        finally {
+            await input.releaseLock(lockPath, lock);
+        }
     }
     catch (error) {
         return {
@@ -128,10 +260,35 @@ async function recoverMarker(input) {
         };
     }
 }
-async function reclaimOwnedMarker(input, markerPath, marker) {
-    if (marker === null ||
-        !(await isOwnedWorkspace(input.scope, markerPath, marker, input.fileSystem)))
-        return emptyRecovery();
+// Migration only: new acquisitions never create directory locks.
+async function recoverLegacyLock(path, runs) {
+    if ((await canonicalPath(path)) === null)
+        return true;
+    const owner = await readLockOwner(path);
+    if (owner === undefined)
+        return false;
+    if (owner === null && runs.some(protectsWorkspace))
+        return false;
+    if (owner !== null && runs.some((run) => run.runId === owner && protectsWorkspace(run)))
+        return false;
+    if (owner !== null)
+        await unlink(join(path, owner));
+    try {
+        await rmdir(path);
+        return true;
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return true;
+        if (isNotEmpty(error))
+            return false;
+        throw error;
+    }
+}
+function protectsWorkspace(run) {
+    return isActiveRunStatus(run.status) || run.status === RunStatus.Ambiguous;
+}
+async function reclaimUnlockedMarker(input, markerPath, marker) {
     if (input.runs.some((run) => (isActiveRunStatus(run.status) || run.status === RunStatus.Ambiguous) &&
         (run.runId === marker.runId || run.workspace?.path === marker.path)))
         return emptyRecovery();
@@ -143,6 +300,7 @@ async function reclaimOwnedMarker(input, markerPath, marker) {
         await input.fileSystem.remove(marker.path);
     if ((await input.options.onWorkspaceReclaimed?.(marker.workItemId)) === false)
         return emptyRecovery();
+    await rm(`${markerPath}.pending`, { force: true });
     await rm(markerPath, { force: true });
     return {
         reclaimed: 1,
@@ -182,7 +340,12 @@ function isOwnershipMarker(value) {
         typeof marker.repositoryResourceId === 'string' &&
         (marker.mode === WorkspaceMode.ReadOnly || marker.mode === WorkspaceMode.Branch) &&
         typeof marker.workspaceId === 'string' &&
-        typeof marker.path === 'string');
+        typeof marker.path === 'string' &&
+        hasValidCheckoutState(marker));
+}
+function hasValidCheckoutState(marker) {
+    return ((marker.initialRevision === undefined || typeof marker.initialRevision === 'string') &&
+        (marker.checkoutReady === undefined || typeof marker.checkoutReady === 'boolean'));
 }
 async function isOwnedWorkspace(scope, markerPath, marker, fileSystem) {
     if (!isSafeWorkspaceId(marker.workspaceId))
@@ -248,6 +411,75 @@ async function exists(path, signal) {
         return false;
     }
 }
+async function restoreReadOnlyWorkspace(path, revision, initialRevision, git, signal) {
+    if (revision !== undefined) {
+        await git(['-C', path, 'fetch', 'origin', revision], signal);
+        const fetched = await readGitRevision(path, 'FETCH_HEAD^{commit}', git, signal);
+        await git(['-C', path, 'checkout', '--detach', '--force', fetched], signal);
+        await git(['-C', path, 'reset', '--hard', fetched], signal);
+        return;
+    }
+    await git(['-C', path, 'reset', '--hard', initialRevision], signal);
+}
+async function readCheckoutRevision(path, git, signal) {
+    return readGitRevision(path, 'HEAD^{commit}', git, signal);
+}
+async function readGitRevision(path, reference, git, signal) {
+    const revision = await git(['-C', path, 'rev-parse', '--verify', reference], signal);
+    if (typeof revision !== 'string' || revision.trim() === '')
+        throw new Error('Git runner did not attest a valid workspace HEAD');
+    return revision.trim();
+}
+async function writeOwnershipMarker(path, marker, signal) {
+    const pending = `${path}.pending`;
+    try {
+        await writeFile(pending, JSON.stringify(marker), { encoding: 'utf8', signal });
+        signal.throwIfAborted();
+        await rename(pending, path);
+    }
+    finally {
+        await rm(pending, { force: true });
+    }
+}
+async function acquireWorkspaceLock(locks, path, signal) {
+    while (true) {
+        signal.throwIfAborted();
+        const lock = await locks.tryAcquire(path);
+        if (lock.acquired)
+            return lock;
+        await waitForLock(signal);
+    }
+}
+async function readLockOwner(path) {
+    try {
+        const owners = await readdir(path);
+        if (owners.length === 0)
+            return null;
+        return owners.length === 1 ? owners[0] : undefined;
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return null;
+        throw error;
+    }
+}
+function isNotEmpty(error) {
+    return (typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOTEMPTY');
+}
+function waitForLock(signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(done, 25);
+        const abort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        function done() {
+            signal.removeEventListener('abort', abort);
+            resolve();
+        }
+        signal.addEventListener('abort', abort, { once: true });
+    });
+}
 function slug(value) {
     return value
         .toLowerCase()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.4.49",
+  "version": "0.4.50",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {