@deepseek-ai/dsh-plugin-manager 0.1.7-alpha.2 → 0.1.7-rc.2

package/lib/types/index.js

@@ -42,14 +42,15 @@ import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import z from '@deepseek-ai/schemastery';
 import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol';
 import { pluginEntryId, readPluginInventory } from '@deepseek-ai/dsh-host-plugin-inventory';
-import { readPluginMeta, readProfileManifest, resolveBundleDir, loadOverlayPatches, composeEntries, reconcileProfilePatches, readProfilePatches, OPTIONAL_BUNDLES, bundlePatchPaths, } from '@deepseek-ai/dsh-app-boot';
+import { readPluginMeta, readProfileManifest, resolveBundleDir, loadOverlayPatches, composeEntries, reconcileProfilePatches, readProfilePatches, OPTIONAL_BUNDLES, bundlePatchPaths, evaluatePluginCompatibility, readProfileCompatibility, readProfileVersionExemptions, setProfileVersionExemption, PROFILE_COMPATIBILITY_FILENAME, } from '@deepseek-ai/dsh-app-boot';
 import { bundleManifest, readProfileRegistry, registryArguments, runProfilePnpm, saveManifest, viewProfilePackage } from "./operations.js";
 import { classifyInstallFailure } from "./install-failure.js";
 import { InvalidInstallSpecError, parseInstallSpec } from "./install-spec.js";
 import { attributeFailure, normalizeRegistry, NPMMIRROR_REGISTRY, registryPlan } from "./registry.js";
 import { writePluginEnabled } from "./patch.js";
-import { ManagementFailure } from "./failure.js";
+import { incompatiblePlugin, ManagementFailure } from "./failure.js";
 import { approveBuilds, readPendingBuilds } from "./build-approval.js";
+import { checkGithubConnection } from "./github-connection.js";
 export { classifyInstallFailure } from "./install-failure.js";
 export { InvalidInstallSpecError, parseInstallSpec } from "./install-spec.js";
 /** An http(s) URL, as pnpm's `--registry` takes it. */
@@ -77,7 +78,9 @@ function flatten(rows) {
 function messageOf(error) { return error instanceof Error ? error.message : String(error); }
 /** An expected refusal keeps its code; anything else becomes an operation error carrying its exact diagnostic. */
 function managementError(error) {
-    return error instanceof ManagementFailure ? { code: error.code } : { code: 'operation-error', diagnostic: messageOf(error) };
+    if (!(error instanceof ManagementFailure))
+        return { code: 'operation-error', diagnostic: messageOf(error) };
+    return { code: error.code, ...error.incompatible === undefined ? {} : { incompatible: error.incompatible } };
 }
 /** The caller stopped an installation; its files are restored before this is thrown. */
 class InstallCancelledError extends Error {
@@ -140,6 +143,8 @@ function parsedForRegistry(spec) {
 let PluginManager = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
+    let _listVersionExemptions_decorators;
+    let _setVersionExemption_decorators;
     let _listPlugins_decorators;
     let _listBundles_decorators;
     let _registries_decorators;
@@ -153,6 +158,8 @@ let PluginManager = (() => {
     return class PluginManager extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _listVersionExemptions_decorators = [Remote];
+            _setVersionExemption_decorators = [Remote];
             _listPlugins_decorators = [Remote];
             _listBundles_decorators = [Remote];
             _registries_decorators = [Remote];
@@ -163,6 +170,8 @@ let PluginManager = (() => {
             _waitForInstall_decorators = [Remote];
             _cancelInstall_decorators = [Remote];
             _removeBundle_decorators = [Remote];
+            __esDecorate(this, null, _listVersionExemptions_decorators, { kind: "method", name: "listVersionExemptions", static: false, private: false, access: { has: obj => "listVersionExemptions" in obj, get: obj => obj.listVersionExemptions }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setVersionExemption_decorators, { kind: "method", name: "setVersionExemption", static: false, private: false, access: { has: obj => "setVersionExemption" in obj, get: obj => obj.setVersionExemption }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _listPlugins_decorators, { kind: "method", name: "listPlugins", static: false, private: false, access: { has: obj => "listPlugins" in obj, get: obj => obj.listPlugins }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _listBundles_decorators, { kind: "method", name: "listBundles", static: false, private: false, access: { has: obj => "listBundles" in obj, get: obj => obj.listBundles }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _registries_decorators, { kind: "method", name: "registries", static: false, private: false, access: { has: obj => "registries" in obj, get: obj => obj.registries }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -181,6 +190,8 @@ let PluginManager = (() => {
             outputBytes: z.number().step(1).min(1).default(16384),
             lockWaitMs: z.number().step(1).min(0).default(120000),
             inspectTimeoutMs: z.number().step(1).min(1000).default(20000),
+            githubConnectionTimeoutMs: z.number().step(1).min(1000).default(5000),
+            idleTimeoutMs: z.number().step(1).min(1000).default(600000),
             registry: z.string().pattern(REGISTRY_URL),
             fallbackRegistries: z.array(z.string().pattern(REGISTRY_URL)).default([NPMMIRROR_REGISTRY]),
         });
@@ -192,6 +203,8 @@ let PluginManager = (() => {
         outputBytes;
         lockWaitMs;
         inspectTimeoutMs;
+        githubConnectionTimeoutMs;
+        idleTimeoutMs;
         pnpmCommand;
         configuredRegistries;
         ownerContext;
@@ -208,6 +221,8 @@ let PluginManager = (() => {
             this.outputBytes = config.outputBytes;
             this.lockWaitMs = config.lockWaitMs;
             this.inspectTimeoutMs = config.inspectTimeoutMs;
+            this.githubConnectionTimeoutMs = config.githubConnectionTimeoutMs;
+            this.idleTimeoutMs = config.idleTimeoutMs;
             this.pnpmCommand = config.pnpmCommand;
             this.configuredRegistries = {
                 registry: config.registry === undefined ? null : normalizeRegistry(config.registry),
@@ -218,6 +233,27 @@ let PluginManager = (() => {
                 await Promise.allSettled([...this.packageOperations]);
             }, 'plugin-manager: package cancellation');
         }
+        /** Read exact plugin-version exemptions saved in this profile.
+         * @returns Accepted package-name@version keys with the runtime versions they may run on, and any
+         * record or file problem the reader rejected, which the caller reports instead of failing.
+         */
+        listVersionExemptions() {
+            const { exemptions, warnings } = readProfileCompatibility(this.profile.dir);
+            return { exemptions, warnings };
+        }
+        /** Grant or revoke one exact plugin/runtime exemption and reevaluate live plugins.
+         * @param packageVersion Exact manifest package name followed by @ and its version; never an installation spec or alias.
+         * @param runtimeVersion Exact current DSH version for grants; revocation may name a previous runtime.
+         * @param enabled Whether to grant rather than revoke the exemption.
+         * @param acceptRisk Required true for grants after the user accepts possible crashes and data loss.
+         * @returns Saved and runtime outcomes. Startup-only profiles require restart.
+         */
+        setVersionExemption(packageVersion, runtimeVersion, enabled, acceptRisk) {
+            return this.change(result => this.configure(async () => {
+                await setProfileVersionExemption(this.profile.dir, packageVersion, runtimeVersion, enabled, acceptRisk === true);
+                result.warnings = await this.reload();
+            }), { stage: 'enable', target: packageVersion, enabled }, 'bundle');
+        }
         /** Read current plugins, including why a row cannot be changed through the profile patch.
          * @returns Current runtime entries with persistent patch targets.
          */
@@ -245,6 +281,7 @@ let PluginManager = (() => {
          */
         listBundles() {
             const manifest = readProfileManifest('dsh', this.profile.dir);
+            const exemptions = readProfileVersionExemptions(this.profile.dir);
             const selected = manifest.dsh?.profile?.bundles ?? [];
             const dependencies = Object.keys(manifest.dependencies ?? {});
             const installation = JSON.parse(readFileSync(this.profile.installAnchor, 'utf8'));
@@ -264,6 +301,9 @@ let PluginManager = (() => {
                                 ...(readOnlyReason === undefined ? {} : { readOnlyReason }), error: { code: 'not-bundle' }, rows: [], overrides: [] });
                         continue;
                     }
+                    const compatibility = evaluatePluginCompatibility(info, exemptions);
+                    if (compatibility !== undefined && !compatibility.exempted)
+                        throw new ManagementFailure('incompatible-version', [incompatiblePlugin(compatibility)]);
                     const dir = resolveBundleDir('dsh', name, this.profile.installAnchor, this.profile.dir);
                     const meta = readPluginMeta(info.name ?? name, pathToFileURL(join(dir, 'package.json')).href);
                     bundles.push({ name, ...(info.version === undefined ? {} : { version: info.version }),
@@ -420,7 +460,9 @@ let PluginManager = (() => {
             }), { stage: 'enable', target: name, enabled }, 'bundle');
         }
         /**
-         * Install a package using the same pnpm implementation as dsh plugin. A run
+         * Install a package using the same pnpm implementation as dsh plugin. GitHub
+         * repositories get a connection check bounded by githubConnectionTimeoutMs before pnpm starts;
+         * only network failures or timeouts stop installation, while pnpm owns authentication and transport fallback. A run
          * that fails, is cancelled, or adds a package without a bundle patch restores
          * `package.json` and `pnpm-lock.yaml` as they were; downloaded files can stay.
          * @param spec One package spec, including local paths relative to the invocation directory.
@@ -431,7 +473,7 @@ let PluginManager = (() => {
         installBundle(spec, options) {
             const requestId = options?.requestId;
             const control = { abort: new AbortController(), phase: 'installing', result: Promise.resolve(null) };
-            const stopped = () => control.abort.signal.aborted;
+            const stopped = () => control.abort.signal.aborted || this.abort.signal.aborted;
             if (requestId !== undefined)
                 this.installs.set(requestId, control);
             const announce = (phase, attempt) => {
@@ -449,12 +491,32 @@ let PluginManager = (() => {
                 }
                 const files = await this.readRestoredFiles();
                 const before = readProfileManifest('dsh', this.profile.dir).dependencies ?? {};
-                const plan = registryPlan(options?.registry, await this.registries());
                 let name;
                 try {
+                    result.registries = [];
+                    const connection = checkGithubConnection(parsedForRegistry(spec), this.profile.dir, {
+                        timeoutMs: this.githubConnectionTimeoutMs, outputBytes: this.outputBytes,
+                        signal: AbortSignal.any([this.abort.signal, control.abort.signal]),
+                        ...this.profile.packageManager?.env === undefined ? {} : { env: this.profile.packageManager.env },
+                    });
+                    this.packageOperations.add(connection);
+                    let connectionFailure;
+                    try {
+                        connectionFailure = await connection;
+                    }
+                    finally {
+                        this.packageOperations.delete(connection);
+                    }
+                    if (stopped())
+                        throw new InstallCancelledError();
+                    if (connectionFailure?.kind === 'network' || connectionFailure?.kind === 'timeout') {
+                        result.packageResult = connectionFailure;
+                        result.failedAt = 'spec-host';
+                        throw new Error(connectionFailure.output);
+                    }
                     // The last run is the result's; the registries asked stay listed whatever the outcome.
+                    const plan = registryPlan(options?.registry, await this.registries());
                     let run;
-                    result.registries = [];
                     for (const [index, registry] of plan.entries()) {
                         if (index > 0)
                             await this.restoreFiles(files);
@@ -467,12 +529,21 @@ let PluginManager = (() => {
                         result.packageResult = run;
                         if (stopped())
                             throw new InstallCancelledError();
-                        /* v8 ignore next 2 -- runPnpm classifies every failed run, so kind is never absent here */
-                        if (run.exitCode === 0 || run.kind === undefined)
+                        // A compatibility refusal is the package's own answer, so no other registry is asked.
+                        if (run.incompatible !== undefined)
+                            throw new ManagementFailure('incompatible-version', run.incompatible);
+                        // A run this manager terminated is not a success, even when pnpm trapped the signal and exited 0.
+                        if (run.exitCode === 0 && run.timedOut !== true)
+                            break;
+                        /* v8 ignore next 2 -- runPnpm classifies every run it does not report as succeeded */
+                        if (run.kind === undefined)
                             break;
-                        const failedAt = attributeFailure(run.kind, run.output, parsedForRegistry(spec));
                         // What the last failed run could not reach; a later run that succeeds leaves nothing to say.
                         delete result.failedAt;
+                        // A run this manager terminated got no answer from the registry at all, so no registry explains it.
+                        if (run.timedOut === true)
+                            break;
+                        const failedAt = attributeFailure(run.kind, run.output, parsedForRegistry(spec));
                         if (failedAt !== 'other')
                             result.failedAt = failedAt;
                         if (failedAt !== 'registry' || index === plan.length - 1)
@@ -481,9 +552,11 @@ let PluginManager = (() => {
                     /* v8 ignore next -- the plan is never empty, so a run always settled */
                     if (run === undefined)
                         throw new Error('no registry was asked');
-                    if (run.exitCode === 0)
+                    // A terminated run reports no usable exit status, so neither its files nor its bundle are trusted.
+                    const succeeded = run.exitCode === 0 && run.timedOut !== true;
+                    if (succeeded)
                         delete result.failedAt;
-                    if (run.exitCode !== 0) {
+                    if (!succeeded) {
                         // pnpm-workspace.yaml is not restored, so the names pnpm left undecided there can be offered for approval.
                         try {
                             result.pendingBuilds = await readPendingBuilds(this.profile.dir);
@@ -506,6 +579,9 @@ let PluginManager = (() => {
                     const manifest = bundleManifest(name, this.profile.dir, this.profile.installAnchor);
                     if (manifest?.dsh?.bundle === undefined)
                         throw new ManagementFailure('not-bundle');
+                    const compatibility = evaluatePluginCompatibility(manifest, readProfileVersionExemptions(this.profile.dir));
+                    if (compatibility !== undefined && !compatibility.exempted)
+                        throw new ManagementFailure('incompatible-version', [incompatiblePlugin(compatibility)]);
                     for (const file of bundlePatchPaths(dir, manifest.dsh.bundle))
                         loadOverlayPatches('dsh', file);
                 }
@@ -542,7 +618,7 @@ let PluginManager = (() => {
         }
         /** Stop an installation this manager owns and wait until its files are back.
          * @param requestId The id the installation was started with.
-         * @returns `cancelled` once pnpm exited and the files are restored, `too-late` once the bundle is being
+         * @returns `cancelled` once the Git check or pnpm exited and the files are restored, `too-late` once the bundle is being
          * applied, `not-running` for any other id.
          */
         async cancelInstall(requestId) {
@@ -583,8 +659,9 @@ let PluginManager = (() => {
                     }
                 });
                 result.packageResult = await this.runPnpm(['remove', name]);
-                if (result.packageResult.exitCode !== 0)
+                if (result.packageResult.exitCode !== 0 || result.packageResult.timedOut === true) {
                     throw new Error(result.packageResult.output);
+                }
             }, { stage: 'remove', target: name }, 'remove');
         }
         /** The rows a bundle's patch inserts and the existing rows it changes; an unreadable patch throws. */
@@ -629,7 +706,8 @@ let PluginManager = (() => {
             const task = runProfilePnpm({ ...this.profile, profile: this.profile.name }, args, {
                 execution: 'service', ...this.profile.packageManager ?? { command: this.pnpmCommand },
                 signal: signal === undefined ? this.abort.signal : AbortSignal.any([this.abort.signal, signal]),
-                outputBytes: this.outputBytes, activateNewBundles: false,
+                outputBytes: this.outputBytes, activateNewBundles: false, idleTimeoutMs: this.idleTimeoutMs,
+                lookupTimeoutMs: this.inspectTimeoutMs,
                 onOutput: (text, stream) => {
                     this.ownerContext.emit('plugin-manager/install-log', { ...identity, jobId, argv, cwd, stream, text });
                 },
@@ -640,7 +718,13 @@ let PluginManager = (() => {
                 this.ownerContext.emit('plugin-manager/install-log', {
                     ...identity, jobId, argv, cwd, stream: 'stdout', text: '', exitCode: signal?.aborted === true ? null : result.exitCode,
                 });
-                return result.exitCode === 0 ? result : { ...result, kind: classifyInstallFailure({ log: result.output }) };
+                // A terminated run keeps its own kind even when pnpm trapped the signal and exited 0.
+                if (result.exitCode === 0 && result.timedOut !== true)
+                    return result;
+                return {
+                    ...result,
+                    kind: classifyInstallFailure({ log: result.output, ...result.timedOut === true ? { timedOut: true } : {} }),
+                };
             }
             catch (error) {
                 this.ownerContext.emit('plugin-manager/install-log', { ...identity, jobId, argv, cwd, stream: 'stderr', text: messageOf(error), exitCode: null });
@@ -671,11 +755,17 @@ let PluginManager = (() => {
         async selectBundle(name, enabled) {
             const manifest = readProfileManifest('dsh', this.profile.dir);
             const previous = manifest.dsh?.profile?.bundles ?? [];
-            if ((enabled || !previous.includes(name)) && bundleManifest(name, this.profile.dir, this.profile.installAnchor) === undefined) {
-                throw new ManagementFailure('not-bundle');
+            if (enabled || !previous.includes(name)) {
+                const metadata = bundleManifest(name, this.profile.dir, this.profile.installAnchor);
+                if (metadata === undefined)
+                    throw new ManagementFailure('not-bundle');
+                if (enabled) {
+                    const compatibility = evaluatePluginCompatibility(metadata, readProfileVersionExemptions(this.profile.dir));
+                    if (compatibility !== undefined && !compatibility.exempted)
+                        throw new ManagementFailure('incompatible-version', [incompatiblePlugin(compatibility)]);
+                    this.bundleRows(name);
+                }
             }
-            if (enabled)
-                this.bundleRows(name);
             if (!enabled && previous.includes(name)) {
                 if (this.protectsManager(name))
                     throw new ManagementFailure('management-required');
@@ -745,7 +835,7 @@ let PluginManager = (() => {
             }, { waitMs: this.lockWaitMs });
         }
         diskState() {
-            return ['package.json', 'cordis.patch.yml', 'pnpm-workspace.yaml'].map((file) => {
+            return ['package.json', 'cordis.patch.yml', 'pnpm-workspace.yaml', PROFILE_COMPATIBILITY_FILENAME].map((file) => {
                 try {
                     return readFileSync(join(this.profile.dir, file), 'utf8');
                 }

package/lib/types/install-failure.js

@@ -12,6 +12,7 @@ const LOG_KINDS = [
     ['disk-full', /\bENOSPC\b|no space left on device/i],
     ['permission', /\bEACCES\b|\bEPERM\b|permission denied/i],
     ['integrity', /ERR_PNPM_TARBALL_INTEGRITY|ERR_PNPM_BAD_TARBALL_SIZE|\bEINTEGRITY\b/],
+    ['unknown', /The requested URL returned error: 40[134]\b/],
     ['network', /\bENOTFOUND\b|\bECONNRESET\b|\bETIMEDOUT\b|\bECONNREFUSED\b|\bEAI_AGAIN\b|ERR_PNPM_META_FETCH_FAIL|ERR_PNPM_FETCH_5\d\d|ERR_PNPM_FETCH_TIMEOUT|\bFETCH_ERROR\b|socket hang up|Could not resolve host|unable to access/],
 ];
 /**

package/lib/types/operations.d.ts

@@ -1,5 +1,6 @@
 import { type ProfileManifest } from '@deepseek-ai/dsh-app-boot';
 import type { PackageResult, Registry } from './types.ts';
+export { setProfileVersionExemption, readProfileVersionExemptions } from '@deepseek-ai/dsh-app-boot';
 /** Profile and invocation locations supplied by the launcher. */
 export interface PackageOperationContext {
     profile: string;
@@ -24,6 +25,15 @@ export interface PackageOperationOptions {
     onOutput?: (text: string, stream: 'stdout' | 'stderr') => void;
     activateNewBundles?: boolean;
     lockWaitMs?: number;
+    /**
+     * Terminate the run once its captured output has been silent for this long, in
+     * milliseconds. A run stopped this way reports `timedOut`; without a bound, a
+     * child that stops progressing without exiting holds its caller forever. A run
+     * with inherited descriptors captures nothing and is never bound.
+     */
+    idleTimeoutMs?: number;
+    /** Bound on the pre-install registry lookup, in milliseconds; without one a fixed bound applies. */
+    lookupTimeoutMs?: number;
 }
 /** Resolve relative package specs against the caller's directory.
  * @param argument One pnpm argument.
@@ -44,10 +54,14 @@ export declare function bundleManifest(name: string, dir: string, anchor: string
  */
 export declare function saveManifest(dir: string, manifest: ProfileManifest): Promise<void>;
 /** Execute pnpm inside a profile whose caller already holds the profile write lock.
+ * Newly installed or updated direct dependencies are checked even when activation is disabled;
+ * an untouched dependency never blocks an unrelated operation and stays denied at startup.
+ * Compatibility denial restores the profile manifest and lockfile, but leaves downloaded modules on disk.
  * @param context Launcher-owned profile and resolution locations.
  * @param args Pnpm arguments, before relative path anchoring.
  * @param options Output, activation and cancellation policy.
- * @returns Exit status and diagnostic path; service output is bounded, CLI output uses inherited descriptors.
+ * @returns Exit status, whether the silence bound stopped the run, and the diagnostic path.
+ * A compatibility denial returns exit code 1. Service output is bounded; CLI output uses inherited descriptors.
  */
 export declare function runProfilePnpm(context: PackageOperationContext, args: readonly string[], options: PackageOperationOptions): Promise<PackageResult>;
 /** Initialize and run the dsh plugin command with the same write lock as the service.