Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(app): ask before closing with running Run/Debug processes (#1445)

ppxb43af99d3ecc9
diff --git a/src/features/app/__tests__/closeGuard.test.ts b/src/features/app/__tests__/closeGuard.test.ts
index 9774d8a4e..c703c1b9c 100644
--- a/src/features/app/__tests__/closeGuard.test.ts
+++ b/src/features/app/__tests__/closeGuard.test.ts
@@ -12,12 +12,22 @@ function deps(answers: PromptResult[]) {
}),
saveAll: vi.fn(async () => {}),
disableConfirmExit: vi.fn(async () => {}),
+ disableConfirmTerminate: vi.fn(async () => {}),
+ runningProcesses: vi.fn(async () => []),
onSaveFailed: vi.fn(),
};
return { d, asked };
}
-const base: CloseInput = { quitting: false, windows: 1, confirmExit: false, dirty: 0, project: "openidea" };
+const base: CloseInput = {
+ quitting: false,
+ windows: 1,
+ confirmExit: false,
+ confirmTerminate: false,
+ processes: [],
+ dirty: 0,
+ project: "openidea",
+};
describe("decideClose", () => {
it("closes silently when nothing needs asking", async () => {
@@ -50,6 +60,46 @@ describe("decideClose", () => {
expect(asked).toHaveLength(0);
});
+ it("asks before terminating a running process", async () => {
+ const { d, asked } = deps([{ button: "terminate", checked: false }]);
+ await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(true);
+ expect(asked).toHaveLength(1);
+ expect(asked[0]?.title).toContain("app");
+ expect(asked[0]?.body).toContain("app");
+ });
+
+ it("names every running process in the prompt", async () => {
+ const { d, asked } = deps([{ button: "terminate", checked: false }]);
+ await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app", "worker"] }, d)).resolves.toBe(true);
+ expect(asked[0]?.body).toContain("app, worker");
+ });
+
+ it("cancelling the terminate prompt keeps the window", async () => {
+ const { d } = deps([{ button: "cancel", checked: false }]);
+ await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(false);
+ });
+
+ it("asks about processes before discarding unsaved changes", async () => {
+ const { d, asked } = deps([{ button: "cancel", checked: false }]);
+ await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"], dirty: 1 }, d)).resolves.toBe(
+ false,
+ );
+ expect(asked).toHaveLength(1);
+ expect(d.saveAll).not.toHaveBeenCalled();
+ });
+
+ it("'don't ask again' turns process confirmation off", async () => {
+ const { d } = deps([{ button: "terminate", checked: true }]);
+ await decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d);
+ expect(d.disableConfirmTerminate).toHaveBeenCalled();
+ });
+
+ it("does not ask about processes when the setting is off", async () => {
+ const { d, asked } = deps([]);
+ await decideClose({ ...base, confirmTerminate: false, processes: ["app"] }, d);
+ expect(asked).toHaveLength(0);
+ });
+
it("saves all on Save", async () => {
const { d } = deps([{ button: "save", checked: false }]);
await expect(decideClose({ ...base, dirty: 2 }, d)).resolves.toBe(true);
@@ -179,3 +229,12 @@ it("includes pending local edits and restored dirty buffers before backend dirty
spy.mockRestore();
}
});
+
+it("confirmLeave asks about running processes before closing", async () => {
+ const { confirmLeave } = await import("../closeGuard");
+ const { d, asked } = deps([{ button: "cancel", checked: false }]);
+ d.runningProcesses = vi.fn(async () => ["app"]);
+ await expect(confirmLeave(d, "openidea")).resolves.toBe(false);
+ expect(asked[0]?.title).toContain("app");
+ expect(asked[0]?.body).toContain("app");
+});
diff --git a/src/features/app/closeGuard.ts b/src/features/app/closeGuard.ts
index c08195de0..dff728230 100644
--- a/src/features/app/closeGuard.ts
+++ b/src/features/app/closeGuard.ts
@@ -3,14 +3,21 @@
*
* Closing a window (traffic light, Quit closing every window) runs
* `decideClose`: confirm exit when this is the last window and
- * `general.confirmExit` is on, then Save All / Don't Save / Cancel when
- * documents have unsaved changes. Quit confirms once, then the backend closes
- * every window, each of which runs only its unsaved-changes check.
+ * `general.confirmExit` is on, then Terminate / Cancel when Run/Debug processes
+ * still run and `run.confirmTerminate` is on, then Save All / Don't Save / Cancel
+ * when documents have unsaved changes. Quit confirms once, then the backend
+ * closes every window, each of which runs its own checks.
*/
import { commands, isTauri, onIdeEvent, type Settings } from "@/platform/ipc";
import { t } from "@/platform/i18n";
import { closeProject, provideLeaveProjectGuard, useProject } from "@/platform/project";
-import { maybeEditorService, notifications, type EditorCloseSession } from "@/workbench/contributions";
+import { workflowSettings } from "@/platform/workflowSettings";
+import {
+ maybeEditorService,
+ notifications,
+ runningProcesses as liveProcesses,
+ type EditorCloseSession,
+} from "@/workbench/contributions";
import { ask, type Ask } from "@/workbench/messages";
import { AUX_CLOSED, auxiliaryWindow, closeDocumentWindows, type AuxCloseResult } from "@/platform/auxWindow";
@@ -29,6 +36,9 @@ export interface CloseInput {
quitting: boolean;
windows: number;
confirmExit: boolean;
+ confirmTerminate: boolean;
+ /** Running Run/Debug process names this close would terminate. */
+ processes: readonly string[];
dirty: number;
project: string | null;
}
@@ -37,6 +47,9 @@ export interface CloseDeps {
ask: Ask;
saveAll: () => Promise<void>;
disableConfirmExit: () => Promise<void>;
+ disableConfirmTerminate: () => Promise<void>;
+ /** Running Run/Debug process names in this window. */
+ runningProcesses: () => Promise<readonly string[]>;
onSaveFailed: (e: unknown) => void;
/** Stops custom document edits/execution before reading their final dirty state. */
prepareClose?: () => Promise<EditorCloseSession | undefined>;
@@ -54,6 +67,24 @@ export async function decideClose(input: CloseInput, deps: CloseDeps): Promise<b
if (r.button !== "exit") return false;
if (r.checked) await deps.disableConfirmExit().catch(() => {});
}
+ if (input.confirmTerminate && input.processes.length > 0) {
+ const names = input.processes;
+ const r = await deps.ask({
+ title:
+ names.length === 1
+ ? t("app.terminateProcesses.titleOne", { name: names[0]! })
+ : t("app.terminateProcesses.titleMany", { count: names.length }),
+ body:
+ names.length === 1
+ ? t("app.terminateProcesses.bodyOne", { name: names[0]! })
+ : t("app.terminateProcesses.bodyMany", { count: names.length, names: names.join(", ") }),
+ buttons: [{ id: "terminate", label: t("app.terminateProcesses.terminate"), primary: true }],
+ checkbox: t("app.terminateProcesses.dontAsk"),
+ icon: "warning",
+ });
+ if (r.button !== "terminate") return false;
+ if (r.checked) await deps.disableConfirmTerminate().catch(() => {});
+ }
let session: EditorCloseSession | undefined;
let authorized = false;
try {
@@ -94,6 +125,11 @@ const defaultDeps: CloseDeps = {
const r = await commands.settingsSet("global", "general.confirmExit", "false");
if (r.status === "ok") useProject.setState({ settings: r.data });
},
+ disableConfirmTerminate: async () => {
+ const r = await commands.settingsSet("global", "run.confirmTerminate", "false");
+ if (r.status === "ok") useProject.setState({ settings: r.data });
+ },
+ runningProcesses: async () => (await liveProcesses()).map((p) => p.name),
onSaveFailed: (e) =>
notifications().notify({
level: "error",
@@ -102,6 +138,11 @@ const defaultDeps: CloseDeps = {
}),
};
+/** Process names this close would terminate; an unavailable feature list never blocks closing. */
+async function processNames(deps: CloseDeps): Promise<string[]> {
+ return [...new Set(await deps.runningProcesses().catch(() => []))].filter(Boolean);
+}
+
let closing = false;
async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
@@ -120,11 +161,14 @@ async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
if (await confirmLeave(deps)) await closeProject();
return false;
}
+ const confirmTerminate = workflowSettings().run.confirmTerminate;
const ok = await decideClose(
{
quitting: ctx.quitting,
windows: ctx.windows,
confirmExit: confirmExitEnabled(s.settings),
+ confirmTerminate,
+ processes: confirmTerminate ? await processNames(deps) : [],
dirty: dirtyCount(),
project: s.project?.name ?? null,
},
@@ -151,15 +195,36 @@ export async function confirmLeave(
project = useProject.getState().project?.name ?? null,
): Promise<boolean> {
if (!(await closeDocumentWindows())) return false;
- return decideClose({ quitting: false, windows: 2, confirmExit: false, dirty: dirtyCount(), project }, deps);
+ const confirmTerminate = workflowSettings().run.confirmTerminate;
+ return decideClose(
+ {
+ quitting: false,
+ windows: 2,
+ confirmExit: false,
+ confirmTerminate,
+ processes: confirmTerminate ? await processNames(deps) : [],
+ dirty: dirtyCount(),
+ project,
+ },
+ deps,
+ );
}
/** Quit: confirm once (if enabled), then let the backend close every window. */
export async function quitApp(deps: CloseDeps = defaultDeps): Promise<void> {
if (!isTauri()) return;
if (confirmExitEnabled(useProject.getState().settings)) {
+ // Each window asks about its own processes as the backend closes it.
const ok = await decideClose(
- { quitting: false, windows: 1, confirmExit: true, dirty: 0, project: null },
+ {
+ quitting: false,
+ windows: 1,
+ confirmExit: true,
+ confirmTerminate: false,
+ processes: [],
+ dirty: 0,
+ project: null,
+ },
{ ...deps, prepareClose: undefined },
);
if (!ok) return;
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index a663c368c..10ffa6113 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -16,6 +16,7 @@ import {
registerMenuGroup,
registerOverlay,
registerRunAnythingProvider,
+ registerRunningProcessesProvider,
registerServiceProvider,
registerTitleItem,
registerToolWindow,
@@ -42,6 +43,7 @@ import { invalidatePythonPackages } from "./pythonPackages";
import { RunWidget } from "./RunWidget";
import { runConfigsRunAnything } from "./runAnything";
import { cleanupRemovedProject, recordRun, runServiceProvider } from "./services";
+import { liveServiceSession, serviceSessions } from "./serviceSessions";
import { runBeforeLaunch } from "./beforeLaunch";
import { compoundChildren } from "./configs";
import { remoteDebugBlocked } from "./remote";
@@ -294,6 +296,13 @@ export function activate(): () => void {
registerOverlay({ id: "run.editConfigs", component: EditConfigsOverlay }),
registerOverlay({ id: "run.dialogs", component: RunDialogsOverlay }),
registerServiceProvider(runServiceProvider),
+ registerRunningProcessesProvider({
+ id: "run",
+ running: () =>
+ serviceSessions(useRun.getState().sessions, useDebugRunSessions.getState().serviceSessions)
+ .filter(liveServiceSession)
+ .map((s) => ({ name: s.config.name })),
+ }),
onWorkflowSettingsChange((w) => w.console, applyConsoleSettings),
registerExternalTools(),
activateStackTrace(),
diff --git a/src/platform/locales/en.json b/src/platform/locales/en.json
index 05325107b..18b229171 100644
--- a/src/platform/locales/en.json
+++ b/src/platform/locales/en.json
@@ -50,6 +50,12 @@
"app.lightEdit.openProjectTooltip": "Open {folder} as a project",
"app.log.failed": "Cannot show the log",
"app.project.opening": "Opening {name}…",
+ "app.terminateProcesses.bodyMany": "Do you want to terminate these {count} processes: {names}?",
+ "app.terminateProcesses.bodyOne": "Do you want to terminate the process '{name}'?",
+ "app.terminateProcesses.dontAsk": "Don't ask again",
+ "app.terminateProcesses.terminate": "Terminate",
+ "app.terminateProcesses.titleMany": "Processes Are Running",
+ "app.terminateProcesses.titleOne": "Process '{name}' Is Running",
"app.title.default": "OpenIDEA",
"app.unsaved.body": "{count, plural, one {# file has} other {# files have}} unsaved changes in {project}. Save before closing?",
"app.unsaved.discard": "Don't Save",
diff --git a/src/platform/locales/zh.json b/src/platform/locales/zh.json
index 3dbaef005..6cf81d316 100644
--- a/src/platform/locales/zh.json
+++ b/src/platform/locales/zh.json
@@ -50,6 +50,12 @@
"app.lightEdit.openProjectTooltip": "将 {folder} 作为项目打开",
"app.log.failed": "无法显示日志",
"app.project.opening": "正在打开 {name}…",
+ "app.terminateProcesses.bodyMany": "是否要终止这 {count} 个进程:{names}?",
+ "app.terminateProcesses.bodyOne": "是否要终止进程“{name}”?",
+ "app.terminateProcesses.dontAsk": "不再询问",
+ "app.terminateProcesses.terminate": "终止",
+ "app.terminateProcesses.titleMany": "有进程正在运行",
+ "app.terminateProcesses.titleOne": "进程“{name}”正在运行",
"app.title.default": "OpenIDEA",
"app.unsaved.body": "{project} 中有 {count} 个文件尚未保存。关闭前是否保存?",
"app.unsaved.discard": "不保存",
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index 7b7c2a633..8f09062c8 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -1459,6 +1459,42 @@ export const useDebugRunSessions = create<{
Console: ComponentType<{ sessionId: number }> | null;
}>(() => ({ sessions: [], serviceSessions: [], Console: null }));
+// ---------------------------------------------------------------------------
+// Processes a closing window or project would terminate. Features that own
+// child processes (Run/Debug sessions) publish them here, so the close guard can
+// ask first (IDEA's "Terminate processes?").
+
+export interface RunningProcess {
+ /** Configuration or session name shown in the prompt. */
+ name: string;
+}
+
+export interface RunningProcessesProvider {
+ id: string;
+ /** Processes this feature is running in the window right now. */
+ running(): RunningProcess[] | Promise<RunningProcess[]>;
+}
+
+const runningProcessesProviders = new Map<string, RunningProcessesProvider>();
+
+export function registerRunningProcessesProvider(p: RunningProcessesProvider): () => void {
+ runningProcessesProviders.set(p.id, p);
+ return () => {
+ if (runningProcessesProviders.get(p.id) === p) runningProcessesProviders.delete(p.id);
+ };
+}
+
+/** Live processes of every provider, one entry per name. */
+export async function runningProcesses(): Promise<RunningProcess[]> {
+ const all = (await Promise.all([...runningProcessesProviders.values()].map((p) => p.running()))).flat();
+ const seen = new Set<string>();
+ return all.filter((p) => {
+ if (!p.name || seen.has(p.name)) return false;
+ seen.add(p.name);
+ return true;
+ });
+}
+
// ---------------------------------------------------------------------------
// "Get from Version Control" sources besides a plain URL (IDEA: GitHub, GitLab…),
// listed in the Clone Repository dialog's sidebar.
diff --git a/src/workbench/runningProcesses.test.ts b/src/workbench/runningProcesses.test.ts
new file mode 100644
index 000000000..8a53c7b22
--- /dev/null
+++ b/src/workbench/runningProcesses.test.ts
@@ -0,0 +1,35 @@
+import { expect, it, vi } from "vitest";
+import { registerRunningProcessesProvider, runningProcesses } from "./contributions";
+
+it("collects live processes from every provider, one entry per name", async () => {
+ const first = vi.fn(async () => [{ name: "app" }, { name: "worker" }]);
+ const second = vi.fn(() => [{ name: "app" }, { name: "docs" }]);
+ const disposers = [
+ registerRunningProcessesProvider({ id: "test.first", running: first }),
+ registerRunningProcessesProvider({ id: "test.second", running: second }),
+ ];
+ try {
+ expect(await runningProcesses()).toEqual([{ name: "app" }, { name: "worker" }, { name: "docs" }]);
+ expect(first).toHaveBeenCalledOnce();
+ expect(second).toHaveBeenCalledOnce();
+ } finally {
+ disposers.forEach((dispose) => dispose());
+ }
+ expect(await runningProcesses()).toEqual([]);
+});
+
+it("keeps a replacement provider registered when its predecessor is disposed", async () => {
+ const disposeOld = registerRunningProcessesProvider({ id: "test.replaced", running: async () => [] });
+ const disposeNew = registerRunningProcessesProvider({
+ id: "test.replaced",
+ running: async () => [{ name: "app" }],
+ });
+ try {
+ disposeOld();
+ expect(await runningProcesses()).toEqual([{ name: "app" }]);
+ } finally {
+ disposeOld();
+ disposeNew();
+ }
+ expect(await runningProcesses()).toEqual([]);
+});