@playdrop/playdrop-cli 0.3.1-build.1

package/dist/apps/build.js

@@ -0,0 +1,561 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNpmScript = runNpmScript;
+exports.buildApp = buildApp;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const node_zlib_1 = require("node:zlib");
+const BASE_SOURCE_IGNORE_PATTERNS = [
+    'node_modules/',
+    'dist/',
+    'build/',
+    'out/',
+    '.next/',
+    '.turbo/',
+    '.cache/',
+    '.git/',
+    '.idea/',
+    '.svelte-kit/',
+    '.DS_Store',
+    '*.log',
+    '*.tmp',
+    '*.zip',
+    'tmp/',
+    'logs/',
+    'coverage/',
+    '.vercel/',
+    '.netlify/',
+];
+const projectBuildCache = new Map();
+const typescriptSourceCache = new Map();
+async function runNpmScript(projectDir, script) {
+    await (0, promises_1.mkdir)(projectDir, { recursive: true });
+    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    await new Promise((resolveRun, rejectRun) => {
+        const child = (0, node_child_process_1.spawn)(npmCommand, ['run', script], {
+            cwd: projectDir,
+            stdio: 'inherit',
+            env: { ...process.env },
+        });
+        child.on('error', rejectRun);
+        child.on('exit', code => {
+            if (code === 0) {
+                resolveRun();
+            }
+            else {
+                rejectRun(new Error(`npm run ${script} failed with exit code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+}
+function readPackageJson(packageJsonPath) {
+    const raw = (0, node_fs_1.readFileSync)(packageJsonPath, 'utf8');
+    return JSON.parse(raw);
+}
+async function ensureProjectBuild(task) {
+    if (!task.isTypescriptProject || !task.packageJsonPath) {
+        return;
+    }
+    if (!projectBuildCache.has(task.projectDir)) {
+        const promise = (async () => {
+            const pkg = readPackageJson(task.packageJsonPath);
+            const scripts = pkg?.scripts ?? {};
+            if (typeof scripts.build !== 'string') {
+                throw new Error(`package.json in ${task.projectDir} is missing a "build" script.`);
+            }
+            await runNpmScript(task.projectDir, 'build');
+        })();
+        projectBuildCache.set(task.projectDir, promise);
+    }
+    await projectBuildCache.get(task.projectDir);
+}
+function globToRegExp(glob) {
+    let pattern = '^';
+    for (let i = 0; i < glob.length; i += 1) {
+        const char = glob[i];
+        if (char === '*') {
+            const next = glob[i + 1];
+            if (next === '*') {
+                pattern += '.*';
+                i += 1;
+            }
+            else {
+                pattern += '[^/]*';
+            }
+            continue;
+        }
+        if (char === '?') {
+            pattern += '.';
+            continue;
+        }
+        if ('+.^$|()[]{}'.includes(char) || char === '\\') {
+            pattern += `\\${char}`;
+            continue;
+        }
+        pattern += char;
+    }
+    pattern += '$';
+    return new RegExp(pattern);
+}
+function readIgnorePatterns(projectDir, filename) {
+    const filePath = (0, node_path_1.join)(projectDir, filename);
+    if (!(0, node_fs_1.existsSync)(filePath)) {
+        return [];
+    }
+    try {
+        const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        return content.split(/\r?\n/);
+    }
+    catch {
+        return [];
+    }
+}
+function buildIgnoreRules(projectDir) {
+    const patterns = [...BASE_SOURCE_IGNORE_PATTERNS];
+    patterns.push(...readIgnorePatterns(projectDir, '.playdropignore'));
+    patterns.push(...readIgnorePatterns(projectDir, '.gitignore'));
+    const rules = [];
+    for (const rawPattern of patterns) {
+        const trimmed = rawPattern.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const normalized = trimmed.replace(/\\/g, '/');
+        if (normalized.endsWith('/')) {
+            const segment = normalized.slice(0, -1);
+            const regex = globToRegExp(`**/${segment}/**`);
+            rules.push({
+                matches: (path, isDir) => {
+                    const target = isDir ? `${path}/` : path;
+                    if (target === `${segment}/`)
+                        return true;
+                    if (target.startsWith(`${segment}/`))
+                        return true;
+                    return regex.test(target);
+                },
+            });
+            continue;
+        }
+        if (!normalized.includes('/') && !normalized.includes('*') && !normalized.includes('?')) {
+            const name = normalized;
+            rules.push({
+                matches: path => {
+                    if (path === name)
+                        return true;
+                    if (path.endsWith(`/${name}`))
+                        return true;
+                    return path.split('/').includes(name);
+                },
+            });
+            continue;
+        }
+        if (!normalized.includes('*') && !normalized.includes('?')) {
+            const target = normalized;
+            rules.push({
+                matches: path => path === target || path.startsWith(`${target}/`),
+            });
+            continue;
+        }
+        const regex = globToRegExp(normalized);
+        rules.push({
+            matches: path => regex.test(path),
+        });
+    }
+    return rules;
+}
+function shouldIgnore(pathFragment, isDir, rules) {
+    return rules.some(rule => rule.matches(pathFragment, isDir));
+}
+function normalizeRelativePath(root, target) {
+    const rel = (0, node_path_1.relative)(root, target).split(node_path_1.sep).join('/');
+    return rel.replace(/^\/+/, '');
+}
+function collectProjectFiles(projectDir, rules) {
+    const results = [];
+    const stack = [projectDir];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        let dirEntries = [];
+        try {
+            dirEntries = (0, node_fs_1.readdirSync)(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of dirEntries) {
+            const absolutePath = (0, node_path_1.join)(current, entry.name);
+            const relativePath = normalizeRelativePath(projectDir, absolutePath);
+            if (!relativePath)
+                continue;
+            const isDir = entry.isDirectory();
+            const ignoreTarget = isDir ? `${relativePath}/` : relativePath;
+            if (shouldIgnore(ignoreTarget, isDir, rules))
+                continue;
+            if (isDir) {
+                stack.push(absolutePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            let stats;
+            try {
+                stats = (0, node_fs_1.statSync)(absolutePath);
+            }
+            catch {
+                continue;
+            }
+            if (!stats.isFile())
+                continue;
+            results.push({
+                absolutePath,
+                relativePath: relativePath.split('/').join('/'),
+                mtime: stats.mtime,
+            });
+        }
+    }
+    results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return results;
+}
+function collectHtmlSourceFiles(task) {
+    const files = [];
+    const htmlStats = (0, node_fs_1.statSync)(task.filePath);
+    files.push({
+        absolutePath: task.filePath,
+        relativePath: (0, node_path_1.basename)(task.filePath),
+        mtime: htmlStats.mtime,
+    });
+    const readmePath = (0, node_path_1.join)(task.projectDir, 'README.md');
+    if ((0, node_fs_1.existsSync)(readmePath)) {
+        const stats = (0, node_fs_1.statSync)(readmePath);
+        files.push({ absolutePath: readmePath, relativePath: 'README.md', mtime: stats.mtime });
+    }
+    const agentsPath = (0, node_path_1.join)(task.projectDir, 'AGENTS.md');
+    if ((0, node_fs_1.existsSync)(agentsPath)) {
+        const stats = (0, node_fs_1.statSync)(agentsPath);
+        files.push({ absolutePath: agentsPath, relativePath: 'AGENTS.md', mtime: stats.mtime });
+    }
+    if (task.catalogueAbsolutePath && (0, node_fs_1.existsSync)(task.catalogueAbsolutePath)) {
+        const stats = (0, node_fs_1.statSync)(task.catalogueAbsolutePath);
+        const relativePath = normalizeRelativePath(task.projectDir, task.catalogueAbsolutePath) || 'catalogue.json';
+        files.push({ absolutePath: task.catalogueAbsolutePath, relativePath, mtime: stats.mtime });
+    }
+    files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return files;
+}
+// Files that are uploaded separately and should not be included in the bundle zip
+const RESERVED_BUNDLE_FILES = new Set(['ecs.json', 'server.js']);
+/**
+ * Collect files for the bundle zip.
+ * - For TypeScript projects: all files in the dist folder (excluding reserved files)
+ * - For HTML projects: just the single HTML file (renamed to entry point)
+ */
+function collectBundleFiles(task) {
+    if (task.isTypescriptProject) {
+        const projectDir = (0, node_path_1.resolve)(task.projectDir);
+        const outputDir = (0, node_path_1.resolve)((0, node_path_1.dirname)(task.filePath));
+        if (outputDir === projectDir) {
+            // If the app output is at project root, avoid zipping the whole project tree.
+            // Bundle only the declared app entry file.
+            const htmlStats = (0, node_fs_1.statSync)(task.filePath);
+            const entryPoint = task.relativeFile || (0, node_path_1.basename)(task.filePath);
+            return [{
+                    absolutePath: task.filePath,
+                    relativePath: entryPoint,
+                    mtime: htmlStats.mtime,
+                }];
+        }
+        // For TypeScript projects with a dedicated output folder, zip that folder.
+        const distDir = outputDir;
+        const results = [];
+        const stack = [distDir];
+        const visited = new Set();
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            let dirEntries = [];
+            try {
+                dirEntries = (0, node_fs_1.readdirSync)(current, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of dirEntries) {
+                const absolutePath = (0, node_path_1.join)(current, entry.name);
+                const relativePath = normalizeRelativePath(distDir, absolutePath);
+                if (!relativePath)
+                    continue;
+                if (entry.isDirectory()) {
+                    stack.push(absolutePath);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                // Skip reserved files - they are uploaded separately
+                if (RESERVED_BUNDLE_FILES.has(entry.name)) {
+                    continue;
+                }
+                let stats;
+                try {
+                    stats = (0, node_fs_1.statSync)(absolutePath);
+                }
+                catch {
+                    continue;
+                }
+                results.push({
+                    absolutePath,
+                    relativePath,
+                    mtime: stats.mtime,
+                });
+            }
+        }
+        results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+        return results;
+    }
+    // For HTML projects, zip just the single HTML file
+    const htmlStats = (0, node_fs_1.statSync)(task.filePath);
+    const entryPoint = task.relativeFile || (0, node_path_1.basename)(task.filePath);
+    return [{
+            absolutePath: task.filePath,
+            relativePath: entryPoint,
+            mtime: htmlStats.mtime,
+        }];
+}
+function createBundleArchive(task) {
+    const entries = collectBundleFiles(task);
+    const buffer = createZipArchive(entries);
+    const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    return { buffer, hash };
+}
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        let crc = i;
+        for (let j = 0; j < 8; j += 1) {
+            if ((crc & 1) !== 0) {
+                crc = (crc >>> 1) ^ 0xedb88320;
+            }
+            else {
+                crc >>>= 1;
+            }
+        }
+        table[i] = crc >>> 0;
+    }
+    return table;
+})();
+function crc32(buffer) {
+    let crc = 0 ^ -1;
+    for (let i = 0; i < buffer.length; i += 1) {
+        crc = (crc >>> 8) ^ CRC32_TABLE[(crc ^ buffer[i]) & 0xff];
+    }
+    return (crc ^ -1) >>> 0;
+}
+function toDosDateTime(date) {
+    const year = Math.max(Math.min(date.getFullYear(), 2107), 1980);
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = Math.floor(date.getSeconds() / 2);
+    const dosDate = ((year - 1980) << 9) | (month << 5) | day;
+    const dosTime = (hours << 11) | (minutes << 5) | seconds;
+    return { dosDate, dosTime };
+}
+function createZipArchive(entries) {
+    const chunks = [];
+    const centralRecords = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const data = (0, node_fs_1.readFileSync)(entry.absolutePath);
+        const compressed = (0, node_zlib_1.deflateRawSync)(data);
+        const crc = crc32(data);
+        const { dosDate, dosTime } = toDosDateTime(entry.mtime);
+        const fileNameBuffer = Buffer.from(entry.relativePath, 'utf8');
+        const localHeader = Buffer.alloc(30);
+        let cursor = 0;
+        localHeader.writeUInt32LE(0x04034b50, cursor);
+        cursor += 4;
+        localHeader.writeUInt16LE(20, cursor);
+        cursor += 2;
+        localHeader.writeUInt16LE(0x0800, cursor);
+        cursor += 2;
+        localHeader.writeUInt16LE(8, cursor);
+        cursor += 2;
+        localHeader.writeUInt16LE(dosTime, cursor);
+        cursor += 2;
+        localHeader.writeUInt16LE(dosDate, cursor);
+        cursor += 2;
+        localHeader.writeUInt32LE(crc, cursor);
+        cursor += 4;
+        localHeader.writeUInt32LE(compressed.length, cursor);
+        cursor += 4;
+        localHeader.writeUInt32LE(data.length, cursor);
+        cursor += 4;
+        localHeader.writeUInt16LE(fileNameBuffer.length, cursor);
+        cursor += 2;
+        localHeader.writeUInt16LE(0, cursor);
+        chunks.push(localHeader, fileNameBuffer, compressed);
+        const centralHeader = Buffer.alloc(46);
+        cursor = 0;
+        centralHeader.writeUInt32LE(0x02014b50, cursor);
+        cursor += 4;
+        centralHeader.writeUInt16LE(0x031e, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(20, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(0x0800, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(8, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(dosTime, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(dosDate, cursor);
+        cursor += 2;
+        centralHeader.writeUInt32LE(crc, cursor);
+        cursor += 4;
+        centralHeader.writeUInt32LE(compressed.length, cursor);
+        cursor += 4;
+        centralHeader.writeUInt32LE(data.length, cursor);
+        cursor += 4;
+        centralHeader.writeUInt16LE(fileNameBuffer.length, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(0, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(0, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(0, cursor);
+        cursor += 2;
+        centralHeader.writeUInt16LE(0, cursor);
+        cursor += 2;
+        centralHeader.writeUInt32LE(0, cursor);
+        cursor += 4;
+        centralHeader.writeUInt32LE(offset, cursor);
+        cursor += 4;
+        centralRecords.push(Buffer.concat([centralHeader, fileNameBuffer]));
+        offset += localHeader.length + fileNameBuffer.length + compressed.length;
+    }
+    const centralDirectory = Buffer.concat(centralRecords);
+    const centralSize = centralDirectory.length;
+    const centralOffset = offset;
+    chunks.push(centralDirectory);
+    const eocd = Buffer.alloc(22);
+    let cursor = 0;
+    eocd.writeUInt32LE(0x06054b50, cursor);
+    cursor += 4;
+    eocd.writeUInt16LE(0, cursor);
+    cursor += 2;
+    eocd.writeUInt16LE(0, cursor);
+    cursor += 2;
+    const entryCount = entries.length;
+    eocd.writeUInt16LE(entryCount, cursor);
+    cursor += 2;
+    eocd.writeUInt16LE(entryCount, cursor);
+    cursor += 2;
+    eocd.writeUInt32LE(centralSize, cursor);
+    cursor += 4;
+    eocd.writeUInt32LE(centralOffset, cursor);
+    cursor += 4;
+    eocd.writeUInt16LE(0, cursor);
+    chunks.push(eocd);
+    return Buffer.concat(chunks);
+}
+function createSourceArchive(task) {
+    if (task.isTypescriptProject) {
+        const cached = typescriptSourceCache.get(task.projectDir);
+        if (cached) {
+            return cached;
+        }
+        const rules = buildIgnoreRules(task.projectDir);
+        const entries = collectProjectFiles(task.projectDir, rules);
+        const buffer = createZipArchive(entries);
+        const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+        const record = { buffer, hash };
+        typescriptSourceCache.set(task.projectDir, record);
+        return record;
+    }
+    const entries = collectHtmlSourceFiles(task);
+    const buffer = createZipArchive(entries);
+    const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    return { buffer, hash };
+}
+async function buildApp(task) {
+    await ensureProjectBuild(task);
+    if (!(0, node_fs_1.existsSync)(task.filePath) || !(0, node_fs_1.statSync)(task.filePath).isFile()) {
+        const locationHint = task.cataloguePath || 'catalogue.json';
+        const bundlePath = task.relativeFile || (0, node_path_1.basename)(task.filePath);
+        const buildAdvice = task.isTypescriptProject
+            ? 'Run `npm run build` in the project directory and confirm the bundle path.'
+            : 'Confirm the catalogue entry points to an existing HTML file.';
+        throw new Error([
+            `Bundle not found for ${task.name}: ${bundlePath}`,
+            `Check the "file" value in ${locationHint}.`,
+            buildAdvice,
+        ].join(' '));
+    }
+    // Create bundle zip for versioned upload
+    const bundleArchive = createBundleArchive(task);
+    const bundleFileName = `${task.name}-bundle.zip`;
+    const bundleBlobPart = Uint8Array.from(bundleArchive.buffer);
+    const bundleFile = new File([bundleBlobPart], bundleFileName, { type: 'application/zip' });
+    const bundleHash = bundleArchive.hash;
+    const sourceArchive = createSourceArchive(task);
+    const sourceFileName = `${task.name}-source.zip`;
+    const sourceBlobPart = Uint8Array.from(sourceArchive.buffer);
+    const sourceFile = new File([sourceBlobPart], sourceFileName, { type: 'application/zip' });
+    const metadata = {};
+    if (task.displayName)
+        metadata.displayName = task.displayName;
+    if (typeof task.description === 'string')
+        metadata.description = task.description;
+    if (task.type)
+        metadata.type = task.type;
+    if (task.emoji !== undefined)
+        metadata.emoji = task.emoji;
+    if (task.color !== undefined)
+        metadata.color = task.color;
+    if (task.surfaceTargets && task.surfaceTargets.length > 0) {
+        metadata.surfaceTargets = task.surfaceTargets;
+    }
+    // For TypeScript projects, files are stored relative to dist directory,
+    // so entryPoint should be the filename, not the full catalogue path
+    metadata.entryPoint = task.isTypescriptProject
+        ? (0, node_path_1.basename)(task.relativeFile)
+        : task.relativeFile;
+    // Build ecs file if path is defined
+    let ecsFile;
+    let ecsHash;
+    if (task.ecsPath) {
+        const ecsBuffer = (0, node_fs_1.readFileSync)(task.ecsPath);
+        ecsHash = (0, node_crypto_1.createHash)('sha256').update(ecsBuffer).digest('hex');
+        const ecsBlobPart = Uint8Array.from(ecsBuffer);
+        ecsFile = new File([ecsBlobPart], 'ecs.json', { type: 'application/json' });
+    }
+    // Build server file if path is defined
+    let serverFile;
+    let serverHash;
+    if (task.serverPath) {
+        const serverBuffer = (0, node_fs_1.readFileSync)(task.serverPath);
+        serverHash = (0, node_crypto_1.createHash)('sha256').update(serverBuffer).digest('hex');
+        const serverBlobPart = Uint8Array.from(serverBuffer);
+        serverFile = new File([serverBlobPart], 'server.js', { type: 'application/javascript' });
+    }
+    return {
+        bundleFile,
+        bundleHash,
+        sourceFile,
+        sourceHash: sourceArchive.hash,
+        metadata,
+        ecsFile,
+        ecsHash,
+        serverFile,
+        serverHash,
+    };
+}

package/dist/apps/index.d.ts

@@ -0,0 +1,15 @@
+import type { ApiClient } from '@playdrop/api-client';
+import type { AppTask } from '../catalogue';
+import { validateAppTask, runFormatScript } from './validate';
+import { buildApp, type AppBuildArtifacts } from './build';
+import { uploadApp, type AppUploadResult } from './upload';
+export type AppPipelineResult = {
+    artifacts: AppBuildArtifacts | null;
+    upload: AppUploadResult;
+};
+export type AppPipelineOptions = {
+    skipEcs?: boolean;
+    creatorUsername?: string;
+};
+export declare function runAppPipeline(client: ApiClient, task: AppTask, options?: AppPipelineOptions): Promise<AppPipelineResult>;
+export { validateAppTask, buildApp, uploadApp, runFormatScript };

package/dist/apps/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFormatScript = exports.uploadApp = exports.buildApp = exports.validateAppTask = void 0;
+exports.runAppPipeline = runAppPipeline;
+const validate_1 = require("./validate");
+Object.defineProperty(exports, "validateAppTask", { enumerable: true, get: function () { return validate_1.validateAppTask; } });
+Object.defineProperty(exports, "runFormatScript", { enumerable: true, get: function () { return validate_1.runFormatScript; } });
+const build_1 = require("./build");
+Object.defineProperty(exports, "buildApp", { enumerable: true, get: function () { return build_1.buildApp; } });
+const upload_1 = require("./upload");
+Object.defineProperty(exports, "uploadApp", { enumerable: true, get: function () { return upload_1.uploadApp; } });
+async function runAppPipeline(client, task, options) {
+    await (0, validate_1.validateAppTask)(task);
+    // External apps don't need to be built - they're hosted elsewhere
+    const isExternal = task.hostingMode === 'EXTERNAL' || !!task.externalUrl;
+    const artifacts = isExternal ? null : await (0, build_1.buildApp)(task);
+    const uploadOptions = {
+        skipEcs: options?.skipEcs,
+        creatorUsername: options?.creatorUsername,
+    };
+    const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);
+    return { artifacts, upload };
+}

package/dist/apps/upload.d.ts

@@ -0,0 +1,19 @@
+import type { ApiClient } from '@playdrop/api-client';
+import type { AppTask } from '../catalogue';
+import type { AppBuildArtifacts } from './build';
+export type AppUploadResult = {
+    fileUnchanged?: boolean;
+    metadataUnchanged?: boolean;
+    sourceUnchanged?: boolean;
+    ecsUnchanged?: boolean;
+    serverUnchanged?: boolean;
+    versionCreated?: boolean;
+    version?: string;
+    versionId?: number;
+    versionNodeId?: string;
+};
+export type AppUploadOptions = {
+    skipEcs?: boolean;
+    creatorUsername?: string;
+};
+export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;