sitevision-cli 1.0.0-beta.9 → 1.0.1

package/dist/utils/create-app.js

@@ -0,0 +1,231 @@
+/**
+ * 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';
+import { debug } from './debug.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 => {
+        // `name` is validated by the caller; joined to avoid DEP0190.
+        debug('spawn', `${CREATE_COMMAND.join(' ')} ${name} (cwd ${parentDir})`);
+        const child = spawn([...CREATE_COMMAND, name].join(' '), {
+            cwd: parentDir,
+            stdio: 'inherit',
+            shell: true,
+        });
+        child.on('close', code => {
+            debug('spawn', `create-sitevision-app exited ${code}`);
+            resolve();
+        });
+        child.on('error', () => resolve());
+    });
+    try {
+        return Boolean(readManifest(path.join(parentDir, name)));
+    }
+    catch {
+        // A half-written manifest is a failed scaffold, not a crash.
+        return false;
+    }
+}
+/**
+ * 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/debug.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { stripVTControlCharacters } from 'node:util';
+let logFile;
+/** Start the debug log (one file per run) in the given directory. */
+export function enableDebug(dir) {
+    if (logFile)
+        return logFile;
+    fs.mkdirSync(dir, { recursive: true });
+    logFile = path.join(dir, 'debug.log');
+    fs.writeFileSync(logFile, '');
+    return logFile;
+}
+export const debugFile = () => logFile;
+/** Append one line; a multi-line message is indented under the first line. */
+export function debug(scope, message) {
+    if (!logFile)
+        return;
+    const text = message.split('\n').join('\n' + ' '.repeat(34));
+    try {
+        fs.appendFileSync(logFile, `${new Date().toISOString()} ${scope.padEnd(8)} ${text}\n`);
+    }
+    catch {
+        // NOOP: A full or read-only disk must not take the CLI down.
+    }
+}
+/** Print a message for the user and keep a copy in the debug log. */
+export function say(text) {
+    debug('out', stripVTControlCharacters(text).trim());
+    console.log(text);
+}
+export const errorText = (error) => error instanceof Error ? (error.stack ?? error.message) : String(error);

package/dist/utils/environments.js

@@ -0,0 +1,74 @@
+import { resolveRuntimeSecrets } from './project-detection.js';
+/** Name of the environment the top-level dev properties describe. */
+export function baseEnvironment(dev) {
+    return dev?.baseEnvironment?.trim() || 'dev';
+}
+export function environmentNames(dev) {
+    const base = baseEnvironment(dev);
+    return [
+        base,
+        ...Object.keys(dev?.environments ?? {}).filter(name => name !== base),
+    ];
+}
+export function isProductionEnvironment(name, dev) {
+    if (name === baseEnvironment(dev))
+        return dev?.production ?? false;
+    return dev?.environments?.[name]?.production ?? /prod/i.test(name);
+}
+/** Badge colour: dev green, production red, anything else yellow. */
+export function environmentColor(name, dev) {
+    if (isProductionEnvironment(name, dev))
+        return 'red';
+    return name === baseEnvironment(dev) ? 'green' : 'yellow';
+}
+/**
+ * The effective dev properties for one environment: the base with that
+ * environment's overrides applied and credentials resolved for its
+ * domain/username. The base ("dev") is returned as-is.
+ */
+export function resolveEnvironment(dev, name) {
+    const production = isProductionEnvironment(name, dev);
+    if (name === baseEnvironment(dev)) {
+        return { ...dev, environmentName: name, productionEnvironment: production };
+    }
+    const override = dev.environments?.[name] ?? {};
+    const { production: _production, ...fields } = override;
+    const resolved = {
+        ...dev,
+        ...fields,
+        password: undefined,
+        accessToken: undefined,
+        sessionCookie: undefined,
+        environmentName: name,
+        productionEnvironment: production,
+    };
+    return resolveRuntimeSecrets(resolved);
+}
+/** A project view whose dev properties are resolved for `name`. */
+export function environmentProject(project, name) {
+    if (!project.devProperties)
+        return project;
+    return {
+        ...project,
+        devProperties: resolveEnvironment(project.devProperties, name),
+    };
+}
+/**
+ * Write one environment's override into the base: keep only the keys whose
+ * value differs from the base, so the file stays minimal.
+ */
+export function withEnvironmentOverride(base, name, values) {
+    const current = { ...base.environments?.[name] };
+    const changed = Object.fromEntries(Object.entries(values).map(([key, value]) => {
+        const baseValue = base[key];
+        const same = value === undefined ||
+            value === '' ||
+            JSON.stringify(value) === JSON.stringify(baseValue);
+        return [key, same ? undefined : value];
+    }));
+    const override = Object.fromEntries(Object.entries({ ...current, ...changed }).filter(([, value]) => value !== undefined));
+    return {
+        ...base,
+        environments: { ...base.environments, [name]: override },
+    };
+}