@playcraft/cli 0.1.42 → 0.1.43-beta

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

@@ -0,0 +1,272 @@
+import { readdir, readFile, realpath } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+import JSON5 from 'json5';
+import { parameterDocumentSchema, parameterPatchPayloadSchema, workspaceRelativePathSchema, WORKSPACE_FILE_CONTENT_MAX, } from '@playcraft/common/cloud-workspace/runtime';
+import { InvalidWorkspacePathError, writeWorkspaceFile, } from './files.js';
+import { ParameterEditError, replaceJson5Path } from './json5-edit.js';
+const MANIFEST_PATH = '.playcraft/workspace.json';
+const DEFAULT_SCHEMA_PATH = 'src/theme/theme.schema.json5';
+const THEME_INDEX_PATH = 'src/theme/index.ts';
+const THEME_ROOT = 'src/theme';
+export async function readWorkspaceParameters(root, revisions) {
+    const located = await locateParameterFiles(root);
+    if (located.errors.some((item) => item.reason === 'parameter_manifest_invalid')) {
+        return parameterDocumentSchema.parse({ status: 'invalid', errors: located.errors });
+    }
+    if (!located.schemaPath) {
+        return parameterDocumentSchema.parse({
+            status: 'missing',
+            ...(located.errors.length > 0 ? { errors: located.errors } : {}),
+        });
+    }
+    const schemaFile = await readOptionalJson5(root, located.schemaPath);
+    if (schemaFile.status === 'missing') {
+        return parameterDocumentSchema.parse({
+            status: 'missing',
+            schemaPath: located.schemaPath,
+            themeId: located.themeId,
+        });
+    }
+    if (schemaFile.status === 'invalid') {
+        return parameterDocumentSchema.parse({
+            status: 'invalid',
+            schemaPath: located.schemaPath,
+            themeId: located.themeId,
+            errors: [{ path: located.schemaPath, reason: schemaFile.reason }],
+        });
+    }
+    if (!located.dataPath) {
+        return parameterDocumentSchema.parse({
+            status: 'schema_only',
+            schemaPath: located.schemaPath,
+            themeId: located.themeId,
+            schema: schemaFile.value,
+            schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
+            ...(located.errors.length > 0 ? { errors: located.errors } : {}),
+        });
+    }
+    const dataFile = await readOptionalJson5(root, located.dataPath);
+    if (dataFile.status === 'missing') {
+        return parameterDocumentSchema.parse({
+            status: 'schema_only',
+            schemaPath: located.schemaPath,
+            dataPath: located.dataPath,
+            themeId: located.themeId,
+            schema: schemaFile.value,
+            schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
+        });
+    }
+    if (dataFile.status === 'invalid') {
+        return parameterDocumentSchema.parse({
+            status: 'invalid',
+            schemaPath: located.schemaPath,
+            dataPath: located.dataPath,
+            themeId: located.themeId,
+            schema: schemaFile.value,
+            schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
+            errors: [{ path: located.dataPath, reason: dataFile.reason }],
+        });
+    }
+    return parameterDocumentSchema.parse({
+        status: 'ready',
+        schemaPath: located.schemaPath,
+        dataPath: located.dataPath,
+        themeId: located.themeId,
+        schema: schemaFile.value,
+        data: dataFile.value,
+        schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
+        dataRevision: revisions[located.dataPath]?.revision ?? 0,
+    });
+}
+export async function patchWorkspaceParameters(root, revisions, payload) {
+    const parsed = parameterPatchPayloadSchema.parse(payload);
+    const document = await readWorkspaceParameters(root, revisions);
+    if (document.status === 'missing' || document.status === 'schema_only' || !document.dataPath) {
+        throw new ParameterEditError('parameter_data_missing');
+    }
+    if (document.status === 'invalid')
+        throw new ParameterEditError('parameter_document_invalid');
+    const typeError = validateAgainstSchema(document.schema, parsed.fieldPath, parsed.value);
+    if (typeError)
+        throw new ParameterEditError(typeError);
+    const source = await readOptionalText(root, document.dataPath);
+    if (source === undefined)
+        throw new ParameterEditError('parameter_data_missing');
+    const next = replaceJson5Path(source, parsed.fieldPath, parsed.value);
+    JSON5.parse(next);
+    return writeWorkspaceFile(root, document.dataPath, next);
+}
+async function locateParameterFiles(root) {
+    const manifest = await readOptionalJson5(root, MANIFEST_PATH);
+    if (manifest.status === 'invalid') {
+        return { errors: [{ path: MANIFEST_PATH, reason: 'parameter_manifest_invalid' }] };
+    }
+    if (manifest.status === 'ok') {
+        const declared = declaredPaths(manifest.value);
+        if (!declared) {
+            return { errors: [{ path: MANIFEST_PATH, reason: 'parameter_manifest_invalid' }] };
+        }
+        if (declared.schemaPath || declared.dataPath)
+            return { ...declared, errors: [] };
+        if (declared.themeId) {
+            return {
+                schemaPath: DEFAULT_SCHEMA_PATH,
+                dataPath: `${THEME_ROOT}/${declared.themeId}/theme.data.json5`,
+                themeId: declared.themeId,
+                errors: [],
+            };
+        }
+    }
+    const schemaExists = (await readOptionalJson5(root, DEFAULT_SCHEMA_PATH)).status !== 'missing';
+    const theme = await readDeclaredTheme(root);
+    const dataPath = theme
+        ? `${THEME_ROOT}/${theme}/theme.data.json5`
+        : await uniqueThemeDataPath(root);
+    if (!schemaExists) {
+        return { themeId: theme, errors: [] };
+    }
+    if (!theme && (await listThemeDataFiles(root)).length > 1) {
+        return {
+            schemaPath: DEFAULT_SCHEMA_PATH,
+            errors: [{ path: THEME_INDEX_PATH, reason: 'theme_data_ambiguous' }],
+        };
+    }
+    return {
+        schemaPath: DEFAULT_SCHEMA_PATH,
+        dataPath,
+        themeId: theme,
+        errors: [],
+    };
+}
+function declaredPaths(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const parameters = value.parameters;
+    if (parameters === undefined)
+        return {};
+    if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters))
+        return undefined;
+    const record = parameters;
+    if (Object.keys(record).some((key) => !['schemaPath', 'dataPath', 'themeId'].includes(key))) {
+        return undefined;
+    }
+    const schemaPath = record.schemaPath === undefined ? undefined : workspaceRelativePathSchema.safeParse(record.schemaPath);
+    const dataPath = record.dataPath === undefined ? undefined : workspaceRelativePathSchema.safeParse(record.dataPath);
+    const themeId = record.themeId === undefined
+        ? undefined
+        : typeof record.themeId === 'string' && record.themeId.trim() && record.themeId.length <= 128
+            ? record.themeId.trim()
+            : undefined;
+    if (record.schemaPath !== undefined && !schemaPath?.success)
+        return undefined;
+    if (record.dataPath !== undefined && !dataPath?.success)
+        return undefined;
+    if (record.themeId !== undefined && !themeId)
+        return undefined;
+    return {
+        schemaPath: schemaPath?.success ? schemaPath.data : undefined,
+        dataPath: dataPath?.success ? dataPath.data : undefined,
+        themeId,
+    };
+}
+async function readDeclaredTheme(root) {
+    const contents = await readOptionalText(root, THEME_INDEX_PATH);
+    if (!contents)
+        return undefined;
+    const text = contents.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
+    const match = text.match(/export\s+\{\s*default\s*\}\s+from\s+['"]\.\/([^'"]+)['"]/);
+    const themeId = match?.[1]?.trim();
+    return themeId && workspaceRelativePathSchema.safeParse(`${THEME_ROOT}/${themeId}/theme.data.json5`).success
+        ? themeId
+        : undefined;
+}
+async function uniqueThemeDataPath(root) {
+    const files = await listThemeDataFiles(root);
+    return files.length === 1 ? files[0] : undefined;
+}
+async function listThemeDataFiles(root) {
+    try {
+        const rootReal = await realpath(root);
+        const themeRoot = resolve(rootReal, ...THEME_ROOT.split('/'));
+        const entries = await readdir(themeRoot, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            const relativePath = `${THEME_ROOT}/${entry.name}/theme.data.json5`;
+            if ((await readOptionalText(root, relativePath)) !== undefined)
+                files.push(relativePath);
+        }
+        return files;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function readOptionalJson5(root, relativePath) {
+    const text = await readOptionalText(root, relativePath);
+    if (text === undefined)
+        return { status: 'missing' };
+    try {
+        return { status: 'ok', value: JSON5.parse(text) };
+    }
+    catch {
+        return { status: 'invalid', reason: 'parameter_document_invalid' };
+    }
+}
+async function readOptionalText(root, relativePath) {
+    const parsed = workspaceRelativePathSchema.safeParse(relativePath);
+    if (!parsed.success)
+        return undefined;
+    try {
+        const rootReal = await realpath(root);
+        const target = resolve(rootReal, ...parsed.data.split('/'));
+        const text = await readFile(target, 'utf8');
+        const existing = await realpath(target);
+        const rel = relative(rootReal, existing);
+        if (rel === '' || rel === '..' || rel.startsWith(`..${sep}`) || rel.startsWith('..')) {
+            throw new InvalidWorkspacePathError(relativePath);
+        }
+        if (Buffer.byteLength(text, 'utf8') > WORKSPACE_FILE_CONTENT_MAX) {
+            throw new ParameterEditError('parameter_document_invalid');
+        }
+        return text;
+    }
+    catch (error) {
+        if (error instanceof ParameterEditError || error instanceof InvalidWorkspacePathError)
+            throw error;
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function validateAgainstSchema(schema, fieldPath, value) {
+    let node = schema;
+    for (const key of fieldPath) {
+        if (!node || typeof node !== 'object' || Array.isArray(node))
+            return 'parameter_value_invalid';
+        const properties = node.properties;
+        if (!properties || typeof properties !== 'object' || Array.isArray(properties))
+            return 'parameter_value_invalid';
+        node = properties[key];
+        if (node === undefined)
+            return undefined;
+    }
+    if (!node || typeof node !== 'object' || Array.isArray(node))
+        return undefined;
+    const type = node.type;
+    if (type === 'string')
+        return typeof value === 'string' ? undefined : 'parameter_value_invalid';
+    if (type === 'boolean')
+        return typeof value === 'boolean' ? undefined : 'parameter_value_invalid';
+    if (type === 'integer')
+        return Number.isInteger(value) ? undefined : 'parameter_value_invalid';
+    if (type === 'number') {
+        return typeof value === 'number' && Number.isFinite(value) ? undefined : 'parameter_value_invalid';
+    }
+    if (type === 'null')
+        return value === null ? undefined : 'parameter_value_invalid';
+    return undefined;
+}

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

@@ -0,0 +1,278 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isLocalWorkspaceGitAuthMode, isLocalWorkspaceGitEnvironment, matchWorkspaceGitGatewayCloneUrl, sameWorkspaceRegistration, workspacePreparationSchema, workspaceRegistrationSchema, workspaceDirectoryNameSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { WorkspaceContextError } from './context-error.js';
+import { workspacePlatformSkillAccess } from './skill-artifact-loader.js';
+import { scaffoldEmptyWorkspace } from './empty-template.js';
+const SKILL_PREPARATION_ERRORS = new Set([
+    'workspace_skills_unavailable',
+    'workspace_skills_platform_required',
+    'workspace_skills_platform_unavailable',
+    'workspace_skills_artifact_unavailable',
+    'workspace_skills_artifact_too_large',
+    'workspace_skills_digest_mismatch',
+    'workspace_skills_invalid',
+    'workspace_skills_invalid_bundle',
+    'workspace_skills_builtin_unknown',
+    'workspace_skills_builtin_conflict',
+]);
+/** The caller holds the Workspace lock. Only an absent, never-published directory may be prepared. */
+export async function prepareWorkspaceCheckout(state, binding, input, leaseFence, directoryName = 'basic', recovery = false) {
+    const preparation = workspacePreparationSchema.safeParse(input);
+    if (!preparation.success)
+        throw new WorkspaceContextError('invalid_workspace_preparation');
+    const standalone = binding.targetKind === 'standalone';
+    if (standalone !== (preparation.data.mode === 'empty'))
+        throw new WorkspaceContextError('invalid_workspace_preparation');
+    const clone = preparation.data.mode === 'clone' ? preparation.data : undefined;
+    const source = binding.repositoryUrl ? parseCloneSource(binding.repositoryUrl) : undefined;
+    const direct = isLocalWorkspaceGitAuthMode(clone?.authMode);
+    if (direct && (!isLocalWorkspaceGitEnvironment(state.config.environment) || !clone?.directAccess
+        || clone.directAccess.repositoryUrl !== binding.repositoryUrl))
+        throw new WorkspaceContextError('workspace_git_gateway_unavailable');
+    const parent = await realpath(state.config.workspaceRoot);
+    const workspace = join(parent, binding.workspaceId);
+    workspaceDirectoryNameSchema.parse(directoryName);
+    const target = join(workspace, directoryName);
+    const receiptDir = join(state.config.stateDir, 'workspace-preparations');
+    await mkdir(receiptDir, { recursive: true, mode: 0o700 });
+    const receiptPath = join(receiptDir, `${binding.workspaceId}${directoryName === 'basic' ? '' : `--${directoryName}`}.json`);
+    let previous = await readReceipt(receiptPath, binding);
+    if (recovery && previous?.status === 'published')
+        previous = undefined;
+    if (previous?.status === 'published')
+        throw new WorkspaceContextError('workspace_recovery_required');
+    if (await exists(target))
+        throw new WorkspaceContextError('workspace_checkout_conflict');
+    if (await exists(workspace)) {
+        const stat = await lstat(workspace);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(workspace) !== workspace)
+            throw new WorkspaceContextError('invalid_workspace_directory');
+    }
+    // An unfinished checkout recorded before the fork instructions were known must be cloned again.
+    const forkMatches = !previous || samePendingFork(previous.binding, binding);
+    if (previous && !forkMatches)
+        await rm(join(parent, previous.stagingName), { recursive: true, force: true });
+    const receipt = previous && forkMatches ? previous : {
+        binding,
+        stagingName: `.prepare-${binding.workspaceId}-${randomUUID()}`,
+        status: 'cloning',
+    };
+    const staging = join(parent, receipt.stagingName);
+    const assertCurrent = () => {
+        if (state.journal.destroyed())
+            throw new WorkspaceContextError('runtime_destroyed');
+        if (leaseFence < state.acceptedLeaseFence)
+            throw new WorkspaceContextError('stale_lease');
+    };
+    assertCurrent();
+    if (receipt.status === 'cloning') {
+        // Persist ownership before creating/removing a staging directory, so a crash can be retried.
+        await writeReceipt(receiptPath, receipt);
+        await rm(staging, { recursive: true, force: true });
+        await mkdir(staging, { mode: 0o700 });
+        const access = clone?.gitAccess;
+        const credential = clone?.directAccess ?? access;
+        const now = Date.now();
+        if (access &&
+            (Date.parse(access.issuedAt) > now || Date.parse(access.expiresAt) <= now + 10_000)) {
+            await rm(staging, { recursive: true, force: true });
+            throw new WorkspaceContextError('workspace_git_access_expired');
+        }
+        const transport = clone?.transport;
+        if (transport && !matchWorkspaceGitGatewayCloneUrl(transport.cloneUrl, state.config.gitGatewayOrigins, binding.repositoryUrl).ok) {
+            await rm(staging, { recursive: true, force: true });
+            throw new WorkspaceContextError('workspace_git_gateway_unavailable');
+        }
+        const deadline = Math.min(now + 90_000, access ? Date.parse(access.expiresAt) : Infinity);
+        const env = {
+            PATH: process.env.PATH,
+            HOME: state.config.stateDir,
+            GIT_CONFIG_NOSYSTEM: '1',
+            GIT_CONFIG_GLOBAL: '/dev/null',
+            GIT_TERMINAL_PROMPT: '0',
+            GIT_ALLOW_PROTOCOL: 'http:https',
+        };
+        // The authenticated registration already carries this operation's scoped credential.
+        // No publisher ledger is mounted in the sandbox; secrets exist only in this child environment.
+        if (credential) {
+            env.GIT_CONFIG_COUNT = transport ? '2' : '1';
+            env.GIT_CONFIG_KEY_0 = `http.${transport?.cloneUrl ?? source.href}.extraHeader`;
+            env.GIT_CONFIG_VALUE_0 = `Authorization: Basic ${Buffer.from(`${credential.username}:${credential.password}`).toString('base64')}`;
+            if (transport) {
+                env.GIT_CONFIG_KEY_1 = `url.${transport.cloneUrl}.insteadOf`;
+                env.GIT_CONFIG_VALUE_1 = binding.repositoryUrl;
+            }
+        }
+        try {
+            if (standalone) {
+                await runGit(['init', '--initial-branch=main', staging], env, deadline);
+                await scaffoldEmptyWorkspace(staging, join(state.config.stateDir, 'skill-artifacts'), workspacePlatformSkillAccess(state, binding.workspaceId));
+            }
+            else {
+                const fork = binding.pendingFork;
+                const cloneBranch = fork?.sourceBranchName ?? binding.branchName;
+                await runGit(['check-ref-format', '--branch', binding.branchName], env, deadline);
+                await runGit(['check-ref-format', '--branch', cloneBranch], env, deadline);
+                await runGit([
+                    'clone',
+                    '--no-checkout',
+                    '--single-branch',
+                    '--branch',
+                    cloneBranch,
+                    '--',
+                    binding.repositoryUrl,
+                    staging,
+                ], env, deadline);
+                // Checkout never receives the temporary credential and never invokes repository hooks or global filters.
+                clearCloneSecrets(env);
+                if (fork) {
+                    await runGit(['-C', staging, 'checkout', '-b', binding.branchName, fork.sourceCommit], env, deadline);
+                }
+                else {
+                    await runGit(['-C', staging, 'checkout', '--force', binding.branchName], env, deadline);
+                }
+            }
+            assertCurrent();
+            receipt.status = 'ready';
+            await writeReceipt(receiptPath, receipt);
+        }
+        catch (error) {
+            await rm(staging, { recursive: true, force: true });
+            if (error instanceof WorkspaceContextError)
+                throw error;
+            if (standalone && error instanceof Error && SKILL_PREPARATION_ERRORS.has(error.message))
+                throw new WorkspaceContextError(error.message);
+            throw new WorkspaceContextError('workspace_clone_failed');
+        }
+        finally {
+            clearCloneSecrets(env);
+        }
+    }
+    const stat = await lstat(staging).catch(() => undefined);
+    if (!stat?.isDirectory() || stat.isSymbolicLink())
+        throw new WorkspaceContextError('workspace_recovery_required');
+    assertCurrent();
+    if (await exists(target))
+        throw new WorkspaceContextError('workspace_checkout_conflict');
+    if (await exists(workspace)) {
+        const stat = await lstat(workspace);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(workspace) !== workspace)
+            throw new WorkspaceContextError('invalid_workspace_directory');
+    }
+    await mkdir(workspace, { recursive: true, mode: 0o700 });
+    await rename(staging, target);
+    receipt.status = 'published';
+    await writeReceipt(receiptPath, receipt);
+}
+function clearCloneSecrets(env) {
+    for (const key of [
+        'GIT_CONFIG_COUNT',
+        'GIT_CONFIG_KEY_0',
+        'GIT_CONFIG_VALUE_0',
+        'GIT_CONFIG_KEY_1',
+        'GIT_CONFIG_VALUE_1',
+    ]) {
+        delete env[key];
+    }
+}
+function parseCloneSource(value) {
+    try {
+        const source = new URL(value);
+        if ((source.protocol !== 'https:' &&
+            !(source.protocol === 'http:' &&
+                ['127.0.0.1', '[::1]', 'localhost'].includes(source.hostname))) ||
+            source.username ||
+            source.password ||
+            source.search ||
+            source.hash)
+            throw new Error();
+        return source;
+    }
+    catch {
+        throw new WorkspaceContextError('workspace_clone_transport_unavailable');
+    }
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function samePendingFork(left, right) {
+    const fork = (value) => value.targetKind === 'standalone' ? undefined : value.pendingFork;
+    return JSON.stringify(fork(left) ?? null) === JSON.stringify(fork(right) ?? null);
+}
+async function readReceipt(path, binding) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        const parsed = workspaceRegistrationSchema.parse(value.binding);
+        if (!sameWorkspaceRegistration(parsed, binding) ||
+            !['cloning', 'ready', 'published'].includes(value.status) ||
+            !new RegExp(`^\\.prepare-${binding.workspaceId}-[0-9a-f-]{36}$`).test(value.stagingName))
+            throw new Error();
+        return { binding: parsed, stagingName: value.stagingName, status: value.status };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new WorkspaceContextError('workspace_preparation_receipt_invalid');
+    }
+}
+async function writeReceipt(path, value) {
+    const temp = `${path}.tmp`;
+    await writeFile(temp, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    await rename(temp, path);
+}
+function runGit(args, env, deadline) {
+    return new Promise((resolve, reject) => {
+        let timedOut = false;
+        const child = spawn('git', [
+            '-c',
+            'core.hooksPath=/dev/null',
+            '-c',
+            'credential.helper=',
+            '-c',
+            'http.followRedirects=false',
+            '-c',
+            'init.templateDir=',
+            ...args,
+        ], {
+            env,
+            detached: process.platform !== 'win32',
+            stdio: 'ignore',
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                if (process.platform !== 'win32' && child.pid)
+                    process.kill(-child.pid, 'SIGKILL');
+                else
+                    child.kill('SIGKILL');
+            }
+            catch {
+                /* The process may have already exited. */
+            }
+        }, Math.max(1, deadline - Date.now()));
+        child.once('error', () => {
+            clearTimeout(timer);
+            reject(new WorkspaceContextError('workspace_clone_failed'));
+        });
+        child.once('exit', (code) => {
+            clearTimeout(timer);
+            if (timedOut)
+                reject(new WorkspaceContextError('workspace_clone_timeout'));
+            else if (code === 0)
+                resolve();
+            else
+                reject(new WorkspaceContextError('workspace_clone_failed'));
+        });
+    });
+}