@playcraft/cli 0.1.50-beta → 0.1.52

package/dist/workspace-runtime/workspaces/delivery-build.js

@@ -1,331 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { copyFile, mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
-import { createPlatformAdapter, getChannelRuleProfile, } from '@playcraft/build';
-import { DELIVERY_QUEUE_LIMIT, isWorkspaceArtifactOutputPath, } from '@playcraft/common/cloud-workspace/runtime';
-import { workspaceRoot } from './registry.js';
-import { excludeFromGit, ensureWorkspaceDependencies } from './dependencies.js';
-import { runDeveloperCommand } from './developer-command.js';
-import { DeliveryStore } from './delivery-store.js';
-import { DeliveryValidationError, validateDeliveryArtifact } from './delivery.js';
-export const DELIVERY_BUILD_TIMEOUT_MS = 10 * 60_000;
-const STAGING_DIRECTORY = '.playcraft-delivery';
-export class DeliveryBuildError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = 'DeliveryBuildError';
-    }
-}
-const queues = new WeakMap();
-const running = new WeakMap();
-export function trackDeliveryBuild(state, task) {
-    const tasks = running.get(state) ?? new Set();
-    running.set(state, tasks);
-    const tracked = task.finally(() => tasks.delete(tracked));
-    tasks.add(tracked);
-}
-export async function settleDeliveryBuilds(state) {
-    await Promise.all([...(running.get(state) ?? [])]);
-}
-const scopeKey = (workspaceId, directoryName) => `${workspaceId}\0${directoryName}`;
-function buildQueues(state) {
-    const known = queues.get(state) ?? new Map();
-    queues.set(state, known);
-    return known;
-}
-function queuedRecord(input, createdAt, queuePosition) {
-    return {
-        buildId: input.buildId,
-        workspaceId: input.workspaceId,
-        directoryName: input.directoryName,
-        channel: input.payload.channel,
-        format: input.payload.format,
-        status: 'queued',
-        ...(input.actor ? { actor: input.actor } : {}),
-        queuePosition,
-        createdAt,
-    };
-}
-async function refreshQueuedRecords(state, key) {
-    const queue = buildQueues(state).get(key);
-    if (!queue)
-        return;
-    const waiting = queue.queue.filter(item => !item.started && !item.canceled);
-    const workspaceId = waiting[0]?.input.workspaceId ?? queue.active?.pending.input.workspaceId;
-    if (!workspaceId)
-        return;
-    const store = new DeliveryStore(state.config.stateDir, workspaceId);
-    await Promise.all(waiting.map((item, index) => {
-        if (item.started || item.canceled)
-            return Promise.resolve();
-        return store.write(queuedRecord(item.input, item.createdAt, index + 1)).catch(() => undefined);
-    }));
-}
-function pump(state, key, queue) {
-    if (queue.active)
-        return;
-    const next = queue.queue.shift();
-    if (!next)
-        return;
-    next.started = true;
-    queue.active = { buildId: next.input.buildId, pending: next };
-    void executeBuild(state, next.input, next.controller)
-        .then(outcome => next.resolve(outcome), error => next.reject(error))
-        .finally(() => {
-        queue.active = undefined;
-        pump(state, key, queue);
-        void refreshQueuedRecords(state, key);
-    });
-}
-export function runDeliveryBuild(state, input) {
-    if (input.directoryName === 'root')
-        return Promise.reject(new DeliveryBuildError('invalid_workspace_directory'));
-    const key = scopeKey(input.workspaceId, input.directoryName);
-    const scopes = buildQueues(state);
-    const queue = scopes.get(key) ?? { queue: [] };
-    if ((queue.active ? 1 : 0) + queue.queue.length >= DELIVERY_QUEUE_LIMIT) {
-        return Promise.reject(new DeliveryBuildError('delivery_queue_full'));
-    }
-    let resolve;
-    let reject;
-    const promise = new Promise((resolvePromise, rejectPromise) => {
-        resolve = resolvePromise;
-        reject = rejectPromise;
-    });
-    const pending = {
-        input,
-        controller: new AbortController(),
-        promise,
-        resolve,
-        reject,
-        createdAt: new Date().toISOString(),
-        canceled: false,
-        started: false,
-    };
-    queue.queue.push(pending);
-    scopes.set(key, queue);
-    pump(state, key, queue);
-    void refreshQueuedRecords(state, key);
-    return promise;
-}
-export async function cancelDeliveryBuild(state, workspaceId, directoryName, buildId) {
-    const key = scopeKey(workspaceId, directoryName);
-    const queue = buildQueues(state).get(key);
-    if (!queue)
-        return false;
-    if (queue.active?.buildId === buildId) {
-        queue.active.pending.controller.abort();
-        return true;
-    }
-    const index = queue.queue.findIndex(item => item.input.buildId === buildId);
-    if (index < 0)
-        return false;
-    const [pending] = queue.queue.splice(index, 1);
-    if (!pending)
-        return false;
-    pending.canceled = true;
-    const record = {
-        ...queuedRecord(pending.input, pending.createdAt, 0),
-        status: 'canceled',
-        finishedAt: new Date().toISOString(),
-        error: 'delivery_canceled',
-    };
-    await new DeliveryStore(state.config.stateDir, workspaceId).write(record).catch(() => undefined);
-    pending.resolve({ record });
-    void refreshQueuedRecords(state, key);
-    return true;
-}
-export function activeDeliveryBuild(state, workspaceId, directoryName) {
-    return buildQueues(state).get(scopeKey(workspaceId, directoryName))?.active?.buildId;
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function outputExtension(format) {
-    return format === 'zip' ? '.zip' : '.html';
-}
-async function listStagedFiles(staging, prefix = '') {
-    const entries = await readdir(join(staging, prefix), { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        if (entry.isSymbolicLink() || entry.name.startsWith('.'))
-            continue;
-        const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-            files.push(...await listStagedFiles(staging, relative));
-            if (files.length > 512)
-                throw new DeliveryBuildError('delivery_output_missing');
-        }
-        else if (entry.isFile()) {
-            files.push(relative);
-        }
-    }
-    return files;
-}
-function choosePrimary(files, format) {
-    const extension = outputExtension(format);
-    const candidates = files.filter(file => file.toLowerCase().endsWith(extension));
-    if (!candidates.length)
-        throw new DeliveryBuildError('delivery_output_missing');
-    const preferred = format === 'zip' ? 'playable.zip' : 'index.html';
-    return candidates.find(file => basename(file).toLowerCase() === preferred) ?? candidates[0];
-}
-/**
- * Copies a single artifact, or the whole staging tree for fragment/mixed channels. Each file is
- * staged next to its final name and renamed, so a partially written package never appears in dist.
- */
-async function copyToDist(root, staging, channel, format) {
-    const files = await listStagedFiles(staging);
-    const primary = choosePrimary(files, format);
-    const mode = getChannelRuleProfile(channel).deliveryMode;
-    const selected = files.length > 1 && (mode === 'fragment-assets' || mode === 'mixed') ? files : [primary];
-    const paths = [];
-    let sizeBytes = 0;
-    for (const file of selected) {
-        const relative = `dist/delivery/${channel}/${file}`;
-        if (!isWorkspaceArtifactOutputPath(relative))
-            throw new DeliveryBuildError('delivery_output_missing');
-        const target = join(root, relative);
-        const directory = dirname(target);
-        await mkdir(directory, { recursive: true });
-        const temporary = join(directory, `.${basename(file)}.${randomUUID()}.tmp`);
-        try {
-            await copyFile(join(staging, file), temporary);
-            await rename(temporary, target);
-        }
-        catch {
-            await rm(temporary, { force: true }).catch(() => undefined);
-            throw new DeliveryBuildError('delivery_copy_failed');
-        }
-        sizeBytes += (await stat(target)).size;
-        paths.push(relative);
-    }
-    return { primary: `dist/delivery/${channel}/${primary}`, paths, sizeBytes };
-}
-/**
- * Runs one channel build. The build writes into a disposable staging directory; only the final
- * artifact is copied into dist so the builder's `--clean` can never erase another delivery.
- */
-async function executeBuild(state, input, controller) {
-    if (input.directoryName === 'root')
-        throw new DeliveryBuildError('invalid_workspace_directory');
-    const root = await workspaceRoot(state, input.workspaceId, input.directoryName);
-    const store = new DeliveryStore(state.config.stateDir, input.workspaceId);
-    const startedAt = new Date().toISOString();
-    const base = {
-        buildId: input.buildId,
-        workspaceId: input.workspaceId,
-        directoryName: input.directoryName,
-        channel: input.payload.channel,
-        format: input.payload.format,
-        status: 'running',
-        ...(input.actor ? { actor: input.actor } : {}),
-        createdAt: startedAt,
-        startedAt,
-    };
-    await store.write(base);
-    const staging = join(root, STAGING_DIRECTORY, input.buildId);
-    let status = 'running';
-    let error;
-    let validationError;
-    let outputPath;
-    let outputPaths;
-    let sizeBytes;
-    let sizeLimitBytes;
-    let report;
-    let logChain = Promise.resolve();
-    let record;
-    try {
-        await mkdir(staging, { recursive: true });
-        await excludeFromGit(root, `/${STAGING_DIRECTORY}/`);
-        await excludeFromGit(root, '/dist/');
-        const dependencies = await ensureWorkspaceDependencies(state, input.workspaceId, root);
-        if (!dependencies.ok) {
-            if (dependencies.logTail) {
-                await store.appendLog(input.buildId, `\n${dependencies.logTail}\n`);
-            }
-            throw new DeliveryBuildError('delivery_dependencies_failed');
-        }
-        const planned = process.env.PLAYCRAFT_DELIVERY_BUILD_COMMAND || 'playcraft build';
-        const command = `umask 002 && NO_COLOR=1 CI=1 ${planned} . --platform ${input.payload.channel} --format ${input.payload.format} --output ${shellQuote(staging)} --mode full`;
-        const outcome = await runDeveloperCommand(state, {
-            processId: `delivery-${input.buildId}`,
-            cwd: root,
-            command,
-            timeoutMs: DELIVERY_BUILD_TIMEOUT_MS,
-            signal: controller.signal,
-            onOutput: (chunk) => {
-                const text = String(chunk);
-                if (!text)
-                    return;
-                logChain = logChain.then(() => store.appendLog(input.buildId, text)).catch(() => undefined);
-            },
-        });
-        if (outcome.canceled) {
-            status = 'canceled';
-            error = 'delivery_canceled';
-        }
-        else if (outcome.timedOut) {
-            status = 'failed';
-            error = 'delivery_timeout';
-        }
-        else if (outcome.code !== 0) {
-            status = 'failed';
-            error = 'delivery_build_failed';
-        }
-        else {
-            const output = await copyToDist(root, staging, input.payload.channel, input.payload.format);
-            outputPath = output.primary;
-            outputPaths = output.paths;
-            sizeBytes = output.sizeBytes;
-            sizeLimitBytes = createPlatformAdapter({
-                platform: input.payload.channel,
-                format: input.payload.format,
-            }).getSizeLimit();
-            try {
-                const result = await validateDeliveryArtifact(root, {
-                    channel: input.payload.channel,
-                    format: input.payload.format,
-                    path: outputPath,
-                });
-                report = result.report;
-                sizeLimitBytes = result.sizeLimitBytes;
-            }
-            catch (cause) {
-                validationError = cause instanceof DeliveryValidationError ? cause.code : 'delivery_report_unavailable';
-            }
-            status = 'succeeded';
-        }
-    }
-    catch (cause) {
-        status = 'failed';
-        error = cause instanceof DeliveryBuildError ? cause.code : 'delivery_build_failed';
-    }
-    finally {
-        await rm(staging, { recursive: true, force: true }).catch(() => undefined);
-        await logChain;
-        if (report) {
-            await store.writeReport(input.buildId, report).catch(() => {
-                validationError = validationError ?? 'delivery_report_unavailable';
-            });
-        }
-        const recordValue = {
-            ...base,
-            status,
-            finishedAt: new Date().toISOString(),
-            ...(outputPath ? { outputPath } : {}),
-            ...(outputPaths && outputPaths.length > 1 ? { outputPaths } : {}),
-            ...(sizeBytes !== undefined ? { sizeBytes } : {}),
-            ...(sizeLimitBytes !== undefined ? { sizeLimitBytes } : {}),
-            ...(report ? { summary: report.summary, buildChain: report.buildChain } : {}),
-            ...(error ? { error } : {}),
-            ...(validationError ? { validationError } : {}),
-            logBytes: await store.logBytes(input.buildId),
-        };
-        record = recordValue;
-        await store.write(recordValue);
-    }
-    return { record, ...(report ? { report } : {}) };
-}

package/dist/workspace-runtime/workspaces/delivery-store.js

@@ -1,168 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { deliveryBuildRecordSchema, deliveryValidationReportSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { AppendOnlyLog } from './append-only-log.js';
-export const DELIVERY_LOG_MAX_BYTES = 2 * 1024 * 1024;
-export const DELIVERY_RECORD_LIMIT = 20;
-const BUILD_ID_PATTERN = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
-function assertBuildId(buildId) {
-    if (!BUILD_ID_PATTERN.test(buildId))
-        throw new Error('invalid_delivery_build_id');
-}
-function workspaceDirectory(stateDir, workspaceId) {
-    return join(stateDir, 'deliveries', createHash('sha256').update(workspaceId).digest('hex'));
-}
-/** Control-owned delivery history; never written inside the checkout. */
-export class DeliveryStore {
-    stateDir;
-    workspaceId;
-    directory;
-    constructor(stateDir, workspaceId) {
-        this.stateDir = stateDir;
-        this.workspaceId = workspaceId;
-        this.directory = workspaceDirectory(stateDir, workspaceId);
-    }
-    async ready() {
-        await mkdir(this.directory, { recursive: true, mode: 0o700 });
-        return this.directory;
-    }
-    recordPath(buildId) {
-        assertBuildId(buildId);
-        return join(this.directory, `${buildId}.json`);
-    }
-    reportPath(buildId) {
-        assertBuildId(buildId);
-        return join(this.directory, `${buildId}.report.json`);
-    }
-    logPath(buildId) {
-        assertBuildId(buildId);
-        return join(this.directory, `${buildId}.log`);
-    }
-    async writeJson(path, value) {
-        const temporary = `${path}.${randomUUID()}.tmp`;
-        try {
-            await writeFile(temporary, JSON.stringify(value), { mode: 0o600 });
-            await rename(temporary, path);
-        }
-        catch (error) {
-            await rm(temporary, { force: true }).catch(() => undefined);
-            throw error;
-        }
-    }
-    async write(record) {
-        const parsed = deliveryBuildRecordSchema.parse(record);
-        await this.ready();
-        await this.writeJson(this.recordPath(parsed.buildId), parsed);
-        await this.prune(parsed.channel);
-    }
-    async read(buildId) {
-        await this.ready();
-        try {
-            const value = JSON.parse(await readFile(this.recordPath(buildId), 'utf8'));
-            const parsed = deliveryBuildRecordSchema.safeParse(value);
-            return parsed.success ? parsed.data : undefined;
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        }
-    }
-    async readAll() {
-        await this.ready();
-        const names = await readdir(this.directory);
-        const records = [];
-        for (const name of names) {
-            if (!/^[a-f0-9-]{36}\.json$/i.test(name))
-                continue;
-            const record = await this.read(name.slice(0, -'.json'.length));
-            if (record)
-                records.push(record);
-        }
-        return records;
-    }
-    async list(directoryName, channel, limit = DELIVERY_RECORD_LIMIT) {
-        const records = (await this.readAll())
-            .filter(record => record.directoryName === directoryName && (!channel || record.channel === channel))
-            .sort((left, right) => right.createdAt.localeCompare(left.createdAt) || right.buildId.localeCompare(left.buildId));
-        return records.slice(0, Math.min(Math.max(limit, 1), 50));
-    }
-    async writeReport(buildId, report) {
-        const parsed = deliveryValidationReportSchema.parse(report);
-        await this.ready();
-        await this.writeJson(this.reportPath(buildId), parsed);
-    }
-    async readReport(buildId) {
-        await this.ready();
-        try {
-            const value = JSON.parse(await readFile(this.reportPath(buildId), 'utf8'));
-            const parsed = deliveryValidationReportSchema.safeParse(value);
-            return parsed.success ? parsed.data : undefined;
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        }
-    }
-    log(buildId) {
-        return new AppendOnlyLog(this.logPath(buildId), DELIVERY_LOG_MAX_BYTES, '[playcraft] delivery log truncated; showing the tail\n');
-    }
-    async appendLog(buildId, chunk) {
-        await this.ready();
-        await this.log(buildId).append(chunk);
-    }
-    async readLog(buildId, offset = 0) {
-        await this.ready();
-        return this.log(buildId).read(offset);
-    }
-    async logBytes(buildId) {
-        return this.log(buildId).size();
-    }
-    async prune(channel) {
-        const records = (await this.readAll())
-            .filter(record => record.channel === channel)
-            .sort((left, right) => right.createdAt.localeCompare(left.createdAt) || right.buildId.localeCompare(left.buildId));
-        if (records.length <= DELIVERY_RECORD_LIMIT)
-            return;
-        for (const record of records.slice(DELIVERY_RECORD_LIMIT)) {
-            await Promise.all([
-                rm(this.recordPath(record.buildId), { force: true }),
-                rm(this.reportPath(record.buildId), { force: true }),
-                rm(this.logPath(record.buildId), { force: true }),
-            ]);
-        }
-    }
-}
-/** A runtime restart leaves no build process behind; mark their records instead of showing them as running. */
-export async function recoverInterruptedDeliveries(stateDir) {
-    const root = join(stateDir, 'deliveries');
-    const buckets = await readdir(root, { withFileTypes: true }).catch(() => []);
-    for (const bucket of buckets) {
-        if (!bucket.isDirectory())
-            continue;
-        const directory = join(root, bucket.name);
-        const names = await readdir(directory).catch(() => []);
-        for (const name of names) {
-            if (!/^[a-f0-9-]{36}\.json$/i.test(name) || name.endsWith('.report.json'))
-                continue;
-            let record;
-            try {
-                const parsed = deliveryBuildRecordSchema.safeParse(JSON.parse(await readFile(join(directory, name), 'utf8')));
-                record = parsed.success ? parsed.data : undefined;
-            }
-            catch {
-                continue;
-            }
-            if (!record || !['queued', 'running'].includes(record.status))
-                continue;
-            await new DeliveryStore(stateDir, record.workspaceId).write({
-                ...record,
-                status: 'interrupted',
-                error: 'delivery_interrupted',
-                finishedAt: new Date().toISOString(),
-            });
-        }
-    }
-}

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

@@ -1,64 +0,0 @@
-import { stat } from 'node:fs/promises';
-import path from 'node:path';
-import { createPlatformAdapter, EngineDetector, runPlayableValidation, } from '@playcraft/build';
-import { deliveryValidateResultSchema, isWorkspaceArtifactOutputPath, } from '@playcraft/common/cloud-workspace/runtime';
-import { artifactPath } from './artifact-files.js';
-export class DeliveryValidationError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = 'DeliveryValidationError';
-    }
-}
-function buildChain(buildTool) {
-    if (buildTool === 'playable-scripts')
-        return 'devkit';
-    if (buildTool === 'playcanvas-native')
-        return 'playcanvas-native';
-    return 'generic';
-}
-/**
- * Validates an already-built artifact in the workspace's dist directory. It never builds: the
- * delivery UI uses it to re-check a file the user or the Agent produced.
- */
-export async function validateDeliveryArtifact(root, payload) {
-    if (!isWorkspaceArtifactOutputPath(payload.path))
-        throw new DeliveryValidationError('invalid_delivery_path');
-    let absolute;
-    try {
-        absolute = await artifactPath(root, payload.path);
-    }
-    catch {
-        throw new DeliveryValidationError('delivery_output_missing');
-    }
-    const info = await stat(absolute).catch(() => undefined);
-    if (!info?.isFile())
-        throw new DeliveryValidationError('delivery_output_missing');
-    const detection = await EngineDetector.detectFull(root).catch(() => ({
-        engine: 'generic',
-        buildTool: 'generic',
-    }));
-    const stages = payload.format === 'zip' ? ['delivery-package'] : ['html-artifact'];
-    let report;
-    try {
-        report = await runPlayableValidation({
-            projectRoot: root,
-            channel: payload.channel,
-            engine: detection.engine,
-            buildTool: detection.buildTool,
-            buildChain: buildChain(detection.buildTool),
-            ...(payload.format === 'zip' ? { packagePath: absolute } : { htmlPath: absolute }),
-            outputDir: path.dirname(absolute),
-        }, stages);
-    }
-    catch {
-        throw new DeliveryValidationError('delivery_validation_failed');
-    }
-    const adapter = createPlatformAdapter({ platform: payload.channel, format: payload.format });
-    return deliveryValidateResultSchema.parse({
-        report,
-        sizeBytes: info.size,
-        sizeLimitBytes: adapter.getSizeLimit(),
-    });
-}