sitevision-cli 1.0.0-beta.31 → 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
@@ -532,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');
@@ -574,13 +764,21 @@ 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, where: where, height: height, onClose: closeOverlay }));
         case 'changelog':
@@ -606,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');
+}

package/dist/utils/i18n.js

@@ -202,6 +202,38 @@ const sv = {
     'required for signed deploys': 'krävs för signerad driftsättning',
     'blank = prompt each run': 'tomt = fråga varje gång',
     SIGNING: 'SIGNERING',
+    MANIFEST: 'MANIFEST',
+    // New app
+    'Name of the new app': 'Namn på den nya appen',
+    'Create it in folder': 'Skapa den i mappen',
+    'Other folder…': 'Annan mapp…',
+    'Type a name for the app, for example my-new-app.': 'Skriv ett namn på appen, till exempel min-nya-app.',
+    'Try "{suggestion}".': 'Prova "{suggestion}".',
+    "An app name can't have spaces.": 'Ett appnamn kan inte innehålla mellanslag.',
+    "An app name can't contain {chars}: it becomes the folder, the package name and the app id.": 'Ett appnamn kan inte innehålla {chars}: det blir mappen, paketnamnet och appens id.',
+    '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}".': 'Gemener är säkrare: npm förväntar sig det, och "{name}" och "{lower}" är samma mapp på macOS och Windows men två på Linux. Prova "{suggestion}", eller tryck Enter igen för att behålla "{name}".',
+    'Start the name with a letter or a digit.': 'Börja namnet med en bokstav eller en siffra.',
+    '{dir} already exists. Pick another name, or keep it and choose a different folder next.': '{dir} finns redan. Välj ett annat namn, eller behåll det och välj en annan mapp i nästa steg.',
+    'creating {app}: installing, questions follow': 'skapar {app}: installerar, frågor kommer strax',
+    'The scaffolder could not be run from here': 'Verktyget kunde inte köras härifrån',
+    'creating {app} failed, see the log': 'kunde inte skapa {app}, se loggen',
+    '{app} created in {dir}': '{app} skapad i {dir}',
+    '{app} created': '{app} skapad',
+    'Create the addon "{addon}" on {domain} now?': 'Skapa tillägget "{addon}" på {domain} nu?',
+    '↑↓ move · Space toggle · Enter submit · Esc cancel': '↑↓ flytta · Mellanslag markera · Enter skicka · Esc avbryt',
+    'App id': 'App-id',
+    Version: 'Version',
+    Name: 'Namn',
+    Description: 'Beskrivning',
+    Author: 'Författare',
+    'Help URL': 'Hjälp-URL',
+    'Not saved: {label} is required.': 'Inte sparat: {label} krävs.',
+    'Identifier of the app in Sitevision; it also names the zip. Changing it makes the next deploy a new app instead of an update.': 'Appens identifierare i Sitevision; den namnger också zip-filen. Ändras den blir nästa driftsättning en ny app i stället för en uppdatering.',
+    'Version of the app. Id and version together identify an upload, so bump it to deploy a new version instead of overwriting the current one.': 'Appens version. Id och version identifierar tillsammans en uppladdning, så höj den för att driftsätta en ny version i stället för att skriva över den nuvarande.',
+    'Name shown when importing and administering the app in the Sitevision editor. A multilingual manifest needs at least English.': 'Namnet som visas när appen importeras och administreras i Sitevisions redigerare. Ett flerspråkigt manifest behöver minst engelska.',
+    'Short description shown next to the name in the Sitevision editor.': 'Kort beskrivning som visas bredvid namnet i Sitevisions redigerare.',
+    'Who made the app, shown in the Sitevision editor.': 'Vem som gjort appen, visas i Sitevisions redigerare.',
+    "Link to the app's documentation, shown in the Sitevision editor.": 'Länk till appens dokumentation, visas i Sitevisions redigerare.',
     ENVIRONMENT: 'MILJÖ',
     'Environment name': 'Miljönamn',
     Production: 'Produktion',