sitevision-cli 1.0.0-beta.9 → 1.0.0

package/dist/shell/Tabs.js

@@ -0,0 +1,96 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { appTypeOf, getPackageJsonSyncChanges, readAncestorDevProperties, localizedText, } from '../utils/project-detection.js';
+import { checkSitevisionScriptsCompatibility } from '../utils/sitevision-scripts-runner.js';
+import { ACCENT, elapsed } from './Frame.js';
+import { t } from '../utils/i18n.js';
+import { getGlobalSigning } from '../utils/config.js';
+export const TABS = [
+    { id: 'overview', label: 'Overview', short: 'Ovw' },
+    { id: 'config', label: 'Config', short: 'Cfg' },
+    { id: 'versions', label: 'Versions', short: 'Ver' },
+    { id: 'log', label: 'Log', short: 'Log' },
+];
+export function TabBar({ tab, narrow, focused, }) {
+    return (_jsx(Box, { paddingX: 1, children: TABS.map((entry, i) => (_jsxs(Text, { children: [_jsxs(Text, { bold: entry.id === tab, color: entry.id === tab ? ACCENT : undefined, dimColor: entry.id !== tab, underline: entry.id === tab && focused, children: [focused && `${i + 1} `, t(narrow ? entry.short : entry.label)] }), ' '.repeat(3)] }, entry.id))) }));
+}
+function Row({ label, value, dim, }) {
+    return (_jsx(Box, { height: 1, flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { dimColor: true, children: label.padEnd(14) }), value, dim && _jsxs(Text, { dimColor: true, children: [" ", dim] })] }) }));
+}
+const LEVEL_COLOR = {
+    info: undefined,
+    ok: 'green',
+    warn: 'yellow',
+    error: 'red',
+};
+const STATUS_GLYPH = {
+    running: _jsx(Spinner, { type: "dots" }),
+    success: _jsx(Text, { color: "green", children: "\u2713" }),
+    error: _jsx(Text, { color: "red", children: "\u2717" }),
+    stopped: _jsx(Text, { dimColor: true, children: "\u25A0" }),
+};
+function time(ms, seconds = false) {
+    const d = new Date(ms);
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return seconds ? `${hh}:${mm}:${ss}` : `${hh}:${mm}`;
+}
+export function Overview({ project, tasks, height, }) {
+    const dev = project.devProperties;
+    const inherited = new Set(project.inheritedKeys);
+    const ancestors = readAncestorDevProperties(project.root);
+    const globalSigning = getGlobalSigning();
+    const src = (key) => inherited.has(key)
+        ? Object.hasOwn(ancestors, key)
+            ? t('↑ root')
+            : 'package.json'
+        : globalSigning[key] !== undefined &&
+            globalSigning[key] ===
+                dev?.[key]
+            ? t('global')
+            : undefined;
+    const notSet = t('not set');
+    const sync = getPackageJsonSyncChanges(project.root).length;
+    const scripts = checkSitevisionScriptsCompatibility(project.root);
+    const recent = tasks
+        .filter(task => task.appRoot === project.root && task.status !== 'running')
+        .slice(-Math.max(1, height - 18))
+        .toReversed();
+    const status = (ok, okText, badText, warn = false) => (_jsxs(Text, { children: [_jsx(Text, { color: ok ? 'green' : warn ? 'yellow' : 'red', children: ok ? '✓' : warn ? '~' : '✗' }), ' ', ok ? okText : badText] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsx(Box, { height: 1, flexShrink: 0, children: _jsxs(Text, { bold: true, wrap: "truncate", children: [localizedText(project.manifest.name) || project.manifest.id, ' ', _jsxs(Text, { dimColor: true, children: [project.manifest.type, project.manifest.bundled ? t(' · bundled') : ''] })] }) }), _jsx(Row, { label: t('id'), value: project.manifest.id }), _jsx(Row, { label: t('version'), value: project.manifest.version }), _jsx(Row, { label: t('type'), value: `${project.manifest.type} (${appTypeOf(project.manifest) ?? '?'})` }), _jsx(Row, { label: t('addon'), value: dev?.addonName ?? notSet, dim: src('addonName') }), _jsx(Row, { label: t('site'), value: dev?.siteName ?? notSet, dim: src('siteName') }), _jsx(Row, { label: t('environment'), value: dev?.environmentName ?? 'dev', dim: dev?.productionEnvironment ? t('production') : undefined }), _jsx(Row, { label: t('domain'), value: dev?.domain ?? notSet, dim: src('domain') }), _jsx(Row, { label: t('auth'), value: dev?.authMethod ?? (dev ? 'basic' : notSet), dim: src('authMethod') }), _jsx(Row, { label: t('signing user'), value: dev?.signingUsername ?? notSet, dim: src('signingUsername') }), _jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { dimColor: true, children: [t('deps').padEnd(10), status(project.hasNodeModules, 'node_modules', t('missing · i to install'))] }), _jsxs(Text, { dimColor: true, children: [t('config').padEnd(10), status(Boolean(dev), t('dev properties'), t('missing · e to edit'))] }), _jsxs(Text, { dimColor: true, children: [t('sync').padEnd(10), status(sync === 0, 'package.json', sync === 1
+                                ? t('1 diff · y to apply')
+                                : t('{n} diffs · y to apply', { n: sync }), true)] }), _jsxs(Text, { dimColor: true, children: [t('signing').padEnd(10), status(project.hasSigningProperties, dev?.signingUsername ?? '', t('missing · / set up signing'))] }), _jsxs(Text, { dimColor: true, children: [t('scripts').padEnd(10), status(scripts.status === 'ok', scripts.installed ?? '', scripts.installed
+                                ? `${scripts.installed} · ${scripts.status}`
+                                : t('not installed · i to install'), scripts.status !== 'not-installed')] }), project.hasLegacyPassword && (_jsxs(Text, { color: "yellow", children: [' '.repeat(10), t('⚠ plaintext password in .dev_properties.json · / migrate')] }))] }), recent.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, dimColor: true, children: t('RECENT') }), recent.map(task => (_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { dimColor: true, children: [time(task.endedAt ?? task.startedAt), " "] }), STATUS_GLYPH[task.status], " ", task.label, ' ', _jsx(Text, { dimColor: true, children: task.error ?? elapsed(task) })] }, task.id)))] }))] }));
+}
+export function Versions({ project, state, selected, }) {
+    if (!project.devProperties) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "yellow", children: t('⚠ Configure dev properties first (e).') }) }));
+    }
+    if (!state) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: t('Press r to fetch versions from {domain}.', {
+                    domain: project.devProperties.domain,
+                }) }) }));
+    }
+    const list = state.executables ?? [];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsxs(Text, { dimColor: true, children: [t('APP IDENTIFIER').padEnd(30), t('VERSION').padEnd(12), t('ACTIVE'), state.loading && (_jsxs(Text, { color: ACCENT, children: [' '.repeat(3), _jsx(Spinner, { type: "dots" })] }))] }), state.error && _jsx(Text, { color: "red", children: state.error }), list.map((e, i) => (_jsxs(Text, { backgroundColor: i === selected ? ACCENT : undefined, color: i === selected ? 'black' : undefined, wrap: "truncate", children: [e.appIdentifier.padEnd(30).slice(0, 30), e.appVersion.padEnd(12), e.active ? '●' : '○', i === selected ? ` ${e.id}` : ''] }, e.id))), !state.loading && !state.error && list.length === 0 && (_jsx(Text, { dimColor: true, children: t('No versions uploaded to {addon}.', {
+                    addon: project.devProperties.addonName,
+                }) })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [list.length === 1
+                            ? t('1 version · a activate selected · r refresh')
+                            : t('{n} versions · a activate selected · r refresh', {
+                                n: list.length,
+                            }), state.fetchedAt
+                            ? t(' · fetched {time}', { time: time(state.fetchedAt) })
+                            : ''] }) })] }));
+}
+export function Log({ task, height, scroll, wrap, }) {
+    if (!task) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: t('No task yet. d dev · w watch · b build · s sign · p deploy') }) }));
+    }
+    const visible = Math.max(1, height - 2);
+    const end = Math.max(0, task.lines.length - scroll);
+    const lines = task.lines.slice(Math.max(0, end - visible), end);
+    return (_jsxs(Box, { width: "100%", flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsxs(Text, { children: [STATUS_GLYPH[task.status], " ", task.label, " ", task.appName, ' ', _jsxs(Text, { dimColor: true, children: [task.phase, " \u00B7 ", elapsed(task), scroll > 0 ? ` · ↑${scroll}` : t(' · following')] })] }), _jsx(Box, { flexDirection: "column", maxHeight: visible, justifyContent: "flex-end", overflow: "hidden", children: lines.map((line, i) => (_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: wrap ? 'wrap' : 'truncate', color: LEVEL_COLOR[line.level], children: [_jsxs(Text, { dimColor: true, children: [time(line.time, true), " ", line.tag.padEnd(3)] }), ' ', line.text] }) }, i))) }, wrap ? 'wrap' : 'truncate')] }));
+}

package/dist/shell/actions.js

@@ -0,0 +1,493 @@
+import { getPackageJsonSyncChanges, syncDevPropertiesToPackageJson, migrateLegacyPassword, getAppType, } from '../utils/project-detection.js';
+import { createAddon } from '../utils/sitevision-api.js';
+import { getSigningPassword, setSigningPassword, setDeployPassword, deleteDeployPassword, deleteOAuth2RefreshToken, deleteSessionCookie, getOAuth2RefreshToken, } from '../utils/keychain.js';
+import { resolveOAuth2AccessToken } from '../utils/oauth2-auth.js';
+import { t } from '../utils/i18n.js';
+import { toDeployConfig } from '../utils/workspace.js';
+import { startBuild, startDev, startDeploy, startInstall, startSign, runningTasks, stoppableTasks, } from '../utils/tasks.js';
+// Credentials obtained during this run, so a password or token is asked for
+// once per app rather than once per action. Never written to disk here.
+const session = {
+    deployPassword: new Map(),
+    signingPassword: new Map(),
+    credential: new Map(),
+    // Addons a deploy confirmed missing; only these offer "Create addon".
+    missingAddons: new Set(),
+};
+const deployKey = (p) => `${p.devProperties?.domain}\0${p.devProperties?.username}`;
+const addonKey = (p) => `${p.devProperties?.domain} ${p.devProperties?.siteName} ${p.devProperties?.addonName}`;
+const askCreateAddon = (ctx) => async (addon) => {
+    session.missingAddons.add(addonKey(ctx.project));
+    const yes = await ctx.confirm(t('Addon {addon} does not exist on {domain}. Create it and deploy again?', {
+        addon,
+        domain: ctx.project.devProperties?.domain ?? '',
+    }));
+    if (yes)
+        session.missingAddons.delete(addonKey(ctx.project));
+    return yes;
+};
+export function forgetSession(project) {
+    session.deployPassword.delete(deployKey(project));
+    session.credential.delete(deployKey(project));
+    if (project.devProperties?.signingUsername) {
+        session.signingPassword.delete(project.devProperties.signingUsername);
+    }
+}
+/** Top-bar auth state without prompting for anything. */
+export function authState(project) {
+    const dev = project.devProperties;
+    if (!dev)
+        return { ready: false, label: t('not configured') };
+    const method = dev.authMethod ?? 'basic';
+    const key = deployKey(project);
+    const who = dev.username ? ` ${dev.username}` : '';
+    if (method === 'basic') {
+        const ready = Boolean(dev.password || session.deployPassword.has(key));
+        return { ready, label: ready ? `basic${who}` : t('basic · password needed') };
+    }
+    if (method === 'oauth2') {
+        const ready = Boolean(dev.accessToken ||
+            session.credential.get(key)?.accessToken ||
+            (dev.oauth2?.clientId &&
+                getOAuth2RefreshToken(dev.domain, dev.oauth2.clientId)));
+        return { ready, label: ready ? `oauth2${who}` : t('oauth2 · not logged in') };
+    }
+    const ready = Boolean(dev.sessionCookie || session.credential.get(key)?.sessionCookie);
+    return { ready, label: ready ? `sso${who}` : t('sso · not logged in') };
+}
+export async function resolveDeployConfig(ctx, fresh = false, 
+// Site-level calls (list addons, log in) work before an addon is chosen.
+{ addon = true } = {}) {
+    const dev = ctx.project.devProperties;
+    const complete = toDeployConfig(dev, { addon });
+    if (!dev || 'error' in complete) {
+        ctx.notify(dev && 'error' in complete
+            ? complete.error
+            : t('Dev properties not configured. Edit config first.'), 'warn');
+        ctx.setTab('config');
+        return null;
+    }
+    const key = deployKey(ctx.project);
+    // Credentials are resolved below, per auth method.
+    const base = {
+        ...complete.config,
+        password: undefined,
+        accessToken: undefined,
+        sessionCookie: undefined,
+    };
+    const method = dev.authMethod ?? 'basic';
+    if (method === 'basic') {
+        let password = fresh
+            ? undefined
+            : (dev.password ?? session.deployPassword.get(key));
+        if (!password) {
+            const answer = await ctx.askPassword(t('Deploy password for {user}@{domain}', {
+                user: dev.username,
+                domain: dev.domain,
+            }), t('Save to OS keychain'));
+            if (!answer?.password)
+                return null;
+            password = answer.password;
+            session.deployPassword.set(key, password);
+            if (answer.remember)
+                setDeployPassword(dev.domain, dev.username, password);
+        }
+        return { ...base, password };
+    }
+    let credential = fresh ? undefined : session.credential.get(key);
+    if (!credential && !fresh) {
+        if (method === 'cookie' && dev.sessionCookie) {
+            credential = { sessionCookie: dev.sessionCookie };
+        }
+        else if (method === 'oauth2') {
+            const token = dev.accessToken ?? (await resolveOAuth2AccessToken(dev));
+            if (token)
+                credential = { accessToken: token };
+        }
+    }
+    credential ??= (await ctx.login(method)) ?? undefined;
+    if (!credential)
+        return null;
+    session.credential.set(key, credential);
+    return { ...base, ...credential };
+}
+async function resolveSigning(ctx) {
+    const dev = ctx.project.devProperties;
+    if (!dev?.signingUsername) {
+        ctx.notify(t('Signing credentials not configured.'), 'warn');
+        ctx.setTab('config');
+        return null;
+    }
+    const username = dev.signingUsername;
+    let password = process.env['SITEVISION_SIGNING_PASSWORD'] ??
+        session.signingPassword.get(username) ??
+        getSigningPassword(username) ??
+        undefined;
+    if (!password) {
+        const answer = await ctx.askPassword(t('Signing password for {user} (developer.sitevision.se)', {
+            user: username,
+        }), t('Save to OS keychain'));
+        if (!answer?.password)
+            return null;
+        password = answer.password;
+        if (answer.remember)
+            setSigningPassword(username, password);
+    }
+    session.signingPassword.set(username, password);
+    return { username, password, certificateName: dev.certificateName };
+}
+const hasDev = (p) => Boolean(p.devProperties);
+const deployDetail = (p) => {
+    const dev = p.devProperties;
+    const env = t('to {env}', { env: dev?.environmentName ?? 'dev' });
+    return dev?.productionEnvironment
+        ? `${env} · ${t('signed zip · confirms first')}`
+        : env;
+};
+/** Deploy to the active environment; production means signed + activate. */
+async function deployTo(ctx, force) {
+    if (ctx.isProduction &&
+        !(await ctx.confirm(t('Deploy the signed {id} to {env} (addon {addon}) and activate it?', {
+            id: ctx.project.manifest.id,
+            env: ctx.environment,
+            addon: ctx.project.devProperties?.addonName ?? '?',
+        })))) {
+        return;
+    }
+    const config = await resolveDeployConfig(ctx);
+    if (!config)
+        return;
+    startDeploy(ctx.project, config, {
+        ...(ctx.isProduction ? { production: true, activate: true } : { force }),
+        onAddonMissing: askCreateAddon(ctx),
+    });
+    ctx.setTab('log');
+}
+const hasSigning = (p) => Boolean(p.devProperties?.signingUsername);
+async function startDevOrWatch(ctx, deploy) {
+    if (deploy && ctx.isProduction) {
+        ctx.notify(t('Dev never deploys to a production environment ({env}). Switch with v.', {
+            env: ctx.environment,
+        }), 'warn');
+        return;
+    }
+    if (runningTasks(ctx.project.root).some(task => task.kind === 'dev' || task.kind === 'watch')) {
+        ctx.notify(t('A dev/watch task is already running for this app (K stops it).'), 'warn');
+        ctx.setTab('log');
+        return;
+    }
+    const signingCredentials = hasSigning(ctx.project)
+        ? ((await resolveSigning(ctx)) ?? undefined)
+        : undefined;
+    if (hasSigning(ctx.project) && !signingCredentials)
+        return;
+    const deployConfig = deploy ? await resolveDeployConfig(ctx) : undefined;
+    if (deploy && !deployConfig)
+        return;
+    startDev(ctx.project, {
+        deploy,
+        signingCredentials,
+        deployConfig: deployConfig ?? undefined,
+        onAddonMissing: askCreateAddon(ctx),
+    });
+    ctx.setTab('log');
+}
+export const actions = [
+    {
+        id: 'dev',
+        key: 'd',
+        group: 'app',
+        label: 'Dev',
+        detail: p => hasSigning(p)
+            ? t('build, sign and deploy on change')
+            : t('build and deploy on change'),
+        enabled: hasDev,
+        async run(ctx) {
+            await startDevOrWatch(ctx, true);
+        },
+    },
+    {
+        id: 'watch',
+        key: 'w',
+        group: 'app',
+        label: 'Watch',
+        detail: p => hasSigning(p) ? t('rebuild and sign only') : t('rebuild only'),
+        async run(ctx) {
+            await startDevOrWatch(ctx, false);
+        },
+    },
+    {
+        id: 'build',
+        key: 'b',
+        group: 'app',
+        label: 'Build',
+        async run(ctx) {
+            startBuild(ctx.project);
+            ctx.setTab('log');
+        },
+    },
+    {
+        id: 'sign',
+        key: 's',
+        group: 'app',
+        label: 'Sign',
+        detail: p => (hasSigning(p) ? undefined : t('credentials missing')),
+        async run(ctx) {
+            const credentials = await resolveSigning(ctx);
+            if (!credentials)
+                return;
+            startSign(ctx.project, credentials);
+            ctx.setTab('log');
+        },
+    },
+    {
+        id: 'deploy',
+        key: 'p',
+        group: 'app',
+        label: 'Deploy',
+        detail: deployDetail,
+        enabled: hasDev,
+        async run(ctx) {
+            await deployTo(ctx, false);
+        },
+    },
+    {
+        id: 'deploy-force',
+        key: 'P',
+        group: 'app',
+        label: 'Deploy (force)',
+        detail: deployDetail,
+        enabled: hasDev,
+        async run(ctx) {
+            await deployTo(ctx, true);
+        },
+    },
+    {
+        id: 'environment',
+        key: 'v',
+        group: 'app',
+        label: 'Switch environment',
+        detail: p => p.devProperties?.environmentName ?? 'dev',
+        enabled: hasDev,
+        async run(ctx) {
+            ctx.cycleEnvironment();
+        },
+    },
+    {
+        id: 'add-environment',
+        group: 'setup',
+        label: 'Add environment',
+        detail: () => t('e.g. test or prod, overriding domain and auth'),
+        enabled: hasDev,
+        async run(ctx) {
+            await ctx.addEnvironment();
+        },
+    },
+    {
+        id: 'versions',
+        key: 'a',
+        group: 'app',
+        label: 'Activate a remote version',
+        enabled: hasDev,
+        async run(ctx) {
+            ctx.setTab('versions');
+        },
+    },
+    {
+        id: 'stop',
+        key: 'K',
+        group: 'app',
+        label: 'Stop running task',
+        enabled: p => stoppableTasks(p.root).length > 0,
+        async run(ctx) {
+            const running = stoppableTasks(ctx.project.root);
+            for (const task of running)
+                task.stop();
+            ctx.notify(running.length > 0
+                ? t('stopped {n} task(s)', { n: running.length })
+                : t('nothing running'));
+        },
+    },
+    {
+        id: 'workspace-settings',
+        group: 'setup',
+        label: 'Workspace settings',
+        detail: () => t('shared auth and site config for every app'),
+        async run(ctx) {
+            if (ctx.openWorkspaceSettings)
+                ctx.openWorkspaceSettings();
+            else
+                ctx.notify(t('Not in a workspace: run svc at the repo root.'), 'warn');
+        },
+    },
+    {
+        id: 'help',
+        key: '?',
+        group: 'setup',
+        label: 'Help',
+        detail: () => t('every key in one place'),
+        async run(ctx) {
+            ctx.openHelp();
+        },
+    },
+    {
+        id: 'changelog',
+        group: 'setup',
+        label: "What's new",
+        detail: () => t('changelog for every release'),
+        async run(ctx) {
+            ctx.openChangelog();
+        },
+    },
+    {
+        id: 'settings',
+        key: ',',
+        group: 'setup',
+        label: 'Settings',
+        detail: () => t('language, intro animation, workspace config'),
+        async run(ctx) {
+            ctx.openSettings();
+        },
+    },
+    {
+        id: 'config',
+        key: 'e',
+        group: 'setup',
+        label: 'Edit config',
+        detail: () => t('dev properties, auth method, signing'),
+        async run(ctx) {
+            ctx.setTab('config');
+        },
+    },
+    {
+        id: 'new-app',
+        group: 'setup',
+        label: 'New app',
+        detail: () => 'create-sitevision-app',
+        async run(ctx) {
+            await ctx.createApp();
+        },
+    },
+    {
+        id: 'create-addon',
+        group: 'setup',
+        label: 'Create addon',
+        detail: p => p.devProperties?.addonName,
+        enabled: hasDev,
+        hidden: p => !session.missingAddons.has(addonKey(p)),
+        async run(ctx) {
+            const config = await resolveDeployConfig(ctx);
+            if (!config)
+                return;
+            const result = await createAddon(config, getAppType(ctx.project.manifest));
+            if (!result.success) {
+                ctx.notify(result.error ?? t('Create addon failed'), 'error');
+                return;
+            }
+            session.missingAddons.delete(addonKey(ctx.project));
+            ctx.notify(t('addon {addon} created', { addon: config.addonName }), 'ok');
+        },
+    },
+    {
+        id: 'sync-package',
+        key: 'y',
+        group: 'setup',
+        label: 'Sync package.json',
+        detail(p) {
+            const n = getPackageJsonSyncChanges(p.root).length;
+            return n === 0
+                ? t('in sync')
+                : n === 1
+                    ? t('1 diff')
+                    : t('{n} diffs', { n });
+        },
+        enabled: p => getPackageJsonSyncChanges(p.root).length > 0,
+        async run(ctx) {
+            syncDevPropertiesToPackageJson(ctx.project.root);
+            ctx.reload();
+            ctx.notify(t('package.json updated'), 'ok');
+        },
+    },
+    {
+        id: 'migrate-password',
+        group: 'setup',
+        label: 'Migrate password to OS keychain',
+        enabled: p => p.hasLegacyPassword,
+        async run(ctx) {
+            const moved = migrateLegacyPassword(ctx.project);
+            ctx.reload();
+            ctx.notify(moved
+                ? t('password moved to keychain')
+                : t('could not access keychain'), moved ? 'ok' : 'error');
+        },
+    },
+    {
+        id: 'install',
+        key: 'i',
+        group: 'setup',
+        label: 'Install dependencies',
+        detail: () => 'npm install',
+        async run(ctx) {
+            startInstall(ctx.project);
+            ctx.setTab('log');
+        },
+    },
+    {
+        id: 'login',
+        key: 'l',
+        group: 'auth',
+        label: 'Log in',
+        detail: p => p.devProperties?.authMethod ?? 'basic',
+        enabled: hasDev,
+        async run(ctx) {
+            forgetSession(ctx.project);
+            if (await resolveDeployConfig(ctx, true, { addon: false }))
+                ctx.notify(t('logged in'), 'ok');
+        },
+    },
+    {
+        id: 'logout',
+        group: 'auth',
+        label: 'Log out',
+        detail: () => t('forget stored credentials for this site'),
+        enabled: hasDev,
+        async run(ctx) {
+            const dev = ctx.project.devProperties;
+            forgetSession(ctx.project);
+            deleteDeployPassword(dev.domain, dev.username);
+            deleteSessionCookie(dev.domain, dev.username);
+            if (dev.oauth2?.clientId)
+                deleteOAuth2RefreshToken(dev.domain, dev.oauth2.clientId);
+            dev.password = undefined;
+            dev.accessToken = undefined;
+            dev.sessionCookie = undefined;
+            ctx.reload();
+            ctx.notify(t('credentials removed'), 'ok');
+        },
+    },
+    {
+        id: 'quit',
+        key: 'q',
+        group: 'app',
+        label: 'Quit',
+        async run(ctx) {
+            ctx.quit();
+        },
+    },
+];
+export function actionForKey(key) {
+    return actions.find(a => a.key === key);
+}
+/** Subsequence match, case-insensitive: "dpp" matches "Deploy to production". */
+export function fuzzyMatch(query, text) {
+    const q = query.toLowerCase();
+    const haystack = text.toLowerCase();
+    let i = 0;
+    for (const ch of haystack) {
+        if (ch === q[i])
+            i++;
+        if (i === q.length)
+            return true;
+    }
+    return q.length === 0;
+}

package/dist/utils/config.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { parseJsonc } from './jsonc.js';
+import { debug } from './debug.js';
 function configDir() {
     const base = process.env['XDG_CONFIG_HOME'] || path.join(os.homedir(), '.config');
     return path.join(base, 'sitevision-cli');
@@ -10,13 +12,33 @@ function configFile() {
 }
 function readConfig() {
     try {
-        return JSON.parse(fs.readFileSync(configFile(), 'utf8'));
+        return parseJsonc(fs.readFileSync(configFile(), 'utf8'));
     }
     catch {
         return {};
     }
 }
+/** Set when the file exists but does not parse; it is then left untouched. */
+export function configProblem() {
+    let text;
+    try {
+        text = fs.readFileSync(configFile(), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        parseJsonc(text);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 function writeConfig(config) {
+    // A hand-edited file with a typo must not be replaced by defaults.
+    if (configProblem())
+        return;
     try {
         fs.mkdirSync(configDir(), { recursive: true });
         fs.writeFileSync(configFile(), JSON.stringify(config, null, 2));
@@ -26,11 +48,47 @@ function writeConfig(config) {
         // shows again next time, which is harmless.
     }
 }
+export function getSettings() {
+    const config = readConfig();
+    return {
+        language: config.language ?? 'en',
+        introAnimation: config.introAnimation ?? true,
+        updateCheck: config.updateCheck ?? true,
+        addonNameDriftWarning: config.warnings?.addonNameDrift ?? true,
+    };
+}
+export function setSettings(patch) {
+    debug('config', `settings ${JSON.stringify(patch)}`);
+    const { addonNameDriftWarning, ...rest } = patch;
+    const config = { ...readConfig(), ...rest };
+    if (addonNameDriftWarning !== undefined) {
+        config.warnings = {
+            ...config.warnings,
+            addonNameDrift: addonNameDriftWarning,
+        };
+    }
+    writeConfig(config);
+}
+export function getGlobalSigning() {
+    const { signingUsername, certificateName } = readConfig();
+    return {
+        ...(signingUsername && { signingUsername }),
+        ...(certificateName && { certificateName }),
+    };
+}
+export function setGlobalSigning(signing) {
+    debug('config', `global signing ${Object.keys(signing).join(', ')}`);
+    writeConfig({ ...readConfig(), ...signing });
+}
+/** Path of the config file, for display. */
+export function settingsFile() {
+    return configFile();
+}
 /**
  * True until the user has completed the first-run welcome at least once.
  */
 export function isFirstRun() {
-    return !readConfig().firstRunCompleted;
+    return !configProblem() && !readConfig().firstRunCompleted;
 }
 /**
  * Persist that the first-run welcome has been seen.
@@ -52,6 +110,8 @@ export function getLastSeenVersion() {
  */
 export function setLastSeenVersion(version) {
     const config = readConfig();
+    if (config.lastSeenVersion === version)
+        return;
     config.lastSeenVersion = version;
     writeConfig(config);
 }