]);

expect(warnings[0]).not.toContain("first-time setup mode");

});

it("keeps global plugin-disable blocker warnings but omits stale plugin cleanup warnings", async () => {

manifestState.plugins = [channelManifest("telegram", "telegram")];

const warnings = await collectDoctorPreviewWarnings({

cfg: {

channels: {

telegram: {

botToken: "123:abc",

groupPolicy: "allowlist",

},

},

plugins: {

enabled: false,

allow: ["acpx"],

entries: {

acpx: { enabled: true },

},

},

},

doctorFixCommand: "openclaw doctor --fix",

});

expect(warnings).toEqual([

expect.stringContaining(

"channels.telegram: channel is configured, but plugins.enabled=false blocks channel plugins globally.",

),

]);

expect(warnings.join("\n")).not.toContain("stale plugin reference");

});

});

}

}

if (hasPluginConfig || hasChannelConfig) {

if ((hasPluginConfig || hasChannelConfig) && params.cfg.plugins?.enabled !== false) {

const {

collectStalePluginConfigWarnings,

isStalePluginAutoRepairBlocked,

expect(maybeRepairStalePluginConfig(cfg)).toEqual({ config: cfg, changes: [] });

});

it("treats stale plugin refs as inert while plugins are globally disabled", () => {

const cfg = {

plugins: {

enabled: false,

allow: ["acpx"],

entries: {

acpx: { enabled: true },

},

},

channels: {

"openclaw-weixin": {

enabled: true,

},

},

} as OpenClawConfig;

expect(scanStalePluginConfig(cfg)).toEqual([]);

expect(maybeRepairStalePluginConfig(cfg)).toEqual({ config: cfg, changes: [] });

expect(manifestRegistry.loadPluginManifestRegistry).not.toHaveBeenCalled();

});

it("uses missing persisted install records as stale channel evidence", () => {

installedPluginIndexMocks.loadInstalledPluginIndexInstallRecordsSync.mockReturnValue({

"openclaw-weixin": {

cfg: OpenClawConfig,

env?: NodeJS.ProcessEnv,

): boolean {

if (cfg.plugins?.enabled === false) {

return false;

}

return collectPluginRegistryState(cfg, env).hasDiscoveryErrors;

}

export function scanStalePluginConfig(

cfg: OpenClawConfig,

env?: NodeJS.ProcessEnv,

): StalePluginConfigHit[] {

if (cfg.plugins?.enabled === false) {

return [];

}

return scanStalePluginConfigWithState(cfg, collectPluginRegistryState(cfg, env));

}

config: OpenClawConfig;

changes: string[];

} {

if (cfg.plugins?.enabled === false) {

return { config: cfg, changes: [] };

}

const registryState = collectPluginRegistryState(cfg, env);

if (registryState.hasDiscoveryErrors) {

return { config: cfg, changes: [] };

});

it("skips when plugins are globally disabled", () => {

expect(

detectPluginAutoEnableCandidates({

config: {

channels: { slack: { botToken: "x" } },

plugins: {

enabled: false,

allow: ["slack"],

entries: { slack: { config: { botToken: "x" } } },

},

},

env,

manifestRegistry: makeRegistry([{ id: "slack", channels: ["slack"] }]),

}),

).toEqual([]);

const result = applyPluginAutoEnable({

config: {

channels: { slack: { botToken: "x" } },

return hasConfiguredEmbeddedHarnessRuntime(cfg, env);

}

function arePluginsGloballyDisabled(cfg: OpenClawConfig): boolean {

return cfg.plugins?.enabled === false;

}

function configMayNeedPluginManifestRegistry(cfg: OpenClawConfig, env: NodeJS.ProcessEnv): boolean {

if (arePluginsGloballyDisabled(cfg)) {

return false;

}

if (hasPluginAllowlistWithMaterialEntries(cfg)) {

return true;

}

cfg: OpenClawConfig,

env: NodeJS.ProcessEnv,

): boolean {

if (arePluginsGloballyDisabled(cfg)) {

return false;

}

if (hasPluginAllowlistWithMaterialEntries(cfg)) {

return true;

}

"bundledRuntimeDepsInstaller",

);

});

it("bypasses plugin lookup and runtime-deps staging when plugins are globally disabled", async () => {

const cfg = {

channels: {

telegram: {

botToken: "token",

},

},

plugins: {

enabled: false,

allow: ["telegram"],

entries: {

telegram: { enabled: true },

},

},

} as OpenClawConfig;

const log = createLog();

const { prepareGatewayPluginBootstrap } = await import("./server-startup-plugins.js");

await expect(

prepareGatewayPluginBootstrap({

cfgAtStart: cfg,

startupRuntimeConfig: cfg,

minimalTestGateway: false,

log,

}),

).resolves.toMatchObject({

startupPluginIds: [],

deferredConfiguredChannelPluginIds: [],

pluginLookUpTable: undefined,

baseGatewayMethods: ["ping"],

});

expect(loadPluginLookUpTable).not.toHaveBeenCalled();

expect(scanBundledPluginRuntimeDeps).not.toHaveBeenCalled();

expect(repairBundledRuntimeDepsInstallRootAsync).not.toHaveBeenCalled();

expect(loadGatewayStartupPlugins).toHaveBeenCalledWith(

expect.objectContaining({

cfg,

pluginIds: [],

pluginLookUpTable: undefined,

preferSetupRuntimeForChannelPlugins: false,

suppressPluginInfoLogs: false,

}),

);

});

});

: {}),

}).config,

});

const pluginsGloballyDisabled = gatewayPluginConfig.plugins?.enabled === false;

const defaultAgentId = resolveDefaultAgentId(gatewayPluginConfig);

const defaultWorkspaceDir = resolveAgentWorkspaceDir(gatewayPluginConfig, defaultAgentId);

const pluginLookUpTable = params.minimalTestGateway

? undefined

: loadPluginLookUpTable({

config: gatewayPluginConfig,

workspaceDir: defaultWorkspaceDir,

env: process.env,

activationSourceConfig,

metadataSnapshot: params.pluginMetadataSnapshot,

});

const pluginLookUpTable =

params.minimalTestGateway || pluginsGloballyDisabled

? undefined

: loadPluginLookUpTable({

config: gatewayPluginConfig,

workspaceDir: defaultWorkspaceDir,

env: process.env,

activationSourceConfig,

metadataSnapshot: params.pluginMetadataSnapshot,

});

const deferredConfiguredChannelPluginIds = [

...(pluginLookUpTable?.startup.configuredDeferredChannelPluginIds ?? []),

];