@dsh-workbench/shared 1.1.8 → 1.1.9

package/dist/host/local-declaration.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { localDirOf } from './spec.js';
+export { localDirOf };
+import { declarationProblemsOf } from '../contract/unit-declaration.js';
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+export function packageManifestOf(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        return asRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function dshRecordOf(dir) {
+    return packageManifestOf(dir)?.dsh;
+}
+export function packageNameOf(dir) {
+    const name = packageManifestOf(dir)?.name;
+    return typeof name === 'string' && name.trim() !== '' ? name.trim() : undefined;
+}
+export function pathDeclarationOf(spec) {
+    const dir = localDirOf(spec);
+    return dir === undefined ? undefined : asRecord(dshRecordOf(dir))?.workbench;
+}
+export function declarationRefusalOf(name, raw) {
+    if (raw === undefined)
+        return [];
+    return declarationProblemsOf(name, raw);
+}

package/dist/host/module-root.d.ts

@@ -0,0 +1 @@
+export declare function packageRootOf(moduleUrl: string): string;

package/dist/host/module-root.js

@@ -0,0 +1,5 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function packageRootOf(moduleUrl) {
+    return dirname(dirname(dirname(fileURLToPath(moduleUrl))));
+}

package/dist/host/npm-registry.d.ts

@@ -0,0 +1,10 @@
+export declare function npmRegistryOf(source: {
+    readonly registryEnv?: string;
+    readonly registryDefault?: string;
+}, env: Readonly<Record<string, string | undefined>>): {
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly env: string;
+};

package/dist/host/npm-registry.js

@@ -0,0 +1,16 @@
+function envValue(env, name) {
+    const value = env[name]?.trim();
+    return value === undefined || value === '' ? { ok: false } : { ok: true, value };
+}
+export function npmRegistryOf(source, env) {
+    const name = source.registryEnv ?? '';
+    if (name !== '') {
+        const fromEnv = envValue(env, name);
+        if (fromEnv.ok)
+            return fromEnv;
+    }
+    const fallback = source.registryDefault?.trim();
+    if (fallback === undefined || fallback === '')
+        return { ok: false, env: name };
+    return { ok: true, value: fallback };
+}

package/dist/host/opencli-runner.d.ts

@@ -2,9 +2,10 @@ import type { DataRequest, DataResult } from '../contract/data.js';
 /**
  * 一条 opencli 命令的执行器：同一形状的 `execFile('opencli', args)`，结果只留 stdout。
  */
-export type OpencliRunner = (args: readonly string[]) => Promise<{
+export type LibRunner = (args: readonly string[]) => Promise<{
     readonly stdout: string;
 }>;
+export type OpencliRunner = LibRunner;
 /**
  * 读缝（`DataReader.read`）的形状；模块直接把自己的 `data.read` 传进来即可。
  */

package/dist/host/package-content.d.ts

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

package/dist/host/package-content.js

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { INSTALL_TIMEOUT_MS } from '../config/constants.js';
+import { parseJsonLoose } from '../lib/text.js';
+import { quoteShellArg } from './shell-text.js';
+import { runShell } from './shell.js';
+import { splitNpmSpec } from './package-kind.js';
+import { localDirOf } from './local-declaration.js';
+function cacheFlag(cacheDir) {
+    return cacheDir === undefined ? '' : ` --cache ${quoteShellArg(cacheDir)}`;
+}
+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)}${cacheFlag(options.cacheDir)}${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/host/package-kind.d.ts

@@ -0,0 +1,13 @@
+export { splitNpmSpec } from './spec.js';
+export type { NpmRef } from './spec.js';
+export type PackageKind = 'runtime-plugin' | 'dsh-bundle' | 'both' | 'neither';
+export interface PackageVerdict {
+    readonly kind: PackageKind;
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export declare function isCommandFile(name: string): boolean;
+export declare function pluginManifestOf(dir: string, manifestFile: string): Readonly<Record<string, unknown>> | undefined;
+export declare function hasCommandFile(dir: string): boolean;
+export declare function dshMarkersOf(raw: unknown): boolean;
+export declare function verdictOf(dir: string, manifestFile: string): PackageVerdict | undefined;

package/dist/host/package-kind.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export { splitNpmSpec } from './spec.js';
+import { dshRecordOf, packageManifestOf, packageNameOf } from './local-declaration.js';
+import { pluginAt } from './plugin.js';
+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, manifestFile) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, manifestFile), '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 dshMarkersOf(raw) {
+    const record = asRecord(raw);
+    return record !== undefined && ('bundle' in record || 'workbench' in record);
+}
+export function verdictOf(dir, manifestFile) {
+    const plugin = pluginAt(dir, manifestFile);
+    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 }),
+    };
+}

package/dist/host/package-route.d.ts

@@ -0,0 +1,31 @@
+import type { DshShell } from '../api/dsh.js';
+export type PackageRouteKind = 'runtime-plugin' | 'dsh-bundle' | 'neither';
+export interface PackageRoute {
+    readonly kind: PackageRouteKind;
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export interface PackageRouter {
+    packageRouteOf(options: RouteOptions): Promise<PackageRoute | undefined>;
+    reset(): void;
+}
+interface RouteOptions {
+    readonly spec: string;
+    readonly shell?: DshShell | undefined;
+    readonly registry?: string | undefined;
+    readonly force?: boolean;
+}
+export interface PackageRouterOptions {
+    readonly manifestFile: string;
+    readonly cacheDir?: string | undefined;
+    readonly dshLookup?: ((options: {
+        shell: DshShell;
+        name: string;
+        registry: string;
+    }) => Promise<{
+        readable: boolean;
+        raw: unknown;
+    }>) | undefined;
+}
+export declare function createPackageRouter(options: PackageRouterOptions): PackageRouter;
+export {};

package/dist/host/package-route.js

@@ -0,0 +1,57 @@
+import { VERSION_CHECK_TTL_MS } from '../config/constants.js';
+import { dshMarkersOf, splitNpmSpec, verdictOf } from './package-kind.js';
+import { withPackageDir } from './package-content.js';
+import { localDirOf } from './local-declaration.js';
+function routeOfVerdict(verdict, fallback) {
+    const pkg = verdict.pkg ?? fallback;
+    if (verdict.kind === 'neither')
+        return { kind: 'neither', ...(pkg === undefined ? {} : { pkg }) };
+    if (verdict.kind === 'dsh-bundle' || verdict.kind === 'both')
+        return { kind: 'dsh-bundle' };
+    return {
+        kind: 'runtime-plugin',
+        ...(pkg === undefined ? {} : { pkg }),
+        ...(verdict.pluginName === undefined ? {} : { pluginName: verdict.pluginName }),
+    };
+}
+export function createPackageRouter(options) {
+    const cache = new Map();
+    return {
+        packageRouteOf: (routeOptions) => routeOf(cache, options, routeOptions),
+        reset: () => {
+            cache.clear();
+        },
+    };
+}
+async function routeOf(cache, options, routeOptions) {
+    const local = localDirOf(routeOptions.spec);
+    if (local !== undefined) {
+        const verdict = verdictOf(local, options.manifestFile);
+        return verdict === undefined ? undefined : routeOfVerdict(verdict, splitNpmSpec(routeOptions.spec)?.name);
+    }
+    const ref = splitNpmSpec(routeOptions.spec);
+    if (ref === undefined)
+        return undefined;
+    const shell = routeOptions.shell;
+    const registry = routeOptions.registry;
+    if (shell === undefined || registry === undefined)
+        return undefined;
+    const key = `${registry}|${routeOptions.spec}`;
+    const hit = cache.get(key);
+    if (routeOptions.force !== true && hit !== undefined && Date.now() - hit.at < VERSION_CHECK_TTL_MS) {
+        return hit.route ?? undefined;
+    }
+    const found = options.dshLookup === undefined
+        ? { readable: false, raw: undefined }
+        : await options.dshLookup({ shell, name: routeOptions.spec, registry });
+    let route;
+    if (found.readable && dshMarkersOf(found.raw)) {
+        route = { kind: 'dsh-bundle' };
+    }
+    else {
+        const verdict = await withPackageDir({ shell, spec: routeOptions.spec, registry, ...(options.cacheDir === undefined ? {} : { cacheDir: options.cacheDir }) }, (dir) => verdictOf(dir, options.manifestFile));
+        route = verdict === undefined ? undefined : routeOfVerdict(verdict, ref.name);
+    }
+    cache.set(key, { at: Date.now(), route: route ?? null });
+    return route;
+}

package/dist/host/paths.d.ts

@@ -1,19 +1,11 @@
-export declare function isolatedRoot(): string;
-export declare function isolatedHome(): string;
-export declare function vendorPrefix(): string;
-export declare function vendorPluginsDir(): string;
-export declare function libsPrefix(): string;
-export declare const OPENCLI_NPM_PACKAGE = "@jackwener/opencli";
-export declare function toolchainOpencliDir(): string;
-export declare function vendorPeerLink(): {
-    readonly dir: string;
-    readonly parent: string;
-};
-export declare function npmCacheDir(): string;
-export declare function libsBinDir(): string;
-/**
- * 把隔离运行时的共用依赖 bin 目录放到 PATH 最前面（可执行文件都从这儿找）。
- * @param env 改哪份环境（默认当前进程）。
- * @returns 真的插进去了就 `true`；已经在里面就 `false`。
- */
-export declare function ensureLibsBinOnPath(env?: NodeJS.ProcessEnv): boolean;
+export interface RuntimeLayout {
+    readonly root: string;
+    readonly home: string;
+    readonly vendorPrefix: string;
+    readonly vendorPluginsDir: string;
+    readonly libsPrefix: string;
+    readonly libsBinDir: string;
+    readonly npmCacheDir: string;
+}
+export declare function runtimeRootOf(id: string): string;
+export declare function runtimeLayoutOf(id: string): RuntimeLayout;

package/dist/host/paths.js

@@ -1,45 +1,18 @@
-import { delimiter } from 'node:path';
 import { workbenchRoot } from './data-root.js';
-export function isolatedRoot() {
-    return `${workbenchRoot()}/opencli`;
-}
-export function isolatedHome() {
-    return `${isolatedRoot()}/home`;
-}
-export function vendorPrefix() {
-    return `${isolatedRoot()}/plugins-npm`;
-}
-export function vendorPluginsDir() {
-    return `${vendorPrefix()}/node_modules`;
-}
-export function libsPrefix() {
-    return `${isolatedRoot()}/libs`;
-}
-export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
-export function toolchainOpencliDir() {
-    return `${isolatedRoot()}/toolchain/node_modules/${OPENCLI_NPM_PACKAGE}`;
-}
-export function vendorPeerLink() {
-    const base = `${vendorPrefix()}/node_modules`;
-    const [scope] = OPENCLI_NPM_PACKAGE.split('/');
-    return { dir: `${base}/${OPENCLI_NPM_PACKAGE}`, parent: `${base}/${scope}` };
-}
-export function npmCacheDir() {
-    return `${isolatedRoot()}/npm-cache`;
-}
-export function libsBinDir() {
-    return `${libsPrefix()}/node_modules/.bin`;
-}
-/**
- * 把隔离运行时的共用依赖 bin 目录放到 PATH 最前面（可执行文件都从这儿找）。
- * @param env 改哪份环境（默认当前进程）。
- * @returns 真的插进去了就 `true`；已经在里面就 `false`。
- */
-export function ensureLibsBinOnPath(env = process.env) {
-    const dir = libsBinDir();
-    const parts = (env.PATH ?? '').split(delimiter).filter((one) => one !== '');
-    if (parts.includes(dir))
-        return false;
-    env.PATH = [dir, ...parts].join(delimiter);
-    return true;
+export function runtimeRootOf(id) {
+    return `${workbenchRoot()}/${id}`;
+}
+export function runtimeLayoutOf(id) {
+    const root = runtimeRootOf(id);
+    const vendorPrefix = `${root}/plugins-npm`;
+    const libsPrefix = `${root}/libs`;
+    return {
+        root,
+        home: `${root}/home`,
+        vendorPrefix,
+        vendorPluginsDir: `${vendorPrefix}/node_modules`,
+        libsPrefix,
+        libsBinDir: `${libsPrefix}/node_modules/.bin`,
+        npmCacheDir: `${root}/npm-cache`,
+    };
 }

package/dist/host/platform.js

@@ -33,7 +33,7 @@ export function hostSurface(input = {}) {
         restartHint: deployment === 'desktop' ? '退出并重开 Desktop' : '重启一次 dsh',
         toolchain: {
             node: { source: deployment === 'desktop' ? 'desktop-shim' : 'path' },
-            npm: { neededFor: 'opencli-install' },
+            npm: { neededFor: 'runtime-install' },
             pnpm: { neededFor: 'workshop', expectedMajor: 10 },
         },
     };

package/dist/host/plugin-ledger.d.ts

@@ -1,7 +1,7 @@
 import type { ModuleStore } from './workspace-store.js';
 export declare const PLUGIN_LEDGER_FILE = "plugins.json";
 export interface PluginLedgerEntry {
-    readonly opencliHome: string;
+    readonly home: string;
     readonly package: string;
     readonly name?: string;
     readonly registry?: string;
@@ -10,23 +10,23 @@ export interface PluginLedgerEntry {
     readonly releasedAt?: string;
 }
 export declare function ledgerKeyOf(entry: {
-    readonly opencliHome: string;
+    readonly home: string;
     readonly package: string;
 }): string;
 export declare function parsePluginLedger(raw: unknown): PluginLedgerEntry[];
 export declare function readPluginLedger(store: ModuleStore): PluginLedgerEntry[];
 export declare function writePluginLedger(store: ModuleStore, entries: readonly PluginLedgerEntry[]): void;
-export declare function pluginEntriesOfHome(entries: readonly PluginLedgerEntry[], opencliHome: string): PluginLedgerEntry[];
+export declare function pluginEntriesOfHome(entries: readonly PluginLedgerEntry[], home: string): PluginLedgerEntry[];
 export declare function isHeldEntry(entry: PluginLedgerEntry): boolean;
-export declare function heldEntriesOfHome(entries: readonly PluginLedgerEntry[], opencliHome: string): PluginLedgerEntry[];
-export declare function heldEntryOfPlugin(entries: readonly PluginLedgerEntry[], opencliHome: string, plugin: string): PluginLedgerEntry | undefined;
-export declare function withReleasedEntry(entries: readonly PluginLedgerEntry[], opencliHome: string, pkg: string, releasedAt: string): PluginLedgerEntry[];
+export declare function heldEntriesOfHome(entries: readonly PluginLedgerEntry[], home: string): PluginLedgerEntry[];
+export declare function heldEntryOfPlugin(entries: readonly PluginLedgerEntry[], home: string, plugin: string): PluginLedgerEntry | undefined;
+export declare function withReleasedEntry(entries: readonly PluginLedgerEntry[], home: string, pkg: string, releasedAt: string): PluginLedgerEntry[];
 export type PluginRetention = 'remove' | 'keep-held' | 'keep-claimed' | 'keep-unsure';
 export declare function pluginRetentionOf(options: {
     readonly held: boolean;
     readonly claimedBy: readonly string[];
     readonly trustworthy: boolean;
 }): PluginRetention;
-export declare function pluginEntryOf(entries: readonly PluginLedgerEntry[], opencliHome: string, pkg: string): PluginLedgerEntry | undefined;
+export declare function pluginEntryOf(entries: readonly PluginLedgerEntry[], home: string, pkg: string): PluginLedgerEntry | undefined;
 export declare function withPluginEntry(entries: readonly PluginLedgerEntry[], entry: PluginLedgerEntry): PluginLedgerEntry[];
-export declare function withoutPluginEntry(entries: readonly PluginLedgerEntry[], opencliHome: string, pkg: string): PluginLedgerEntry[];
+export declare function withoutPluginEntry(entries: readonly PluginLedgerEntry[], home: string, pkg: string): PluginLedgerEntry[];

package/dist/host/plugin-ledger.js

@@ -1,6 +1,6 @@
 export const PLUGIN_LEDGER_FILE = 'plugins.json';
 export function ledgerKeyOf(entry) {
-    return `${entry.opencliHome}\u0000${entry.package}`;
+    return `${entry.home}\u0000${entry.package}`;
 }
 function textOf(value) {
     if (typeof value !== 'string')
@@ -8,20 +8,27 @@ function textOf(value) {
     const trimmed = value.trim();
     return trimmed === '' ? undefined : trimmed;
 }
+function legacyHomeOf(box) {
+    for (const [key, value] of Object.entries(box)) {
+        if (key !== 'home' && key.toLowerCase().endsWith('home'))
+            return value;
+    }
+    return undefined;
+}
 function entryOf(value) {
     if (typeof value !== 'object' || value === null)
         return undefined;
     const box = value;
-    const opencliHome = textOf(box['opencliHome']);
+    const home = textOf(box['home']) ?? textOf(legacyHomeOf(box));
     const pkg = textOf(box['package']);
     const installedAt = textOf(box['installedAt']);
-    if (opencliHome === undefined || pkg === undefined || installedAt === undefined)
+    if (home === undefined || pkg === undefined || installedAt === undefined)
         return undefined;
     const name = textOf(box['name']);
     const registry = textOf(box['registry']);
     const releasedAt = textOf(box['releasedAt']);
     return {
-        opencliHome,
+        home,
         package: pkg,
         installedAt,
         ...(name === undefined ? {} : { name }),
@@ -57,23 +64,23 @@ export function writePluginLedger(store, entries) {
     }
     store.write(PLUGIN_LEDGER_FILE, { entries });
 }
-export function pluginEntriesOfHome(entries, opencliHome) {
-    return entries.filter((entry) => entry.opencliHome === opencliHome);
+export function pluginEntriesOfHome(entries, home) {
+    return entries.filter((entry) => entry.home === home);
 }
 export function isHeldEntry(entry) {
     return entry.releasedAt === undefined;
 }
-export function heldEntriesOfHome(entries, opencliHome) {
-    return pluginEntriesOfHome(entries, opencliHome).filter(isHeldEntry);
+export function heldEntriesOfHome(entries, home) {
+    return pluginEntriesOfHome(entries, home).filter(isHeldEntry);
 }
-export function heldEntryOfPlugin(entries, opencliHome, plugin) {
+export function heldEntryOfPlugin(entries, home, plugin) {
     const key = plugin.trim();
     if (key === '')
         return undefined;
-    return heldEntriesOfHome(entries, opencliHome).find((entry) => entry.name === key || entry.package === key);
+    return heldEntriesOfHome(entries, home).find((entry) => entry.name === key || entry.package === key);
 }
-export function withReleasedEntry(entries, opencliHome, pkg, releasedAt) {
-    const entry = pluginEntryOf(entries, opencliHome, pkg);
+export function withReleasedEntry(entries, home, pkg, releasedAt) {
+    const entry = pluginEntryOf(entries, home, pkg);
     if (entry === undefined || entry.releasedAt !== undefined)
         return [...entries];
     return withPluginEntry(entries, { ...entry, releasedAt });
@@ -85,15 +92,15 @@ export function pluginRetentionOf(options) {
         return 'keep-unsure';
     return options.claimedBy.length > 0 ? 'keep-claimed' : 'remove';
 }
-export function pluginEntryOf(entries, opencliHome, pkg) {
-    const key = ledgerKeyOf({ opencliHome, package: pkg });
+export function pluginEntryOf(entries, home, pkg) {
+    const key = ledgerKeyOf({ home, package: pkg });
     return entries.find((entry) => ledgerKeyOf(entry) === key);
 }
 export function withPluginEntry(entries, entry) {
     const key = ledgerKeyOf(entry);
     return [...entries.filter((item) => ledgerKeyOf(item) !== key), entry];
 }
-export function withoutPluginEntry(entries, opencliHome, pkg) {
-    const key = ledgerKeyOf({ opencliHome, package: pkg });
+export function withoutPluginEntry(entries, home, pkg) {
+    const key = ledgerKeyOf({ home, package: pkg });
     return entries.filter((entry) => ledgerKeyOf(entry) !== key);
 }

package/dist/host/plugin.d.ts

@@ -1,4 +1,3 @@
-export declare const OPENCLI_MANIFEST_FILE = "opencli-plugin.json";
-export declare function pluginAt(dir: string): {
+export declare function pluginAt(dir: string, manifestFile: string): {
     readonly name?: string;
 } | undefined;

package/dist/host/plugin.js

@@ -1,6 +1,5 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-export const OPENCLI_MANIFEST_FILE = 'opencli-plugin.json';
 function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
 }
@@ -11,9 +10,9 @@ function isCommandFile(name) {
         return false;
     return name.endsWith('.ts') || name.endsWith('.js');
 }
-function pluginManifestOf(dir) {
+function pluginManifestOf(dir, manifestFile) {
     try {
-        const parsed = JSON.parse(readFileSync(join(dir, OPENCLI_MANIFEST_FILE), 'utf8'));
+        const parsed = JSON.parse(readFileSync(join(dir, manifestFile), 'utf8'));
         if (Array.isArray(parsed))
             return undefined;
         return asRecord(parsed);
@@ -30,8 +29,8 @@ function hasCommandFile(dir) {
         return false;
     }
 }
-export function pluginAt(dir) {
-    const manifest = pluginManifestOf(dir);
+export function pluginAt(dir, manifestFile) {
+    const manifest = pluginManifestOf(dir, manifestFile);
     if (manifest === undefined || !hasCommandFile(dir))
         return undefined;
     const name = manifest.name;