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.

fix(services): show debug session output and state (#540)

wangxga1e9cf1c447ac
diff --git a/src/features/debugger/__tests__/runOrigin.test.ts b/src/features/debugger/__tests__/runOrigin.test.ts
index 1f108bf1a..0472f27cb 100644
--- a/src/features/debugger/__tests__/runOrigin.test.ts
+++ b/src/features/debugger/__tests__/runOrigin.test.ts
@@ -9,17 +9,89 @@ import {
} from "@/workbench/contributions";
import type { RunConfig } from "@/platform/ipc";
import { registerDebugActions } from "../actions";
-import { adoptSession, publishContext, rerunSession, useDebug } from "../state";
+import {
+ adoptSession,
+ appendConsole,
+ handleDebugEvent,
+ publishContext,
+ rerunSession,
+ resetSessions,
+ startSession,
+ stopSession,
+ 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 })),
+ runStop: 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 } };
});
+
+it("retains only configured debug roots for Services without changing live toolbar sessions", () => {
+ adoptSession(1, { runConfig: config, process: 7, startedAt: 10 });
+ adoptSession(2, { parent: 1, status: "paused" });
+ adoptSession(3);
+ publishContext();
+ expect(useDebugRunSessions.getState().serviceSessions).toMatchObject([
+ { id: 1, config, processId: 7, startedAt: 10, status: "paused" },
+ ]);
+ handleDebugEvent(1, { kind: "terminated" });
+ expect(useDebugRunSessions.getState().sessions.map((s) => s.id)).toEqual([3]);
+ expect(useDebugRunSessions.getState().serviceSessions).toMatchObject([{ id: 1, status: "terminated" }]);
+});
+
+it("does not republish service metadata when console output changes", () => {
+ adoptSession(1, { runConfig: config });
+ const summaries = useDebugRunSessions.getState().serviceSessions;
+ expect(summaries).toHaveLength(1);
+ appendConsole(1, "stdout", "application output\n");
+ expect(useDebugRunSessions.getState().serviceSessions).toBe(summaries);
+});
+
+it("stops shared-process debugger roots without stopping their process until requested", async () => {
+ adoptSession(1, { runConfig: config, process: 7 });
+ await stopSession(1, { stopProcess: false });
+ expect(ipc.debugStop).toHaveBeenCalledWith(1);
+ expect(ipc.runStop).not.toHaveBeenCalled();
+ await stopSession(1);
+ expect(ipc.runStop).toHaveBeenCalledWith(7);
+});
+
+it("pins Show in Debug to the configured session and clears summaries with the project", () => {
+ adoptSession(1, { runConfig: config });
+ adoptSession(2, { runConfig: { ...config, id: "other" } });
+ const summary = useDebugRunSessions.getState().serviceSessions[0]!;
+ summary.show();
+ expect(useDebug.getState().active).toBe(1);
+ resetSessions();
+ expect(useDebugRunSessions.getState().serviceSessions).toEqual([]);
+ summary.show();
+ expect(useDebug.getState().active).toBeNull();
+});
+
+it("removes terminated summaries when a subsequent debug start prunes their source", async () => {
+ adoptSession(1, { runConfig: config });
+ handleDebugEvent(1, { kind: "terminated" });
+ await startSession(
+ {
+ name: "next",
+ adapter: "js-debug",
+ request: "launch",
+ program: null,
+ args: [],
+ cwd: "/p",
+ env: {},
+ extraJson: null,
+ },
+ { runConfig: { ...config, id: "next" } },
+ );
+ expect(useDebugRunSessions.getState().serviceSessions.map((s) => s.id)).toEqual([42]);
+});
const config: RunConfig = {
id: "node:server",
name: "server",
diff --git a/src/features/debugger/__tests__/serviceConsole.test.tsx b/src/features/debugger/__tests__/serviceConsole.test.tsx
new file mode 100644
index 000000000..d897c7460
--- /dev/null
+++ b/src/features/debugger/__tests__/serviceConsole.test.tsx
@@ -0,0 +1,73 @@
+import { beforeEach, expect, it, vi } from "vitest";
+import { act, fireEvent, render, screen, within } from "@testing-library/react";
+import { adoptSession, appendConsole, useDebug } from "../state";
+import { DebugConsole, DebugServiceConsole } from "../ui/DebugConsole";
+
+vi.mock("@tanstack/react-virtual", () => ({
+ useVirtualizer: ({ count }: { count: number }) => ({
+ getTotalSize: () => count * 18,
+ getVirtualItems: () => Array.from({ length: count }, (_, index) => ({ index, key: index, start: index * 18 })),
+ measureElement: () => {},
+ scrollToIndex: () => {},
+ }),
+}));
+
+beforeEach(() => useDebug.setState({ sessions: {}, console: {}, active: null }));
+
+it("shows the requested session without changing or following the active debugger", () => {
+ adoptSession(1, { name: "one" });
+ adoptSession(2, { name: "two" });
+ appendConsole(1, "stdout", "service one\n");
+ appendConsole(2, "stdout", "service two\n");
+ useDebug.setState({ active: 2 });
+ const view = render(<DebugServiceConsole sessionId={1} />);
+ expect(screen.getByRole("log")).toHaveTextContent("service one");
+ expect(screen.getByRole("log")).not.toHaveTextContent("service two");
+ expect(screen.queryByRole("textbox")).toBeNull();
+ expect(useDebug.getState().active).toBe(2);
+ act(() => appendConsole(2, "stdout", "unrelated\n"));
+ expect(screen.getByRole("log")).not.toHaveTextContent("unrelated");
+ view.rerender(<DebugServiceConsole sessionId={2} />);
+ expect(screen.getByRole("log")).toHaveTextContent("service two");
+ expect(screen.getByRole("log")).not.toHaveTextContent("service one");
+});
+
+it("shares output and clearing with the interactive debugger console", () => {
+ const session = adoptSession(1);
+ appendConsole(1, "stdout", "shared log\n");
+ render(
+ <>
+ <DebugServiceConsole sessionId={1} />
+ <DebugConsole session={session} />
+ </>,
+ );
+ expect(screen.getAllByRole("log").every((log) => log.textContent?.includes("shared log"))).toBe(true);
+ expect(screen.getByRole("textbox", { name: "Debug console input" })).toBeEnabled();
+ const clear = screen.getAllByRole("button", { name: "Clear Console" })[0]!;
+ fireEvent.click(clear);
+ for (const log of screen.getAllByRole("log")) expect(within(log).queryByText("shared log")).toBeNull();
+ expect(useDebug.getState().console[1]).toEqual([]);
+});
+
+it("shows an empty state when its source has been cleared", () => {
+ render(<DebugServiceConsole sessionId={99} />);
+ expect(screen.getByText("No debug output available")).toBeTruthy();
+ expect(screen.queryByRole("log")).toBeNull();
+});
+
+it("explains why a remote attached process may have no application logs", () => {
+ adoptSession(1, {
+ launch: {
+ name: "remote",
+ adapter: "java-debug",
+ request: "attach",
+ program: null,
+ args: [],
+ cwd: "/p",
+ env: {},
+ extraJson: null,
+ },
+ });
+ render(<DebugServiceConsole sessionId={1} />);
+ expect(screen.getByText("The attached process may not provide standard output to the debugger.")).toBeTruthy();
+});
diff --git a/src/features/debugger/index.ts b/src/features/debugger/index.ts
index 18ade51d0..ed0bb12cc 100644
--- a/src/features/debugger/index.ts
+++ b/src/features/debugger/index.ts
@@ -13,6 +13,7 @@ import {
registerOverlay,
registerRunConfigType,
registerToolWindow,
+ useDebugRunSessions,
} from "@/workbench/contributions";
import { registerDebugActions } from "./actions";
import { loadBreakpoints } from "./breakpoints/store";
@@ -28,12 +29,16 @@ import { DebuggerOverlays } from "./ui/Overlays";
import { REMOTE_TYPES } from "./remote";
export function activate(): () => void {
+ useDebugRunSessions.setState({
+ Console: lazyComponent(() => import("./ui/DebugConsole").then((m) => m.DebugServiceConsole)),
+ });
loadWatches();
publishContext();
loadBreakpoints(useProject.getState().project?.root ?? null);
loadExceptionBreakpoints(useProject.getState().project?.root ?? null);
loadSpecialBreakpoints(useProject.getState().project?.root ?? null);
const disposers = [
+ () => useDebugRunSessions.setState({ sessions: [], serviceSessions: [], Console: null }),
registerDebugActions(),
// Remote JVM Debug, Go Remote, …: Run/Debug Configurations › Add New Configuration.
...REMOTE_TYPES.map(registerRunConfigType),
diff --git a/src/features/debugger/state.ts b/src/features/debugger/state.ts
index 18d3f5202..d983c6289 100644
--- a/src/features/debugger/state.ts
+++ b/src/features/debugger/state.ts
@@ -235,7 +235,29 @@ function settleStart(id: DebugSessionId | null) {
export function publishContext() {
const s = activeSession();
+ const retained = Object.values(useDebug.getState().sessions);
useDebugRunSessions.setState({
+ serviceSessions: retained.flatMap((session) => {
+ if (session.parent != null || !session.runConfig) return [];
+ const paused =
+ isLive(session) && retained.some((child) => child.status === "paused" && rootOf(child).id === session.id);
+ return [
+ {
+ id: session.id,
+ config: session.runConfig,
+ startedAt: session.startedAt ?? 0,
+ status: paused ? ("paused" as const) : session.status,
+ processId: session.process,
+ rerun: session.runConfig || session.launch ? () => void rerunSession(session.id) : null,
+ stop: (options?: { stopProcess?: boolean }) => stopSession(session.id, options),
+ show: () => {
+ if (!useDebug.getState().sessions[session.id]) return;
+ selectSession(session.id);
+ toolWindowService().show("debug", true);
+ },
+ },
+ ];
+ }),
sessions: Object.values(useDebug.getState().sessions)
.filter((session) => session.parent == null && isLive(session))
.map((session) => {
@@ -445,6 +467,7 @@ export async function startSession(
for (const id of ansiStreams.keys()) if (!sessions[id]) ansiStreams.delete(id);
return { sessions, console: consoleLines, active: s.active != null && sessions[s.active] ? s.active : null };
});
+ publishContext();
try {
if (workflowSettings().run.showOnStart) toolWindowService().show("debug");
} catch {
@@ -536,7 +559,7 @@ export async function startSession(
}
}
-export async function stopSession(id: DebugSessionId) {
+export async function stopSession(id: DebugSessionId, options: { stopProcess?: boolean } = {}) {
const s = useDebug.getState().sessions[id];
if (!s) return;
const root = rootOf(s);
@@ -555,7 +578,8 @@ export async function stopSession(id: DebugSessionId) {
markTerminated(root.id);
}
// Detaching leaves an attached JVM running: stop the process it belongs to, like IDEA.
- if (root.process != null) await call(commands.runStop(root.process)).catch(() => undefined);
+ if (options.stopProcess !== false && root.process != null)
+ await call(commands.runStop(root.process)).catch(() => undefined);
}
export async function rerunSession(id: DebugSessionId) {
diff --git a/src/features/debugger/ui/DebugConsole.tsx b/src/features/debugger/ui/DebugConsole.tsx
new file mode 100644
index 000000000..18a32b9ff
--- /dev/null
+++ b/src/features/debugger/ui/DebugConsole.tsx
@@ -0,0 +1,173 @@
+import { useLayoutEffect, useRef, useState, type KeyboardEvent } from "react";
+import clsx from "clsx";
+import { useVirtualizer } from "@tanstack/react-virtual";
+import { copySelectionOnKeyDown } from "@/ui/selectableText";
+import { EmptyState, IconButton, showContextMenu, T, type MenuItem } from "@/ui";
+import { tx } from "@/platform/i18n";
+import { spanStyle } from "@/ui/ansi";
+import ansi from "@/ui/ansi.module.css";
+import { appendConsole, clearConsole, evaluate, isLive, useDebug, type DebugSession } from "../state";
+import { pushHistory, readHistory, setConsoleHistoryBrowser } from "./expressionHistory";
+import styles from "./DebugToolWindow.module.css";
+
+export function DebugServiceConsole({ sessionId }: { sessionId: number }) {
+ const session = useDebug((s) => s.sessions[sessionId]);
+ return session ? (
+ <DebugConsole key={sessionId} session={session} interactive={false} />
+ ) : (
+ <EmptyState title="No debug output available" />
+ );
+}
+
+export function DebugConsole({ session, interactive = true }: { session: DebugSession; interactive?: boolean }) {
+ const lines = useDebug((s) => s.console[session.id]);
+ const scroller = useRef<HTMLDivElement>(null);
+ const stick = useRef(true);
+ const programmatic = useRef(false);
+ const [input, setInput] = useState("");
+ const history = useRef<string[]>(readHistory("console"));
+ const historyPos = useRef(-1);
+ const inputRef = useRef<HTMLInputElement>(null);
+
+ const virtualizer = useVirtualizer({
+ count: lines?.length ?? 0,
+ getScrollElement: () => scroller.current,
+ estimateSize: () => 18,
+ overscan: 30,
+ getItemKey: (i) => lines?.[i]?.id ?? i,
+ });
+
+ useLayoutEffect(() => {
+ const el = scroller.current;
+ if (!el || !stick.current || !lines?.length) return;
+ programmatic.current = true;
+ virtualizer.scrollToIndex(lines.length - 1, { align: "end" });
+ el.scrollTop = el.scrollHeight;
+ requestAnimationFrame(() => (programmatic.current = false));
+ }, [lines, virtualizer]);
+
+ const submit = async () => {
+ const e = input.trim();
+ if (!e) return;
+ pushHistory("console", e);
+ history.current = readHistory("console");
+ historyPos.current = -1;
+ setInput("");
+ appendConsole(session.id, "input", `> ${e}\n`);
+ try {
+ const v = await evaluate(e, "repl", session);
+ appendConsole(session.id, "result", `${v.value}\n`);
+ } catch (err) {
+ appendConsole(session.id, "stderr", `${err instanceof Error ? err.message : String(err)}\n`);
+ }
+ };
+
+ /** IDEA's Browse History popup: the expressions typed before, most recent first. */
+ const browseHistory = () => {
+ const el = inputRef.current;
+ const r = el?.getBoundingClientRect();
+ const items: MenuItem[] = history.current.length
+ ? history.current.slice(0, 30).map((h, i) => ({
+ id: String(i),
+ label: h.length > 120 ? `${h.slice(0, 120)}…` : h,
+ run: () => {
+ setInput(h);
+ historyPos.current = i;
+ el?.focus();
+ },
+ }))
+ : [{ id: "none", label: "No history", disabled: true }];
+ showContextMenu({ x: r?.left ?? 120, y: (r?.top ?? 200) - 4 }, items);
+ };
+
+ const onKeyDown = (e: KeyboardEvent<HTMLInputElement>) => {
+ if (e.key === "Enter") {
+ e.preventDefault();
+ void submit();
+ } else if (e.key === "ArrowUp" || e.key === "ArrowDown") {
+ const h = history.current;
+ if (!h.length) return;
+ e.preventDefault();
+ const pos = Math.max(-1, Math.min(h.length - 1, historyPos.current + (e.key === "ArrowUp" ? 1 : -1)));
+ historyPos.current = pos;
+ setInput(pos < 0 ? "" : h[pos]!);
+ }
+ };
+
+ return (
+ <div className={styles.console}>
+ <div
+ ref={scroller}
+ className={clsx(styles.consoleOutput, ansi.palette)}
+ onScroll={(e) => {
+ if (programmatic.current) return;
+ const el = e.currentTarget;
+ stick.current = el.scrollHeight - el.scrollTop - el.clientHeight < 24;
+ }}
+ onContextMenu={(e) => {
+ e.preventDefault();
+ showContextMenu(e, [{ label: "Clear All", icon: "trash", run: () => clearConsole(session.id) }]);
+ }}
+ role="log"
+ onKeyDown={copySelectionOnKeyDown}
+ aria-label={tx("Debug console")}
+ tabIndex={0}
+ >
+ {!lines?.length && session.launch?.request === "attach" && (
+ <T>The attached process may not provide standard output to the debugger.</T>
+ )}
+ <div className={styles.consoleInner} style={{ height: virtualizer.getTotalSize() }}>
+ {virtualizer.getVirtualItems().map((item) => {
+ const l = lines?.[item.index];
+ if (!l) return null;
+ return (
+ <span
+ key={item.key}
+ data-index={item.index}
+ ref={virtualizer.measureElement}
+ className={clsx(styles.out, styles[`cat-${l.category}`])}
+ style={{ transform: `translateY(${item.start}px)` }}
+ >
+ {l.spans.map((sp, i) => (
+ <span key={i} style={spanStyle(sp)}>
+ {sp.text}
+ </span>
+ ))}
+ </span>
+ );
+ })}
+ </div>
+ </div>
+ <div className={styles.repl}>
+ {interactive && (
+ <>
+ <span className={styles.prompt} aria-hidden>
+ ›
+ </span>
+ <input
+ ref={inputRef}
+ className={styles.evalInput}
+ onFocus={() => setConsoleHistoryBrowser(browseHistory)}
+ onBlur={() => setConsoleHistoryBrowser(null)}
+ value={input}
+ onChange={(e) => setInput(e.target.value)}
+ onKeyDown={onKeyDown}
+ placeholder={isLive(session) ? "Evaluate in the debug console" : "Session finished"}
+ disabled={!isLive(session)}
+ aria-label={tx("Debug console input")}
+ spellCheck={false}
+ autoComplete="off"
+ />
+ </>
+ )}
+ <IconButton
+ icon="trash"
+ title="Clear Console"
+ size="small"
+ iconSize={12}
+ onClick={() => clearConsole(session.id)}
+ />
+ </div>
+ </div>
+ );
+}
diff --git a/src/features/debugger/ui/DebugToolWindow.tsx b/src/features/debugger/ui/DebugToolWindow.tsx
index d8bf9ea82..7a9af34ed 100644
--- a/src/features/debugger/ui/DebugToolWindow.tsx
+++ b/src/features/debugger/ui/DebugToolWindow.tsx
@@ -1,8 +1,6 @@
/** Debug tool window: toolbar, Threads & Variables (frames + variables), Console. */
-import { copySelectionOnKeyDown } from "@/ui/selectableText";
-import { useEffect, useLayoutEffect, useMemo, useRef, useState, type KeyboardEvent } from "react";
+import { useEffect, useMemo, useRef, useState, type KeyboardEvent } from "react";
import clsx from "clsx";
-import { useVirtualizer } from "@tanstack/react-virtual";
import { executeAction, getAction } from "@/platform/actions";
import { evaluateWhen, useContextKeys } from "@/platform/context";
import { basename, useProject } from "@/platform/project";
@@ -28,24 +26,19 @@ import { frameLabel, groupFrames } from "../frames";
import { blurDebugView, focusDebugView } from "./focusedView";
import {
addWatch,
- clearConsole,
evaluate,
- isLive,
selectFrame,
selectSession,
selectThread,
- appendConsole,
revealFrame,
sessionSupports,
useDebug,
type DebugSession,
} from "../state";
+import { DebugConsole } from "./DebugConsole";
import { VariablesView, type VarRoot } from "./VariablesView";
-import { pushHistory, readHistory, setConsoleHistoryBrowser } from "./expressionHistory";
import { sortVariables } from "../values";
import { workflowSettings } from "@/platform/workflowSettings";
-import { spanStyle } from "@/ui/ansi";
-import ansi from "@/ui/ansi.module.css";
import styles from "./DebugToolWindow.module.css";
import { tx } from "@/platform/i18n";
@@ -222,7 +215,11 @@ export function DebugToolWindow() {
<MoreActions />
</div>
<div role="tabpanel" id={`debug-panel-${tab}`} aria-labelledby={`debug-tab-${tab}`} className={styles.panel}>
- {tab === "variables" ? <ThreadsAndVariables session={active} /> : <ConsoleView session={active} />}
+ {tab === "variables" ? (
+ <ThreadsAndVariables session={active} />
+ ) : (
+ <DebugConsole key={active.id} session={active} />
+ )}
</div>
</div>
);
@@ -555,151 +552,3 @@ function VariablesPane({ session }: { session: DebugSession }) {
</div>
);
}
-
-// --- console -------------------------------------------------------------------
-
-function ConsoleView({ session }: { session: DebugSession }) {
- const lines = useDebug((s) => s.console[session.id]);
- const scroller = useRef<HTMLDivElement>(null);
- const stick = useRef(true);
- const programmatic = useRef(false);
- const [input, setInput] = useState("");
- const history = useRef<string[]>(readHistory("console"));
- const historyPos = useRef(-1);
- const inputRef = useRef<HTMLInputElement>(null);
-
- const virtualizer = useVirtualizer({
- count: lines?.length ?? 0,
- getScrollElement: () => scroller.current,
- estimateSize: () => 18,
- overscan: 30,
- getItemKey: (i) => lines?.[i]?.id ?? i,
- });
-
- useLayoutEffect(() => {
- const el = scroller.current;
- if (!el || !stick.current || !lines?.length) return;
- programmatic.current = true;
- virtualizer.scrollToIndex(lines.length - 1, { align: "end" });
- el.scrollTop = el.scrollHeight;
- requestAnimationFrame(() => (programmatic.current = false));
- }, [lines, virtualizer]);
-
- const submit = async () => {
- const e = input.trim();
- if (!e) return;
- pushHistory("console", e);
- history.current = readHistory("console");
- historyPos.current = -1;
- setInput("");
- appendConsole(session.id, "input", `> ${e}\n`);
- try {
- const v = await evaluate(e, "repl", session);
- appendConsole(session.id, "result", `${v.value}\n`);
- } catch (err) {
- appendConsole(session.id, "stderr", `${err instanceof Error ? err.message : String(err)}\n`);
- }
- };
-
- /** IDEA's Browse History popup: the expressions typed before, most recent first. */
- const browseHistory = () => {
- const el = inputRef.current;
- const r = el?.getBoundingClientRect();
- const items: MenuItem[] = history.current.length
- ? history.current.slice(0, 30).map((h, i) => ({
- id: String(i),
- label: h.length > 120 ? `${h.slice(0, 120)}…` : h,
- run: () => {
- setInput(h);
- historyPos.current = i;
- el?.focus();
- },
- }))
- : [{ id: "none", label: "No history", disabled: true }];
- showContextMenu({ x: r?.left ?? 120, y: (r?.top ?? 200) - 4 }, items);
- };
-
- const onKeyDown = (e: KeyboardEvent<HTMLInputElement>) => {
- if (e.key === "Enter") {
- e.preventDefault();
- void submit();
- } else if (e.key === "ArrowUp" || e.key === "ArrowDown") {
- const h = history.current;
- if (!h.length) return;
- e.preventDefault();
- const pos = Math.max(-1, Math.min(h.length - 1, historyPos.current + (e.key === "ArrowUp" ? 1 : -1)));
- historyPos.current = pos;
- setInput(pos < 0 ? "" : h[pos]!);
- }
- };
-
- return (
- <div className={styles.console}>
- <div
- ref={scroller}
- className={clsx(styles.consoleOutput, ansi.palette)}
- onScroll={(e) => {
- if (programmatic.current) return;
- const el = e.currentTarget;
- stick.current = el.scrollHeight - el.scrollTop - el.clientHeight < 24;
- }}
- onContextMenu={(e) => {
- e.preventDefault();
- showContextMenu(e, [{ label: "Clear All", icon: "trash", run: () => clearConsole(session.id) }]);
- }}
- role="log"
- onKeyDown={copySelectionOnKeyDown}
- aria-label={tx("Debug console")}
- tabIndex={0}
- >
- <div className={styles.consoleInner} style={{ height: virtualizer.getTotalSize() }}>
- {virtualizer.getVirtualItems().map((item) => {
- const l = lines?.[item.index];
- if (!l) return null;
- return (
- <span
- key={item.key}
- data-index={item.index}
- ref={virtualizer.measureElement}
- className={clsx(styles.out, styles[`cat-${l.category}`])}
- style={{ transform: `translateY(${item.start}px)` }}
- >
- {l.spans.map((sp, i) => (
- <span key={i} style={spanStyle(sp)}>
- {sp.text}
- </span>
- ))}
- </span>
- );
- })}
- </div>
- </div>
- <label className={styles.repl}>
- <span className={styles.prompt} aria-hidden>
- ›
- </span>
- <input
- ref={inputRef}
- className={styles.evalInput}
- onFocus={() => setConsoleHistoryBrowser(browseHistory)}
- onBlur={() => setConsoleHistoryBrowser(null)}
- value={input}
- onChange={(e) => setInput(e.target.value)}
- onKeyDown={onKeyDown}
- placeholder={isLive(session) ? "Evaluate in the debug console" : "Session finished"}
- disabled={!isLive(session)}
- aria-label={tx("Debug console input")}
- spellCheck={false}
- autoComplete="off"
- />
- <IconButton
- icon="trash"
- title="Clear Console"
- size="small"
- iconSize={12}
- onClick={() => clearConsole(session.id)}
- />
- </label>
- </div>
- );
-}
diff --git a/src/features/run/RunServices.module.css b/src/features/run/RunServices.module.css
index b75407269..288bb3362 100644
--- a/src/features/run/RunServices.module.css
+++ b/src/features/run/RunServices.module.css
@@ -29,3 +29,9 @@
gap: 6px;
padding: 0 12px 12px;
}
+
+.debugConsole {
+ display: flex;
+ height: 100%;
+ min-height: 0;
+}
diff --git a/src/features/run/RunView.tsx b/src/features/run/RunView.tsx
index ca43eb621..7c9b5a38f 100644
--- a/src/features/run/RunView.tsx
+++ b/src/features/run/RunView.tsx
@@ -43,7 +43,15 @@ function sessionIcon(s: RunSession): string {
return s.config.isTest ? "check" : "run";
}
-export function SessionPanel({ session }: { session: RunSession }) {
+export function SessionPanel({
+ session,
+ onRerun,
+ onStop,
+}: {
+ session: RunSession;
+ onRerun?: (() => void) | null;
+ onStop?: () => void;
+}) {
const version = useRun((s) => s.versions[session.id] ?? 0);
const rt = runtime(session.id);
const [follow, setFollow] = useState(true);
@@ -123,7 +131,8 @@ export function SessionPanel({ session }: { session: RunSession }) {
iconSize={14}
title="Rerun"
shortcut={shortcutLabel("run.rerun")}
- onClick={() => rerunSession(session.id)}
+ disabled={onRerun === null}
+ onClick={onRerun ?? (() => rerunSession(session.id))}
/>
{rt.tests && (
<IconButton
@@ -140,9 +149,9 @@ export function SessionPanel({ session }: { session: RunSession }) {
icon="stop"
iconSize={13}
title="Stop"
- tone={running ? "danger" : "default"}
- disabled={!running}
- onClick={() => void stopSession(session.id)}
+ tone={running || onStop ? "danger" : "default"}
+ disabled={!running && !onStop}
+ onClick={onStop ?? (() => void stopSession(session.id))}
/>
{session.config.kind === "tomcat" && (
<IconButton
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index 9687af4d6..90b0249e4 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -39,7 +39,7 @@ import { registerGoActions } from "./goActions";
import { invalidateGoModules } from "./goModules";
import { RunWidget } from "./RunWidget";
import { runConfigsRunAnything } from "./runAnything";
-import { runServiceProvider } from "./services";
+import { recordRun, runServiceProvider } from "./services";
import { runBeforeLaunch } from "./beforeLaunch";
import { compoundChildren } from "./configs";
import { remoteDebugBlocked } from "./remote";
@@ -106,6 +106,7 @@ async function debugConfig(config: RunConfig, chain: readonly string[] = []) {
}
if (remoteDebugBlocked(config)) return;
if (!(await prepareLaunch(config, chain))) return;
+ recordRun(config.id);
// Remote JVM Debug, Go Remote…: the debugger attaches, nothing is launched here.
if (isDebugOnly(config) && getAction("debug.startConfig")) {
await executeAction("debug.startConfig", config);
diff --git a/src/features/run/remote.test.tsx b/src/features/run/remote.test.tsx
index 270841f6d..d18cd2b3f 100644
--- a/src/features/run/remote.test.tsx
+++ b/src/features/run/remote.test.tsx
@@ -50,6 +50,7 @@ import { activate } from "./index";
import { remoteDebugBlocked, remoteLabel, startRemedy, startWithRemedies, withTarget, type RemedyDeps } from "./remote";
import { resetRuns, saveUserConfigs, startRun, useRun } from "./store";
import { newConfigOfType } from "./types";
+import { readRan } from "./services";
const cfg = (id: string, extra: Partial<RunConfig> = {}): RunConfig => ({
id,
@@ -175,6 +176,14 @@ describe("remote debugging", () => {
await executeAction("run.debugConfig", local.id);
expect(startConfig).toHaveBeenCalledWith(local);
});
+
+ it("remembers a non-Spring-Boot configuration accepted for debugging", async () => {
+ useProject.setState({ project: { root: "/remember-debug" } as never });
+ const local = cfg("python:debug", { debugAdapter: "debugpy" });
+ useRun.setState({ configs: [local], loaded: true });
+ await executeAction("run.debugConfig", local.id);
+ expect(readRan("/remember-debug")).toContain(local.id);
+ });
});
describe("SSH remedies when starting", () => {
diff --git a/src/features/run/serviceSessions.test.ts b/src/features/run/serviceSessions.test.ts
new file mode 100644
index 000000000..4bac8b315
--- /dev/null
+++ b/src/features/run/serviceSessions.test.ts
@@ -0,0 +1,174 @@
+import { expect, it, vi } from "vitest";
+import type { RunConfig } from "@/platform/ipc";
+import type { DebugServiceSession } from "@/workbench/contributions";
+import type { RunSession } from "./store";
+import { currentServiceSession, serviceDebugger, serviceSessions, stopServiceSessions } from "./serviceSessions";
+
+const { stopRun, waitForExit, getSession } = vi.hoisted(() => ({
+ stopRun: vi.fn(),
+ waitForExit: vi.fn(),
+ getSession: vi.fn(),
+}));
+vi.mock("./store", () => ({
+ stopSession: stopRun,
+ waitForExit,
+ useRun: { getState: () => ({ sessions: [getSession()].filter(Boolean) }) },
+}));
+const config = (id = "app"): RunConfig => ({
+ id,
+ name: "same name",
+ kind: "spring-boot",
+ command: "java",
+ args: [],
+ cwd: null,
+ env: {},
+ detected: true,
+ isTest: false,
+ debugAdapter: "java-debug",
+});
+const run = (id: string, startedAt: number, extra: Partial<RunSession> = {}): RunSession => ({
+ id,
+ config: config(),
+ startedAt,
+ runId: 7,
+ status: "running",
+ endedAt: null,
+ exitCode: null,
+ stdinClosed: false,
+ ...extra,
+});
+const debug = (id: number, startedAt: number, extra: Partial<DebugServiceSession> = {}): DebugServiceSession => ({
+ id,
+ config: config(),
+ startedAt,
+ status: "running",
+ processId: null,
+ stop: vi.fn(async () => {}),
+ rerun: vi.fn(),
+ show: vi.fn(),
+ ...extra,
+});
+
+it("prefers a live debug launch to stale Run output and isolates equal names by config id", () => {
+ const d = debug(1, 2);
+ const sessions = serviceSessions(
+ [run("old", 1, { status: "finished" })],
+ [d, debug(2, 3, { config: config("other") })],
+ );
+ expect(currentServiceSession("app", sessions)?.debug).toEqual([d]);
+ expect(currentServiceSession("other", sessions)?.debug[0]?.id).toBe(2);
+});
+
+it("keeps an older live instance ahead of a newer finished one and uses stable tie breaking", () => {
+ const active = debug(1, 1);
+ const sessions = serviceSessions([run("done", 10, { status: "finished" })], [active]);
+ expect(currentServiceSession("app", sessions)?.debug).toEqual([active]);
+ const tied = serviceSessions([run("a", 1)], [active]);
+ expect(currentServiceSession("app", tied)?.debug).toEqual([active]);
+ expect(currentServiceSession("app", [...tied].reverse())?.debug).toEqual([active]);
+});
+
+it("pairs all debugger roots with the same Run process without guessing by config id alone", () => {
+ const r = run("maven", 1);
+ const d = [debug(1, 2, { processId: 7 }), debug(2, 3, { processId: 7 })];
+ const sessions = serviceSessions([r], [...d, debug(3, 4, { processId: 8 })]);
+ expect(sessions).toHaveLength(2);
+ expect(sessions[0]).toMatchObject({ run: r, debug: d, startedAt: 1 });
+ expect(serviceDebugger(sessions[0])).toBe(d[1]);
+ expect(serviceSessions([r], [debug(4, 5, { config: config("other"), processId: 7 })])).toHaveLength(2);
+});
+
+it("falls back to Run controls when its attached debugger has terminated", () => {
+ const sessions = serviceSessions([run("maven", 1)], [debug(1, 2, { processId: 7, status: "terminated" })]);
+ expect(serviceDebugger(sessions[0])).toBeUndefined();
+ expect(currentServiceSession("app", sessions)?.run?.id).toBe("maven");
+});
+
+it("stops the displayed execution without stopping another parallel instance", async () => {
+ const first = debug(1, 1);
+ const latest = debug(2, 2);
+ const selected = currentServiceSession("app", serviceSessions([], [first, latest]))!;
+ await stopServiceSessions([selected]);
+ expect(latest.stop).toHaveBeenCalledOnce();
+ expect(first.stop).not.toHaveBeenCalled();
+});
+
+it("awaits shared debugger stops without a retained Run and terminates their process only once", async () => {
+ stopRun.mockClear();
+ const calls: string[] = [];
+ const first = debug(1, 1, {
+ processId: 7,
+ stop: vi.fn(async (options) => {
+ await Promise.resolve();
+ calls.push(options?.stopProcess === false ? "detach first" : "stop process first");
+ }),
+ });
+ const last = debug(2, 2, {
+ processId: 7,
+ stop: vi.fn(async (options) => {
+ calls.push(options?.stopProcess === false ? "detach last" : "stop process last");
+ }),
+ });
+ const targets = serviceSessions([], [first, last]);
+ await stopServiceSessions([...targets, ...targets]);
+ expect(calls).toEqual(["detach first", "stop process last"]);
+ expect(stopRun).not.toHaveBeenCalled();
+});
+
+it("stops the owning Run before detaching shared roots so JDWP cannot trigger another attachment", async () => {
+ stopRun.mockClear();
+ let processAlive = true;
+ let reattachments = 0;
+ const calls: string[] = [];
+ stopRun.mockImplementationOnce(async () => {
+ calls.push("stop run");
+ });
+ let exit!: () => void;
+ waitForExit.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ exit = () => {
+ processAlive = false;
+ resolve();
+ };
+ }),
+ );
+ getSession.mockImplementationOnce(() => run("maven", 0, { status: "finished" }));
+ const roots = [1, 2].map((id) =>
+ debug(id, id, {
+ processId: 7,
+ stop: vi.fn(async () => {
+ await Promise.resolve();
+ if (processAlive) reattachments++;
+ calls.push(`detach ${id}`);
+ }),
+ }),
+ );
+ const targets = serviceSessions([run("maven", 0)], roots);
+ const stopping = stopServiceSessions([...targets, ...targets]);
+ await vi.waitFor(() => expect(stopRun).toHaveBeenCalledOnce());
+ for (const root of roots) expect(root.stop).not.toHaveBeenCalled();
+ exit();
+ await stopping;
+ expect(reattachments).toBe(0);
+ expect(calls).toEqual(["stop run", "detach 1", "detach 2"]);
+ expect(stopRun).toHaveBeenCalledExactlyOnceWith("maven");
+ for (const root of roots) expect(root.stop).toHaveBeenCalledExactlyOnceWith({ stopProcess: false });
+});
+
+it("stops all group executions including unpaired Run and ignores finished roots", async () => {
+ stopRun.mockClear();
+ const done = debug(3, 1, { status: "terminated" });
+ const running = debug(4, 2);
+ await stopServiceSessions(serviceSessions([run("plain", 1)], [done, running]));
+ expect(stopRun).toHaveBeenCalledWith("plain");
+ expect(running.stop).toHaveBeenCalledOnce();
+ expect(done.stop).not.toHaveBeenCalled();
+});
+
+it("does not detach a JVM still running after the exit wait expires", async () => {
+ getSession.mockReturnValueOnce(run("maven", 0));
+ const root = debug(1, 1, { processId: 7 });
+ await stopServiceSessions(serviceSessions([run("maven", 0)], [root]));
+ expect(root.stop).not.toHaveBeenCalled();
+});
diff --git a/src/features/run/serviceSessions.ts b/src/features/run/serviceSessions.ts
new file mode 100644
index 000000000..49f217b7c
--- /dev/null
+++ b/src/features/run/serviceSessions.ts
@@ -0,0 +1,97 @@
+import type { RunConfig } from "@/platform/ipc";
+import type { DebugServiceSession } from "@/workbench/contributions";
+import { stopSession, useRun, waitForExit, type RunSession } from "./store";
+
+/** One execution: a Run process and its attached debuggers, or a direct debug launch. */
+export interface ServiceSession {
+ config: RunConfig;
+ startedAt: number;
+ run?: RunSession;
+ debug: DebugServiceSession[];
+}
+
+const running = (s: RunSession) => s.status === "running" || s.status === "starting";
+const debugging = (s: DebugServiceSession) => s.status !== "terminated";
+
+export function serviceSessions(runs: readonly RunSession[], debug: readonly DebugServiceSession[]): ServiceSession[] {
+ const out = runs.map((run): ServiceSession => ({ config: run.config, startedAt: run.startedAt, run, debug: [] }));
+ const processes = new Map(out.filter((s) => s.run!.runId !== null).map((s) => [s.run!.runId, s]));
+ for (const session of debug) {
+ const owner = session.processId === null ? undefined : processes.get(session.processId);
+ if (owner && owner.config.id === session.config.id) owner.debug.push(session);
+ else out.push({ config: session.config, startedAt: session.startedAt, debug: [session] });
+ }
+ return out;
+}
+
+export function liveServiceSession(session: ServiceSession): boolean {
+ return !!(session.run && running(session.run)) || session.debug.some(debugging);
+}
+
+/** Only a live debugger owns controls; retained output alone cannot claim a live Run. */
+export function serviceDebugger(session: ServiceSession | undefined): DebugServiceSession | undefined {
+ return session?.debug.filter(debugging).sort((a, b) => b.startedAt - a.startedAt || b.id - a.id)[0];
+}
+
+function compareSessions(a: ServiceSession, b: ServiceSession): number {
+ const key = (s: ServiceSession) => s.run?.id ?? `debug:${s.debug[0]!.id}`;
+ return (
+ Number(liveServiceSession(b)) - Number(liveServiceSession(a)) ||
+ b.startedAt - a.startedAt ||
+ Number(b.debug.length > 0) - Number(a.debug.length > 0) ||
+ key(a).localeCompare(key(b))
+ );
+}
+
+export function currentServiceSessions(sessions: readonly ServiceSession[]): Map<string, ServiceSession> {
+ const out = new Map<string, ServiceSession>();
+ for (const session of sessions) {
+ const previous = out.get(session.config.id);
+ if (!previous || compareSessions(session, previous) < 0) out.set(session.config.id, session);
+ }
+ return out;
+}
+
+export function currentServiceSession(
+ configId: string,
+ sessions: readonly ServiceSession[],
+): ServiceSession | undefined {
+ return currentServiceSessions(sessions).get(configId);
+}
+
+/** A build process may expose several JDWP ports, each with its own debugger root. */
+export async function stopServiceSessions(sessions: readonly ServiceSession[]): Promise<void> {
+ const roots = new Map<number, DebugServiceSession>();
+ const runs = new Map<string, RunSession>();
+ for (const s of sessions) {
+ for (const d of s.debug) if (debugging(d)) roots.set(d.id, d);
+ if (s.run && running(s.run)) runs.set(s.run.id, s.run);
+ }
+ const groups = new Map<number, DebugServiceSession[]>();
+ for (const d of roots.values()) {
+ if (d.processId === null) await d.stop();
+ else {
+ const group = groups.get(d.processId) ?? [];
+ group.push(d);
+ groups.set(d.processId, group);
+ }
+ }
+ for (const [processId, group] of groups) {
+ const run = [...runs.values()].find((s) => s.runId === processId);
+ if (run) {
+ // Detaching a live JVM republishes its JDWP port and can trigger another attachment.
+ await stopSession(run.id);
+ await waitForExit([run.id]);
+ if (useRun.getState().sessions.some((s) => s.id === run.id && running(s))) {
+ runs.delete(run.id);
+ continue;
+ }
+ for (const d of group) await d.stop({ stopProcess: false });
+ } else {
+ for (const d of group.slice(0, -1)) await d.stop({ stopProcess: false });
+ await group.at(-1)!.stop();
+ }
+ for (const [id, run] of runs) if (run.runId === processId) runs.delete(id);
+ }
+ for (const run of runs.values()) await stopSession(run.id);
+}
diff --git a/src/features/run/services.test.ts b/src/features/run/services.test.ts
index ae2106045..8a5ceb93e 100644
--- a/src/features/run/services.test.ts
+++ b/src/features/run/services.test.ts
@@ -3,6 +3,7 @@ import type { RunConfig } from "@/platform/ipc";
import { DEFAULT_TYPES, readRan, readTypes, runServiceItems, sessionDetail, sessionStatus } from "./services";
import { startedPort } from "./serverPort";
import type { RunSession } from "./store";
+import type { DebugServiceSession } from "@/workbench/contributions";
const config = (id: string, kind: string): RunConfig => ({
id,
@@ -41,6 +42,56 @@ describe("run configurations in Services", () => {
const dev = config("dev", "npm");
const scratch = config("context:file", "python");
+ it.each(["spring-boot", "node", "python", "go", "cargo"])(
+ "shows configured %s debug roots without a Run session",
+ (kind) => {
+ const c = config("debug-app", kind);
+ const d: DebugServiceSession = {
+ id: 1,
+ config: c,
+ status: "running",
+ processId: null,
+ startedAt: 2,
+ stop: async () => {},
+ rerun: null,
+ show: () => {},
+ };
+ const build = (status: DebugServiceSession["status"]) => runServiceItems([c], [], [], [], {}, [{ ...d, status }]);
+ expect(build("running")[0]?.children?.[0]).toMatchObject({
+ key: "run:config:debug-app",
+ detail: "Debugging",
+ icon: "debug",
+ dim: false,
+ });
+ expect(build("paused")[0]?.children?.[0]?.detail).toBe("Suspended");
+ expect(build("terminated")[0]?.children?.[0]).toMatchObject({ detail: "Finished", dim: true });
+ },
+ );
+
+ it("does not reuse an old Run port for a new direct debug launch or double-count an attachment", () => {
+ const c = config("app", "spring-boot");
+ const r = session("run", c, "finished", 1, { runId: 7, httpPort: 8080 });
+ const d: DebugServiceSession = {
+ id: 1,
+ config: c,
+ status: "running",
+ processId: null,
+ startedAt: 2,
+ stop: async () => {},
+ rerun: null,
+ show: () => {},
+ };
+ const direct = runServiceItems([c], [r], DEFAULT_TYPES, [], {}, [d]);
+ expect(direct[0]?.detail).toBe("1 running");
+ expect(direct[0]?.children?.[0]?.detail).toBe("Debugging");
+ const attached = runServiceItems([c], [{ ...r, status: "running" }], DEFAULT_TYPES, [], {}, [
+ { ...d, processId: 7 },
+ ]);
+ expect(attached[0]?.detail).toBe("1 running");
+ expect(attached[0]?.children).toHaveLength(1);
+ expect(attached[0]?.children?.[0]?.detail).toBe(":8080");
+ });
+
it("applies display order to detected and saved configurations of every language", () => {
const configs = [
config("java-a", "spring-boot"),
diff --git a/src/features/run/services.tsx b/src/features/run/services.tsx
index d11d69937..7f13a708f 100644
--- a/src/features/run/services.tsx
+++ b/src/features/run/services.tsx
@@ -19,13 +19,24 @@ import {
toolWindowService,
notifications,
useRunConfigTypes,
+ useDebugRunSessions,
+ type DebugServiceSession,
type ServiceItemAction,
type ServiceProviderContribution,
type ServiceTreeItem,
} from "@/workbench/contributions";
import { commandLine, configIcon, KIND_OPTIONS, kindLabel } from "./configs";
import { SessionPanel } from "./RunView";
-import { startRun, stopSession, useRun, type RunSession } from "./store";
+import { startRun, useRun, type RunSession } from "./store";
+import {
+ currentServiceSession,
+ currentServiceSessions,
+ liveServiceSession,
+ serviceDebugger,
+ serviceSessions,
+ stopServiceSessions,
+ type ServiceSession,
+} from "./serviceSessions";
import { isDebugOnly } from "./types";
import {
currentServiceOrder,
@@ -129,16 +140,6 @@ export function recordRun(configId: string) {
const busy = (s: RunSession) => s.status === "running" || s.status === "starting";
-/** The newest session of each configuration id. */
-function latestSessions(sessions: readonly RunSession[]): Map<string, RunSession> {
- const out = new Map<string, RunSession>();
- for (const s of sessions) {
- const prev = out.get(s.config.id);
- if (!prev || s.startedAt >= prev.startedAt) out.set(s.config.id, s);
- }
- return out;
-}
-
export function sessionStatus(s: RunSession | undefined): string | undefined {
if (!s) return undefined;
if (busy(s)) return s.status === "starting" ? "Starting" : "Running";
@@ -152,6 +153,19 @@ export function sessionDetail(s: RunSession | undefined): string | undefined {
return s && busy(s) && s.httpPort ? `:${s.httpPort}` : sessionStatus(s);
}
+function executionDetail(s: ServiceSession | undefined): string | undefined {
+ if (!s) return undefined;
+ const debug = serviceDebugger(s);
+ if (debug?.status === "paused") return "Suspended";
+ if (debug)
+ return s.run && busy(s.run) && s.run.httpPort
+ ? `:${s.run.httpPort}`
+ : debug.status === "starting"
+ ? "Starting"
+ : "Debugging";
+ return s.run ? sessionDetail(s.run) : "Finished";
+}
+
/**
* Groups by configuration type: added types list all their configurations, other
* types only those that ran. A default type (Spring Boot) without configurations is hidden.
@@ -162,10 +176,12 @@ export function runServiceItems(
added: readonly string[],
ran: readonly string[] = [],
order: ServiceOrder = {},
+ debug: readonly DebugServiceSession[] = [],
): ServiceTreeItem[] {
- const latest = latestSessions(sessions);
+ const executions = serviceSessions(sessions, debug);
+ const latest = currentServiceSessions(executions);
const kinds = [...added];
- for (const s of sessions) if (!kinds.includes(s.config.kind)) kinds.push(s.config.kind);
+ for (const s of executions) if (!kinds.includes(s.config.kind)) kinds.push(s.config.kind);
for (const id of ran) {
const kind = configs.find((c) => c.id === id)?.kind;
if (kind && !kinds.includes(kind)) kinds.push(kind);
@@ -182,14 +198,14 @@ export function runServiceItems(
return {
key: CONFIG_PREFIX + c.id,
label: c.name,
- icon: s && busy(s) ? "run" : configIcon(c),
- detail: sessionDetail(s),
- dim: !s || !busy(s),
+ icon: serviceDebugger(s) ? "debug" : s && liveServiceSession(s) ? "run" : configIcon(c),
+ detail: executionDetail(s),
+ dim: !s || !liveServiceSession(s),
};
});
const running = entries.filter((c) => {
const s = latest.get(c.id);
- return !!s && busy(s);
+ return !!s && liveServiceSession(s);
}).length;
return [
{
@@ -210,6 +226,7 @@ function useRoots(): ServiceTreeItem[] {
const order = useServiceOrder(projectLocation(root));
const configs = useRun((s) => s.configs);
const sessions = useRun((s) => s.sessions);
+ const debug = useDebugRunSessions((s) => s.serviceSessions);
const types = useAddedTypes((s) => s.types);
const typesRoot = useAddedTypes((s) => s.root);
const ran = useRanConfigs((s) => s.ids);
@@ -219,28 +236,29 @@ function useRoots(): ServiceTreeItem[] {
if (ranRoot !== root) useRanConfigs.setState({ root, ids: root ? readRan(root) : [] });
}, [root, typesRoot, ranRoot]);
return useMemo(
- () => runServiceItems(configs, sessions, typesRoot === root ? types : [], ranRoot === root ? ran : [], order),
- [configs, sessions, types, typesRoot, ran, ranRoot, root, order],
+ () =>
+ runServiceItems(configs, sessions, typesRoot === root ? types : [], ranRoot === root ? ran : [], order, debug),
+ [configs, sessions, types, typesRoot, ran, ranRoot, root, order, debug],
);
}
interface Resolved {
kind: string | null;
config: RunConfig | null;
- session: RunSession | undefined;
+ session: ServiceSession | undefined;
/** Sessions of a group's configurations. */
- sessions: RunSession[];
+ sessions: ServiceSession[];
}
function resolve(item: ServiceTreeItem): Resolved {
const { configs, sessions } = useRun.getState();
- const latest = latestSessions(sessions);
+ const executions = serviceSessions(sessions, useDebugRunSessions.getState().serviceSessions);
if (item.key.startsWith(TYPE_PREFIX)) {
const kind = item.key.slice(TYPE_PREFIX.length);
- return { kind, config: null, session: undefined, sessions: sessions.filter((s) => s.config.kind === kind) };
+ return { kind, config: null, session: undefined, sessions: executions.filter((s) => s.config.kind === kind) };
}
const id = item.key.slice(CONFIG_PREFIX.length);
- const session = latest.get(id);
+ const session = currentServiceSession(id, executions);
const config = configs.find((c) => c.id === id) ?? session?.config ?? null;
return { kind: config?.kind ?? null, config, session, sessions: session ? [session] : [] };
}
@@ -252,36 +270,42 @@ function showOutput(s: RunSession) {
/** Runs (or reruns, in its tab) a configuration; the output stays in Services instead of opening Run. */
function run(r: Resolved) {
- if (r.session && r.session.config.id === r.config?.id)
- void startRun(r.session.config, r.session.id, r.session.baseConfig, { show: false });
- else if (r.config) void startRun(r.config, undefined, undefined, { show: false });
+ const debug = serviceDebugger(r.session);
+ if (debug) debug.rerun?.();
+ else if (r.session?.run) {
+ const s = r.session.run;
+ void startRun(s.config, s.id, s.baseConfig, { show: false });
+ } else if (r.config) void startRun(r.config, undefined, undefined, { show: false });
}
function debug(r: Resolved) {
- if (r.config) void executeAction("run.debugConfig", r.config);
+ const session = serviceDebugger(r.session);
+ if (session) session.rerun?.();
+ else if (r.config) void executeAction("run.debugConfig", r.config);
}
function actions(item: ServiceTreeItem): ServiceItemAction[] {
const r = resolve(item);
- const running = r.sessions.filter(busy);
+ const running = r.sessions.filter(liveServiceSession);
const stop = {
id: "stop",
title: "Stop",
icon: "stop",
disabled: !running.length,
- run: () => running.forEach((s) => void stopSession(s.id)),
+ run: () => void stopServiceSessions(running),
};
if (!r.config) return [stop];
- const live = !!r.session && busy(r.session);
+ const live = !!r.session && liveServiceSession(r.session);
+ const debugging = serviceDebugger(r.session);
return [
{
id: "run",
title: live ? "Rerun" : "Run",
icon: live ? "rerun" : "run",
- disabled: isDebugOnly(r.config),
+ disabled: debugging ? !debugging.rerun : isDebugOnly(r.config),
run: () => run(r),
},
- { id: "debug", title: "Debug", icon: "debug", run: () => debug(r) },
+ { id: "debug", title: "Debug", icon: "debug", disabled: !!debugging && !debugging.rerun, run: () => debug(r) },
stop,
];
}
@@ -301,7 +325,8 @@ function menu(item: ServiceTreeItem): MenuItem[] {
}
if (r.config) {
const config = r.config;
- const session = r.session;
+ const session = r.session?.run;
+ const debuggerSession = serviceDebugger(r.session) ?? r.session?.debug.at(-1);
items.push(
{ kind: "separator" },
{
@@ -310,6 +335,12 @@ function menu(item: ServiceTreeItem): MenuItem[] {
disabled: !session,
run: () => session && showOutput(session),
},
+ {
+ label: "Show in Debug Tool Window",
+ icon: "toolwindow-debug",
+ disabled: !debuggerSession,
+ run: () => debuggerSession?.show(),
+ },
{ label: "Edit Configuration…", icon: "edit", run: () => void executeAction("run.editConfigs", config.id) },
);
}
@@ -319,6 +350,8 @@ function menu(item: ServiceTreeItem): MenuItem[] {
function RunDetail({ item }: { item: ServiceTreeItem }) {
// Re-render on session changes.
useRun((s) => s.sessions);
+ const debugViews = useDebugRunSessions();
+ const Console = debugViews.Console;
const t = useT();
const txTemplate = useTxTemplate();
const r = resolve(item);
@@ -333,7 +366,25 @@ function RunDetail({ item }: { item: ServiceTreeItem }) {
</EmptyState>
);
// The configuration ran: its console, as in the Run tool window.
- if (r.session) return <SessionPanel session={r.session} />;
+ if (r.session?.run) {
+ const execution = r.session;
+ const d = serviceDebugger(execution);
+ return (
+ <SessionPanel
+ key={execution.run!.id}
+ session={execution.run!}
+ onRerun={d ? d.rerun : undefined}
+ onStop={d ? () => void stopServiceSessions([execution]) : undefined}
+ />
+ );
+ }
+ const d = r.session?.debug[0];
+ if (d && Console)
+ return (
+ <div className={styles.debugConsole}>
+ <Console key={d.id} sessionId={d.id} />
+ </div>
+ );
return (
<div className={styles.detail}>
<dl className={styles.facts}>
@@ -400,7 +451,7 @@ export const runServiceProvider: ServiceProviderContribution = {
menu,
activate: (item) => {
const r = resolve(item);
- if (r.config && !(r.session && busy(r.session)) && !isDebugOnly(r.config)) run(r);
+ if (r.config && !(r.session && liveServiceSession(r.session)) && !isDebugOnly(r.config)) run(r);
},
detail: RunDetail,
addMenu,
@@ -425,6 +476,7 @@ export const runServiceProvider: ServiceProviderContribution = {
currentTypes(),
ranIds(useProject.getState().project?.root ?? null),
order,
+ useDebugRunSessions.getState().serviceSessions,
).find((g) => g.key === TYPE_PREFIX + kind);
const ids = group?.children?.map((c) => c.key.slice(CONFIG_PREFIX.length)) ?? [];
const from = source.key.slice(CONFIG_PREFIX.length),
diff --git a/src/features/services/ServicesTree.debug.test.tsx b/src/features/services/ServicesTree.debug.test.tsx
new file mode 100644
index 000000000..1904d9f94
--- /dev/null
+++ b/src/features/services/ServicesTree.debug.test.tsx
@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { act, fireEvent, render, screen, within } from "@testing-library/react";
+import { commands, type RunConfig } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import { validateSettings } from "@/features/settings/model/schema";
+import { adoptSession, appendConsole, useDebug } from "@/features/debugger/state";
+import { DebugServiceConsole } from "@/features/debugger/ui/DebugConsole";
+import { runServiceProvider } from "@/features/run/services";
+import { onRunExited, runtime, startRun, useRun } from "@/features/run/store";
+import { registerServiceProvider, useDebugRunSessions, type DebugServiceSession } from "@/workbench/contributions";
+import { ServicesTreeView } from "./ServicesTree";
+import { useServicesTree } from "./tree";
+
+vi.mock("@tanstack/react-virtual", () => ({
+ useVirtualizer: ({ count }: { count: number }) => ({
+ getTotalSize: () => count * 18,
+ getVirtualItems: () =>
+ Array.from({ length: count }, (_, index) => ({ index, key: index, start: index * 18, size: 18 })),
+ measureElement: () => {},
+ measure: () => {},
+ scrollToIndex: () => {},
+ }),
+}));
+
+const config: RunConfig = {
+ id: "gateway",
+ name: "Gateway",
+ kind: "spring-boot",
+ command: "java",
+ args: [],
+ cwd: null,
+ env: {},
+ detected: true,
+ isTest: false,
+ debugAdapter: "java-debug",
+};
+const summary = (id: number, extra: Partial<DebugServiceSession> = {}): DebugServiceSession => ({
+ id,
+ config,
+ startedAt: id,
+ status: "running",
+ processId: null,
+ stop: vi.fn(async () => {}),
+ rerun: vi.fn(),
+ show: vi.fn(),
+ ...extra,
+});
+let dispose: () => void;
+beforeEach(() => {
+ localStorage.clear();
+ useProject.setState({
+ project: { root: "/services-debug", name: "app", isGit: false, settings: validateSettings({}) },
+ });
+ useRun.setState({ configs: [config], sessions: [], loaded: true });
+ useDebug.setState({ sessions: {}, console: {}, active: null });
+ useDebugRunSessions.setState({ sessions: [], serviceSessions: [], Console: DebugServiceConsole });
+ useServicesTree.setState({
+ roots: {},
+ selectedKey: null,
+ selectedKeys: new Set(),
+ expanded: new Set(["run:type:spring-boot"]),
+ });
+ dispose = registerServiceProvider(runServiceProvider);
+});
+afterEach(() => {
+ vi.restoreAllMocks();
+ dispose();
+ useDebugRunSessions.setState({ sessions: [], serviceSessions: [], Console: null });
+});
+const select = () =>
+ fireEvent.mouseDown(
+ within(screen.getByRole("tree", { name: "Services" }))
+ .getByText("Gateway")
+ .closest('[role="treeitem"]')!,
+ );
+const toolbar = () => within(screen.getByRole("toolbar", { name: "Services actions" }));
+
+it("shows debug output/state, pins actions, and does not rebuild the tree for stdout", async () => {
+ adoptSession(1, { runConfig: config });
+ adoptSession(2, { runConfig: { ...config, id: "other" } });
+ appendConsole(1, "stdout", "gateway log\n");
+ appendConsole(2, "stdout", "other log\n");
+ const d = summary(1);
+ useDebugRunSessions.setState({ serviceSessions: [d] });
+ useDebug.setState({ active: 2 });
+ render(<ServicesTreeView />);
+ select();
+ expect(screen.getByRole("log")).toHaveTextContent("gateway log");
+ expect(screen.getByRole("log")).not.toHaveTextContent("other log");
+ expect(toolbar().getByRole("button", { name: "Stop" })).toBeEnabled();
+ fireEvent.click(toolbar().getByRole("button", { name: "Rerun" }));
+ expect(d.rerun).toHaveBeenCalledOnce();
+ expect(useDebug.getState().active).toBe(2);
+ const roots = useServicesTree.getState().roots;
+ act(() => appendConsole(1, "stdout", "next log\n"));
+ expect(screen.getByRole("log")).toHaveTextContent("next log");
+ expect(useServicesTree.getState().roots).toBe(roots);
+ act(() => useDebugRunSessions.setState({ serviceSessions: [{ ...d, status: "paused" }] }));
+ expect(within(screen.getByRole("tree")).getByText("Suspended")).toBeTruthy();
+ fireEvent.click(toolbar().getByRole("button", { name: "Stop" }));
+ expect(d.stop).toHaveBeenCalledOnce();
+});
+
+it("keeps the other parallel instance alive and then displays it", async () => {
+ adoptSession(1);
+ adoptSession(2);
+ appendConsole(1, "stdout", "first instance\n");
+ appendConsole(2, "stdout", "second instance\n");
+ const first = summary(1),
+ second = summary(2);
+ useDebugRunSessions.setState({ serviceSessions: [first, second] });
+ render(<ServicesTreeView />);
+ select();
+ expect(screen.getByRole("log")).toHaveTextContent("second instance");
+ fireEvent.click(toolbar().getByRole("button", { name: "Stop" }));
+ expect(second.stop).toHaveBeenCalledOnce();
+ expect(first.stop).not.toHaveBeenCalled();
+ act(() => useDebugRunSessions.setState({ serviceSessions: [first, { ...second, status: "terminated" }] }));
+ expect(screen.getByRole("log")).toHaveTextContent("first instance");
+});
+
+it("shows the owning Run output for attached debugging and overrides both sets of controls", async () => {
+ const stopRun = vi.spyOn(commands, "runStop").mockImplementation(async (id) => {
+ queueMicrotask(() => onRunExited(id, 130));
+ return { status: "ok", data: null };
+ });
+ const c = { ...config, kind: "shell", command: "echo", debugAdapter: null };
+ const s = await startRun(c);
+ expect(s).not.toBeNull();
+ const active = { ...s!, config, status: "running" as const, runId: 7 };
+ runtime(s!.id)!.console.append({ kind: "stdout", text: "Maven application log\n" });
+ useRun.setState({ configs: [config], sessions: [active] });
+ const d = summary(1, { processId: 7 });
+ useDebugRunSessions.setState({ serviceSessions: [d] });
+ render(<ServicesTreeView />);
+ select();
+ expect(screen.getByRole("log")).toHaveTextContent("Maven application log");
+ const actions = within(screen.getByRole("toolbar", { name: "Run actions" }));
+ fireEvent.click(actions.getByRole("button", { name: "Rerun" }));
+ expect(d.rerun).toHaveBeenCalledOnce();
+ await act(async () => fireEvent.click(actions.getByRole("button", { name: "Stop" })));
+ expect(stopRun).toHaveBeenCalledExactlyOnceWith(7);
+ await vi.waitFor(() => expect(d.stop).toHaveBeenCalledExactlyOnceWith({ stopProcess: false }));
+ act(() => useRun.setState({ sessions: [{ ...active, status: "finished" }] }));
+ expect(actions.getByRole("button", { name: "Stop" })).toBeEnabled();
+});
+
+it("group Stop stops all roots but terminates a shared Maven process only once", async () => {
+ const first = summary(1, { processId: 7 }),
+ second = summary(2, { processId: 7 });
+ useDebugRunSessions.setState({ serviceSessions: [first, second] });
+ render(<ServicesTreeView />);
+ fireEvent.mouseDown(within(screen.getByRole("tree")).getByText("Spring Boot").closest('[role="treeitem"]')!);
+ fireEvent.click(toolbar().getByRole("button", { name: "Stop" }));
+ await vi.waitFor(() => expect(second.stop).toHaveBeenCalledOnce());
+ expect(first.stop).toHaveBeenCalledExactlyOnceWith({ stopProcess: false });
+ expect(second.stop).toHaveBeenCalledExactlyOnceWith();
+});
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 28269b99b..e2c86d147 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5318,5 +5318,9 @@
"No selected paths can be deployed to {server}": "所选路径均无法部署到 {server}",
"No deployment server covers the selected paths": "没有部署服务器覆盖所选路径",
"Not covered by this server's mappings": "此服务器的映射未覆盖该路径",
- "Excluded from deployment": "已从部署中排除"
+ "Excluded from deployment": "已从部署中排除",
+ "No debug output available": "暂无可用的调试输出",
+ "The attached process may not provide standard output to the debugger.": "附加的进程可能不会向调试器提供标准输出。",
+ "Show in Debug Tool Window": "在调试工具窗口中显示",
+ "Suspended": "已暂停"
}
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index e393b2e28..98e80ef09 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -1294,4 +1294,20 @@ export interface DebugRunSession {
resume: () => void;
}
-export const useDebugRunSessions = create<{ sessions: DebugRunSession[] }>(() => ({ sessions: [] }));
+/** Configured debugger roots retained by the debugger, including finished output. */
+export interface DebugServiceSession {
+ id: number;
+ config: RunConfig;
+ startedAt: number;
+ status: "starting" | "running" | "paused" | "terminated";
+ processId: number | null;
+ rerun: (() => void) | null;
+ stop: (options?: { stopProcess?: boolean }) => Promise<void>;
+ show: () => void;
+}
+
+export const useDebugRunSessions = create<{
+ sessions: DebugRunSession[];
+ serviceSessions: DebugServiceSession[];
+ Console: ComponentType<{ sessionId: number }> | null;
+}>(() => ({ sessions: [], serviceSessions: [], Console: null }));