sitevision-cli 1.0.0-beta.8 → 1.0.0

package/dist/utils/project-detection.js

@@ -1,7 +1,10 @@
 import fs from 'fs';
 import path from 'path';
 import { getDeployPassword, setDeployPassword, getSessionCookie, } from './keychain.js';
-import { parseJsonc } from './jsonc.js';
+import { parseJsonc, stripJsonComments } from './jsonc.js';
+import { getLanguage } from './i18n.js';
+import { getGlobalSigning } from './config.js';
+import { debug } from './debug.js';
 // =============================================================================
 // LOCALIZED TEXT
 // =============================================================================
@@ -14,13 +17,27 @@ import { parseJsonc } from './jsonc.js';
  * raw object as a React child, which Sitevision's localized manifests would
  * otherwise trigger.
  */
-export function localizedText(value, preferred = 'sv') {
+export function localizedText(value, preferred = getLanguage()) {
     if (!value)
         return '';
     if (typeof value === 'string')
         return value;
     return value[preferred] ?? value['en'] ?? Object.values(value)[0] ?? '';
 }
+/**
+ * The manifest's names when the addon name is none of them. The two are
+ * separate things (the addon is an object on the site, the name a label in the
+ * zip), so a difference is only ever pointed out, never "fixed".
+ */
+export function addonNameDrift(addonName, manifest) {
+    const same = (text) => text.trim().toLowerCase();
+    const names = (typeof manifest?.name === 'string'
+        ? [manifest.name]
+        : Object.values(manifest?.name ?? {})).filter(name => name.trim() !== '');
+    if (!addonName?.trim() || names.length === 0)
+        return undefined;
+    return names.some(name => same(name) === same(addonName)) ? undefined : names;
+}
 // =============================================================================
 // PATH UTILITIES
 // =============================================================================
@@ -61,13 +78,111 @@ export function findDevPropertiesPath(root) {
 export function getDefaultDevPropertiesPath(root) {
     return path.join(root, '.dev_properties.json');
 }
+/**
+ * Ancestor directories of `root` (outermost first) up to and including the
+ * nearest one containing `.git`, or the filesystem root. Each may carry a
+ * `.dev_properties.json` whose values the app inherits (nearest wins).
+ */
+function ancestorDirs(root) {
+    const dirs = [];
+    let dir = path.dirname(root);
+    while (true) {
+        dirs.unshift(dir);
+        if (fs.existsSync(path.join(dir, '.git')))
+            break;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return dirs;
+}
+/** A bare host: no scheme, no path, no stray spaces. */
+export function normalizeDomain(value) {
+    const host = value
+        .trim()
+        .replace(/^[a-z]+:\/\//i, '')
+        .replaceAll(/\s/g, '');
+    const slash = host.indexOf('/');
+    return slash === -1 ? host : host.slice(0, slash);
+}
+function readDevPropertiesFile(dir) {
+    const file = findDevPropertiesPath(dir);
+    if (!file)
+        return null;
+    try {
+        const dev = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        // ponytail: top level only; a hand-edited environment override keeps its
+        // scheme until it is saved from the config form.
+        dev.domain &&= normalizeDomain(dev.domain);
+        return dev;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Merge config layers, later ones winning. `environments` merges per name, so a
+ * layer that overrides one field of an environment keeps the rest of it.
+ */
+export function mergeDevLayers(...layers) {
+    let merged = {};
+    for (const layer of layers) {
+        if (!layer)
+            continue;
+        const environments = { ...merged.environments };
+        for (const [name, override] of Object.entries(layer.environments ?? {})) {
+            environments[name] = { ...environments[name], ...override };
+        }
+        merged = { ...merged, ...layer };
+        if (Object.keys(environments).length > 0) {
+            merged.environments = environments;
+        }
+    }
+    return merged;
+}
+/**
+ * The dev properties a workspace root defines (its own file merged over any
+ * ancestors'), with the deploy password resolved from the keychain like an
+ * app's would be. Used to edit shared config from the shell.
+ */
+export function readWorkspaceDevProperties(root) {
+    const merged = mergeDevLayers(readInheritedDevProperties(root), readDevPropertiesFile(root));
+    if (merged.domain && merged.username && !merged.password) {
+        merged.password =
+            process.env['SITEVISION_DEPLOY_PASSWORD'] ??
+                getDeployPassword(merged.domain, merged.username) ??
+                undefined;
+    }
+    return merged;
+}
+/** Ancestor directories' .dev_properties.json merged, nearest wins (no own file). */
+export function readAncestorDevProperties(root) {
+    return mergeDevLayers(...ancestorDirs(root).map(dir => readDevPropertiesFile(dir)));
+}
+/** Shared defaults from package.json: the workspace root's first, the app's on top. */
+export function readPackageDefaultsChain(root) {
+    return mergeDevLayers(...[...ancestorDirs(root), root].map(dir => readPackageDefaults(dir)));
+}
+/**
+ * Everything an app's own .dev_properties.json sits on top of: package.json
+ * defaults (root, then app), then ancestor .dev_properties.json files.
+ */
+export function readInheritedDevProperties(root) {
+    return mergeDevLayers(readPackageDefaultsChain(root), readAncestorDevProperties(root));
+}
 /**
  * Get app ID configuration from environment or defaults
  */
-function getAppIdConfig() {
+export function getAppIdConfig() {
     return {
-        prefix: process.env['SITEVISION_APP_ID_PREFIX'] || '',
-        suffix: process.env['SITEVISION_APP_ID_SUFFIX'] || '',
+        // svc's own names first, then the ones sitevision-scripts reads.
+        prefix: process.env['SITEVISION_APP_ID_PREFIX'] ||
+            process.env['APP_ID_PREFIX'] ||
+            '',
+        suffix: process.env['SITEVISION_APP_ID_SUFFIX'] ||
+            process.env['APP_ID_SUFFIX'] ||
+            '',
     };
 }
 /**
@@ -104,6 +219,20 @@ export function getZipPath(projectRoot, manifest) {
 export function getSignedZipPath(projectRoot, manifest) {
     return path.join(projectRoot, 'dist', getSignedZipFilename(manifest));
 }
+/**
+ * The zip a non-production deploy uploads: the signed one when it is at least
+ * as new as the build, since some sites reject unsigned apps even on dev.
+ */
+export function getDeployZipPath(projectRoot, manifest) {
+    const zip = getZipPath(projectRoot, manifest);
+    const signed = getSignedZipPath(projectRoot, manifest);
+    const mtime = (file) => fs.statSync(file, { throwIfNoEntry: false })?.mtimeMs;
+    const signedAt = mtime(signed);
+    if (signedAt === undefined)
+        return zip;
+    const builtAt = mtime(zip);
+    return builtAt === undefined || signedAt >= builtAt ? signed : zip;
+}
 // =============================================================================
 // API ENDPOINT UTILITIES
 // =============================================================================
@@ -127,6 +256,11 @@ export function getApiEndpoints(appType) {
                 addon: 'headlesscustommodule',
                 import: 'restAppImport',
             };
+        case 'mcp':
+            return {
+                addon: 'mcpServerCustomModule',
+                import: 'mcpServerImport',
+            };
     }
 }
 /**
@@ -163,7 +297,7 @@ export function buildImportEndpointUrl(domain, siteName, addonName, appType, use
 export class ManifestParseError extends Error {
     constructor(manifestPath, cause) {
         const reason = cause instanceof Error ? cause.message : String(cause);
-        super(`${manifestPath} is not valid JSON: ${reason}`);
+        super(`${manifestPath} ${reason}`);
         this.name = 'ManifestParseError';
     }
 }
@@ -183,18 +317,66 @@ export function readManifest(cwd) {
         }
         // Manifests may contain comments (Sitevision's own docs show them), so
         // parse as JSONC.
+        let manifest;
         try {
-            return {
-                manifestPath,
-                manifest: parseJsonc(fs.readFileSync(manifestPath, 'utf-8')),
-            };
+            manifest = parseJsonc(fs.readFileSync(manifestPath, 'utf-8'));
         }
         catch (error) {
-            throw new ManifestParseError(manifestPath, error);
+            throw new ManifestParseError(manifestPath, `is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (typeof manifest !== 'object' || manifest === null) {
+            throw new ManifestParseError(manifestPath, 'must be a JSON object');
         }
+        // Zip names, endpoints and the build all derive from these.
+        for (const key of ['id', 'version', 'type']) {
+            if (typeof manifest[key] !== 'string' || manifest[key] === '') {
+                throw new ManifestParseError(manifestPath, `is missing "${key}"`);
+            }
+        }
+        return { manifestPath, manifest };
     }
     return null;
 }
+const JSON_STRING = String.raw `"(?:[^"\\]|\\.)*"`;
+const escapeRegExp = (s) => s.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw `\$&`);
+/**
+ * Set one text field of manifest.json, or one language of a localized field.
+ * An empty value removes the key. A value that is already a string is replaced
+ * in the text, so comments and formatting survive; anything else rewrites the
+ * file, which is refused when that would drop comments.
+ */
+export function writeManifestField(manifestPath, key, value, lang) {
+    debug('config', `write ${manifestPath} ${key}`);
+    const raw = fs.readFileSync(manifestPath, 'utf-8');
+    const wanted = parseJsonc(raw);
+    const existing = wanted[key];
+    if (lang && typeof existing !== 'object') {
+        // A plain string becomes the English text of a multilingual value.
+        wanted[key] = existing ? { en: existing } : {};
+    }
+    const holder = lang ? wanted[key] : wanted;
+    const leaf = lang ?? key;
+    // JSON.stringify drops an undefined key.
+    holder[leaf] = value || undefined;
+    const prefix = lang
+        ? String.raw `"${escapeRegExp(key)}"\s*:\s*\{[^}]*?"${escapeRegExp(lang)}"\s*:\s*`
+        : String.raw `"${escapeRegExp(key)}"\s*:\s*`;
+    const patched = raw.replace(new RegExp(`(${prefix})${JSON_STRING}`), (_, before) => before + JSON.stringify(value));
+    let patchedOk = false;
+    try {
+        patchedOk = JSON.stringify(parseJsonc(patched)) === JSON.stringify(wanted);
+    }
+    catch { }
+    if (patchedOk) {
+        fs.writeFileSync(manifestPath, patched);
+        return;
+    }
+    if (stripJsonComments(raw) !== raw) {
+        throw new Error(`${manifestPath} has comments; add or remove "${leaf}" by hand`);
+    }
+    const indent = /^(?<indent>[\t ]+)/m.exec(raw)?.groups?.['indent'] ?? '\t';
+    fs.writeFileSync(manifestPath, JSON.stringify(wanted, null, indent) + (raw.endsWith('\n') ? '\n' : ''));
+}
 /**
  * Detect if the current directory is a Sitevision project
  */
@@ -217,52 +399,25 @@ export function detectProject(cwd = process.cwd()) {
         // Check for node_modules
         const nodeModulesPath = path.join(cwd, 'node_modules');
         const hasNodeModules = fs.existsSync(nodeModulesPath);
-        // Check for dev properties
+        // Dev properties: ancestor files (workspace root) merged under the app's
+        // own file, so shared site/auth config lives once at the repo root.
         const devPropertiesPath = findDevPropertiesPath(cwd);
+        const inherited = readInheritedDevProperties(cwd);
+        const own = devPropertiesPath ? readDevPropertiesFile(cwd) : null;
+        const inheritedKeys = Object.keys(inherited).filter(key => !own || !Object.hasOwn(own, key));
         let devProperties;
-        let hasDevProperties = false;
+        const hasDevProperties = Boolean(own) || inheritedKeys.length > 0;
         let hasLegacyPassword = false;
-        if (devPropertiesPath) {
-            hasDevProperties = true;
+        if (hasDevProperties) {
             try {
-                const parsed = JSON.parse(fs.readFileSync(devPropertiesPath, 'utf-8'));
+                // ponytail: the global signing identity only reaches a project that
+                // has some config of its own, so "configured?" checks stay truthful.
+                const parsed = mergeDevLayers(getGlobalSigning(), inherited, own);
                 hasLegacyPassword =
                     typeof parsed.password === 'string' && parsed.password.length > 0;
                 devProperties = parsed;
-                // Resolve deploy password: env var > keychain (file is legacy-only)
-                if (!hasLegacyPassword &&
-                    devProperties.domain &&
-                    devProperties.username) {
-                    const envPassword = process.env['SITEVISION_DEPLOY_PASSWORD'];
-                    if (envPassword) {
-                        devProperties.password = envPassword;
-                    }
-                    else {
-                        const stored = getDeployPassword(devProperties.domain, devProperties.username);
-                        if (stored) {
-                            devProperties.password = stored;
-                        }
-                    }
-                }
-                // Resolve an OAuth2 access token: env var > keychain refresh.
-                // The env var is the manual/CI path; the interactive login stores a
-                // refresh token in the keychain and mints access tokens from it.
-                if (devProperties.authMethod === 'oauth2') {
-                    const envToken = process.env['SITEVISION_ACCESS_TOKEN'];
-                    if (envToken) {
-                        devProperties.accessToken = envToken;
-                    }
-                }
-                // Resolve a session cookie: env var > keychain (captured at login).
-                if (devProperties.authMethod === 'cookie' &&
-                    devProperties.domain &&
-                    devProperties.username) {
-                    const envCookie = process.env['SITEVISION_SESSION_COOKIE'];
-                    devProperties.sessionCookie =
-                        envCookie ??
-                            getSessionCookie(devProperties.domain, devProperties.username) ??
-                            undefined;
-                }
+                if (!hasLegacyPassword)
+                    resolveRuntimeSecrets(devProperties);
             }
             catch {
                 // Invalid dev properties file
@@ -279,6 +434,7 @@ export function detectProject(cwd = process.cwd()) {
             hasSigningProperties,
             hasLegacyPassword,
             devProperties,
+            inheritedKeys,
             packageJson,
             hasSitevisionScripts,
             hasNodeModules,
@@ -294,6 +450,29 @@ export function detectProject(cwd = process.cwd()) {
         return null;
     }
 }
+/**
+ * Fill the runtime-only credential fields for the given domain/username:
+ * deploy password (env var > keychain), OAuth2 access token (env var), and
+ * session cookie (env var > keychain). Mutates and returns `dev`.
+ */
+export function resolveRuntimeSecrets(dev) {
+    if (dev.domain && dev.username) {
+        dev.password =
+            process.env['SITEVISION_DEPLOY_PASSWORD'] ??
+                getDeployPassword(dev.domain, dev.username) ??
+                undefined;
+    }
+    if (dev.authMethod === 'oauth2') {
+        dev.accessToken = process.env['SITEVISION_ACCESS_TOKEN'] ?? undefined;
+    }
+    if (dev.authMethod === 'cookie' && dev.domain) {
+        dev.sessionCookie =
+            process.env['SITEVISION_SESSION_COOKIE'] ??
+                getSessionCookie(dev.domain, dev.username) ??
+                undefined;
+    }
+    return dev;
+}
 /**
  * Validate that we're in a Sitevision project directory
  */
@@ -305,20 +484,31 @@ export function requireProject(cwd) {
     return project;
 }
 /**
- * Get the app type (web, widget, rest)
+ * The app type (web, widget, rest, mcp), or undefined for a manifest type
+ * this CLI does not know. Display code uses this so one odd app never takes
+ * the whole shell down.
  */
-export function getAppType(manifest) {
-    const type = manifest.type.toLowerCase();
-    if (type.startsWith('web')) {
+export function appTypeOf(manifest) {
+    const type = String(manifest.type ?? '').toLowerCase();
+    if (type.startsWith('web'))
         return 'web';
-    }
-    if (type.startsWith('widget')) {
+    if (type.startsWith('widget'))
         return 'widget';
-    }
-    if (type.startsWith('rest')) {
+    if (type.startsWith('rest'))
         return 'rest';
-    }
-    throw new Error(`Unknown app type: ${manifest.type}`);
+    if (type.startsWith('mcp'))
+        return 'mcp';
+    return undefined;
+}
+/**
+ * Get the app type (web, widget, rest, mcp). Throws for unknown types, since
+ * build and deploy cannot proceed without knowing the endpoints.
+ */
+export function getAppType(manifest) {
+    const type = appTypeOf(manifest);
+    if (!type)
+        throw new Error(`Unknown app type: ${manifest.type}`);
+    return type;
 }
 /**
  * Check if the app uses webpack bundling
@@ -346,11 +536,32 @@ export function readDevProperties(projectRoot) {
  * `accessToken` and `sessionCookie` are held in the OS keychain / resolved at
  * runtime instead.
  */
-export function writeDevProperties(projectRoot, properties) {
+export function writeDevProperties(projectRoot, properties, 
+// App mode: write every value, so plain sitevision-scripts finds them all.
+{ complete = false } = {}) {
     const devPropertiesPath = findDevPropertiesPath(projectRoot) ||
         getDefaultDevPropertiesPath(projectRoot);
-    const { password: _password, accessToken: _accessToken, sessionCookie: _sessionCookie, ...persisted } = properties;
-    fs.writeFileSync(devPropertiesPath, JSON.stringify(persisted, null, 2));
+    debug('config', `write ${devPropertiesPath} (${Object.keys(properties).join(', ')})`);
+    const { password: _password, accessToken: _accessToken, sessionCookie: _sessionCookie, environmentName: _environmentName, productionEnvironment: _productionEnvironment, ...persisted } = properties;
+    // Keep the app file minimal: values identical to the inherited ones stay
+    // at the workspace root instead of being copied into every app. An empty
+    // string means "unset", so it is dropped rather than written as an override
+    // that would shadow the inherited value.
+    const inherited = complete
+        ? {}
+        : mergeDevLayers(getGlobalSigning(), readInheritedDevProperties(projectRoot));
+    const own = Object.fromEntries(Object.entries(persisted).filter(([key, value]) => value !== '' &&
+        (!Object.hasOwn(inherited, key) ||
+            JSON.stringify(inherited[key]) !== JSON.stringify(value))));
+    // A plaintext password already in the file (sitevision-scripts puts it
+    // there) moves to the keychain; if that fails it stays rather than be lost.
+    const legacy = readDevPropertiesFile(projectRoot)?.password;
+    if (legacy) {
+        const { domain, username } = { ...inherited, ...persisted };
+        if (!setDeployPassword(domain, username, legacy))
+            own['password'] = legacy;
+    }
+    fs.writeFileSync(devPropertiesPath, JSON.stringify(own, null, 2));
 }
 export function readSvcConfig(projectRoot) {
     try {
@@ -361,6 +572,7 @@ export function readSvcConfig(projectRoot) {
     }
 }
 export function writeSvcConfig(projectRoot, updates) {
+    debug('config', `write .svcconfig ${JSON.stringify(updates)}`);
     const merged = { ...readSvcConfig(projectRoot), ...updates };
     fs.writeFileSync(path.join(projectRoot, '.svcconfig'), JSON.stringify(merged, null, 2) + '\n');
 }
@@ -368,13 +580,24 @@ export function writeSvcConfig(projectRoot, updates) {
 // PACKAGE.JSON SYNC
 // =============================================================================
 /**
- * Fields duplicated between .dev_properties.json and package.json, where
- * sitevision-scripts reads them under different names.
+ * Values tied to the person running svc. They stay in .dev_properties.json and
+ * never go into package.json.
  */
-const PACKAGE_JSON_SYNC_KEYS = [
-    { packageKey: 'developmentDomain', devKey: 'domain' },
-    { packageKey: 'siteName', devKey: 'siteName' },
-    { packageKey: 'addonName', devKey: 'addonName' },
+export const USER_KEYS = ['username', 'signingUsername', 'certificateName'];
+// Shared values package.json can hold: three top-level fields, the rest under "svc".
+const PACKAGE_TOP_KEYS = {
+    domain: 'developmentDomain',
+    siteName: 'siteName',
+    addonName: 'addonName',
+};
+const PACKAGE_SVC_KEYS = [
+    'authMethod',
+    'oauth2',
+    'sessionLoginUrl',
+    'useHTTPForDevDeploy',
+    'baseEnvironment',
+    'production',
+    'environments',
 ];
 function readPackageJson(projectRoot) {
     try {
@@ -384,60 +607,166 @@ function readPackageJson(projectRoot) {
         return null;
     }
 }
+/** The shared defaults one directory's package.json provides. */
+export function readPackageDefaults(dir) {
+    const packageJson = readPackageJson(dir);
+    if (!packageJson)
+        return {};
+    const defaults = {};
+    for (const [devKey, packageKey] of Object.entries(PACKAGE_TOP_KEYS)) {
+        const value = packageJson[packageKey];
+        if (typeof value === 'string' && value !== '')
+            defaults[devKey] = value;
+    }
+    const svc = packageJson['svc'];
+    for (const key of PACKAGE_SVC_KEYS) {
+        if (svc?.[key] !== undefined)
+            defaults[key] = svc[key];
+    }
+    if (typeof defaults['domain'] === 'string') {
+        defaults['domain'] = normalizeDomain(defaults['domain']);
+    }
+    return defaults;
+}
 /**
- * Which of the shared fields package.json is missing or disagrees on, relative
- * to the given dev properties. Reads package.json from disk — an earlier
- * `npm install` in the same session may have rewritten it.
+ * Shared values in this directory's own .dev_properties.json that package.json
+ * does not already provide, here or further up. User values never qualify.
  */
-export function getPackageJsonSyncChanges(projectRoot, properties) {
-    const packageJson = readPackageJson(projectRoot);
-    if (!packageJson)
+function pendingSync(dir) {
+    const own = readDevPropertiesFile(dir);
+    if (!own)
         return [];
-    const changes = [];
-    for (const { packageKey, devKey } of PACKAGE_JSON_SYNC_KEYS) {
-        const to = properties[devKey];
-        if (typeof to !== 'string' || to === '')
-            continue;
-        const from = packageJson[packageKey];
-        if (from !== to) {
-            changes.push(from === undefined
-                ? { key: packageKey, to }
-                : { key: packageKey, from, to });
+    const defaults = readPackageDefaultsChain(dir);
+    const pending = [];
+    for (const key of [...Object.keys(PACKAGE_TOP_KEYS), ...PACKAGE_SVC_KEYS]) {
+        let value = own[key];
+        if (key === 'environments' && value) {
+            value = Object.fromEntries(Object.entries(value).map(([name, override]) => [
+                name,
+                Object.fromEntries(Object.entries(override).filter(([field]) => !USER_KEYS.includes(field))),
+            ]));
         }
+        if (value === undefined || value === '')
+            continue;
+        if (JSON.stringify(value) ===
+            JSON.stringify(defaults[key] ?? IMPLICIT_VALUES[key]))
+            continue;
+        pending.push({ key, value });
     }
-    return changes;
+    return pending;
 }
+// Manifest fields package.json mirrors under the same name; the manifest wins.
+const MANIFEST_PACKAGE_KEYS = ['version', 'description', 'author'];
 /**
- * Copy the shared fields from dev properties into package.json, preserving the
- * file's existing indentation and trailing newline.
+ * Manifest values the app's own package.json does not mirror yet. Nothing when
+ * either file is missing, so syncing never creates a package.json for this.
  */
-export function syncDevPropertiesToPackageJson(projectRoot, properties) {
-    const packageJsonPath = path.join(projectRoot, 'package.json');
-    let raw;
+function pendingManifestSync(dir) {
+    const packageJson = readPackageJson(dir);
+    if (!packageJson)
+        return [];
+    let manifest;
     try {
-        raw = fs.readFileSync(packageJsonPath, 'utf-8');
-    }
-    catch {
-        return false;
+        manifest = readManifest(dir)?.manifest;
     }
-    let packageJson;
-    try {
-        packageJson = JSON.parse(raw);
+    catch { }
+    if (!manifest)
+        return [];
+    const pending = [];
+    for (const key of MANIFEST_PACKAGE_KEYS) {
+        const value = key === 'description'
+            ? localizedText(manifest.description, 'en')
+            : manifest[key];
+        const current = packageJson[key];
+        // ponytail: an author object ({name, email}) is left alone.
+        if (!value || typeof value !== 'string' || value === current)
+            continue;
+        if (current !== undefined && typeof current !== 'string')
+            continue;
+        pending.push({ key, from: current, value });
     }
-    catch {
+    return pending;
+}
+/** What an unset field means, so spelling out the default is not a change. */
+export const IMPLICIT_VALUES = {
+    authMethod: 'basic',
+    useHTTPForDevDeploy: false,
+    production: false,
+};
+const packageLabel = (key) => PACKAGE_TOP_KEYS[key] ?? `svc.${key}`;
+const display = (value) => typeof value === 'string' ? value : JSON.stringify(value);
+/** What syncing this directory would change in its package.json. */
+export function getPackageJsonSyncChanges(dir) {
+    const current = readPackageDefaults(dir);
+    return [
+        ...pendingSync(dir).map(({ key, value }) => current[key] === undefined
+            ? { key: packageLabel(key), to: display(value) }
+            : {
+                key: packageLabel(key),
+                from: display(current[key]),
+                to: display(value),
+            }),
+        ...pendingManifestSync(dir).map(({ key, from, value }) => ({
+            key,
+            ...(from !== undefined && { from }),
+            to: value,
+        })),
+    ];
+}
+export function hasPackageJson(dir) {
+    return fs.existsSync(path.join(dir, 'package.json'));
+}
+/**
+ * Copy the pending shared values from .dev_properties.json, and the manifest
+ * fields package.json mirrors, into package.json, creating package.json when
+ * the directory has none. Throws if it cannot be
+ * read or written.
+ */
+export function syncDevPropertiesToPackageJson(dir) {
+    const pending = pendingSync(dir);
+    const mirrored = pendingManifestSync(dir);
+    if (pending.length + mirrored.length === 0 && hasPackageJson(dir))
         return false;
-    }
-    for (const { packageKey, devKey } of PACKAGE_JSON_SYNC_KEYS) {
-        const value = properties[devKey];
-        if (typeof value === 'string' && value !== '') {
-            packageJson[packageKey] = value;
+    updatePackageJson(dir, packageJson => {
+        for (const { key, value } of mirrored)
+            packageJson[key] = value;
+        for (const { key, value } of pending) {
+            const topKey = PACKAGE_TOP_KEYS[key];
+            if (topKey) {
+                packageJson[topKey] = value;
+            }
+            else {
+                packageJson['svc'] = {
+                    ...packageJson['svc'],
+                    [key]: value,
+                };
+            }
         }
-    }
-    const indent = /^(?<indent>[\t ]+)/m.exec(raw)?.groups?.['indent'] ?? '\t';
-    const newline = raw.endsWith('\n') ? '\n' : '';
-    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, indent) + newline);
+    });
     return true;
 }
+/**
+ * Edit package.json in place, keeping its indentation and trailing newline. A
+ * missing file is created; an unreadable or invalid one throws, so the caller
+ * can warn instead of dropping the change silently.
+ */
+export function updatePackageJson(dir, mutate) {
+    const packageJsonPath = path.join(dir, 'package.json');
+    // A new file is private, so a workspace root is never published by accident.
+    let raw = '{\n\t"private": true\n}\n';
+    try {
+        if (hasPackageJson(dir))
+            raw = fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(raw);
+        mutate(packageJson);
+        const indent = /^(?<indent>[\t ]+)/m.exec(raw)?.groups?.['indent'] ?? '\t';
+        const newline = raw.endsWith('\n') ? '\n' : '';
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, indent) + newline);
+    }
+    catch (error) {
+        throw new Error(`Could not update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 /**
  * Move a plaintext password from .dev_properties.json into the OS keychain and
  * strip it from the file. Returns true if the password was migrated.
@@ -453,10 +782,26 @@ export function migrateLegacyPassword(project) {
         return false;
     if (!setDeployPassword(domain, username, password))
         return false;
-    // writeDevProperties strips `password` defensively; keep the in-memory value.
-    writeDevProperties(project.root, project.devProperties);
-    project.hasLegacyPassword = false;
-    return true;
+    // Remove only the password, from whichever file holds it; every other value
+    // stays as written.
+    for (const dir of [project.root, ...ancestorDirs(project.root)]) {
+        const file = findDevPropertiesPath(dir);
+        if (!file)
+            continue;
+        try {
+            const { password: stored, ...rest } = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (stored !== undefined) {
+                fs.writeFileSync(file, JSON.stringify(rest, null, 2));
+            }
+        }
+        catch {
+            // Unreadable file: nothing to migrate there. Unwritable: checked below.
+        }
+    }
+    // Moved only if no file still holds it.
+    const left = [project.root, ...ancestorDirs(project.root)].some(dir => readDevPropertiesFile(dir)?.password);
+    project.hasLegacyPassword = left;
+    return !left;
 }
 /**
  * Ensure the dist directory exists