@sparkelf/dsh-plus 0.2.1-rc.2.2 → 0.2.2-alpha.2.1

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,42 @@ 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;
+    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;
+        }
+        throw new Error('unknown option: ' + String(token));
+    }
+    if (edition === undefined)
+        throw new Error('install requires --edition personal or --edition team');
+    return { edition };
+}
+/**
+ * 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 } = parseInstallOptions(argv);
+    const paths = resolvePaths(declarationAnchor());
+    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 +247,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.
@@ -588,6 +635,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 +648,10 @@ 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)',
     '',
     'capabilities options:',
     '  --enable <ids>   enable the comma-separated capability ids',
@@ -622,6 +674,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.
  *

package/lib/types/standalone-profile.js

@@ -14,6 +14,7 @@ import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { parseDocument } from 'yaml';
+import { readPatchSet } from "./patch-set.js";
 /** Profile name a standalone installation owns when its package declares none. */
 export const STANDALONE_PROFILE = 'plus';
 /**
@@ -97,6 +98,12 @@ function requireStringArray(value, label) {
         throw new Error(label + ' must be a string array');
     return value;
 }
+/** Read one non-empty string field. */
+function requireString(value, label) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(label + ' must be a non-empty string');
+    return value;
+}
 /** Resolve the DSH home, honouring the environment override the launcher itself reads. */
 export function resolveHome(env = process.env) {
     const configured = env.DSH_HOME;
@@ -158,19 +165,12 @@ export function resolveDistributionDirectory(anchor) {
     }
     throw new Error('@sparkelf/dsh-plus resolved outside ' + resolve(dirname(anchor)) + ' (found ' + resolved + '); run this command from the directory that installed it');
 }
-/** The reviewed bundle order and pins the installed distribution declares. */
 export function readDistributionProfile(distributionDirectory) {
     const manifest = requireRecord(JSON.parse(readFileSync(join(distributionDirectory, 'package.json'), 'utf8')), 'Plus distribution manifest');
     const plus = requireRecord(manifest.dshPlus, 'dshPlus');
     const profile = requireRecord(plus.profile, 'dshPlus.profile');
-    const rawDependencies = requireRecord(profile.dependencies, 'dshPlus.profile.dependencies');
+    const dependencies = requireDependencyMap(requireRecord(profile.dependencies, 'dshPlus.profile.dependencies'), 'dshPlus.profile.dependencies');
     const rawAllowBuilds = requireRecord(profile.allowBuilds, 'dshPlus.profile.allowBuilds');
-    const dependencies = {};
-    for (const [name, spec] of Object.entries(rawDependencies)) {
-        if (typeof spec !== 'string' || spec === '')
-            throw new Error('dshPlus.profile.dependencies.' + name + ' must be a non-empty string');
-        dependencies[name] = spec;
-    }
     const allowBuilds = {};
     for (const [name, allowed] of Object.entries(rawAllowBuilds)) {
         if (typeof allowed !== 'boolean')
@@ -189,6 +189,16 @@ export function readDistributionProfile(distributionDirectory) {
             throw new Error('dshPlus.profile.overrides.' + name + ' must be a non-empty string');
         overrides[name] = spec;
     }
+    const editions = {};
+    const rawEditions = plus.editions === undefined ? {} : requireRecord(plus.editions, 'dshPlus.editions');
+    for (const [id, value] of Object.entries(rawEditions)) {
+        const edition = requireRecord(value, 'dshPlus.editions.' + id);
+        editions[id] = {
+            label: requireString(edition.label, 'dshPlus.editions.' + id + '.label'),
+            bundles: requireStringArray(edition.bundles, 'dshPlus.editions.' + id + '.bundles'),
+            packages: requireDependencyMap(requireRecord(edition.packages, 'dshPlus.editions.' + id + '.packages'), 'dshPlus.editions.' + id + '.packages'),
+        };
+    }
     const compatibility = requireRecord(plus.compatibility, 'dshPlus.compatibility');
     return {
         name: String(manifest.name),
@@ -196,10 +206,21 @@ export function readDistributionProfile(distributionDirectory) {
         dependencies,
         allowBuilds,
         overrides,
+        editions,
         dshRange: String(compatibility.dsh),
         version: String(manifest.version),
     };
 }
+/** Read one package-name-to-spec map, rejecting empty entries. */
+function requireDependencyMap(value, label) {
+    const dependencies = {};
+    for (const [name, spec] of Object.entries(value)) {
+        if (typeof spec !== 'string' || spec === '')
+            throw new Error(label + '.' + name + ' must be a non-empty string');
+        dependencies[name] = spec;
+    }
+    return dependencies;
+}
 /**
  * Give the profile its own installed tree, built from the distribution's declarations.
  *
@@ -250,6 +271,9 @@ function installWithRegistryFallback(paths) {
             cwd: paths.profileDirectory,
             stdio: 'inherit',
             shell: process.platform === 'win32',
+            // A registry that accepts the connection but never answers would otherwise hold the
+            // first start for pnpm's full retry budget before the fallback got a chance.
+            timeout: 5 * 60_000,
         });
         if (result.error !== undefined)
             throw result.error;
@@ -430,12 +454,32 @@ export function resolvePaths(anchor, env = process.env) {
  *
  * @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 function ensureProfile(paths, consumerDirectory) {
+export function ensureProfile(paths, consumerDirectory, edition) {
     const manifestPath = join(paths.profileDirectory, 'package.json');
     const distribution = readDistributionProfile(paths.distributionDirectory);
+    const composition = edition === undefined ? undefined : distribution.editions[edition];
+    if (edition !== undefined && composition === undefined) {
+        const offered = Object.keys(distribution.editions);
+        throw new Error('unknown edition "' + edition + '"; this release offers '
+            + (offered.length === 0 ? '(none)' : offered.join(', ')));
+    }
+    const editionPackages = composition?.packages ?? {};
+    const editionBundles = composition?.bundles ?? distribution.bundles;
     if (existsSync(manifestPath)) {
+        // A selected edition is an explicit install choice, so its packages and bundle order
+        // replace the profile's rather than being ignored. Other profile decisions stay.
+        if (composition !== undefined) {
+            const manifest = requireRecord(JSON.parse(readFileSync(manifestPath, 'utf8')), 'Plus profile manifest');
+            manifest.dependencies = { ...manifest.dependencies, ...editionPackages };
+            manifest.dsh = {
+                ...manifest.dsh,
+                profile: { ...manifest.dsh?.profile, bundles: [...editionBundles] },
+            };
+            writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+        }
         // The workspace carries decisions the distribution owns — overrides and the build
         // script allowlist — and a distribution release changes them. Rewriting on every
         // start is what lets an upgraded installation receive the new values; a profile
@@ -456,10 +500,11 @@ export function ensureProfile(paths, consumerDirectory) {
             // fails at load with a module the launcher would have carried.
             '@deepseek-ai/dsh': distribution.dshRange,
             ...distribution.dependencies,
+            ...editionPackages,
         },
         dsh: {
             profile: {
-                bundles: distribution.bundles,
+                bundles: [...editionBundles],
                 patchReload: 'live',
             },
         },
@@ -536,34 +581,20 @@ function git(root, args, acceptFailure = false) {
  */
 export function applyProfileNpmPatches(distributionDirectory, profileDirectory) {
     const manifest = requireRecord(JSON.parse(readFileSync(join(distributionDirectory, 'package.json'), 'utf8')), 'Plus distribution manifest');
-    const plus = requireRecord(manifest.dshPlus, 'dshPlus');
-    const names = plus.patchPackages;
-    if (!Array.isArray(names))
-        throw new Error('dshPlus.patchPackages must be an array');
+    const patchSet = readPatchSet(distributionDirectory, manifest);
     const applied = [];
-    for (const value of names) {
-        if (typeof value !== 'string' || value === '')
-            throw new Error('dshPlus.patchPackages entries must be non-empty strings');
-        const patchPackage = resolveInstalledPackage(distributionDirectory, value);
-        const declaration = requireRecord(patchPackage.manifest.dshPatch, value + ' dshPatch');
-        const variants = declaration.variants;
-        if (!Array.isArray(variants))
-            throw new Error(value + ' dshPatch.variants must be an array');
-        for (const entry of variants) {
-            const variant = requireRecord(entry, value + ' variant');
-            const target = requireRecord(variant.target, value + ' variant target');
-            // Only npm targets reach an installed package; a source target needs the
-            // official checkout, which a standalone installation does not have.
-            if (target.kind !== 'npm')
-                continue;
-            const targetName = String(target.name);
-            const patched = resolveInstalledPackage(profileDirectory, targetName);
-            const file = resolve(patchPackage.directory, String(variant.file));
-            if (git(patched.directory, ['apply', '--reverse', '--check', file], true) !== undefined)
-                continue;
-            git(patched.directory, ['apply', file]);
-            applied.push(value + ' -> ' + targetName);
-        }
+    for (const entry of [...patchSet.entries, ...patchSet.thirdPartyPatches]) {
+        // Only npm targets reach an installed package; a source target needs the
+        // official checkout, which a standalone installation does not have.
+        if (entry.target.kind !== 'npm')
+            continue;
+        const targetName = entry.target.name;
+        const patched = resolveInstalledPackage(profileDirectory, targetName);
+        const file = resolve(distributionDirectory, entry.file);
+        if (git(patched.directory, ['apply', '--reverse', '--check', file], true) !== undefined)
+            continue;
+        git(patched.directory, ['apply', file]);
+        applied.push(entry.id + ' -> ' + targetName);
     }
     return applied;
 }
@@ -575,7 +606,22 @@ function resolveInstalledPackage(from, packageName) {
         manifestPath = requireFrom.resolve(packageName + '/package.json');
     }
     catch {
-        throw new Error(packageName + ' is not installed under ' + from);
+        // Some packages do not export `./package.json`; resolve the entry module instead and walk
+        // up to the directory that holds the manifest.
+        let directory;
+        try {
+            directory = dirname(requireFrom.resolve(packageName));
+        }
+        catch {
+            throw new Error(packageName + ' is not installed under ' + from);
+        }
+        while (!existsSync(resolve(directory, 'package.json'))) {
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error(packageName + ' has no resolvable package manifest under ' + from);
+            directory = parent;
+        }
+        manifestPath = resolve(directory, 'package.json');
     }
     const manifest = requireRecord(JSON.parse(readFileSync(manifestPath, 'utf8')), packageName + ' manifest');
     return { name: packageName, version: String(manifest.version), directory: dirname(manifestPath), manifest };