Merge pull request #2313 from can1357/farm/a4aed75b/npm-plugin-load-deps
fix(cli): reject unloadable npm plugin installs
This commit is contained in:
Can Bölük
@@ -2,6 +2,10 @@
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed npm plugin installs to reject packages whose declared extension entry points cannot load because imports or nested dependencies are unresolved ([#2312](https://github.com/can1357/oh-my-pi/issues/2312)).
|
||||
|
||||
### Breaking Changes
|
||||
|
||||
- Replaced the `omp setup stt` command with `omp setup speech`. The old `stt` setup component is gone (no alias); `omp setup speech` now provisions the full speech stack — audio recorder, speech-to-text model, and text-to-speech model.
|
||||
|
||||
@@ -172,34 +172,49 @@ function resolveManifestEntryFile(joined: string): string | null {
|
||||
* Handles both single-string and string[] base entries, plus feature-specific entries.
|
||||
*/
|
||||
function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "commands" | "extensions"): string[] {
|
||||
const paths: string[] = [];
|
||||
const resolved: string[] = [];
|
||||
for (const entry of resolvePluginManifestEntries(plugin, key)) {
|
||||
if (entry.resolvedPath) {
|
||||
resolved.push(entry.resolvedPath);
|
||||
}
|
||||
}
|
||||
return resolved;
|
||||
}
|
||||
|
||||
/**
|
||||
* Declared manifest entries paired with their resolved file path. Returns one
|
||||
* record per declared entry — base entries first, then enabled-feature entries
|
||||
* — so callers (e.g. install-time validation) can detect manifest entries that
|
||||
* point at missing files instead of silently skipping them like
|
||||
* {@link resolvePluginPaths} does.
|
||||
*/
|
||||
export function resolvePluginManifestEntries(
|
||||
plugin: InstalledPlugin,
|
||||
key: "tools" | "hooks" | "commands" | "extensions",
|
||||
): Array<{ entry: string; resolvedPath: string | null }> {
|
||||
const declared: Array<{ entry: string; resolvedPath: string | null }> = [];
|
||||
const manifest = plugin.manifest;
|
||||
|
||||
// Base entry (always included if exists)
|
||||
const resolveEntry = (entry: string): { entry: string; resolvedPath: string | null } => ({
|
||||
entry,
|
||||
resolvedPath: resolveManifestEntryFile(path.join(plugin.path, entry)),
|
||||
});
|
||||
|
||||
const base = manifest[key];
|
||||
if (base) {
|
||||
const entries = Array.isArray(base) ? base : [base];
|
||||
for (const entry of entries) {
|
||||
const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
|
||||
if (resolved) {
|
||||
paths.push(resolved);
|
||||
}
|
||||
declared.push(resolveEntry(entry));
|
||||
}
|
||||
}
|
||||
|
||||
// Feature-specific entries
|
||||
if (manifest.features && plugin.enabledFeatures) {
|
||||
const enabledSet = new Set(plugin.enabledFeatures);
|
||||
|
||||
for (const [featName, feat] of Object.entries(manifest.features)) {
|
||||
if (!enabledSet.has(featName)) continue;
|
||||
|
||||
if (feat[key]) {
|
||||
for (const entry of feat[key]) {
|
||||
const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
|
||||
if (resolved) {
|
||||
paths.push(resolved);
|
||||
}
|
||||
declared.push(resolveEntry(entry));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -207,19 +222,15 @@ function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "c
|
||||
// null means use defaults - enable features with default: true
|
||||
for (const [_featName, feat] of Object.entries(manifest.features)) {
|
||||
if (!feat.default) continue;
|
||||
|
||||
if (feat[key]) {
|
||||
for (const entry of feat[key]) {
|
||||
const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
|
||||
if (resolved) {
|
||||
paths.push(resolved);
|
||||
}
|
||||
declared.push(resolveEntry(entry));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return paths;
|
||||
return declared;
|
||||
}
|
||||
|
||||
export function resolvePluginToolPaths(plugin: InstalledPlugin): string[] {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import * as fs from "node:fs";
|
||||
import * as os from "node:os";
|
||||
import * as path from "node:path";
|
||||
import {
|
||||
getPluginsDir,
|
||||
@@ -11,6 +12,8 @@ import {
|
||||
logger,
|
||||
} from "@oh-my-pi/pi-utils";
|
||||
import { type GitSource, parseGitUrl } from "./git-url";
|
||||
import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "./legacy-pi-compat";
|
||||
import { resolvePluginManifestEntries } from "./loader";
|
||||
import { extractPackageName, parsePluginSpec } from "./parser";
|
||||
import type {
|
||||
DoctorCheck,
|
||||
@@ -74,6 +77,34 @@ function gitInstallSpec(original: string, source: GitSource): string {
|
||||
return `${source.repo}#${source.ref}`;
|
||||
}
|
||||
|
||||
function findGitPackageName(source: GitSource, deps: Record<string, string>): string | undefined {
|
||||
for (const [key, value] of Object.entries(deps)) {
|
||||
if (typeof value !== "string") {
|
||||
continue;
|
||||
}
|
||||
const installedSource = parseGitUrl(value);
|
||||
if (installedSource && installedSource.host === source.host && installedSource.path === source.path) {
|
||||
return key;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function hasDefaultExport(value: unknown): value is { default?: unknown } {
|
||||
return typeof value === "object" && value !== null && "default" in value;
|
||||
}
|
||||
|
||||
function hasExtensionFactoryExport(module: unknown): boolean {
|
||||
return typeof module === "function" || (hasDefaultExport(module) && typeof module.default === "function");
|
||||
}
|
||||
|
||||
interface PluginPackageSnapshot {
|
||||
readonly actualName: string;
|
||||
readonly packagePath: string;
|
||||
readonly backupRoot: string;
|
||||
readonly backupPath: string;
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Plugin Manager
|
||||
// =============================================================================
|
||||
@@ -173,6 +204,88 @@ export class PluginManager {
|
||||
}
|
||||
}
|
||||
|
||||
async #snapshotInstalledPackage(actualName: string | undefined): Promise<PluginPackageSnapshot | null> {
|
||||
if (!actualName) {
|
||||
return null;
|
||||
}
|
||||
const packagePath = path.join(getPluginsNodeModules(), actualName);
|
||||
try {
|
||||
await fs.promises.lstat(packagePath);
|
||||
} catch (err) {
|
||||
if (isEnoent(err)) {
|
||||
return null;
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
|
||||
const backupRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omp-plugin-backup-"));
|
||||
const backupPath = path.join(backupRoot, "package");
|
||||
await fs.promises.cp(packagePath, backupPath, { recursive: true, verbatimSymlinks: true });
|
||||
return { actualName, packagePath, backupRoot, backupPath };
|
||||
}
|
||||
|
||||
async #cleanupSnapshot(snapshot: PluginPackageSnapshot | null): Promise<void> {
|
||||
if (!snapshot) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
await fs.promises.rm(snapshot.backupRoot, { recursive: true, force: true });
|
||||
} catch (err) {
|
||||
logger.warn("Failed to remove plugin install backup", { plugin: snapshot.actualName, error: String(err) });
|
||||
}
|
||||
}
|
||||
|
||||
async #rollbackFailedInstall(
|
||||
actualName: string,
|
||||
packageJsonBefore: string,
|
||||
snapshot: PluginPackageSnapshot | null,
|
||||
): Promise<void> {
|
||||
await Bun.write(getPluginsPackageJson(), packageJsonBefore);
|
||||
const packagePath = path.join(getPluginsNodeModules(), actualName);
|
||||
await fs.promises.rm(packagePath, { recursive: true, force: true });
|
||||
if (!snapshot) {
|
||||
return;
|
||||
}
|
||||
await fs.promises.mkdir(path.dirname(snapshot.packagePath), { recursive: true });
|
||||
await fs.promises.cp(snapshot.backupPath, snapshot.packagePath, { recursive: true, verbatimSymlinks: true });
|
||||
}
|
||||
|
||||
async #validateInstalledExtensions(plugin: InstalledPlugin): Promise<void> {
|
||||
const declaredEntries = resolvePluginManifestEntries(plugin, "extensions");
|
||||
if (declaredEntries.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
const errors: string[] = [];
|
||||
const loadable: string[] = [];
|
||||
for (const { entry, resolvedPath } of declaredEntries) {
|
||||
if (resolvedPath === null) {
|
||||
errors.push(`${entry}: declared extension entry not found on disk`);
|
||||
} else {
|
||||
loadable.push(resolvedPath);
|
||||
}
|
||||
}
|
||||
|
||||
if (loadable.length > 0) {
|
||||
installLegacyPiSpecifierShim();
|
||||
for (const extensionPath of loadable) {
|
||||
try {
|
||||
const module = await loadLegacyPiModule(extensionPath);
|
||||
if (!hasExtensionFactoryExport(module)) {
|
||||
errors.push(`${extensionPath}: extension does not export a valid factory function`);
|
||||
}
|
||||
} catch (err) {
|
||||
const message = err instanceof Error ? err.message : String(err);
|
||||
errors.push(`${extensionPath}: ${message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (errors.length > 0) {
|
||||
throw new Error(`Plugin ${plugin.name} extension validation failed:\n${errors.join("\n")}`);
|
||||
}
|
||||
}
|
||||
|
||||
// ==========================================================================
|
||||
// Install / Uninstall
|
||||
// ==========================================================================
|
||||
@@ -217,113 +330,131 @@ export class PluginManager {
|
||||
};
|
||||
}
|
||||
const pkgJsonPath = getPluginsPackageJson();
|
||||
const depsBefore = gitSource ? await this.#readDeps(pkgJsonPath) : {};
|
||||
const packageJsonBefore = await Bun.file(pkgJsonPath).text();
|
||||
const depsBefore = await this.#readDeps(pkgJsonPath);
|
||||
const packageInstallSpec = gitSource ? gitInstallSpec(spec.packageName, gitSource) : spec.packageName;
|
||||
const existingActualName = gitSource
|
||||
? findGitPackageName(gitSource, depsBefore)
|
||||
: extractPackageName(spec.packageName);
|
||||
const packageSnapshot = await this.#snapshotInstalledPackage(existingActualName);
|
||||
|
||||
// Run npm install
|
||||
const proc = Bun.spawn(["bun", "install", packageInstallSpec], {
|
||||
cwd: getPluginsDir(),
|
||||
stdin: "ignore",
|
||||
stdout: "pipe",
|
||||
stderr: "pipe",
|
||||
windowsHide: true,
|
||||
});
|
||||
try {
|
||||
// Run npm install
|
||||
const proc = Bun.spawn(["bun", "install", packageInstallSpec], {
|
||||
cwd: getPluginsDir(),
|
||||
stdin: "ignore",
|
||||
stdout: "pipe",
|
||||
stderr: "pipe",
|
||||
windowsHide: true,
|
||||
});
|
||||
|
||||
const exitCode = await proc.exited;
|
||||
if (exitCode !== 0) {
|
||||
const stderr = await new Response(proc.stderr).text();
|
||||
throw new Error(`npm install failed: ${stderr}`);
|
||||
}
|
||||
// Resolve actual package name. npm specs encode the name (strip version);
|
||||
// git specs do not, so diff plugins/package.json deps to find the new entry.
|
||||
let actualName: string;
|
||||
if (gitSource) {
|
||||
const depsAfter = await this.#readDeps(pkgJsonPath);
|
||||
let resolved: string | undefined;
|
||||
for (const key of Object.keys(depsAfter)) {
|
||||
if (!(key in depsBefore)) {
|
||||
resolved = key;
|
||||
break;
|
||||
}
|
||||
const exitCode = await proc.exited;
|
||||
if (exitCode !== 0) {
|
||||
const stderr = await new Response(proc.stderr).text();
|
||||
throw new Error(`npm install failed: ${stderr}`);
|
||||
}
|
||||
// Fallback: a force-reinstall of an already-present git plugin will not
|
||||
// add a new key, just rewrite the existing one to the new spec value.
|
||||
// Match by the install value for force-reinstalls where no new key is
|
||||
// added (non-GitHub shorthands are normalized before bun sees them).
|
||||
if (!resolved) {
|
||||
const needle = packageInstallSpec.replace(/^git\+/i, "");
|
||||
for (const [key, value] of Object.entries(depsAfter)) {
|
||||
if (typeof value === "string" && value.includes(needle)) {
|
||||
// Resolve actual package name. npm specs encode the name (strip version);
|
||||
// git specs do not, so diff plugins/package.json deps to find the new entry.
|
||||
let actualName: string;
|
||||
if (gitSource) {
|
||||
const depsAfter = await this.#readDeps(pkgJsonPath);
|
||||
let resolved: string | undefined;
|
||||
for (const key of Object.keys(depsAfter)) {
|
||||
if (!(key in depsBefore)) {
|
||||
resolved = key;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Fallback: a force-reinstall of an already-present git plugin will not
|
||||
// add a new key, just rewrite the existing one to the new spec value.
|
||||
// Match by repository identity, not by ref, so failed upgrades from
|
||||
// one ref to another still resolve to the original package name.
|
||||
if (!resolved) {
|
||||
resolved = findGitPackageName(gitSource, depsAfter);
|
||||
}
|
||||
if (!resolved) {
|
||||
throw new Error(
|
||||
`Installed ${spec.packageName} but could not determine package name from plugins/package.json`,
|
||||
);
|
||||
}
|
||||
actualName = resolved;
|
||||
} else {
|
||||
actualName = extractPackageName(spec.packageName);
|
||||
}
|
||||
if (!resolved) {
|
||||
throw new Error(
|
||||
`Installed ${spec.packageName} but could not determine package name from plugins/package.json`,
|
||||
);
|
||||
}
|
||||
actualName = resolved;
|
||||
} else {
|
||||
actualName = extractPackageName(spec.packageName);
|
||||
}
|
||||
const pkgPath = path.join(getPluginsNodeModules(), actualName, "package.json");
|
||||
const pkgPath = path.join(getPluginsNodeModules(), actualName, "package.json");
|
||||
|
||||
let pkg: { name: string; version: string; omp?: PluginManifest; pi?: PluginManifest };
|
||||
try {
|
||||
pkg = await Bun.file(pkgPath).json();
|
||||
} catch (err) {
|
||||
if (isEnoent(err)) {
|
||||
throw new Error(`Package installed but package.json not found at ${pkgPath}`);
|
||||
let pkg: { name: string; version: string; omp?: PluginManifest; pi?: PluginManifest };
|
||||
try {
|
||||
pkg = await Bun.file(pkgPath).json();
|
||||
} catch (err) {
|
||||
if (isEnoent(err)) {
|
||||
throw new Error(`Package installed but package.json not found at ${pkgPath}`);
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
const manifest: PluginManifest = pkg.omp || pkg.pi || { version: pkg.version };
|
||||
manifest.version = pkg.version;
|
||||
const manifest: PluginManifest = pkg.omp || pkg.pi || { version: pkg.version };
|
||||
manifest.version = pkg.version;
|
||||
|
||||
// Resolve enabled features
|
||||
let enabledFeatures: string[] | null = null;
|
||||
if (spec.features === "*") {
|
||||
// All features
|
||||
enabledFeatures = manifest.features ? Object.keys(manifest.features) : null;
|
||||
} else if (Array.isArray(spec.features)) {
|
||||
if (spec.features.length > 0) {
|
||||
// Validate requested features exist
|
||||
if (manifest.features) {
|
||||
for (const feat of spec.features) {
|
||||
if (!(feat in manifest.features)) {
|
||||
throw new Error(
|
||||
`Unknown feature "${feat}" in ${actualName}. Available: ${Object.keys(manifest.features).join(", ")}`,
|
||||
);
|
||||
// Resolve enabled features
|
||||
let enabledFeatures: string[] | null = null;
|
||||
if (spec.features === "*") {
|
||||
// All features
|
||||
enabledFeatures = manifest.features ? Object.keys(manifest.features) : null;
|
||||
} else if (Array.isArray(spec.features)) {
|
||||
if (spec.features.length > 0) {
|
||||
// Validate requested features exist
|
||||
if (manifest.features) {
|
||||
for (const feat of spec.features) {
|
||||
if (!(feat in manifest.features)) {
|
||||
throw new Error(
|
||||
`Unknown feature "${feat}" in ${actualName}. Available: ${Object.keys(manifest.features).join(", ")}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
enabledFeatures = spec.features;
|
||||
} else {
|
||||
// Empty array = no optional features
|
||||
enabledFeatures = [];
|
||||
}
|
||||
enabledFeatures = spec.features;
|
||||
} else {
|
||||
// Empty array = no optional features
|
||||
enabledFeatures = [];
|
||||
}
|
||||
// null = use defaults
|
||||
|
||||
const installedPlugin: InstalledPlugin = {
|
||||
name: pkg.name,
|
||||
version: pkg.version,
|
||||
path: path.join(getPluginsNodeModules(), actualName),
|
||||
manifest,
|
||||
enabledFeatures,
|
||||
enabled: true,
|
||||
};
|
||||
|
||||
try {
|
||||
await this.#validateInstalledExtensions(installedPlugin);
|
||||
} catch (err) {
|
||||
try {
|
||||
await this.#rollbackFailedInstall(actualName, packageJsonBefore, packageSnapshot);
|
||||
} catch (rollbackErr) {
|
||||
const message = err instanceof Error ? err.message : String(err);
|
||||
const rollbackMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
|
||||
throw new Error(`${message}\nRollback failed: ${rollbackMessage}`);
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
|
||||
// Update runtime config
|
||||
const config = await this.#ensureConfigLoaded();
|
||||
config.plugins[pkg.name] = {
|
||||
version: pkg.version,
|
||||
enabledFeatures,
|
||||
enabled: true,
|
||||
};
|
||||
await this.#saveRuntimeConfig();
|
||||
|
||||
return installedPlugin;
|
||||
} finally {
|
||||
await this.#cleanupSnapshot(packageSnapshot);
|
||||
}
|
||||
// null = use defaults
|
||||
|
||||
// Update runtime config
|
||||
const config = await this.#ensureConfigLoaded();
|
||||
config.plugins[pkg.name] = {
|
||||
version: pkg.version,
|
||||
enabledFeatures,
|
||||
enabled: true,
|
||||
};
|
||||
await this.#saveRuntimeConfig();
|
||||
|
||||
return {
|
||||
name: pkg.name,
|
||||
version: pkg.version,
|
||||
path: path.join(getPluginsNodeModules(), actualName),
|
||||
manifest,
|
||||
enabledFeatures,
|
||||
enabled: true,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,281 @@
|
||||
import { afterEach, beforeEach, describe, expect, test, vi } from "bun:test";
|
||||
import * as fs from "node:fs/promises";
|
||||
import * as os from "node:os";
|
||||
import * as path from "node:path";
|
||||
import { PluginManager } from "@oh-my-pi/pi-coding-agent/extensibility/plugins/manager";
|
||||
import * as piUtils from "@oh-my-pi/pi-utils";
|
||||
import type { Subprocess } from "bun";
|
||||
|
||||
function emptyStream(): ReadableStream<Uint8Array> {
|
||||
const body = new Response("").body;
|
||||
if (!body) {
|
||||
throw new Error("Failed to create empty response stream");
|
||||
}
|
||||
return body;
|
||||
}
|
||||
|
||||
interface PluginFixture {
|
||||
readonly version: string;
|
||||
readonly source: string;
|
||||
readonly dependencyVersion?: string;
|
||||
readonly peerDependencies?: Record<string, string>;
|
||||
}
|
||||
|
||||
async function writePluginPackage(pluginsNodeModules: string, name: string, fixture: PluginFixture): Promise<string> {
|
||||
const installedDir = path.join(pluginsNodeModules, name);
|
||||
await fs.mkdir(path.join(installedDir, "dist"), { recursive: true });
|
||||
await Bun.write(
|
||||
path.join(installedDir, "package.json"),
|
||||
JSON.stringify(
|
||||
{
|
||||
name,
|
||||
version: fixture.version,
|
||||
...(fixture.peerDependencies ? { peerDependencies: fixture.peerDependencies } : {}),
|
||||
omp: { extensions: ["./dist/extension.ts"] },
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await Bun.write(path.join(installedDir, "dist", "extension.ts"), fixture.source);
|
||||
return installedDir;
|
||||
}
|
||||
|
||||
describe("PluginManager.install load validation", () => {
|
||||
let tmpRoot: string;
|
||||
let pluginsDir: string;
|
||||
let pluginsNodeModules: string;
|
||||
let pluginsPkgJson: string;
|
||||
|
||||
beforeEach(async () => {
|
||||
tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "omp-plugin-validation-"));
|
||||
pluginsDir = path.join(tmpRoot, "plugins");
|
||||
pluginsNodeModules = path.join(pluginsDir, "node_modules");
|
||||
pluginsPkgJson = path.join(pluginsDir, "package.json");
|
||||
await fs.mkdir(pluginsNodeModules, { recursive: true });
|
||||
|
||||
vi.spyOn(piUtils, "getPluginsDir").mockReturnValue(pluginsDir);
|
||||
vi.spyOn(piUtils, "getPluginsNodeModules").mockReturnValue(pluginsNodeModules);
|
||||
vi.spyOn(piUtils, "getPluginsPackageJson").mockReturnValue(pluginsPkgJson);
|
||||
vi.spyOn(piUtils, "getPluginsLockfile").mockReturnValue(path.join(tmpRoot, "omp-plugins.lock.json"));
|
||||
vi.spyOn(piUtils, "getProjectDir").mockReturnValue(tmpRoot);
|
||||
vi.spyOn(piUtils, "getProjectPluginOverridesPath").mockReturnValue(path.join(tmpRoot, "plugin-overrides.json"));
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
vi.restoreAllMocks();
|
||||
await fs.rm(tmpRoot, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test("rejects an install whose extension entry cannot resolve its dependencies", async () => {
|
||||
vi.spyOn(Bun, "spawn").mockImplementation(((cmd: string[]) => {
|
||||
expect(cmd).toEqual(["bun", "install", "broken-plugin"]);
|
||||
|
||||
const prepare = (async () => {
|
||||
await Bun.write(
|
||||
pluginsPkgJson,
|
||||
JSON.stringify(
|
||||
{ name: "omp-plugins", private: true, dependencies: { "broken-plugin": "1.0.0" } },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await writePluginPackage(pluginsNodeModules, "broken-plugin", {
|
||||
version: "1.0.0",
|
||||
peerDependencies: { "missing-peer": "^1.0.0" },
|
||||
source:
|
||||
'import { missing } from "missing-peer";\nexport default function(pi) { pi.registerCommand(String(missing), { handler: async () => {} }); }\n',
|
||||
});
|
||||
})();
|
||||
|
||||
return {
|
||||
pid: 1,
|
||||
stdout: emptyStream(),
|
||||
stderr: emptyStream(),
|
||||
exited: prepare.then(() => 0),
|
||||
} as Subprocess;
|
||||
}) as typeof Bun.spawn);
|
||||
|
||||
await expect(new PluginManager(tmpRoot).install("broken-plugin")).rejects.toThrow(/missing-peer/);
|
||||
|
||||
const pluginsPackage = await Bun.file(pluginsPkgJson).json();
|
||||
expect(pluginsPackage.dependencies ?? {}).toEqual({});
|
||||
expect(await Bun.file(path.join(pluginsNodeModules, "broken-plugin", "package.json")).exists()).toBe(false);
|
||||
expect(await Bun.file(path.join(tmpRoot, "omp-plugins.lock.json")).exists()).toBe(false);
|
||||
});
|
||||
|
||||
test("restores the previous package tree when reinstall validation fails", async () => {
|
||||
await Bun.write(
|
||||
pluginsPkgJson,
|
||||
JSON.stringify({ name: "omp-plugins", private: true, dependencies: { "broken-plugin": "1.0.0" } }, null, 2),
|
||||
);
|
||||
await Bun.write(
|
||||
path.join(tmpRoot, "omp-plugins.lock.json"),
|
||||
JSON.stringify(
|
||||
{ plugins: { "broken-plugin": { version: "1.0.0", enabledFeatures: null, enabled: true } }, settings: {} },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await writePluginPackage(pluginsNodeModules, "broken-plugin", {
|
||||
version: "1.0.0",
|
||||
source: 'export default function(pi) { pi.registerCommand("old-ok", { handler: async () => {} }); }\n',
|
||||
});
|
||||
|
||||
vi.spyOn(Bun, "spawn").mockImplementation(((cmd: string[]) => {
|
||||
expect(cmd).toEqual(["bun", "install", "broken-plugin"]);
|
||||
|
||||
const prepare = (async () => {
|
||||
await Bun.write(
|
||||
pluginsPkgJson,
|
||||
JSON.stringify(
|
||||
{ name: "omp-plugins", private: true, dependencies: { "broken-plugin": "2.0.0" } },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await writePluginPackage(pluginsNodeModules, "broken-plugin", {
|
||||
version: "2.0.0",
|
||||
peerDependencies: { "missing-peer": "^1.0.0" },
|
||||
source:
|
||||
'import { missing } from "missing-peer";\nexport default function(pi) { pi.registerCommand(String(missing), { handler: async () => {} }); }\n',
|
||||
});
|
||||
})();
|
||||
|
||||
return {
|
||||
pid: 1,
|
||||
stdout: emptyStream(),
|
||||
stderr: emptyStream(),
|
||||
exited: prepare.then(() => 0),
|
||||
} as Subprocess;
|
||||
}) as typeof Bun.spawn);
|
||||
|
||||
await expect(new PluginManager(tmpRoot).install("broken-plugin")).rejects.toThrow(/missing-peer/);
|
||||
|
||||
const pluginsPackage = await Bun.file(pluginsPkgJson).json();
|
||||
expect(pluginsPackage.dependencies).toEqual({ "broken-plugin": "1.0.0" });
|
||||
const restoredPackage = await Bun.file(path.join(pluginsNodeModules, "broken-plugin", "package.json")).json();
|
||||
expect(restoredPackage.version).toBe("1.0.0");
|
||||
const restoredExtension = await Bun.file(
|
||||
path.join(pluginsNodeModules, "broken-plugin", "dist", "extension.ts"),
|
||||
).text();
|
||||
expect(restoredExtension).toContain("old-ok");
|
||||
expect(restoredExtension).not.toContain("missing-peer");
|
||||
const lock = await Bun.file(path.join(tmpRoot, "omp-plugins.lock.json")).json();
|
||||
expect(lock.plugins["broken-plugin"]).toEqual({ version: "1.0.0", enabledFeatures: null, enabled: true });
|
||||
});
|
||||
|
||||
test("restores the previous git plugin tree when reinstalling a different ref fails validation", async () => {
|
||||
await Bun.write(
|
||||
pluginsPkgJson,
|
||||
JSON.stringify(
|
||||
{ name: "omp-plugins", private: true, dependencies: { "git-plugin": "github:org/plugin#v1" } },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await Bun.write(
|
||||
path.join(tmpRoot, "omp-plugins.lock.json"),
|
||||
JSON.stringify(
|
||||
{ plugins: { "git-plugin": { version: "1.0.0", enabledFeatures: null, enabled: true } }, settings: {} },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await writePluginPackage(pluginsNodeModules, "git-plugin", {
|
||||
version: "1.0.0",
|
||||
source: 'export default function(pi) { pi.registerCommand("git-old-ok", { handler: async () => {} }); }\n',
|
||||
});
|
||||
|
||||
vi.spyOn(Bun, "spawn").mockImplementation(((cmd: string[]) => {
|
||||
expect(cmd).toEqual(["bun", "install", "github:org/plugin#v2"]);
|
||||
|
||||
const prepare = (async () => {
|
||||
await Bun.write(
|
||||
pluginsPkgJson,
|
||||
JSON.stringify(
|
||||
{ name: "omp-plugins", private: true, dependencies: { "git-plugin": "github:org/plugin#v2" } },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await writePluginPackage(pluginsNodeModules, "git-plugin", {
|
||||
version: "2.0.0",
|
||||
peerDependencies: { "missing-peer": "^1.0.0" },
|
||||
source:
|
||||
'import { missing } from "missing-peer";\nexport default function(pi) { pi.registerCommand(String(missing), { handler: async () => {} }); }\n',
|
||||
});
|
||||
})();
|
||||
|
||||
return {
|
||||
pid: 1,
|
||||
stdout: emptyStream(),
|
||||
stderr: emptyStream(),
|
||||
exited: prepare.then(() => 0),
|
||||
} as Subprocess;
|
||||
}) as typeof Bun.spawn);
|
||||
|
||||
await expect(new PluginManager(tmpRoot).install("github:org/plugin#v2")).rejects.toThrow(/missing-peer/);
|
||||
|
||||
const pluginsPackage = await Bun.file(pluginsPkgJson).json();
|
||||
expect(pluginsPackage.dependencies).toEqual({ "git-plugin": "github:org/plugin#v1" });
|
||||
const restoredPackage = await Bun.file(path.join(pluginsNodeModules, "git-plugin", "package.json")).json();
|
||||
expect(restoredPackage.version).toBe("1.0.0");
|
||||
const restoredExtension = await Bun.file(
|
||||
path.join(pluginsNodeModules, "git-plugin", "dist", "extension.ts"),
|
||||
).text();
|
||||
expect(restoredExtension).toContain("git-old-ok");
|
||||
expect(restoredExtension).not.toContain("missing-peer");
|
||||
const lock = await Bun.file(path.join(tmpRoot, "omp-plugins.lock.json")).json();
|
||||
expect(lock.plugins["git-plugin"]).toEqual({ version: "1.0.0", enabledFeatures: null, enabled: true });
|
||||
});
|
||||
|
||||
test("rejects an install whose manifest declares a missing extension entry", async () => {
|
||||
vi.spyOn(Bun, "spawn").mockImplementation(((cmd: string[]) => {
|
||||
expect(cmd).toEqual(["bun", "install", "partial-plugin"]);
|
||||
|
||||
const prepare = (async () => {
|
||||
await Bun.write(
|
||||
pluginsPkgJson,
|
||||
JSON.stringify(
|
||||
{ name: "omp-plugins", private: true, dependencies: { "partial-plugin": "1.0.0" } },
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
const installedDir = path.join(pluginsNodeModules, "partial-plugin");
|
||||
await fs.mkdir(path.join(installedDir, "dist"), { recursive: true });
|
||||
await Bun.write(
|
||||
path.join(installedDir, "package.json"),
|
||||
JSON.stringify(
|
||||
{
|
||||
name: "partial-plugin",
|
||||
version: "1.0.0",
|
||||
omp: { extensions: ["./dist/valid.ts", "./dist/missing.ts"] },
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await Bun.write(
|
||||
path.join(installedDir, "dist", "valid.ts"),
|
||||
'export default function(pi) { pi.registerCommand("valid-ext", { handler: async () => {} }); }\n',
|
||||
);
|
||||
})();
|
||||
|
||||
return {
|
||||
pid: 1,
|
||||
stdout: emptyStream(),
|
||||
stderr: emptyStream(),
|
||||
exited: prepare.then(() => 0),
|
||||
} as Subprocess;
|
||||
}) as typeof Bun.spawn);
|
||||
|
||||
await expect(new PluginManager(tmpRoot).install("partial-plugin")).rejects.toThrow(/dist\/missing\.ts/);
|
||||
|
||||
const pluginsPackage = await Bun.file(pluginsPkgJson).json();
|
||||
expect(pluginsPackage.dependencies ?? {}).toEqual({});
|
||||
expect(await Bun.file(path.join(pluginsNodeModules, "partial-plugin", "package.json")).exists()).toBe(false);
|
||||
expect(await Bun.file(path.join(tmpRoot, "omp-plugins.lock.json")).exists()).toBe(false);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user