await fs.rm(root, { recursive: true, force: true });

}

});

it("does not flag entry_unresolved when runtimeExtensions exists even if source entry is missing", async () => {

const root = await makeFixtureRoot("runtime-extensions");

try {

const pluginDir = path.join(root, "user-plugins", "runtime-only");

await fs.mkdir(path.join(pluginDir, "dist"), { recursive: true });

await fs.writeFile(path.join(pluginDir, "dist", "index.js"), "export default {};", "utf-8");

// Source entry (./src/index.ts) does NOT exist

// But runtime entry (./dist/index.js) DOES exist

await fs.writeFile(

path.join(pluginDir, "package.json"),

JSON.stringify({

name: "runtime-only",

version: "0.0.1",

type: "module",

openclaw: {

extensions: ["./src/index.ts"],

runtimeExtensions: ["./dist/index.js"],

},

}),

"utf-8",

);

await fs.writeFile(

path.join(pluginDir, "openclaw.plugin.json"),

JSON.stringify({ id: "runtime-only" }),

"utf-8",

);

const installsPath = path.join(root, "plugins", "installs.json");

await fs.mkdir(path.dirname(installsPath), { recursive: true });

await fs.writeFile(

installsPath,

JSON.stringify({

version: 1,

plugins: [

{

pluginId: "runtime-only",

manifestPath: path.join(pluginDir, "openclaw.plugin.json"),

rootDir: pluginDir,

enabled: true,

packageJson: { path: "package.json" },

},

],

}),

"utf-8",

);

const report = await runPostUpgradeProbes({ installsPath });

expect(report.findings.filter((f) => f.code === "plugin.entry_unresolved")).toHaveLength(0);

} finally {

await fs.rm(root, { recursive: true, force: true });

}

});

});

describe("runPostUpgradeProbes — plugin.manifest_drift", () => {

import crypto from "node:crypto";

import fs from "node:fs/promises";

import path from "node:path";

import { listBuiltRuntimeEntryCandidates } from "../plugins/package-entrypoints.js";

import type { PostUpgradeFinding, PostUpgradeReport } from "./doctor-post-upgrade.types.js";

type InstalledPluginRecord = {

async function readInstalledPackageJson(rootDir: string, packageJsonRelPath: string) {

const absPath = path.join(rootDir, packageJsonRelPath);

const raw = await fs.readFile(absPath, "utf-8");

return JSON.parse(raw) as { openclaw?: { extensions?: string[] } };

return JSON.parse(raw) as { openclaw?: { extensions?: string[]; runtimeExtensions?: string[] } };

}

async function fileExists(absPath: string): Promise<boolean> {

for (const record of installs.plugins) {

if (!record.enabled) continue;

const pkgRelPath = record.packageJson?.path ?? "package.json";

let pkg: { openclaw?: { extensions?: string[] } };

let pkg: { openclaw?: { extensions?: string[]; runtimeExtensions?: string[] } };

try {

pkg = await readInstalledPackageJson(record.rootDir, pkgRelPath);

} catch (err) {

continue;

}

const entries = pkg.openclaw?.extensions ?? [];

for (const entry of entries) {

const runtimeExtensions = pkg.openclaw?.runtimeExtensions ?? [];

for (const [index, entry] of entries.entries()) {

// First, check if there's an explicit runtimeExtensions entry at this index

const runtimeEntry = runtimeExtensions[index];

if (runtimeEntry) {

const absRuntimeEntry = path.resolve(record.rootDir, runtimeEntry);

if (await fileExists(absRuntimeEntry)) {

// Runtime entry exists, so we're good; skip to next entry

continue;

}

// Runtime entry doesn't exist; flag it

findings.push({

level: "error",

code: "plugin.entry_unresolved",

message: `Plugin ${record.pluginId} declares runtimeExtensions entry ${runtimeEntry} but the file does not exist at ${absRuntimeEntry}.`,

plugin: record.pluginId,

entry: runtimeEntry,

});

continue;

}

// No explicit runtime entry; try the source entry

const absEntry = path.resolve(record.rootDir, entry);

if (!(await fileExists(absEntry))) {

// Source entry doesn't exist either; flag it

findings.push({

level: "error",

code: "plugin.entry_unresolved",