dshmarket 1.2.2 → 1.2.4

package/lib/dsh-cli.js

@@ -0,0 +1,224 @@
+/**
+ * Process layer: re-invoking the dsh CLI that launched this host, spawning
+ * `dsh plugin` commands with timeouts and live progress, and provisioning
+ * pnpm. This is the only module that starts child processes.
+ *
+ * Installs run through node:child_process, not ctx.shell: the shell service is
+ * the agent's sandboxed executor and denies writes to the profile directory.
+ */
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { logEvent } from './log.js';
+import { pluginArgsFor } from './pnpm-compat.js';
+import { profileDir } from './profile.js';
+// 15 min default (slow networks + git installs), overridable for CI/tests.
+// (#6 by @qichuang321.)
+const INSTALL_TIMEOUT_MS = Number(process.env.DSH_MARKET_INSTALL_TIMEOUT_MS) || 15 * 60 * 1000;
+/**
+ * Windows npm/corepack/pnpm are `.cmd` shims. Node's `spawn` without a shell
+ * cannot start them (ENOENT / EINVAL). Same pattern as dsh's `plugin` forwarder.
+ */
+export const winCmdShim = process.platform === 'win32';
+/**
+ * Argv re-invoking the CLI that launched this host process, so installs work
+ * whether dsh runs from a global bin, a local install, or repo source
+ * (`node --import tsx/esm .../bin.ts`). Falls back to a PATH `dsh`.
+ */
+export function dshArgv() {
+    const entry = process.argv[1];
+    if (entry !== undefined && /[\\/](?:bin\.(?:js|ts)|dsh)$/.test(entry)) {
+        // Absolute paths are required: source launches (`pnpm dsh`) pass a
+        // relative entry, which the child resolves against its OWN cwd and dies
+        // with MODULE_NOT_FOUND (#13). cwd near the entry keeps execArgv imports
+        // (tsx/esm) resolvable on source launches.
+        const abs = resolve(entry);
+        return { file: process.execPath, args: [...process.execArgv, abs], cwd: dirname(abs), viaShell: false };
+    }
+    // Bare `dsh` is a .cmd shim on Windows that only a shell can start (#13).
+    return { file: 'dsh', args: [], cwd: undefined, viaShell: winCmdShim };
+}
+/**
+ * Kill a spawned child and, on Windows, its whole process tree — `kill()`
+ * there only terminates the wrapper, leaving pnpm children running.
+ * (Contributed in #7 by @mraing.)
+ */
+export function killChild(child) {
+    if (process.platform === 'win32' && child.pid !== undefined) {
+        try {
+            spawn('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' });
+            return;
+        }
+        catch { /* fall through */ }
+    }
+    child.kill('SIGKILL');
+}
+/** The child of the operation currently running, for /dsh-market/cancel. */
+let activeChild = null;
+let cancelRequested = false;
+/**
+ * Kill a child and its whole tree, gracefully where the platform allows:
+ * taskkill /T /F on Windows (plain kill() leaves pnpm children running),
+ * SIGTERM with a 5s SIGKILL escalation elsewhere so pnpm can clean up.
+ * (Cancel flow contributed in #6 by @qichuang321.)
+ */
+function killTree(child) {
+    if (process.platform === 'win32' && child.pid !== undefined) {
+        try {
+            spawn('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' });
+            return;
+        }
+        catch { /* fall through */ }
+    }
+    // POSIX: the dsh wrapper runs pnpm as a grandchild (spawnSync), which a
+    // plain child.kill() leaves running — it keeps our stdio pipes open, so
+    // the close event never fires and the market looks stuck "installing".
+    // The child is spawned detached as its own process GROUP; kill the group.
+    const signalTree = (signal) => {
+        if (child.pid === undefined)
+            return;
+        try {
+            process.kill(-child.pid, signal);
+        }
+        catch {
+            try {
+                child.kill(signal);
+            }
+            catch { /* already gone */ }
+        }
+    };
+    signalTree('SIGTERM');
+    const escalate = setTimeout(() => signalTree('SIGKILL'), 5000);
+    escalate.unref?.();
+}
+/**
+ * Cancel the plugin command currently running.
+ * @returns true when there was one to cancel.
+ */
+export function cancelActive() {
+    if (activeChild === null)
+        return false;
+    cancelRequested = true;
+    killTree(activeChild);
+    return true;
+}
+/** Whether `pnpm` resolves on PATH; success is cached, absence is re-probed. */
+let pnpmReady = false;
+/** Probe `pnpm --version` on PATH. */
+export function probePnpm() {
+    if (pnpmReady)
+        return Promise.resolve(true);
+    return new Promise((resolvePromise) => {
+        const child = spawn('pnpm', ['--version'], { stdio: 'ignore', shell: winCmdShim });
+        child.on('error', () => resolvePromise(false));
+        child.on('close', (code) => {
+            pnpmReady = code === 0;
+            resolvePromise(pnpmReady);
+        });
+    });
+}
+function runQuiet(file, args, timeoutMs) {
+    return new Promise((resolvePromise) => {
+        const child = spawn(file, args, {
+            env: { ...process.env, CI: 'true' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: winCmdShim,
+        });
+        let output = '';
+        const timer = setTimeout(() => killChild(child), timeoutMs);
+        const collect = (chunk) => { output = (output + chunk.toString()).slice(-8 * 1024); };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.on('error', (error) => { clearTimeout(timer); resolvePromise({ code: 127, output: error.message }); });
+        child.on('close', (code) => { clearTimeout(timer); resolvePromise({ code, output }); });
+    });
+}
+/**
+ * Provision pnpm without user involvement: corepack (ships with Node) first,
+ * a global npm install as fallback.
+ * @returns true when `pnpm --version` succeeds afterwards.
+ */
+export async function provisionPnpm() {
+    const corepack = await runQuiet('corepack', ['enable', 'pnpm'], 60 * 1000);
+    logEvent(corepack.code === 0 ? 'info' : 'warn', 'setup-pnpm', `corepack enable: exit=${String(corepack.code)} ${corepack.output.slice(-200)}`);
+    if (await probePnpm())
+        return true;
+    const npm = await runQuiet('npm', ['install', '-g', 'pnpm'], 3 * 60 * 1000);
+    logEvent(npm.code === 0 ? 'info' : 'error', 'setup-pnpm', `npm -g: exit=${String(npm.code)} ${npm.output.slice(-200)}`);
+    return probePnpm();
+}
+/** Singleton progress state; the status route reads it, runDshPlugin writes it. */
+export const progress = { active: false, target: '', startedAt: 0, lastLine: '' };
+/** Identifies this host process; the client scopes its pending-restart flags to it. */
+export const BOOT_ID = `${String(process.pid)}-${String(Date.now())}`;
+function trackProgress(chunk) {
+    const lines = chunk.split('\n').map(l => l.trim()).filter(l => l !== '');
+    if (lines.length > 0)
+        progress.lastLine = lines[lines.length - 1].slice(0, 200);
+}
+/**
+ * Central allowlist for every spawn target, regardless of which route built
+ * it (defense in depth on top of per-route validation — the win32 bare-dsh
+ * fallback runs through a shell). Suggested in #16 by @anupamme.
+ */
+const TARGET_RE = /^[A-Za-z0-9@:./_#+-]+$/;
+/** Run one `dsh plugin --profile <p> …` command with timeout and progress tracking. */
+export function runDshPlugin(profile, pluginArgs) {
+    const { file, args, cwd, viaShell } = dshArgv();
+    pluginArgs = pluginArgsFor(profileDir(profile), pluginArgs);
+    const target = pluginArgs[pluginArgs.length - 1] ?? '';
+    if (!TARGET_RE.test(target)) {
+        logEvent('error', 'install', `unsafe plugin target rejected: ${JSON.stringify(target)}`);
+        return Promise.resolve({ exitCode: 1, timedOut: false, stdout: '', stderr: `unsafe plugin target rejected: ${JSON.stringify(target)}`, cancelled: false });
+    }
+    progress.active = true;
+    progress.target = target;
+    progress.startedAt = Date.now();
+    progress.lastLine = '';
+    return new Promise((resolvePromise) => {
+        const child = spawn(file, [...args, 'plugin', '--profile', profile, ...pluginArgs], {
+            cwd,
+            // pnpm v10 blocks forever on a silent interactive prompt without a TTY
+            // (observed on re-add over a pinned git spec); CI mode forces it to act
+            // or fail instead of asking.
+            env: { ...process.env, CI: 'true' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: viaShell,
+            // Own process group on POSIX so cancel/timeout can kill the whole
+            // tree (dsh wrapper + pnpm grandchild) with one group signal.
+            detached: process.platform !== 'win32',
+        });
+        activeChild = child;
+        cancelRequested = false;
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killTree(child);
+        }, INSTALL_TIMEOUT_MS);
+        child.stdout.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout = (stdout + text).slice(-256 * 1024);
+            trackProgress(text);
+        });
+        child.stderr.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderr = (stderr + text).slice(-64 * 1024);
+            trackProgress(text);
+        });
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            progress.active = false;
+            if (activeChild === child)
+                activeChild = null;
+            resolvePromise({ exitCode: 127, timedOut: false, stdout, stderr: `${stderr}\n${error.message}`, cancelled: false });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            progress.active = false;
+            if (activeChild === child)
+                activeChild = null;
+            resolvePromise({ exitCode: code, timedOut, stdout, stderr, cancelled: cancelRequested });
+        });
+    });
+}

package/lib/http.js

@@ -0,0 +1,39 @@
+/**
+ * Minimal HTTP helpers shared by every market route: JSON serialization,
+ * same-origin enforcement for mutating endpoints, and a size-capped JSON
+ * body reader.
+ */
+/** Write a JSON payload with no-store caching. */
+export function sendJson(response, status, payload) {
+    response.writeHead(status, {
+        'cache-control': 'no-store',
+        'content-type': 'application/json; charset=utf-8',
+    });
+    response.end(JSON.stringify(payload));
+}
+/** True when the request's Origin matches its Host — required on every POST route. */
+export function sameOrigin(request) {
+    const origin = request.headers.origin;
+    const host = request.headers.host;
+    if (origin === undefined || host === undefined)
+        return false;
+    try {
+        return new URL(origin).host === host;
+    }
+    catch {
+        return false;
+    }
+}
+/** Read and parse a JSON request body, rejecting anything over 4 KiB. */
+export async function readJsonBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 4096)
+            throw new Error('request body too large');
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}

package/lib/install.js

@@ -0,0 +1,132 @@
+/**
+ * Install orchestration: collection-repo retargeting, post-install
+ * validation that keeps broken pieces from bricking the next boot, and
+ * update staleness detection. Every function takes the plugin runner as a
+ * parameter so tests can substitute a recording fake.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { classifyPnpmFailure } from './pnpm-compat.js';
+import { entryArtifactExists, hasDshManifest, pluginSubdirs, profileDir, readInstalled } from './profile.js';
+import { logEvent } from './log.js';
+/**
+ * Run one plugin command with automatic recovery from the pnpm-major drift
+ * failure (#20 bug 2): when the modules directory was built by a different
+ * pnpm major, pnpm's documented remedy is one `install` to recreate it —
+ * do that silently and retry the original command once. Any recognized
+ * failure that survives gets its bilingual explanation appended to stderr
+ * so the UI shows an actionable message instead of a wall of text (#20 bug 3).
+ */
+export async function withHoistRecovery(run, profile, pluginArgs) {
+    let result = await run(profile, pluginArgs);
+    const ok = (r) => r.exitCode === 0 && !r.timedOut && !r.cancelled;
+    if (!ok(result) && classifyPnpmFailure(`${result.stderr}\n${result.stdout}`)?.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.
+        const rebuild = await run(profile, ['install', '--no-frozen-lockfile']);
+        if (ok(rebuild))
+            result = await run(profile, pluginArgs);
+    }
+    if (!ok(result) && !result.cancelled) {
+        const failure = classifyPnpmFailure(`${result.stderr}\n${result.stdout}`);
+        if (failure !== null)
+            result = { ...result, stderr: `${result.stderr}\n\n${failure.message}` };
+    }
+    return result;
+}
+/**
+ * Some registry entries point at collection repos whose actual plugin lives
+ * in a subdirectory — the root has no package.json (or a workspace root with
+ * no dsh surface), and pnpm installs the bare fileset with exit 0. Detect
+ * that junk install, drop it, and re-add each plugin subdirectory through
+ * pnpm's `#path:` selector (#18).
+ * @returns overall success (true when nothing needed retargeting).
+ */
+export async function retargetCollections(run, profile, before, target) {
+    if (!target.startsWith('github:'))
+        return true;
+    const junk = Object.keys(readInstalled(profile)).filter((name) => {
+        if (before.has(name))
+            return false;
+        const root = join(profileDir(profile), 'node_modules', name);
+        if (!existsSync(join(root, 'package.json')))
+            return true;
+        return !hasDshManifest(root);
+    });
+    let allOk = true;
+    for (const name of junk) {
+        const root = join(profileDir(profile), 'node_modules', name);
+        const candidates = pluginSubdirs(root);
+        logEvent('info', 'install', `${name}: collection repo (root declares no dsh manifest); plugins inside: ${candidates.join(', ') || 'none'}`);
+        await run(profile, ['remove', name]);
+        if (candidates.length === 0) {
+            allOk = false;
+            continue;
+        }
+        for (const sub of candidates) {
+            const result = await run(profile, ['add', `${target}#path:/${sub}`]);
+            if (result.exitCode !== 0 || result.timedOut) {
+                allOk = false;
+                logEvent('error', 'install', `${target}#path:/${sub}: exit=${String(result.exitCode)}${result.timedOut ? ' TIMEOUT' : ''} — ${(result.stderr || result.stdout).slice(-220)}`);
+            }
+        }
+    }
+    return allOk;
+}
+/**
+ * Fake-success guard (#18): validate every package the install added. A
+ * piece without a dsh manifest or without its declared entry artifact
+ * (source-only checkout, build blocked by pnpm allowBuilds) would brick the
+ * next boot, so it is removed on the spot.
+ * @returns names kept and names removed as broken.
+ */
+export async function validateAddedPlugins(run, profile, before) {
+    const addedNow = Object.keys(readInstalled(profile)).filter(n => !before.has(n));
+    const keep = [];
+    const removedBroken = [];
+    for (const n of addedNow) {
+        const dir = join(profileDir(profile), 'node_modules', n);
+        if (hasDshManifest(dir) && entryArtifactExists(dir)) {
+            keep.push(n);
+        }
+        else {
+            removedBroken.push(n);
+            await run(profile, ['remove', n]);
+        }
+    }
+    return { keep, removedBroken };
+}
+/**
+ * Whether a clean-exit update actually changed nothing — pnpm's
+ * minimumReleaseAge silently keeps the old version and exits 0 when the new
+ * release is "too young" (#13, #22), so a clean exit alone does not mean the
+ * update happened.
+ */
+export function isStaleUpdate(check) {
+    return check.isGit
+        ? check.beforeCommit !== null && check.afterCommit === check.beforeCommit
+        : check.beforeVersion !== null && check.afterVersion === check.beforeVersion;
+}
+/**
+ * Package names pnpm reported as having their build scripts ignored
+ * ("Ignored build scripts: esbuild, koffi."). Empty when none.
+ * (#6 by @qichuang321.)
+ */
+export function parseIgnoredBuilds(stdout, stderr) {
+    const m = /Ignored build scripts:?\s*([^\n]+)/i.exec(`${stdout}\n${stderr}`);
+    if (m === null)
+        return [];
+    const found = [];
+    for (const chunk of m[1].split(',')) {
+        // Entries may carry a version suffix and the sentence's final period.
+        const trimmed = chunk.trim().replace(/\.$/, '');
+        if (trimmed === '')
+            continue;
+        const at = trimmed.lastIndexOf('@');
+        const name = at > 0 ? trimmed.slice(0, at) : trimmed;
+        if (name !== '' && !found.includes(name))
+            found.push(name);
+    }
+    return found;
+}

package/lib/pnpm-compat.js

@@ -0,0 +1,72 @@
+/**
+ * pnpm compatibility layer — everything the market needs to know about how
+ * different pnpm majors behave inside a dsh profile directory, kept pure and
+ * separately testable (test/unit + test/integration exercise this module
+ * against real pnpm 9/10/11).
+ *
+ * Verified behavior matrix (2026-08, pnpm 9.15.9 / 10.28.2 / 11.21.0):
+ * - workspace root, `add` without -w:  pnpm 9 fails ERR_PNPM_ADDING_TO_ROOT;
+ *   pnpm 10/11 succeed.
+ * - `add -w` where NO pnpm-workspace.yaml exists: ALL majors fail with
+ *   "--workspace-root may only be used inside a workspace".
+ * - modules dir built by pnpm 9, then pnpm 10/11 mutate it:
+ *   ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF (defaults drifted between majors).
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Decide the argv for a `dsh plugin <add|remove> …` call in the given profile.
+ *
+ * pnpm 9 refuses to add at a workspace root without -w (#17, #20); every
+ * pnpm major refuses -w when the directory is NOT a workspace. So the flag
+ * is injected exactly when the profile has a pnpm-workspace.yaml.
+ * @param profileDir - resolved profile directory (owns pnpm-workspace.yaml, or not).
+ * @param pluginArgs - the raw args, e.g. ['add', 'dshmarket@latest'].
+ * @returns args with -w injected when — and only when — the profile is a workspace root.
+ */
+export function pluginArgsFor(profileDir, pluginArgs) {
+    if (pluginArgs[0] !== 'add' && pluginArgs[0] !== 'remove')
+        return pluginArgs;
+    if (!existsSync(join(profileDir, 'pnpm-workspace.yaml')))
+        return pluginArgs;
+    return [pluginArgs[0], '-w', ...pluginArgs.slice(1)];
+}
+/**
+ * Map a failed pnpm run's combined output to a known failure mode.
+ *
+ * dsh's own wrapper line ("dsh: pnpm failed in profile directory …") names no
+ * cause, so the market must recognize pnpm's real diagnostics itself (#20).
+ * @param output - stdout+stderr of the failed run.
+ * @returns the classified failure, or null when unrecognized (raw output is then shown as-is).
+ */
+export function classifyPnpmFailure(output) {
+    if (output.includes('ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF')) {
+        return {
+            code: 'hoist-pattern-diff',
+            recoverable: true,
+            message: 'profile 的 node_modules 是旧版 pnpm 创建的，与当前 pnpm 的默认配置不兼容，需要重建后重试 / this profile\'s node_modules was created by a different pnpm major; it must be rebuilt (pnpm install) before changes can be applied',
+        };
+    }
+    if (output.includes('ERR_PNPM_ADDING_TO_ROOT')) {
+        return {
+            code: 'adding-to-root',
+            recoverable: false,
+            message: 'pnpm 拒绝在 workspace 根目录安装（缺少 -w）。这是市场的 bug，请升级 dshmarket 到最新版 / pnpm refused to add at a workspace root (missing -w); this is a market bug — please update dshmarket',
+        };
+    }
+    if (/--workspace-root may only be used inside a workspace/i.test(output)) {
+        return {
+            code: 'not-a-workspace',
+            recoverable: false,
+            message: 'profile 目录不是 pnpm workspace，却传入了 -w。这是市场的 bug，请升级 dshmarket 到最新版 / -w was passed but the profile is not a pnpm workspace; this is a market bug — please update dshmarket',
+        };
+    }
+    if (output.includes('pnpm not found on PATH')) {
+        return {
+            code: 'pnpm-missing',
+            recoverable: false,
+            message: '找不到 pnpm，请先在市场页顶部一键安装组件 / pnpm is not on PATH — use the one-click setup at the top of the market page',
+        };
+    }
+    return null;
+}

package/lib/profile.js

@@ -0,0 +1,166 @@
+/**
+ * Profile filesystem reads — everything the market learns from a dsh
+ * profile directory (manifest, lockfile, installed package trees). Pure
+ * functions of the directory contents; no processes, no network.
+ */
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Resolve a profile name to its directory under DSH_HOME (default ~/.dsh). */
+export function profileDir(profile) {
+    const home = process.env.DSH_HOME ?? join(homedir(), '.dsh');
+    return join(home, 'profiles', profile);
+}
+/**
+ * The in-box bundles dsh's profile templates install themselves — the ONLY
+ * names the market hides from the installed list. Community plugins may
+ * legitimately publish under the official scope (#28), so a whole-scope
+ * filter would make them invisible and fail install validation.
+ * (Diagnosis and fix proposed in #28 by @Lograthmic.)
+ */
+const INBOX_BUNDLES = new Set([
+    '@deepseek-ai/dsh-base',
+    '@deepseek-ai/dsh-web-app',
+    '@deepseek-ai/dsh-headless',
+]);
+/** Community dependencies of the profile (in-box bundles filtered out). */
+export function readInstalled(profile) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(profileDir(profile), 'package.json'), 'utf8'));
+        const installed = {};
+        for (const [name, spec] of Object.entries(manifest.dependencies ?? {})) {
+            if (!INBOX_BUNDLES.has(name))
+                installed[name] = spec;
+        }
+        return installed;
+    }
+    catch {
+        return {};
+    }
+}
+/** The version actually present in the profile's node_modules, or null. */
+export function readInstalledVersion(profile, name) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(profileDir(profile), 'node_modules', name, 'package.json'), 'utf8'));
+        return manifest.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Pinned commit per `owner/repo` from the profile lockfile's codeload tarball URLs. */
+export function readLockCommits(profile) {
+    const commits = new Map();
+    try {
+        const lock = readFileSync(join(profileDir(profile), 'pnpm-lock.yaml'), 'utf8');
+        for (const m of lock.matchAll(/codeload\.github\.com\/([^/\s]+\/[^/\s]+)\/tar\.gz\/([0-9a-f]{40})/g)) {
+            commits.set(m[1].toLowerCase(), m[2]);
+        }
+    }
+    catch { /* no lockfile — no git installs to report */ }
+    return commits;
+}
+/** True when the installed package's manifest declares a dsh plugin surface. */
+export function hasDshManifest(dir) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return manifest.dsh !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True when the package's declared entry artifact actually exists — github
+ * source checkouts of build-required plugins ship no lib/, and promoting one
+ * into the bundle layer bricks the next boot (ERR_MODULE_NOT_FOUND kills the
+ * whole profile, #18).
+ */
+export function entryArtifactExists(dir) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        const candidates = [];
+        if (typeof manifest.main === 'string')
+            candidates.push(manifest.main);
+        const rootExport = typeof manifest.exports === 'string'
+            ? manifest.exports
+            : manifest.exports?.['.'];
+        if (typeof rootExport === 'string')
+            candidates.push(rootExport);
+        else if (rootExport !== null && typeof rootExport === 'object') {
+            for (const value of Object.values(rootExport))
+                if (typeof value === 'string')
+                    candidates.push(value);
+        }
+        if (candidates.length === 0)
+            candidates.push('index.js');
+        return candidates.some(rel => existsSync(join(dir, rel)));
+    }
+    catch {
+        return false;
+    }
+}
+/** Plugin subdirectories (depth 2) of a collection checkout, as relative paths. */
+export function pluginSubdirs(root) {
+    const found = [];
+    let level1 = [];
+    try {
+        level1 = readdirSync(root, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory() && /^[A-Za-z0-9_.-]+$/.test(dirent.name) && dirent.name !== 'node_modules')
+            .map(dirent => dirent.name);
+    }
+    catch {
+        return found;
+    }
+    for (const sub of level1) {
+        if (hasDshManifest(join(root, sub))) {
+            found.push(sub);
+            continue;
+        }
+        try {
+            for (const inner of readdirSync(join(root, sub), { withFileTypes: true })) {
+                if (!inner.isDirectory() || !/^[A-Za-z0-9_.-]+$/.test(inner.name) || inner.name === 'node_modules')
+                    continue;
+                if (hasDshManifest(join(root, sub, inner.name)))
+                    found.push(`${sub}/${inner.name}`);
+            }
+        }
+        catch { /* unreadable level — skip */ }
+        if (found.length >= 8)
+            break;
+    }
+    return found.slice(0, 8);
+}
+/**
+ * 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) {
+    const file = join(profileDir(profile), 'pnpm-workspace.yaml');
+    let yaml = '';
+    try {
+        yaml = readFileSync(file, 'utf8');
+    }
+    catch { /* created below */ }
+    const blockRe = /allowBuilds:\n((?:[ \t]+[^\n]*\n?)*)/;
+    const map = {};
+    const blockMatch = blockRe.exec(yaml);
+    if (blockMatch !== null) {
+        for (const line of blockMatch[1].split('\n')) {
+            const m = /^[ \t]+([^:\s]+(?:\/[^:\s]+)?)\s*:\s*(\S.*)?$/.exec(line);
+            if (m !== null)
+                map[m[1]] = m[2] ?? 'true';
+        }
+    }
+    for (const pkg of packages) {
+        if (/^[A-Za-z0-9@/_.-]+$/.test(pkg))
+            map[pkg] = 'true';
+    }
+    const block = Object.entries(map).map(([k, v]) => `  ${k}: ${v}`).join('\n');
+    const blockText = `allowBuilds:\n${block}\n`;
+    writeFileSync(file, blockMatch !== null ? yaml.replace(blockRe, blockText) : `${yaml.replace(/\n?$/, '\n')}${blockText}`);
+    return Object.keys(map);
+}