@playcraft/cli 0.1.54 → 0.1.56-beta

package/dist/workspace-runtime/workspaces/remix-references.js

@@ -0,0 +1,301 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { chmod, lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { WORKSPACE_REMIX_REFERENCE_MAX_BYTES, WORKSPACE_REMIX_REFERENCE_MAX_FILES, WORKSPACE_REMIX_REFERENCES_DIRECTORY, WORKSPACE_REMIX_REFERENCES_MANIFEST, remixReferenceContentHashInput, workspaceDirectoryNameSchema, workspaceRemixReferenceExportSchema, workspaceRemixReferenceSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { isCredentialFile } from './git.js';
+const exec = promisify(execFile);
+const RECEIPT = '.reference.json';
+const ATTRIBUTES = '.gitattributes';
+const SNAPSHOT_ATTRIBUTES = '* -filter -text -ident -working-tree-encoding -eol\n';
+const INERT_DIRECTORY = '_source_metadata';
+const MANIFEST_MAX_BYTES = 16 * 1024 * 1024;
+const EXCLUDED = new Set(['.git', 'node_modules', '.next', '.cache', '.tmp', '.turbo', '.pnpm-store', '.ssh', '.aws']);
+const INERT = new Set(['.agents', '.claude', '.codex', '.cursor', '.playcraft', '.gitignore', '.gitattributes',
+    '.gitmodules', 'agents.md', 'claude.md', 'gemini.md', '.cursorrules', '.mcp.json']);
+const locks = new Map();
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+export class RemixReferenceError extends Error {
+    constructor(code) { super(code); this.name = 'RemixReferenceError'; }
+}
+async function safeDirectory(root, relative = '', create = false) {
+    let current = root;
+    for (const segment of relative.split('/').filter(Boolean)) {
+        current = join(current, segment);
+        if (create)
+            await mkdir(current, { mode: 0o755 }).catch((error) => {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            });
+        const info = await lstat(current);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new RemixReferenceError('remix_reference_path_conflict');
+    }
+    return current;
+}
+async function readFileSafely(root, path, limit) {
+    await safeDirectory(root, dirname(path) === '.' ? '' : dirname(path));
+    const handle = await open(join(root, path), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() || before.nlink !== 1 || before.size > limit)
+            throw new RemixReferenceError('remix_reference_changed');
+        const data = Buffer.alloc(before.size + 1);
+        let length = 0;
+        while (length < data.length) {
+            const { bytesRead } = await handle.read(data, length, data.length - length, length);
+            if (!bytesRead)
+                break;
+            length += bytesRead;
+        }
+        const after = await handle.stat();
+        if (length !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
+            throw new RemixReferenceError('remix_reference_changed');
+        return data.subarray(0, length);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function identity(snapshot) {
+    const { source, contentHash } = snapshot;
+    return hash(JSON.stringify([source.environment, source.projectUuid, source.branchName, source.commit, contentHash]));
+}
+function referencePath(referenceId, commit) {
+    return `${WORKSPACE_REMIX_REFERENCES_DIRECTORY}/${referenceId.slice(0, 20)}-${commit.slice(0, 12)}`;
+}
+/** Project instructions and Git filters remain readable source material without becoming active configuration. */
+function materializedPath(sourcePath) {
+    const parts = sourcePath.split('/').map(part => part.toLowerCase());
+    if (parts.some(part => EXCLUDED.has(part)) || isCredentialFile(sourcePath) ||
+        parts.some(part => ['.npmrc', '.yarnrc', '.netrc', '.git-credentials'].includes(part)))
+        return undefined;
+    if (parts[0] === INERT_DIRECTORY || parts[0] === RECEIPT)
+        throw new RemixReferenceError('remix_reference_path_conflict');
+    if (parts.some(part => INERT.has(part)))
+        return `${INERT_DIRECTORY}/${hash(sourcePath)}.txt`;
+    return sourcePath;
+}
+async function readManifest(root) {
+    try {
+        const value = JSON.parse((await readFileSafely(root, WORKSPACE_REMIX_REFERENCES_MANIFEST, MANIFEST_MAX_BYTES)).toString('utf8'));
+        if (value?.version !== 1 || !Array.isArray(value.items) || value.items.length > 100)
+            throw new RemixReferenceError('remix_reference_manifest_invalid');
+        const items = value.items.map((item) => workspaceRemixReferenceSchema.parse(item));
+        if (new Set(items.map(item => item.referenceId)).size !== items.length)
+            throw new RemixReferenceError('remix_reference_manifest_invalid');
+        return items;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        if (error instanceof RemixReferenceError)
+            throw error;
+        throw new RemixReferenceError('remix_reference_manifest_invalid');
+    }
+}
+function validateRecord(record, directoryName) {
+    if (record.directoryName !== directoryName || record.referenceId !== identity(record) ||
+        record.path !== referencePath(record.referenceId, record.source.commit) || record.name !== record.source.name)
+        throw new RemixReferenceError('remix_reference_manifest_invalid');
+    const paths = new Set();
+    for (const file of record.files) {
+        if (file.path !== materializedPath(file.sourcePath) || paths.has(file.path.toLowerCase()))
+            throw new RemixReferenceError('remix_reference_manifest_invalid');
+        paths.add(file.path.toLowerCase());
+    }
+    if ((record.omittedFiles ?? []).some(file => materializedPath(file.path) !== undefined))
+        throw new RemixReferenceError('remix_reference_manifest_invalid');
+    const originalFiles = [...record.files.map(file => ({ ...file, path: file.sourcePath })), ...(record.omittedFiles ?? [])];
+    if (originalFiles.length > WORKSPACE_REMIX_REFERENCE_MAX_FILES || new Set(originalFiles.map(file => file.path.toLowerCase())).size !== originalFiles.length ||
+        hash(remixReferenceContentHashInput(originalFiles)) !== record.contentHash ||
+        originalFiles.reduce((sum, file) => sum + file.size, 0) > WORKSPACE_REMIX_REFERENCE_MAX_BYTES)
+        throw new RemixReferenceError('remix_reference_manifest_invalid');
+}
+async function verifyReference(root, record, directoryName) {
+    validateRecord(record, directoryName);
+    const target = await safeDirectory(root, record.path);
+    const receipt = JSON.parse((await readFileSafely(target, RECEIPT, MANIFEST_MAX_BYTES)).toString('utf8'));
+    if (JSON.stringify(workspaceRemixReferenceSchema.parse(receipt)) !== JSON.stringify(record))
+        throw new RemixReferenceError('remix_reference_changed');
+    if ((await readFileSafely(target, ATTRIBUTES, 256)).toString('utf8') !== SNAPSHOT_ATTRIBUTES)
+        throw new RemixReferenceError('remix_reference_changed');
+    const expected = new Set([RECEIPT, ATTRIBUTES, ...record.files.map(file => file.path)]);
+    const walk = async (directory, prefix = '') => {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isSymbolicLink())
+                throw new RemixReferenceError('remix_reference_changed');
+            if (entry.isDirectory())
+                await walk(await safeDirectory(target, path), path);
+            else if (!entry.isFile() || !expected.delete(path))
+                throw new RemixReferenceError('remix_reference_changed');
+        }
+    };
+    await walk(target);
+    if (expected.size)
+        throw new RemixReferenceError('remix_reference_changed');
+    for (const file of record.files) {
+        const bytes = await readFileSafely(target, file.path, file.size);
+        if (bytes.length !== file.size || hash(bytes) !== file.sha256)
+            throw new RemixReferenceError('remix_reference_changed');
+    }
+}
+/** Reads revalidate the snapshot, so changed/deleted files cannot silently remain attached to a turn. */
+export async function listWorkspaceRemixReferences(root, directoryName = 'basic') {
+    workspaceDirectoryNameSchema.parse(directoryName);
+    const rootReal = await realpath(root);
+    const items = await readManifest(rootReal);
+    for (const item of items)
+        await verifyReference(rootReal, item, directoryName);
+    return items;
+}
+export async function resolveWorkspaceRemixReference(root, directoryName, referenceId, snapshotHash) {
+    workspaceDirectoryNameSchema.parse(directoryName);
+    try {
+        const rootReal = await realpath(root);
+        const item = (await readManifest(rootReal)).find(item => item.referenceId === referenceId);
+        if (!item)
+            throw new RemixReferenceError('context_remix_reference_unavailable');
+        if (item.contentHash !== snapshotHash)
+            throw new RemixReferenceError('context_remix_reference_changed');
+        await verifyReference(rootReal, item, directoryName);
+        return item;
+    }
+    catch (error) {
+        if (error instanceof RemixReferenceError && error.message.startsWith('context_'))
+            throw error;
+        throw new RemixReferenceError('context_remix_reference_changed');
+    }
+}
+async function trackReference(root, record) {
+    const environment = { PATH: process.env.PATH, HOME: root, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null', GIT_TERMINAL_PROMPT: '0' };
+    const gitOptions = ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root];
+    const paths = [WORKSPACE_REMIX_REFERENCES_MANIFEST, `${record.path}/${RECEIPT}`, `${record.path}/${ATTRIBUTES}`,
+        ...record.files.map(file => `${record.path}/${file.path}`)];
+    // Reject higher-priority repository attributes before Git can execute a conversion filter.
+    const attributes = await new Promise((resolve, reject) => {
+        const child = execFile('git', [...gitOptions, 'check-attr', '-z', '--stdin', 'filter', 'text', 'ident', 'working-tree-encoding', 'eol'], {
+            timeout: 60_000, maxBuffer: 40 * 1024 * 1024, env: environment, encoding: 'utf8',
+        }, (error, stdout) => error ? reject(error) : resolve(stdout));
+        child.stdin?.end(`${paths.join('\0')}\0`);
+    });
+    const fields = attributes.split('\0');
+    if (fields.length !== paths.length * 15 + 1)
+        throw new RemixReferenceError('remix_reference_git_attributes');
+    for (let index = 0; index < fields.length - 1; index += 3) {
+        const [path, attribute, value] = fields.slice(index, index + 3);
+        if (path === WORKSPACE_REMIX_REFERENCES_MANIFEST && (attribute === 'text' || attribute === 'eol'))
+            continue;
+        if (value !== 'unset' && value !== 'unspecified')
+            throw new RemixReferenceError('remix_reference_git_attributes');
+    }
+    // A source file may have been tracked despite its old ignore rules. Track this approved snapshot explicitly.
+    await exec('git', [...gitOptions,
+        '--literal-pathspecs', 'add', '--force', '--', record.path, WORKSPACE_REMIX_REFERENCES_MANIFEST], {
+        timeout: 60_000, maxBuffer: 1024 * 1024,
+        env: environment,
+    });
+}
+async function importReference(root, directoryName, input, assertCurrent) {
+    workspaceDirectoryNameSchema.parse(directoryName);
+    const parsed = workspaceRemixReferenceExportSchema.safeParse(input);
+    if (!parsed.success)
+        throw new RemixReferenceError('invalid_remix_reference');
+    const snapshot = parsed.data;
+    if (snapshot.contentHash !== hash(remixReferenceContentHashInput(snapshot.files)))
+        throw new RemixReferenceError('remix_reference_changed');
+    const plannedFiles = snapshot.files.map(file => {
+        const bytes = Buffer.from(file.content, 'base64');
+        if (bytes.toString('base64') !== file.content || bytes.length !== file.size || hash(bytes) !== file.sha256)
+            throw new RemixReferenceError('remix_reference_changed');
+        if (bytes.subarray(0, 128).toString('utf8').startsWith('version https://git-lfs.github.com/spec/v1'))
+            throw new RemixReferenceError('remix_reference_external_resource');
+        return { ...file, bytes, targetPath: materializedPath(file.path) };
+    });
+    const files = plannedFiles.filter(file => file.targetPath !== undefined);
+    if (!files.length)
+        throw new RemixReferenceError('remix_reference_empty');
+    const rootReal = await realpath(root);
+    const referenceId = identity(snapshot);
+    const path = referencePath(referenceId, snapshot.source.commit);
+    const items = await readManifest(rootReal);
+    await safeDirectory(rootReal, '.playcraft', true);
+    let record = items.find(item => item.referenceId === referenceId);
+    if (record) {
+        await verifyReference(rootReal, record, directoryName);
+        assertCurrent();
+        await trackReference(rootReal, record);
+        return record;
+    }
+    if (items.length >= 100)
+        throw new RemixReferenceError('remix_reference_limit');
+    await safeDirectory(rootReal, WORKSPACE_REMIX_REFERENCES_DIRECTORY, true);
+    const target = join(rootReal, path);
+    const existing = await lstat(target).catch((error) => { if (error.code === 'ENOENT')
+        return undefined; throw error; });
+    if (existing) {
+        // A complete published directory is its recovery receipt when the process died before writing the manifest.
+        if (!existing.isDirectory() || existing.isSymbolicLink())
+            throw new RemixReferenceError('remix_reference_path_conflict');
+        record = workspaceRemixReferenceSchema.parse(JSON.parse((await readFileSafely(rootReal, `${path}/${RECEIPT}`, MANIFEST_MAX_BYTES)).toString('utf8')));
+        if (record.referenceId !== referenceId)
+            throw new RemixReferenceError('remix_reference_path_conflict');
+        await verifyReference(rootReal, record, directoryName);
+    }
+    else {
+        record = workspaceRemixReferenceSchema.parse({ referenceId, directoryName, path, name: snapshot.source.name,
+            source: snapshot.source, contentHash: snapshot.contentHash, importedAt: new Date().toISOString(),
+            files: files.map(file => ({ path: file.targetPath, sourcePath: file.path, sha256: file.sha256, size: file.size })),
+            omittedFiles: plannedFiles.filter(file => file.targetPath === undefined).map(file => ({ path: file.path, sha256: file.sha256, size: file.size })) });
+        const stage = await mkdtemp(join(dirname(rootReal), '.remix-reference-'));
+        try {
+            for (const file of files) {
+                assertCurrent();
+                await safeDirectory(stage, dirname(file.targetPath) === '.' ? '' : dirname(file.targetPath), true);
+                await writeFile(join(stage, file.targetPath), file.bytes, { flag: 'wx', mode: 0o644 });
+            }
+            await writeFile(join(stage, RECEIPT), JSON.stringify(record), { flag: 'wx', mode: 0o644 });
+            await writeFile(join(stage, ATTRIBUTES), SNAPSHOT_ATTRIBUTES, { flag: 'wx', mode: 0o644 });
+            await chmod(stage, 0o755);
+            assertCurrent();
+            await safeDirectory(rootReal, WORKSPACE_REMIX_REFERENCES_DIRECTORY);
+            if (await lstat(target).catch(() => undefined))
+                throw new RemixReferenceError('remix_reference_path_conflict');
+            await rename(stage, target);
+        }
+        finally {
+            await rm(stage, { recursive: true, force: true });
+        }
+    }
+    const serialized = JSON.stringify({ version: 1, items: [...items, record] });
+    if (Buffer.byteLength(serialized) > MANIFEST_MAX_BYTES)
+        throw new RemixReferenceError('remix_reference_limit');
+    await safeDirectory(rootReal, '.playcraft', true);
+    const temporary = join(rootReal, '.playcraft', `.remix-references-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, serialized, { flag: 'wx', mode: 0o644 });
+        assertCurrent();
+        await safeDirectory(rootReal, '.playcraft');
+        await rename(temporary, join(rootReal, WORKSPACE_REMIX_REFERENCES_MANIFEST));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    await trackReference(rootReal, record);
+    return record;
+}
+export async function importWorkspaceRemixReference(root, directoryName, snapshot, assertCurrent = () => { }) {
+    const previous = locks.get(root) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(() => importReference(root, directoryName, snapshot, assertCurrent));
+    locks.set(root, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (locks.get(root) === current)
+            locks.delete(root);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { readWorkspaceFile } from './files.js';
+import { revisionScope, workspaceRoot } from './registry.js';
+/** Observe native/manual edits before checking an editor's conditional write. */
+export async function withObservedFile(state, workspaceId, path, action, directoryName = 'basic') {
+    const scope = revisionScope(state, workspaceId, directoryName);
+    return state.journal.exclusive(`file:${scope ?? 'single'}:${path}`, async () => {
+        const records = state.journal.fileRevisions(scope);
+        const previous = records[path];
+        let file;
+        try {
+            file = await readWorkspaceFile(await workspaceRoot(state, workspaceId, directoryName), path, records);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const hash = file?.contentHash ?? '';
+        const revision = previous ? previous.revision + (previous.contentHash === hash ? 0 : 1) : 0;
+        if ((!previous && file) || (previous && previous.contentHash !== hash)) {
+            await state.journal.putFileRevision(path, { revision, contentHash: hash }, scope);
+        }
+        return action({ file: file ? { ...file, revision } : undefined, revision });
+    });
+}
+export async function readObservedFile(state, workspaceId, path, directoryName = 'basic') {
+    return withObservedFile(state, workspaceId, path, async ({ file }) => {
+        if (!file)
+            throw Object.assign(new Error('file_not_found'), { code: 'ENOENT' });
+        return file;
+    }, directoryName);
+}

package/dist/workspace-runtime/workspaces/session-image.js

@@ -0,0 +1,104 @@
+import { constants } from 'node:fs';
+import { lstat, open, realpath } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { WORKSPACE_ATTACHMENT_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
+import { artifactPath } from './artifact-files.js';
+import { imageMime } from './attachments.js';
+import { sessionWorkspaceRoot } from './registry.js';
+/** Paths come from local history or an authenticated controller's archived conversation item. */
+export async function serveSessionImage(state, request, response, query, recordedPath) {
+    let handle;
+    try {
+        const workspaceId = query.get('workspaceId') ?? '', sessionId = query.get('sessionId') ?? '';
+        const itemId = query.get('itemId') ?? '', directoryName = query.get('directoryName') ?? 'basic';
+        if ([workspaceId, sessionId, itemId].some(id => !id || id.length > 128 || id.includes('\0'))
+            || query.has('path') || state.journal.destroyed())
+            throw new Error('image_not_found');
+        const archivedPath = request.method === 'POST' ? recordedPath : undefined;
+        const session = state.journal.getSession(sessionId);
+        if ((!session && archivedPath === undefined) || (session && (session.workspaceId !== workspaceId
+            || (session.directoryName ?? 'basic') !== directoryName)))
+            throw new Error('image_not_found');
+        const root = await sessionWorkspaceRoot(state, workspaceId, directoryName);
+        let imagePath = archivedPath;
+        for (const event of imagePath ? [] : state.journal.listEvents().reverse()) {
+            if (!['item/started', 'item/completed', 'item.started', 'item.completed'].includes(event.type))
+                continue;
+            const payload = record(event.payload), item = record(payload.item);
+            if (payload.sessionId === sessionId && payload.workspaceId === workspaceId
+                && (payload.directoryName === undefined || payload.directoryName === directoryName)
+                && item.type === 'imageView' && item.id === itemId && typeof item.path === 'string') {
+                imagePath = item.path;
+                break;
+            }
+        }
+        // Acknowledged source events can be reclaimed; native history remains the authority afterwards.
+        if (!imagePath && session && state.native?.readThreadImage) {
+            const threadIds = new Set([session.threadId]);
+            for (const { operation } of state.journal.listOperations()) {
+                if (operation.sessionId === sessionId && operation.workspaceId === workspaceId
+                    && (operation.directoryName ?? 'basic') === directoryName && operation.nativeThreadId)
+                    threadIds.add(operation.nativeThreadId);
+            }
+            for (const threadId of threadIds) {
+                imagePath = await state.native.readThreadImage({ threadId, itemId });
+                if (imagePath)
+                    break;
+            }
+        }
+        if (!imagePath || imagePath.length > 4096 || imagePath.includes('\0') || imagePath.includes('\\'))
+            throw new Error('image_not_found');
+        const temporaryRoot = await realpath('/tmp');
+        const target = imagePath.startsWith('/tmp/') ? resolve(temporaryRoot, imagePath.slice('/tmp/'.length))
+            : isAbsolute(imagePath) ? resolve(imagePath) : resolve(root, imagePath);
+        const stateRoot = await realpath(state.config.stateDir);
+        const workspaceParent = await realpath(state.config.workspaceRoot);
+        if (inside(stateRoot, target))
+            throw new Error('image_not_found');
+        const allowedRoot = inside(root, target) ? root
+            : inside(temporaryRoot, target) && !inside(workspaceParent, target) ? temporaryRoot : undefined;
+        if (!allowedRoot)
+            throw new Error('image_not_found');
+        const path = await artifactPath(allowedRoot, relative(allowedRoot, target).split(sep).join('/'));
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const before = await handle.stat();
+        const current = await lstat(await artifactPath(allowedRoot, relative(allowedRoot, target).split(sep).join('/')));
+        if (current.dev !== before.dev || current.ino !== before.ino)
+            throw new Error('image_not_found');
+        if (!before.isFile() || before.nlink !== 1 || before.size === 0 || before.size > WORKSPACE_ATTACHMENT_MAX_BYTES)
+            throw new Error('image_not_found');
+        const bytes = Buffer.alloc(before.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const read = await handle.read(bytes, offset, bytes.length - offset, offset);
+            if (!read.bytesRead)
+                throw new Error('image_not_found');
+            offset += read.bytesRead;
+        }
+        const after = await handle.stat(), mimeType = imageMime(bytes);
+        if (mimeType === 'application/octet-stream' || before.size !== after.size
+            || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+            throw new Error('image_not_found');
+        response.writeHead(200, {
+            'content-type': mimeType,
+            'content-length': String(bytes.length),
+            'cache-control': 'private, no-store',
+            'x-content-type-options': 'nosniff',
+            'content-security-policy': "sandbox; default-src 'none'",
+            'referrer-policy': 'no-referrer',
+        });
+        response.end(request.method === 'HEAD' ? undefined : bytes);
+    }
+    catch {
+        response.writeHead(404, { 'content-type': 'application/json', 'cache-control': 'private, no-store',
+            'x-content-type-options': 'nosniff' });
+        response.end(request.method === 'HEAD' ? undefined : JSON.stringify({ error: 'image_not_found' }));
+    }
+    finally {
+        await handle?.close();
+    }
+}
+function inside(root, target) { return target === root || target.startsWith(`${root}${sep}`); }
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}

package/dist/workspace-runtime/workspaces/shared-git.js

@@ -0,0 +1,40 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { launcherSocket, runDeveloperCommand } from './developer-command.js';
+import { shareWorkspaceRepository } from './git.js';
+/**
+ * Directories under `.git` this process cannot write: another user created them without group
+ * write. Only their owner can change that, so they are reported rather than fixed here.
+ */
+export async function foreignUnwritableGitDirectories(root) {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined;
+    const found = [];
+    const visit = async (path) => {
+        const stat = await lstat(path).catch(() => undefined);
+        if (!stat?.isDirectory())
+            return;
+        if (stat.uid !== uid && (stat.mode & 0o020) === 0)
+            found.push(path);
+        for (const entry of await readdir(path).catch(() => []))
+            await visit(join(path, entry));
+    };
+    await visit(join(root, '.git'));
+    return found;
+}
+/**
+ * Prepares a workspace repository for a Git write by this process: new directories become group
+ * writable, and directories the development user already made without group write are opened by
+ * that user through the launcher. Without a launcher (local runs) both users are the same.
+ */
+export async function shareWorkspaceGit(state, root) {
+    await shareWorkspaceRepository(root).catch(() => undefined);
+    if (!launcherSocket(state) || !(await foreignUnwritableGitDirectories(root)).length)
+        return;
+    await runDeveloperCommand(state, {
+        processId: `git-share-${Date.now().toString(36)}`,
+        cwd: root,
+        command: 'find .git -type d -uid "$(id -u)" ! -perm -g+w -exec chmod g+ws {} +',
+        timeoutMs: 30_000,
+        onOutput: () => undefined,
+    }).catch(() => undefined);
+}

package/dist/workspace-runtime/workspaces/skill-artifact-loader.js

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+import { workspaceRoot } from './registry.js';
+import { PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
+const MAX_ARTIFACT_BYTES = 80 * 1024 * 1024;
+/** Requests an exact locked artifact using control identity; no storage credentials reach Codex. */
+export async function loadWorkspaceSkillArtifact(state, workspaceId, entry, directoryName = 'basic') {
+    await workspaceRoot(state, workspaceId, directoryName);
+    return requestWorkspaceSkillArtifact(state, workspaceId, entry);
+}
+async function requestWorkspaceSkillArtifact(state, workspaceId, entry) {
+    const epoch = state.runtimeEpoch;
+    if (state.journal.destroyed())
+        throw new Error('workspace_skills_unavailable');
+    const endpoint = platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.skillArtifacts);
+    const response = await fetch(endpoint, {
+        method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
+        headers: { authorization: `Bearer ${state.config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': state.config.environment },
+        body: JSON.stringify({ runtimeId: state.config.runtimeId, generation: state.config.generation,
+            runtimeEpoch: epoch, workspaceId, entryKey: entry.entryKey, revision: entry.revision }),
+    });
+    if (!response.ok || !response.body) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new Error(response.status === 401 || response.status === 403
+            ? 'workspace_skills_unavailable' : 'workspace_skills_artifact_unavailable');
+    }
+    const reader = response.body.getReader(), chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            total += chunk.value.byteLength;
+            if (total > Math.ceil(MAX_ARTIFACT_BYTES * 4 / 3) + 4096)
+                throw new Error('workspace_skills_artifact_too_large');
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+    const result = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (typeof result.content !== 'string' || result.artifactHash !== entry.revision.artifactHash
+        || result.content.length > Math.ceil(MAX_ARTIFACT_BYTES * 4 / 3) || result.content.length % 4 !== 0 || /[^A-Za-z0-9+/=]/.test(result.content))
+        throw new Error('workspace_skills_digest_mismatch');
+    const archive = Buffer.from(result.content, 'base64');
+    if (archive.byteLength > MAX_ARTIFACT_BYTES || archive.toString('base64') !== result.content || createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    if (state.journal.destroyed() || epoch !== state.runtimeEpoch)
+        throw new Error('workspace_skills_unavailable');
+    return archive;
+}
+/** The platform independently authorizes the trusted binding, including an unpublished checkout. */
+export function workspacePlatformSkillAccess(state, workspaceId) {
+    return {
+        resolve: async (skillRefs) => {
+            const epoch = state.runtimeEpoch;
+            if (state.journal.destroyed())
+                throw new Error('workspace_skills_unavailable');
+            const response = await fetch(`${platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.skillArtifacts)}/resolve`, {
+                method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
+                headers: { authorization: `Bearer ${state.config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': state.config.environment },
+                body: JSON.stringify({ runtimeId: state.config.runtimeId, generation: state.config.generation,
+                    runtimeEpoch: epoch, workspaceId, skillRefs }),
+            });
+            if (!response.ok) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new Error(response.status === 401 || response.status === 403
+                    ? 'workspace_skills_unavailable' : 'workspace_skills_platform_unavailable');
+            }
+            if (!response.body)
+                throw new Error('workspace_skills_platform_unavailable');
+            const reader = response.body.getReader(), chunks = [];
+            let total = 0;
+            try {
+                while (true) {
+                    const part = await reader.read();
+                    if (part.done)
+                        break;
+                    total += part.value.byteLength;
+                    if (total > 1024 * 1024)
+                        throw new Error('workspace_skills_platform_unavailable');
+                    chunks.push(part.value);
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => undefined);
+            }
+            if (state.journal.destroyed() || epoch !== state.runtimeEpoch)
+                throw new Error('workspace_skills_unavailable');
+            return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        },
+        loadArtifact: entry => requestWorkspaceSkillArtifact(state, workspaceId, entry),
+    };
+}