Are you sure you want to close it?", + "TERMINAL_CLOSE_SINGLE_TITLE": "Close Terminal?", + "TERMINAL_CLOSE_SINGLE_MSG": "This terminal has an active process. Closing it will stop the process.
Do you want to continue?", + "TERMINAL_CLOSE_SINGLE_BTN": "Close Terminal", + "TERMINAL_CLOSE_ALL_TITLE": "Close All Terminals?", + "TERMINAL_CLOSE_ALL_MSG": "All terminals will be closed.
No active processes are running.
Continue?", + "TERMINAL_CLOSE_ALL_BTN": "Close All", + "TERMINAL_CLOSE_ALL_MSG_PROCESS_ONE": "All terminals will be closed.
1 active process will be stopped.
Continue?", + "TERMINAL_CLOSE_ALL_MSG_PROCESS_MANY": "All terminals will be closed.
{0} active processes will be stopped.
Continue?", + "TERMINAL_CLOSE_ALL_STOP_BTN": "Close All & Stop Processes", + "TERMINAL_FOCUS_HINT": "Press {0} to switch between editor and terminal", + "TERMINAL_CLEAR": "Clear Terminal", "EXTENDED_COMMIT_MESSAGE": "EXTENDED", "GETTING_STAGED_DIFF_PROGRESS": "Getting diff of staged files\u2026", "GIT_COMMIT": "Git commit\u2026", diff --git a/src/phoenix-builder/phoenix-builder-boot.js b/src/phoenix-builder/phoenix-builder-boot.js index f3d5269d00..91eb38b2d0 100644 --- a/src/phoenix-builder/phoenix-builder-boot.js +++ b/src/phoenix-builder/phoenix-builder-boot.js @@ -52,6 +52,26 @@ const RECONNECT_MAX_MS = 5000; const DEFAULT_WS_URL = "ws://localhost:38571"; + // --- Trust ring reference (set later via setKernalModeTrust) --- + let _kernalModeTrust = null; + + /** + * Dismantle the trust ring before reload. Awaits up to 5s, ignores errors. + * @return {Promise
+ + `; + let focusPanel = WorkspaceManager.createBottomPanel("focusTestPanel", + _$(focusPanelTemplate), 100); + + focusPanel.focus = function () { + _$("#focus-test-input")[0].focus(); + return true; + }; + + focusPanel.show(); + expect(focusPanel.isVisible()).toBeTrue(); + + expect(MainViewManager.getActivePaneId()).toEqual("first-pane"); + promise = MainViewManager._open(MainViewManager.FIRST_PANE, FileSystem.getFileForPath(testPath + "/test.js")); + await awaitsForDone(promise, "MainViewManager.doOpen"); + + // Shift+Escape from editor should focus the panel's text input + SpecRunnerUtils.simulateKeyEvent(KeyEvent.DOM_VK_ESCAPE, "keydown", + _$("#editor-holder")[0], { shiftKey: true }); + expect(testWindow.document.activeElement).toBe(_$("#focus-test-input")[0]); + + // Shift+Escape from panel should focus the editor + SpecRunnerUtils.simulateKeyEvent(KeyEvent.DOM_VK_ESCAPE, "keydown", + _$("#editor-holder")[0], { shiftKey: true }); + expect(EditorManager.getFocusedEditor()).toBeTruthy(); + expect(testWindow.document.activeElement).not.toBe(_$("#focus-test-input")[0]); + + focusPanel.hide(); + WorkspaceManager.destroyBottomPanel("focusTestPanel"); + }); + + it("should app-drawer-button toggle the default panel", async function () { + panel1.hide(); + panel2.hide(); + let defaultPanel = WorkspaceManager.getPanelForID(WorkspaceManager.DEFAULT_PANEL_ID); + if (defaultPanel.isVisible()) { + defaultPanel.hide(); + } + expect(defaultPanel.isVisible()).toBeFalse(); + + // Click app-drawer-button to show the default panel + _$("#app-drawer-button").click(); + expect(defaultPanel.isVisible()).toBeTrue(); + + // Click again to hide it + _$("#app-drawer-button").click(); + expect(defaultPanel.isVisible()).toBeFalse(); }); it("should escape collapse bottom panel regardless of canBeShown", async function () { @@ -1237,5 +1319,171 @@ define(function (require, exports, module) { expect(maxSize).toBeLessThanOrEqual(testWindow.innerWidth * 0.75); }); }); + + describe("Plugin panel clamping on window resize", function () { + let pluginPanel, $toolbarIcon; + const MIN_WIDTH = 200; + + beforeAll(function () { + $toolbarIcon = _$(''); + _$("#plugin-icons-bar").append($toolbarIcon); + + let panelTemplate = '
Test Panel
';
+ pluginPanel = WorkspaceManager.createPluginPanel(
+ "test-clamp-panel", _$(panelTemplate), MIN_WIDTH, $toolbarIcon
+ );
+ });
+
+ afterAll(function () {
+ if (pluginPanel) {
+ pluginPanel.hide();
+ }
+ $toolbarIcon.remove();
+ });
+
+ afterEach(function () {
+ pluginPanel.hide();
+ });
+
+ it("should clamp plugin panel when window resizes smaller", function () {
+ pluginPanel.show();
+ WorkspaceManager.setPluginPanelWidth(600);
+
+ const $mainToolbar = _$("#main-toolbar");
+ const widthBefore = $mainToolbar.width();
+
+ // Simulate a narrow window resize
+ const sidebarWidth = _$("#sidebar").outerWidth() || 0;
+ const maxAllowed = Math.min(
+ testWindow.innerWidth * 0.75,
+ testWindow.innerWidth - sidebarWidth - 100
+ );
+
+ // Only expect clamping if the panel was wider than max
+ if (widthBefore > maxAllowed) {
+ testWindow.dispatchEvent(new testWindow.Event("resize"));
+ expect($mainToolbar.width()).toBeLessThanOrEqual(maxAllowed);
+ } else {
+ // Panel fits, dispatch resize and verify it stays unchanged
+ testWindow.dispatchEvent(new testWindow.Event("resize"));
+ expect($mainToolbar.width()).toEqual(widthBefore);
+ }
+ });
+
+ it("should not let toolbar disappear on window resize", function () {
+ pluginPanel.show();
+
+ const $mainToolbar = _$("#main-toolbar");
+ const $pluginIconsBar = _$("#plugin-icons-bar");
+
+ testWindow.dispatchEvent(new testWindow.Event("resize"));
+
+ // Toolbar must remain at least as wide as the icons bar + panel minWidth
+ const minToolbarWidth = MIN_WIDTH + $pluginIconsBar.outerWidth();
+ expect($mainToolbar.width()).toBeGreaterThanOrEqual(minToolbarWidth);
+ });
+
+ it("should clamp panel width when shown after window was resized", function () {
+ // Panel is hidden; compute what the max toolbar width would be
+ const sidebarWidth = _$("#sidebar").outerWidth() || 0;
+ const maxToolbarWidth = Math.min(
+ testWindow.innerWidth * 0.75,
+ testWindow.innerWidth - sidebarWidth - 100
+ );
+
+ // Now show the panel — it should be clamped to maxToolbarWidth
+ pluginPanel.show();
+
+ const $mainToolbar = _$("#main-toolbar");
+ expect($mainToolbar.width()).toBeLessThanOrEqual(maxToolbarWidth);
+
+ // And content area should match
+ const $windowContent = _$(".content");
+ const rightOffset = parseInt($windowContent.css("right"), 10);
+ expect(rightOffset).toEqual($mainToolbar.width());
+ });
+
+ it("should keep content right offset in sync after resize clamp", function () {
+ pluginPanel.show();
+ WorkspaceManager.setPluginPanelWidth(600);
+
+ testWindow.dispatchEvent(new testWindow.Event("resize"));
+
+ const $mainToolbar = _$("#main-toolbar");
+ const $windowContent = _$(".content");
+ const rightOffset = parseInt($windowContent.css("right"), 10);
+ expect(rightOffset).toEqual($mainToolbar.width());
+ });
+ });
+
+ describe("Quick Access panel (app drawer button)", function () {
+ const DEFAULT_PANEL_ID = "workspace.defaultPanel";
+
+ function getDrawerButton() {
+ return _$("#app-drawer-button");
+ }
+
+ function isDefaultPanelVisible() {
+ return _$("#default-panel").is(":visible");
+ }
+
+ function isDrawerSelected() {
+ return getDrawerButton().hasClass("selected-button");
+ }
+
+ beforeEach(function () {
+ // Ensure a clean state: hide any open panels
+ const panel = WorkspaceManager.getPanelForID(DEFAULT_PANEL_ID);
+ if (panel && panel.isVisible()) {
+ panel.hide();
+ }
+ });
+
+ it("should have the app-drawer button in the toolbar", function () {
+ expect(getDrawerButton().length).toBe(1);
+ });
+
+ it("should open Quick Access panel on drawer button click", function () {
+ expect(isDefaultPanelVisible()).toBeFalse();
+
+ getDrawerButton().click();
+
+ expect(isDefaultPanelVisible()).toBeTrue();
+ });
+
+ it("should show selected state when panel is open", function () {
+ expect(isDrawerSelected()).toBeFalse();
+
+ getDrawerButton().click();
+
+ expect(isDrawerSelected()).toBeTrue();
+ });
+
+ it("should close Quick Access panel on second click", function () {
+ getDrawerButton().click();
+ expect(isDefaultPanelVisible()).toBeTrue();
+ expect(isDrawerSelected()).toBeTrue();
+
+ getDrawerButton().click();
+
+ expect(isDefaultPanelVisible()).toBeFalse();
+ expect(isDrawerSelected()).toBeFalse();
+ });
+
+ it("should deselect drawer when another panel opens", async function () {
+ getDrawerButton().click();
+ expect(isDefaultPanelVisible()).toBeTrue();
+ expect(isDrawerSelected()).toBeTrue();
+
+ // Open a different panel (Problems)
+ await CommandManager.execute(Commands.VIEW_TOGGLE_PROBLEMS);
+
+ expect(isDefaultPanelVisible()).toBeFalse();
+ expect(isDrawerSelected()).toBeFalse();
+
+ // Clean up: close Problems panel
+ await CommandManager.execute(Commands.VIEW_TOGGLE_PROBLEMS);
+ });
+ });
});
});
diff --git a/test/spec/NotificationUI-test.js b/test/spec/NotificationUI-test.js
index 2880179714..7b8418b333 100644
--- a/test/spec/NotificationUI-test.js
+++ b/test/spec/NotificationUI-test.js
@@ -114,5 +114,109 @@ define(function (require, exports, module) {
await verifyToast(NotificationUI.NOTIFICATION_STYLES_CSS_CLASS.DANGER);
await verifyToast("custom-class-name");
}, 10000);
+
+ describe("showToastOn", function () {
+ let $container;
+
+ beforeAll(function () {
+ $container = $(
+ '');
+ $("body").append($container);
+ });
+
+ afterAll(function () {
+ $container.remove();
+ });
+
+ it("Should show an inline toast inside a container", async function () {
+ let notification = NotificationUI.showToastOn($container[0], "Hello inline toast");
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 1;
+ }, "waiting for inline toast to appear");
+ expect($container.find(".inline-toast").text()).toBe("Hello inline toast");
+ notification.close();
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 0;
+ }, "waiting for inline toast to close");
+ });
+
+ it("Should auto-close after autoCloseTimeS", async function () {
+ NotificationUI.showToastOn($container[0], "Auto close", {
+ autoCloseTimeS: 1
+ });
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 1;
+ }, "waiting for inline toast to appear");
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 0;
+ }, "waiting for inline toast to auto-close", 3000);
+ });
+
+ it("Should dismiss on click by default", async function () {
+ NotificationUI.showToastOn($container[0], "Click me");
+ await awaitsFor(function () {
+ return $container.find(".inline-toast.visible").length === 1;
+ }, "waiting for inline toast to be visible");
+ $container.find(".inline-toast").click();
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 0;
+ }, "waiting for inline toast to close on click");
+ });
+
+ it("Should not dismiss on click when dismissOnClick is false", async function () {
+ let notification = NotificationUI.showToastOn($container[0], "No dismiss", {
+ dismissOnClick: false,
+ autoCloseTimeS: 0
+ });
+ await awaitsFor(function () {
+ return $container.find(".inline-toast.visible").length === 1;
+ }, "waiting for inline toast to be visible");
+ $container.find(".inline-toast").click();
+ await awaits(250);
+ expect($container.find(".inline-toast").length).toBe(1);
+ notification.close("manual");
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 0;
+ }, "waiting for inline toast to close manually");
+ });
+
+ it("Should accept a jQuery selector string as container", async function () {
+ NotificationUI.showToastOn("#inline-toast-test-container", "Selector toast");
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 1;
+ }, "waiting for inline toast via selector");
+ $container.find(".inline-toast").click();
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 0;
+ }, "waiting for inline toast to close");
+ });
+
+ it("Should resolve done callback with close reason", async function () {
+ let closeReason;
+ let notification = NotificationUI.showToastOn($container[0], "Done test");
+ notification.done(function (reason) {
+ closeReason = reason;
+ });
+ await awaitsFor(function () {
+ return $container.find(".inline-toast.visible").length === 1;
+ }, "waiting for inline toast to be visible");
+ notification.close("testReason");
+ await awaitsFor(function () {
+ return closeReason === "testReason";
+ }, "waiting for done callback");
+ });
+
+ it("Should accept HTML template with elements", async function () {
+ NotificationUI.showToastOn($container[0], 'Bold text');
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 1;
+ }, "waiting for inline toast");
+ expect($container.find(".inline-toast b").length).toBe(1);
+ $container.find(".inline-toast").click();
+ await awaitsFor(function () {
+ return $container.find(".inline-toast").length === 0;
+ }, "waiting for inline toast to close");
+ });
+ });
});
});
diff --git a/test/spec/PreferencesManager-integ-test.js b/test/spec/PreferencesManager-integ-test.js
index f7c63336df..a686578522 100644
--- a/test/spec/PreferencesManager-integ-test.js
+++ b/test/spec/PreferencesManager-integ-test.js
@@ -58,20 +58,20 @@ define(function (require, exports, module) {
await awaitsForDone(SpecRunnerUtils.openProjectFiles(fileName));
await awaitsFor(()=>{
return PreferencesManager.get("spaceUnits") === expectedSpaceUnits;
- }, "space units to be "+expectedSpaceUnits);
+ }, "space units to be "+expectedSpaceUnits, 10000);
await awaitsForDone(FileViewController.openAndSelectDocument(nonProjectFile,
FileViewController.WORKING_SET_VIEW));
await awaitsFor(()=>{
return PreferencesManager.get("spaceUnits") !== expectedSpaceUnits;
- }, "space non project file units not to be "+expectedSpaceUnits);
+ }, "space non project file units not to be "+expectedSpaceUnits, 10000);
// Changing projects will force a change in the project scope.
await SpecRunnerUtils.loadProjectInTestWindow(projectWithoutSettings);
await awaitsForDone(SpecRunnerUtils.openProjectFiles("file_one.js"));
await awaitsFor(()=>{
return PreferencesManager.get("spaceUnits") !== expectedSpaceUnits;
- }, "space units not to be "+expectedSpaceUnits);
+ }, "space units not to be "+expectedSpaceUnits, 10000);
}
it("should find .phcode.json preferences in the project", async function () {
diff --git a/test/spec/SpecRunnerUtils.js b/test/spec/SpecRunnerUtils.js
index 871d3938af..beef9a2aaa 100644
--- a/test/spec/SpecRunnerUtils.js
+++ b/test/spec/SpecRunnerUtils.js
@@ -54,6 +54,30 @@ define(function (require, exports, module) {
MainViewManager._initialize($("#mock-main-view"));
+ // When the test runner page reloads (e.g. switching test
+ // categories), terminate the test window's Node engine so
+ // its phnode.exe process and children (ESLint runners,
+ // terminal shells) don't become orphans that hold directory
+ // locks on Windows.
+ window.addEventListener("beforeunload", function () {
+ if (_testWindow && _testWindow.PhNodeEngine) {
+ try {
+ _testWindow.PhNodeEngine.terminateNode();
+ } catch (e) {
+ // ignore — test window may already be torn down
+ }
+ }
+ // Also terminate the SpecRunner's own PhNode process so it
+ // doesn't become an orphan on page reload.
+ if (window.PhNodeEngine) {
+ try {
+ window.PhNodeEngine.terminateNode();
+ } catch (e) {
+ // ignore
+ }
+ }
+ });
+
function _getFileSystem() {
return FileSystem;
}
diff --git a/test/spec/Terminal-integ-test.js b/test/spec/Terminal-integ-test.js
new file mode 100644
index 0000000000..9cc256f62e
--- /dev/null
+++ b/test/spec/Terminal-integ-test.js
@@ -0,0 +1,814 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/*global describe, it, expect, beforeAll, afterAll, afterEach, awaitsFor, spyOn */
+
+define(function (require, exports, module) {
+
+ if (!Phoenix.isNativeApp) {
+ return;
+ }
+
+ const SpecRunnerUtils = require("spec/SpecRunnerUtils");
+ const Strings = require("strings");
+
+ const IS_WINDOWS = Phoenix.platform === "win";
+ const IS_MAC = Phoenix.platform === "mac";
+
+ describe("integration:Terminal", function () {
+ let testWindow,
+ __PR,
+ WorkspaceManager,
+ testProjectPath;
+
+ const PANEL_ID = "terminal-panel";
+
+ beforeAll(async function () {
+ testWindow = await SpecRunnerUtils.createTestWindowAndRun();
+ __PR = testWindow.__PR;
+ WorkspaceManager = testWindow.brackets.test.WorkspaceManager;
+
+ // Create a real temp directory so the terminal has a
+ // physical native path to use as cwd.
+ testProjectPath = await SpecRunnerUtils.getTempTestDirectory(
+ "/spec/JSUtils-test-files"
+ );
+ await SpecRunnerUtils.loadProjectInTestWindow(testProjectPath);
+ }, 30000);
+
+ afterAll(async function () {
+ // Dispose all terminal PTY processes before teardown.
+ // panel.hide() keeps terminals alive by design, so we
+ // must explicitly kill them.
+ if (testWindow) {
+ try {
+ const termModule = testWindow.brackets.getModule(
+ "extensionsIntegrated/Terminal/main"
+ );
+ if (termModule && termModule._disposeAll) {
+ await termModule._disposeAll();
+ }
+ } catch (e) {
+ // test window may already be torn down
+ }
+ }
+ const panel = WorkspaceManager
+ ? WorkspaceManager.getPanelForID(PANEL_ID)
+ : null;
+ if (panel && panel.isVisible()) {
+ panel.hide();
+ }
+ testWindow = null;
+ __PR = null;
+ WorkspaceManager = null;
+ await SpecRunnerUtils.closeTestWindow();
+ }, 30000);
+
+ afterEach(async function () {
+ // If a test failed and left a dialog open, dismiss it
+ // so the next test starts from a clean state.
+ if (testWindow && isDialogOpen()) {
+ testWindow.$(".modal.instance .dialog-button")
+ .last().click();
+ try {
+ await awaitsFor(function () {
+ return !isDialogOpen();
+ }, "dialog to close", 3000);
+ } catch (e) {
+ // ignore — best-effort cleanup
+ }
+ }
+ });
+
+ // --- Helpers ---
+
+ async function openTerminal() {
+ await __PR.execCommand(__PR.Commands.VIEW_TERMINAL);
+ await awaitsFor(function () {
+ return testWindow.$("#terminal-panel").is(":visible");
+ }, "terminal panel to be visible", 10000);
+ }
+
+ function clickNewTerminal() {
+ testWindow.$(".terminal-flyout-new-btn").click();
+ }
+
+ function getTerminalCount() {
+ return testWindow.$(".terminal-flyout-item").length;
+ }
+
+ function clickPanelCloseButton() {
+ testWindow.$(
+ '.bottom-panel-tab[data-panel-id="terminal-panel"]'
+ + ' .bottom-panel-tab-close-btn'
+ ).click();
+ }
+
+ function isDialogOpen() {
+ return testWindow.$(".modal.instance").length >= 1;
+ }
+
+ function getDialogTitle() {
+ return testWindow.$(
+ ".modal.instance .dialog-title"
+ ).text();
+ }
+
+ function getDialogConfirmButtonText() {
+ return testWindow.$(
+ ".modal.instance .dialog-button.primary"
+ ).text();
+ }
+
+ /**
+ * Trigger a flyout process refresh so tab titles
+ * reflect the current foreground process.
+ */
+ function triggerFlyoutRefresh() {
+ testWindow.$(".terminal-tab-flyout")
+ .trigger("mouseenter");
+ }
+
+ /**
+ * Wait for the active terminal's shell to initialize.
+ * The flyout title text changes from "Terminal" to the
+ * shell name (e.g. "bash") once process info is fetched.
+ */
+ async function waitForShellReady() {
+ const termModule = testWindow.brackets.getModule(
+ "extensionsIntegrated/Terminal/main"
+ );
+ // Fail fast if the PTY never started
+ await awaitsFor(function () {
+ const active = termModule._getActiveTerminal();
+ return active && active.isAlive;
+ }, "terminal PTY to be alive", 10000);
+
+ // Then wait for process info
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const title = testWindow.$(
+ ".terminal-flyout-item.active "
+ + ".terminal-flyout-title"
+ ).text();
+ return title && title !== "Terminal";
+ }, "shell to initialize", 10000);
+ }
+
+ /**
+ * Wait for a child process (e.g. "node") to appear as
+ * the active terminal's foreground process in the flyout.
+ */
+ async function waitForActiveProcess(processName) {
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const title = testWindow.$(
+ ".terminal-flyout-item.active "
+ + ".terminal-flyout-title"
+ ).text();
+ return title && title.indexOf(processName) !== -1;
+ }, processName + " process to appear in flyout",
+ 15000);
+ }
+
+ /**
+ * Write data to the active terminal's PTY via the
+ * terminal extension's test helper.
+ */
+ async function writeToTerminal(text) {
+ const termModule = testWindow.brackets.getModule(
+ "extensionsIntegrated/Terminal/main"
+ );
+ await termModule._writeToActiveTerminal(text);
+ }
+
+ /**
+ * Get the native platform path for the loaded project.
+ * Mirrors the same VFS→native conversion the terminal uses.
+ */
+ function getNativeProjectPath() {
+ const Phoenix = testWindow.Phoenix;
+ const ProjectManager =
+ testWindow.brackets.test.ProjectManager;
+ const fullPath =
+ ProjectManager.getProjectRoot().fullPath;
+ const tauriPrefix = Phoenix.VFS.getTauriDir();
+ let nativePath;
+ if (fullPath.startsWith(tauriPrefix)) {
+ nativePath =
+ Phoenix.fs.getTauriPlatformPath(fullPath);
+ } else {
+ nativePath = fullPath;
+ }
+ // Strip trailing slash (terminal does the same)
+ if (nativePath.length > 1 &&
+ (nativePath.endsWith("/") ||
+ nativePath.endsWith("\\"))) {
+ nativePath = nativePath.slice(0, -1);
+ }
+ return nativePath;
+ }
+
+ // --- Tests ---
+
+ describe("Panel basics", function () {
+ it("should open terminal in the current project directory",
+ async function () {
+ await openTerminal();
+ expect(testWindow.$("#terminal-panel")
+ .is(":visible")).toBeTrue();
+ expect(getTerminalCount()).toBe(1);
+
+ if (IS_WINDOWS || IS_MAC) {
+ // On Windows, PowerShell/cmd set the title to
+ // their own executable path. On macOS, zsh does
+ // not emit title escape sequences by default.
+ // Just verify the shell started and updated its
+ // title from the default profile name.
+ await waitForShellReady();
+ const flyoutTitle = testWindow.$(
+ ".terminal-flyout-item.active"
+ ).attr("title") || "";
+ expect(flyoutTitle).not.toBe("");
+ } else {
+ // On Linux, verify the cwd by running `pwd`
+ // and checking the terminal buffer. This is
+ // more reliable than checking the terminal
+ // title, which depends on the shell's PS1
+ // including title-setting escape sequences.
+ await waitForShellReady();
+ await writeToTerminal("pwd\r");
+
+ const expectedPath = getNativeProjectPath();
+ const projectDirName = expectedPath
+ .split("/").pop().split("\\").pop();
+
+ const termModule = testWindow.brackets
+ .getModule(
+ "extensionsIntegrated/Terminal/main"
+ );
+ await awaitsFor(function () {
+ const active =
+ termModule._getActiveTerminal();
+ if (!active) {
+ return false;
+ }
+ const buffer =
+ active.terminal.buffer.active;
+ for (let i = 0; i < buffer.length; i++) {
+ const line = buffer.getLine(i);
+ if (line && line.translateToString()
+ .indexOf(projectDirName) !== -1) {
+ return true;
+ }
+ }
+ return false;
+ }, "pwd output to contain project dir",
+ 15000);
+ }
+ });
+
+ it("should close single idle terminal without dialog",
+ async function () {
+ if (!testWindow.$("#terminal-panel")
+ .is(":visible")) {
+ await openTerminal();
+ }
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "single terminal to exist", 5000);
+
+ await waitForShellReady();
+
+ clickPanelCloseButton();
+
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+
+ expect(isDialogOpen()).toBeFalse();
+ expect(getTerminalCount()).toBe(0);
+ });
+ });
+
+ describe("Close confirmation with multiple terminals",
+ function () {
+ it("should show close-all dialog and cancel keeps panel",
+ async function () {
+ await openTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "first terminal", 10000);
+
+ clickNewTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 2;
+ }, "second terminal", 10000);
+
+ await waitForShellReady();
+
+ clickPanelCloseButton();
+
+ await __PR.waitForModalDialog();
+
+ expect(getDialogTitle())
+ .toBe(Strings.TERMINAL_CLOSE_ALL_TITLE);
+ expect(getDialogConfirmButtonText())
+ .toBe(Strings.TERMINAL_CLOSE_ALL_BTN);
+
+ // Cancel
+ __PR.clickDialogButtonID(
+ __PR.Dialogs.DIALOG_BTN_CANCEL
+ );
+ await __PR.waitForModalDialogClosed();
+
+ expect(testWindow.$("#terminal-panel")
+ .is(":visible")).toBeTrue();
+ expect(getTerminalCount()).toBe(2);
+ });
+
+ it("should close all terminals when confirmed",
+ async function () {
+ // Still 2 terminals from previous test
+ expect(getTerminalCount()).toBe(2);
+
+ clickPanelCloseButton();
+ await __PR.waitForModalDialog();
+
+ __PR.clickDialogButtonID(
+ __PR.Dialogs.DIALOG_BTN_OK
+ );
+ await __PR.waitForModalDialogClosed();
+
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+
+ expect(getTerminalCount()).toBe(0);
+ });
+ });
+
+ describe("Close confirmation with active process", function () {
+ it("should show close-terminal dialog for single terminal",
+ async function () {
+ await openTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "terminal to be created", 10000);
+
+ await waitForShellReady();
+
+ // Start a long-running node process
+ await writeToTerminal(
+ 'node -e "setTimeout(()=>{},60000)"\r'
+ );
+ await waitForActiveProcess("node");
+
+ clickPanelCloseButton();
+
+ await __PR.waitForModalDialog();
+
+
+ expect(getDialogTitle())
+ .toBe(Strings.TERMINAL_CLOSE_SINGLE_TITLE);
+ expect(getDialogConfirmButtonText())
+ .toBe(Strings.TERMINAL_CLOSE_SINGLE_BTN);
+
+ // Cancel — terminal stays
+ __PR.clickDialogButtonID(
+ __PR.Dialogs.DIALOG_BTN_CANCEL
+ );
+ await __PR.waitForModalDialogClosed();
+
+ expect(testWindow.$("#terminal-panel")
+ .is(":visible")).toBeTrue();
+ expect(getTerminalCount()).toBe(1);
+
+ // Now confirm
+ clickPanelCloseButton();
+ await __PR.waitForModalDialog();
+ __PR.clickDialogButtonID(
+ __PR.Dialogs.DIALOG_BTN_OK
+ );
+ await __PR.waitForModalDialogClosed();
+
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "panel to close after confirm", 5000);
+
+ expect(getTerminalCount()).toBe(0);
+ });
+
+ it("should show stop-processes dialog with multiple terminals",
+ async function () {
+ await openTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "first terminal", 10000);
+
+ clickNewTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 2;
+ }, "second terminal", 10000);
+
+ await waitForShellReady();
+
+ await writeToTerminal(
+ 'node -e "setTimeout(()=>{},60000)"\r'
+ );
+ await waitForActiveProcess("node");
+
+ clickPanelCloseButton();
+
+ await __PR.waitForModalDialog();
+
+
+ expect(getDialogTitle())
+ .toBe(Strings.TERMINAL_CLOSE_ALL_TITLE);
+ expect(getDialogConfirmButtonText())
+ .toBe(Strings.TERMINAL_CLOSE_ALL_STOP_BTN);
+
+ // Cancel
+ __PR.clickDialogButtonID(
+ __PR.Dialogs.DIALOG_BTN_CANCEL
+ );
+ await __PR.waitForModalDialogClosed();
+
+ expect(getTerminalCount()).toBe(2);
+
+ // Confirm
+ clickPanelCloseButton();
+ await __PR.waitForModalDialog();
+ __PR.clickDialogButtonID(
+ __PR.Dialogs.DIALOG_BTN_OK
+ );
+ await __PR.waitForModalDialogClosed();
+
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "panel to close after confirm", 5000);
+
+ expect(getTerminalCount()).toBe(0);
+ });
+ });
+
+ describe("Terminal title management", function () {
+ it("should retain custom title while child process runs",
+ async function () {
+ await openTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "terminal to be created", 10000);
+
+ await waitForShellReady();
+
+ // Start a long-running node process that sets a
+ // custom terminal title via escape sequence.
+ await writeToTerminal(
+ 'node -e "process.stdout.write('
+ + "'\\x1b]0;MyAppTitle\\x07'"
+ + ');setTimeout(()=>{},60000)"\r'
+ );
+ await waitForActiveProcess("node");
+
+ // Verify the custom title appears
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const title = testWindow.$(
+ ".terminal-flyout-item.active"
+ ).attr("title") || "";
+ return title.indexOf("MyAppTitle") !== -1;
+ }, "custom title to appear", 10000);
+
+ // Trigger several flyout refreshes — the title
+ // must remain stable while the process runs.
+ triggerFlyoutRefresh();
+ const title = testWindow.$(
+ ".terminal-flyout-item.active"
+ ).attr("title") || "";
+ expect(title).toContain("MyAppTitle");
+
+ // Kill the node process so next test starts clean
+ await writeToTerminal("\x03"); // Ctrl+C
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const label = testWindow.$(
+ ".terminal-flyout-item.active "
+ + ".terminal-flyout-title"
+ ).text();
+ return label && label.indexOf("node") === -1;
+ }, "node process to exit", 10000);
+
+ // Clean up
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+
+ it("should clear stale title after child process exits",
+ async function () {
+ await openTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "terminal to be created", 10000);
+
+ await waitForShellReady();
+
+ // Start a node process that sets a custom title
+ // then exits after a short delay.
+ await writeToTerminal(
+ 'node -e "process.stdout.write('
+ + "'\\x1b]0;TestCustomTitle\\x07'"
+ + ');setTimeout(()=>{},3000)"\r'
+ );
+ await waitForActiveProcess("node");
+
+ // Verify the custom title appears in the flyout
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const title = testWindow.$(
+ ".terminal-flyout-item.active"
+ ).attr("title") || "";
+ return title.indexOf("TestCustomTitle") !== -1;
+ }, "custom title to appear", 10000);
+
+ // Wait for the node process to exit (3s timeout)
+ // and the flyout to reflect the shell again.
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const title = testWindow.$(
+ ".terminal-flyout-item.active"
+ ).attr("title") || "";
+ return title.indexOf("TestCustomTitle") === -1;
+ }, "stale title to be cleared after exit", 15000);
+
+ // Wait for the process info to update (async)
+ // so the flyout label reflects the shell, not the
+ // exited child process.
+ await awaitsFor(function () {
+ triggerFlyoutRefresh();
+ const lbl = testWindow.$(
+ ".terminal-flyout-item.active "
+ + ".terminal-flyout-title"
+ ).text();
+ return lbl && lbl.indexOf("node") === -1;
+ }, "flyout label to show shell instead of node",
+ 15000);
+
+ // The flyout label should be back to the shell
+ const label = testWindow.$(
+ ".terminal-flyout-item.active "
+ + ".terminal-flyout-title"
+ ).text();
+ expect(label).not.toBe("");
+ expect(label).not.toContain("node");
+
+ // Clean up
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+ });
+
+ describe("Context menu commands", function () {
+ let CommandManager;
+
+ function getActiveTerminal() {
+ const mod = testWindow.brackets.getModule(
+ "extensionsIntegrated/Terminal/main"
+ );
+ return mod._getActiveTerminal();
+ }
+
+ /**
+ * Check whether a marker string appears anywhere
+ * in the active terminal's buffer.
+ */
+ function bufferContains(marker) {
+ const active = getActiveTerminal();
+ if (!active) {
+ return false;
+ }
+ const buffer = active.terminal.buffer.active;
+ for (let i = 0; i < buffer.length; i++) {
+ const line = buffer.getLine(i);
+ if (line && line.translateToString()
+ .indexOf(marker) !== -1) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ beforeAll(function () {
+ CommandManager =
+ testWindow.brackets.test.CommandManager;
+ });
+
+ it("should clear the terminal screen",
+ async function () {
+ await openTerminal();
+ await waitForShellReady();
+
+ // Write some output so the terminal has content
+ await writeToTerminal("echo cleartest\r");
+ await awaitsFor(function () {
+ return bufferContains("cleartest");
+ }, "echo output to appear", 10000);
+
+ // Execute the clear command
+ await CommandManager.execute("terminal.clear");
+
+ // After clear, the marker should no longer be
+ // in the buffer (xterm.clear() wipes scrollback).
+ await awaitsFor(function () {
+ return !bufferContains("cleartest");
+ }, "terminal to be cleared", 5000);
+
+ // Clean up
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+
+ it("should copy selected terminal text to clipboard",
+ async function () {
+ await openTerminal();
+ await waitForShellReady();
+
+ // Write a unique marker string
+ await writeToTerminal("echo COPYMARKER123\r");
+ await awaitsFor(function () {
+ return bufferContains("COPYMARKER123");
+ }, "echo output to appear", 10000);
+
+ // Select all text in xterm
+ const active = getActiveTerminal();
+ active.terminal.selectAll();
+ expect(active.terminal.hasSelection())
+ .toBeTrue();
+ const selection = active.terminal.getSelection();
+ expect(selection).toContain("COPYMARKER123");
+
+ // The copy command writes to the system clipboard
+ // via navigator.clipboard.writeText(). In the test
+ // iframe clipboard writes may be denied (no focus),
+ // so we verify the command reads the right text by
+ // spying on writeText.
+ const clipboard = testWindow.navigator.clipboard;
+ let copiedText = null;
+ spyOn(clipboard, "writeText").and.callFake(
+ function (text) {
+ copiedText = text;
+ return testWindow.Promise.resolve();
+ }
+ );
+ await CommandManager.execute("terminal.copy");
+ expect(copiedText).toContain("COPYMARKER123");
+
+ // Clean up
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+
+ it("should paste clipboard text into terminal",
+ async function () {
+ await openTerminal();
+ await waitForShellReady();
+
+ // Mock clipboard.readText to return a known string,
+ // since the test iframe may not have clipboard
+ // permission (no window focus).
+ const pasteText = "PASTEMARKER456";
+ const clipboard = testWindow.navigator.clipboard;
+ spyOn(clipboard, "readText").and.returnValue(
+ testWindow.Promise.resolve(pasteText)
+ );
+
+ // Execute the paste command
+ await CommandManager.execute("terminal.paste");
+
+ // The pasted text should appear in the terminal
+ // buffer (written to PTY input → echoed back).
+ await awaitsFor(function () {
+ return bufferContains(pasteText);
+ }, "pasted text to appear in terminal", 10000);
+
+ // Clean up: press Enter then close
+ await writeToTerminal("\r");
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+
+ it("should disable copy when there is no selection",
+ async function () {
+ await openTerminal();
+ await waitForShellReady();
+
+ const active = getActiveTerminal();
+ // Ensure no selection
+ active.terminal.clearSelection();
+ expect(active.terminal.hasSelection())
+ .toBeFalse();
+
+ // Open context menu to trigger
+ // beforeContextMenuOpen event
+ const Menus = testWindow.brackets.test.Menus;
+ const ctxMenu = Menus.getContextMenu(
+ "terminal-context-menu"
+ );
+ ctxMenu.open({pageX: 100, pageY: 100});
+
+ const copyCmd =
+ CommandManager.get("terminal.copy");
+ expect(copyCmd.getEnabled()).toBeFalse();
+
+ // Close menu
+ ctxMenu.close();
+
+ // Now select text and re-open
+ active.terminal.selectAll();
+ ctxMenu.open({pageX: 100, pageY: 100});
+ expect(copyCmd.getEnabled()).toBeTrue();
+ ctxMenu.close();
+
+ // Clean up
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+ });
+
+ describe("Programmatic hide vs user close", function () {
+ it("should keep terminals alive after panel.hide()",
+ async function () {
+ await openTerminal();
+ await awaitsFor(function () {
+ return getTerminalCount() === 1;
+ }, "terminal to be created", 10000);
+
+ const panel =
+ WorkspaceManager.getPanelForID(PANEL_ID);
+ panel.hide();
+
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to hide", 5000);
+
+ expect(isDialogOpen()).toBeFalse();
+
+ // Re-show — terminal should still exist
+ panel.show();
+ await awaitsFor(function () {
+ return testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to show again", 5000);
+
+ expect(getTerminalCount()).toBe(1);
+
+ // Clean up
+ clickPanelCloseButton();
+ await awaitsFor(function () {
+ return !testWindow.$("#terminal-panel")
+ .is(":visible");
+ }, "terminal panel to close", 5000);
+ });
+ });
+ });
+});