import os from "node:os";

import path from "node:path";

import type { Command } from "commander";

import { getRuntimeConfig, readConfigFileSnapshot, replaceConfigFile } from "../config/config.js";

import { resolveStateDir } from "../config/paths.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import {

tracePluginLifecyclePhase,

tracePluginLifecyclePhaseAsync,

} from "../plugins/plugin-lifecycle-trace.js";

import { tracePluginLifecyclePhaseAsync } from "../plugins/plugin-lifecycle-trace.js";

import { defaultRuntime } from "../runtime.js";

import { formatDocsLink } from "../terminal/links.js";

import { theme } from "../terminal/theme.js";

import { shortenHomePath } from "../utils.js";

import type { PluginInspectOptions } from "./plugins-inspect-command.js";

import type { PluginsListOptions } from "./plugins-list-command.js";

import { applyParentDefaultHelpAction } from "./program/parent-default-help.js";

json?: boolean;

};

export type PluginSearchOptions = {

json?: boolean;

limit?: number;

};

export type PluginUninstallOptions = {

keepFiles?: boolean;

/** @deprecated Use keepFiles. */

await runPluginsListCommand(opts);

});

plugins

.command("search")

.description("Search ClawHub plugin packages")

.argument("[query...]", "Search query")

.option("--limit <n>", "Max results", (value) => Number.parseInt(value, 10))

.option("--json", "Print JSON", false)

.action(async (queryParts: string[], opts: PluginSearchOptions) => {

const { runPluginsSearchCommand } = await import("./plugins-search-command.js");

await runPluginsSearchCommand(queryParts, opts);

});

plugins

.command("inspect")

.alias("info")

.option("--force", "Skip confirmation prompt", false)

.option("--dry-run", "Show what would be removed without making changes", false)

.action(async (id: string, opts: PluginUninstallOptions) => {

const {

loadInstalledPluginIndexInstallRecords,

removePluginInstallRecordFromRecords,

withoutPluginInstallRecords,

withPluginInstallRecords,

} = await import("../plugins/installed-plugin-index-records.js");

const { buildPluginSnapshotReport } = await import("../plugins/status.js");

const {

applyPluginUninstallDirectoryRemoval,

formatUninstallActionLabels,

formatUninstallSlotResetPreview,

planPluginUninstall,

resolveUninstallChannelConfigKeys,

UNINSTALL_ACTION_LABELS,

} = await import("../plugins/uninstall.js");

const { commitPluginInstallRecordsWithConfig } =

await import("./plugins-install-record-commit.js");

const { refreshPluginRegistryAfterConfigMutation } =

await import("./plugins-registry-refresh.js");

const { resolvePluginUninstallId } = await import("./plugins-uninstall-selection.js");

const { promptYesNo } = await import("./prompt.js");

const snapshot = await tracePluginLifecyclePhaseAsync(

"config read",

() => readConfigFileSnapshot(),

{ command: "uninstall" },

);

const sourceConfig = (snapshot.sourceConfig ?? snapshot.config) as OpenClawConfig;

const installRecords = await tracePluginLifecyclePhaseAsync(

"install records load",

() => loadInstalledPluginIndexInstallRecords(),

{ command: "uninstall" },

);

const cfg = withPluginInstallRecords(sourceConfig, installRecords);

const report = tracePluginLifecyclePhase(

"plugin registry snapshot",

() => buildPluginSnapshotReport({ config: cfg }),

{ command: "uninstall" },

);

const extensionsDir = path.join(resolveStateDir(process.env, os.homedir), "extensions");

const keepFiles = Boolean(opts.keepFiles || opts.keepConfig);

if (opts.keepConfig) {

defaultRuntime.log(theme.warn("`--keep-config` is deprecated, use `--keep-files`."));

}

const { plugin, pluginId } = resolvePluginUninstallId({

rawId: id,

config: cfg,

plugins: report.plugins,

});

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

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

if (!hasEntry && !hasInstall) {

if (plugin) {

defaultRuntime.error(

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

);

} else {

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

}

return defaultRuntime.exit(1);

}

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

const plan = planPluginUninstall({

config: cfg,

pluginId,

channelIds,

deleteFiles: !keepFiles,

extensionsDir,

});

if (!plan.ok) {

defaultRuntime.error(plan.error);

return defaultRuntime.exit(1);

}

const preview: string[] = [];

if (plan.actions.entry) {

preview.push(UNINSTALL_ACTION_LABELS.entry);

}

if (plan.actions.install) {

preview.push(UNINSTALL_ACTION_LABELS.install);

}

if (plan.actions.allowlist) {

preview.push(UNINSTALL_ACTION_LABELS.allowlist);

}

if (plan.actions.denylist) {

preview.push(UNINSTALL_ACTION_LABELS.denylist);

}

if (plan.actions.loadPath) {

preview.push(UNINSTALL_ACTION_LABELS.loadPath);

}

if (plan.actions.memorySlot) {

preview.push(formatUninstallSlotResetPreview("memory"));

}

if (plan.actions.contextEngineSlot) {

preview.push(formatUninstallSlotResetPreview("contextEngine"));

}

const channels = cfg.channels as Record<string, unknown> | undefined;

if (plan.actions.channelConfig && hasInstall && channels) {

for (const key of resolveUninstallChannelConfigKeys(pluginId, { channelIds })) {

if (Object.hasOwn(channels, key)) {

preview.push(`${UNINSTALL_ACTION_LABELS.channelConfig} (channels.${key})`);

}

}

}

if (plan.directoryRemoval) {

preview.push(`directory: ${shortenHomePath(plan.directoryRemoval.target)}`);

}

const pluginName = plugin?.name || pluginId;

defaultRuntime.log(

`Plugin: ${theme.command(pluginName)}${pluginName !== pluginId ? theme.muted(` (${pluginId})`) : ""}`,

);

defaultRuntime.log(`Will remove: ${preview.length > 0 ? preview.join(", ") : "(nothing)"}`);

if (opts.dryRun) {

defaultRuntime.log(theme.muted("Dry run, no changes made."));

return;

}

if (!opts.force) {

const confirmed = await promptYesNo(`Uninstall plugin "${pluginId}"?`);

if (!confirmed) {

defaultRuntime.log("Cancelled.");

return;

}

}

const nextInstallRecords = removePluginInstallRecordFromRecords(installRecords, pluginId);

const nextConfig = withoutPluginInstallRecords(plan.config);

await tracePluginLifecyclePhaseAsync(

"config mutation",

() =>

commitPluginInstallRecordsWithConfig({

previousInstallRecords: installRecords,

nextInstallRecords,

nextConfig,

...(snapshot.hash !== undefined ? { baseHash: snapshot.hash } : {}),

}),

{ command: "uninstall" },

);

const directoryResult = await applyPluginUninstallDirectoryRemoval(plan.directoryRemoval);

for (const warning of directoryResult.warnings) {

defaultRuntime.log(theme.warn(warning));

}

await refreshPluginRegistryAfterConfigMutation({

config: nextConfig,

reason: "source-changed",

installRecords: nextInstallRecords,

traceCommand: "uninstall",

logger: {

warn: (message) => defaultRuntime.log(theme.warn(message)),

},

});

const removed = formatUninstallActionLabels({

...plan.actions,

directory: directoryResult.directoryRemoved,

});

defaultRuntime.log(

`Uninstalled plugin "${pluginId}". Removed: ${removed.length > 0 ? removed.join(", ") : "nothing"}.`,

);

defaultRuntime.log("Restart the gateway to apply changes.");

const { runPluginUninstallCommand } = await import("./plugins-uninstall-command.js");

await runPluginUninstallCommand(id, opts);

});

plugins