sitevision-cli 1.0.0-beta.30 → 1.0.0-beta.32

package/dist/shell/Shell.js

@@ -1,10 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import fs from 'node:fs';
 import path from 'node:path';
 import { useCallback, useEffect, useMemo, useReducer, useState } from 'react';
 import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import Spinner from 'ink-spinner';
 import { detectProject, appTypeOf, localizedText, readWorkspaceDevProperties, readSvcConfig, writeSvcConfig, writeDevProperties, syncDevPropertiesToPackageJson, } from '../utils/project-detection.js';
-import { appGroup, configIncomplete, needsOnboarding, } from '../utils/workspace.js';
+import { appGroup, configIncomplete, discoverApps, needsOnboarding, } from '../utils/workspace.js';
+import { createAppInTerminal, isEmptyOrMissing, seedNewApp, startCreateApp, appNameAdvice, appNameProblem, } from '../utils/create-app.js';
 import { listAddons, listExecutables, } from '../utils/sitevision-api.js';
 import { useTasks, runningTasks, startActivate, getTasks, } from '../utils/tasks.js';
 import { PasswordInput } from '../components/PasswordInput.js';
@@ -20,7 +22,7 @@ import { Popover } from './Popover.js';
 import { ChangelogPanel } from './Changelog.js';
 import { baseEnvironment, environmentColor, environmentNames, environmentProject, isProductionEnvironment, resolveEnvironment, } from '../utils/environments.js';
 import { t } from '../utils/i18n.js';
-import { actionForKey, authState, resolveDeployConfig, } from './actions.js';
+import { actionForKey, actions, authState, resolveDeployConfig, } from './actions.js';
 function useSize() {
     const { stdout } = useStdout();
     const read = () => ({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
@@ -35,7 +37,7 @@ function useSize() {
     }, [stdout]);
     return size;
 }
-export function Shell({ apps: initialApps, workspaceRoot, version, minimal = false, updatedFrom, }) {
+export function Shell({ apps: initialApps, workspaceRoot, version, minimal = false, updatedFrom, handover, }) {
     const { exit } = useApp();
     const { columns, rows } = useSize();
     const tasks = useTasks();
@@ -51,6 +53,7 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
     const [versionRow, setVersionRow] = useState(0);
     const [logScroll, setLogScroll] = useState(0);
     const [logWrap, setLogWrap] = useState(false);
+    const [offerAddon, setOfferAddon] = useState();
     const [notice, setNotice] = useState(null);
     const [, tick] = useReducer((n) => n + 1, 0);
     // In workspace mode the row after the last app is "Workspace settings".
@@ -169,6 +172,165 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
             writeSvcConfig(configRoot, { environment: clean });
             notify(t('environment {env} added', { env: clean }), 'ok');
         },
+        async createApp() {
+            const promptText = async (label, initial, validate, error, advise) => new Promise(resolve => {
+                setOverlay({
+                    kind: 'prompt',
+                    label,
+                    initial,
+                    validate,
+                    advise,
+                    error,
+                    resolve,
+                });
+            });
+            const base = workspaceRoot ?? path.dirname(rawProject.root);
+            const suggested = workspaceRoot
+                ? path.relative(workspaceRoot, path.dirname(rawProject.root)) || '.'
+                : base;
+            // Asked again, with the reason, until the name is free in that folder.
+            let name = '';
+            let parentDir = '';
+            let appDir = '';
+            let taken;
+            for (;;) {
+                // eslint-disable-next-line no-await-in-loop
+                const typed = await promptText(t('Name of the new app'), name, appNameProblem, taken, appNameAdvice);
+                if (typed === null)
+                    return;
+                name = typed.trim();
+                // Folders that already hold apps, then a way to type another one.
+                const folders = [
+                    ...new Set([
+                        suggested,
+                        ...apps.map(app => workspaceRoot
+                            ? path.relative(base, path.dirname(app.root)) || '.'
+                            : path.dirname(app.root)),
+                    ]),
+                ].toSorted((a, b) => a.localeCompare(b));
+                // eslint-disable-next-line no-await-in-loop
+                const folderPick = await new Promise(resolve => {
+                    setOverlay({
+                        kind: 'choice',
+                        label: t('Create it in folder'),
+                        choices: [...folders, t('Other folder…')],
+                        multi: false,
+                        initial: [folders.indexOf(suggested)],
+                        resolve,
+                    });
+                });
+                if (!folderPick)
+                    return;
+                const folder = folders[folderPick[0]] ??
+                    // eslint-disable-next-line no-await-in-loop
+                    (await promptText(t('Create it in folder'), suggested));
+                if (folder === null)
+                    return;
+                parentDir = path.resolve(base, folder.trim() || '.');
+                appDir = path.join(parentDir, name);
+                if (isEmptyOrMissing(appDir))
+                    break;
+                taken = t('{dir} already exists. Pick another name, or keep it and choose a different folder next.', { dir: path.relative(base, appDir) });
+            }
+            // Both were checked above, so a run that leaves no app may remove them.
+            const madeParent = !fs.existsSync(parentDir);
+            const discard = () => {
+                fs.rmSync(appDir, { recursive: true, force: true });
+                if (madeParent && isEmptyOrMissing(parentDir))
+                    fs.rmSync(parentDir, { recursive: true, force: true });
+            };
+            fs.mkdirSync(parentDir, { recursive: true });
+            const known = (workspaceRoot
+                ? readWorkspaceDevProperties(workspaceRoot)
+                : rawProject.devProperties);
+            const ask = async (question) => {
+                // svc keeps passwords in the keychain, never in the app's file.
+                if (question.name === 'password')
+                    return { skip: true };
+                const shared = known?.[question.name];
+                if (!question.error &&
+                    ['domain', 'siteName', 'username', 'useHTTPForDevDeploy'].includes(question.name) &&
+                    shared !== undefined &&
+                    shared !== '')
+                    return { value: shared };
+                const label = question.error
+                    ? `${question.message} (${question.error})`
+                    : question.message;
+                if (question.type === 'confirm') {
+                    const value = await new Promise(resolve => {
+                        setOverlay({ kind: 'confirm', message: label, resolve });
+                    });
+                    return { value };
+                }
+                if (question.type === 'password') {
+                    const secret = await new Promise(resolve => {
+                        setOverlay({ kind: 'password', label, resolve });
+                    });
+                    return secret && { value: secret.password };
+                }
+                if (question.choices.length > 0) {
+                    const multi = question.type === 'checkbox';
+                    const picked = await new Promise(resolve => {
+                        setOverlay({
+                            kind: 'choice',
+                            label,
+                            choices: question.choices,
+                            multi,
+                            initial: [question.default ?? []].flat(),
+                            resolve,
+                        });
+                    });
+                    return picked && { value: multi ? picked : picked[0] };
+                }
+                const initial = question.default ?? (question.name === 'addonName' ? name : '');
+                const value = await promptText(label, typeof initial === 'string' ? initial : JSON.stringify(initial));
+                return value === null ? null : { value };
+            };
+            notify(t('creating {app}: installing, questions follow', { app: name }));
+            setTab('log');
+            const { done } = startCreateApp({ name, parentDir, ask });
+            let outcome = await done;
+            setOverlay(null);
+            if (outcome === 'unmanaged') {
+                if (!handover) {
+                    notify(t('The scaffolder could not be run from here'), 'error');
+                    return;
+                }
+                fs.rmSync(appDir, { recursive: true, force: true });
+                handover(async () => {
+                    if (await createAppInTerminal(name, parentDir))
+                        seedNewApp(appDir, workspaceRoot);
+                    else
+                        discard();
+                });
+                return;
+            }
+            if (outcome !== 'created') {
+                discard();
+                if (outcome === 'failed')
+                    notify(t('creating {app} failed, see the log', { app: name }), 'error');
+                return;
+            }
+            try {
+                seedNewApp(appDir, workspaceRoot);
+            }
+            catch (error) {
+                notify(error instanceof Error ? error.message : String(error), 'warn');
+                outcome = 'failed';
+            }
+            if (!workspaceRoot ||
+                path.relative(workspaceRoot, appDir).startsWith('..')) {
+                notify(t('{app} created in {dir}', { app: name, dir: appDir }), 'ok');
+                return;
+            }
+            const found = discoverApps(workspaceRoot);
+            setApps(found);
+            setFilter('');
+            setSelected(Math.max(0, found.findIndex(app => app.root === appDir)));
+            if (outcome === 'created')
+                notify(t('{app} created', { app: name }), 'ok');
+            setOfferAddon(appDir);
+        },
         openWorkspaceSettings: workspaceRoot
             ? () => {
                 setSelected(apps.length);
@@ -252,12 +414,38 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
     const pickAddon = useCallback(async () => new Promise(resolve => {
         setOverlay({ kind: 'picker', resolve });
     }), []);
+    // A freshly created app: once it is the selected project, offer its addon.
+    useEffect(() => {
+        if (!offerAddon || project.root !== offerAddon || overlay)
+            return;
+        setOfferAddon(undefined);
+        const addon = project.devProperties?.addonName;
+        const action = actions.find(entry => entry.id === 'create-addon');
+        if (!addon || !action || !project.devProperties?.domain)
+            return;
+        void context
+            .confirm(t('Create the addon "{addon}" on {domain} now?', {
+            addon,
+            domain: project.devProperties.domain,
+        }))
+            .then(yes => {
+            if (yes)
+                run(action);
+        });
+    }, [offerAddon, project, overlay, context, run]);
     const loadAddons = useCallback(async () => {
         const config = await resolveDeployConfig(context);
         return config ? listAddons(config) : { error: t('No credentials.') };
     }, [context]);
     const appTasks = tasks.filter(task => task.appRoot === project.root);
-    const logTask = appTasks.find(task => task.status === 'running') ?? appTasks.at(-1);
+    // A new app is not in the list while it is being created, so its log shows
+    // wherever you are; a failed one stays up until another task runs.
+    const creating = tasks.findLast(task => task.kind === 'create');
+    const logTask = appTasks.find(task => task.status === 'running') ??
+        (creating?.status === 'running' ||
+            (creating?.status === 'error' && creating === tasks.at(-1))
+            ? creating
+            : appTasks.at(-1));
     useInput((raw, key) => {
         // Terminals speaking the kitty keyboard protocol report shift+s as
         // "s" plus a shift flag; fold that back into the uppercase letter so
@@ -432,6 +620,7 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
             ['/', 'commands'],
             ['q', 'quit'],
         ]);
+    const where = focus === 'nav' && !settings ? 'nav' : settings ? 'workspace' : tab;
     const hereHints = focus === 'nav' && !settings
         ? navHints
         : settings
@@ -507,6 +696,7 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
         renderOverlay(overlay, {
             project,
             here: hereHints,
+            where,
             closeOverlay,
             run,
             notify,
@@ -530,6 +720,8 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
                     base: rawProject.devProperties,
                     environment: env,
                     workspaceRoot,
+                    manifest: project.manifest,
+                    manifestPath: project.paths.manifest,
                 }, active: formActive, width: narrow ? columns : columns - sidebar, height: contentHeight, pickAddon: pickAddon, onSaved: () => {
                     reload();
                     notify(t('config saved'), 'ok');
@@ -542,7 +734,7 @@ export function Shell({ apps: initialApps, workspaceRoot, version, minimal = fal
                                             : t(' · shared .dev_properties.json at the root') })] })) : (_jsx(TabBar, { tab: tab, narrow: narrow, focused: focus === 'content' })), _jsx(Box, { flexDirection: "column", height: contentHeight, overflow: "hidden", alignItems: "flex-start", children: content })] })] }), _jsx(BottomBar, { hints: hints, right: right }), popover && (_jsx(Popover, { columns: columns, rows: frameRows, width: popoverWidth, height: popoverHeight, children: popover }))] }));
 }
 function renderOverlay(overlay, env) {
-    const { project, here, closeOverlay, run, notify, loadAddons, height, rerender, openWorkspace, } = env;
+    const { project, here, where, closeOverlay, run, notify, loadAddons, height, rerender, openWorkspace, } = env;
     switch (overlay.kind) {
         case 'palette':
             return (_jsx(CommandPalette, { project: project, onRun: run, onClose: closeOverlay, height: height }));
@@ -572,15 +764,23 @@ function renderOverlay(overlay, env) {
                     overlay.resolve(answer);
                 } }));
         case 'prompt':
-            return (_jsx(TextPrompt, { label: overlay.label, onSubmit: value => {
+            return (_jsx(TextPrompt, { label: overlay.label, initial: overlay.initial, validate: overlay.validate, advise: overlay.advise, error: overlay.error, onSubmit: value => {
                     closeOverlay();
                     overlay.resolve(value);
                 }, onCancel: () => {
                     closeOverlay();
                     overlay.resolve(null);
-                } }));
+                } }, overlay.label));
+        case 'choice':
+            return (_jsx(ChoicePrompt, { label: overlay.label, choices: overlay.choices, multi: overlay.multi, initial: overlay.initial, onSubmit: picked => {
+                    closeOverlay();
+                    overlay.resolve(picked);
+                }, onCancel: () => {
+                    closeOverlay();
+                    overlay.resolve(null);
+                } }, overlay.label));
         case 'help':
-            return _jsx(HelpPanel, { here: here, height: height, onClose: closeOverlay });
+            return (_jsx(HelpPanel, { here: here, where: where, height: height, onClose: closeOverlay }));
         case 'changelog':
             return (_jsx(ChangelogPanel, { since: overlay.since, height: height, onClose: closeOverlay }));
         case 'settings':
@@ -604,17 +804,54 @@ function Confirm({ message, onAnswer, }) {
     });
     return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { children: message }), _jsx(Text, { dimColor: true, children: t('y confirm · n cancel') })] }));
 }
-function TextPrompt({ label, onSubmit, onCancel, }) {
-    const [value, setValue] = useState('');
+function ChoicePrompt({ label, choices, multi, initial, onSubmit, onCancel, }) {
+    const [cursor, setCursor] = useState(multi ? 0 : (initial[0] ?? 0));
+    const [checked, setChecked] = useState(() => new Set(multi ? initial : []));
     useInput((input, key) => {
         if (key.escape)
             onCancel();
         else if (key.return)
-            onSubmit(value);
+            onSubmit(multi ? [...checked].toSorted((a, b) => a - b) : [cursor]);
+        else if (key.upArrow)
+            setCursor(c => (c - 1 + choices.length) % choices.length);
+        else if (key.downArrow)
+            setCursor(c => (c + 1) % choices.length);
+        else if (multi && input === ' ') {
+            setChecked(current => {
+                const next = new Set(current);
+                if (!next.delete(cursor))
+                    next.add(cursor);
+                return next;
+            });
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: label }), choices.map((choice, i) => (_jsxs(Text, { color: i === cursor ? ACCENT : undefined, bold: i === cursor, children: [i === cursor ? '▸ ' : '  ', multi ? (checked.has(i) ? '◉ ' : '◯ ') : '', choice] }, choice))), _jsx(Text, { dimColor: true, children: multi
+                    ? t('↑↓ move · Space toggle · Enter submit · Esc cancel')
+                    : t('↑↓ move · Enter select · Esc cancel') })] }));
+}
+function TextPrompt({ label, initial = '', validate, advise, error, onSubmit, onCancel, }) {
+    const [value, setValue] = useState(initial);
+    const [problem, setProblem] = useState(error);
+    // The value an advice was shown for; submitting it again keeps it.
+    const [advised, setAdvised] = useState();
+    const advice = advised === value ? advise?.(value) : undefined;
+    useInput((input, key) => {
+        if (key.escape)
+            onCancel();
+        else if (key.return) {
+            const invalid = validate?.(value);
+            setProblem(invalid);
+            if (invalid)
+                return;
+            if (advise?.(value) && advised !== value)
+                setAdvised(value);
+            else
+                onSubmit(value);
+        }
         else if (key.backspace || key.delete)
             setValue(v => v.slice(0, -1));
         else if (input && !key.ctrl && !key.meta)
             setValue(v => v + input);
     });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: label }), _jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: "\u276F " }), value, _jsx(Text, { inverse: true, children: " " })] }), _jsx(Text, { dimColor: true, children: t('Press Enter to submit, Esc to cancel') })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: label }), _jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: "\u276F " }), value, _jsx(Text, { inverse: true, children: " " })] }), problem && _jsxs(Text, { color: "red", children: ["\u2717 ", problem] }), !problem && advice && _jsx(Text, { color: "yellow", children: advice }), _jsx(Text, { dimColor: true, children: t('Press Enter to submit, Esc to cancel') })] }));
 }

package/dist/shell/actions.d.ts

@@ -22,6 +22,7 @@ export interface ActionContext {
     isProduction: boolean;
     cycleEnvironment: () => void;
     addEnvironment: () => Promise<void>;
+    createApp: () => Promise<void>;
     notify: (text: string, level?: 'info' | 'ok' | 'warn' | 'error') => void;
     quit: () => void;
 }

package/dist/utils/create-app.d.ts

@@ -0,0 +1,53 @@
+import { type Task } from './tasks.js';
+export declare const CREATE_COMMAND: string[];
+export interface PromptQuestion {
+    name: string;
+    type: string;
+    message: string;
+    choices: string[];
+    default?: unknown;
+    error?: string;
+}
+export type PromptReply = {
+    value: unknown;
+} | {
+    skip: true;
+};
+export type Ask = (question: PromptQuestion) => Promise<PromptReply | null>;
+/** A folder name that is also a usable package name and manifest id. */
+export declare const validAppName: (name: string) => boolean;
+/** The closest conventional name: "Min nya app!" and "MinNyaApp" become "min-nya-app". */
+export declare function suggestAppName(name: string): string;
+/** What is wrong with a typed app name, said so the fix is obvious. */
+export declare function appNameProblem(typed: string): string | undefined;
+/** A valid name that could be better; the user may keep it. */
+export declare function appNameAdvice(typed: string): string | undefined;
+export declare const isEmptyOrMissing: (dir: string) => boolean;
+/** Listen for the stub's questions. `null` from `ask` means the user cancelled. */
+export declare function servePrompts(ask: Ask, onCancel: () => void): Promise<{
+    socketPath: string;
+    connected: () => boolean;
+    close: () => void;
+}>;
+export type CreateOutcome = 'created' | 'unmanaged' | 'failed' | 'stopped';
+/**
+ * Run the scaffolder for `name` inside `parentDir`. "unmanaged" means it never
+ * asked svc anything and left no app: the prompt bridge did not take.
+ */
+export declare function startCreateApp(options: {
+    name: string;
+    parentDir: string;
+    ask: Ask;
+    command?: string[];
+}): {
+    task: Task;
+    done: Promise<CreateOutcome>;
+};
+/** Run the scaffolder on the real terminal; resolves when it exits. */
+export declare function createAppInTerminal(name: string, parentDir: string): Promise<boolean>;
+/**
+ * Replace the template's placeholders with what is known, and fold the config
+ * the tool wrote into svc's layout: no plaintext password, and nothing in the
+ * app's .dev_properties.json that the workspace already provides.
+ */
+export declare function seedNewApp(appDir: string, workspaceRoot?: string): void;

package/dist/utils/create-app.js

@@ -0,0 +1,219 @@
+/**
+ * New apps are scaffolded by Sitevision's own tool. svc runs it as a task and
+ * answers its questions through a socket (see source/scaffold); when the tool no
+ * longer asks through inquirer the run is reported as unmanaged, and the caller
+ * hands it the real terminal instead.
+ */
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { spawn } from 'node:child_process';
+import { stripVTControlCharacters } from 'node:util';
+import { t } from './i18n.js';
+import { ProcessRunner } from './process-runner.js';
+import { createTask, setPhase } from './tasks.js';
+import { detectProject, findDevPropertiesPath, migrateLegacyPassword, readInheritedDevProperties, readManifest, updatePackageJson, writeManifestField, } from './project-detection.js';
+export const CREATE_COMMAND = [
+    'npx',
+    '--yes',
+    '@sitevision/create-sitevision-app',
+];
+/** A folder name that is also a usable package name and manifest id. */
+export const validAppName = (name) => /^[\da-z][\w\-.]*$/i.test(name);
+/** The closest conventional name: "Min nya app!" and "MinNyaApp" become "min-nya-app". */
+export function suggestAppName(name) {
+    return name
+        .trim()
+        .normalize('NFKD')
+        .replaceAll(/[\u0300-\u036F]/g, '')
+        .replaceAll(/(?<=[\da-z])(?=[A-Z])/g, '-')
+        .toLowerCase()
+        .replaceAll(/\s+/g, '-')
+        .replaceAll(/[^\w\-.]/g, '')
+        .replace(/^[^\da-z]+/i, '');
+}
+/** What is wrong with a typed app name, said so the fix is obvious. */
+export function appNameProblem(typed) {
+    const name = typed.trim();
+    if (!name)
+        return t('Type a name for the app, for example my-new-app.');
+    if (validAppName(name))
+        return undefined;
+    const suggestion = suggestAppName(name);
+    const tryThis = suggestion
+        ? ' ' + t('Try "{suggestion}".', { suggestion })
+        : '';
+    if (/\s/.test(name) && validAppName(name.replaceAll(/\s+/g, '-')))
+        return t("An app name can't have spaces.") + tryThis;
+    const bad = [...new Set(name.replaceAll(/[\s\w\-.]/g, ''))].join(' ');
+    if (bad) {
+        return (t("An app name can't contain {chars}: it becomes the folder, the package name and the app id.", {
+            chars: bad,
+        }) + tryThis);
+    }
+    return t('Start the name with a letter or a digit.') + tryThis;
+}
+/** A valid name that could be better; the user may keep it. */
+export function appNameAdvice(typed) {
+    const name = typed.trim();
+    if (!validAppName(name) || name === name.toLowerCase())
+        return undefined;
+    return t('Lowercase is safer: npm expects it, and "{name}" and "{lower}" are one folder on macOS and Windows but two on Linux. Try "{suggestion}", or press Enter again to keep "{name}".', { name, lower: name.toLowerCase(), suggestion: suggestAppName(name) });
+}
+export const isEmptyOrMissing = (dir) => !fs.existsSync(dir) || fs.readdirSync(dir).length === 0;
+/** Listen for the stub's questions. `null` from `ask` means the user cancelled. */
+export async function servePrompts(ask, onCancel) {
+    const id = `svc-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+    const socketPath = process.platform === 'win32'
+        ? `\\\\.\\pipe\\${id}`
+        : path.join(os.tmpdir(), `${id}.sock`);
+    let connected = false;
+    const server = net.createServer(socket => {
+        connected = true;
+        socket.on('error', () => { });
+        void (async () => {
+            for await (const line of readline.createInterface({ input: socket })) {
+                const reply = await ask(JSON.parse(line));
+                if (!reply) {
+                    socket.destroy();
+                    onCancel();
+                    return;
+                }
+                socket.write(JSON.stringify(reply) + '\n');
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(socketPath, resolve);
+    });
+    return {
+        socketPath,
+        connected: () => connected,
+        close: () => server.close(),
+    };
+}
+/**
+ * Run the scaffolder for `name` inside `parentDir`. "unmanaged" means it never
+ * asked svc anything and left no app: the prompt bridge did not take.
+ */
+export function startCreateApp(options) {
+    const { name, parentDir, ask, command = CREATE_COMMAND } = options;
+    const appDir = path.join(parentDir, name);
+    let runner;
+    let stopped = false;
+    const { task, log, finish } = createTask('create', { root: appDir, manifest: { name, id: name } }, 'create-sitevision-app', () => {
+        stopped = true;
+        runner?.kill();
+        finish('stopped');
+    });
+    const done = (async () => {
+        const prompts = await servePrompts(ask, () => task.stop());
+        try {
+            // .js from dist, .ts when svc itself runs from source.
+            const register = new URL(`../scaffold/register${path.extname(import.meta.url)}`, import.meta.url).href;
+            runner = new ProcessRunner(command[0], [...command.slice(1), name], parentDir, {
+                ...process.env,
+                NODE_OPTIONS: `${process.env['NODE_OPTIONS'] ?? ''} --import=${register}`.trim(),
+                SVC_PROMPT_SOCKET: prompts.socketPath,
+            });
+            runner.on('output', (output) => {
+                // The tool clears the screen between steps; that is noise in a log.
+                const text = stripVTControlCharacters(output.data);
+                if (text.trim())
+                    log('create', text, output.type === 'stderr' ? 'warn' : 'info');
+            });
+            setPhase(task, 'scaffolding');
+            await runner.run();
+            if (stopped)
+                return 'stopped';
+            // The exit code is 0 even when the prompts crash, so look at the result.
+            if (readManifest(appDir)) {
+                finish('success');
+                return 'created';
+            }
+            if (prompts.connected()) {
+                finish('error', 'The scaffolder finished without creating an app');
+                return 'failed';
+            }
+            finish('stopped');
+            return 'unmanaged';
+        }
+        catch (error) {
+            finish('error', error instanceof Error ? error.message : String(error));
+            return 'failed';
+        }
+        finally {
+            prompts.close();
+        }
+    })();
+    return { task, done };
+}
+/** Run the scaffolder on the real terminal; resolves when it exits. */
+export async function createAppInTerminal(name, parentDir) {
+    await new Promise(resolve => {
+        const child = spawn(CREATE_COMMAND[0], [...CREATE_COMMAND.slice(1), name], {
+            cwd: parentDir,
+            stdio: 'inherit',
+            shell: true,
+        });
+        child.on('close', () => resolve());
+        child.on('error', () => resolve());
+    });
+    return Boolean(readManifest(path.join(parentDir, name)));
+}
+/**
+ * Replace the template's placeholders with what is known, and fold the config
+ * the tool wrote into svc's layout: no plaintext password, and nothing in the
+ * app's .dev_properties.json that the workspace already provides.
+ */
+export function seedNewApp(appDir, workspaceRoot) {
+    const found = readManifest(appDir);
+    if (!found)
+        return;
+    const { manifest, manifestPath } = found;
+    const seed = (key, value) => {
+        const localized = typeof manifest[key] === 'object';
+        writeManifestField(manifestPath, key, value, localized ? 'en' : undefined);
+    };
+    seed('name', path.basename(appDir));
+    if (workspaceRoot) {
+        let shared = {};
+        try {
+            shared = JSON.parse(fs.readFileSync(path.join(workspaceRoot, 'package.json'), 'utf8'));
+        }
+        catch { }
+        const author = typeof shared['author'] === 'object'
+            ? shared['author']?.name
+            : shared['author'];
+        if (typeof author === 'string' && author)
+            writeManifestField(manifestPath, 'author', author);
+        if (typeof shared['homepage'] === 'string' && shared['homepage'])
+            writeManifestField(manifestPath, 'helpUrl', shared['homepage']);
+    }
+    const project = detectProject(appDir);
+    if (project)
+        migrateLegacyPassword(project);
+    const file = findDevPropertiesPath(appDir);
+    if (!workspaceRoot || !file)
+        return;
+    const own = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const inherited = readInheritedDevProperties(appDir);
+    if (typeof own['addonName'] === 'string' && own['addonName']) {
+        const addonName = own['addonName'];
+        updatePackageJson(appDir, packageJson => {
+            packageJson['addonName'] = addonName;
+        });
+    }
+    const rest = Object.fromEntries(Object.entries(own).filter(([key, value]) => key !== 'addonName' &&
+        value !== '' &&
+        value !== undefined &&
+        !(key === 'useHTTPForDevDeploy' && value === false) &&
+        JSON.stringify(value) !== JSON.stringify(inherited[key])));
+    if (Object.keys(rest).length === 0)
+        fs.rmSync(file);
+    else
+        fs.writeFileSync(file, JSON.stringify(rest, null, 2) + '\n');
+}