dshmarket 1.58.0 → 1.59.0

package/lib/check.js

@@ -32,6 +32,15 @@ import { JSON_SCHEMA, Type, load } from 'js-yaml';
 import { findDshInstallDir } from './dsh-install.js';
 import { resolveDshHome } from './home-paths.js';
 import { INBOX_BUNDLES, readBundleRules, suggestOrder, validateOrder } from './order.js';
+// Electron's app.asar packages can be loadable by the host while invisible to
+// filesystem probes made from a profile plugin. Keep this fallback limited to
+// packages confirmed to ship with the official Desktop app, and only use it
+// when the install anchor is the packaged app.
+const DESKTOP_HOST_BUNDLES = new Set(['@deepseek-ai/dsh-experimental-agent-team-profile']);
+const DESKTOP_HOST_LOADERS = new Set(['@deepseek-ai/dsh-mcp-client']);
+function isPackagedDesktopInstall(dshInstallDir) {
+    return dshInstallDir !== null && /[/\\]app\.asar[/\\]dsh$/iu.test(dshInstallDir);
+}
 export { findDshInstallDir } from './dsh-install.js';
 /** js-yaml dialect for `!!js` scalars — identical to dsh-app-boot's entryListSchema. */
 const jsExpr = new Type('tag:yaml.org,2002:js', {
@@ -702,13 +711,15 @@ function lockfileCoreVersions(profileDir) {
  */
 export function buildBundleLayers(profileDirectory, bundleNames, specs, dshInstallDir) {
     const bundles = bundleNames.map((name) => {
+        const hostProvided = INBOX_BUNDLES.has(name)
+            || (isPackagedDesktopInstall(dshInstallDir) && DESKTOP_HOST_BUNDLES.has(name));
         // The real loader gives the DSH installation first refusal for in-box
         // bundles. Desktop keeps that installation private from plugins, so a
         // DIRECT profile-local copy with the same official name is only a stale
         // shadow, never evidence for the layer the running host loaded (#371).
         // Keep walking the profile anchor's parent search paths: Desktop heals an
         // authoritative host fallback at <profiles>/node_modules.
-        const ignoredProfilePackage = dshInstallDir === null && INBOX_BUNDLES.has(name)
+        const ignoredProfilePackage = dshInstallDir === null && hostProvided
             ? join(profileDirectory, 'node_modules', name)
             : undefined;
         const anchors = [
@@ -729,7 +740,7 @@ export function buildBundleLayers(profileDirectory, bundleNames, specs, dshInsta
         const layer = {
             name,
             source: specs[name] ?? '(not a direct dependency)',
-            kind: INBOX_BUNDLES.has(name) ? 'official' : 'community',
+            kind: hostProvided ? 'official' : 'community',
             directory,
             patchPath: null,
             patchPaths: [],
@@ -748,7 +759,7 @@ export function buildBundleLayers(profileDirectory, bundleNames, specs, dshInsta
             // fatal verdict and rolled back a good update (#369) — while `dsh
             // --dump-config` on the same profile exited 0. Unknown has to read as
             // unknown; the profile's own bundles are still judged normally.
-            if (INBOX_BUNDLES.has(name)) {
+            if (hostProvided) {
                 layer.error = null;
                 layer.unresolvedInbox = true;
                 return layer;
@@ -963,6 +974,15 @@ export function analyzeProfile(profileDirectory, options = {}) {
     for (const { row, packageName } of candidates.values()) {
         if (profilePackageInstalled(profileDirectory, packageName))
             continue;
+        // Official Electron keeps built-in packages beside app.asar, not inside
+        // the writable profile. The loader can resolve them from this anchor.
+        if (dshInstall !== null && core.has(packageName)
+            && resolvePackageDir(join(dshInstall, 'package.json'), packageName) !== null)
+            continue;
+        if (isPackagedDesktopInstall(dshInstall) && DESKTOP_HOST_LOADERS.has(packageName)) {
+            warnings.push(`${row.layer}: bundled Desktop loader ${packageName} could not be independently resolved from app.asar`);
+            continue;
+        }
         const message = `${row.layer}: loader package ${packageName} is not installed in the profile`;
         if (row.activation === 'required')
             errors.push(`${message} — the profile will fail to boot`);

package/lib/index.js

@@ -2,7 +2,9 @@
  * dsh-market host entry: mounts the market's HTTP routes once the profile
  * composes the webServer and shell services.
  */
+import { dirname, isAbsolute } from 'node:path';
 import { createDesktopPluginRuntime, setHostPackageManager } from './dsh-cli.js';
+import { createOfficialDesktopRuntime } from './official-desktop.js';
 import { isDshProfileName } from './profile.js';
 import { mountMarketRoutes } from './routes.js';
 import { installDesktopMarketSettings, installMarketSettings } from './settings.js';
@@ -98,6 +100,42 @@ export function apply(ctx, config) {
             // its name, and never with somebody else's.
             const profileContext = ctx.get('profileContext');
             const launched = launchedProfile(profileContext);
+            // The official Electron app owns this profile. Its CLI explicitly
+            // refuses `--profile desktop`; use the app's pluginManager service.
+            // Looking it up at request time lets the market mount before the
+            // service while still failing closed if it never becomes available.
+            // The dsh CLI refuses a profile by NAME — `profile.toLowerCase() ===
+            // "desktop"` (@deepseek-ai/dsh 0.1.7-alpha.2) — so a launched profile
+            // with that name can never be changed through `dsh plugin`, whatever
+            // the install layout. Detection follows the same rule rather than the
+            // app.asar anchor shape an earlier draft keyed on: the official desktop
+            // host is not published, its layout could not be checked, and a host
+            // that missed the anchor test fell straight back to the CLI and failed
+            // every install (#702). A third-party shell announces itself through
+            // `desktopProfiles`, and this whole block runs only when that service
+            // is absent, so this never takes a third-party shell's profile.
+            const officialElectron = launched !== undefined && launched.name.toLowerCase() === 'desktop';
+            if (officialElectron && config?.profile === undefined) {
+                const runtime = createOfficialDesktopRuntime(() => hostCtx.get('pluginManager'), launched.name, launched.dir);
+                const resolved = {
+                    profile: launched.name,
+                    profileDirectory: launched.dir,
+                    desktopHost: true,
+                    allowRestart: false,
+                    maxSnapshots: config?.maxSnapshots,
+                    ...(typeof profileContext?.installAnchor === 'string' && isAbsolute(profileContext.installAnchor)
+                        ? { dshInstallDir: dirname(profileContext.installAnchor) } : {}),
+                };
+                installDesktopMarketSettings(ctx);
+                host.effect(() => {
+                    const disposeRoutes = mountMarketRoutes(host, resolved, runtime, agentsLookupOf(ctx));
+                    return async () => {
+                        disposeRoutes();
+                        await runtime.dispose();
+                    };
+                }, 'dsh-market: official Desktop routes and package operations');
+                return;
+            }
             // The launcher's own package manager, when it publishes one. Registering
             // it here covers both the pnpm probe and every install spawn, since the
             // invocation's environment reaches both through spawnEnv (#653).

package/lib/install.js

@@ -7,7 +7,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { classifyPnpmFailure, HOST_NAMESPACE_RE } from './pnpm-compat.js';
-import { conflictingEntryIds, dropFromManifest, hasDshManifest, hasLoadableEntry, pluginSubdirs, profileDir, readInstalled, readManifestDeps, readProfileBundles } from './profile.js';
+import { conflictingEntryIds, dropFromManifest, hasDshManifest, hasLoadableEntry, pluginSubdirs, profileDir, readInstalled, readManifestDeps, readProfileBundles, dropUnparseableBuildKeys } from './profile.js';
 import { logEvent } from './log.js';
 import { cleanOrphanedStore } from './store.js';
 /**
@@ -113,7 +113,19 @@ export async function withHoistRecovery(run, profile, pluginArgs, profileDirecto
     const ok = (r) => r.exitCode === 0 && !r.timedOut && !r.cancelled;
     if (!ok(result) && !result.cancelled) {
         const failure = classifyPnpmFailure(`${result.stderr}\n${result.stdout}`, result.exitCode);
-        if (failure?.code === 'hoist-pattern-diff') {
+        if (failure?.code === 'unparseable-build-key') {
+            // The profile's own allowBuilds block is what fails, so no retry of the
+            // same command can pass until it is repaired (#698). Drop only the
+            // source-form keys this pnpm cannot parse — bare names stay, and on
+            // these versions a bare name is what authorizes a git dependency — then
+            // run the command once more.
+            const removed = dropUnparseableBuildKeys(profile, profileDirectory);
+            if (removed.length > 0) {
+                logEvent('warn', 'install', `this pnpm cannot parse git-source allowBuilds keys; removed ${removed.join(', ')} from pnpm-workspace.yaml and retrying once (#698)`);
+                result = await run(profile, pluginArgs);
+            }
+        }
+        else if (failure?.code === 'hoist-pattern-diff') {
             logEvent('warn', 'install', `modules dir was built by a different pnpm major — rebuilding (pnpm install) and retrying once`);
             // --no-frozen-lockfile: the market runs pnpm with CI=true (TTY hangs),
             // where a lockfile written by the old major would otherwise be refused.
@@ -411,6 +423,30 @@ export function parsePrepareNotAllowed(stdout, stderr) {
     const at = raw.lastIndexOf('@');
     return at > 0 ? raw.slice(0, at) : raw;
 }
+/**
+ * The allowBuilds key pnpm itself printed for a prepare refusal, when it
+ * printed one (#698).
+ *
+ * pnpm 11 ends ERR_PNPM_GIT_DEP_PREPARE_NOT_ALLOWED with the exact line to
+ * add — measured on 11.8.0 against the reported plugin:
+ *
+ *     For example:
+ *     allowBuilds:
+ *       @dsh-external/dsh-super-injector@https://codeload.github.com/…/tar.gz/<sha>: true
+ *
+ * For a TRANSITIVE git dependency that key is the only knowledge anyone has
+ * of its source: the package is in neither node_modules, package.json nor
+ * the catalog. pnpm 10 prints an `onlyBuiltDependencies` example with the
+ * bare name instead, and gets null here — the bare name is what it needs.
+ *
+ * @returns the key, or null when the output carries no allowBuilds example.
+ */
+export function parsePrepareKey(stdout, stderr) {
+    // ndjson carries this inside a JSON string: quotes and newlines escaped.
+    const text = `${stdout}\n${stderr}`.replace(/\\"/g, '"').replace(/\\n/g, '\n');
+    const m = /For example:\s*\n\s*allowBuilds:\s*\n[ \t]+("?)([^\s"]+)\1:\s*true/.exec(text);
+    return m === null ? null : m[2];
+}
 /**
  * Package names pnpm reported as having their build scripts ignored
  * ("Ignored build scripts: esbuild, koffi."). Empty when none.

package/lib/official-desktop.js

@@ -0,0 +1,135 @@
+/** The official Electron profile is owned by DSH's in-process plugin manager. */
+import { randomUUID } from 'node:crypto';
+import { progress, TARGET_RE } from './dsh-cli.js';
+/**
+ * What a user can actually do when the market cannot perform an operation on
+ * the official Desktop profile: the app's own Plugins page runs the same
+ * managed pipeline. Bilingual, because it is read in the operations panel.
+ */
+export const OFFICIAL_PAGE_HINT = '官方桌面客户端的这个插件操作需要在「设置 → 插件」里完成；市场无法通过命令行修改桌面端的 profile。 / On the official desktop app, do this from Settings → Plugins; the market cannot change the desktop profile through the command line.';
+function failure(message, exitCode = 1) {
+    return { exitCode, timedOut: false, stdout: '', stderr: message, cancelled: false };
+}
+function detail(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (error === undefined)
+        return 'plugin manager did not explain the failure';
+    return JSON.stringify(error);
+}
+/** Never fall back to `dsh plugin --profile desktop`: that CLI is forbidden. */
+export function createOfficialDesktopRuntime(managerLookup, profileName, _profileDirectory) {
+    let disposed = false;
+    let active;
+    const runPlugin = (profile, argv) => {
+        if (disposed)
+            return Promise.resolve(failure('official desktop plugin runtime is disposed', 127));
+        if (profile !== profileName)
+            return Promise.resolve(failure('refusing to change a different profile', 127));
+        if (active !== undefined)
+            return Promise.resolve({ ...failure('another plugin operation is running', 127), busy: true });
+        const manager = managerLookup();
+        if (manager === undefined
+            || typeof manager.installBundle !== 'function'
+            || typeof manager.removeBundle !== 'function'
+            || typeof manager.cancelInstall !== 'function') {
+            return Promise.resolve(failure(OFFICIAL_PAGE_HINT, 127));
+        }
+        // Market sends pnpm argv. Only operations representable by the official
+        // manager are accepted; silently dropping pnpm flags would change intent.
+        const [command, target, ...extra] = argv;
+        if (extra.length !== 0 || typeof target !== 'string' || !TARGET_RE.test(target)) {
+            return Promise.resolve(failure('this desktop operation is not supported by the official plugin manager', 127));
+        }
+        const spec = target;
+        // Only `add` and `remove` map onto the manager. `update` reached here
+        // only for the #564 in-place re-resolve of a floating git spec; turning
+        // it into `name@latest` (as a first draft did) would cross the installed
+        // range and ignore the release channel, which is a different operation.
+        if (command !== 'add' && command !== 'remove') {
+            return Promise.resolve(failure(OFFICIAL_PAGE_HINT, 127));
+        }
+        const requestId = command === 'remove' ? undefined : randomUUID();
+        progress.active = true;
+        progress.target = target;
+        progress.startedAt = Date.now();
+        progress.lastLine = 'Using the official desktop plugin manager';
+        progress.error = null;
+        progress.cancelling = false;
+        let operation;
+        try {
+            operation = command === 'remove'
+                ? manager.removeBundle(target)
+                : manager.installBundle(spec, { requestId });
+        }
+        catch (error) {
+            progress.active = false;
+            return Promise.resolve(failure(detail(error), 127));
+        }
+        const current = { requestId, cancelled: false, done: Promise.resolve(failure('not started')) };
+        active = current;
+        current.done = operation.then((result) => {
+            // `overridden` is a change the manager KEPT (`changed: true`) whose live
+            // state differs because another layer — a user patch — overrides it.
+            // It is not a failed install: reporting it as one sent the update route
+            // into a rollback of a change the manager had already kept.
+            const ok = result.application === 'applied'
+                || result.application === 'restart-required'
+                || result.application === 'overridden';
+            const output = [
+                result.packageResult?.output ?? '',
+                result.application === 'overridden' ? 'the plugin manager kept this change, but another layer overrides whether it is enabled' : '',
+            ].filter(Boolean).join('\n');
+            const message = ok ? '' : detail(result.error);
+            if (!ok)
+                progress.error = message;
+            return {
+                // `||`, not `??`: a failure at stage `enable` follows a SUCCESSFUL
+                // pnpm step, so packageResult.exitCode is 0 there — and every route
+                // reads exit 0 as success. A failed application must never be 0.
+                exitCode: ok ? 0 : (result.packageResult?.exitCode || 1),
+                timedOut: false,
+                stdout: output,
+                stderr: message,
+                cancelled: current.cancelled || result.application === 'cancelled',
+            };
+        }, (error) => {
+            const message = detail(error);
+            progress.error = message;
+            return failure(message, 127);
+        }).finally(() => {
+            progress.active = false;
+            progress.cancelling = false;
+            if (active === current)
+                active = undefined;
+        });
+        return current.done;
+    };
+    return {
+        runPlugin,
+        probePnpm: async () => managerLookup() !== undefined,
+        provisionPnpm: async () => ({ ok: managerLookup() !== undefined, hint: 'Use the official desktop plugin manager' }),
+        cancelActive: () => {
+            if (active?.requestId === undefined)
+                return false;
+            active.cancelled = true;
+            progress.cancelling = true;
+            const manager = managerLookup();
+            if (manager !== undefined)
+                void manager.cancelInstall(active.requestId).catch(() => { });
+            return true;
+        },
+        supportsExactRollbackTarget: target => TARGET_RE.test(target),
+        dispose: async () => {
+            disposed = true;
+            if (active?.requestId !== undefined) {
+                const manager = managerLookup();
+                if (manager !== undefined)
+                    void manager.cancelInstall(active.requestId).catch(() => { });
+            }
+            await active?.done;
+        },
+    };
+}

package/lib/pnpm-compat.js

@@ -313,6 +313,22 @@ export function classifyPnpmFailure(output, exitCode) {
     // pnpm's FETCHER, before anything lands in node_modules — so the package
     // the user must approve is not installed yet, and pnpm's own hint names a
     // commit-pinned codeload URL that changes on every push.
+    // #698: pnpm 10.26+ and 11.0–11.5 read an allowBuilds key as
+    // `name@<version union>`, so a git or archive source there fails the WHOLE
+    // workspace file — every pnpm command in the profile, not the one plugin.
+    // Named separately from any install failure because the cure is in the
+    // profile's own pnpm-workspace.yaml, which withHoistRecovery repairs.
+    {
+        const found = /ERR_PNPM_INVALID_VERSION_UNION[\s\S]*?Found: \\?"([^"\\]+)\\?"/.exec(output);
+        if (found !== null && /@(?:git\+|https?:)/.test(found[1].slice(1))) {
+            return {
+                code: 'unparseable-build-key',
+                recoverable: false,
+                pkg: found[1],
+                message: `这个版本的 pnpm 读不懂 allowBuilds 里的 git 来源键（${found[1]}），整个 profile 的包操作都会因此失败 / this pnpm version cannot read a git-source key in allowBuilds (${found[1]}), which fails every package operation in the profile`,
+            };
+        }
+    }
     if (output.includes('ERR_PNPM_GIT_DEP_PREPARE_NOT_ALLOWED')) {
         return {
             code: 'git-prepare-not-allowed',

package/lib/profile.js

@@ -261,6 +261,19 @@ export function readInstalledVersion(profile, name, explicitDir) {
         return null;
     }
 }
+/**
+ * The `name` in the package.json of the directory a dependency is installed
+ * under, or null. DSH Desktop requires it to equal the dependency key (#694).
+ */
+export function readInstalledPackageName(profile, name, explicitDir) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(profileDir(profile, explicitDir), 'node_modules', name, 'package.json'), 'utf8'));
+        return typeof manifest.name === 'string' ? manifest.name : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** The installed package manifest, or null when absent or malformed. */
 export function readInstalledManifest(profile, name, explicitDir) {
     try {
@@ -1025,26 +1038,8 @@ function quoteYamlKey(key) {
     }
     return key;
 }
-/**
- * Allow the given packages' build scripts in the profile's
- * pnpm-workspace.yaml `allowBuilds` block (the key dsh profiles use),
- * merging with existing entries and leaving the rest of the yaml intact.
- * (#6 by @qichuang321.)
- * @returns every package now allowed.
- */
-export function setAllowBuilds(profile, packages, explicitDir) {
-    const file = join(profileDir(profile, explicitDir), 'pnpm-workspace.yaml');
-    let yaml = '';
-    try {
-        yaml = readFileSync(file, 'utf8');
-    }
-    catch { /* created below */ }
-    // `\r?\n`, not `\n`: a CRLF pnpm-workspace.yaml (every Windows editor, and
-    // git with core.autocrlf=true) put a `\r` between `allowBuilds:` and the
-    // newline, so the old pattern never matched an EXISTING block and appended
-    // a second one. Two top-level `allowBuilds:` keys is invalid YAML, and pnpm
-    // then refuses every install in that profile — not just the one that
-    // triggered it (#231 by @MichengAI).
+/** The allowBuilds block(s) of a pnpm-workspace.yaml, read into one map. */
+function readAllowBuildsMap(yaml) {
     const blockRe = /allowBuilds:[ \t]*\r?\n((?:[ \t]+[^\r\n]*\r?\n?)*)/g;
     const map = {};
     // Every block, not just the first: a profile already broken by the bug
@@ -1075,6 +1070,50 @@ export function setAllowBuilds(profile, packages, explicitDir) {
             map[key] = m[2] ?? 'true';
         }
     }
+    return { map, blockRe, blockMatch };
+}
+/** Write `map` back as the file's single allowBuilds block, in its own line endings. */
+function writeAllowBuildsMap(file, yaml, map, blockRe, blockMatch) {
+    // Write back in the file's OWN line ending. Rewriting a CRLF workspace
+    // file with LF would leave it mixed, which is the same class of mess this
+    // fix exists to clean up.
+    const eol = /\r\n/.test(yaml) ? '\r\n' : '\n';
+    const block = Object.entries(map).map(([k, v]) => `  ${quoteYamlKey(k)}: ${v}`).join(eol);
+    const blockText = `allowBuilds:${eol}${block}${eol}`;
+    let next;
+    if (blockMatch === null) {
+        next = `${yaml.replace(/\r?\n?$/, eol)}${blockText}`;
+    }
+    else {
+        // The merged block replaces the first occurrence; any further ones are
+        // the duplicates this bug created and are dropped — their entries are
+        // already folded into `map` above, so nothing is lost.
+        let seen = 0;
+        next = yaml.replace(blockRe, () => (seen++ === 0 ? blockText : ''));
+    }
+    writeFileSync(file, next);
+}
+/**
+ * Allow the given packages' build scripts in the profile's
+ * pnpm-workspace.yaml `allowBuilds` block (the key dsh profiles use),
+ * merging with existing entries and leaving the rest of the yaml intact.
+ * (#6 by @qichuang321.)
+ * @returns every package now allowed.
+ */
+export function setAllowBuilds(profile, packages, explicitDir) {
+    const file = join(profileDir(profile, explicitDir), 'pnpm-workspace.yaml');
+    let yaml = '';
+    try {
+        yaml = readFileSync(file, 'utf8');
+    }
+    catch { /* created below */ }
+    // `\r?\n`, not `\n`: a CRLF pnpm-workspace.yaml (every Windows editor, and
+    // git with core.autocrlf=true) put a `\r` between `allowBuilds:` and the
+    // newline, so the old pattern never matched an EXISTING block and appended
+    // a second one. Two top-level `allowBuilds:` keys is invalid YAML, and pnpm
+    // then refuses every install in that profile — not just the one that
+    // triggered it (#231 by @MichengAI).
+    const { map, blockRe, blockMatch } = readAllowBuildsMap(yaml);
     // What may be written, and nothing else. The allowlist is not a host
     // trust boundary — every key here is derived from the profile's OWN
     // manifest or the curated catalog — it is what stops a caller writing
@@ -1091,7 +1130,13 @@ export function setAllowBuilds(profile, packages, explicitDir) {
     // serves it. Optionally pinned to a commit, which is the form pnpm 11.8.0
     // names for a plain remote. https only: the market installs from https
     // remotes, and an http key would authorize a source it never writes.
-    const GIT_KEY_RE = new RegExp(`^${NAME}@git\\+https://[A-Za-z0-9_.-]+(?::\\d{1,5})?/${SEG}(?:/${SEG})*\\.git(?:#${SHA})?$`);
+    //
+    // The `.git` suffix is optional because pnpm keys the remote exactly as it
+    // was spelled: measured on 12.4.1, a remote installed without `.git`
+    // authorizes under `name@git+…/repo` and NOT under `…/repo.git`, so
+    // requiring the suffix dropped a correctly derived key on its way out, and
+    // appending it would have written one pnpm never reads.
+    const GIT_KEY_RE = new RegExp(`^${NAME}@git\\+https://[A-Za-z0-9_.-]+(?::\\d{1,5})?/${SEG}(?:/${SEG})*(?:\\.git)?(?:#${SHA})?$`);
     // The commit-pinned download a host serves, which is what pnpm below 11.21
     // matches instead (#285): codeload for github, the project archive for
     // gitlab.com and bitbucket.org (#637). Each branch names its host and its
@@ -1105,23 +1150,51 @@ export function setAllowBuilds(profile, packages, explicitDir) {
         if (/^[A-Za-z0-9@/_.-]+$/.test(pkg) || GIT_KEY_RE.test(pkg) || ARCHIVE_KEY_RE.test(pkg))
             map[pkg] = 'true';
     }
-    // Write back in the file's OWN line ending. Rewriting a CRLF workspace
-    // file with LF would leave it mixed, which is the same class of mess this
-    // fix exists to clean up.
-    const eol = /\r\n/.test(yaml) ? '\r\n' : '\n';
-    const block = Object.entries(map).map(([k, v]) => `  ${quoteYamlKey(k)}: ${v}`).join(eol);
-    const blockText = `allowBuilds:${eol}${block}${eol}`;
-    let next;
-    if (blockMatch === null) {
-        next = `${yaml.replace(/\r?\n?$/, eol)}${blockText}`;
+    writeAllowBuildsMap(file, yaml, map, blockRe, blockMatch);
+    return Object.keys(map);
+}
+/**
+ * Remove the allowBuilds keys pnpm cannot parse as a version range, and say
+ * which (#698).
+ *
+ * pnpm reads an allowBuilds key as `name@<version union>`, and on 10.26 to
+ * the latest 10.x and on 11.0 to 11.5 a git or archive source there —
+ * `name@git+https://…`, `name@https://codeload…` — is rejected as
+ * "Invalid versions union … Use exact versions only". Not the one entry: the
+ * whole workspace file, so EVERY later pnpm command in the profile fails,
+ * including installs that have nothing to do with it. Measured on 9.15,
+ * 10.0 through 10.29, 11.0 through 11.8, 11.21 and 12.4; 10.25 and below
+ * ignore allowBuilds and 11.6 and above accept these keys.
+ *
+ * Those are exactly the keys the market writes for a git source (#68, #285,
+ * #637), because the pnpm versions that need them to authorize anything
+ * read them fine. On the versions in between, a bare name is what
+ * authorizes a git dependency — measured on 10.29 — and it is kept.
+ *
+ * @returns the keys removed; empty when nothing matched, in which case the
+ *   file is left untouched.
+ */
+export function dropUnparseableBuildKeys(profile, explicitDir) {
+    const file = join(profileDir(profile, explicitDir), 'pnpm-workspace.yaml');
+    let yaml;
+    try {
+        yaml = readFileSync(file, 'utf8');
     }
-    else {
-        // The merged block replaces the first occurrence; any further ones are
-        // the duplicates this bug created and are dropped — their entries are
-        // already folded into `map` above, so nothing is lost.
-        let seen = 0;
-        next = yaml.replace(blockRe, () => (seen++ === 0 ? blockText : ''));
+    catch {
+        return [];
     }
-    writeFileSync(file, next);
-    return Object.keys(map);
+    const { map, blockRe, blockMatch } = readAllowBuildsMap(yaml);
+    // A key is a source rather than a version when what follows the name's own
+    // `@` starts a URL scheme. Scoped names begin with `@`, so the separator is
+    // the first `@` after position 0.
+    const removed = Object.keys(map).filter(key => {
+        const at = key.indexOf('@', 1);
+        return at > 0 && /^(?:git\+|https?:)/.test(key.slice(at + 1));
+    });
+    if (removed.length === 0)
+        return [];
+    for (const key of removed)
+        delete map[key];
+    writeAllowBuildsMap(file, yaml, map, blockRe, blockMatch);
+    return removed;
 }