update-types:

- minor

- patch

open-pull-requests-limit: 10

open-pull-requests-limit: 20

registries:

- npm-npmjs

0b39ec73150d957acdc4dac3fe0b468998e74bb602750d31b1ecfd6eda7d6dc5 config-baseline.json

6d477ca3b60982b770e85929ab8393a7923a6b31ce99f3b7c7dba13cdd4f9180 config-baseline.core.json

2f2463daef1ea612d58e6bf0148d928d884a331053ad1063f9d18b0f753f51a1 config-baseline.json

b95cc4a3b15e688afa58cf700dac425af4e50fd092209e75903e73d5d2988717 config-baseline.core.json

a2a949a99f5cc5960d4d7ae0159b6b48c4d6b1f813be67cda196457ab2f88034 config-baseline.channel.json

fffe0e74eab92a88c3c57952a70bc932438ce3a7f5f9982688437f2cdaee0bcb config-baseline.plugin.json

// Barnacle owns deterministic GitHub triage and auto-response behavior.

const activePrLimit = 10;

const activePrLimit = 20;

const thirdPartyExtensionMessage =

"Please publish this as a third-party plugin on [ClawHub](https://clawhub.ai) instead of adding it to the core repo. Docs: https://docs.openclaw.ai/plugin and https://docs.openclaw.ai/tools/clawhub";

},

"r: too-many-prs": {

color: "D93F0B",

description: "Auto-close: author has more than ten active PRs.",

description: "Auto-close: author has more than twenty active PRs.",

},

"r: too-many-prs-override": {

color: "C2E0C6",

});

});

it("cleans stale policy refs even when plugin is absent from the current registry", async () => {

const baseConfig = {

plugins: {

allow: ["alpha", "beta"],

deny: ["alpha"],

},

} as OpenClawConfig;

const nextConfig = {

plugins: {

allow: ["beta"],

},

} as OpenClawConfig;

loadConfig.mockReturnValue(baseConfig);

buildPluginSnapshotReport.mockReturnValue({

plugins: [],

diagnostics: [],

});

planPluginUninstall.mockReturnValue({

ok: true,

config: nextConfig,

actions: {

entry: false,

install: false,

allowlist: true,

denylist: true,

loadPath: false,

memorySlot: false,

contextEngineSlot: false,

channelConfig: false,

directory: false,

},

directoryRemoval: null,

});

await runPluginsCommand(["plugins", "uninstall", "alpha", "--force"]);

expect(planPluginUninstall).toHaveBeenCalledWith(

expect.objectContaining({

pluginId: "alpha",

deleteFiles: true,

}),

);

expect(writeConfigFile).toHaveBeenCalledWith(nextConfig);

expect(runtimeLogs.at(-2)).toContain('Uninstalled plugin "alpha"');

});

it("exits when uninstall target is not managed by plugin install records", async () => {

loadConfig.mockReturnValue({

plugins: {

plugins: [{ id: "alpha", name: "alpha" }],

diagnostics: [],

});

planPluginUninstall.mockReturnValue({

ok: false,

error: "Plugin not found: alpha",

});

await expect(runPluginsCommand(["plugins", "uninstall", "alpha", "--force"])).rejects.toThrow(

"__exit__:1",

);

expect(runtimeErrors.at(-1)).toContain("is not managed by plugins config/install records");

expect(planPluginUninstall).not.toHaveBeenCalled();

expect(planPluginUninstall).toHaveBeenCalled();

});

});

config: cfg,

plugins: report.plugins,

});

const hasEntry = pluginId in (cfg.plugins?.entries ?? {});

const hasInstall = pluginId in (cfg.plugins?.installs ?? {});

if (!hasEntry && !hasInstall) {

if (plugin) {

runtime.error(

`Plugin "${pluginId}" is not managed by plugins config/install records and cannot be uninstalled.`,

);

} else {

runtime.error(`Plugin not found: ${id}`);

}

runtime.exit(1);

return;

}

const channelIds = plugin?.status === "loaded" ? plugin.channelIds : undefined;

const plan = planPluginUninstall({

config: cfg,

extensionsDir,

});

if (!plan.ok) {

runtime.error(plan.error);

if (plugin) {

runtime.error(

`Plugin "${pluginId}" is not managed by plugins config/install records and cannot be uninstalled.`,

);

} else {

runtime.error(plan.error);

}

runtime.exit(1);

return;

}

const hasInstall = pluginId in (cfg.plugins?.installs ?? {});

const preview: string[] = [];

if (plan.actions.entry) {

knownUnsupported?: string[];

};

export type ClawHubPackageArtifactSummary = {

kind?: "legacy-zip" | "npm-pack" | null;

kind?: string | null;

sha256?: string | null;

size?: number | null;

format?: "zip" | "tgz" | null;

format?: string | null;

npmIntegrity?: string | null;

npmShasum?: string | null;

npmTarballName?: string | null;

) => void;

type TsdownInputOptions = (

options: { onLog?: TsdownOnLog },

options: { external?: TsdownExternalOption; onLog?: TsdownOnLog },

format?: unknown,

context?: unknown,

) => { onLog?: TsdownOnLog } | undefined;

) => { external?: TsdownExternalOption; onLog?: TsdownOnLog } | undefined;

type TsdownExternalOption = string | RegExp | Array<string | RegExp> | TsdownExternalFunction;

type TsdownExternalFunction = (

id: string,

parentId: string | undefined,

isResolved: boolean,

) => boolean | null | undefined;

function asConfigArray(config: unknown): TsdownConfigEntry[] {

return Array.isArray(config) ? (config as TsdownConfigEntry[]) : [config as TsdownConfigEntry];

it("externalizes known heavy native dependencies", () => {

const unifiedGraph = unifiedDistGraph();

const neverBundle = unifiedGraph?.deps?.neverBundle;

const external = unifiedGraph?.inputOptions?.({})?.external;

if (typeof neverBundle === "function") {

expect(neverBundle("@lancedb/lancedb")).toBe(true);

expect(neverBundle("@matrix-org/matrix-sdk-crypto-nodejs")).toBe(true);

expect(neverBundle("matrix-js-sdk/lib/client.js")).toBe(true);

expect(neverBundle("qrcode-terminal/lib/main.js")).toBe(true);

expect(neverBundle("not-a-runtime-dependency")).toBe(false);

} else {

expect(neverBundle).toEqual(expect.arrayContaining(["@lancedb/lancedb", "matrix-js-sdk"]));

expect(neverBundle).toEqual(

expect.arrayContaining(["@lancedb/lancedb", "matrix-js-sdk", "qrcode-terminal"]),

);

}

expect(typeof external).toBe("function");

const externalize = external as TsdownExternalFunction;

expect(externalize("qrcode-terminal/lib/main.js", undefined, false)).toBe(true);

});

it("suppresses unresolved imports from extension source", () => {

}

});

it("cleans stale policy references even when plugin code and install records are gone", async () => {

const result = await uninstallPlugin({

config: createPluginConfig({

allow: ["missing-plugin", "other-plugin"],

deny: ["missing-plugin"],

slots: {

memory: "missing-plugin",

},

}),

pluginId: "missing-plugin",

deleteFiles: true,

});

const successfulResult = expectSuccessfulUninstall(result);

expect(successfulResult.actions).toEqual({

entry: false,

install: false,

allowlist: true,

denylist: true,

loadPath: false,

memorySlot: true,

contextEngineSlot: false,

channelConfig: false,

directory: false,

});

expect(successfulResult.config.plugins?.allow).toEqual(["other-plugin"]);

expect(successfulResult.config.plugins?.deny).toBeUndefined();

expect(successfulResult.config.plugins?.slots?.memory).toBe("memory-core");

expect(runCommandWithTimeoutMock).not.toHaveBeenCalled();

});

it("removes config entries", async () => {

const config = createPluginConfig({

entries: createSinglePluginEntries(),

await expect(fs.access(pluginDir)).rejects.toThrow();

});

it("skips npm cleanup when the managed package directory is already absent", async () => {

const stateDir = path.join(tempDir, "state");

const npmRoot = path.join(stateDir, "npm");

const pluginDir = path.join(npmRoot, "node_modules", "missing-plugin");

const applied = await applyPluginUninstallDirectoryRemoval({

target: pluginDir,

cleanup: {

kind: "npm",

npmRoot,

packageName: "missing-plugin",

},

});

expect(applied).toEqual({ directoryRemoved: false, warnings: [] });

expect(runCommandWithTimeoutMock).not.toHaveBeenCalled();

});

it("warns and still removes npm package dirs when npm prune cleanup fails", async () => {

runCommandWithTimeoutMock.mockResolvedValueOnce({

code: 1,

);

}

function hasUninstallAction(actions: Omit<UninstallActions, "directory">): boolean {

return Object.values(actions).some(Boolean);

}

export function formatUninstallSlotResetPreview(slotKey: "memory" | "contextEngine"): string {

const actionKey = slotKey === "memory" ? "memorySlot" : "contextEngineSlot";

return `${UNINSTALL_ACTION_LABELS[actionKey]} (will reset to "${defaultSlotIdForKey(slotKey)}")`;

export function planPluginUninstall(params: UninstallPluginParams): PluginUninstallPlanResult {

const { config, pluginId, channelIds, deleteFiles = true, extensionsDir } = params;

// Validate plugin exists

const hasEntry = pluginId in (config.plugins?.entries ?? {});

const hasInstall = pluginId in (config.plugins?.installs ?? {});

if (!hasEntry && !hasInstall) {

return { ok: false, error: `Plugin not found: ${pluginId}` };

}

const installRecord = config.plugins?.installs?.[pluginId];

const isLinked = isLinkedPathInstallRecord(installRecord);

channelIds,

});

if (!hasEntry && !hasInstall && !hasUninstallAction(configActions)) {

return { ok: false, error: `Plugin not found: ${pluginId}` };

}

const actions: UninstallActions = {

...configActions,

directory: false,

.then(() => true)

.catch(() => false)) ?? false;

const warnings: string[] = [];

if (!existed) {

return { directoryRemoved: false, warnings };

}

if (removal.cleanup?.kind === "npm") {

const uninstall = await runCommandWithTimeout(

[

expect(managedLabelSpecs["r: support"].description).toContain("support requests");

expect(managedLabelSpecs["r: false-positive"].description).toContain("false positive");

expect(managedLabelSpecs["r: third-party-extension"].description).toContain("ClawHub");

expect(managedLabelSpecs["r: too-many-prs"].description).toContain("ten active PRs");

expect(managedLabelSpecs["r: too-many-prs"].description).toContain("twenty active PRs");

for (const label of Object.values(candidateLabels)) {

expect(managedLabelSpecs[label]).toBeDefined();

);

expect(calls.createComment).not.toContainEqual(

expect.objectContaining({

body: expect.stringContaining("more than 10 active PRs"),

body: expect.stringContaining("more than 20 active PRs"),

}),

);

expect(calls.update).not.toContainEqual(expect.objectContaining({ state: "closed" }));