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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(run): target the selected configuration's run or debug session from the toolbar (#326)
l0ng-aia7b5758f5a71
diff --git a/src/features/debugger/__tests__/runOrigin.test.ts b/src/features/debugger/__tests__/runOrigin.test.tsnew file mode 100644index 000000000..1f108bf1a--- /dev/null+++ b/src/features/debugger/__tests__/runOrigin.test.ts@@ -0,0 +1,104 @@+import { beforeEach, expect, it, vi } from "vitest";+import { executeAction, registerActions } from "@/platform/actions";+import { useProject } from "@/platform/project";+import {+ provideNotificationService,+ provideToolWindowService,+ useDebugRunSessions,+ type ToolWindowService,+} from "@/workbench/contributions";+import type { RunConfig } from "@/platform/ipc";+import { registerDebugActions } from "../actions";+import { adoptSession, publishContext, rerunSession, useDebug } from "../state";++const ipc = vi.hoisted(() => ({+ javaDebugServer: vi.fn(async () => ({ status: "ok", data: 5005 })),+ debugStart: vi.fn(async () => ({ status: "ok", data: 42 })),+ debugStop: vi.fn(async () => ({ status: "ok", data: null })),+}));+vi.mock("@/platform/ipc", async (original) => {+ const real = await original<typeof import("@/platform/ipc")>();+ return { ...real, isTauri: () => true, commands: { ...real.commands, ...ipc } };+});+const config: RunConfig = {+ id: "node:server",+ name: "server",+ kind: "node",+ command: "node",+ args: ["server.js"],+ cwd: null,+ env: {},+ detected: true,+ isTest: false,+ debugAdapter: "js-debug",+};+beforeEach(() => {+ useDebug.setState({ sessions: {}, active: null, console: {} });+ useDebugRunSessions.setState({ sessions: [] });+ useProject.setState({ project: { root: "/p" } as never });+ provideNotificationService({ notify: vi.fn() });+ provideToolWindowService({ show: vi.fn() } as unknown as ToolWindowService);+ vi.clearAllMocks();+});++it("keeps the RunConfig through debug.startConfig and reruns through its debug preparation", async () => {+ const dispose = registerDebugActions();+ const restart = vi.fn();+ const unregister = registerActions([{ id: "run.debugConfig", title: "Debug", run: ({ arg }) => restart(arg) }]);+ try {+ await executeAction("debug.startConfig", config);+ const session = useDebug.getState().sessions[42]!;+ expect(session.runConfig).toEqual(config);+ expect(session.startedAt).toBeGreaterThan(0);+ expect(useDebugRunSessions.getState().sessions[0]?.configId).toBe(config.id);+ await rerunSession(42);+ expect(ipc.debugStop).toHaveBeenCalledWith(42);+ expect(restart).toHaveBeenCalledWith(config);+ } finally {+ dispose();+ unregister();+ }+});++it("preserves the source configuration for a separately built debug binary", async () => {+ const dispose = registerDebugActions();+ try {+ await executeAction("debug.startConfig", { config, origin: { ...config, id: "source:server" } });+ expect(useDebug.getState().sessions[42]?.runConfig?.id).toBe("source:server");+ } finally {+ dispose();+ }+});++it("keeps the originating JVM configuration when attaching to its build process", async () => {+ const dispose = registerDebugActions();+ try {+ await executeAction("debug.attach", {+ name: "server",+ module: "",+ hostName: "127.0.0.1",+ port: 5005,+ process: 7,+ runConfig: config,+ });+ expect(useDebug.getState().sessions[42]).toMatchObject({ runConfig: config, process: 7, launch: null });+ expect(useDebugRunSessions.getState().sessions[0]?.rerun).toBeTypeOf("function");+ } finally {+ dispose();+ }+});++it("exposes a paused child through its originating root rather than the active unrelated session", () => {+ adoptSession(1, { runConfig: config });+ adoptSession(2, { parent: 1, status: "paused", stoppedThread: 1 });+ adoptSession(3, { runConfig: { ...config, id: "other" } });+ useDebug.setState({ active: 3 });+ publishContext();+ const roots = useDebugRunSessions.getState().sessions;+ expect(roots.map((s) => [s.configId, s.paused])).toEqual([+ [config.id, true],+ ["other", false],+ ]);+ roots[0]!.resume();+ expect(useDebug.getState().active).toBe(2);+});diff --git a/src/features/debugger/actions.ts b/src/features/debugger/actions.tsindex 88338717c..d40740b5f 100644--- a/src/features/debugger/actions.ts+++ b/src/features/debugger/actions.ts@@ -211,17 +211,19 @@ async function startRemote(config: RunConfig, root: string) {}const launch = await javaAttachConfig({ name: config.name, module: t.module, hostName, port }, root);// A listen relay accepts one debugger: rerunning listens again through the configuration.- await startSession(launch, { rerunnable: t.mode === "attach" });+ await startSession(launch, { runConfig: config, rerunnable: t.mode === "attach" });return;}const launch = remoteAttachConfig(config, root);- if (launch) await startSession(launch);+ if (launch) await startSession(launch, { runConfig: config });}async function startConfig(arg: unknown) {const root = useProject.getState().project?.root;if (!root) return;- let config: RunConfig | null = isRunConfig(arg) ? arg : null;+ const origin = arg && typeof arg === "object" && "origin" in arg && isRunConfig(arg.origin) ? arg.origin : null;+ const input = arg && typeof arg === "object" && "config" in arg ? arg.config : arg;+ let config: RunConfig | null = isRunConfig(input) ? input : null;if (!config) {if (!isTauri()) {notifications().notify({ group: "run", level: "warning", title: "Debugging needs the desktop app" });@@ -256,7 +258,7 @@ async function startConfig(arg: unknown) {await maybeEditorService()?.saveAll().catch(() => undefined);- await startSession(await javaLaunchConfig(config, root));+ await startSession(await javaLaunchConfig(config, root), { runConfig: origin ?? config });return;}const launch = launchConfigFor(config, root);@@ -272,7 +274,7 @@ async function startConfig(arg: unknown) {await maybeEditorService()?.saveAll().catch(() => undefined);- await startSession(launch);+ await startSession(launch, { runConfig: origin ?? config });}export function registerDebugActions(): () => void {@@ -312,7 +314,11 @@ export function registerDebugActions(): () => void {const root = useProject.getState().project?.root;if (!root || !isJavaAttachTarget(arg)) return;const launch = await javaAttachConfig(arg, root);- await startSession(launch, { process: (arg.process ?? null) as RunId | null, rerunnable: false });+ await startSession(launch, {+ process: (arg.process ?? null) as RunId | null,+ runConfig: arg.runConfig,+ rerunnable: false,+ });})(),),},diff --git a/src/features/debugger/java.ts b/src/features/debugger/java.tsindex d5b3d45b7..5f5f93c4f 100644--- a/src/features/debugger/java.ts+++ b/src/features/debugger/java.ts@@ -102,7 +102,9 @@ export interface JavaAttachTarget {port: number;}-export function isJavaAttachTarget(arg: unknown): arg is JavaAttachTarget & { process?: number | null } {+export function isJavaAttachTarget(+ arg: unknown,+): arg is JavaAttachTarget & { process?: number | null; runConfig?: RunConfig } {return !!arg && typeof arg === "object" && "port" in arg && typeof (arg as { port: unknown }).port === "number";}diff --git a/src/features/debugger/state.ts b/src/features/debugger/state.tsindex 336c9eb56..59e5f9888 100644--- a/src/features/debugger/state.ts+++ b/src/features/debugger/state.ts@@ -16,11 +16,12 @@ import {type DebugSessionId,type LaunchConfig,type RunId,+ type RunConfig,type StackFrame,type ThreadInfo,type Variable,} from "@/platform/ipc";-import { maybeEditorService, notifications, toolWindowService } from "@/workbench/contributions";+import { maybeEditorService, notifications, toolWindowService, useDebugRunSessions } from "@/workbench/contributions";import { breakpointsOf, consumeTemporary, refreshStates, resetStatuses } from "./breakpoints/store";import { interpolateLog, logParts, suspends } from "./breakpoints/model";import { syncSpecial, useSpecialBreakpoints } from "./breakpoints/special";@@ -32,6 +33,9 @@ export type SessionStatus = "starting" | "running" | "paused" | "terminated";export interface DebugSession {id: DebugSessionId;name: string;+ /** Originating configuration, retained for toolbar targeting and prepared debug reruns. */+ runConfig?: RunConfig;+ startedAt?: number;adapter: string;parent: DebugSessionId | null;/** Launch configuration (root sessions), used by Rerun. */@@ -136,6 +140,7 @@ function blank(id: DebugSessionId, p: Partial<DebugSession> = {}): DebugSessionreturn {id,name: "Debug",+ startedAt: Date.now(),adapter: "",parent: null,launch: null,@@ -211,10 +216,32 @@ function settleStart(id: DebugSessionId | null) {export function publishContext() {const s = activeSession();+ useDebugRunSessions.setState({+ sessions: Object.values(useDebug.getState().sessions)+ .filter((session) => session.parent == null && isLive(session))+ .map((session) => {+ const paused = Object.values(useDebug.getState().sessions).find(+ (child) => child.status === "paused" && rootOf(child).id === session.id,+ );+ return {+ id: session.id,+ configId: session.runConfig?.id ?? null,+ name: session.runConfig?.name ?? session.name,+ startedAt: session.startedAt ?? 0,+ paused: !!paused,+ rerun: session.runConfig || session.launch ? () => void rerunSession(session.id) : null,+ stop: () => void stopSession(session.id),+ resume: () => {+ selectSession(paused?.id ?? session.id);+ void executeAction("debug.resume");+ },+ };+ }),+ });const anyLive = Object.values(useDebug.getState().sessions).some(isLive);setContext("debugSessionActive", anyLive);setContext("debugSessionPaused", s?.status === "paused");- setContext("debugCanRerun", !!s && !!rootOf(s).launch);+ setContext("debugCanRerun", !!s && !!(rootOf(s).runConfig || rootOf(s).launch));setContext("debugCanHotSwap",Object.values(useDebug.getState().sessions).some((x) => isLive(x) && !!x.caps?.hotCodeReplace),@@ -253,6 +280,7 @@ export function clearConsole(session: DebugSessionId) {export async function startSession(launch: LaunchConfig,options: {+ runConfig?: RunConfig;/** A process started for this session (e.g. Maven with a JDWP agent): Stop ends it too. */process?: RunId | null;/** Rerun repeats the launch (false for attaching to a process that is gone afterwards). */@@ -275,6 +303,7 @@ export async function startSession(} catch {// Workbench not ready (tests).}+ const startedAt = Date.now();pendingStarts++;try {const id = await call(commands.debugStart(launch));@@ -287,6 +316,8 @@ export async function startSession([id]: {...cur,name: launch.name,+ runConfig: options.runConfig,+ startedAt,adapter: launch.adapter,launch: options.rerunnable === false ? null : launch,process: options.process ?? null,@@ -353,6 +384,11 @@ export async function rerunSession(id: DebugSessionId) {const s = useDebug.getState().sessions[id];if (!s) return;const root = rootOf(s);+ if (root.runConfig) {+ if (isLive(root)) await stopSession(root.id);+ await executeAction("run.debugConfig", root.runConfig);+ return;+ }const launch = root.launch;if (!launch) return;if (isLive(root)) await stopSession(root.id);diff --git a/src/features/run/RunWidget.test.tsx b/src/features/run/RunWidget.test.tsxnew file mode 100644index 000000000..abd5fdea8--- /dev/null+++ b/src/features/run/RunWidget.test.tsx@@ -0,0 +1,123 @@+import { afterEach, beforeEach, expect, it, vi } from "vitest";+import { cleanup, fireEvent, render, screen } from "@testing-library/react";+import { executeAction } from "@/platform/actions";+import { setContext } from "@/platform/context";+import type { RunConfig } from "@/platform/ipc";+import { useDebugRunSessions, type DebugRunSession } from "@/workbench/contributions";+import { applicationConfig } from "./application";+import { activate } from "./index";+import { RunWidget } from "./RunWidget";+import { resetRuns, useRun, type RunSession } from "./store";+import { selectedTarget } from "./sessionTargets";++const config = (id: string): RunConfig => ({+ id,+ name: id,+ kind: "shell",+ command: "sleep",+ args: ["60"],+ cwd: null,+ env: {},+ detected: false,+ isTest: false,+ debugAdapter: null,+});+const app = config("SdCloudOaApplication");+const npm = config("sdcloud-oa-vue3: npm run dev");+const run = (c: RunConfig, startedAt = 1): RunSession => ({+ id: c.id,+ config: c,+ runId: 1,+ status: "running",+ exitCode: null,+ startedAt,+ endedAt: null,+ stdinClosed: false,+});+const debug = (c: RunConfig, startedAt = 2): DebugRunSession => ({+ id: 1,+ configId: c.id,+ name: c.name,+ startedAt,+ paused: false,+ rerun: vi.fn(),+ stop: vi.fn(),+ resume: vi.fn(),+});+let dispose: () => void;+beforeEach(() => {+ resetRuns();+ useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });+ useDebugRunSessions.setState({ sessions: [] });+ setContext("projectOpen", true);+ dispose = activate();+});+afterEach(() => {+ cleanup();+ dispose();+ useDebugRunSessions.setState({ sessions: [] });+});++it("reruns and stops the selected configuration among several running sessions", () => {+ useRun.setState({ sessions: [run(app), run(npm, 3)] });+ render(<RunWidget />);+ expect(screen.getByRole("button", { name: `Rerun '${app.name}'` })).toBeTruthy();+ fireEvent.click(screen.getByRole("button", { name: `Stop '${app.name}'` }));+ expect(useRun.getState().sessions.map((s) => !!s.stopped)).toEqual([true, false]);+});++it("offers Run/Debug for an idle selection and Stop for the other process", () => {+ useRun.setState({ sessions: [run(npm)] });+ render(<RunWidget />);+ expect(screen.getByRole("button", { name: `Run '${app.name}'` })).toBeTruthy();+ expect(screen.getByRole("button", { name: `Debug '${app.name}'` })).toBeTruthy();+ expect(screen.queryByRole("button", { name: /Rerun/ })).toBeNull();+ fireEvent.click(screen.getByRole("button", { name: `Stop '${npm.name}'` }));+ expect(useRun.getState().sessions[0]?.stopped).toBe(true);+});++it("offers a stop list when the selection is idle and several other sessions run", () => {+ useRun.setState({ sessions: [run(npm), run(config("other"))] });+ render(<RunWidget />);+ expect(screen.getByRole("button", { name: "Stop (2 running)" })).toBeTruthy();+ expect(screen.queryByRole("button", { name: /Rerun/ })).toBeNull();+});++it("targets the selected debug session while npm runs, through buttons and shortcut actions", async () => {+ const session = debug(app);+ useRun.setState({ sessions: [run(npm, 3)] });+ useDebugRunSessions.setState({ sessions: [session] });+ render(<RunWidget />);+ fireEvent.click(screen.getByRole("button", { name: `Rerun '${app.name}'` }));+ await vi.waitFor(() => expect(session.rerun).toHaveBeenCalledOnce());+ await executeAction("run.run");+ expect(session.rerun).toHaveBeenCalledTimes(2);+ fireEvent.click(screen.getByRole("button", { name: `Stop '${app.name}'` }));+ await executeAction("run.stop");+ expect(session.stop).toHaveBeenCalledTimes(2);+ expect(useRun.getState().sessions[0]?.stopped).toBeUndefined();+});++it("ignores an unrelated debug session for an idle selection", () => {+ useDebugRunSessions.setState({ sessions: [debug(npm)] });+ render(<RunWidget />);+ expect(screen.getByRole("button", { name: `Run '${app.name}'` })).toBeTruthy();+ expect(screen.queryByRole("button", { name: /Rerun/ })).toBeNull();+});++it.each([1, 3])("prefers the newest Run or Debug session of the same config (run start %s)", (startedAt) => {+ expect(selectedTarget(app.id, [run(app, startedAt)], [debug(app, 2)])?.debug).toBe(startedAt < 2);+});++it("matches a detected Spring configuration after its object and id are regenerated", () => {+ const detect = () =>+ applicationConfig(+ { className: "com.example.SdCloudOaApplication", spring: true },+ "src/main/java/com/example/SdCloudOaApplication.java",+ );+ const original = detect();+ const regenerated = detect();+ expect(regenerated).not.toBe(original);+ expect(regenerated.id).toBe(original.id);+ expect(selectedTarget(regenerated.id, [run(original), run(npm)], [])?.name).toBe(original.name);+});diff --git a/src/features/run/RunWidget.tsx b/src/features/run/RunWidget.tsxindex 910af3594..bfb150cd8 100644--- a/src/features/run/RunWidget.tsx+++ b/src/features/run/RunWidget.tsx@@ -2,13 +2,13 @@ import { useRef, useState } from "react";import clsx from "clsx";import { BarButton, Icon, IconButton, Menu, type MenuItem } from "@/ui";import { executeAction } from "@/platform/actions";-import { useContextKeys } from "@/platform/context";import { useTx } from "@/platform/i18n";import { shortcutLabel } from "@/platform/keymap";-import { runExecutors, useRunExecutors } from "@/workbench/contributions";+import { runExecutors, useRunExecutors, useDebugRunSessions } from "@/workbench/contributions";import { configIcon } from "./configs";import { useRemoteLabel } from "./remote";-import { CURRENT_FILE, rerunSession, sessionsOf, startRun, stopSession, useRun } from "./store";+import { CURRENT_FILE, useRun } from "./store";+import { compoundTargets, selectedTarget } from "./sessionTargets";import { isDebugOnly } from "./types";import styles from "./Run.module.css";@@ -25,15 +25,15 @@ export function RunWidget() {// Remote JVM Debug and the like: only Debug applies, as in IDEA.const debugOnly = !!selected && isDebugOnly(selected);const running = sessions.filter((s) => s.status === "running" || s.status === "starting");- // A compound is running while any of its configurations is; Stop stops them all.- const compoundRunning = selected?.kind === "compound" ? sessionsOf(selected, running) : [];- const runningSelected = compoundRunning[0] ?? running.find((s) => s.config.id === selectedId) ?? null;- const target = runningSelected ?? running[running.length - 1] ?? null;- // Debug sessions belong to the debugger feature; like IDEA the widget offers their Rerun / Stop.- const debugging = useContextKeys((c) => !!c.debugSessionActive);- const canRerunDebug = useContextKeys((c) => !!c.debugCanRerun);- const debugPaused = useContextKeys((c) => !!c.debugSessionPaused);- const active = !!runningSelected || debugging;+ const debug = useDebugRunSessions((s) => s.sessions);+ const compoundRunning = compoundTargets(selected, running, debug);+ const target = selectedTarget(selectedId, running, debug);+ const debugging = !!target?.debug;+ const active = !!target || compoundRunning.length > 0;+ const count = running.length + debug.length;+ const stopName = compoundRunning.length+ ? selected?.name+ : (target?.name ?? running[0]?.config.name ?? debug[0]?.name);const moreRef = useRef<HTMLButtonElement>(null);const [moreOpen, setMoreOpen] = useState(false);const executors = useRunExecutors((s) => s.executors);@@ -80,43 +80,9 @@ export function RunWidget() {<Icon name="chevron-down" size={14} className={styles.widgetChevron} /></BarButton><span className={styles.widgetButtons}>- {target ? (+ {active ? (<>- <IconButton- icon="rerun-filled"- size="large"- iconSize={16}- className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledRun)}- title={tx`Rerun '${compoundRunning.length && selected ? selected.name : target.config.name}'`}- shortcut={shortcutLabel("run.run")}- onClick={() => (compoundRunning.length && selected ? void startRun(selected) : rerunSession(target.id))}- />- <IconButton- icon="stop-filled"- size="large"- iconSize={16}- className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledStop)}- title={- compoundRunning.length && selected- ? tx`Stop '${selected.name}'`- : running.length > 1- ? tx`Stop (${running.length} running)`- : tx`Stop '${target.config.name}'`- }- shortcut={shortcutLabel("run.stop")}- onClick={() =>- compoundRunning.length- ? compoundRunning.forEach((s) => void stopSession(s.id))- : running.length > 1- ? void executeAction("run.stop")- : void stopSession(target.id)- }- />- </>- ) : debugging ? (- // IDEA while debugging: Resume (when paused), Rerun Debug and Stop as filled buttons.- <>- {debugPaused && (+ {target?.paused && (<IconButtonicon="resume"size="large"@@ -124,27 +90,18 @@ export function RunWidget() {className={styles.widgetButton}title="Resume Program"shortcut={shortcutLabel("debug.resume")}- onClick={() => void executeAction("debug.resume")}+ onClick={() => target.resume()}/>)}<IconButton- icon="restart-debug-filled"+ icon={debugging ? "restart-debug-filled" : "rerun-filled"}size="large"iconSize={16}className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledRun)}- title="Rerun Debug Session"- shortcut={shortcutLabel("debug.rerun")}- disabled={!canRerunDebug}- onClick={() => void executeAction("debug.rerun")}- />- <IconButton- icon="stop-filled"- size="large"- iconSize={16}- className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledStop)}- title="Stop Debug Session"- shortcut={shortcutLabel("debug.stop")}- onClick={() => void executeAction("debug.stop")}+ title={tx`Rerun '${selected?.name ?? target?.name ?? ""}'`}+ shortcut={shortcutLabel("run.run")}+ disabled={!!target && !target.rerun}+ onClick={() => void executeAction("run.run")}/></>) : (@@ -179,6 +136,17 @@ export function RunWidget() {/></>)}+ {count > 0 && (+ <IconButton+ icon="stop-filled"+ size="large"+ iconSize={16}+ className={clsx(styles.widgetButton, styles.widgetFilled, styles.widgetFilledStop)}+ title={active || count === 1 ? tx`Stop '${stopName ?? ""}'` : tx`Stop (${count} running)`}+ shortcut={shortcutLabel("run.stop")}+ onClick={() => void executeAction("run.stop")}+ />+ )}<IconButtonref={moreRef}icon="more"diff --git a/src/features/run/contextRun.ts b/src/features/run/contextRun.tsindex 11b04b3ce..742e6a7c0 100644--- a/src/features/run/contextRun.ts+++ b/src/features/run/contextRun.ts@@ -126,7 +126,7 @@ export async function launchProduced(p: Produced, debug: boolean): Promise<void>return;}if (!(await buildFirst(p.debug.build))) return;- await executeAction("debug.startConfig", p.debug.config);+ await executeAction("debug.startConfig", { config: p.debug.config, origin: config });return;}await executeAction("run.debugConfig", config);diff --git a/src/features/run/index.ts b/src/features/run/index.tsindex 699455018..b0b1a2e19 100644--- a/src/features/run/index.ts+++ b/src/features/run/index.ts@@ -11,6 +11,7 @@ import { onWorkflowSettingsChange } from "@/platform/workflowSettings";import { showContextMenu, lazyComponent, type MenuItem } from "@/ui";import {menuGroupItems,+ useDebugRunSessions,notifications,registerMenuGroup,registerOverlay,@@ -50,7 +51,6 @@ import {CURRENT_FILE,currentFileSelected,prepareLaunch,- sessionsOf,setBeforeLaunchRunner,loadConfigs,failedTests,@@ -66,6 +66,7 @@ import {stopSession,useRun,} from "./store";+import { compoundTargets, selectedTarget } from "./sessionTargets";import { tx } from "@/platform/i18n";function hasProject() {@@ -84,6 +85,11 @@ async function runSelected() {useRun.setState({ chooserOpen: true, chooserMode: "run" });return;}+ const target = selectedTarget(config.id, useRun.getState().sessions, useDebugRunSessions.getState().sessions);+ if (target) {+ target.rerun?.();+ return;+ }await startRun(config);}@@ -172,9 +178,8 @@ function configFromArg(arg: unknown): RunConfig | undefined {}/**- * IDEA's Stop: in the Run or Debug tool window, the selected tab's process; otherwise the- * only running process, or a chooser of every running one (run sessions and the- * `stopProcess` items other features contribute, e.g. debug sessions).+ * Stop: in the Run or Debug tool window, the selected tab's process; otherwise the selected+ * configuration's session, or a chooser of every running process.*/function stopAction() {const ctx = getContext();@@ -183,22 +188,24 @@ function stopAction() {return;}const running = runningSessions();- const { activeSession } = useRun.getState();if (ctx.toolWindowFocus && ctx.activeToolWindow === "run") {- const active = running.find((s) => s.id === activeSession);+ const active = running.find((s) => s.id === useRun.getState().activeSession);if (active) {void stopSession(active.id);return;}}- // A selected compound stops all of its configurations.+ const debug = useDebugRunSessions.getState().sessions;const selected = selectedConfig();- if (selected?.kind === "compound") {- const own = sessionsOf(selected, running);- if (own.length) {- own.forEach((s) => void stopSession(s.id));- return;- }+ const compound = compoundTargets(selected, running, debug);+ if (compound.length) {+ compound.forEach((s) => s.stop());+ return;+ }+ const target = selectedTarget(useRun.getState().selectedId, running, debug);+ if (target) {+ target.stop();+ return;}const items = [...running.map((s): MenuItem => ({diff --git a/src/features/run/javaDebug.ts b/src/features/run/javaDebug.tsindex 0fbed5b2f..d06f77cb9 100644--- a/src/features/run/javaDebug.ts+++ b/src/features/run/javaDebug.ts@@ -77,6 +77,7 @@ export async function debugWithAgent(config: RunConfig): Promise<boolean> {hostName: "127.0.0.1",port,process: runId,+ runConfig: config,});};const session = await startRun(config, undefined, undefined, {diff --git a/src/features/run/session.test.tsx b/src/features/run/session.test.tsxindex f278da6d0..cc8f1d5de 100644--- a/src/features/run/session.test.tsx+++ b/src/features/run/session.test.tsx@@ -4,6 +4,7 @@ import { executeAction } from "@/platform/actions";import { setContext } from "@/platform/context";import type { RunConfig } from "@/platform/ipc";import {+ useDebugRunSessions,provideNotificationService,provideToolWindowService,registerMenuGroup,@@ -51,6 +52,7 @@ const running = (id: string, c: RunConfig, runId: number | null = null): RunSessbeforeEach(() => {resetRuns();+ useDebugRunSessions.setState({ sessions: [] });confirm.mockClear();confirm.mockResolvedValue(true);provideToolWindowService({ show: vi.fn(), isVisible: () => true } as unknown as ToolWindowService);@@ -153,6 +155,8 @@ describe("Stop", () => {setContext("projectOpen", true);useRun.setState({sessions: [running("run1", config("a"), 1), running("run2", config("b"), 2)],+ configs: [config("a"), config("b")],+ selectedId: "a",activeSession: "run2",});setContext("toolWindowFocus", true);diff --git a/src/features/run/sessionTargets.ts b/src/features/run/sessionTargets.tsnew file mode 100644index 000000000..367a9e37f--- /dev/null+++ b/src/features/run/sessionTargets.ts@@ -0,0 +1,32 @@+import { compoundChildren } from "./configs";+import type { RunConfig } from "@/platform/ipc";+import type { DebugRunSession } from "@/workbench/contributions";+import { rerunSession, sessionsOf, stopSession, useRun, type RunSession } from "./store";++/** Selection, never tool-window focus or an unrelated process, determines the primary target. */+export function selectedTarget(selectedId: string | null, runs: RunSession[], debug: DebugRunSession[]) {+ const candidates = [+ ...runs+ .filter((s) => (s.status === "running" || s.status === "starting") && s.config.id === selectedId)+ .map((s) => ({+ name: s.config.name,+ startedAt: s.startedAt,+ debug: false,+ paused: false,+ rerun: () => rerunSession(s.id),+ stop: () => void stopSession(s.id),+ resume: () => {},+ })),+ ...debug.filter((s) => s.configId != null && s.configId === selectedId).map((s) => ({ ...s, debug: true })),+ ];+ return candidates.sort((a, b) => b.startedAt - a.startedAt)[0] ?? null;+}++export function compoundTargets(config: RunConfig | undefined, runs: RunSession[], debug: DebugRunSession[]) {+ if (config?.kind !== "compound") return [];+ const ids = new Set(compoundChildren(config, useRun.getState().configs).map((c) => c.id));+ return [+ ...sessionsOf(config, runs).map((s) => ({ stop: () => void stopSession(s.id) })),+ ...debug.filter((s) => s.configId != null && ids.has(s.configId)),+ ];+}diff --git a/src/features/run/store.ts b/src/features/run/store.tsindex 21dff33dc..8e3cd8091 100644--- a/src/features/run/store.ts+++ b/src/features/run/store.ts@@ -19,7 +19,7 @@ import { downloadJdkActions } from "@/platform/jdk";import { useProject } from "@/platform/project";import { executeAction } from "@/platform/actions";import { workflowSettings } from "@/platform/workflowSettings";-import { maybeEditorService, notifications, toolWindowService } from "@/workbench/contributions";+import { maybeEditorService, notifications, toolWindowService, useDebugRunSessions } from "@/workbench/contributions";import { ConsoleModel } from "./console";import { jvmFrameTarget } from "./links";import { confirmRerun, confirmTerminate } from "./dialogs";@@ -261,6 +261,7 @@ export function adoptTemporary(config: RunConfig): RunConfig {const busy = new Set(state.sessions.filter((x) => x.status === "running" || x.status === "starting").map((x) => x.config.id),);+ for (const session of useDebugRunSessions.getState().sessions) if (session.configId) busy.add(session.configId);while (temporary.length > MAX_TEMPORARY) {const evict = temporary.find((id) => id !== config.id && !busy.has(id)) ?? temporary[0]!;temporary = temporary.filter((id) => id !== evict);diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.tsindex b3fa65d61..78bf02f24 100644--- a/src/workbench/contributions.ts+++ b/src/workbench/contributions.ts@@ -1256,3 +1256,17 @@ export function showStatusInfo(text: string, ms = 8000) {if (useStatusInfo.getState().seq === seq) useStatusInfo.setState({ text: null });}, ms);}++/** Live debugger roots exposed to the run toolbar without coupling feature stores. */+export interface DebugRunSession {+ id: number;+ configId: string | null;+ name: string;+ startedAt: number;+ paused: boolean;+ rerun: (() => void) | null;+ stop: () => void;+ resume: () => void;+}++export const useDebugRunSessions = create<{ sessions: DebugRunSession[] }>(() => ({ sessions: [] }));