@playcraft/cli 0.1.54 → 0.1.55-beta

package/dist/workspace-runtime/workspaces/dependencies.js

@@ -0,0 +1,279 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFile, lstat, mkdir, open, readFile, stat, writeFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { setTimeout as delay } from 'node:timers/promises';
+import { join } from 'node:path';
+import { launcherSocket, runDeveloperCommand } from './developer-command.js';
+/** Long enough for a cold store on a game template; a stuck registry must not hold the write lease. */
+const INSTALL_TIMEOUT_MS = 10 * 60_000;
+const LOG_TAIL_LINES = 50;
+const LOG_TAIL_MAX_CHARS = 8_000;
+const WRITE_PREFIX = 'dependencies-';
+const SHARE_WAIT_MS = 60_000;
+/**
+ * Projects are managed with pnpm. Installation can create or update pnpm-lock.yaml, never
+ * prompts, and writes plain lines to the log. Package scripts run: the workspace is the user's own
+ * sandbox and the install runs as the development user.
+ */
+const INSTALL_COMMAND = 'pnpm install --no-frozen-lockfile --store-dir /var/cache/playcraft/pnpm-store --reporter=append-only --config.confirm-modules-purge=false';
+/** Installs whenever there is a package.json; the hash says whether a finished install is current. */
+export async function planInstall(root) {
+    const manifest = await readOptional(join(root, 'package.json'));
+    if (manifest === undefined)
+        return { kind: 'skip' };
+    const lock = (await readOptional(join(root, 'pnpm-lock.yaml'))) ?? '';
+    return {
+        kind: 'install',
+        lockHash: createHash('sha256').update(manifest).update('\0').update(lock).digest('hex'),
+    };
+}
+const running = new WeakMap();
+/**
+ * Starts the install after a workspace is registered; opening the workspace never waits for it.
+ * Registering again retries a failed install and reinstalls after the manifest or lockfile
+ * changed. One install runs per workspace at a time: the same directory shares its task; another
+ * directory waits for it before installing. The returned task covers the requested directory.
+ */
+export function scheduleDependencyInstall(state, workspaceId, root, shouldStart) {
+    const inFlight = running.get(state) ?? new Map();
+    running.set(state, inFlight);
+    const existing = inFlight.get(workspaceId);
+    if (existing?.root === root) {
+        if (!shouldStart)
+            existing.guards = undefined;
+        else
+            existing.guards?.push(shouldStart);
+        return existing.task;
+    }
+    const scheduled = { root, task: Promise.resolve(), guards: shouldStart ? [shouldStart] : undefined };
+    const begin = () => {
+        if (state.journal.destroyed() || (scheduled.guards && !scheduled.guards.some((guard) => guard())))
+            return;
+        return installOnce(state, workspaceId, root);
+    };
+    const task = (existing ? existing.task.then(begin) : begin() ?? Promise.resolve())
+        .catch((error) => {
+        console.error(`[workspace-runtime] dependency install for ${workspaceId} failed to run`, error);
+    })
+        .finally(() => { if (inFlight.get(workspaceId)?.task === task)
+        inFlight.delete(workspaceId); });
+    scheduled.task = task;
+    inFlight.set(workspaceId, scheduled);
+    return task;
+}
+/** Settles every install started in this process; used by tests and shutdown. */
+export async function settleDependencyInstalls(state) {
+    while (running.get(state)?.size) {
+        await Promise.all([...(running.get(state)?.values() ?? [])].map((record) => record.task));
+    }
+}
+export function readDependencies(state, workspaceId) {
+    return state.journal.getWorkspaceDependencies(workspaceId) ?? { workspaceId, status: 'pending' };
+}
+/**
+ * Makes the install finish before a build reads the checkout. The install is skipped when the
+ * manifest and lockfile already match; otherwise the returned task covers the whole install.
+ */
+export async function ensureWorkspaceDependencies(state, workspaceId, root) {
+    await scheduleDependencyInstall(state, workspaceId, root);
+    const dependencies = readDependencies(state, workspaceId);
+    if (dependencies.status === 'ready' || dependencies.status === 'none')
+        return { ok: true };
+    return {
+        ok: false,
+        error: dependencies.error ?? 'dependencies_not_ready',
+        ...(dependencies.logTail ? { logTail: dependencies.logTail } : {}),
+    };
+}
+/**
+ * An install cut off by a restart left no process behind (the launcher stops the group when its
+ * connection closes), so its status and write lease are closed rather than left in progress.
+ */
+export async function recoverInterruptedInstalls(journal) {
+    const now = new Date().toISOString();
+    for (const record of journal.listWorkspaceDependencies()) {
+        if (record.status !== 'installing')
+            continue;
+        await journal.putWorkspaceDependencies({
+            ...record,
+            status: 'failed',
+            error: 'interrupted',
+            finishedAt: now,
+        });
+    }
+    for (const write of journal.listManagedWrites()) {
+        if (write.writeId.startsWith(WRITE_PREFIX) && !write.stoppedAt) {
+            await journal.putManagedWrite({ ...write, stoppedAt: now });
+        }
+    }
+}
+async function installOnce(state, workspaceId, root) {
+    const plan = await planInstall(root);
+    const current = state.journal.getWorkspaceDependencies(workspaceId);
+    if (plan.kind === 'skip') {
+        if (current?.status !== 'none') {
+            await state.journal.putWorkspaceDependencies({
+                workspaceId,
+                status: 'none',
+                finishedAt: new Date().toISOString(),
+            });
+        }
+        return;
+    }
+    if (current?.status === 'ready' &&
+        current.lockHash === plan.lockHash &&
+        (await isDirectory(join(root, 'node_modules')))) {
+        return;
+    }
+    await excludeFromGit(root);
+    const startedAt = new Date().toISOString();
+    const writeId = `${WRITE_PREFIX}${workspaceId}-${randomUUID()}`;
+    // A checkpoint waits for this write: node_modules is half written until the install ends.
+    await state.journal.putManagedWrite({ writeId, workspaceId, source: 'background', startedAt });
+    await state.journal.putWorkspaceDependencies({
+        workspaceId,
+        status: 'installing',
+        startedAt,
+    });
+    let outcome;
+    try {
+        // Through the launcher the install runs as the development group, which cannot enter the
+        // checkout until Runtime has opened it; a local install runs as the owner and need not wait.
+        const shared = !launcherSocket(state) || (await waitUntilShared(root));
+        outcome = shared
+            ? await runInstall(state, workspaceId, root)
+            : { code: undefined, timedOut: false, log: '', error: 'workspace_not_shared' };
+    }
+    finally {
+        await state.journal.putManagedWrite({
+            writeId,
+            workspaceId,
+            source: 'background',
+            startedAt,
+            stoppedAt: new Date().toISOString(),
+        });
+    }
+    const ok = outcome.code === 0 && !outcome.timedOut;
+    await state.journal.putWorkspaceDependencies({
+        workspaceId,
+        status: ok ? 'ready' : 'failed',
+        ...(ok
+            ? { lockHash: plan.lockHash }
+            : {
+                error: outcome.error ??
+                    (outcome.timedOut ? 'install_timeout' : `install_exit_${outcome.code ?? 'lost'}`),
+            }),
+        startedAt,
+        finishedAt: new Date().toISOString(),
+        logTail: tail(outcome.log),
+    });
+}
+/**
+ * Runs as the development user through the launcher, so the packages belong to the same user as
+ * Codex and its own later installs. Without a launcher (local runs and tests) it runs directly.
+ */
+async function runInstall(state, workspaceId, root) {
+    // Tests replace the install; a real registry is never reached from them.
+    const store = process.env.PLAYCRAFT_PNPM_STORE ?? (process.platform === 'linux' ? '/var/cache/playcraft/pnpm-store' : join(state.config.stateDir, 'pnpm-store'));
+    const quotedStore = `'${store.replaceAll("'", "'\\''")}'`;
+    const planned = process.env.PLAYCRAFT_DEPENDENCY_INSTALL_COMMAND || INSTALL_COMMAND.replace('/var/cache/playcraft/pnpm-store', quotedStore);
+    const logDir = join(state.config.stateDir, 'dependency-logs');
+    await mkdir(logDir, { recursive: true, mode: 0o700 });
+    const logPath = join(logDir, `${workspaceId}.log`);
+    await writeFile(logPath, `$ ${planned}\n`, { mode: 0o600 });
+    let log = '';
+    let pending = Promise.resolve();
+    const outcome = await runDeveloperCommand(state, {
+        processId: `${WRITE_PREFIX}${workspaceId}`,
+        cwd: root,
+        command: planned,
+        timeoutMs: INSTALL_TIMEOUT_MS,
+        onOutput: (chunk) => {
+            const text = String(chunk);
+            log = (log + text).slice(-64 * 1024);
+            pending = pending.then(() => appendFile(logPath, text)).catch(() => undefined);
+        },
+    });
+    await pending;
+    return { ...outcome, log };
+}
+/**
+ * The checkout is cloned private to the control user and opened to the development group by
+ * Runtime after registration. Group read, write and search on the root is the sign it is open.
+ */
+export async function waitUntilShared(root, timeoutMs = SHARE_WAIT_MS, intervalMs = 500) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            if (((await stat(root)).mode & 0o070) === 0o070)
+                return true;
+        }
+        catch {
+            /* not there yet */
+        }
+        if (Date.now() >= deadline)
+            return false;
+        await delay(intervalMs);
+    }
+}
+/** A local-only ignore, never committed: the change list must not fill up with installed packages. */
+/** Keeps sandbox-managed folders out of the Git panel without touching the project's .gitignore. */
+export async function excludeFromGit(root, entry = '/node_modules/') {
+    const flags = constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+    const handles = [];
+    let file;
+    try {
+        const directory = await open(root, flags);
+        handles.push(directory);
+        const pinned = (handle, fallback) => process.platform === 'linux' ? `/proc/self/fd/${handle.fd}` : fallback;
+        const rootPath = pinned(directory, root);
+        const git = await open(join(rootPath, '.git'), flags).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (!git)
+            return;
+        handles.push(git);
+        const gitPath = pinned(git, join(root, '.git'));
+        await mkdir(join(gitPath, 'info')).catch((error) => {
+            if (error.code !== 'EEXIST')
+                throw error;
+        });
+        const info = await open(join(gitPath, 'info'), flags);
+        handles.push(info);
+        file = await open(join(pinned(info, join(root, '.git/info')), 'exclude'), constants.O_RDWR | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o666);
+        const metadata = await file.stat();
+        if (!metadata.isFile() || metadata.nlink !== 1 || metadata.size > 1024 * 1024) {
+            throw new Error('invalid_git_exclude');
+        }
+        const current = await file.readFile('utf8');
+        if (!current.split('\n').some((line) => line.trim() === entry)) {
+            await file.writeFile(`${current && !current.endsWith('\n') ? '\n' : ''}${entry}\n`);
+        }
+    }
+    finally {
+        await file?.close();
+        for (const handle of handles.reverse())
+            await handle.close();
+    }
+}
+function tail(log) {
+    return log.split('\n').slice(-LOG_TAIL_LINES).join('\n').slice(-LOG_TAIL_MAX_CHARS);
+}
+async function readOptional(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+async function isDirectory(path) {
+    try {
+        return (await lstat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/workspace-runtime/workspaces/developer-command.js

@@ -0,0 +1,98 @@
+import { spawn } from 'node:child_process';
+import { startLauncherProcess } from '../codex/launcher-client.js';
+export function launcherSocket(state) {
+    const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+    return socketPath && state.config.workspaceMode === 'multi' ? socketPath : undefined;
+}
+/**
+ * Runs a shell command in the workspace as the development user through the launcher, so whatever
+ * it writes belongs to the same user as Codex. Without a launcher (local runs and tests) it runs
+ * directly as the owner. Output from both streams goes to `onOutput`.
+ */
+export async function runDeveloperCommand(state, input) {
+    if (input.signal?.aborted)
+        return { code: null, timedOut: false, canceled: true };
+    const command = `{ ${input.command}; } </dev/null 2>&1`;
+    const socketPath = launcherSocket(state);
+    const launched = socketPath
+        ? await startLauncherProcess({
+            socketPath,
+            processId: input.processId,
+            runtimeEpoch: state.runtimeEpoch,
+            argv: ['/usr/bin/bash', '-lc', command],
+            cwd: input.cwd,
+            env: {},
+        })
+        : undefined;
+    launched?.stdin?.end();
+    const local = launched
+        ? undefined
+        : spawn('bash', ['-lc', command], {
+            cwd: input.cwd,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    const stdout = launched?.stdout ?? local.stdout;
+    const stderr = launched?.stderr ?? local.stderr;
+    stdout.on('data', input.onOutput);
+    stderr.on('data', input.onOutput);
+    let timedOut = false;
+    let canceled = false;
+    let killTimer;
+    const abort = () => {
+        if (canceled || timedOut)
+            return;
+        canceled = true;
+        if (launched) {
+            void launched.stop().catch(() => undefined);
+            return;
+        }
+        if (!local?.pid)
+            return;
+        try {
+            process.kill(-local.pid, 'SIGTERM');
+        }
+        catch {
+            /* already gone */
+        }
+        killTimer = setTimeout(() => {
+            try {
+                process.kill(-local.pid, 'SIGKILL');
+            }
+            catch {
+                /* already gone */
+            }
+        }, 5_000);
+        killTimer.unref?.();
+    };
+    input.signal?.addEventListener('abort', abort, { once: true });
+    const code = await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            timedOut = true;
+            if (launched)
+                void launched.stop().catch(() => undefined);
+            else if (local?.pid) {
+                try {
+                    process.kill(-local.pid, 'SIGKILL');
+                }
+                catch {
+                    /* already gone */
+                }
+            }
+        }, input.timeoutMs);
+        const finish = (value) => {
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            input.signal?.removeEventListener('abort', abort);
+            resolve(value);
+        };
+        if (launched)
+            launched.onExit(finish);
+        else {
+            local.once('error', () => finish(null));
+            local.once('close', (value) => finish(value));
+        }
+    });
+    return { code, timedOut, ...(canceled ? { canceled: true } : {}) };
+}

package/dist/workspace-runtime/workspaces/directories.js

@@ -0,0 +1,135 @@
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { lstat, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { workspaceDirectoryRegistrationSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceContainerRoot, workspaceRoot, WorkspaceContextError } from './registry.js';
+import { openDirectoryToDevelopment } from './directory-access.js';
+import { prepareWorkspaceCheckout } from './prepare.js';
+import { readDependencies, scheduleDependencyInstall } from './dependencies.js';
+import { revisionScope } from './registry.js';
+import { ensureWorkspaceSkills } from './skills.js';
+import { checkoutBatchCommit, freezeBatchCommit } from './batch-commit.js';
+import { ensureWorkspaceArtifactInstructions } from './instructions.js';
+import { shareWorkspaceRepository } from './git.js';
+import { checkoutChatWorktree } from './worktree-checkout.js';
+const execute = promisify(execFile);
+/** Trusted Runtime registration restores immutable input; it never follows basic's current branch head. */
+export async function registerWorkspaceDirectory(state, input, leaseFence, sourceDirectoryName, worktree = false) {
+    const directory = workspaceDirectoryRegistrationSchema.parse(input);
+    if (directory.directoryName === 'basic')
+        throw new WorkspaceContextError('workspace_directory_binding_conflict');
+    return state.journal.exclusive(`directory:${directory.workspaceId}:${directory.directoryName}`, async () => {
+        if (state.journal.destroyed())
+            throw new WorkspaceContextError('runtime_destroyed');
+        if (leaseFence < state.acceptedLeaseFence)
+            throw new WorkspaceContextError('stale_lease');
+        const binding = state.journal.getWorkspace(directory.workspaceId);
+        if (!binding)
+            throw new WorkspaceContextError('workspace_not_registered');
+        const existing = binding.directories?.find(item => item.directoryName === directory.directoryName);
+        if (existing && (existing.remixId !== directory.remixId || existing.branchName !== directory.branchName || (existing.sourceCommit !== undefined && existing.sourceCommit !== directory.sourceCommit)))
+            throw new WorkspaceContextError('workspace_directory_binding_conflict');
+        const parent = await workspaceContainerRoot(state, directory.workspaceId);
+        const root = join(parent, directory.directoryName);
+        const git = async (cwd, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'credential.helper=', '-c', 'core.fsmonitor=false', '-C', cwd, ...args], {
+            timeout: 90_000, maxBuffer: 1024 * 1024,
+            env: { PATH: process.env.PATH, HOME: state.config.stateDir, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
+        })).stdout.trim();
+        const stat = await lstat(root).catch(() => undefined);
+        if (stat) {
+            if (!stat.isDirectory() || stat.isSymbolicLink() || await git(root, 'symbolic-ref', '--short', 'HEAD') !== directory.branchName
+                || (binding.repositoryUrl !== null && await git(root, 'config', '--get', 'remote.origin.url') !== binding.repositoryUrl))
+                throw new WorkspaceContextError('workspace_checkout_mismatch');
+        }
+        else {
+            if (existing && existing.status !== 'pending')
+                throw new WorkspaceContextError('workspace_recovery_required');
+            if (!directory.sourceCommit)
+                throw new WorkspaceContextError('workspace_directory_source_commit_required');
+            const staging = join(parent, `.directory-${randomUUID()}`);
+            try {
+                const source = await workspaceRoot(state, directory.workspaceId, sourceDirectoryName ?? 'basic');
+                await git(source, 'cat-file', '-e', `${directory.sourceCommit}^{commit}`);
+                if (worktree)
+                    await checkoutChatWorktree(source, staging, directory.sourceCommit, state.config.stateDir);
+                else if (sourceDirectoryName !== undefined) {
+                    const frozen = await freezeBatchCommit({ source: { workspaceId: directory.workspaceId, root: source },
+                        commitHash: directory.sourceCommit, snapshotId: `directory-${directory.remixId}` });
+                    await checkoutBatchCommit({ source: { workspaceId: directory.workspaceId, root: source }, frozen, destination: staging });
+                }
+                else
+                    await execute('git', ['-c', 'core.hooksPath=/dev/null', 'clone', '--local', '--no-hardlinks', '--no-checkout', '--', source, staging], { timeout: 90_000, maxBuffer: 1024 * 1024 });
+                await git(staging, 'checkout', '-b', directory.branchName, directory.sourceCommit);
+                if (binding.repositoryUrl)
+                    await git(staging, 'remote', 'set-url', 'origin', binding.repositoryUrl);
+                else
+                    await git(staging, 'remote', 'remove', 'origin').catch(() => undefined);
+                await git(staging, 'config', 'user.name', 'PlayCraft');
+                await git(staging, 'config', 'user.email', 'playcraft@localhost');
+                await git(staging, 'config', 'core.sharedRepository', 'group');
+                await ensureWorkspaceSkills(staging, join(state.config.stateDir, 'skill-artifacts'));
+                if (leaseFence < state.acceptedLeaseFence)
+                    throw new WorkspaceContextError('stale_lease');
+                await rename(staging, root);
+            }
+            finally {
+                await rm(staging, { recursive: true, force: true });
+            }
+        }
+        await shareWorkspaceRepository(root);
+        await ensureWorkspaceArtifactInstructions(root);
+        await openDirectoryToDevelopment(root, (await lstat(state.config.workspaceRoot)).gid);
+        await state.journal.exclusive(`workspace:${directory.workspaceId}`, async () => {
+            state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, leaseFence);
+            await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
+            const latest = state.journal.getWorkspace(directory.workspaceId) ?? binding;
+            await state.journal.putWorkspace({ ...latest, directories: [...(latest.directories ?? []).filter(item => item.directoryName !== directory.directoryName), { ...directory, status: 'ready' }] });
+        });
+        if (state.gitCredentials && binding.repositoryUrl) {
+            await state.gitCredentials.configure(state.journal.getWorkspace(directory.workspaceId) ?? binding, await state.gitCredentials.prepareDirectory(directory.workspaceId, directory.directoryName), directory.directoryName);
+        }
+        return directory;
+    });
+}
+/** A reclaimed checkout recovers its existing remote branch; no new variant or moving basic head is used. */
+export async function restoreWorkspaceDirectory(state, workspaceId, directoryName = 'basic') {
+    if (directoryName === 'root')
+        return;
+    await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
+        const binding = state.journal.getWorkspace(workspaceId);
+        const directory = binding?.directories?.find(item => item.directoryName === directoryName);
+        if (!binding)
+            return;
+        if (directory?.status !== 'reclaimed') {
+            await ensureWorkspaceArtifactInstructions(await workspaceRoot(state, workspaceId, directoryName));
+            return;
+        }
+        if (binding.targetKind === 'standalone' || !state.gitCredentials)
+            throw new WorkspaceContextError('workspace_recovery_required');
+        const preparation = await state.gitCredentials.prepareDirectory(workspaceId, directoryName);
+        const { pendingFork: _pendingFork, directories: _directories, ...base } = binding;
+        const target = directoryName === 'basic' ? base : { ...base, targetKind: 'remix', remixId: directory.remixId, branchName: directory.branchName };
+        const root = join(state.config.workspaceRoot, workspaceId, directoryName);
+        if (!await lstat(root).catch(() => undefined))
+            await prepareWorkspaceCheckout(state, target, preparation, state.acceptedLeaseFence, directoryName, true);
+        await shareWorkspaceRepository(root);
+        await ensureWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'));
+        await ensureWorkspaceArtifactInstructions(root);
+        await openDirectoryToDevelopment(root, (await lstat(state.config.workspaceRoot)).gid);
+        await state.journal.putWorkspace({ ...binding, directories: binding.directories?.map(item => item.directoryName === directoryName ? { ...item, status: 'ready' } : item) });
+        try {
+            await state.gitCredentials.configure(binding, preparation, directoryName);
+            const scope = revisionScope(state, workspaceId, directoryName);
+            await scheduleDependencyInstall(state, scope, root);
+            if (!['ready', 'none'].includes(readDependencies(state, scope).status))
+                throw new WorkspaceContextError('workspace_directory_restore_dependencies_failed');
+        }
+        catch (error) {
+            const current = state.journal.getWorkspace(workspaceId);
+            await state.journal.putWorkspace({ ...current, directories: current.directories?.map(item => item.directoryName === directoryName ? { ...item, status: 'reclaimed' } : item) });
+            throw error;
+        }
+    });
+}

package/dist/workspace-runtime/workspaces/directory-access.js

@@ -0,0 +1,37 @@
+import { chmod, chown, lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Grant development-group traversal of the workspace container without touching source checkouts. */
+export async function grantWorkspaceTraversal(root, groupId) {
+    const stat = await lstat(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error('invalid_workspace_directory');
+    if (stat.gid !== groupId)
+        await chown(root, stat.uid, groupId);
+    await chmod(root, (stat.mode & 0o777) | 0o2010);
+}
+/** The sandbox development group can edit engine directories. Symlinks never grant access outside the tree. */
+export async function openDirectoryToDevelopment(root, groupId) {
+    const currentUid = typeof process.getuid === 'function' ? process.getuid() : undefined;
+    const visit = async (path) => {
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink())
+            return;
+        const canModify = currentUid === undefined || currentUid === 0 || stat.uid === currentUid;
+        if (canModify && stat.gid !== groupId)
+            await chown(path, stat.uid, groupId);
+        if (stat.isDirectory()) {
+            if (canModify)
+                await chmod(path, (stat.mode & 0o777) | 0o2770);
+            const entries = await readdir(path).catch(error => {
+                if (!canModify && error.code === 'EACCES')
+                    return [];
+                throw error;
+            });
+            for (const entry of entries)
+                await visit(join(path, entry));
+        }
+        else if (stat.isFile() && canModify)
+            await chmod(path, (stat.mode & 0o777) | 0o660);
+    };
+    await visit(root);
+}