@playcraft/cli 0.1.49-beta → 0.1.51

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(),
-    });
-}

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

@@ -1,279 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { appendFile, lstat, mkdir, open, readFile, stat, writeFile } from 'node:fs/promises';
-import { constants } from 'node:fs';
-import { setTimeout as delay } from 'node:timers/promises';
-import { join } from 'node:path';
-import { launcherSocket, runDeveloperCommand } from './developer-command.js';
-/** Long enough for a cold store on a game template; a stuck registry must not hold the write lease. */
-const INSTALL_TIMEOUT_MS = 10 * 60_000;
-const LOG_TAIL_LINES = 50;
-const LOG_TAIL_MAX_CHARS = 8_000;
-const WRITE_PREFIX = 'dependencies-';
-const SHARE_WAIT_MS = 60_000;
-/**
- * Projects are managed with pnpm. Installation can create or update pnpm-lock.yaml, never
- * prompts, and writes plain lines to the log. Package scripts run: the workspace is the user's own
- * sandbox and the install runs as the development user.
- */
-const INSTALL_COMMAND = 'pnpm install --no-frozen-lockfile --store-dir /var/cache/playcraft/pnpm-store --reporter=append-only --config.confirm-modules-purge=false';
-/** Installs whenever there is a package.json; the hash says whether a finished install is current. */
-export async function planInstall(root) {
-    const manifest = await readOptional(join(root, 'package.json'));
-    if (manifest === undefined)
-        return { kind: 'skip' };
-    const lock = (await readOptional(join(root, 'pnpm-lock.yaml'))) ?? '';
-    return {
-        kind: 'install',
-        lockHash: createHash('sha256').update(manifest).update('\0').update(lock).digest('hex'),
-    };
-}
-const running = new WeakMap();
-/**
- * Starts the install after a workspace is registered; opening the workspace never waits for it.
- * Registering again retries a failed install and reinstalls after the manifest or lockfile
- * changed. One install runs per workspace at a time: the same directory shares its task; another
- * directory waits for it before installing. The returned task covers the requested directory.
- */
-export function scheduleDependencyInstall(state, workspaceId, root, shouldStart) {
-    const inFlight = running.get(state) ?? new Map();
-    running.set(state, inFlight);
-    const existing = inFlight.get(workspaceId);
-    if (existing?.root === root) {
-        if (!shouldStart)
-            existing.guards = undefined;
-        else
-            existing.guards?.push(shouldStart);
-        return existing.task;
-    }
-    const scheduled = { root, task: Promise.resolve(), guards: shouldStart ? [shouldStart] : undefined };
-    const begin = () => {
-        if (state.journal.destroyed() || (scheduled.guards && !scheduled.guards.some((guard) => guard())))
-            return;
-        return installOnce(state, workspaceId, root);
-    };
-    const task = (existing ? existing.task.then(begin) : begin() ?? Promise.resolve())
-        .catch((error) => {
-        console.error(`[workspace-runtime] dependency install for ${workspaceId} failed to run`, error);
-    })
-        .finally(() => { if (inFlight.get(workspaceId)?.task === task)
-        inFlight.delete(workspaceId); });
-    scheduled.task = task;
-    inFlight.set(workspaceId, scheduled);
-    return task;
-}
-/** Settles every install started in this process; used by tests and shutdown. */
-export async function settleDependencyInstalls(state) {
-    while (running.get(state)?.size) {
-        await Promise.all([...(running.get(state)?.values() ?? [])].map((record) => record.task));
-    }
-}
-export function readDependencies(state, workspaceId) {
-    return state.journal.getWorkspaceDependencies(workspaceId) ?? { workspaceId, status: 'pending' };
-}
-/**
- * Makes the install finish before a build reads the checkout. The install is skipped when the
- * manifest and lockfile already match; otherwise the returned task covers the whole install.
- */
-export async function ensureWorkspaceDependencies(state, workspaceId, root) {
-    await scheduleDependencyInstall(state, workspaceId, root);
-    const dependencies = readDependencies(state, workspaceId);
-    if (dependencies.status === 'ready' || dependencies.status === 'none')
-        return { ok: true };
-    return {
-        ok: false,
-        error: dependencies.error ?? 'dependencies_not_ready',
-        ...(dependencies.logTail ? { logTail: dependencies.logTail } : {}),
-    };
-}
-/**
- * An install cut off by a restart left no process behind (the launcher stops the group when its
- * connection closes), so its status and write lease are closed rather than left in progress.
- */
-export async function recoverInterruptedInstalls(journal) {
-    const now = new Date().toISOString();
-    for (const record of journal.listWorkspaceDependencies()) {
-        if (record.status !== 'installing')
-            continue;
-        await journal.putWorkspaceDependencies({
-            ...record,
-            status: 'failed',
-            error: 'interrupted',
-            finishedAt: now,
-        });
-    }
-    for (const write of journal.listManagedWrites()) {
-        if (write.writeId.startsWith(WRITE_PREFIX) && !write.stoppedAt) {
-            await journal.putManagedWrite({ ...write, stoppedAt: now });
-        }
-    }
-}
-async function installOnce(state, workspaceId, root) {
-    const plan = await planInstall(root);
-    const current = state.journal.getWorkspaceDependencies(workspaceId);
-    if (plan.kind === 'skip') {
-        if (current?.status !== 'none') {
-            await state.journal.putWorkspaceDependencies({
-                workspaceId,
-                status: 'none',
-                finishedAt: new Date().toISOString(),
-            });
-        }
-        return;
-    }
-    if (current?.status === 'ready' &&
-        current.lockHash === plan.lockHash &&
-        (await isDirectory(join(root, 'node_modules')))) {
-        return;
-    }
-    await excludeFromGit(root);
-    const startedAt = new Date().toISOString();
-    const writeId = `${WRITE_PREFIX}${workspaceId}-${randomUUID()}`;
-    // A checkpoint waits for this write: node_modules is half written until the install ends.
-    await state.journal.putManagedWrite({ writeId, workspaceId, source: 'background', startedAt });
-    await state.journal.putWorkspaceDependencies({
-        workspaceId,
-        status: 'installing',
-        startedAt,
-    });
-    let outcome;
-    try {
-        // Through the launcher the install runs as the development group, which cannot enter the
-        // checkout until Runtime has opened it; a local install runs as the owner and need not wait.
-        const shared = !launcherSocket(state) || (await waitUntilShared(root));
-        outcome = shared
-            ? await runInstall(state, workspaceId, root)
-            : { code: undefined, timedOut: false, log: '', error: 'workspace_not_shared' };
-    }
-    finally {
-        await state.journal.putManagedWrite({
-            writeId,
-            workspaceId,
-            source: 'background',
-            startedAt,
-            stoppedAt: new Date().toISOString(),
-        });
-    }
-    const ok = outcome.code === 0 && !outcome.timedOut;
-    await state.journal.putWorkspaceDependencies({
-        workspaceId,
-        status: ok ? 'ready' : 'failed',
-        ...(ok
-            ? { lockHash: plan.lockHash }
-            : {
-                error: outcome.error ??
-                    (outcome.timedOut ? 'install_timeout' : `install_exit_${outcome.code ?? 'lost'}`),
-            }),
-        startedAt,
-        finishedAt: new Date().toISOString(),
-        logTail: tail(outcome.log),
-    });
-}
-/**
- * Runs as the development user through the launcher, so the packages belong to the same user as
- * Codex and its own later installs. Without a launcher (local runs and tests) it runs directly.
- */
-async function runInstall(state, workspaceId, root) {
-    // Tests replace the install; a real registry is never reached from them.
-    const store = process.env.PLAYCRAFT_PNPM_STORE ?? (process.platform === 'linux' ? '/var/cache/playcraft/pnpm-store' : join(state.config.stateDir, 'pnpm-store'));
-    const quotedStore = `'${store.replaceAll("'", "'\\''")}'`;
-    const planned = process.env.PLAYCRAFT_DEPENDENCY_INSTALL_COMMAND || INSTALL_COMMAND.replace('/var/cache/playcraft/pnpm-store', quotedStore);
-    const logDir = join(state.config.stateDir, 'dependency-logs');
-    await mkdir(logDir, { recursive: true, mode: 0o700 });
-    const logPath = join(logDir, `${workspaceId}.log`);
-    await writeFile(logPath, `$ ${planned}\n`, { mode: 0o600 });
-    let log = '';
-    let pending = Promise.resolve();
-    const outcome = await runDeveloperCommand(state, {
-        processId: `${WRITE_PREFIX}${workspaceId}`,
-        cwd: root,
-        command: planned,
-        timeoutMs: INSTALL_TIMEOUT_MS,
-        onOutput: (chunk) => {
-            const text = String(chunk);
-            log = (log + text).slice(-64 * 1024);
-            pending = pending.then(() => appendFile(logPath, text)).catch(() => undefined);
-        },
-    });
-    await pending;
-    return { ...outcome, log };
-}
-/**
- * The checkout is cloned private to the control user and opened to the development group by
- * Runtime after registration. Group read, write and search on the root is the sign it is open.
- */
-export async function waitUntilShared(root, timeoutMs = SHARE_WAIT_MS, intervalMs = 500) {
-    const deadline = Date.now() + timeoutMs;
-    for (;;) {
-        try {
-            if (((await stat(root)).mode & 0o070) === 0o070)
-                return true;
-        }
-        catch {
-            /* not there yet */
-        }
-        if (Date.now() >= deadline)
-            return false;
-        await delay(intervalMs);
-    }
-}
-/** A local-only ignore, never committed: the change list must not fill up with installed packages. */
-/** Keeps sandbox-managed folders out of the Git panel without touching the project's .gitignore. */
-export async function excludeFromGit(root, entry = '/node_modules/') {
-    const flags = constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
-    const handles = [];
-    let file;
-    try {
-        const directory = await open(root, flags);
-        handles.push(directory);
-        const pinned = (handle, fallback) => process.platform === 'linux' ? `/proc/self/fd/${handle.fd}` : fallback;
-        const rootPath = pinned(directory, root);
-        const git = await open(join(rootPath, '.git'), flags).catch((error) => {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        });
-        if (!git)
-            return;
-        handles.push(git);
-        const gitPath = pinned(git, join(root, '.git'));
-        await mkdir(join(gitPath, 'info')).catch((error) => {
-            if (error.code !== 'EEXIST')
-                throw error;
-        });
-        const info = await open(join(gitPath, 'info'), flags);
-        handles.push(info);
-        file = await open(join(pinned(info, join(root, '.git/info')), 'exclude'), constants.O_RDWR | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o666);
-        const metadata = await file.stat();
-        if (!metadata.isFile() || metadata.nlink !== 1 || metadata.size > 1024 * 1024) {
-            throw new Error('invalid_git_exclude');
-        }
-        const current = await file.readFile('utf8');
-        if (!current.split('\n').some((line) => line.trim() === entry)) {
-            await file.writeFile(`${current && !current.endsWith('\n') ? '\n' : ''}${entry}\n`);
-        }
-    }
-    finally {
-        await file?.close();
-        for (const handle of handles.reverse())
-            await handle.close();
-    }
-}
-function tail(log) {
-    return log.split('\n').slice(-LOG_TAIL_LINES).join('\n').slice(-LOG_TAIL_MAX_CHARS);
-}
-async function readOptional(path) {
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch {
-        return undefined;
-    }
-}
-async function isDirectory(path) {
-    try {
-        return (await lstat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/workspace-runtime/workspaces/developer-command.js

@@ -1,98 +0,0 @@
-import { spawn } from 'node:child_process';
-import { startLauncherProcess } from '../codex/launcher-client.js';
-export function launcherSocket(state) {
-    const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
-    return socketPath && state.config.workspaceMode === 'multi' ? socketPath : undefined;
-}
-/**
- * Runs a shell command in the workspace as the development user through the launcher, so whatever
- * it writes belongs to the same user as Codex. Without a launcher (local runs and tests) it runs
- * directly as the owner. Output from both streams goes to `onOutput`.
- */
-export async function runDeveloperCommand(state, input) {
-    if (input.signal?.aborted)
-        return { code: null, timedOut: false, canceled: true };
-    const command = `{ ${input.command}; } </dev/null 2>&1`;
-    const socketPath = launcherSocket(state);
-    const launched = socketPath
-        ? await startLauncherProcess({
-            socketPath,
-            processId: input.processId,
-            runtimeEpoch: state.runtimeEpoch,
-            argv: ['/usr/bin/bash', '-lc', command],
-            cwd: input.cwd,
-            env: {},
-        })
-        : undefined;
-    launched?.stdin?.end();
-    const local = launched
-        ? undefined
-        : spawn('bash', ['-lc', command], {
-            cwd: input.cwd,
-            detached: true,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-    const stdout = launched?.stdout ?? local.stdout;
-    const stderr = launched?.stderr ?? local.stderr;
-    stdout.on('data', input.onOutput);
-    stderr.on('data', input.onOutput);
-    let timedOut = false;
-    let canceled = false;
-    let killTimer;
-    const abort = () => {
-        if (canceled || timedOut)
-            return;
-        canceled = true;
-        if (launched) {
-            void launched.stop().catch(() => undefined);
-            return;
-        }
-        if (!local?.pid)
-            return;
-        try {
-            process.kill(-local.pid, 'SIGTERM');
-        }
-        catch {
-            /* already gone */
-        }
-        killTimer = setTimeout(() => {
-            try {
-                process.kill(-local.pid, 'SIGKILL');
-            }
-            catch {
-                /* already gone */
-            }
-        }, 5_000);
-        killTimer.unref?.();
-    };
-    input.signal?.addEventListener('abort', abort, { once: true });
-    const code = await new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            timedOut = true;
-            if (launched)
-                void launched.stop().catch(() => undefined);
-            else if (local?.pid) {
-                try {
-                    process.kill(-local.pid, 'SIGKILL');
-                }
-                catch {
-                    /* already gone */
-                }
-            }
-        }, input.timeoutMs);
-        const finish = (value) => {
-            clearTimeout(timer);
-            if (killTimer)
-                clearTimeout(killTimer);
-            input.signal?.removeEventListener('abort', abort);
-            resolve(value);
-        };
-        if (launched)
-            launched.onExit(finish);
-        else {
-            local.once('error', () => finish(null));
-            local.once('close', (value) => finish(value));
-        }
-    });
-    return { code, timedOut, ...(canceled ? { canceled: true } : {}) };
-}