@playdrop/playdrop-cli 0.3.1-build.1

package/dist/commands/create.js

@@ -0,0 +1,1174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const promises_1 = __importDefault(require("node:readline/promises"));
+const node_process_1 = require("node:process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const fflate_1 = require("fflate");
+const types_1 = require("@playdrop/types");
+const config_1 = require("../config");
+const apiClient_1 = require("../apiClient");
+const http_1 = require("../http");
+const environment_1 = require("../environment");
+const messages_1 = require("../messages");
+const init_1 = require("./init");
+const app_1 = require("@playdrop/types/app");
+const catalogue_utils_1 = require("../catalogue-utils");
+const catalogue_1 = require("../catalogue");
+const CATALOGUE_FILENAME = 'catalogue.json';
+async function downloadArchive(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download project archive (${response.status})`);
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+}
+function sanitizeArchivePath(targetDir, relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (!normalized || normalized.includes('..')) {
+        return null;
+    }
+    const absolute = (0, node_path_1.resolve)(targetDir, normalized);
+    if (!absolute.startsWith((0, node_path_1.resolve)(targetDir))) {
+        return null;
+    }
+    return absolute;
+}
+function trimArchivePrefix(entries) {
+    const filtered = entries
+        .map((name) => name.replace(/\\/g, '/'))
+        .filter((name) => name.length > 0 && !name.startsWith('__MACOSX/'));
+    if (filtered.length === 0) {
+        return '';
+    }
+    const firstSegments = new Set(filtered.map((name) => name.split('/')[0]));
+    if (firstSegments.size === 1) {
+        const [segment] = Array.from(firstSegments);
+        if (segment && !segment.includes('.')) {
+            return `${segment}/`;
+        }
+    }
+    return '';
+}
+function extractProjectArchive(buffer, targetDir) {
+    const files = (0, fflate_1.unzipSync)(buffer);
+    const names = Object.keys(files);
+    const prefix = trimArchivePrefix(names);
+    let manifest = null;
+    for (const originalName of names) {
+        let name = originalName.replace(/\\/g, '/');
+        if (!name || name.startsWith('__MACOSX/')) {
+            continue;
+        }
+        if (prefix && name.startsWith(prefix)) {
+            name = name.slice(prefix.length);
+        }
+        if (!name) {
+            continue;
+        }
+        const isDirectory = name.endsWith('/');
+        const destination = sanitizeArchivePath(targetDir, name);
+        if (!destination) {
+            continue;
+        }
+        if (isDirectory) {
+            (0, node_fs_1.mkdirSync)(destination, { recursive: true });
+            continue;
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destination), { recursive: true });
+        const data = files[originalName];
+        const bufferData = Buffer.from(data);
+        (0, node_fs_1.writeFileSync)(destination, bufferData);
+        if (name === 'playdrop.project.json') {
+            try {
+                manifest = JSON.parse(Buffer.from(data).toString('utf8'));
+            }
+            catch {
+                manifest = null;
+            }
+        }
+    }
+    const entryPoint = manifest?.entryPoint ? manifest.entryPoint.trim() : undefined;
+    return { manifest, entryPoint: entryPoint || null };
+}
+function findFirstHtmlFile(projectDir) {
+    const stack = [projectDir];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        let entries = [];
+        try {
+            entries = (0, node_fs_1.readdirSync)(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const absolute = (0, node_path_1.join)(current, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git') {
+                    continue;
+                }
+                stack.push(absolute);
+                continue;
+            }
+            if (entry.isFile() && entry.name.toLowerCase().endsWith('.html')) {
+                return absolute;
+            }
+        }
+    }
+    return null;
+}
+async function promptInstallDependencies(projectDir) {
+    if (!node_process_1.stdin.isTTY || !node_process_1.stdout.isTTY) {
+        return false;
+    }
+    const label = (0, node_path_1.relative)(process.cwd(), projectDir) || projectDir;
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    const answer = await rl.question(`Run "npm install" inside ${label}? (y/N) `);
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+function runNpmInstall(projectDir) {
+    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const result = (0, node_child_process_1.spawnSync)(npmCommand, ['install'], {
+        cwd: projectDir,
+        stdio: 'inherit',
+    });
+    return result.status === 0;
+}
+function extractEntryPointFromMetadata(metadata) {
+    if (!metadata) {
+        return null;
+    }
+    const candidate = metadata.entryPoint;
+    if (typeof candidate === 'string' && candidate.trim().length > 0) {
+        return candidate.trim();
+    }
+    if (typeof metadata.file === 'string' && metadata.file.trim().length > 0) {
+        return metadata.file.trim();
+    }
+    return null;
+}
+const DEFAULT_SURFACE_TARGETS = {
+    desktop: app_1.DEFAULT_APP_SURFACE_TARGETS.includes('DESKTOP'),
+    mobileLandscape: app_1.DEFAULT_APP_SURFACE_TARGETS.includes('MOBILE_LANDSCAPE'),
+    mobilePortrait: app_1.DEFAULT_APP_SURFACE_TARGETS.includes('MOBILE_PORTRAIT'),
+};
+const DEFAULT_APP_VERSION = '1.0.0';
+const APP_TYPE_SLUGS = {
+    game: 'GAME',
+    template: 'TEMPLATE',
+    templates: 'TEMPLATE',
+    tool: 'TOOL',
+    tools: 'TOOL',
+    demo: 'DEMO',
+    demos: 'DEMO',
+};
+function makeDefaultAppEntry(name, filePath) {
+    return {
+        name,
+        file: filePath,
+        version: DEFAULT_APP_VERSION,
+        displayName: name,
+        description: '',
+        type: app_1.DEFAULT_APP_TYPE,
+        surfaceTargets: { ...DEFAULT_SURFACE_TARGETS },
+    };
+}
+function buildCatalogueEntry(name, metadata, sourceInfo, relativeFilePath) {
+    const entry = makeDefaultAppEntry(name, relativeFilePath);
+    if (!metadata) {
+        if (sourceInfo.templateSlug) {
+            entry.templateSource = sourceInfo.templateSlug;
+        }
+        if (sourceInfo.remixSlug) {
+            entry.remixSource = sourceInfo.remixSlug;
+        }
+        return entry;
+    }
+    if (typeof metadata.displayName === 'string' && metadata.displayName.trim().length > 0) {
+        entry.displayName = metadata.displayName.trim();
+    }
+    if (typeof metadata.description === 'string') {
+        entry.description = metadata.description;
+    }
+    if (typeof metadata.type === 'string' && metadata.type.trim().length > 0) {
+        const parsedType = (0, app_1.parseAppType)(metadata.type.trim());
+        if (parsedType) {
+            entry.type = parsedType;
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'emoji')) {
+        const emoji = metadata.emoji;
+        if (emoji === null || (typeof emoji === 'string' && emoji.trim().length === 0)) {
+            entry.emoji = null;
+        }
+        else if (typeof emoji === 'string') {
+            entry.emoji = emoji;
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'color')) {
+        const color = metadata.color;
+        if (color === null || (typeof color === 'string' && color.trim().length === 0)) {
+            entry.color = null;
+        }
+        else if (typeof color === 'string') {
+            entry.color = color;
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'file')) {
+        const providedFile = metadata.file;
+        if (typeof providedFile === 'string' && providedFile.trim().length > 0) {
+            entry.file = providedFile.trim();
+        }
+        else if (providedFile === null) {
+            delete entry.file;
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'version')) {
+        const providedVersion = metadata.version;
+        if (typeof providedVersion === 'string' && providedVersion.trim().length > 0) {
+            entry.version = providedVersion.trim();
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'surfaceTargets')) {
+        try {
+            const parsed = (0, catalogue_utils_1.parseSurfaceTargets)(metadata.surfaceTargets);
+            entry.surfaceTargets = { ...parsed.map };
+        }
+        catch (error) {
+            throw new Error(`Invalid surfaceTargets for ${name}: ${error?.message || 'unknown error'}`);
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'templateSource')) {
+        const templateSource = metadata.templateSource;
+        if (templateSource === null || typeof templateSource === 'string') {
+            entry.templateSource = templateSource;
+        }
+    }
+    else if (sourceInfo.templateSlug) {
+        entry.templateSource = sourceInfo.templateSlug;
+    }
+    if (Object.prototype.hasOwnProperty.call(metadata, 'remixSource')) {
+        const remixSource = metadata.remixSource;
+        if (remixSource === null || typeof remixSource === 'string') {
+            entry.remixSource = remixSource;
+        }
+    }
+    else if (sourceInfo.remixSlug) {
+        entry.remixSource = sourceInfo.remixSlug;
+    }
+    return entry;
+}
+function readCatalogue(path) {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, 'utf8');
+        if (!raw.trim()) {
+            return { schemaVersion: 2, apps: [] };
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function ensureCatalogueEntry(name, metadata, cataloguePath, sourceInfo, htmlFilePath) {
+    const path = (0, node_path_1.resolve)(cataloguePath);
+    const catalogueDir = (0, node_path_1.dirname)(path);
+    const relativeFilePath = (0, node_path_1.relative)(catalogueDir, (0, node_path_1.resolve)(htmlFilePath)) || `${name}.html`;
+    const normalizedFilePath = relativeFilePath.replace(/\\/g, '/');
+    const entry = buildCatalogueEntry(name, metadata, sourceInfo, normalizedFilePath);
+    if (!(0, node_fs_1.existsSync)(path)) {
+        const catalogue = { schemaVersion: 2, apps: [entry] };
+        (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(catalogue, null, 2)}\n`);
+        return { path, createdFile: true, addedEntry: true };
+    }
+    const parsed = readCatalogue(path);
+    if (!parsed) {
+        return { path, createdFile: false, addedEntry: false, error: 'invalid_json' };
+    }
+    if (parsed.schemaVersion !== 2) {
+        return { path, createdFile: false, addedEntry: false, error: 'invalid_schema_version' };
+    }
+    if (!Array.isArray(parsed.apps) && Array.isArray(parsed.games)) {
+        return { path, createdFile: false, addedEntry: false, error: 'legacy_games_property' };
+    }
+    const apps = Array.isArray(parsed.apps) ? [...parsed.apps] : [];
+    if (apps.some((app) => typeof app?.name === 'string' && app.name === name)) {
+        return { path, createdFile: false, addedEntry: false, alreadyPresent: true };
+    }
+    apps.push(entry);
+    const updated = { ...parsed, apps };
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(updated, null, 2)}\n`);
+    return { path, createdFile: false, addedEntry: true };
+}
+function logCatalogueOutcome(result, name) {
+    const label = (0, node_path_1.relative)(process.cwd(), result.path) || CATALOGUE_FILENAME;
+    if (result.error === 'invalid_json') {
+        (0, messages_1.printErrorWithHelp)(`Could not update ${label} because it contains invalid JSON.`, [
+            `Fix the JSON in ${label} and add ${name} to the apps list, then rerun "playdrop-cli create ${name}" if needed.`
+        ], { command: 'create' });
+        process.exitCode = process.exitCode || 1;
+        return false;
+    }
+    if (result.error === 'legacy_games_property') {
+        (0, messages_1.printErrorWithHelp)(`${label} still uses the legacy "games" catalogue field.`, [
+            'Rename the top-level "games" array to "apps" and rerun `playdrop-cli create`. This rename removes the old terminology.'
+        ], { command: 'create' });
+        process.exitCode = process.exitCode || 1;
+        return false;
+    }
+    if (result.error === 'invalid_schema_version') {
+        (0, messages_1.printErrorWithHelp)(`${label} must set "schemaVersion": 2.`, ['Update the file to schema v2 and rerun `playdrop-cli create`.'], { command: 'create' });
+        process.exitCode = process.exitCode || 1;
+        return false;
+    }
+    if (result.createdFile) {
+        console.log(`Initialized ${label} and added ${name}.`);
+        return true;
+    }
+    if (result.addedEntry) {
+        console.log(`Added ${name} to ${label}.`);
+        return true;
+    }
+    if (result.alreadyPresent) {
+        console.log(`${label} already contains ${name}; keeping existing entry.`);
+    }
+    return true;
+}
+function updateExtractedProjectCatalogue(name, metadata, projectCataloguePath, sourceInfo, htmlFilePath) {
+    const path = (0, node_path_1.resolve)(projectCataloguePath);
+    const parsed = readCatalogue(path);
+    if (!parsed) {
+        return { path, updated: false, error: 'invalid_json' };
+    }
+    if (parsed.schemaVersion !== 2) {
+        return { path, updated: false, error: 'invalid_schema_version' };
+    }
+    if (!Array.isArray(parsed.apps) && Array.isArray(parsed.games)) {
+        return { path, updated: false, error: 'legacy_games_property' };
+    }
+    const apps = Array.isArray(parsed.apps) ? [...parsed.apps] : [];
+    const relativeFilePath = (0, node_path_1.relative)((0, node_path_1.dirname)(path), (0, node_path_1.resolve)(htmlFilePath)) || `${name}.html`;
+    const normalizedFilePath = relativeFilePath.replace(/\\/g, '/');
+    const metadataName = metadata && typeof metadata.name === 'string' && metadata.name.trim().length > 0
+        ? metadata.name.trim()
+        : null;
+    const metadataFile = metadata && typeof metadata.file === 'string' && metadata.file.trim().length > 0
+        ? metadata.file.trim()
+        : null;
+    const nextType = app_1.DEFAULT_APP_TYPE;
+    let targetIndex = -1;
+    for (let i = 0; i < apps.length; i += 1) {
+        const entry = apps[i];
+        if (!entry) {
+            continue;
+        }
+        if (metadataName && typeof entry.name === 'string' && entry.name === metadataName) {
+            targetIndex = i;
+            break;
+        }
+        if (typeof entry.name === 'string' && entry.name === name) {
+            targetIndex = i;
+            break;
+        }
+        if (metadataFile && typeof entry.file === 'string' && entry.file === metadataFile) {
+            targetIndex = i;
+            break;
+        }
+        if (typeof entry.file === 'string' && entry.file === normalizedFilePath) {
+            targetIndex = i;
+            break;
+        }
+    }
+    if (targetIndex === -1) {
+        if (apps.length === 0) {
+            const newEntry = buildCatalogueEntry(name, metadata, sourceInfo, normalizedFilePath);
+            newEntry.type = nextType;
+            apps.push(newEntry);
+        }
+        else {
+            targetIndex = 0;
+        }
+    }
+    if (targetIndex >= 0 && targetIndex < apps.length) {
+        const existing = { ...(apps[targetIndex] || {}) };
+        existing.name = name;
+        existing.type = nextType;
+        if (!existing.file) {
+            existing.file = normalizedFilePath;
+        }
+        if (typeof existing.version !== 'string' || existing.version.trim().length === 0) {
+            existing.version = DEFAULT_APP_VERSION;
+        }
+        if (sourceInfo.templateSlug) {
+            existing.templateSource = sourceInfo.templateSlug;
+        }
+        if (sourceInfo.remixSlug) {
+            existing.remixSource = sourceInfo.remixSlug;
+        }
+        apps[targetIndex] = existing;
+    }
+    const updated = { ...parsed, apps };
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(updated, null, 2)}\n`);
+    return { path, updated: true };
+}
+function logProjectCatalogueOutcome(result, name) {
+    const label = (0, node_path_1.relative)(process.cwd(), result.path) || CATALOGUE_FILENAME;
+    if (result.error === 'invalid_json') {
+        (0, messages_1.printErrorWithHelp)(`Could not update ${label} because it contains invalid JSON.`, [
+            `Fix the JSON in ${label} and add ${name} to the apps list, then rerun "playdrop-cli create ${name}" if needed.`
+        ], { command: 'create' });
+        process.exitCode = process.exitCode || 1;
+        return false;
+    }
+    if (result.error === 'legacy_games_property') {
+        (0, messages_1.printErrorWithHelp)(`${label} still uses the legacy "games" catalogue field.`, [
+            'Rename the top-level "games" array to "apps" and rerun `playdrop-cli create`. This rename removes the old terminology.'
+        ], { command: 'create' });
+        process.exitCode = process.exitCode || 1;
+        return false;
+    }
+    if (result.error === 'invalid_schema_version') {
+        (0, messages_1.printErrorWithHelp)(`${label} must set "schemaVersion": 2.`, ['Update the file to schema v2 and rerun `playdrop-cli create`.'], { command: 'create' });
+        process.exitCode = process.exitCode || 1;
+        return false;
+    }
+    if (result.updated) {
+        console.log(`Updated ${label} for ${name}.`);
+    }
+    return true;
+}
+function logNextSteps(name, options) {
+    console.log('\nNext steps:');
+    if (options.hasCatalogue && options.catalogueLabel) {
+        console.log(` - Review ${options.catalogueLabel} to set displayName, description, emoji, color, type, and surfaceTargets as needed.`);
+    }
+    else {
+        console.log(' - Run "playdrop-cli init ." when you are ready to add catalogue metadata and project docs.');
+    }
+    if (options.projectDir) {
+        console.log(` - Open ${options.projectDir} to continue building your project.`);
+        if (options.hasPackageJson) {
+            if (options.dependenciesInstalled) {
+                console.log(` - Dependencies installed. Use "npm run dev" inside ${options.projectDir} for live reload.`);
+            }
+            else {
+                console.log(` - Run "npm install" inside ${options.projectDir} before your first build.`);
+            }
+        }
+        console.log(` - The bundled HTML entry point is ${options.entryPointLabel}.`);
+    }
+    else {
+        console.log(` - Build your app in ${options.entryPointLabel}.`);
+    }
+    console.log(` - Test locally with "playdrop-cli dev ${name}".`);
+    if (options.hasCatalogue) {
+        console.log(` - Deploy a single app with "playdrop-cli upload ${name}" or everything in the catalogue with "playdrop-cli upload .".`);
+    }
+    else {
+        console.log(' - After running "playdrop-cli init", upload with "playdrop-cli upload ." to share your project.');
+    }
+}
+async function promptInit() {
+    if (!node_process_1.stdin.isTTY || !node_process_1.stdout.isTTY) {
+        return false;
+    }
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    const answer = await rl.question('No catalogue.json found. Run "playdrop-cli init ." first? (y/N) ');
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+async function ensureLocalCatalogue(cataloguePath) {
+    if ((0, node_fs_1.existsSync)(cataloguePath)) {
+        return { path: cataloguePath, initSummary: null, created: false };
+    }
+    const shouldInit = await promptInit();
+    if (!shouldInit) {
+        (0, messages_1.printErrorWithHelp)('A local catalogue.json is required to register app metadata next to the app file.', [
+            'Run "playdrop-cli init ." in this directory to create catalogue.json and starter docs before running "playdrop-cli create".'
+        ], { command: 'create', includeGeneralHelp: false });
+        process.exitCode = process.exitCode || 1;
+        return null;
+    }
+    const summary = await (0, init_1.init)('.', { quiet: true });
+    if (!summary) {
+        process.exitCode = process.exitCode || 1;
+        return null;
+    }
+    return { path: summary.cataloguePath, initSummary: summary, created: true };
+}
+function findWorkspaceRootDirectory(cataloguePath) {
+    let currentDir = (0, node_path_1.dirname)((0, node_path_1.resolve)(cataloguePath));
+    while (true) {
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            return currentDir;
+        }
+        const parentCatalogue = (0, node_path_1.resolve)(parentDir, CATALOGUE_FILENAME);
+        if (!(0, node_fs_1.existsSync)(parentCatalogue)) {
+            return currentDir;
+        }
+        currentDir = parentDir;
+    }
+}
+function warnMissingWorkspaceReadme(cataloguePath) {
+    const workspaceRoot = findWorkspaceRootDirectory(cataloguePath);
+    const readmePath = (0, node_path_1.resolve)(workspaceRoot, 'README.md');
+    if ((0, node_fs_1.existsSync)(readmePath)) {
+        return;
+    }
+    const workspaceLabel = (0, node_path_1.relative)(process.cwd(), workspaceRoot) || '.';
+    const initCommandTarget = workspaceLabel === '.' ? '.' : workspaceLabel;
+    console.log(`\nWorkspace docs reminder: README.md is missing at ${workspaceLabel}. Add documentation there or run "playdrop-cli init ${initCommandTarget}" before creating apps next time to auto-populate it.`);
+}
+function parseTemplateKey(value) {
+    const parts = value.split('/').map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 1) {
+        const slug = parts[0];
+        if (!slug) {
+            return null;
+        }
+        return { namespace: 'playdrop', slug, key: `playdrop/template/${slug}` };
+    }
+    if (parts.length >= 3) {
+        const [creator, typeSegment, ...rest] = parts;
+        if (!creator) {
+            return null;
+        }
+        const normalizedType = typeSegment.toLowerCase();
+        if (normalizedType !== 'template' && normalizedType !== 'templates') {
+            return null;
+        }
+        const slug = rest.join('/');
+        if (!slug) {
+            return null;
+        }
+        return { namespace: creator, slug, key: `${creator}/template/${slug}` };
+    }
+    return null;
+}
+function parseRemixKey(value) {
+    const parts = value.split('/').map((part) => part.trim()).filter(Boolean);
+    if (parts.length < 3) {
+        return null;
+    }
+    const [creator, typeSegment, ...rest] = parts;
+    if (!creator) {
+        return null;
+    }
+    const normalizedType = typeSegment.toLowerCase();
+    const mappedType = APP_TYPE_SLUGS[normalizedType];
+    if (!mappedType) {
+        return null;
+    }
+    const name = rest.join('/');
+    if (!name) {
+        return null;
+    }
+    return {
+        creator,
+        name,
+        type: mappedType,
+        typeSlug: mappedType.toLowerCase(),
+    };
+}
+async function fetchRemixScaffold(client, creator, app) {
+    try {
+        const response = await client.fetchRemixScaffold(creator, app);
+        const archiveUrl = typeof response?.archiveUrl === 'string' && response.archiveUrl.trim().length > 0
+            ? response.archiveUrl.trim()
+            : null;
+        const htmlContent = typeof response?.html === 'string' ? response.html : null;
+        if (!archiveUrl && !htmlContent) {
+            throw new Error('Remix response missing scaffold content');
+        }
+        const metadata = response.metadata;
+        const entryPoint = extractEntryPointFromMetadata(metadata);
+        return {
+            html: htmlContent,
+            metadata,
+            archiveUrl,
+            entryPoint,
+        };
+    }
+    catch (unknownError) {
+        if (unknownError instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(unknownError, 'Remix scaffold');
+        }
+        if (unknownError instanceof types_1.ApiError) {
+            const detail = unknownError.message?.trim();
+            throw new Error(detail || `status ${unknownError.status}`);
+        }
+        throw unknownError;
+    }
+}
+async function fetchTemplateScaffold(client, namespace, slug) {
+    try {
+        const response = await client.fetchTemplateScaffold(namespace, slug);
+        const archiveUrl = typeof response?.archiveUrl === 'string' && response.archiveUrl.trim().length > 0
+            ? response.archiveUrl.trim()
+            : null;
+        const htmlContent = typeof response?.html === 'string' ? response.html : null;
+        if (!archiveUrl && !htmlContent) {
+            throw new Error('Template response missing scaffold content');
+        }
+        const metadata = response.metadata;
+        const entryPoint = extractEntryPointFromMetadata(metadata);
+        return {
+            html: htmlContent,
+            metadata,
+            archiveUrl,
+            entryPoint,
+        };
+    }
+    catch (unknownError) {
+        if (unknownError instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(unknownError, 'Template scaffold');
+        }
+        if (unknownError instanceof types_1.ApiError) {
+            const detail = unknownError.message?.trim();
+            throw new Error(detail || `status ${unknownError.status}`);
+        }
+        throw unknownError;
+    }
+}
+function describeInitSummary(summary) {
+    if (!summary) {
+        return null;
+    }
+    const parts = [];
+    parts.push(summary.readmeStatus === 'created' ? 'created README.md' : 'kept existing README.md');
+    parts.push(summary.agentsStatus === 'created' ? 'created AGENTS.md' : 'kept existing AGENTS.md');
+    parts.push(summary.catalogueStatus === 'created' ? 'created catalogue.json' : 'kept existing catalogue.json');
+    if (summary.gitStatus === 'initialized') {
+        parts.push('initialized git repository');
+    }
+    else if (summary.gitStatus === 'declined') {
+        parts.push('skipped git init');
+    }
+    return `Project bootstrap recap: ${parts.join('; ')}.`;
+}
+async function create(name, options = {}) {
+    const file = (0, node_path_1.resolve)(`${name}.html`);
+    const projectDirCandidate = (0, node_path_1.resolve)(name);
+    const templateOptionRaw = options.template?.trim();
+    const remixOptionRaw = options.remix?.trim();
+    const existingLookup = (0, catalogue_1.resolveCatalogueEntries)(process.cwd(), { filterName: name });
+    if (existingLookup.errors.length > 0) {
+        for (const error of existingLookup.errors) {
+            (0, messages_1.printErrorWithHelp)(error, ['Fix the catalogue issues noted above, then rerun "playdrop-cli create".'], {
+                command: 'create',
+                includeGeneralHelp: false,
+            });
+        }
+        process.exitCode = 1;
+        return;
+    }
+    if (existingLookup.apps.length > 1) {
+        (0, messages_1.printErrorWithHelp)(`Multiple catalogue entries share the app name "${name}".`, [
+            'Ensure each app has a unique name across catalogue.json files before running "playdrop-cli create".'
+        ], { command: 'create' });
+        process.exitCode = 1;
+        return;
+    }
+    const existingTask = existingLookup.apps.length === 1 ? existingLookup.apps[0] : null;
+    const reuseExistingApp = existingTask !== null && !templateOptionRaw && !remixOptionRaw;
+    if (!reuseExistingApp && ((0, node_fs_1.existsSync)(file) || (0, node_fs_1.existsSync)(projectDirCandidate))) {
+        (0, messages_1.printErrorWithHelp)(`Cannot create ${name} because a file or directory with that name already exists.`, [
+            'Choose a different app name or remove the existing file before running "playdrop-cli create" again.'
+        ], { command: 'create' });
+        process.exitCode = 1;
+        return;
+    }
+    if (templateOptionRaw && remixOptionRaw) {
+        (0, messages_1.printErrorWithHelp)('Cannot use --template and --remix at the same time.', [
+            'Choose one source: use "--remix {creator}/{type}/{name}" to remix an existing app, or "--template {creator}/template/{name}" to start from a template.'
+        ], { command: 'create' });
+        process.exitCode = 1;
+        return;
+    }
+    if (!templateOptionRaw && !remixOptionRaw) {
+        if (!reuseExistingApp) {
+            (0, messages_1.printErrorWithHelp)('Specify either --template or --remix when creating an app.', [
+                'Use "playdrop-cli list --type templates" to discover available templates.',
+                'Browse https://playdrop.ai, pick an app, and pass its key with "--remix creator/type/name".'
+            ], { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const templateOption = templateOptionRaw || undefined;
+    const remixOption = remixOptionRaw || undefined;
+    const cfg = (0, config_1.loadConfig)();
+    const envName = cfg.env;
+    if (!envName) {
+        (0, messages_1.printLoginRequired)('Creating an app', 'create');
+        process.exitCode = 1;
+        return;
+    }
+    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
+    if (!envConfig) {
+        const choices = (0, environment_1.formatEnvironmentList)();
+        (0, messages_1.printErrorWithHelp)(`Environment "${envName}" from your Playdrop config is not supported.`, [
+            `Available environments: ${choices}.`,
+            'Run "playdrop-cli login --env <env>" to save a supported environment before creating apps.'
+        ], { command: 'create', includeGeneralHelp: false });
+        process.exitCode = 1;
+        return;
+    }
+    if (!cfg.token) {
+        (0, messages_1.printLoginRequired)('Creating an app', 'create');
+        process.exitCode = 1;
+        return;
+    }
+    if (envConfig.allowInsecureRequests) {
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+    }
+    const currentDir = process.cwd();
+    const localCataloguePath = (0, node_path_1.resolve)(currentDir, CATALOGUE_FILENAME);
+    let initSummary = null;
+    let workspaceCatalogueResult = null;
+    let workspaceCatalogueUpdateSucceeded = false;
+    let projectCatalogueResult = null;
+    let cataloguePathToUse = null;
+    let projectCataloguePath = null;
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
+    const sourceInfo = {};
+    let scaffold = null;
+    let provenanceMessage = '';
+    if (!reuseExistingApp && remixOption) {
+        const parsed = parseRemixKey(remixOption);
+        if (!parsed) {
+            (0, messages_1.printErrorWithHelp)('The --remix value must use the {creator}/{type}/{name} key format.', [
+                'Example: playdrop/game/hangingout.',
+                'Use "playdrop-cli list --type app" to find remixable keys.'
+            ], { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+        const remixKeyDisplay = `${parsed.creator}/${parsed.typeSlug}/${parsed.name}`;
+        sourceInfo.remixSlug = remixKeyDisplay;
+        try {
+            scaffold = await fetchRemixScaffold(client, parsed.creator, parsed.name);
+            provenanceMessage = `Remixed from ${remixKeyDisplay}.`;
+        }
+        catch (error) {
+            if (error instanceof http_1.CLIUnsupportedClientError) {
+                process.exitCode = 1;
+                return;
+            }
+            const detailMessage = typeof error?.message === 'string' && error.message.trim()
+                ? error.message.trim()
+                : '';
+            const problem = detailMessage
+                ? `Failed to fetch remix source: ${detailMessage}`
+                : 'Failed to fetch remix source.';
+            (0, messages_1.printErrorWithHelp)(problem, [
+                'Confirm the key is correct and that you have access to remix the source app.',
+                'Retry once you are logged in and the Playdrop API is reachable.'
+            ], { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else if (templateOption) {
+        if (reuseExistingApp) {
+            // ignore template when reusing local files
+        }
+        else {
+            const parsed = parseTemplateKey(templateOption);
+            if (!parsed) {
+                (0, messages_1.printErrorWithHelp)('The --template value must use the {creator}/template/{name} key format.', [
+                    'Example: playdrop/template/typescript_template.',
+                    'You can also pass a short name like "starter" to use playdrop/template/starter.'
+                ], { command: 'create' });
+                process.exitCode = 1;
+                return;
+            }
+            sourceInfo.templateSlug = parsed.key;
+            try {
+                scaffold = await fetchTemplateScaffold(client, parsed.namespace, parsed.slug);
+                provenanceMessage = `Scaffolded from template ${parsed.key}.`;
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    process.exitCode = 1;
+                    return;
+                }
+                const detailMessage = typeof error?.message === 'string' && error.message.trim()
+                    ? error.message.trim()
+                    : '';
+                const problem = detailMessage
+                    ? `Failed to fetch template: ${detailMessage}`
+                    : 'Failed to fetch template.';
+                (0, messages_1.printErrorWithHelp)(problem, [
+                    'Verify the template key and ensure you are logged in.',
+                    'Retry when the Playdrop API is reachable.'
+                ], { command: 'create' });
+                process.exitCode = 1;
+                return;
+            }
+        }
+    }
+    if (!reuseExistingApp && !scaffold) {
+        (0, messages_1.printErrorWithHelp)('Failed to retrieve scaffold data. Specify a valid --template or --remix key and try again.', [
+            'Use "playdrop-cli list --type templates" to discover available templates.',
+            'Browse https://playdrop.ai and copy an app key to pass with "--remix".'
+        ], { command: 'create' });
+        process.exitCode = 1;
+        return;
+    }
+    const hasArchive = !reuseExistingApp && typeof scaffold?.archiveUrl === 'string' && scaffold.archiveUrl?.trim().length > 0;
+    let htmlFilePath = reuseExistingApp && existingTask ? existingTask.filePath : '';
+    let projectDir = reuseExistingApp && existingTask ? existingTask.projectDir : null;
+    let packageJsonPath = reuseExistingApp && existingTask ? existingTask.packageJsonPath ?? null : null;
+    if (!reuseExistingApp && !hasArchive) {
+        const ensuredCatalogue = await ensureLocalCatalogue(localCataloguePath);
+        if (!ensuredCatalogue) {
+            return;
+        }
+        initSummary = ensuredCatalogue.initSummary;
+        cataloguePathToUse = ensuredCatalogue.path;
+    }
+    if (!reuseExistingApp && hasArchive) {
+        projectDir = projectDirCandidate;
+        try {
+            (0, node_fs_1.mkdirSync)(projectDir);
+        }
+        catch (error) {
+            (0, messages_1.printErrorWithHelp)(`Cannot create ${projectDir} because it already exists.`, [
+                'Remove or rename the existing directory before running "playdrop-cli create" again.'
+            ], { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const archiveBuffer = await downloadArchive(scaffold.archiveUrl);
+            const extraction = extractProjectArchive(archiveBuffer, projectDir);
+            const extractedCatalogue = (0, node_path_1.resolve)(projectDir, CATALOGUE_FILENAME);
+            projectCataloguePath = (0, node_fs_1.existsSync)(extractedCatalogue) ? extractedCatalogue : null;
+            const entryPointCandidates = [
+                extraction.entryPoint,
+                scaffold.entryPoint ?? null,
+                'dist/index.html',
+                `${name}.html`,
+            ].filter((value) => typeof value === 'string' && value.trim().length > 0);
+            let resolvedEntryPoint = null;
+            for (const candidate of entryPointCandidates) {
+                const normalized = candidate.replace(/^\.\/?/, '').replace(/^\\+/, '').replace(/\\/g, '/');
+                const candidatePath = (0, node_path_1.resolve)(projectDir, normalized);
+                if ((0, node_fs_1.existsSync)(candidatePath) && (0, node_fs_1.statSync)(candidatePath).isFile()) {
+                    resolvedEntryPoint = candidatePath;
+                    break;
+                }
+            }
+            if (!resolvedEntryPoint) {
+                const fallbackHtml = findFirstHtmlFile(projectDir);
+                if (fallbackHtml) {
+                    resolvedEntryPoint = fallbackHtml;
+                }
+            }
+            if (!resolvedEntryPoint) {
+                (0, node_fs_1.rmSync)(projectDir, { recursive: true, force: true });
+                (0, messages_1.printErrorWithHelp)('Extracted project archive did not include an HTML entry point.', [
+                    'Check the template archive and ensure playdrop.project.json specifies a valid entryPoint before retrying.'
+                ], { command: 'create' });
+                process.exitCode = 1;
+                return;
+            }
+            htmlFilePath = resolvedEntryPoint;
+            const packageCandidate = (0, node_path_1.join)(projectDir, 'package.json');
+            packageJsonPath = (0, node_fs_1.existsSync)(packageCandidate) ? packageCandidate : null;
+        }
+        catch (error) {
+            (0, node_fs_1.rmSync)(projectDir, { recursive: true, force: true });
+            const detailMessage = typeof error?.message === 'string' && error.message.trim()
+                ? error.message.trim()
+                : 'Failed to download or extract the project archive.';
+            (0, messages_1.printNetworkIssue)(detailMessage, 'create');
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`Created ${projectDir}`);
+    }
+    else {
+        if (reuseExistingApp) {
+            htmlFilePath = existingTask.filePath;
+            if (!(0, node_fs_1.existsSync)(htmlFilePath) || !(0, node_fs_1.statSync)(htmlFilePath).isFile()) {
+                (0, messages_1.printErrorWithHelp)(`Could not reuse existing app because ${htmlFilePath} does not exist.`, [
+                    'Update catalogue.json or remove the entry before rerunning "playdrop-cli create".'
+                ], { command: 'create' });
+                process.exitCode = 1;
+                return;
+            }
+            projectDir = existingTask.projectDir;
+            packageJsonPath = existingTask.packageJsonPath ?? null;
+            cataloguePathToUse = existingTask.catalogueAbsolutePath;
+        }
+        else if (!scaffold?.html) {
+            (0, messages_1.printNetworkIssue)('Unable to retrieve template content for playdrop-cli create.', 'create');
+            process.exitCode = 1;
+            return;
+        }
+        if (!reuseExistingApp) {
+            htmlFilePath = file;
+            const scaffoldHtml = scaffold.html;
+            (0, node_fs_1.writeFileSync)(htmlFilePath, scaffoldHtml);
+            console.log(`Created ${htmlFilePath}`);
+        }
+    }
+    if (provenanceMessage) {
+        console.log(provenanceMessage);
+    }
+    if (!reuseExistingApp && projectCataloguePath) {
+        projectCatalogueResult = updateExtractedProjectCatalogue(name, scaffold.metadata, projectCataloguePath, sourceInfo, htmlFilePath);
+        const projectUpdateSucceeded = logProjectCatalogueOutcome(projectCatalogueResult, name);
+        if (!projectUpdateSucceeded) {
+            return;
+        }
+    }
+    const workspaceCatalogueExists = (0, node_fs_1.existsSync)(localCataloguePath);
+    const workspaceCatalogueRequired = !projectCataloguePath;
+    const shouldEnsureWorkspaceCatalogue = workspaceCatalogueRequired || workspaceCatalogueExists;
+    if (!reuseExistingApp && shouldEnsureWorkspaceCatalogue) {
+        if (!cataloguePathToUse) {
+            const ensuredCatalogue = await ensureLocalCatalogue(localCataloguePath);
+            if (!ensuredCatalogue) {
+                return;
+            }
+            initSummary = ensuredCatalogue.initSummary;
+            cataloguePathToUse = ensuredCatalogue.path;
+        }
+        try {
+            workspaceCatalogueResult = ensureCatalogueEntry(name, scaffold.metadata, cataloguePathToUse, sourceInfo, htmlFilePath);
+        }
+        catch (error) {
+            const fallbackLabel = cataloguePathToUse
+                ? ((0, node_path_1.relative)(process.cwd(), cataloguePathToUse) || CATALOGUE_FILENAME)
+                : CATALOGUE_FILENAME;
+            const message = typeof error?.message === 'string' && error.message.includes('surfaceTargets')
+                ? error.message
+                : `Could not update ${fallbackLabel} because it contains invalid JSON.`;
+            const suggestions = typeof error?.message === 'string' && error.message.includes('surfaceTargets')
+                ? ['Fix the catalogue entry described above, then rerun "playdrop-cli create".']
+                : [`Fix the JSON in ${fallbackLabel} and add ${name} again before rerunning "playdrop-cli create".`];
+            (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+        workspaceCatalogueUpdateSucceeded = logCatalogueOutcome(workspaceCatalogueResult, name);
+        if (!workspaceCatalogueUpdateSucceeded) {
+            return;
+        }
+    }
+    let registrationTask = null;
+    if (reuseExistingApp && existingTask) {
+        registrationTask = existingTask;
+    }
+    else {
+        const registrationLookup = (0, catalogue_1.resolveCatalogueEntries)(process.cwd(), { filterName: name });
+        if (registrationLookup.errors.length > 0) {
+            const otherErrors = registrationLookup.errors.filter((error) => typeof error !== 'string' || !error.includes('Duplicate app name'));
+            if (otherErrors.length > 0) {
+                for (const error of otherErrors) {
+                    (0, messages_1.printErrorWithHelp)(error, ['Fix the catalogue issues noted above, then rerun "playdrop-cli create".'], { command: 'create', includeGeneralHelp: false });
+                }
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (registrationLookup.apps.length === 0) {
+            (0, messages_1.printErrorWithHelp)(`App "${name}" was not found in any catalogue.json after scaffolding.`, [
+                'Ensure catalogue.json was updated, then rerun "playdrop-cli create".'
+            ], { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+        const candidates = registrationLookup.apps;
+        const preferredCataloguePaths = [];
+        if (workspaceCatalogueResult && workspaceCatalogueUpdateSucceeded) {
+            preferredCataloguePaths.push((0, node_path_1.resolve)(workspaceCatalogueResult.path));
+        }
+        if (projectCatalogueResult?.updated) {
+            preferredCataloguePaths.push((0, node_path_1.resolve)(projectCatalogueResult.path));
+        }
+        let selectedTask = null;
+        for (const preferred of preferredCataloguePaths) {
+            const match = candidates.find(task => (0, node_path_1.resolve)(task.catalogueAbsolutePath) === preferred);
+            if (match) {
+                selectedTask = match;
+                break;
+            }
+        }
+        if (!selectedTask && candidates.length === 1) {
+            selectedTask = candidates[0];
+        }
+        if (!selectedTask) {
+            const matchingByHtml = candidates.filter(task => task.filePath === htmlFilePath);
+            if (matchingByHtml.length === 1) {
+                selectedTask = matchingByHtml[0];
+            }
+        }
+        if (!selectedTask) {
+            (0, messages_1.printErrorWithHelp)(`Multiple catalogue entries share the app name "${name}".`, [
+                'Ensure each app has a unique name across catalogue.json files before running "playdrop-cli create".'
+            ], { command: 'create' });
+            process.exitCode = 1;
+            return;
+        }
+        registrationTask = selectedTask;
+    }
+    if (registrationTask) {
+        const metadataWarning = (0, catalogue_1.formatMissingMetadataWarnings)(registrationTask);
+        if (metadataWarning) {
+            console.log(`⚠️ ${metadataWarning}`);
+        }
+        const displayName = registrationTask.displayName && registrationTask.displayName.trim().length > 0
+            ? registrationTask.displayName
+            : registrationTask.name;
+        const createPayload = {
+            name,
+            displayName,
+        };
+        let createConflict = false;
+        try {
+            await client.createApp(createPayload);
+            console.log(`Registered ${displayName} with the Playdrop API.`);
+        }
+        catch (error) {
+            if (error instanceof http_1.CLIUnsupportedClientError) {
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof types_1.UnsupportedClientError) {
+                (0, http_1.handleUnsupportedError)(error, 'Register app');
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof types_1.ApiError) {
+                if (error.status === 409) {
+                    createConflict = true;
+                    console.log(`ℹ️ App ${name} already exists on ${envName}. Updating metadata from the local catalogue.`);
+                }
+                else {
+                    (0, messages_1.printErrorWithHelp)(`Failed to register ${name} (status ${error.status}).`, [
+                        'Ensure your account has creator permissions and retry once the issue is resolved.'
+                    ], { command: 'create' });
+                    process.exitCode = 1;
+                    return;
+                }
+            }
+            else if (error instanceof TypeError) {
+                (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to register the app.', 'create');
+                process.exitCode = 1;
+                return;
+            }
+            else {
+                throw error;
+            }
+        }
+        // Note: emoji, color, description are now per-version fields (set via version upload)
+        const updatePayload = {};
+        if (registrationTask.type) {
+            updatePayload.type = registrationTask.type;
+        }
+        if (registrationTask.displayName && registrationTask.displayName.trim().length > 0) {
+            updatePayload.displayName = registrationTask.displayName;
+        }
+        if (Object.keys(updatePayload).length > 0) {
+            try {
+                await client.updateApp(name, updatePayload);
+                if (createConflict) {
+                    console.log(`Updated ${name} metadata on the Playdrop API.`);
+                }
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'Update app');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Failed to update ${name} metadata (status ${error.status}).`, [
+                        'Update the catalogue entry and retry, or contact the Playdrop team if the issue persists.'
+                    ], { command: 'create' });
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof TypeError) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to update the app.', 'create');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+    }
+    const projectDirLabel = projectDir ? ((0, node_path_1.relative)(process.cwd(), projectDir) || projectDir) : null;
+    const entryPointLabel = (0, node_path_1.relative)(process.cwd(), htmlFilePath) || (0, node_path_1.basename)(htmlFilePath);
+    const hasPackageJson = Boolean(packageJsonPath);
+    let dependenciesInstalled = false;
+    if (!reuseExistingApp && projectDir && packageJsonPath && node_process_1.stdin.isTTY && node_process_1.stdout.isTTY) {
+        const accepted = await promptInstallDependencies(projectDir);
+        if (accepted) {
+            const success = runNpmInstall(projectDir);
+            dependenciesInstalled = success;
+            if (!success) {
+                console.warn('npm install failed. Install dependencies manually before continuing.');
+            }
+        }
+    }
+    if (initSummary) {
+        const recap = describeInitSummary(initSummary);
+        if (recap) {
+            console.log(recap);
+        }
+    }
+    const projectCatalogueUpdated = Boolean(projectCatalogueResult?.updated);
+    const workspaceCatalogueUpdated = Boolean(workspaceCatalogueResult && workspaceCatalogueUpdateSucceeded);
+    let catalogueLabel;
+    if (projectCatalogueUpdated && projectCatalogueResult) {
+        catalogueLabel = (0, node_path_1.relative)(process.cwd(), projectCatalogueResult.path) || CATALOGUE_FILENAME;
+    }
+    else if (workspaceCatalogueUpdated && workspaceCatalogueResult) {
+        catalogueLabel = (0, node_path_1.relative)(process.cwd(), workspaceCatalogueResult.path) || CATALOGUE_FILENAME;
+    }
+    let hasCatalogue = projectCatalogueUpdated || workspaceCatalogueUpdated;
+    if (reuseExistingApp && existingTask) {
+        hasCatalogue = true;
+        if (!catalogueLabel) {
+            catalogueLabel = (0, node_path_1.relative)(process.cwd(), existingTask.catalogueAbsolutePath) || CATALOGUE_FILENAME;
+        }
+    }
+    logNextSteps(name, {
+        hasCatalogue,
+        catalogueLabel,
+        projectDir: projectDirLabel,
+        entryPointLabel,
+        hasPackageJson,
+        dependenciesInstalled,
+    });
+    if (workspaceCatalogueUpdated && workspaceCatalogueResult) {
+        warnMissingWorkspaceReadme(workspaceCatalogueResult.path);
+    }
+}