@playcraft/cli 0.1.38-beta → 0.1.39-prod

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

@@ -1,245 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { attachmentIdsSchema, WORKSPACE_USER_UPLOADS_DIRECTORY, WORKSPACE_ATTACHMENT_MAX_BYTES, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES, WORKSPACE_DIRECTORY_ATTACHMENT_MAX_BYTES, workspaceAttachmentSchema, workspaceDirectoryAttachmentUploadSchema, workspaceDirectoryAttachmentFilePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { artifactMime } from './artifact-files.js';
-import { excludeFromGit } from './dependencies.js';
-import { hashAttachment, probeAttachmentVideo } from './video-attachments.js';
-const stagingPath = `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.directory-uploads`;
-const locks = new Map();
-async function withUploadLock(root, id, action) {
-    const key = `${root}\0${id}`;
-    const previous = locks.get(key) ?? Promise.resolve();
-    const current = previous.catch(() => undefined).then(action);
-    locks.set(key, current);
-    try {
-        return await current;
-    }
-    finally {
-        if (locks.get(key) === current)
-            locks.delete(key);
-    }
-}
-async function safeDirectory(root, relative, create = false) {
-    let directory = root;
-    for (const part of relative.split('/')) {
-        directory = join(directory, part);
-        if (create)
-            await mkdir(directory, { mode: 0o755 }).catch((error) => {
-                if (error.code !== 'EEXIST')
-                    throw error;
-            });
-        if (!(await lstat(directory)).isDirectory())
-            throw new Error('invalid_attachment');
-    }
-    return directory;
-}
-function validId(id) {
-    if (!attachmentIdsSchema.safeParse([id]).success)
-        throw new Error('invalid_attachment');
-}
-async function readManifest(root, id) {
-    validId(id);
-    const stage = await safeDirectory(root, `${stagingPath}/${id}`);
-    const handle = await open(join(stage, 'manifest.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-            throw new Error('invalid_attachment');
-        return workspaceDirectoryAttachmentUploadSchema.parse(JSON.parse(await handle.readFile('utf8')));
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function beginWorkspaceDirectoryAttachment(root, body) {
-    const manifest = workspaceDirectoryAttachmentUploadSchema.parse(body);
-    await excludeFromGit(root, `/${WORKSPACE_USER_UPLOADS_DIRECTORY}/`);
-    const staging = await safeDirectory(root, stagingPath, true);
-    const id = randomUUID();
-    const stage = join(staging, id);
-    await mkdir(stage, { mode: 0o755 });
-    try {
-        await mkdir(join(stage, 'data'), { mode: 0o755 });
-        await mkdir(join(stage, 'data', manifest.name), { mode: 0o755 });
-        await writeFile(join(stage, 'manifest.json'), JSON.stringify(manifest), { flag: 'wx', mode: 0o644 });
-        return { uploadId: id };
-    }
-    catch (error) {
-        await rm(stage, { recursive: true, force: true });
-        throw error;
-    }
-}
-/** Each member is streamed and created exclusively; no completed member can be overwritten. */
-export async function uploadWorkspaceDirectoryFile(root, id, path, request) {
-    return withUploadLock(root, id, async () => {
-        workspaceDirectoryAttachmentFilePathSchema.parse(path);
-        const manifest = await readManifest(root, id);
-        const member = manifest.files.find(file => file.path === path);
-        if (!member)
-            throw new Error('invalid_attachment');
-        const length = request.headers['content-length'];
-        if (length !== undefined && (!/^\d+$/.test(length) || Number(length) !== member.size))
-            throw new Error('invalid_attachment');
-        const relative = `${stagingPath}/${id}/data/${manifest.name}/${path}`;
-        await safeDirectory(root, dirname(relative), true);
-        const handle = await open(join(root, relative), constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | constants.O_NOFOLLOW, 0o644);
-        try {
-            let size = 0;
-            for await (const chunk of request) {
-                const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                if (size + bytes.length > member.size)
-                    throw new Error('invalid_attachment');
-                let offset = 0;
-                while (offset < bytes.length)
-                    offset += (await handle.write(bytes, offset, bytes.length - offset, size + offset)).bytesWritten;
-                size += bytes.length;
-            }
-            if (size !== member.size)
-                throw new Error('invalid_attachment');
-            await handle.sync();
-            if (member.mimeType.startsWith('video/')) {
-                const media = await probeAttachmentVideo(handle);
-                if (media.mimeType !== member.mimeType && !(member.mimeType === 'video/quicktime' && media.mimeType === 'video/mp4'))
-                    throw new Error('invalid_attachment');
-            }
-            return { path, size };
-        }
-        catch (error) {
-            await rm(join(root, relative), { force: true });
-            throw error;
-        }
-        finally {
-            await handle.close();
-        }
-    });
-}
-async function assertExactFiles(directory, expected, prefix = '') {
-    for (const name of await readdir(directory)) {
-        const relative = prefix ? `${prefix}/${name}` : name;
-        const path = join(directory, name);
-        const stat = await lstat(path);
-        if (stat.isDirectory())
-            await assertExactFiles(path, expected, relative);
-        else if (!stat.isFile() || stat.nlink !== 1 || !expected.delete(relative))
-            throw new Error('invalid_attachment');
-    }
-    if (!prefix && expected.size)
-        throw new Error('invalid_attachment');
-}
-async function directoryFiles(root, relative, manifest) {
-    const directory = await safeDirectory(root, relative);
-    await assertExactFiles(directory, new Set(manifest.files.map(file => file.path)));
-    const files = [];
-    for (const file of manifest.files) {
-        await safeDirectory(directory, dirname(file.path) === '.' ? '' : dirname(file.path));
-        const handle = await open(join(directory, file.path), constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            const stat = await handle.stat();
-            if (!stat.isFile() || stat.nlink !== 1 || stat.size !== file.size)
-                throw new Error('invalid_attachment');
-            const media = file.mimeType.startsWith('video/') ? await probeAttachmentVideo(handle) : undefined;
-            if (media && media.mimeType !== file.mimeType && !(file.mimeType === 'video/quicktime' && media.mimeType === 'video/mp4'))
-                throw new Error('invalid_attachment');
-            const inferred = artifactMime(file.path);
-            files.push({ path: file.path, size: stat.size, sha256: await hashAttachment(handle),
-                mimeType: media?.mimeType ?? (inferred === 'application/octet-stream' ? file.mimeType : inferred) });
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    return files;
-}
-export async function completeWorkspaceDirectoryAttachment(root, id) {
-    return withUploadLock(root, id, async () => {
-        const manifest = await readManifest(root, id);
-        const stage = await safeDirectory(root, `${stagingPath}/${id}`);
-        const files = await directoryFiles(root, `${stagingPath}/${id}/data/${manifest.name}`, manifest);
-        const metadata = await safeDirectory(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata`, true);
-        const uploads = await safeDirectory(root, WORKSPACE_USER_UPLOADS_DIRECTORY);
-        const attachment = { id, name: manifest.name, kind: 'directory',
-            size: files.reduce((size, file) => size + file.size, 0), mimeType: 'application/vnd.playcraft.directory',
-            path: `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}/${manifest.name}`, files };
-        workspaceAttachmentSchema.parse(attachment);
-        const target = join(uploads, id);
-        await mkdir(target, { mode: 0o755 });
-        try {
-            await rename(join(stage, 'data', manifest.name), join(target, manifest.name));
-            await writeFile(join(metadata, `${id}.json`), JSON.stringify(attachment), { flag: 'wx', mode: 0o644 });
-        }
-        catch (error) {
-            await rm(target, { recursive: true, force: true });
-            throw error;
-        }
-        await rm(stage, { recursive: true, force: true });
-        return attachment;
-    });
-}
-export async function cancelWorkspaceDirectoryAttachment(root, id) {
-    validId(id);
-    return withUploadLock(root, id, async () => {
-        const parent = await safeDirectory(root, stagingPath);
-        const stage = join(parent, id);
-        try {
-            if (!(await lstat(stage)).isDirectory())
-                throw new Error('invalid_attachment');
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        await rm(stage, { recursive: true, force: true });
-        return { uploadId: id, cancelled: true };
-    });
-}
-export async function readWorkspaceDirectoryMetadata(root, id) {
-    validId(id);
-    const metadata = await safeDirectory(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata`);
-    const handle = await open(join(metadata, `${id}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-            throw new Error('invalid_attachment');
-        const attachment = workspaceAttachmentSchema.parse(JSON.parse(await handle.readFile('utf8')));
-        if (attachment.id !== id || attachment.kind !== 'directory' || attachment.origin || !attachment.files ||
-            attachment.path !== `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}/${attachment.name}` || attachment.mimeType !== 'application/vnd.playcraft.directory')
-            throw new Error('invalid_attachment');
-        workspaceDirectoryAttachmentUploadSchema.parse({ name: attachment.name, files: attachment.files.map(({ sha256: _digest, ...file }) => file) });
-        if (attachment.size !== attachment.files.reduce((size, file) => size + file.size, 0) || attachment.size > WORKSPACE_DIRECTORY_ATTACHMENT_MAX_BYTES)
-            throw new Error('invalid_attachment');
-        return attachment;
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function openWorkspaceDirectoryFile(root, attachment, path) {
-    workspaceDirectoryAttachmentFilePathSchema.parse(path);
-    const file = attachment.files?.find(file => file.path === path);
-    if (!file || !attachment.path)
-        throw new Error('attachment_unavailable');
-    const directory = await safeDirectory(root, attachment.path);
-    if (dirname(file.path) !== '.')
-        await safeDirectory(directory, dirname(file.path));
-    const handle = await open(join(directory, file.path), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        const limit = file.mimeType.startsWith('video/') ? WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES : WORKSPACE_ATTACHMENT_MAX_BYTES;
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size !== file.size || stat.size > limit || await hashAttachment(handle) !== file.sha256)
-            throw new Error('attachment_unavailable');
-        return { handle, name: file.path.split('/').at(-1), mimeType: file.mimeType, size: file.size };
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
-    }
-}
-export async function resolveWorkspaceDirectoryAttachment(root, id) {
-    const attachment = await readWorkspaceDirectoryMetadata(root, id);
-    const files = await directoryFiles(root, attachment.path, { name: attachment.name, files: attachment.files.map(({ sha256: _digest, ...file }) => file) });
-    if (files.some((file, index) => file.sha256 !== attachment.files[index].sha256 || file.mimeType !== attachment.files[index].mimeType))
-        throw new Error('attachment_unavailable');
-    return { ...attachment, path: join(root, attachment.path) };
-}

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, excludeAttemptId, ignoreSourceCaptures = false) {
-    if (await productionDirectoryBusy(state, workspaceId, directoryName, excludeAttemptId, ignoreSourceCaptures))
-        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 };
-}

package/dist/workspace-runtime/workspaces/disk-snapshot.js

@@ -1,31 +0,0 @@
-import { createHash } from 'node:crypto';
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
-import { WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
-export async function sampleDiskFile(path) {
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const before = await handle.stat();
-        if (!before.isFile() || before.size > WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES)
-            throw new Error('snapshot_body_missing');
-        const digest = createHash('sha256');
-        const chunk = Buffer.allocUnsafe(64 * 1024);
-        let position = 0;
-        for (;;) {
-            const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
-            if (!bytesRead)
-                break;
-            digest.update(chunk.subarray(0, bytesRead));
-            position += bytesRead;
-            if (position > WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES)
-                throw new Error('snapshot_body_missing');
-        }
-        const after = await handle.stat();
-        if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || position !== before.size)
-            throw new Error('snapshot_body_missing');
-        return { hash: digest.digest('hex'), size: position, mode: before.mode & 0o777 };
-    }
-    finally {
-        await handle.close();
-    }
-}

package/dist/workspace-runtime/workspaces/empty-template.js

@@ -1,42 +0,0 @@
-import { cp, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { resolveCliPackageRoot } from '../../scaffold/compose.js';
-import { importBuiltinProjectSkills } from '../../project-skills/builtin-import.js';
-import { createHash } from 'node:crypto';
-import { canonicalProjectSkillsJson } from '@playcraft/common/project-skills';
-import { syncLocalProjectSkills } from '../../project-skills/local-store.js';
-import { selectOptionalPlatformSkills } from './optional-platform-skills.js';
-export const EMPTY_WORKSPACE_REPOSITORY_SKILLS = [
-    'playcraft-skill-recommender',
-    'playcraft-image-generation',
-    'playcraft-audio-generation',
-    'playcraft-image-processing',
-    'playcraft-build-optimizer',
-];
-export const EMPTY_WORKSPACE_PLATFORM_SKILLS = ['playcraft-video-understanding', 'playcraft-replica-validation'];
-export const EMPTY_WORKSPACE_DEFAULT_SKILLS = [...EMPTY_WORKSPACE_REPOSITORY_SKILLS, ...EMPTY_WORKSPACE_PLATFORM_SKILLS];
-/** Only called in a new, unpublished staging directory; existing workspaces are never scaffolded. */
-export async function scaffoldEmptyWorkspace(root, skillCache, access) {
-    const selected = await selectOptionalPlatformSkills([...EMPTY_WORKSPACE_PLATFORM_SKILLS], access);
-    const cliRoot = resolveCliPackageRoot();
-    const template = join(cliRoot, 'project-templates', 'empty');
-    for (const [source, target] of [
-        ['gitignore', '.gitignore'],
-        ['AGENTS.md', 'AGENTS.md'],
-    ]) {
-        await cp(join(template, source), join(root, target), { force: false, errorOnExist: true });
-    }
-    const skills = join(root, '.agents', 'skills');
-    await mkdir(skills, { recursive: true });
-    for (const name of EMPTY_WORKSPACE_REPOSITORY_SKILLS) {
-        await cp(join(cliRoot, 'project-template', '.claude', 'skills', name), join(skills, name), {
-            recursive: true,
-            force: false,
-            errorOnExist: true,
-        });
-    }
-    const snapshot = await syncLocalProjectSkills(root, skillCache);
-    if (selected)
-        await importBuiltinProjectSkills(root, { names: [...EMPTY_WORKSPACE_PLATFORM_SKILLS], expectedDeclarationHash: snapshot.lock.declarationHash,
-            expectedLockHash: createHash('sha256').update(canonicalProjectSkillsJson(snapshot.lock)).digest('hex') }, skillCache, access, selected, true);
-}

package/dist/workspace-runtime/workspaces/files-search.js

@@ -1,116 +0,0 @@
-import { createHash } from 'node:crypto';
-import { lstat, opendir, realpath } from 'node:fs/promises';
-import { join, relative, sep } from 'node:path';
-import { workspaceFileSearchQuerySchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-const SKIP_DIRECTORIES = new Set(['.git', 'node_modules', '.playcraft', '.next', 'dist', 'build', 'coverage', '.turbo']);
-const SCAN_PAGE_ENTRIES = 1000;
-export class InvalidWorkspaceSearchError extends Error {
-    code;
-    constructor(code = 'invalid_workspace_search') {
-        super(code);
-        this.code = code;
-        this.name = 'InvalidWorkspaceSearchError';
-    }
-}
-/** Enumerates names only. The cursor is scoped to the resolved checkout and query, never to a caller supplied path. */
-export async function searchWorkspaceFiles(root, query, options = {}) {
-    const parsed = workspaceFileSearchQuerySchema.safeParse(query);
-    if (!parsed.success)
-        throw new InvalidWorkspaceSearchError();
-    options.signal?.throwIfAborted();
-    const rootReal = await realpath(root);
-    const needle = parsed.data.query.toLocaleLowerCase();
-    const scope = createHash('sha256').update(rootReal).update('\0').update(needle).digest('hex');
-    const start = decodeCursor(parsed.data.cursor, scope);
-    const files = [];
-    let offset = 0;
-    for await (const path of walk(rootReal, rootReal, options.signal)) {
-        options.signal?.throwIfAborted();
-        offset += 1;
-        if (offset <= start)
-            continue;
-        if (path && path.toLocaleLowerCase().includes(needle)) {
-            const target = join(rootReal, ...path.split('/'));
-            const info = await lstat(target).catch(ignoreUnavailable);
-            const targetReal = info?.isFile() && !info.isSymbolicLink() ? await realpath(target).catch(ignoreUnavailable) : undefined;
-            if (targetReal && inside(rootReal, targetReal))
-                files.push({ path });
-        }
-        if (files.length >= parsed.data.limit || offset - start >= SCAN_PAGE_ENTRIES) {
-            return { files, truncated: true, nextCursor: encodeCursor(scope, offset) };
-        }
-    }
-    return { files, truncated: false };
-}
-async function* walk(root, current, signal) {
-    signal?.throwIfAborted();
-    const currentInfo = await lstat(current).catch(ignoreUnavailable);
-    if (!currentInfo?.isDirectory() || currentInfo.isSymbolicLink())
-        return;
-    const resolved = await realpath(current).catch(ignoreUnavailable);
-    if (!resolved || !inside(root, resolved))
-        return;
-    const directory = await opendir(resolved).catch(ignoreUnavailable);
-    if (!directory)
-        return;
-    // Recheck after opening: a concurrently replaced directory must not reveal another checkout's paths.
-    const openedPath = await realpath(current).catch(ignoreUnavailable);
-    if (openedPath !== resolved || !inside(root, openedPath)) {
-        await directory.close();
-        return;
-    }
-    for await (const entry of directory) {
-        signal?.throwIfAborted();
-        if (['.git', 'node_modules', '.playcraft'].includes(entry.name)) {
-            yield undefined;
-            continue;
-        }
-        const child = join(resolved, entry.name);
-        const path = relative(root, child).split(sep).join('/');
-        if (!workspaceRelativePathSchema.safeParse(path).success) {
-            yield undefined;
-            continue;
-        }
-        if (entry.isDirectory()) {
-            yield undefined;
-            if (!SKIP_DIRECTORIES.has(entry.name))
-                yield* walk(root, child, signal);
-            continue;
-        }
-        if (!entry.isFile()) {
-            yield undefined;
-            continue;
-        }
-        yield path;
-    }
-}
-function inside(root, path) {
-    const value = relative(root, path);
-    return value === '' || (value !== '..' && !value.startsWith(`..${sep}`) && !value.startsWith(sep));
-}
-function ignoreUnavailable(error) {
-    if (['ENOENT', 'ENOTDIR', 'EACCES'].includes(error.code ?? ''))
-        return undefined;
-    throw error;
-}
-function encodeCursor(scope, offset) {
-    return Buffer.from(JSON.stringify({ v: 1, scope, offset })).toString('base64url');
-}
-function decodeCursor(cursor, scope) {
-    if (!cursor)
-        return 0;
-    try {
-        if (!/^[A-Za-z0-9_-]+$/.test(cursor))
-            throw new Error();
-        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
-        if (typeof value !== 'object' || value === null)
-            throw new Error();
-        const { v, scope: suppliedScope, offset } = value;
-        if (v !== 1 || suppliedScope !== scope || typeof offset !== 'number' || !Number.isSafeInteger(offset) || offset < 0)
-            throw new Error();
-        return offset;
-    }
-    catch {
-        throw new InvalidWorkspaceSearchError('invalid_workspace_search_cursor');
-    }
-}