@playcraft/cli 0.0.56 → 0.0.58

package/dist/workspace-runtime/workspaces/json5-edit.js

@@ -0,0 +1,170 @@
+import JSON5 from 'json5';
+export class ParameterEditError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'ParameterEditError';
+    }
+}
+export function replaceJson5Path(source, fieldPath, value) {
+    const span = findJson5ValueSpan(source, fieldPath);
+    if (!span)
+        throw new ParameterEditError('parameter_field_missing');
+    const current = skipTrivia(source, span.start, span.end);
+    if (source[current] === '{' || source[current] === '[') {
+        throw new ParameterEditError('parameter_value_invalid');
+    }
+    return `${source.slice(0, span.start)}${formatJson5Value(value, source.slice(span.start, span.end))}${source.slice(span.end)}`;
+}
+export function findJson5ValueSpan(source, fieldPath) {
+    const start = skipTrivia(source, 0, source.length);
+    if (source[start] !== '{')
+        throw new ParameterEditError('parameter_document_invalid');
+    return findInObject(source, start, source.length, fieldPath, 0);
+}
+function findInObject(source, braceIndex, end, fieldPath, depth) {
+    let index = skipTrivia(source, braceIndex + 1, end);
+    while (index < end) {
+        if (source[index] === '}')
+            return undefined;
+        const key = parseKey(source, index, end);
+        index = skipTrivia(source, key.end, end);
+        if (source[index] !== ':')
+            throw new ParameterEditError('parameter_document_invalid');
+        const value = scanValue(source, index + 1, end);
+        if (key.name === fieldPath[depth]) {
+            if (depth === fieldPath.length - 1)
+                return value;
+            const nested = skipTrivia(source, value.start, end);
+            if (source[nested] !== '{')
+                throw new ParameterEditError('parameter_field_missing');
+            return findInObject(source, nested, value.end, fieldPath, depth + 1);
+        }
+        index = skipTrivia(source, value.end, end);
+        if (source[index] === ',')
+            index = skipTrivia(source, index + 1, end);
+    }
+    throw new ParameterEditError('parameter_document_invalid');
+}
+function parseKey(source, start, end) {
+    const index = skipTrivia(source, start, end);
+    const first = source[index];
+    if (first === '"' || first === "'") {
+        const close = stringEnd(source, index, end);
+        return { name: JSON5.parse(source.slice(index, close)), end: close };
+    }
+    if (!/[A-Za-z_$]/.test(first ?? ''))
+        throw new ParameterEditError('parameter_document_invalid');
+    let cursor = index + 1;
+    while (cursor < end && /[A-Za-z0-9_$]/.test(source[cursor]))
+        cursor += 1;
+    return { name: source.slice(index, cursor), end: cursor };
+}
+function scanValue(source, from, end) {
+    const start = skipTrivia(source, from, end);
+    const first = source[start];
+    if (first === '"' || first === "'")
+        return { start, end: stringEnd(source, start, end) };
+    if (first === '{' || first === '[')
+        return { start, end: balancedEnd(source, start, end) };
+    let cursor = start;
+    while (cursor < end) {
+        const current = source[cursor];
+        if (/\s/.test(current) || current === ',' || current === '}' || current === ']' || current === '/')
+            break;
+        cursor += 1;
+    }
+    if (cursor === start)
+        throw new ParameterEditError('parameter_document_invalid');
+    return { start, end: cursor };
+}
+function balancedEnd(source, start, end) {
+    const open = source[start];
+    const close = open === '{' ? '}' : ']';
+    let depth = 0;
+    let index = start;
+    while (index < end) {
+        const current = source[index];
+        if (current === '"' || current === "'") {
+            index = stringEnd(source, index, end);
+            continue;
+        }
+        if (current === '/' && source[index + 1] === '/') {
+            index = skipTrivia(source, index, end);
+            continue;
+        }
+        if (current === '/' && source[index + 1] === '*') {
+            index = skipTrivia(source, index, end);
+            continue;
+        }
+        if (current === open)
+            depth += 1;
+        else if (current === close) {
+            depth -= 1;
+            if (depth === 0)
+                return index + 1;
+        }
+        index += 1;
+    }
+    throw new ParameterEditError('parameter_document_invalid');
+}
+function stringEnd(source, start, end) {
+    const quote = source[start];
+    let index = start + 1;
+    while (index < end) {
+        const current = source[index];
+        if (current === '\\') {
+            index += 2;
+            continue;
+        }
+        if (current === quote)
+            return index + 1;
+        index += 1;
+    }
+    throw new ParameterEditError('parameter_document_invalid');
+}
+function skipTrivia(source, start, end) {
+    let index = start;
+    while (index < end) {
+        const current = source[index];
+        if (/\s/.test(current)) {
+            index += 1;
+            continue;
+        }
+        if (current === '/' && source[index + 1] === '/') {
+            index += 2;
+            while (index < end && source[index] !== '\n')
+                index += 1;
+            continue;
+        }
+        if (current === '/' && source[index + 1] === '*') {
+            const close = source.indexOf('*/', index + 2);
+            if (close < 0 || close >= end)
+                throw new ParameterEditError('parameter_document_invalid');
+            index = close + 2;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function formatJson5Value(value, previous) {
+    if (typeof value === 'string') {
+        const trimmed = previous.trim();
+        if (trimmed.startsWith("'")) {
+            return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+        }
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'boolean' || value === null)
+        return String(value);
+    const trimmed = previous.trim();
+    if (/^[-+]?0x[0-9a-fA-F]+$/.test(trimmed) && Number.isInteger(value)) {
+        const sign = value < 0 ? '-' : trimmed.startsWith('+') ? '+' : '';
+        const hex = Math.abs(value).toString(16);
+        const upper = /[A-F]/.test(trimmed) && !/[a-f]/.test(trimmed);
+        return `${sign}0x${upper ? hex.toUpperCase() : hex}`;
+    }
+    return Number.isInteger(value) ? String(value) : JSON.stringify(value);
+}

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;
+}