@dsh-workbench/adapter-supply 1.1.14-beta.2 → 1.1.15

package/dist/bundle-manager.d.ts

@@ -0,0 +1,11 @@
+import type { DshHostContext } from '@dsh-workbench/shared';
+import type { BundleCancellation, BundleChange, BundleInspection, BundleInstallRequest, BundleRegistries, BundleRegistry } from '@dsh-workbench/shared/contract/protocol/bundle-install';
+export interface BundleManager {
+    registries(): Promise<BundleRegistries | null>;
+    inspect(spec: string, registry?: BundleRegistry): Promise<BundleInspection | null>;
+    install(request: BundleInstallRequest): Promise<BundleChange | null>;
+    remove(name: string): Promise<BundleChange | null>;
+    setEnabled?(name: string, enabled: boolean): Promise<BundleChange | null>;
+    cancel(requestId: string): Promise<BundleCancellation | null>;
+}
+export declare function readBundleManager(ctx: DshHostContext): BundleManager | undefined;

package/dist/bundle-manager.js

@@ -0,0 +1,181 @@
+import { RESTART_REASONS } from '@dsh-workbench/shared/contract/protocol/bundle-install';
+const MANAGER_SERVICE = 'pluginManager';
+const APPLICATIONS = ['applied', 'restart-required', 'overridden', 'failed', 'cancelled'];
+const STAGES = ['install', 'enable', 'remove'];
+const PROBLEMS = [
+    'invalid-spec',
+    'already-installed',
+    'not-found',
+    'not-a-package',
+    'not-a-bundle',
+    'not-a-workbench-module',
+    'network',
+    'unknown',
+];
+const SPEC_KINDS = ['registry', 'path', 'git', 'tarball'];
+const FAILURE_KINDS = [
+    'pnpm-missing',
+    'timeout',
+    'not-found',
+    'no-matching-version',
+    'network',
+    'disk-full',
+    'permission',
+    'build-blocked',
+    'integrity',
+    'unknown',
+];
+const CANCELLATIONS = ['cancelled', 'too-late', 'not-running'];
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function asText(value) {
+    return typeof value === 'string' ? value : '';
+}
+function pick(allowed, value) {
+    return typeof value === 'string' && allowed.includes(value) ? value : undefined;
+}
+function asRegistry(value) {
+    if (value === null)
+        return null;
+    return typeof value === 'string' ? value : undefined;
+}
+function asTextArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function asRegistries(raw) {
+    const record = asRecord(raw);
+    if (record === undefined)
+        return null;
+    const registry = asRegistry(record.registry);
+    if (registry === undefined)
+        return null;
+    return {
+        registry,
+        fallbackRegistries: asTextArray(record.fallbackRegistries),
+        resolved: typeof record.resolved === 'string' ? record.resolved : null,
+    };
+}
+function asPackageResult(raw) {
+    const record = asRecord(raw);
+    if (record === undefined)
+        return undefined;
+    const kind = pick(FAILURE_KINDS, record.kind);
+    return {
+        exitCode: typeof record.exitCode === 'number' ? record.exitCode : -1,
+        output: asText(record.output),
+        truncated: record.truncated === true,
+        logPath: asText(record.logPath),
+        ...(kind === undefined ? {} : { kind }),
+    };
+}
+function asChange(raw) {
+    const record = asRecord(raw);
+    if (record === undefined)
+        return null;
+    const application = pick(APPLICATIONS, record.application);
+    const stage = pick(STAGES, record.stage);
+    if (application === undefined || stage === undefined)
+        return null;
+    const error = asRecord(record.error);
+    const packageResult = asPackageResult(record.packageResult);
+    const pendingBuilds = asTextArray(record.pendingBuilds);
+    const restartReason = pick(RESTART_REASONS, record.restartReason);
+    const failedAt = pick(['registry', 'spec-host'], record.failedAt);
+    const bundle = asText(record.bundle);
+    const version = asText(record.version);
+    const errorCode = error === undefined ? '' : asText(error.code);
+    const errorDetail = error === undefined ? '' : asText(error.diagnostic);
+    return {
+        application,
+        stage,
+        changed: record.changed === true,
+        target: asText(record.target),
+        ...(bundle === '' ? {} : { bundle }),
+        ...(version === '' ? {} : { version }),
+        ...(errorCode === '' ? {} : { errorCode }),
+        ...(errorDetail === '' ? {} : { errorDetail }),
+        ...(packageResult === undefined ? {} : { packageResult }),
+        ...(pendingBuilds.length === 0 ? {} : { pendingBuilds }),
+        ...(restartReason === undefined ? {} : { restartReason }),
+        ...(failedAt === undefined ? {} : { failedAt }),
+    };
+}
+function asInspection(raw) {
+    const record = asRecord(raw);
+    if (record === undefined)
+        return null;
+    const status = asText(record.status);
+    if (status === 'refused') {
+        const problem = pick(PROBLEMS, record.problem) ?? 'unknown';
+        const registries = Array.isArray(record.registries)
+            ? record.registries.map(asRegistry).filter((item) => item !== undefined)
+            : [];
+        return {
+            status: 'refused',
+            problem,
+            reason: asText(record.reason),
+            ...(registries.length === 0 ? {} : { registries }),
+        };
+    }
+    if (status !== 'accepted')
+        return null;
+    const kind = pick(SPEC_KINDS, record.kind);
+    const registry = asRegistry(record.registry);
+    if (kind === undefined || registry === undefined)
+        return null;
+    const name = asText(record.name);
+    const version = asText(record.version);
+    const description = asText(record.description);
+    const host = asText(record.host);
+    return {
+        status: 'accepted',
+        kind,
+        bundle: typeof record.bundle === 'boolean' ? record.bundle : null,
+        registry,
+        ...(name === '' ? {} : { name }),
+        ...(version === '' ? {} : { version }),
+        ...(description === '' ? {} : { description }),
+        ...(host === '' ? {} : { host }),
+    };
+}
+export function readBundleManager(ctx) {
+    const face = ctx.get(MANAGER_SERVICE);
+    if (face === undefined)
+        return undefined;
+    if (typeof face.installBundle !== 'function' || typeof face.removeBundle !== 'function')
+        return undefined;
+    return {
+        async registries() {
+            if (typeof face.registries !== 'function')
+                return null;
+            return asRegistries(await face.registries());
+        },
+        async inspect(spec, registry) {
+            if (typeof face.inspect !== 'function')
+                return null;
+            return asInspection(await face.inspect(spec, registry === undefined ? undefined : { registry }));
+        },
+        async install(request) {
+            const options = {
+                ...(request.registry === undefined ? {} : { registry: request.registry }),
+                ...(request.requestId === undefined ? {} : { requestId: request.requestId }),
+                ...(request.approvedBuilds === undefined ? {} : { approvedBuilds: request.approvedBuilds }),
+            };
+            return asChange(await face.installBundle?.(request.spec, options));
+        },
+        async remove(name) {
+            return asChange(await face.removeBundle?.(name));
+        },
+        async setEnabled(name, enabled) {
+            if (typeof face.setBundleEnabled !== 'function')
+                return null;
+            return asChange(await face.setBundleEnabled(name, enabled));
+        },
+        async cancel(requestId) {
+            if (typeof face.cancelInstall !== 'function')
+                return null;
+            return pick(CANCELLATIONS, (asRecord(await face.cancelInstall(requestId)) ?? {}).status) ?? null;
+        },
+    };
+}

package/dist/dsh-plugins.d.ts

@@ -0,0 +1,5 @@
+import type { DshHostContext } from '@dsh-workbench/shared';
+import type { RouteHandler } from '@dsh-workbench/shared/host';
+import type { DshPluginsSnapshot } from '@dsh-workbench/shared/contract/protocol/dsh-plugins';
+export declare function readDshPlugins(ctx: DshHostContext): Promise<DshPluginsSnapshot>;
+export declare function dshPluginsHandler(ctx: DshHostContext): RouteHandler;

package/dist/dsh-plugins.js

@@ -0,0 +1,51 @@
+const MANAGER_SERVICE = 'pluginManager';
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function asArray(value) {
+    if (Array.isArray(value))
+        return value;
+    const record = asRecord(value);
+    if (record === undefined)
+        return [];
+    for (const key of ['rows', 'items', 'list', 'bundles', 'plugins']) {
+        const inner = record[key];
+        if (Array.isArray(inner))
+            return inner;
+    }
+    return [];
+}
+function asText(value) {
+    return typeof value === 'string' ? value : '';
+}
+function rowOf(value) {
+    const record = asRecord(value);
+    if (record === undefined)
+        return undefined;
+    const name = asText(record.name) || asText(record.id);
+    if (name === '')
+        return undefined;
+    return { name, version: asText(record.version), enabled: record.disabled !== true && record.enabled !== false };
+}
+function rowsOf(value) {
+    const rows = [];
+    for (const item of asArray(value)) {
+        const row = rowOf(item);
+        if (row !== undefined)
+            rows.push(row);
+    }
+    return rows;
+}
+export async function readDshPlugins(ctx) {
+    const manager = ctx.get(MANAGER_SERVICE);
+    if (manager === undefined)
+        return { available: false, bundles: [], plugins: [] };
+    const [bundles, plugins] = await Promise.all([
+        manager.listBundles === undefined ? undefined : manager.listBundles(),
+        manager.listPlugins === undefined ? undefined : manager.listPlugins(),
+    ]);
+    return { available: true, bundles: rowsOf(bundles), plugins: rowsOf(plugins) };
+}
+export function dshPluginsHandler(ctx) {
+    return () => readDshPlugins(ctx);
+}

package/dist/installed-module.d.ts

@@ -0,0 +1,51 @@
+import type { DshHostContext } from '@dsh-workbench/shared';
+export interface UnitDeclarationSource {
+    readonly pkg: string;
+    readonly declaration: unknown;
+}
+export type InstalledModule = {
+    readonly kind: 'module';
+    readonly pkg: string;
+    readonly unit: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+} | {
+    readonly kind: 'not-module';
+    readonly pkg: string;
+} | {
+    readonly kind: 'unknown';
+    readonly pkg: string;
+};
+export declare function isPackageName(value: string): boolean;
+export declare function profileDirOf(ctx: DshHostContext): string | null;
+export interface ProfileModule {
+    readonly pkg: string;
+    readonly unit: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+    readonly fromRegistry?: boolean;
+}
+export declare function profileManifestOf(profileDir: string | null): Readonly<Record<string, unknown>> | undefined;
+export declare function profileModules(profileDir: string | null): readonly ProfileModule[];
+export declare function createDeclarationLookup(profileDir: string | null): (unit: string) => UnitDeclarationSource | undefined;
+export declare function moduleDeclarationOf(profileDir: string | null, pkg: string): unknown;
+export interface DeclarationGap {
+    readonly pkg: string;
+    readonly problems: readonly string[];
+}
+export declare function declarationGaps(profileDir: string | null): readonly DeclarationGap[] | undefined;
+export declare function declaredPluginCommands(profileDir: string | null): ReadonlyMap<string, ReadonlySet<string>>;
+export declare function readInstalledModule(profileDir: string | null, pkg: string): InstalledModule;
+export declare function isPackedArtifactSpec(spec: string): boolean;
+export declare function isLocalDependencySpec(spec: string): boolean;
+export declare function isRegistryDependencySpec(spec: string): boolean;
+export interface ProfilePackage {
+    readonly pkg: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+}
+export declare function readProfilePackage(profileDir: string | null, pkg: string): ProfilePackage | undefined;
+export declare function packageVersionAt(packageRoot: string): string | undefined;

package/dist/installed-module.js

@@ -0,0 +1,265 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { declarationProblemsOf, packageSourceOf, readDeclaration, scopeOf } from '@dsh-workbench/shared/host';
+const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function asText(value) {
+    return typeof value === 'string' ? value : '';
+}
+export function isPackageName(value) {
+    return value.length <= 214 && PACKAGE_NAME.test(value);
+}
+export function profileDirOf(ctx) {
+    const profile = ctx.get('profileContext');
+    const dir = typeof profile?.dir === 'string' ? profile.dir.trim() : '';
+    return dir === '' ? null : dir;
+}
+function stringsOf(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+export function profileManifestOf(profileDir) {
+    if (profileDir === null)
+        return undefined;
+    try {
+        return asRecord(JSON.parse(fs.readFileSync(path.join(profileDir, 'package.json'), 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function profileModules(profileDir) {
+    const record = profileManifestOf(profileDir);
+    if (record === undefined)
+        return [];
+    const bundles = stringsOf(asRecord(asRecord(record.dsh)?.profile)?.bundles);
+    const dependencies = asRecord(record.dependencies) ?? {};
+    const names = bundles.length > 0 ? bundles : Object.keys(dependencies);
+    const found = [];
+    for (const pkg of names) {
+        const read = readInstalledModule(profileDir, pkg);
+        if (read.kind === 'module') {
+            const spec = asText(dependencies[read.pkg]);
+            found.push({
+                pkg: read.pkg,
+                unit: read.unit,
+                version: read.version,
+                ...(read.registry === undefined ? {} : { registry: read.registry }),
+                local: isLocalDependencySpec(spec),
+                fromRegistry: isRegistryDependencySpec(spec),
+            });
+        }
+    }
+    return found;
+}
+export function createDeclarationLookup(profileDir) {
+    let roster;
+    const scan = () => new Map(profileModules(profileDir).map((row) => [row.unit, row.pkg]));
+    return (unit) => {
+        roster ??= scan();
+        let pkg = roster.get(unit);
+        if (pkg === undefined) {
+            roster = scan();
+            pkg = roster.get(unit);
+        }
+        return pkg === undefined ? undefined : { pkg, declaration: moduleDeclarationOf(profileDir, pkg) };
+    };
+}
+function registryFromLockfile(profileDir, pkg) {
+    let text;
+    try {
+        text = fs.readFileSync(path.join(profileDir, 'pnpm-lock.yaml'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const at = text.indexOf(`  ${pkg}@`);
+    const quoted = at === -1 ? text.indexOf(`  '${pkg}@`) : at;
+    if (quoted === -1)
+        return undefined;
+    const headerEnd = text.indexOf('\n', quoted);
+    const end = headerEnd === -1 ? -1 : text.indexOf('\n  ', headerEnd + 1);
+    const block = text.slice(quoted, end === -1 ? quoted + 900 : end);
+    const match = /tarball:\s*([^\s,}]+)/.exec(block);
+    const tarball = match?.[1];
+    if (tarball === undefined || !tarball.startsWith('http'))
+        return undefined;
+    const cut = tarball.lastIndexOf(`/${pkg}/`);
+    if (cut <= 'https://'.length)
+        return undefined;
+    return tarball.slice(0, cut);
+}
+function unquoted(value) {
+    const quote = value.charAt(0);
+    if (value.length >= 2 && (quote === '"' || quote === "'") && value.endsWith(quote)) {
+        return value.slice(1, -1).trim();
+    }
+    return value;
+}
+function registryFromNpmrc(profileDir, pkg) {
+    let text;
+    try {
+        text = fs.readFileSync(path.join(profileDir, '.npmrc'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const scope = scopeOf(pkg);
+    let fallback;
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('#') || trimmed.startsWith(';'))
+            continue;
+        const separator = trimmed.indexOf('=');
+        if (separator <= 0)
+            continue;
+        const key = trimmed.slice(0, separator).trim();
+        const value = unquoted(trimmed.slice(separator + 1).trim());
+        if (value === '')
+            continue;
+        if (scope !== null && key === `${scope}:registry`)
+            return value;
+        if (key === 'registry')
+            fallback = value;
+    }
+    return fallback;
+}
+function registryOf(profileDir, pkg, manifest) {
+    const declared = asText(asRecord(manifest.publishConfig)?.registry);
+    if (declared !== '')
+        return declared;
+    const recorded = packageSourceOf(profileDir, pkg);
+    if (recorded !== undefined)
+        return recorded.registry;
+    const locked = registryFromLockfile(profileDir, pkg);
+    return locked === undefined ? registryFromNpmrc(profileDir, pkg) : locked;
+}
+export function moduleDeclarationOf(profileDir, pkg) {
+    if (profileDir === null || !isPackageName(pkg))
+        return undefined;
+    try {
+        const text = fs.readFileSync(path.join(profileDir, 'node_modules', pkg, 'package.json'), 'utf8');
+        return asRecord(asRecord(asRecord(JSON.parse(text))?.dsh)?.workbench);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function declarationGaps(profileDir) {
+    if (profileManifestOf(profileDir) === undefined)
+        return undefined;
+    const gaps = [];
+    for (const module of profileModules(profileDir)) {
+        const problems = declarationProblemsOf(module.pkg, moduleDeclarationOf(profileDir, module.pkg));
+        if (problems.length > 0)
+            gaps.push({ pkg: module.pkg, problems });
+    }
+    return gaps;
+}
+export function declaredPluginCommands(profileDir) {
+    const declared = new Map();
+    for (const module of profileModules(profileDir)) {
+        const read = readDeclaration(module.pkg, moduleDeclarationOf(profileDir, module.pkg));
+        for (const need of read.manifest?.needs ?? []) {
+            if (need.kind !== 'extension')
+                continue;
+            const name = need.name.trim();
+            if (name === '')
+                continue;
+            const commands = declared.get(name) ?? new Set();
+            for (const command of need.commands ?? [])
+                commands.add(command);
+            declared.set(name, commands);
+        }
+    }
+    return declared;
+}
+export function readInstalledModule(profileDir, pkg) {
+    if (profileDir === null || !isPackageName(pkg))
+        return { kind: 'unknown', pkg };
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(path.join(profileDir, 'node_modules', pkg, 'package.json'), 'utf8'));
+    }
+    catch {
+        return { kind: 'unknown', pkg };
+    }
+    const record = asRecord(manifest);
+    if (record === undefined)
+        return { kind: 'unknown', pkg };
+    const declared = asRecord(asRecord(record.dsh)?.workbench);
+    const unit = declared === undefined ? '' : asText(declared.unit);
+    if (unit === '')
+        return { kind: 'not-module', pkg };
+    const registry = registryOf(profileDir, pkg, record);
+    return {
+        kind: 'module',
+        pkg,
+        unit,
+        version: asText(record.version),
+        ...(registry === undefined ? {} : { registry }),
+    };
+}
+const PACKED_ARTIFACT = /\.(?:tgz|tar\.gz|tar)$/i;
+export function isPackedArtifactSpec(spec) {
+    const trimmed = spec.trim();
+    const pkgPath = trimmed.startsWith('file:') ? trimmed.slice('file:'.length) : trimmed;
+    return PACKED_ARTIFACT.test(pkgPath);
+}
+export function isLocalDependencySpec(spec) {
+    const trimmed = spec.trim();
+    if (isPackedArtifactSpec(trimmed))
+        return false;
+    return (trimmed.startsWith('link:') ||
+        trimmed.startsWith('file:') ||
+        trimmed.startsWith('./') ||
+        trimmed.startsWith('../') ||
+        trimmed.startsWith('/'));
+}
+const NON_REGISTRY_SPEC = /^(?:git\+|git:|github:|gitlab:|bitbucket:|https?:|ssh:|workspace:)/i;
+export function isRegistryDependencySpec(spec) {
+    const trimmed = spec.trim();
+    if (trimmed === '')
+        return true;
+    if (isLocalDependencySpec(trimmed) || isPackedArtifactSpec(trimmed))
+        return false;
+    return !NON_REGISTRY_SPEC.test(trimmed);
+}
+export function readProfilePackage(profileDir, pkg) {
+    if (profileDir === null || !isPackageName(pkg))
+        return undefined;
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(path.join(profileDir, 'node_modules', pkg, 'package.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    const record = asRecord(manifest);
+    if (record === undefined)
+        return undefined;
+    const version = asText(record.version);
+    if (version === '')
+        return undefined;
+    const registry = registryOf(profileDir, pkg, record);
+    const dependencies = asRecord(profileManifestOf(profileDir)?.dependencies) ?? {};
+    const local = isLocalDependencySpec(asText(dependencies[pkg]));
+    return {
+        pkg,
+        version,
+        ...(registry === undefined ? {} : { registry }),
+        ...(local ? { local: true } : {}),
+    };
+}
+export function packageVersionAt(packageRoot) {
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    const version = asText(asRecord(manifest)?.version);
+    return version === '' ? undefined : version;
+}

package/dist/package-content.d.ts

@@ -0,0 +1,6 @@
+import type { DshShell } from '@dsh-workbench/shared';
+export declare function withPackageDir<T>(options: {
+    readonly shell?: DshShell | undefined;
+    readonly spec: string;
+    readonly registry?: string | undefined;
+}, visit: (dir: string) => T): Promise<T | undefined>;

package/dist/package-content.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import { npmCacheDir } from '@dsh-workbench/adapter-runtime';
+import os from 'node:os';
+import path from 'node:path';
+import { INSTALL_TIMEOUT_MS, parseJsonLoose, quoteShellArg, runShell } from '@dsh-workbench/shared/host';
+import { splitNpmSpec } from './package-kind.js';
+import { localDirOf } from './registry-declaration.js';
+function packedFileFrom(stdout, root) {
+    const parsed = parseJsonLoose(stdout);
+    if (Array.isArray(parsed)) {
+        const first = parsed[0];
+        const filename = typeof first === 'object' && first !== null ? first.filename : undefined;
+        if (typeof filename === 'string' && filename.trim() !== '') {
+            const at = path.join(root, path.basename(filename.trim()));
+            if (fs.existsSync(at))
+                return at;
+        }
+    }
+    try {
+        const found = fs.readdirSync(root).filter((name) => name.endsWith('.tgz'));
+        return found.length === 1 ? path.join(root, found[0] ?? '') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function withPackageDir(options, visit) {
+    const local = localDirOf(options.spec);
+    if (local !== undefined)
+        return visit(local);
+    if (splitNpmSpec(options.spec) === undefined)
+        return undefined;
+    const shell = options.shell;
+    if (shell === undefined)
+        return undefined;
+    let root;
+    try {
+        root = fs.mkdtempSync(path.join(os.tmpdir(), 'wb-package-'));
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const at = options.registry === undefined ? '' : ` --registry ${quoteShellArg(options.registry)}`;
+        const packed = await runShell(shell, `npm pack ${quoteShellArg(options.spec)} --ignore-scripts --json --pack-destination ${quoteShellArg(root)} --cache ${quoteShellArg(npmCacheDir())}${at}`, { timeoutMs: INSTALL_TIMEOUT_MS }).catch(() => undefined);
+        if (packed === undefined || packed.exitCode !== 0)
+            return undefined;
+        const file = packedFileFrom(packed.stdout, root);
+        if (file === undefined)
+            return undefined;
+        const unpacked = await runShell(shell, `tar -xzf ${quoteShellArg(file)} -C ${quoteShellArg(root)}`, {
+            timeoutMs: INSTALL_TIMEOUT_MS,
+        }).catch(() => undefined);
+        if (unpacked === undefined || unpacked.exitCode !== 0)
+            return undefined;
+        const dir = path.join(root, 'package');
+        if (!fs.existsSync(dir))
+            return undefined;
+        return visit(dir);
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}

package/dist/package-kind.d.ts

@@ -0,0 +1,21 @@
+export type PackageKind = 'runtime-plugin' | 'dsh-bundle' | 'both' | 'neither';
+export interface PackageVerdict {
+    readonly kind: PackageKind;
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export interface NpmRef {
+    readonly name: string;
+    readonly version?: string;
+}
+export declare const OPENCLI_MANIFEST_FILE = "opencli-plugin.json";
+export declare function splitNpmSpec(spec: string): NpmRef | undefined;
+export declare function isCommandFile(name: string): boolean;
+export declare function pluginManifestOf(dir: string): Readonly<Record<string, unknown>> | undefined;
+export declare function hasCommandFile(dir: string): boolean;
+export declare function pluginAt(dir: string): {
+    readonly name?: string;
+} | undefined;
+export declare function dshMarkersOf(raw: unknown): boolean;
+export declare function verdictOf(dir: string): PackageVerdict | undefined;
+export declare function refusalReason(): string;

package/dist/package-kind.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isPackageName } from '@dsh-workbench/shared/host';
+import { dshRecordOf, packageManifestOf, packageNameOf } from './registry-declaration.js';
+export const OPENCLI_MANIFEST_FILE = 'opencli-plugin.json';
+const VERSION = /^[a-zA-Z0-9][a-zA-Z0-9._+-]*$/;
+export function splitNpmSpec(spec) {
+    const value = spec.trim();
+    const at = value.lastIndexOf('@');
+    const name = at > 0 ? value.slice(0, at) : value;
+    const version = at > 0 ? value.slice(at + 1) : '';
+    if (!isPackageName(name))
+        return undefined;
+    if (version !== '' && !VERSION.test(version))
+        return undefined;
+    return { name, ...(version === '' ? {} : { version }) };
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+export function isCommandFile(name) {
+    if (name.endsWith('.d.ts') || name.endsWith('.test.ts'))
+        return false;
+    if (name.endsWith('.d.js'))
+        return false;
+    return name.endsWith('.ts') || name.endsWith('.js');
+}
+export function pluginManifestOf(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, OPENCLI_MANIFEST_FILE), 'utf8'));
+        if (Array.isArray(parsed))
+            return undefined;
+        return asRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hasCommandFile(dir) {
+    try {
+        return fs.readdirSync(dir).some(isCommandFile);
+    }
+    catch {
+        return false;
+    }
+}
+export function pluginAt(dir) {
+    const manifest = pluginManifestOf(dir);
+    if (manifest === undefined || !hasCommandFile(dir))
+        return undefined;
+    const name = manifest.name;
+    return typeof name === 'string' && name.trim() !== '' ? { name: name.trim() } : {};
+}
+export function dshMarkersOf(raw) {
+    const record = asRecord(raw);
+    return record !== undefined && ('bundle' in record || 'workbench' in record);
+}
+export function verdictOf(dir) {
+    const plugin = pluginAt(dir);
+    if (packageManifestOf(dir) === undefined && plugin === undefined)
+        return undefined;
+    const dsh = dshMarkersOf(dshRecordOf(dir));
+    const kind = plugin !== undefined && dsh ? 'both' : plugin !== undefined ? 'runtime-plugin' : dsh ? 'dsh-bundle' : 'neither';
+    const pkg = packageNameOf(dir);
+    return {
+        kind,
+        ...(pkg === undefined ? {} : { pkg }),
+        ...(plugin?.name === undefined ? {} : { pluginName: plugin.name }),
+    };
+}
+export function refusalReason() {
+    return '这个包既不是工作台的模块，也不是 opencli 的插件，装了也用不上';
+}

package/dist/package-route.d.ts

@@ -1,10 +1,10 @@
-import type { DshShell, ResolvedPluginSource } from '@dsh-workbench/shared';
-import type { PackageRoute } from '@dsh-workbench/shared/host';
+import type { ResolvedPluginSource } from '@dsh-workbench/shared';
+import type { PackageRoute, Seam } from '@dsh-workbench/shared/host';
 export declare const LOCAL_PLUGIN_ENV = "DSH_WB_OPENCLI_PLUGIN_PATH";
 export declare const PLUGIN_REGISTRY_ENV = "DSH_WB_OPENCLI_PLUGIN_REGISTRY";
 export declare function packageRouteOf(options: {
     readonly spec: string;
-    readonly shell?: DshShell | undefined;
+    readonly seam?: Seam | undefined;
     readonly registry?: string | undefined;
     readonly force?: boolean;
 }): Promise<PackageRoute | undefined>;

package/dist/package-route.js

@@ -1,12 +1,11 @@
 import { createPackageRouter, localDirOf, splitNpmSpec } from '@dsh-workbench/shared/host';
-import { npmCacheDir, OPENCLI_MANIFEST_FILE } from '@dsh-workbench/adapter-runtime';
+import { OPENCLI_MANIFEST_FILE } from '@dsh-workbench/adapter-runtime';
 import { registryDshOf } from './registry-declaration.js';
 import { resolvePluginSource } from './plugin-source.js';
 export const LOCAL_PLUGIN_ENV = 'DSH_WB_OPENCLI_PLUGIN_PATH';
 export const PLUGIN_REGISTRY_ENV = 'DSH_WB_OPENCLI_PLUGIN_REGISTRY';
 const router = createPackageRouter({
     manifestFile: OPENCLI_MANIFEST_FILE,
-    cacheDir: npmCacheDir(),
     dshLookup: (options) => registryDshOf(options),
 });
 export async function packageRouteOf(options) {

package/dist/plugin-catalog.d.ts

@@ -1,4 +1,4 @@
-import type { DshShell } from '@dsh-workbench/shared';
+import { type Seam } from '@dsh-workbench/shared/host';
 export interface PluginCommandArg {
     readonly name: string;
     readonly type: string;
@@ -52,7 +52,7 @@ export interface PluginCatalog {
     snapshot(): PluginCatalogSnapshot;
 }
 export interface PluginCatalogOptions {
-    readonly shell?: DshShell | undefined;
+    readonly seam?: Seam | undefined;
     readonly command: string;
     readonly timeoutMs?: number;
 }

package/dist/plugin-catalog.js

@@ -1,4 +1,4 @@
-import { OPENCLI_TIMEOUT_MS, parseJsonLoose, runShell } from '@dsh-workbench/shared/host';
+import { OPENCLI_TIMEOUT_MS, now, parseJsonLoose, productWrite } from '@dsh-workbench/shared/host';
 function recordOf(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
 }
@@ -141,12 +141,12 @@ export function createPluginCatalog(options) {
     };
     let heavy;
     async function read(line) {
-        const shell = options.shell;
-        if (shell === undefined) {
-            return { ok: false, problem: '没有执行缝（shell 服务不可用），探不了这个命令面' };
+        const seam = options.seam;
+        if (seam === undefined) {
+            return { ok: false, problem: '没有执行缝，探不了这个命令面' };
         }
         try {
-            const result = await runShell(shell, line, { timeoutMs });
+            const result = await seam.run({ command: line, intent: productWrite(), retry: 'safe', timeoutMs });
             if (result.timedOut)
                 return { ok: false, problem: `${line} 超过 ${String(Math.round(timeoutMs / 1000))} 秒没返回` };
             if (result.exitCode !== 0) {
@@ -160,7 +160,7 @@ export function createPluginCatalog(options) {
         }
     }
     function fail(problem) {
-        current = { ok: false, at: Date.now(), sets: current.sets, problems: [problem] };
+        current = { ok: false, at: now(), sets: current.sets, problems: [problem] };
         return current;
     }
     async function refresh(callOptions = {}) {
@@ -173,7 +173,7 @@ export function createPluginCatalog(options) {
         }
         const fingerprint = fingerprintOf(plugins);
         if (!callOptions.force && heavy !== undefined && heavy.fingerprint === fingerprint) {
-            current = { ok: true, at: Date.now(), sets: heavy.sets, problems: heavy.problems };
+            current = { ok: true, at: now(), sets: heavy.sets, problems: heavy.problems };
             return current;
         }
         const commandsRun = await read(`${options.command} list -f json`);
@@ -185,7 +185,7 @@ export function createPluginCatalog(options) {
         }
         const attributed = attributeCommands(plugins, rows);
         heavy = { fingerprint, sets: attributed.sets, problems: attributed.problems };
-        current = { ok: true, at: Date.now(), sets: attributed.sets, problems: attributed.problems };
+        current = { ok: true, at: now(), sets: attributed.sets, problems: attributed.problems };
         return current;
     }
     return { refresh, snapshot: () => current };

package/dist/plugin-units.js

@@ -1,3 +1,4 @@
+import { now as clockNow } from '@dsh-workbench/shared/host';
 import { PROBE_TTL_MS, TEXT_OUTPUT, jsonText, sessionWorkspace, unitTitleKey } from '@dsh-workbench/shared/host';
 import { pluginLoginHint } from './plugin-login-hint.js';
 import { PLUGIN_PROMPT_BUDGET, RUN_CODE_TOOL, pluginApprovalFor, pluginPromptChars, pluginToolArgv, pluginToolDescription, pluginToolName, pluginToolParameters, pluginToolSession, pluginToolWrites, } from './plugin-tools.js';
@@ -213,13 +214,13 @@ export function createPluginUnits(options) {
                 ...probed.problems,
                 '这次探测没成功：上面这些插件行的工具面维持在上一份（不是"这些插件没有命令"）',
             ];
-            report = { ok: false, at: Date.now(), plugins: report.plugins, problems };
+            report = { ok: false, at: clockNow(), plugins: report.plugins, problems };
             warn(problems);
             return snapshot();
         }
         const plan = planOf(options, registered);
         reconcile(registered, plan.units, options, note);
-        report = { ok: true, at: Date.now(), plugins: plan.rows, problems: plan.problems };
+        report = { ok: true, at: clockNow(), plugins: plan.rows, problems: plan.problems };
         warn(plan.problems);
         return snapshot();
     }
@@ -235,7 +236,7 @@ export function createPluginUnits(options) {
     return {
         refresh,
         touch() {
-            const now = Date.now();
+            const now = clockNow();
             if (inflight !== undefined)
                 return;
             if (now - lastTouch < PROBE_TTL_MS)

package/dist/registry-declaration.d.ts

@@ -1,8 +1,8 @@
-import type { DshShell } from '@dsh-workbench/shared';
+import type { Seam } from '@dsh-workbench/shared/host';
 export { declarationRefusalOf, dshRecordOf, localDirOf, packageManifestOf, packageNameOf, pathDeclarationOf, } from '@dsh-workbench/shared/host';
 export type { RegistryDshLookup } from '@dsh-workbench/shared/host';
 export declare function registryDshOf(options: {
-    shell: DshShell;
+    seam: Seam;
     name: string;
     registry?: string | undefined;
     force?: boolean;
@@ -11,7 +11,7 @@ export declare function registryDshOf(options: {
     readonly raw: unknown;
 }>;
 export declare function registryDeclarationOf(options: {
-    shell: DshShell;
+    seam: Seam;
     name: string;
     registry: string;
     force?: boolean;

package/dist/registry-declaration.js

@@ -1,10 +1,9 @@
-import { npmCacheDir } from '@dsh-workbench/adapter-runtime';
 import { createRegistryLookup } from '@dsh-workbench/shared/host';
 export { declarationRefusalOf, dshRecordOf, localDirOf, packageManifestOf, packageNameOf, pathDeclarationOf, } from '@dsh-workbench/shared/host';
 const lookup = createRegistryLookup();
 export async function registryDshOf(options) {
-    return lookup.registryDshOf({ ...options, cacheDir: npmCacheDir() });
+    return lookup.registryDshOf(options);
 }
 export async function registryDeclarationOf(options) {
-    return lookup.registryDeclarationOf({ ...options, cacheDir: npmCacheDir() });
+    return lookup.registryDeclarationOf(options);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-workbench/adapter-supply",
-  "version": "1.1.14-beta.2",
+  "version": "1.1.15",
   "description": "Workbench supply adapter package.",
   "type": "module",
   "exports": {
@@ -22,8 +22,8 @@
     "directory": "packages/adapter-supply"
   },
   "dependencies": {
-    "@dsh-workbench/adapter-runtime": "1.1.14-beta.2",
-    "@dsh-workbench/shared": "1.1.14-beta.2"
+    "@dsh-workbench/adapter-runtime": "1.1.15",
+    "@dsh-workbench/shared": "1.1.15"
   },
   "devDependencies": {
     "@types/node": "^24.19.0",