@dsh-workbench/adapter-supply 0.0.0-stage → 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-workbench contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,27 @@
-# Temporary Holding Version
+# @dsh-workbench/adapter-supply
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+工作台的供应适配器。
+
+## 职责
+
+- 已安装模块发现与声明校验
+- bundle / package / plugin 路由与安装计划
+- registry 声明、插件目录与登录提示
+- 插件来源解析（plugin-source）
+
+## 入口
+
+```ts
+import { profileDirOf, profileModules, readInstalledModule } from '@dsh-workbench/adapter-supply';
+```
+
+## 边界
+
+只依赖 `@dsh-workbench/shared` 的宿主契约与纯工具；不读取 core 内部文件，不拥有 profile 的 self-update。
+
+## 验证
+
+```bash
+pnpm --filter @dsh-workbench/adapter-supply run build
+pnpm --filter @dsh-workbench/adapter-supply run test
+```

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/index.d.ts

@@ -0,0 +1,12 @@
+export * from './registry-declaration.js';
+export * from './installed-module.js';
+export * from './package-route.js';
+export * from './plugin-login-hint.js';
+export * from './package-kind.js';
+export * from './package-content.js';
+export * from './plugin-units.js';
+export * from './plugin-tools.js';
+export * from './dsh-plugins.js';
+export * from './plugin-catalog.js';
+export * from './bundle-manager.js';
+export * from './plugin-source.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from './registry-declaration.js';
+export * from './installed-module.js';
+export * from './package-route.js';
+export * from './plugin-login-hint.js';
+export * from './package-kind.js';
+export * from './package-content.js';
+export * from './plugin-units.js';
+export * from './plugin-tools.js';
+export * from './dsh-plugins.js';
+export * from './plugin-catalog.js';
+export * from './bundle-manager.js';
+export * from './plugin-source.js';

package/dist/installed-module.d.ts

@@ -0,0 +1,49 @@
+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;
+}
+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 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,210 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { declarationProblemsOf, readDeclaration } 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')
+            found.push({
+                pkg: read.pkg,
+                unit: read.unit,
+                version: read.version,
+                ...(read.registry === undefined ? {} : { registry: read.registry }),
+                local: isLocalDependencySpec(asText(dependencies[read.pkg])),
+            });
+    }
+    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);
+}
+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 declaredRegistry = asText(asRecord(record.publishConfig)?.registry);
+    const registry = declaredRegistry === '' ? registryFromLockfile(profileDir, pkg) : declaredRegistry;
+    return {
+        kind: 'module',
+        pkg,
+        unit,
+        version: asText(record.version),
+        ...(registry === '' ? {} : { 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('/'));
+}
+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 declaredRegistry = asText(asRecord(record.publishConfig)?.registry);
+    const registry = declaredRegistry === '' ? registryFromLockfile(profileDir, pkg) : declaredRegistry;
+    const dependencies = asRecord(profileManifestOf(profileDir)?.dependencies) ?? {};
+    const local = isLocalDependencySpec(asText(dependencies[pkg]));
+    return {
+        pkg,
+        version,
+        ...(registry === '' ? {} : { 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 });
+    }
+}