import fs from "node:fs";

import path from "node:path";

import { findOverlappingWorkspaceAgentIds } from "../agents/agent-delete-safety.js";

import { resolveAgentDir, resolveAgentWorkspaceDir } from "../agents/agent-scope.js";

import { replaceConfigFile } from "../config/config.js";

import { logConfigUpdated } from "../config/logging.js";

import { resolveSessionTranscriptsDirForAgent } from "../config/sessions.js";

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

import {

purgeAgentSessionStoreEntries,

resolveSessionTranscriptsDirForAgent,

} from "../config/sessions.js";

import { callGateway, isGatewayTransportError } from "../gateway/call.js";

import { DEFAULT_AGENT_ID, normalizeAgentId } from "../routing/session-key.js";

import { type RuntimeEnv, writeRuntimeJson } from "../runtime.js";

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

import { lowercasePreservingWhitespace } from "../shared/string-coerce.js";

import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";

import { createClackPrompter } from "../wizard/clack-prompter.js";

import {

createQuietRuntime,

purgeAgentSessionStoreEntries,

requireValidConfigFileSnapshot,

} from "./agents.command-shared.js";

import { createQuietRuntime, requireValidConfigFileSnapshot } from "./agents.command-shared.js";

import { findAgentEntryIndex, listAgentEntries, pruneAgentConfig } from "./agents.config.js";

import { moveToTrash } from "./onboard-helpers.js";

function normalizeWorkspacePathForComparison(input: string): string {

const resolved = path.resolve(input.replaceAll("\0", ""));

let normalized = resolved;

try {

normalized = fs.realpathSync.native(resolved);

} catch {

// Keep lexical path for non-existent directories.

}

if (process.platform === "win32") {

return lowercasePreservingWhitespace(normalized);

}

return normalized;

}

function isPathWithinRoot(candidatePath: string, rootPath: string): boolean {

const relative = path.relative(rootPath, candidatePath);

return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));

}

function workspacePathsOverlap(left: string, right: string): boolean {

const normalizedLeft = normalizeWorkspacePathForComparison(left);

const normalizedRight = normalizeWorkspacePathForComparison(right);

return (

isPathWithinRoot(normalizedLeft, normalizedRight) ||

isPathWithinRoot(normalizedRight, normalizedLeft)

);

}

function findOverlappingWorkspaceAgentIds(

cfg: OpenClawConfig,

agentId: string,

workspaceDir: string,

): string[] {

const entries = listAgentEntries(cfg);

const normalizedAgentId = normalizeAgentId(agentId);

const overlappingAgentIds: string[] = [];

for (const entry of entries) {

const otherAgentId = normalizeAgentId(entry.id);

if (otherAgentId === normalizedAgentId) {

continue;

}

const otherWorkspace = resolveAgentWorkspaceDir(cfg, otherAgentId);

if (workspacePathsOverlap(workspaceDir, otherWorkspace)) {

overlappingAgentIds.push(otherAgentId);

}

}

return overlappingAgentIds;

}

type AgentsDeleteOptions = {

id: string;

force?: boolean;

json?: boolean;

};

type AgentsDeleteGatewayResult = {

ok: true;

agentId: string;

removedBindings: number;

};

async function maybeDeleteAgentThroughGateway(params: {

agentId: string;

deleteFiles: boolean;

}): Promise<AgentsDeleteGatewayResult | null> {

try {

return await callGateway<AgentsDeleteGatewayResult>({

method: "agents.delete",

params: {

agentId: params.agentId,

deleteFiles: params.deleteFiles,

},

mode: GATEWAY_CLIENT_MODES.CLI,

clientName: GATEWAY_CLIENT_NAMES.CLI,

requiredMethods: ["agents.delete"],

});

} catch (error) {

if (isGatewayTransportError(error)) {

return null;

}

throw error;

}

}

export async function agentsDeleteCommand(

opts: AgentsDeleteOptions,

runtime: RuntimeEnv = defaultRuntime,

const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);

const agentDir = resolveAgentDir(cfg, agentId);

const sessionsDir = resolveSessionTranscriptsDirForAgent(agentId);

const result = pruneAgentConfig(cfg, agentId);

const gatewayResult = await maybeDeleteAgentThroughGateway({

agentId,

deleteFiles: true,

});

if (gatewayResult) {

const workspaceSharedWith = findOverlappingWorkspaceAgentIds(cfg, agentId, workspaceDir);

const workspaceRetained = workspaceSharedWith.length > 0;

if (opts.json) {

writeRuntimeJson(runtime, {

agentId,

workspace: workspaceDir,

workspaceRetained: workspaceRetained || undefined,

workspaceRetainedReason: workspaceRetained ? "shared" : undefined,

workspaceSharedWith: workspaceRetained ? workspaceSharedWith : undefined,

agentDir,

sessionsDir,

removedBindings: gatewayResult.removedBindings,

removedAllow: result.removedAllow,

transport: "gateway",

});

} else {

runtime.log(`Deleted agent: ${agentId}`);

}

return;

}

await replaceConfigFile({

nextConfig: result.config,

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