@sparkelf/dsh-plus 0.2.1-rc.2.4 → 0.2.2-alpha.2.10

package/lib/types/apply.js

@@ -1,11 +1,12 @@
-/** Materialize the Plus distribution's independent patch packages without Desktop. */
+/** Materialize the Plus distribution's embedded patch set without Desktop. */
 import { spawnSync } from 'node:child_process';
 import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync, } from 'node:fs';
 import { createRequire } from 'node:module';
-import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { satisfies, valid, validRange } from 'semver';
 import { parseDocument } from 'yaml';
+import { readPatchSet } from "./patch-set.js";
 const FORMAT_VERSION = 1;
 function isSelectedNpmPatch(patch) {
     return patch.target.kind === 'npm';
@@ -50,7 +51,22 @@ function requireStringArray(value, label) {
 }
 function resolveInstalledPackage(distributionDirectory, packageName) {
     const requireFromDistribution = createRequire(resolve(distributionDirectory, 'package.json'));
-    const manifestPath = requireFromDistribution.resolve(packageName + '/package.json');
+    let manifestPath;
+    try {
+        manifestPath = requireFromDistribution.resolve(packageName + '/package.json');
+    }
+    catch {
+        // Some packages do not export `./package.json`; resolve the entry module instead and walk
+        // up to the directory that holds the manifest.
+        let directory = dirname(requireFromDistribution.resolve(packageName));
+        while (!existsSync(resolve(directory, 'package.json'))) {
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error(packageName + ' has no resolvable package manifest');
+            directory = parent;
+        }
+        manifestPath = resolve(directory, 'package.json');
+    }
     const manifest = readJsonObject(manifestPath, packageName + ' manifest');
     return {
         name: packageName,
@@ -59,48 +75,6 @@ function resolveInstalledPackage(distributionDirectory, packageName) {
         manifest,
     };
 }
-function resolvePatchFile(packageDirectory, declared) {
-    const absoluteFile = resolve(packageDirectory, declared);
-    const local = relative(packageDirectory, absoluteFile);
-    if (isAbsolute(local) || local === '..' || local.startsWith('../')) {
-        throw new Error('patch file must stay inside its patch package: ' + declared);
-    }
-    if (!existsSync(absoluteFile))
-        throw new Error('patch file does not exist: ' + absoluteFile);
-    return { relativeFile: local.replaceAll('\\', '/'), absoluteFile };
-}
-function parseVariant(value, index, patchPackage) {
-    const label = patchPackage.name + ' dshPatch.variants[' + String(index) + ']';
-    const variant = requireObject(value, label);
-    const target = requireObject(variant.target, label + '.target');
-    const kind = requireString(target.kind, label + '.target.kind');
-    const common = {
-        id: requireString(variant.id, label + '.id'),
-        dsh: requireRange(variant.dsh, label + '.dsh'),
-        file: requireString(variant.file, label + '.file'),
-        patchPackage,
-    };
-    if (kind === 'npm') {
-        return {
-            ...common,
-            target: {
-                kind,
-                name: requireString(target.name, label + '.target.name'),
-                range: requireRange(target.range, label + '.target.range'),
-            },
-        };
-    }
-    if (kind === 'dsh-source') {
-        return {
-            ...common,
-            target: {
-                kind,
-                baseRevision: requireString(target.baseRevision, label + '.target.baseRevision'),
-            },
-        };
-    }
-    throw new Error('unsupported patch target kind: ' + kind);
-}
 function git(root, args, acceptFailure = false) {
     const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
     if (result.status === 0)
@@ -148,23 +122,6 @@ function requireSourceBase(root, baseRevision) {
     }
     return checkoutRevision;
 }
-function patchPackageVariants(distributionDirectory, names) {
-    const variants = [];
-    for (const name of names) {
-        const patchPackage = resolveInstalledPackage(distributionDirectory, name);
-        const declaration = requireObject(patchPackage.manifest.dshPatch, name + ' dshPatch');
-        if (declaration.formatVersion !== FORMAT_VERSION) {
-            throw new Error('unsupported dshPatch formatVersion in ' + name + ': ' + String(declaration.formatVersion));
-        }
-        if (!Array.isArray(declaration.variants) || declaration.variants.length === 0) {
-            throw new Error(name + ' dshPatch.variants must be a non-empty array');
-        }
-        for (const [index, value] of declaration.variants.entries()) {
-            variants.push(parseVariant(value, index, patchPackage));
-        }
-    }
-    return variants;
-}
 // 先验证official source，再物化Plus声明的profile依赖，避免source不匹配时改动用户profile。
 function prepareSelection(distributionDirectory, profileDirectory, dshRoot) {
     const distributionManifest = readJsonObject(resolve(distributionDirectory, 'package.json'), 'Plus distribution manifest');
@@ -192,31 +149,24 @@ function prepareSelection(distributionDirectory, profileDirectory, dshRoot) {
             throw new Error('dshPlus.profile.allowBuilds.' + name + ' must be a boolean');
         allowBuilds[name] = allowed;
     }
-    const patchPackageNames = requireStringArray(plus.patchPackages, 'dshPlus.patchPackages');
+    const patchSet = readPatchSet(distributionDirectory, distributionManifest);
     const dependencies = requireObject(distributionManifest.dependencies, 'Plus distribution dependencies');
     const dshManifest = readJsonObject(resolve(dshRoot, 'package.json'), 'DSH source manifest');
     const dshVersion = requireVersion(dshManifest.version, 'DSH source version');
     if (!satisfies(dshVersion, dshRange, { includePrerelease: true })) {
         throw new Error(distributionName + '@' + distributionVersion + ' requires DSH ' + dshRange + ', found ' + dshVersion);
     }
-    const checkoutRevision = requireSourceBase(dshRoot, baseRevision);
-    const groups = new Map();
-    for (const variant of patchPackageVariants(distributionDirectory, patchPackageNames)) {
-        const entries = groups.get(variant.id) ?? [];
-        entries.push(variant);
-        groups.set(variant.id, entries);
-    }
+    const checkoutRevision = requireSourceBase(dshRoot, patchSet.sourceBaseRevision);
+    const patchEntries = [...patchSet.entries, ...patchSet.thirdPartyPatches];
     const sourceStates = new Map();
-    const orderedGroups = [...groups].sort(([left], [right]) => left.localeCompare(right));
-    for (const [, variants] of orderedGroups) {
-        for (const variant of variants) {
-            if (variant.target.kind !== 'dsh-source'
-                || variant.target.baseRevision !== baseRevision
-                || !satisfies(dshVersion, variant.dsh, { includePrerelease: true }))
-                continue;
-            const file = resolvePatchFile(variant.patchPackage.directory, variant.file);
-            sourceStates.set(file.absoluteFile, sourcePatchState(dshRoot, file.absoluteFile));
+    for (const item of patchEntries) {
+        if (!satisfies(dshVersion, item.dsh, { includePrerelease: true })) {
+            throw new Error('patch ' + item.id + ' declares DSH ' + item.dsh + ', found ' + dshVersion);
         }
+        if (item.target.kind !== 'dsh-source')
+            continue;
+        const absoluteFile = resolve(distributionDirectory, item.file);
+        sourceStates.set(absoluteFile, sourcePatchState(dshRoot, absoluteFile));
     }
     const pendingSourceFiles = [...sourceStates].flatMap(([file, state]) => state === 'pending' ? [file] : []);
     preflightSourcePatches(dshRoot, pendingSourceFiles);
@@ -227,49 +177,38 @@ function prepareSelection(distributionDirectory, profileDirectory, dshRoot) {
         return { name, version: installed.version };
     });
     const runtimePackages = [
-        ...Object.keys(dependencies).filter(name => !patchPackageNames.includes(name)).sort().map((name) => {
+        ...Object.keys(dependencies).sort().map((name) => {
             const installed = resolveInstalledPackage(distributionDirectory, name);
             return { name, version: installed.version };
         }),
         ...profileDependencies,
     ].sort((left, right) => left.name.localeCompare(right.name));
     const selected = [];
-    // 每个patch id必须在当前DSH、official base与installed npm graph上唯一命中，不能fallback到第二variant。
-    for (const [id, variants] of orderedGroups) {
-        const candidates = variants.flatMap((variant) => {
-            if (!satisfies(dshVersion, variant.dsh, { includePrerelease: true }))
-                return [];
-            const file = resolvePatchFile(variant.patchPackage.directory, variant.file);
-            if (variant.target.kind === 'dsh-source') {
-                if (variant.target.baseRevision !== baseRevision)
-                    return [];
-                return [{
-                        id,
-                        patchPackage: { name: variant.patchPackage.name, version: variant.patchPackage.version },
-                        file: file.relativeFile,
-                        absoluteFile: file.absoluteFile,
-                        target: { kind: 'dsh-source', baseRevision },
-                        alreadyApplied: sourceStates.get(file.absoluteFile) === 'applied',
-                    }];
-            }
-            const targetDirectory = variant.target.name in profileDependencySpecs ? profileDirectory : distributionDirectory;
-            const targetVersion = resolveInstalledPackage(targetDirectory, variant.target.name).version;
-            if (!satisfies(targetVersion, variant.target.range, { includePrerelease: true }))
-                return [];
-            return [{
-                    id,
-                    patchPackage: { name: variant.patchPackage.name, version: variant.patchPackage.version },
-                    file: file.relativeFile,
-                    absoluteFile: file.absoluteFile,
-                    target: { kind: 'npm', name: variant.target.name, version: targetVersion },
-                }];
+    for (const item of patchEntries) {
+        const absoluteFile = resolve(distributionDirectory, item.file);
+        if (item.target.kind === 'dsh-source') {
+            selected.push({
+                id: item.id,
+                scope: item.scope,
+                file: item.file,
+                absoluteFile,
+                target: { kind: 'dsh-source', baseRevision: patchSet.sourceBaseRevision },
+                alreadyApplied: sourceStates.get(absoluteFile) === 'applied',
+            });
+            continue;
+        }
+        const targetDirectory = item.target.name in profileDependencySpecs ? profileDirectory : distributionDirectory;
+        const targetVersion = resolveInstalledPackage(targetDirectory, item.target.name).version;
+        if (!satisfies(targetVersion, item.target.range, { includePrerelease: true })) {
+            throw new Error('patch ' + item.id + ' targets ' + item.target.name + ' ' + item.target.range + ', found ' + targetVersion);
+        }
+        selected.push({
+            id: item.id,
+            scope: item.scope,
+            file: item.file,
+            absoluteFile,
+            target: { kind: 'npm', name: item.target.name, version: targetVersion },
         });
-        const [candidate] = candidates;
-        if (candidate === undefined)
-            throw new Error('no compatible patch variant for ' + id + ' on DSH ' + dshVersion);
-        if (candidates.length > 1)
-            throw new Error('multiple compatible patch variants for ' + id + ' on DSH ' + dshVersion);
-        selected.push(candidate);
     }
     const lockPatches = selected.map((patch) => {
         if ('alreadyApplied' in patch) {
@@ -299,7 +238,7 @@ function materializePatchFiles(profileDirectory, patches) {
     const root = resolve(profileDirectory, '.dsh-plus', 'patches');
     rmSync(root, { recursive: true, force: true });
     const stablePatches = patches.map((patch) => {
-        const destination = resolve(root, patch.patchPackage.name, patch.patchPackage.version, patch.file);
+        const destination = resolve(root, patch.scope, patch.id, basename(patch.file));
         mkdirSync(dirname(destination), { recursive: true });
         copyFileSync(patch.absoluteFile, destination);
         return { ...patch, absoluteFile: destination };
@@ -323,7 +262,7 @@ function materializePatchFiles(profileDirectory, patches) {
             continue;
         }
         // 成员或版本变化必须改变workspace路径，使pnpm重新应用新的组合payload。
-        const members = group.map(patch => encodeURIComponent(patch.id + '@' + patch.patchPackage.version)).join('+');
+        const members = group.map(patch => encodeURIComponent(patch.id)).join('+');
         const destination = resolve(root, 'combined', encodeURIComponent(key), members + '.patch');
         mkdirSync(dirname(destination), { recursive: true });
         const contents = group.map((patch) => {

package/lib/types/patch-set.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Read the Plus distribution's embedded patch set.
+ *
+ * The distribution owns one patch set for official DSH and, separately, the patches it
+ * carries for third-party packages. Both live inside the distribution package: the
+ * manifest declares entries, and each entry's payload is a file under `patches/`. A
+ * consumer resolves no independently published patch package.
+ *
+ * The two lists are governed differently. A Plus entry must target an official package
+ * that the profile republishes and overrides; a third-party entry must name its upstream
+ * and a retirement condition, and never becomes part of the official patch set.
+ */
+/** An npm package the distribution patches in place. */
+export interface NpmPatchTarget {
+    readonly kind: 'npm';
+    readonly name: string;
+    readonly range: string;
+}
+/** One official source path set, applied to the exact `dshPlus.sourceBase` revision. */
+export interface SourcePatchTarget {
+    readonly kind: 'dsh-source';
+    readonly baseRevision: string;
+    /** Official packages the patch modifies; each must be republished and overridden. */
+    readonly packages: readonly string[];
+    readonly paths: readonly string[];
+}
+/** Where one patch payload lands. */
+export type PatchTarget = NpmPatchTarget | SourcePatchTarget;
+/** Who owns the entry: the Plus official delta or a carried third-party patch. */
+export type PatchScope = 'plus' | 'third-party';
+/** One entry of the embedded patch set. */
+export interface PatchSetEntry {
+    /** Stable identity used by the lock and by retirement records. */
+    readonly id: string;
+    readonly scope: PatchScope;
+    /** DSH range the entry applies to. */
+    readonly dsh: string;
+    /** Payload path, relative to the distribution package. */
+    readonly file: string;
+    /** The behavior or upstream release that retires this entry. */
+    readonly retireWhen: string;
+    /** Third-party entries name the upstream they track. */
+    readonly upstreamUrl?: string;
+    readonly target: PatchTarget;
+}
+/** The distribution's complete embedded patch declaration. */
+export interface PatchSet {
+    readonly entries: readonly PatchSetEntry[];
+    readonly thirdPartyPatches: readonly PatchSetEntry[];
+    readonly sourceBaseRevision: string;
+}
+/**
+ * Read and validate the embedded patch set from an installed distribution.
+ * @param distributionDirectory - installed `@sparkelf/dsh-plus` directory.
+ * @param manifest - its parsed package manifest.
+ * @returns the ordered Plus entries, third-party entries, and the exact source base.
+ */
+export declare function readPatchSet(distributionDirectory: string, manifest: Record<string, unknown>): PatchSet;
+//# sourceMappingURL=patch-set.d.ts.map

package/lib/types/patch-set.js

@@ -0,0 +1,132 @@
+/**
+ * Read the Plus distribution's embedded patch set.
+ *
+ * The distribution owns one patch set for official DSH and, separately, the patches it
+ * carries for third-party packages. Both live inside the distribution package: the
+ * manifest declares entries, and each entry's payload is a file under `patches/`. A
+ * consumer resolves no independently published patch package.
+ *
+ * The two lists are governed differently. A Plus entry must target an official package
+ * that the profile republishes and overrides; a third-party entry must name its upstream
+ * and a retirement condition, and never becomes part of the official patch set.
+ */
+import { existsSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { validRange } from 'semver';
+function object(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(label + ' must be an object');
+    return value;
+}
+function string(value, label) {
+    if (typeof value !== 'string' || value === '')
+        throw new Error(label + ' must be a non-empty string');
+    return value;
+}
+function range(value, label) {
+    const text = string(value, label);
+    if (validRange(text) === null)
+        throw new Error(label + ' is not a semantic-version range: ' + text);
+    return text;
+}
+/** A payload stays inside the distribution package it is declared by. */
+function patchFile(distributionDirectory, declared, label) {
+    const absolute = resolve(distributionDirectory, declared);
+    const local = relative(distributionDirectory, absolute);
+    if (local === '' || isAbsolute(local) || local === '..' || local.startsWith('../')) {
+        throw new Error(label + ' must stay inside the distribution package: ' + declared);
+    }
+    if (!existsSync(absolute))
+        throw new Error(label + ' does not exist: ' + absolute);
+    return local.replaceAll('\\', '/');
+}
+function sourceTarget(value, sourceBaseRevision, label) {
+    const target = object(value, label);
+    if (target.kind !== 'dsh-source')
+        throw new Error(label + '.kind must be dsh-source');
+    if (!Array.isArray(target.paths) || target.paths.length === 0)
+        throw new Error(label + '.paths must be a non-empty array');
+    const paths = target.paths.map((entry, index) => {
+        const path = string(entry, label + '.paths[' + String(index) + ']');
+        if (!path.endsWith('/'))
+            throw new Error(label + '.paths entries must be repository directory prefixes');
+        return path;
+    });
+    if (!Array.isArray(target.packages) || target.packages.length === 0) {
+        throw new Error(label + '.packages must be a non-empty array');
+    }
+    const packages = target.packages.map((entry, index) => {
+        const name = string(entry, label + '.packages[' + String(index) + ']');
+        if (!name.startsWith('@deepseek-ai/'))
+            throw new Error(label + '.packages entries must be official package names');
+        return name;
+    });
+    return { kind: 'dsh-source', baseRevision: sourceBaseRevision, packages, paths };
+}
+function npmTarget(value, label) {
+    const target = object(value, label);
+    if (target.kind !== 'npm')
+        throw new Error(label + '.kind must be npm');
+    return {
+        kind: 'npm',
+        name: string(target.name, label + '.name'),
+        range: range(target.range, label + '.range'),
+    };
+}
+function entry(value, scope, sourceBaseRevision, distributionDirectory, label) {
+    const record = object(value, label);
+    const id = string(record.id, label + '.id');
+    const dsh = range(record.dsh, label + '.dsh');
+    const file = patchFile(distributionDirectory, string(record.file, label + '.file'), label + '.file');
+    const retireWhen = string(record.retireWhen, label + '.retireWhen');
+    const targetLabel = label + '.target';
+    const target = scope === 'plus'
+        ? (object(record.target, targetLabel).kind === 'dsh-source'
+            ? sourceTarget(record.target, sourceBaseRevision, targetLabel)
+            : npmTarget(record.target, targetLabel))
+        : npmTarget(record.target, targetLabel);
+    if (scope === 'third-party') {
+        return {
+            id,
+            scope,
+            dsh,
+            file,
+            retireWhen,
+            upstreamUrl: string(record.upstreamUrl, label + '.upstreamUrl'),
+            target,
+        };
+    }
+    return { id, scope, dsh, file, retireWhen, target };
+}
+/**
+ * Read and validate the embedded patch set from an installed distribution.
+ * @param distributionDirectory - installed `@sparkelf/dsh-plus` directory.
+ * @param manifest - its parsed package manifest.
+ * @returns the ordered Plus entries, third-party entries, and the exact source base.
+ */
+export function readPatchSet(distributionDirectory, manifest) {
+    const plus = object(manifest.dshPlus, 'dshPlus');
+    const sourceBase = object(plus.sourceBase, 'dshPlus.sourceBase');
+    const sourceBaseRevision = string(sourceBase.revision, 'dshPlus.sourceBase.revision');
+    const declaration = object(plus.patchSet, 'dshPlus.patchSet');
+    if (declaration.formatVersion !== 1)
+        throw new Error('dshPlus.patchSet.formatVersion must be 1');
+    if (!Array.isArray(declaration.entries) || declaration.entries.length === 0) {
+        throw new Error('dshPlus.patchSet.entries must be a non-empty array');
+    }
+    const entries = declaration.entries.map((value, index) => entry(value, 'plus', sourceBaseRevision, distributionDirectory, 'dshPlus.patchSet.entries[' + String(index) + ']'));
+    const thirdPartyRaw = plus.thirdPartyPatches;
+    const thirdParty = thirdPartyRaw === undefined
+        ? []
+        : (Array.isArray(thirdPartyRaw)
+            ? thirdPartyRaw.map((value, index) => entry(value, 'third-party', sourceBaseRevision, distributionDirectory, 'dshPlus.thirdPartyPatches[' + String(index) + ']'))
+            : (() => { throw new Error('dshPlus.thirdPartyPatches must be an array'); })());
+    const ids = new Set();
+    for (const item of [...entries, ...thirdParty]) {
+        if (ids.has(item.id))
+            throw new Error('duplicate patch entry id: ' + item.id);
+        ids.add(item.id);
+    }
+    return { entries, thirdPartyPatches: thirdParty, sourceBaseRevision };
+}
+//# sourceMappingURL=patch-set.js.map

package/lib/types/standalone-cli.js

@@ -25,6 +25,7 @@ function parseStartOptions(argv) {
     let host = '127.0.0.1';
     let open = true;
     let foreground = false;
+    let edition;
     let capabilities;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
@@ -52,6 +53,14 @@ function parseStartOptions(argv) {
             foreground = true;
             continue;
         }
+        if (token === '--edition') {
+            const value = argv[index + 1];
+            if (value === undefined || value === '')
+                throw new Error('--edition requires a value');
+            edition = value;
+            index += 1;
+            continue;
+        }
         if (token === '--capabilities') {
             const value = argv[index + 1];
             if (value === undefined)
@@ -73,7 +82,7 @@ function parseStartOptions(argv) {
         }
         throw new Error('unknown option: ' + String(token));
     }
-    return { port, host, open, foreground, capabilities };
+    return { port, host, open, foreground, edition, capabilities };
 }
 /**
  * Resolve a stated capability selection.
@@ -157,6 +166,54 @@ function runForeground(entry, profileName, port, host, open) {
     const result = spawnSync(process.execPath, args, { stdio: 'inherit' });
     return result.status ?? 1;
 }
+/** Parse the install command's edition selection. */
+function parseInstallOptions(argv) {
+    let edition;
+    let profile;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--edition') {
+            const value = argv[index + 1];
+            if (value === undefined || value === '')
+                throw new Error('--edition requires a value');
+            edition = value;
+            index += 1;
+            continue;
+        }
+        if (token === '--profile') {
+            const value = argv[index + 1];
+            if (value === undefined || value === '')
+                throw new Error('--profile requires a value');
+            profile = value;
+            index += 1;
+            continue;
+        }
+        throw new Error('unknown option: ' + String(token));
+    }
+    if (edition === undefined)
+        throw new Error('install requires --edition personal or --edition team');
+    return { edition, profile };
+}
+/**
+ * Install one edition's package manifest into the profile.
+ *
+ * The profile's `package.json` is the install artifact; there is no separate standalone
+ * package. A later `start` uses the same manifest, so changing the edition is a new
+ * install rather than a second product.
+ *
+ * @param argv - arguments after `install`.
+ * @returns the process exit code.
+ */
+function install(argv) {
+    const { edition, profile } = parseInstallOptions(argv);
+    const base = resolvePaths(declarationAnchor());
+    const paths = profile === undefined
+        ? base
+        : { ...base, profileName: profile, profileDirectory: join(base.home, 'profiles', profile) };
+    ensureProfile(paths, installationRoot(), edition);
+    console.log('Installed the ' + edition + ' edition into ' + paths.profileDirectory);
+    return 0;
+}
 async function start(argv) {
     const options = parseStartOptions(argv);
     const anchor = installationAnchor();
@@ -202,10 +259,12 @@ async function start(argv) {
         }
         console.log('pnpm installed.');
     }
-    const created = ensureProfile(paths, installationRoot());
+    const created = ensureProfile(paths, installationRoot(), options.edition);
     console.log(created
         ? 'Created the ' + paths.profileName + ' profile at ' + paths.profileDirectory
         : 'Using the existing ' + paths.profileName + ' profile');
+    if (options.edition !== undefined)
+        console.log('Edition: ' + options.edition);
     // The profile symlinks the consumer's packages, so a patch lands on the installed
     // copy the launcher loads. A reinstall restores the published bytes, which is why
     // this runs on every start rather than only when the profile was created.
@@ -581,6 +640,30 @@ async function doctor() {
         ? 'capabilities: ' + (actual.mounted.length === 0 ? '(none enabled)' : actual.mounted.join(', '))
         : 'capabilities disagree with ' + CAPABILITY_RECORD + ': ' + drifted.map(capability => capability.id).join(', ')
             + ' (run dsh-plus capabilities)');
+    const profileManifestPath = join(paths.profileDirectory, 'package.json');
+    if (existsSync(profileManifestPath)) {
+        const profileManifest = JSON.parse(readFileSync(profileManifestPath, 'utf8'));
+        const editionId = profileManifest.dsh?.profile?.plusEdition;
+        if (editionId !== undefined) {
+            const distribution = readDistributionProfile(paths.distributionDirectory);
+            const edition = distribution.editions[editionId];
+            if (edition === undefined) {
+                check(false, 'edition "' + editionId + '" is not declared by this distribution');
+            }
+            else {
+                const bundles = new Set(profileManifest.dsh?.profile?.bundles ?? []);
+                const missingBundles = edition.bundles.filter(bundle => !bundles.has(bundle));
+                const packageNames = Object.keys(edition.packages);
+                const missingPackages = packageNames.filter(name => !existsSync(join(paths.profileDirectory, 'node_modules', ...name.split('/'), 'package.json')));
+                check(missingBundles.length === 0, 'edition ' + editionId + ': ' + String(edition.bundles.length - missingBundles.length) + '/'
+                    + String(edition.bundles.length) + ' bundles mounted'
+                    + (missingBundles.length === 0 ? '' : ' (missing ' + missingBundles.join(', ') + ')'));
+                check(missingPackages.length === 0, 'edition ' + editionId + ': ' + String(packageNames.length - missingPackages.length) + '/'
+                    + String(packageNames.length) + ' packages installed'
+                    + (missingPackages.length === 0 ? '' : ' (missing ' + missingPackages.join(', ') + ')'));
+            }
+        }
+    }
     console.log(failures === 0 ? 'No problems found.' : String(failures) + ' problem(s) found.');
     return failures === 0 ? 0 : 1;
 }
@@ -588,6 +671,7 @@ const USAGE = [
     'Usage: dsh-plus <command> [options]',
     '',
     'Commands:',
+    '  install       install an edition package manifest into the profile',
     '  start         start the server (first run creates the profile)',
     '  stop          stop the server',
     '  status        report whether the server is running',
@@ -600,6 +684,11 @@ const USAGE = [
     '  --host <h>     interface to bind (default 127.0.0.1)',
     '  --no-open      do not open a browser',
     '  --foreground   run in this terminal instead of in the background',
+    '  --edition <id> install the named edition manifest (personal or team)',
+    '',
+    'install options:',
+    '  --edition <id>  package manifest to install (personal or team)',
+    '  --profile <n>   profile name to install into (default: this installation)',
     '',
     'capabilities options:',
     '  --enable <ids>   enable the comma-separated capability ids',
@@ -622,6 +711,8 @@ export async function runStandaloneCli(argv) {
         console.log(USAGE);
         return 0;
     }
+    if (command === 'install')
+        return install(rest);
     if (command === 'start')
         return await start(rest);
     if (command === 'stop')

package/lib/types/standalone-profile.d.ts

@@ -93,12 +93,18 @@ export declare function isWithin(candidate: string, parent: string, platform?: N
  */
 export declare function resolveDistributionDirectory(anchor: string): string;
 /** The reviewed bundle order and pins the installed distribution declares. */
+export interface EditionComposition {
+    readonly label: string;
+    readonly bundles: readonly string[];
+    readonly packages: Readonly<Record<string, string>>;
+}
 export declare function readDistributionProfile(distributionDirectory: string): {
     readonly name: string;
     readonly bundles: readonly string[];
     readonly dependencies: Readonly<Record<string, string>>;
     readonly allowBuilds: Readonly<Record<string, boolean>>;
     readonly overrides: Readonly<Record<string, string>>;
+    readonly editions: Readonly<Record<string, EditionComposition>>;
     readonly dshRange: string;
     readonly version: string;
 };
@@ -191,9 +197,10 @@ export declare function resolvePaths(anchor: string, env?: NodeJS.ProcessEnv): S
  *
  * @param paths - resolved standalone paths.
  * @param consumerDirectory - directory whose `node_modules` holds the installed packages.
+ * @param edition - edition id whose package list to install, or undefined for the default.
  * @returns whether this call created the manifest.
  */
-export declare function ensureProfile(paths: StandalonePaths, consumerDirectory: string): boolean;
+export declare function ensureProfile(paths: StandalonePaths, consumerDirectory: string, edition?: string): boolean;
 /**
  * Apply the reviewed npm-target patches to the profile's installed packages.
  *