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
feat(run): grouped Add Service menu and the configuration picker (#2091)
Qing6f9279e7538a
diff --git a/src/features/run/RunServices.module.css b/src/features/run/RunServices.module.cssindex 288bb3362..7bc776f29 100644--- a/src/features/run/RunServices.module.css+++ b/src/features/run/RunServices.module.css@@ -35,3 +35,12 @@height: 100%;min-height: 0;}++.importList {+ display: flex;+ flex-direction: column;+ gap: var(--space-2);+ padding: var(--space-3);+ max-height: 320px;+ overflow: auto;+}diff --git a/src/features/run/configs.test.ts b/src/features/run/configs.test.tsindex bcfdd0eaa..06fbf9c06 100644--- a/src/features/run/configs.test.ts+++ b/src/features/run/configs.test.ts@@ -1,7 +1,10 @@import { afterEach, describe, expect, it } from "vitest";import type { RunConfig } from "@/platform/ipc";import { usePlatform } from "@/platform/platformInfo";+import { registerRunConfigType } from "@/workbench/contributions";import {+ categoryOf,+ kindLabel,commandLine,duplicateConfig,formatArgs,@@ -17,6 +20,9 @@ import {import { contextConfig, fileRole } from "./context";import { cacheRunTemplates } from "./runTemplates";import { registerBuiltinTypes } from "./types";+// After "./types": tomcat → buildUpdate → store → types is a cycle; importing tomcat first+// would freeze tomcatType at undefined inside BUILTIN_TYPES.+import { tomcatType } from "./tomcat";import { envFromRows } from "./EnvDialog";import { configRemoved, defaultSelection, rerunConfig, useRun, type RunSession } from "./store";@@ -527,3 +533,30 @@ describe("rerunning a session after its configuration changed (#1497)", () => {useRun.setState({ configs: [] });});});++describe("categoryOf", () => {+ it("maps kinds to their language categories and unlisted ones to Others", () => {+ expect(categoryOf("spring-boot")).toBe("Java");+ expect(categoryOf("maven")).toBe("Build Tools");+ expect(categoryOf("npm")).toBe("JavaScript");+ expect(categoryOf("cargo")).toBe("Rust");+ expect(categoryOf("godot")).toBe("Others");+ });++ it("prefers a registered type's group (Servers, Docker) over the category map", () => {+ const disposeTomcat = registerRunConfigType(tomcatType);+ expect(categoryOf("tomcat")).toBe("Servers");+ expect(kindLabel("tomcat")).toBe("Tomcat Server");+ disposeTomcat();+ const dispose = registerRunConfigType({+ id: "fake-server",+ label: "Fake",+ icon: "server",+ group: "Servers",+ fields: [],+ commandLine: () => null,+ });+ expect(categoryOf("fake-server")).toBe("Servers");+ dispose();+ });+});diff --git a/src/features/run/configs.ts b/src/features/run/configs.tsindex fa4c39a96..322af2d2c 100644--- a/src/features/run/configs.ts+++ b/src/features/run/configs.ts@@ -43,11 +43,61 @@ const KIND_LABELS: Record<string, string> = {};export const KIND_OPTIONS = Object.entries(KIND_LABELS).map(([value, label]) => ({ value, label }));+/**+ * The menu category of a run configuration kind, for the Services "Add Service"+ * menu (IDEA's template groups): a registered type's group (Docker, Servers),+ * else its language/tool category, else "Others".+ */+export const KIND_CATEGORIES: Record<string, string> = {+ "spring-boot": "Java",+ application: "Java",+ native: "Java",+ "java-file": "Java",+ kotlin: "Java",+ kotlinc: "Java",+ "scala-cli": "Java",+ maven: "Build Tools",+ gradle: "Build Tools",+ cmake: "Build Tools",+ make: "Build Tools",+ just: "Build Tools",+ npm: "JavaScript",+ vue: "JavaScript",+ node: "JavaScript",+ bun: "JavaScript",+ deno: "JavaScript",+ python: "Python",+ pytest: "Python",+ cargo: "Rust",+ rustc: "Rust",+ go: "Go",+ cc: "C/C++",+ "cmake-application": "C/C++",+ shell: "Shell",+ program: "Shell",+};++/** Category order of the Add Service menu; unlisted categories (plugins) sort after, then "Others". */+export const CATEGORY_ORDER: readonly string[] = [+ "Java",+ "Build Tools",+ "JavaScript",+ "Python",+ "Rust",+ "Go",+ "C/C++",+ "Shell",+ "Servers",+ "Docker",+];++export function categoryOf(kind: string): string {+ return useRunConfigTypes.getState().types.get(kind)?.group ?? KIND_CATEGORIES[kind] ?? "Others";+}export function kindLabel(kind: string): string {const type = useRunConfigTypes.getState().types.get(kind);- // A grouped type ("Tomcat Server › Local") is named by its group outside the Add menu.- return type?.group ?? type?.label ?? KIND_LABELS[kind] ?? (kind ? kind[0]!.toUpperCase() + kind.slice(1) : "Other");+ return type?.label ?? KIND_LABELS[kind] ?? (kind ? kind[0]!.toUpperCase() + kind.slice(1) : "Other");}export function configIcon(config: Pick<RunConfig, "kind" | "isTest">): string {diff --git a/src/features/run/index.ts b/src/features/run/index.tsindex 3460be206..2e13d07d2 100644--- a/src/features/run/index.ts+++ b/src/features/run/index.ts@@ -44,6 +44,7 @@ import { RunWidget } from "./RunWidget";import { runConfigsRunAnything } from "./runAnything";import { cleanupRemovedProject, recordRun, registerRunServiceActions, runServiceProvider } from "./services";import { liveServiceSession, serviceSessions } from "./serviceSessions";+import { ServiceImportHost } from "./serviceImport";import { cmakeBuildId } from "./cmake";import { runBeforeLaunch } from "./beforeLaunch";import { compoundChildren } from "./configs";@@ -341,6 +342,8 @@ export function activate(): () => void {component: lazyWhen(useEditConfigsOpen, () => import("./EditConfigsDialog").then((m) => m.EditConfigsOverlay)),}),registerOverlay({ id: "run.dialogs", component: RunDialogsOverlay }),+ registerOverlay({ id: "run.serviceImport", component: ServiceImportHost }),+ registerOverlay({ id: "run.serviceImport", component: ServiceImportHost }),registerServiceProvider(runServiceProvider),registerRunServiceActions(),registerRunningProcessesProvider({diff --git a/src/features/run/serviceImport.tsx b/src/features/run/serviceImport.tsxnew file mode 100644index 000000000..a5175e724--- /dev/null+++ b/src/features/run/serviceImport.tsx@@ -0,0 +1,96 @@+/**+ * "Add Service" of a configuration type with several configurations: pick the+ * ones to show in Services (removed ones are restored the same way).+ * Rendered by one overlay, like the Services view's dialogs.+ */+import { Fragment, useState, type ReactNode } from "react";+import { create } from "zustand";+import type { RunConfig } from "@/platform/ipc";+import { Checkbox, Dialog } from "@/ui";+import { kindLabel } from "./configs";+import { tx } from "@/platform/i18n";+import styles from "./RunServices.module.css";++interface Entry {+ id: number;+ node: ReactNode;+}++const useDialogs = create<{ stack: Entry[] }>(() => ({ stack: [] }));+let seq = 0;++export function ServiceImportHost() {+ const stack = useDialogs((s) => s.stack);+ return (+ <>+ {stack.map((e) => (+ <Fragment key={e.id}>{e.node}</Fragment>+ ))}+ </>+ );+}++/** The configurations of `kind` to show; `null` when the dialog was cancelled. */+export function pickServices(+ kind: string,+ configs: readonly RunConfig[],+ shown: ReadonlySet<string>,+): Promise<Set<string> | null> {+ return new Promise((resolve) => {+ const id = ++seq;+ const close = () => useDialogs.setState((s) => ({ stack: s.stack.filter((e) => e.id !== id) }));+ useDialogs.setState((s) => ({+ stack: [+ ...s.stack,+ {+ id,+ node: (+ <ImportDialog+ kind={kind}+ configs={configs}+ shown={shown}+ onDone={(picked) => {+ close();+ resolve(picked);+ }}+ />+ ),+ },+ ],+ }));+ });+}++function ImportDialog(props: {+ kind: string;+ configs: readonly RunConfig[];+ shown: ReadonlySet<string>;+ onDone: (picked: Set<string> | null) => void;+}) {+ const [picked, setPicked] = useState<Set<string>>(() => new Set(props.shown));+ const toggle = (id: string) =>+ setPicked((prev) => {+ const next = new Set(prev);+ if (next.has(id)) next.delete(id);+ else next.add(id);+ return next;+ });+ return (+ <Dialog+ open+ title={tx`Add Service (${kindLabel(props.kind)})`}+ onClose={() => props.onDone(null)}+ width={420}+ buttons={[+ { label: "OK", role: "default", disabled: picked.size === 0, onClick: () => props.onDone(picked) },+ { label: "Cancel", role: "cancel" },+ ]}+ >+ <div className={styles.importList}>+ {props.configs.map((c) => (+ <Checkbox key={c.id} checked={picked.has(c.id)} onChange={() => toggle(c.id)} label={<span>{c.name}</span>} />+ ))}+ </div>+ </Dialog>+ );+}diff --git a/src/features/run/services.test.ts b/src/features/run/services.test.tsindex 86c14bf7d..cf827b356 100644--- a/src/features/run/services.test.ts+++ b/src/features/run/services.test.ts@@ -1,4 +1,6 @@import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import type { MenuItem } from "@/ui";+import { pickServices } from "./serviceImport";import type { RunConfig } from "@/platform/ipc";import { useProject } from "@/platform/project";@@ -12,17 +14,20 @@ vi.mock("@/platform/ipc", async (importOriginal) => ({import {addType,cleanupRemovedProject,+ categorizedTypes,runServiceProvider,registerRunServiceActions,DEFAULT_TYPES,+ readHidden,readRan,readTypes,runServiceItems,sessionDetail,sessionStatus,} from "./services";+import { KIND_OPTIONS, categoryOf } from "./configs";import { startedPort } from "@/platform/serverPort";-import { useDebugRunSessions, type DebugServiceSession } from "@/workbench/contributions";+import { registerRunConfigType, useDebugRunSessions, type DebugServiceSession } from "@/workbench/contributions";import { useRun, type RunSession } from "./store";const { startRun, stopServiceSessions, openUrl, showContextMenu } = vi.hoisted(() => ({@@ -37,6 +42,7 @@ vi.mock("./serviceSessions", async (importOriginal) => ({stopServiceSessions,}));+vi.mock("./serviceImport", () => ({ pickServices: vi.fn() }));vi.mock("./navigate", () => ({ openUrl }));vi.mock("@/ui", async (importOriginal) => ({ ...(await importOriginal<typeof import("@/ui")>()), showContextMenu }));@@ -334,6 +340,118 @@ describe("embedded web server port", () => {});});+describe("hidden configurations", () => {+ const a = config("a", "spring-boot");+ const b = config("b", "spring-boot");++ it("hides a configuration unless it runs", () => {+ const hidden = { "spring-boot": ["a"] };+ const stopped = runServiceItems([a, b], [], DEFAULT_TYPES, [], {}, [], () => false, hidden);+ expect(stopped[0]!.children!.map((c) => c.key)).toEqual(["run:config:b"]);+ const running = runServiceItems(+ [a, b],+ [session("s1", a, "running", 1)],+ DEFAULT_TYPES,+ [],+ {},+ [],+ () => false,+ hidden,+ );+ expect(running[0]!.children!.map((c) => c.key)).toEqual(["run:config:a", "run:config:b"]);+ });++ it("keeps an empty default group whose configurations are all hidden", () => {+ const items = runServiceItems([a], [], DEFAULT_TYPES, [], {}, [], () => false, { "spring-boot": ["a"] });+ expect(items).toHaveLength(1);+ expect(items[0]!.children).toEqual([]);+ });++ it("persists hidden ids per project", () => {+ localStorage.clear();+ expect(readHidden("/p")).toEqual({});+ localStorage.setItem("openidea.services.runHidden:/p", JSON.stringify({ "spring-boot": ["a"] }));+ expect(readHidden("/p")).toEqual({ "spring-boot": ["a"] });+ expect(readHidden("/q")).toEqual({});+ expect(readHidden(null)).toEqual({});+ });+});++describe("add service categories", () => {+ it("categorizes every built-in kind; update the table when adding kinds", () => {+ const expected: Record<string, string> = {+ npm: "JavaScript",+ vue: "JavaScript",+ node: "JavaScript",+ bun: "JavaScript",+ deno: "JavaScript",+ cargo: "Rust",+ rustc: "Rust",+ gradle: "Build Tools",+ maven: "Build Tools",+ cmake: "Build Tools",+ make: "Build Tools",+ just: "Build Tools",+ go: "Go",+ python: "Python",+ pytest: "Python",+ phpunit: "Others",+ composer: "Others",+ cc: "C/C++",+ "cmake-application": "C/C++",+ shell: "Shell",+ program: "Shell",+ compound: "Others",+ application: "Java",+ "spring-boot": "Java",+ native: "Java",+ "java-file": "Java",+ kotlin: "Java",+ kotlinc: "Java",+ "scala-cli": "Java",+ ruby: "Others",+ php: "Others",+ perl: "Others",+ lua: "Others",+ r: "Others",+ swift: "Others",+ dart: "Others",+ elixir: "Others",+ };+ for (const { value } of KIND_OPTIONS) expect(categoryOf(value), value).toBe(expected[value]);+ });++ it("orders buckets: fixed order first, unlisted plugin categories after, Others last", () => {+ const dispose = registerRunConfigType({+ id: "fake-cloud",+ label: "Cloud Run",+ icon: "cloud",+ group: "Clouds",+ fields: [],+ commandLine: () => null,+ });+ const buckets = categorizedTypes(["ruby", "spring-boot", "npm", "fake-cloud", "gradle"]);+ expect(buckets.map((b) => b.category)).toEqual(["Java", "Build Tools", "JavaScript", "Clouds", "Others"]);+ dispose();+ });++ it("keeps a single-member category as its own bucket", () => {+ expect(categorizedTypes(["go", "ruby"])).toEqual([+ { category: "Go", kinds: ["go"] },+ { category: "Others", kinds: ["ruby"] },+ ]);+ });++ it("sorts each bucket's kinds by their label", () => {+ const buckets = categorizedTypes(["spring-boot", "application", "java-file", "native"]);+ expect(buckets[0]).toEqual({ category: "Java", kinds: ["application", "java-file", "native", "spring-boot"] });+ });++ it("groups nothing for an empty list", () => {+ expect(categorizedTypes([])).toEqual([]);+ });+});+describe("open in browser", () => {const item = () => ({ key: "run:config:a", label: "a", icon: "" });const hasBrowser = () => !runServiceProvider.actions!(item()).find((a) => a.id === "open-browser")?.disabled;@@ -559,3 +677,66 @@ describe("removing a workspace member from Services", () => {expect(readTypes("/w/main")).toEqual(["npm"]);});});++describe("service selection", () => {+ const group = { key: "run:type:npm", label: "npm", icon: "" };+ const item = (id: string) => ({ key: `run:config:${id}`, label: id, icon: "" });+ const leaf = (items: MenuItem[], label: string): Extract<MenuItem, { run?: unknown }> => {+ for (const entry of items) {+ if (entry.kind === "separator" || entry.kind === "header" || entry.kind === "action") continue;+ if (entry.label === label) return entry;+ if (entry.submenu) {+ const found = leaf(entry.submenu, label);+ if (found) return found;+ }+ }+ return undefined!;+ };++ beforeEach(() => {+ localStorage.clear();+ useProject.setState({ project: { root: "/selection" } as never });+ useRun.setState({ configs: [config("dev", "npm")], sessions: [] });+ vi.mocked(pickServices).mockReset();+ startRun.mockReset().mockResolvedValue(null);+ });++ it("restores a hidden single configuration through its group's Add Service", async () => {+ leaf(runServiceProvider.menu!(item("dev")), "Remove from Services").run!();+ expect(readHidden("/selection")).toEqual({ npm: ["dev"] });+ await leaf(runServiceProvider.menu!(group), "Add Service").run!();+ expect(readHidden("/selection")).toEqual({ npm: [] });+ expect(pickServices).not.toHaveBeenCalled();+ });++ it("keeps Run All and Restart All scoped to visible configurations", async () => {+ addType("npm");+ useRun.setState({ configs: [config("dev", "npm"), config("test", "npm")] });+ leaf(runServiceProvider.menu!(item("dev")), "Remove from Services").run!();+ for (const id of ["run-all", "restart-all"]) {+ startRun.mockClear();+ await runServiceProvider.actions!(group)+ .find((a) => a.id === id)!+ .run();+ expect(startRun.mock.calls.map(([c]) => c.id)).toEqual(["test"]);+ }+ });++ it("does not apply a picker result after switching projects", async () => {+ useRun.setState({ configs: [config("dev", "npm"), config("test", "npm")] });+ let finish!: (value: Set<string>) => void;+ vi.mocked(pickServices).mockImplementation(+ () =>+ new Promise((resolve) => {+ finish = resolve;+ }),+ );+ const pending = leaf(runServiceProvider.menu!(group), "Add Service").run!();+ useProject.setState({ project: { root: "/other-selection" } as never });+ finish(new Set(["dev"]));+ await pending;+ await Promise.resolve();+ expect(readHidden("/other-selection")).toEqual({});+ expect(readTypes("/other-selection")).toEqual(DEFAULT_TYPES);+ });+});diff --git a/src/features/run/services.tsx b/src/features/run/services.tsxindex 26ec0716d..b35c3dd34 100644--- a/src/features/run/services.tsx+++ b/src/features/run/services.tsx@@ -8,7 +8,7 @@*/import { useEffect, useMemo } from "react";import { create } from "zustand";-import { executeAction, registerActions } from "@/platform/actions";+import { executeAction, registerActions, type Action } from "@/platform/actions";import type { RunConfig } from "@/platform/ipc";import { useProject } from "@/platform/project";import { projectLocation, useRemote } from "@/platform/remote";@@ -25,7 +25,8 @@ import {type ServiceProviderContribution,type ServiceTreeItem,} from "@/workbench/contributions";-import { commandLine, configIcon, KIND_OPTIONS, kindLabel } from "./configs";+import { pickServices } from "./serviceImport";+import { CATEGORY_ORDER, categoryOf, commandLine, configIcon, KIND_OPTIONS, kindLabel } from "./configs";import { openUrl } from "./navigate";import { SessionPanel } from "./RunView";import { showApplicationUpdate } from "./applicationUpdate";@@ -209,6 +210,71 @@ export async function cleanupRemovedProject(removedRoot: string): Promise<void>}}+// Configurations hidden from Services, per project (removed one by one; "Add Service" restores)++const HIDDEN_KEY = "openidea.services.runHidden:";++const useHiddenConfigs = create<{ location: string | null; hidden: Record<string, string[]> }>(() => ({+ location: null,+ hidden: {},+}));++/** Hidden configuration ids per kind, persisted per project. */+export function readHidden(location: string | null): Record<string, string[]> {+ if (!location) return {};+ try {+ const raw: unknown = JSON.parse(localStorage.getItem(HIDDEN_KEY + location) ?? "{}");+ const hidden: Record<string, string[]> = {};+ if (raw && typeof raw === "object")+ for (const [kind, ids] of Object.entries(raw))+ if (Array.isArray(ids)) hidden[kind] = ids.filter((id): id is string => typeof id === "string");+ return hidden;+ } catch {+ return {};+ }+}++function currentHidden(): Record<string, string[]> {+ const s = useHiddenConfigs.getState();+ const location = projectLocation(useProject.getState().project?.root);+ return s.location === location ? s.hidden : readHidden(location);+}++function saveHidden(hidden: Record<string, string[]>) {+ const location = projectLocation(useProject.getState().project?.root);+ useHiddenConfigs.setState({ location, hidden });+ if (!location) return;+ try {+ localStorage.setItem(HIDDEN_KEY + location, JSON.stringify(hidden));+ } catch {+ /* storage unavailable */+ }+}++/** Removes one configuration from Services; it reappears while it runs (its console stays reachable). */+function hideConfig(kind: string, id: string) {+ const hidden = currentHidden();+ if ((hidden[kind] ?? []).includes(id)) return;+ saveHidden({ ...hidden, [kind]: [...(hidden[kind] ?? []), id] });+}++/** "Add Service" on a type group: pick which of the kind's configurations show. */+async function pickForKind(kind: string) {+ const location = projectLocation(useProject.getState().project?.root);+ const configs = useRun.getState().configs.filter((c) => c.kind === kind);+ if (configs.length <= 1) {+ saveHidden({ ...currentHidden(), [kind]: [] });+ addType(kind);+ return;+ }+ const hidden = new Set(currentHidden()[kind] ?? []);+ const picked = await pickServices(kind, configs, new Set(configs.filter((c) => !hidden.has(c.id)).map((c) => c.id)));+ if (!picked || projectLocation(useProject.getState().project?.root) !== location) return;+ addType(kind);+ const remaining = configs.filter((c) => !picked.has(c.id)).map((c) => c.id);+ saveHidden({ ...currentHidden(), [kind]: remaining });+}+// ---------------------------------------------------------------------------// Tree@@ -255,6 +321,7 @@ export function runServiceItems(order: ServiceOrder = {},debug: readonly DebugServiceSession[] = [],removed: (id: string) => boolean = () => false,+ hidden: Record<string, readonly string[]> = {},): ServiceTreeItem[] {const executions = serviceSessions(sessions, debug);const latest = currentServiceSessions(executions);@@ -271,8 +338,16 @@ export function runServiceItems(: ran.map((id) => configs.find((c) => c.id === id)).filter((c): c is RunConfig => !!c && c.kind === kind);for (const s of latest.values())if (s.config.kind === kind && shown(s) && !entries.some((c) => c.id === s.config.id)) entries.push(s.config);- if (!entries.length && DEFAULT_TYPES.includes(kind)) return [];- const children = orderServices(entries, order[kind]).map((c): ServiceTreeItem => {+ // Hidden configurations reappear only while they run (their console stays reachable).+ const hiddenIds = new Set(hidden[kind] ?? []);+ const visible = entries.filter((c) => {+ if (!hiddenIds.has(c.id)) return true;+ const s = latest.get(c.id);+ return !!s && liveServiceSession(s);+ });+ // Keep an empty group only when its existing configurations can be restored.+ if (!visible.length && DEFAULT_TYPES.includes(kind) && !configs.some((c) => c.kind === kind)) return [];+ const children = orderServices(visible, order[kind]).map((c): ServiceTreeItem => {const s = latest.get(c.id);return {key: CONFIG_PREFIX + c.id,@@ -282,7 +357,7 @@ export function runServiceItems(dim: !s || !liveServiceSession(s),};});- const running = entries.filter((c) => {+ const running = visible.filter((c) => {const s = latest.get(c.id);return !!s && liveServiceSession(s);}).length;@@ -302,7 +377,8 @@ export function runServiceItems(function useRoots(): ServiceTreeItem[] {const root = useProject((s) => s.project?.root ?? null);useRemote((s) => s.session);- const order = useServiceOrder(projectLocation(root));+ const location = projectLocation(root);+ const order = useServiceOrder(location);const configs = useRun((s) => s.configs);const sessions = useRun((s) => s.sessions);const debug = useDebugRunSessions((s) => s.serviceSessions);@@ -310,10 +386,13 @@ function useRoots(): ServiceTreeItem[] {const typesRoot = useAddedTypes((s) => s.root);const ran = useRanConfigs((s) => s.ids);const ranRoot = useRanConfigs((s) => s.root);+ const hidden = useHiddenConfigs((s) => s.hidden);+ const hiddenLocation = useHiddenConfigs((s) => s.location);useEffect(() => {if (typesRoot !== root) useAddedTypes.setState({ root, types: root ? readTypes(root) : [] });if (ranRoot !== root) useRanConfigs.setState({ root, ids: root ? readRan(root) : [] });- }, [root, typesRoot, ranRoot]);+ if (hiddenLocation !== location) useHiddenConfigs.setState({ location, hidden: readHidden(location) });+ }, [root, typesRoot, ranRoot, hiddenLocation, location]);return useMemo(() =>runServiceItems(@@ -324,8 +403,9 @@ function useRoots(): ServiceTreeItem[] {order,debug,configRemoved,+ hiddenLocation === location ? hidden : {},),- [configs, sessions, types, typesRoot, ran, ranRoot, root, order, debug],+ [configs, sessions, types, typesRoot, ran, ranRoot, root, order, debug, hidden, hiddenLocation, location],);}@@ -340,14 +420,26 @@ interface Resolved {function resolve(item: ServiceTreeItem): Resolved {const { configs, sessions } = useRun.getState();const executions = serviceSessions(sessions, useDebugRunSessions.getState().serviceSessions);+ // A configuration type's group node (`run:type:spring-boot`).if (item.key.startsWith(TYPE_PREFIX)) {const kind = item.key.slice(TYPE_PREFIX.length);- return { kind, config: null, session: undefined, sessions: executions.filter((s) => s.config.kind === kind) };+ return {+ kind,+ config: null,+ session: undefined,+ sessions: executions.filter((s) => s.config.kind === kind),+ };}+ // A configuration (`run:config:<id>`).const id = item.key.slice(CONFIG_PREFIX.length);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] : [] };+ return {+ kind: config?.kind ?? null,+ config,+ session,+ sessions: session ? [session] : [],+ };}function showOutput(s: RunSession) {@@ -385,6 +477,7 @@ function groupConfigs(kind: string): RunConfig[] {location ? currentServiceOrder(location) : {},debug,configRemoved,+ currentHidden(),).find((item) => item.key === TYPE_PREFIX + kind);return (group?.children ?? []).flatMap((item) => {const id = item.key.slice(CONFIG_PREFIX.length);@@ -523,8 +616,8 @@ const SERVICE_ACTIONS = [];export function registerRunServiceActions(): () => void {- return registerActions(- SERVICE_ACTIONS.map(({ id, action, title, icon }) => ({+ return registerActions([+ ...SERVICE_ACTIONS.map<Action>(({ id, action, title, icon }) => ({id: action,title,icon,@@ -536,7 +629,29 @@ export function registerRunServiceActions(): () => void {if (action && !action.disabled) await action.run();},})),- );+ {+ id: "run.services.addType",+ title: "Add Service",+ icon: "plus",+ category: "Run",+ hidden: true,+ run: async ({ arg }) => {+ if (typeof arg === "string") await pickForKind(arg);+ },+ },+ {+ id: "run.services.hideConfig",+ title: "Remove from Services",+ icon: "close",+ category: "Run",+ hidden: true,+ run: ({ arg }) => {+ if (typeof arg !== "string") return;+ const { config } = resolve({ key: CONFIG_PREFIX + arg, label: "", icon: "" });+ if (config) hideConfig(config.kind, config.id);+ },+ },+ ]);}function actions(item: ServiceTreeItem): ServiceItemAction[] {@@ -562,9 +677,21 @@ function menu(item: ServiceTreeItem): MenuItem[] {run: a.run,}));const r = resolve(item);- if (!r.config && r.kind && currentTypes().includes(r.kind)) {+ if (!r.config && r.kind) {const kind = r.kind;- items.push({ kind: "separator" }, { label: "Remove from Services", icon: "close", run: () => removeType(kind) });+ items.push(+ { kind: "separator" },+ {+ label: "Add Service",+ icon: "plus",+ disabled: !useRun.getState().configs.some((c) => c.kind === kind),+ run: async () => {+ await executeAction("run.services.addType", kind);+ },+ },+ );+ if (currentTypes().includes(kind))+ items.push({ label: "Remove from Services", icon: "close", run: () => removeType(kind) });}if (r.config) {const config = r.config;@@ -585,6 +712,11 @@ function menu(item: ServiceTreeItem): MenuItem[] {run: () => debuggerSession?.show(),},{ label: "Edit Configuration…", icon: "edit", run: () => void executeAction("run.editConfigs", config.id) },+ {+ label: "Remove from Services",+ icon: "close",+ run: () => void executeAction("run.services.hideConfig", config.id),+ },);}return items;@@ -643,6 +775,14 @@ function RunDetail({ item }: { item: ServiceTreeItem }) {<dd><T>{kindLabel(r.config.kind)}</T></dd>+ {r.config.module && (+ <>+ <dt>+ <T>Module</T>+ </dt>+ <dd>{r.config.module}</dd>+ </>+ )}<dt><T>Command</T></dt>@@ -666,24 +806,61 @@ function RunDetail({ item }: { item: ServiceTreeItem }) {);}+/** The leaf label of a kind: the registered type's own label, else its kind label. */+const labelOf = (kind: string) => useRunConfigTypes.getState().types.get(kind)?.label ?? kindLabel(kind);++/**+ * The kinds grouped by menu category, in display order: `CATEGORY_ORDER` first,+ * then unlisted (plugin) categories alphabetically, then "Others" last; each+ * bucket's kinds sorted by leaf label. One submenu is rendered per bucket, even+ * for a single member, so adding groups and members later keeps the structure.+ */+export function categorizedTypes(kinds: readonly string[]): Array<{ category: string; kinds: string[] }> {+ const byCategory = new Map<string, string[]>();+ for (const kind of kinds) {+ const category = categoryOf(kind);+ byCategory.set(category, [...(byCategory.get(category) ?? []), kind]);+ }+ const rank = (category: string) => {+ const i = CATEGORY_ORDER.indexOf(category);+ // Unlisted (plugin) categories sort after the fixed order, before "Others".+ return i === -1 ? CATEGORY_ORDER.length : i;+ };+ const categories = [...byCategory.keys()].sort(+ (a, b) => rank(a) - rank(b) || (a === "Others" ? 1 : b === "Others" ? -1 : 0) || a.localeCompare(b),+ );+ return categories.map((category) => ({+ category,+ kinds: [...byCategory.get(category)!].sort((a, b) => labelOf(a).localeCompare(labelOf(b))),+ }));+}+/** "Add Service › Run Configuration Type": the project's types first, then the rest. */function addMenu(): MenuItem[] {const added = currentTypes();const used = [...new Set(useRun.getState().configs.map((c) => c.kind))];const known = [...KIND_OPTIONS.map((o) => o.value), ...useRunConfigTypes.getState().types.keys()];const kinds = [...new Set([...used, ...known])].filter((k) => k !== "compound" && !added.includes(k));+ /** A leaf item: the type's own label; grouped types live in their group's submenu. */const item = (kind: string): MenuItem => ({- label: kindLabel(kind),+ label: useRunConfigTypes.getState().types.get(kind)?.label ?? kindLabel(kind),icon: configIcon({ kind, isTest: false }),- run: () => addType(kind),+ run: async () => {+ await executeAction("run.services.addType", kind);+ },});+ const grouped = (list: readonly string[]) =>+ categorizedTypes(list).map(({ category, kinds: members }) => ({+ label: category,+ icon: configIcon({ kind: members[0]!, isTest: false }),+ submenu: members.map(item),+ }));const submenu: MenuItem[] = [- ...kinds.filter((k) => used.includes(k)).map(item),- ...(used.some((k) => kinds.includes(k)) ? [{ kind: "separator" } as MenuItem] : []),- ...kinds- .filter((k) => !used.includes(k))- .sort((a, b) => kindLabel(a).localeCompare(kindLabel(b)))- .map(item),+ ...grouped(kinds.filter((k) => used.includes(k))),+ ...(used.some((k) => kinds.includes(k)) && kinds.some((k) => !used.includes(k))+ ? [{ kind: "separator" } as MenuItem]+ : []),+ ...grouped(kinds.filter((k) => !used.includes(k))),];return [{ label: "Run Configuration Type", icon: "toolwindow-run", disabled: !submenu.length, submenu }];}@@ -722,13 +899,18 @@ export const runServiceProvider: ServiceProviderContribution = {ranIds(useProject.getState().project?.root ?? null),order,useDebugRunSessions.getState().serviceSessions,+ configRemoved,+ currentHidden(),).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),to = target.key.slice(CONFIG_PREFIX.length);if (!ids.includes(from) || !ids.includes(to)) return;if (- !saveServiceOrder(location, { ...order, [kind]: moveServiceOrder(order[kind] ?? [], ids, from, to, position) })+ !saveServiceOrder(location, {+ ...order,+ [kind]: moveServiceOrder(order[kind] ?? [], ids, from, to, position),+ })) {notifications().notify({group: "run",diff --git a/src/features/run/tomcat.test.tsx b/src/features/run/tomcat.test.tsxindex 13b27bef7..a2599e484 100644--- a/src/features/run/tomcat.test.tsx+++ b/src/features/run/tomcat.test.tsx@@ -51,7 +51,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => ({afterEach(cleanup);describe("Tomcat Local", () => {- it("offers a Local configuration grouped under Tomcat Server with build and browser defaults", () => {+ it("offers a Tomcat Server configuration grouped under Servers with build and browser defaults", () => {const config = newConfigOfType(tomcatType, []);expect(config.params).toMatchObject({httpPort: "8080",@@ -60,9 +60,7 @@ describe("Tomcat Local", () => {openBrowser: "true",});expect(config.debugAdapter).toBe("java-debug");- expect(typeRows([tomcatType], "")).toEqual(- expect.arrayContaining([expect.objectContaining({ label: "Tomcat Server" })]),- );+ expect(typeRows([tomcatType], "")).toEqual(expect.arrayContaining([expect.objectContaining({ label: "Servers" })]));expect(missingParams(config, tomcatType)).toHaveProperty("tomcatHome");});it("validates ports and context paths and supports manually chosen web roots", () => {diff --git a/src/features/run/tomcat.ts b/src/features/run/tomcat.tsindex caeca49ef..64cba9d5a 100644--- a/src/features/run/tomcat.ts+++ b/src/features/run/tomcat.ts@@ -11,8 +11,8 @@ const validateOptionalPort = (value: string) => (!value.trim() ? null : validateexport const tomcatType: RunConfigTypeContribution = {id: "tomcat",- group: "Tomcat Server",- label: "Local",+ group: "Servers",+ label: "Tomcat Server",icon: "tomcat",description: "Run a WAR application in a local Tomcat server",debugAdapter: "java-debug",diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.jsonindex f95a2c079..45cb292ca 100644--- a/src/platform/locales/text/en.json+++ b/src/platform/locales/text/en.json@@ -1,4 +1,16 @@{+ "Docker": "Docker",+ "Shell": "Shell",+ "C/C++": "C/C++",+ "Go": "Go",+ "Rust": "Rust",+ "Python": "Python",+ "JavaScript": "JavaScript",+ "Build Tools": "Build Tools",+ "Java": "Java",+ "Add Service ({kind})": "Add Service ({kind})",+ "Others": "Others",+ "Servers": "Servers","Skills": "Skills","Keyword": "Keyword","Identifiers": "Identifiers",diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex 835641778..93cf42838 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -1,4 +1,15 @@{+ "Docker": "Docker",+ "Shell": "Shell",+ "C/C++": "C/C++",+ "Go": "Go",+ "Rust": "Rust",+ "Python": "Python",+ "JavaScript": "JavaScript",+ "Java": "Java",+ "Add Service ({kind})": "添加服务({kind})",+ "Others": "其他",+ "Servers": "服务器","Skills": "技能","Identifiers": "标识符","Parameter": "参数",