@playcraft/cli 0.1.28 → 0.1.29

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

@@ -1,264 +0,0 @@
-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. Frozen installation preserves 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 --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' };
-}
-/**
- * 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

@@ -1,64 +0,0 @@
-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) {
-    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;
-    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);
-            resolve(value);
-        };
-        if (launched)
-            launched.onExit(finish);
-        else {
-            local.once('error', () => finish(null));
-            local.once('close', (value) => finish(value));
-        }
-    });
-    return { code, timedOut };
-}

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

@@ -1,113 +0,0 @@
-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';
-const execute = promisify(execFile);
-/** Trusted Runtime registration clones an immutable local commit; it never follows basic's current branch head. */
-export async function registerWorkspaceDirectory(state, input, leaseFence, sourceDirectoryName) {
-    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 || !binding.repositoryUrl)
-            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 || 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 source = await workspaceRoot(state, directory.workspaceId, sourceDirectoryName ?? 'basic');
-            await git(source, 'cat-file', '-e', `${directory.sourceCommit}^{commit}`);
-            const staging = join(parent, `.directory-${randomUUID()}`);
-            try {
-                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);
-                await git(staging, 'remote', 'set-url', 'origin', binding.repositoryUrl);
-                await git(staging, 'config', 'user.name', 'PlayCraft');
-                await git(staging, 'config', 'user.email', 'playcraft@localhost');
-                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 openDirectoryToDevelopment(root, (await lstat(state.config.workspaceRoot)).gid);
-        state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, leaseFence);
-        await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
-        await state.journal.putWorkspace({ ...binding, directories: [...(binding.directories ?? []).filter(item => item.directoryName !== directory.directoryName), { ...directory, status: 'ready' }] });
-        if (state.gitCredentials)
-            await state.gitCredentials.configure(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 || directory?.status !== 'reclaimed')
-            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 ensureWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'));
-        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

@@ -1,29 +0,0 @@
-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 visit = async (path) => {
-        const stat = await lstat(path);
-        if (stat.isSymbolicLink())
-            return;
-        if (stat.gid !== groupId)
-            await chown(path, stat.uid, groupId);
-        if (stat.isDirectory()) {
-            await chmod(path, (stat.mode & 0o777) | 0o2770);
-            for (const entry of await readdir(path))
-                await visit(join(path, entry));
-        }
-        else if (stat.isFile())
-            await chmod(path, (stat.mode & 0o777) | 0o660);
-    };
-    await visit(root);
-}

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

@@ -1,111 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { promisify } from 'node:util';
-import { workspaceDirectoryNameSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { productionDirectoryBusy } from '../production/controller.js';
-import { workspaceRoot, workspaceSessions } from './registry.js';
-const execute = promisify(execFile);
-const git = async (state, root, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root, ...args], {
-    timeout: 30_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();
-export async function workspaceDirectoryOccupied(state, workspaceId, directoryName) {
-    if (await productionDirectoryBusy(state, workspaceId, directoryName))
-        return true;
-    if (state.journal.listOperations().some(({ operation }) => operation.workspaceId === workspaceId
-        && (operation.directoryName ?? 'basic') === directoryName && ['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status)))
-        return true;
-    if (workspaceSessions(state, workspaceId, directoryName).some(session => session.turnBlock === 'uncertain' || ['starting', 'running', 'waiting_for_user'].includes(session.turnStatus ?? '')))
-        return true;
-    if (state.journal.listTerminals().some(terminal => terminal.workspaceId === workspaceId && (terminal.directoryName ?? 'basic') === directoryName && terminal.status !== 'destroyed'))
-        return true;
-    return [workspaceId, `${workspaceId}:${directoryName}`].some(scope => state.journal.listManagedWrites(scope).some(write => !write.stoppedAt));
-}
-async function assertCleanAndPushed(state, root, allowedHead) {
-    if (await git(state, root, 'status', '--porcelain', '--untracked-files=all'))
-        throw new Error('workspace_directory_uncommitted');
-    const upstream = await git(state, root, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}').catch(() => '');
-    if (!upstream || (Number(await git(state, root, 'rev-list', '--count', `${upstream}..HEAD`)) > 0 && await git(state, root, 'rev-parse', 'HEAD') !== allowedHead))
-        throw new Error('workspace_directory_unpushed');
-}
-/** Keep remote branches, published previews and all journal identities; only local checkouts are reclaimed. */
-export async function cleanupWorkspaceDirectories(state, workspaceId, directoryNames) {
-    if (!Array.isArray(directoryNames) || directoryNames.length === 0 || directoryNames.length > 64)
-        throw new Error('workspace_directories_invalid');
-    const names = [...new Set(directoryNames.map(name => workspaceDirectoryNameSchema.parse(name)))];
-    return state.journal.exclusive(`maintenance:${workspaceId}`, async () => {
-        const cleaned = [];
-        const blocked = [];
-        for (const directoryName of names) {
-            try {
-                await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
-                    if (await workspaceDirectoryOccupied(state, workspaceId, directoryName))
-                        throw new Error('workspace_directory_occupied');
-                    const root = await workspaceRoot(state, workspaceId, directoryName);
-                    await assertCleanAndPushed(state, root);
-                    const binding = state.journal.getWorkspace(workspaceId);
-                    // Persist recoverable identity before removing the checkout; a retry cannot silently adopt another branch.
-                    const existing = binding.directories?.find(item => item.directoryName === directoryName);
-                    const directory = existing ?? { workspaceId, directoryName, remixId: binding.remixId, branchName: binding.branchName };
-                    await state.journal.putWorkspace({ ...binding, directories: [...(binding.directories ?? []).filter(item => item.directoryName !== directoryName), { ...directory, status: 'reclaimed' }] });
-                    await rm(root, { recursive: true });
-                    cleaned.push(directoryName);
-                });
-            }
-            catch (error) {
-                blocked.push({ directoryName, reason: error instanceof Error && /^[a-z0-9_]+$/.test(error.message) ? error.message : 'workspace_cleanup_failed' });
-            }
-        }
-        return { cleaned, blocked };
-    });
-}
-/** Conflicts remain isolated to their own engineering directory. Busy directories are skipped without deferred work. */
-export async function syncWorkspaceDirectories(state, workspaceId, commitHash, targetDirectoryNames) {
-    if (typeof commitHash !== 'string' || !/^[a-f0-9]{40,64}$/.test(commitHash) || !Array.isArray(targetDirectoryNames) || targetDirectoryNames.length === 0 || targetDirectoryNames.length > 64)
-        throw new Error('workspace_sync_invalid');
-    const basic = await workspaceRoot(state, workspaceId, 'basic');
-    await git(state, basic, 'merge-base', '--is-ancestor', commitHash, 'HEAD');
-    const synced = [], skipped = [], conflicts = [];
-    for (const directoryName of [...new Set(targetDirectoryNames.map(name => workspaceDirectoryNameSchema.parse(name)))]) {
-        if (directoryName === 'basic')
-            throw new Error('workspace_sync_target_invalid');
-        await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
-            if (await workspaceDirectoryOccupied(state, workspaceId, directoryName)) {
-                skipped.push({ directoryName, reason: 'directory_busy' });
-                return;
-            }
-            const root = await workspaceRoot(state, workspaceId, directoryName);
-            const ledger = join(state.config.stateDir, 'directory-sync', workspaceId, `${directoryName}.json`);
-            const applied = await readFile(ledger, 'utf8').then(value => JSON.parse(value), () => undefined);
-            await assertCleanAndPushed(state, root, applied?.sourceCommit === commitHash ? applied.targetCommit : undefined);
-            if (applied?.sourceCommit === commitHash && await git(state, root, 'rev-parse', 'HEAD') === applied.targetCommit) {
-                synced.push(directoryName);
-                return;
-            }
-            const containing = await git(state, root, 'merge-base', '--is-ancestor', commitHash, 'HEAD').then(() => true, () => false);
-            if (containing) {
-                synced.push(directoryName);
-                return;
-            }
-            // Import the exact preserved basic commit, without fetching a moving remote branch.
-            await execute('git', ['-c', 'core.hooksPath=/dev/null', '-C', root, 'fetch', '--no-tags', '--', basic, commitHash], { timeout: 30_000, maxBuffer: 1024 * 1024 });
-            const equivalent = (await git(state, root, 'cherry', 'HEAD', commitHash)).split('\n').some(line => line === `- ${commitHash}`);
-            if (!equivalent) {
-                try {
-                    await git(state, root, '-c', 'user.name=PlayCraft', '-c', 'user.email=playcraft@localhost', 'cherry-pick', commitHash);
-                }
-                catch {
-                    conflicts.push(directoryName);
-                    return;
-                }
-            }
-            await mkdir(join(state.config.stateDir, 'directory-sync', workspaceId), { recursive: true, mode: 0o700 });
-            const temporary = `${ledger}.${randomUUID()}.tmp`;
-            await writeFile(temporary, JSON.stringify({ sourceCommit: commitHash, targetCommit: await git(state, root, 'rev-parse', 'HEAD') }), { mode: 0o600 });
-            await rename(temporary, ledger);
-            synced.push(directoryName);
-        });
-    }
-    return { synced, skipped, conflicts, previewStale: true };
-}

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

@@ -1,49 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { workspaceRoot, WorkspaceContextError } from './registry.js';
-const execute = promisify(execFile);
-/** Measures registered checkouts only when requested; journal activity never scans private neighboring workspaces. */
-export async function readWorkspaceDirectoryStats(state, workspaceId) {
-    const binding = state.journal.getWorkspace(workspaceId);
-    if (!binding)
-        throw new WorkspaceContextError('workspace_not_registered');
-    const names = [...new Set(['basic', ...(binding.directories ?? []).map(directory => directory.directoryName)])];
-    const operations = state.journal.listOperations().map(item => item.operation).filter(operation => operation.workspaceId === workspaceId);
-    const events = state.journal.listEvents().flatMap(event => {
-        const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
-        const session = typeof payload.sessionId === 'string' ? state.journal.getSession(payload.sessionId) : undefined;
-        if ((payload.workspaceId ?? session?.workspaceId) !== workspaceId)
-            return [];
-        return [{ directoryName: String(payload.directoryName ?? session?.directoryName ?? 'basic'), occurredAt: event.occurredAt }];
-    });
-    const latest = (dates) => {
-        const timestamps = dates.map(value => Date.parse(value)).filter(Number.isFinite);
-        return timestamps.length ? new Date(Math.max(...timestamps)).toISOString() : null;
-    };
-    const directories = [];
-    for (const directoryName of names) {
-        const lastUsedAt = latest([...operations.filter(operation => (operation.directoryName ?? 'basic') === directoryName).map(operation => operation.updatedAt),
-            ...events.filter(event => event.directoryName === directoryName).map(event => event.occurredAt)]);
-        if (binding.directories?.some(directory => directory.directoryName === directoryName && directory.status === 'reclaimed')) {
-            directories.push({ directoryName, sizeBytes: 0, lastUsedAt, status: 'reclaimed' });
-            continue;
-        }
-        let root;
-        try {
-            root = await workspaceRoot(state, workspaceId, directoryName);
-        }
-        catch (error) {
-            if (!(error instanceof WorkspaceContextError) || error.message !== 'workspace_not_prepared')
-                throw error;
-            directories.push({ directoryName, sizeBytes: 0, lastUsedAt, status: 'missing' });
-            continue;
-        }
-        const output = await execute('du', ['-sk', root], { timeout: 30_000, maxBuffer: 4096 });
-        const blocks = Number(output.stdout.trim().split(/\s+/)[0]);
-        if (!Number.isSafeInteger(blocks) || blocks < 0 || !Number.isSafeInteger(blocks * 1024))
-            throw new Error('workspace_directory_stats_invalid');
-        directories.push({ directoryName, sizeBytes: blocks * 1024, lastUsedAt, status: 'present' });
-    }
-    return { workspaceId, sizeBytes: directories.reduce((sum, directory) => sum + directory.sizeBytes, 0),
-        lastUsedAt: latest([...operations.map(operation => operation.updatedAt), ...events.map(event => event.occurredAt)]), directories };
-}