my_wins 1.4.0 → 1.5.1

package/docs/conemu.md

@@ -0,0 +1,40 @@
+# ConEmu integration
+
+`my_wins` can open console commands in `ConEmu` tabs instead of separate system `cmd.exe` windows.
+
+## How it works
+
+- Top-level `conemu` in `my_wins.json` points to `ConEmu.exe` or `ConEmu64.exe`.
+- When `conemu` is configured, console wins use `ConEmu` by default.
+- Per-win `conemu: true|false` overrides the default.
+- New tabs are created through `ConEmu` shell/macros.
+- After tab creation, `my_wins` explicitly renames the visible ConEmu tab caption to the win `title`.
+- The internal console title may still change while commands run, but the ConEmu tab caption should stay stable.
+
+## Example
+
+```json5
+{
+  conemu: "D:\\ProgsReady\\ConEmu\\ConEmu64.exe",
+  wins: {
+    api: {
+      title: "API",
+      cmd: "npm run dev"
+    },
+    worker: {
+      title: "Worker",
+      cmd: "npm run worker"
+    },
+    plain_cmd: {
+      conemu: false,
+      cmd: "echo this one uses a normal cmd window"
+    }
+  }
+}
+```
+
+## Current limitations
+
+- `ConEmu` support is Windows-only.
+- Background color for `ConEmu` tabs is applied after the tab is activated.
+- Automated integration testing for `ConEmu` is skipped if `ConEmu` is not installed at the expected test path.

package/lib/index.js

@@ -1,5 +1,6 @@
 const { spawn, execFile, exec } = require("child_process");
 const fs = require("fs");
+const path = require("path");
 const JSON5 = require("json5");
 const inquirer = require("inquirer");
 const keysender = require("@sumbat/keysender");
@@ -42,6 +43,211 @@ function awaitDelay(delay) {
 	});
 }
 
+function execFileAsync(file, args, options) {
+	return new Promise((resolve, reject)=>{
+		execFile(file, args, options || {}, (error, stdout, stderr)=>{
+			if (error) {
+				error.stdout = stdout;
+				error.stderr = stderr;
+				reject(error);
+				return;
+			}
+			resolve({ stdout, stderr });
+		});
+	});
+}
+
+function toPowerShellSingleQuotedString(value) {
+	return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function buildConEmuCreateTabCommand(win) {
+	const titleCommand = `title ${win.matchTitle}`;
+	return {
+		titleCommand,
+	};
+}
+
+function getConEmuInfo(settings) {
+	if (!settings.conemu) return null;
+
+	const guiPath = path.resolve(settings.conemu);
+	const baseDir = path.dirname(guiPath);
+	const helperName = /64\.exe$/i.test(guiPath) ? "ConEmuC64.exe" : "ConEmuC.exe";
+	const helperCandidates = [
+		path.join(baseDir, helperName),
+		path.join(baseDir, "ConEmu", helperName),
+	];
+	const macroPath = helperCandidates.find((candidate)=>fs.existsSync(candidate));
+
+	if (!fs.existsSync(guiPath)) {
+		throw new Error(`ConEmu executable not found: ${guiPath}`);
+	}
+	if (!macroPath) {
+		throw new Error(`ConEmu GuiMacro executable not found near: ${guiPath}`);
+	}
+
+	return {
+		guiPath,
+		macroPath,
+		guiPid: null,
+	};
+}
+
+function shouldUseConEmuForWin(settings, win, conemuInfo) {
+	if (!conemuInfo) return false;
+	if (!win || win.app) return false;
+	if (typeof win.conemu === "boolean") return win.conemu;
+	return true;
+}
+
+async function execConEmuMacro(conemu, macro, tabIndex) {
+	if (!conemu || !conemu.guiPid) throw new Error("ConEmu GUI PID is not initialized");
+	const guiMacroTarget = tabIndex ? `-GuiMacro:${conemu.guiPid}:T${tabIndex}` : `-GuiMacro:${conemu.guiPid}`;
+	const command = [
+		"&",
+		toPowerShellSingleQuotedString(conemu.macroPath),
+		toPowerShellSingleQuotedString(guiMacroTarget),
+		toPowerShellSingleQuotedString(macro),
+	].join(" ");
+	const result = await execFileAsync("powershell", ["-NoProfile", "-Command", command]);
+	return (result.stdout || "").trim();
+}
+
+async function execConEmuCommand(conemu, command, commandArgs, tabIndex) {
+	const serializedArgs = (commandArgs || []).map((arg)=>{
+		if (typeof arg === "number") return String(arg);
+		return `"${String(arg).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+	});
+	return execConEmuMacro(conemu, `${command}(${serializedArgs.join(",")})`, tabIndex);
+}
+
+async function findConEmuGuiPidByActiveTitle(title) {
+	if (!title) return null;
+	const titleMask = `*${title}*`;
+	const command = [
+		"(",
+		"Get-Process ConEmu64,ConEmu -ErrorAction SilentlyContinue",
+		`| Where-Object { $_.MainWindowHandle -ne 0 -and $_.MainWindowTitle -like ${toPowerShellSingleQuotedString(titleMask)} }`,
+		"| Sort-Object Id -Descending",
+		"| Select-Object -First 1 -ExpandProperty Id",
+		")",
+	].join(" ");
+	const result = await execFileAsync("powershell", ["-NoProfile", "-Command", command]);
+	const pid = parseInt((result.stdout || "").trim(), 10);
+	return Number.isFinite(pid) ? pid : null;
+}
+
+async function listConEmuGuiPids() {
+	const command = [
+		"(",
+		"Get-Process ConEmu64,ConEmu -ErrorAction SilentlyContinue",
+		"| Where-Object { $_.MainWindowHandle -ne 0 -and $_.MainWindowTitle -notlike 'About ConEmu*' }",
+		"| Sort-Object Id",
+		"| Select-Object -ExpandProperty Id",
+		")",
+	].join(" ");
+	const result = await execFileAsync("powershell", ["-NoProfile", "-Command", command]);
+	return (result.stdout || "")
+		.split(/\r?\n/)
+		.map((line)=>parseInt(line.trim(), 10))
+		.filter((pid)=>Number.isFinite(pid));
+}
+
+async function listConEmuTabsByPid(guiPid, macroPath) {
+	const command = [
+		"&",
+		toPowerShellSingleQuotedString(macroPath),
+		toPowerShellSingleQuotedString(`-GuiMacro:${guiPid}`),
+		toPowerShellSingleQuotedString("Tab(12)"),
+	].join(" ");
+	const result = await execFileAsync("powershell", ["-NoProfile", "-Command", command]);
+	return String(result.stdout || "")
+		.split(/\r?\n/)
+		.map((line)=>line.trim())
+		.filter(Boolean);
+}
+
+async function waitForConEmuGuiPid(title, timeoutMs, beforePids) {
+	const started = Date.now();
+	const knownBefore = new Set(beforePids || []);
+	while (Date.now() - started < timeoutMs) {
+		const pid = await findConEmuGuiPidByActiveTitle(title);
+		if (pid) return pid;
+
+		const currentPids = await listConEmuGuiPids();
+		const newPid = currentPids.find((currentPid)=>!knownBefore.has(currentPid));
+		if (newPid) return newPid;
+		if (currentPids.length === 1) return currentPids[0];
+		if (currentPids.length > 1) return currentPids[currentPids.length - 1];
+		await awaitDelay(200);
+	}
+	throw new Error(`Couldn't find ConEmu GUI window for title '${title}'`);
+}
+
+async function launchConEmuTab(conemu, win, isFirstTab) {
+	const { titleCommand } = buildConEmuCreateTabCommand(win);
+	if (isFirstTab) {
+		const beforePids = await listConEmuGuiPids();
+		const beforePid = beforePids.length ? beforePids[beforePids.length - 1] : null;
+		const beforeTabs = beforePid ? await listConEmuTabsByPid(beforePid, conemu.macroPath) : [];
+		const childArgs = ["-run", "cmd.exe", "/k", titleCommand];
+		const child = spawn(conemu.guiPath, childArgs, {
+			detached: true,
+			stdio: "ignore",
+		});
+		child.unref();
+		conemu.guiPid = await waitForConEmuGuiPid(null, 10000, beforePids);
+		const afterTabs = await listConEmuTabsByPid(conemu.guiPid, conemu.macroPath);
+		const tabIndex = afterTabs.length > beforeTabs.length ? afterTabs.length : afterTabs.length;
+		await renameConEmuTab(conemu, tabIndex, win.tabTitle);
+		return tabIndex;
+	}
+
+	const beforeTabs = await listConEmuTabsByPid(conemu.guiPid, conemu.macroPath);
+	await execConEmuCommand(conemu, "Shell", ["new_console", "cmd.exe", `/k ${titleCommand}`]);
+	await awaitDelay(300);
+	const afterTabs = await listConEmuTabsByPid(conemu.guiPid, conemu.macroPath);
+	const tabIndex = afterTabs.length > beforeTabs.length ? afterTabs.length : afterTabs.length;
+	await renameConEmuTab(conemu, tabIndex, win.tabTitle);
+	return tabIndex;
+}
+
+async function activateConEmuTab(conemu, tabIndex) {
+	await execConEmuCommand(conemu, "Tab", [7, tabIndex]);
+	await awaitDelay(150);
+}
+
+async function renameConEmuTab(conemu, tabIndex, tabTitle) {
+	if (!tabTitle) return;
+	await execConEmuCommand(conemu, "Rename", [1, tabTitle], tabIndex);
+	await awaitDelay(150);
+}
+
+async function stabilizeConEmuTabTitle(conemu, win) {
+	if (!conemu || !win || !win.conemuTabIndex || !win.tabTitle) return;
+	await awaitDelay(500);
+	await renameConEmuTab(conemu, win.conemuTabIndex, win.tabTitle);
+	await awaitDelay(1000);
+	await renameConEmuTab(conemu, win.conemuTabIndex, win.tabTitle);
+}
+
+async function setConEmuBackgroundColor(conemu, tabIndex, backgroundcolor) {
+	if (!backgroundcolor) return;
+	await execConEmuCommand(conemu, "SetOption", ["bgImage", backgroundcolor], tabIndex);
+	await awaitDelay(150);
+}
+
+async function printInConEmuTab(conemu, tabIndex, cmd) {
+	await execConEmuCommand(conemu, "Print", [cmd], tabIndex);
+	await awaitDelay(200);
+}
+
+async function pressEnterInConEmuTab(conemu, tabIndex) {
+	await execConEmuCommand(conemu, "Keys", ["Enter"], tabIndex);
+	await awaitDelay(200);
+}
+
 function parseArgs(argv) {
 	const raw = argv.slice(2);
 	let menu = false;
@@ -150,7 +356,8 @@ function buildRunSettings(baseSettings, filterNames) {
 	for(let k in settings.wins) {
 		const w = settings.wins[k];
 		w.name = k;
-		w.title = w.name+randSuffix()
+		w.tabTitle = w.title || w.name;
+		w.matchTitle = `my_wins_${w.name.replace(/[^\w.-]+/g, "_")}${randSuffix()}`;
 	}
 
 	return settings;
@@ -159,17 +366,23 @@ function buildRunSettings(baseSettings, filterNames) {
 async function runOnce(baseSettings, filterNames) {
 	const settings = buildRunSettings(baseSettings, filterNames);
 	if (!Object.keys(settings.wins).length) return;
+	const conemu = getConEmuInfo(settings);
 
 	let wins = keysender.getAllWindows();
+	let createdConsoleCount = 0;
 
 	for(let k in settings.wins) {
 		const w = settings.wins[k];
-		const {name, title, app, no_run, cmd} = w;
+		const {name, app, no_run, cmd} = w;
+		const useConEmu = shouldUseConEmuForWin(settings, w, conemu);
 		if(app && !no_run) {
 			exec(cmd);
 			delete settings.wins[k];
+		} else if (useConEmu) {
+			w.conemuTabIndex = await launchConEmuTab(conemu, w, createdConsoleCount === 0);
+			createdConsoleCount++;
 		} else
-			exec(`start cmd.exe @cmd /k "title ${title}"`);
+			exec(`start cmd.exe @cmd /k "title ${w.matchTitle}"`);
 	}
 
 	await awaitDelay(settings.startTimeout || 1500);
@@ -181,14 +394,34 @@ async function runOnce(baseSettings, filterNames) {
 	let winIndex = 0;
 	for(let k in settings.wins) {
 		const w = settings.wins[k];
-		const {name, title, app, cmd, no_run, delay} = w;
+		const {name, app, cmd, no_run, delay} = w;
+		const useConEmu = shouldUseConEmuForWin(settings, w, conemu);
 
-		let win_info_candidates = wins.filter(c => c.title.includes(title));
+		let win_info_candidates = wins.filter(c => c.title.includes(w.matchTitle));
 		const win_info = win_info_candidates[0];
 
-		if (!win_info) console.warn(`CODE00000000 Couldn't find window ${title}`);
+		if (useConEmu) {
+			w.winIndex = winIndex;
+			w.view = winsArray[winIndex];
+			await setConEmuBackgroundColor(conemu, w.conemuTabIndex, w.backgroundcolor);
+
+			w.activate = async ()=>{
+				await activateConEmuTab(conemu, w.conemuTabIndex);
+			};
+
+			w.print = async (nextCmd) => {
+				await printInConEmuTab(conemu, w.conemuTabIndex, nextCmd);
+			};
+
+			w.pressEnter = async  () => {
+				await pressEnterInConEmuTab(conemu, w.conemuTabIndex);
+			};
+
+			await w.print(cmd);
+		}
+		else if (!win_info) console.warn(`CODE00000000 Couldn't find window ${w.matchTitle}`);
 		else if (win_info_candidates.length > 1)
-			console.warn(`CODE00000000 There are ${win_info_candidates.length} windows with title '${title}'. Only one window expected!`);
+			console.warn(`CODE00000000 There are ${win_info_candidates.length} windows with title '${w.matchTitle}'. Only one window expected!`);
 		else {
 			const win = new keysender.Hardware(win_info.handle);
 			w.win = win;
@@ -214,14 +447,6 @@ async function runOnce(baseSettings, filterNames) {
 			}
 
 			await w.print(cmd);
-			// await awaitDelay(200);
-			// if(!no_run) {
-			// 	if(delay) {
-			// 		await awaitDelay(delay);
-			// 	}
-			// 	w.pressEnter();
-			// }
-			// await awaitDelay(300);
 		}
 		winIndex++;
 	}
@@ -234,6 +459,9 @@ async function runOnce(baseSettings, filterNames) {
 					await awaitDelay(delay);
 				}
 				await w.pressEnter();
+				if (shouldUseConEmuForWin(settings, w, conemu)) {
+					await stabilizeConEmuTabTitle(conemu, w);
+				}
 			}
 		}
 
@@ -262,6 +490,7 @@ async function promptMenu(winNames, exitChecked) {
 }
 
 module.exports.defaultSettings = defaultSettings;
+module.exports.shouldUseConEmuForWin = shouldUseConEmuForWin;
 module.exports.run = async ()=>{
 	const args = parseArgs(process.argv);
 	if (args.version) {

package/package.json

@@ -1,37 +1,37 @@
 {
-  "name": "my_wins",
-  "version": "1.4.0",
-  "description": "Automates starting and laying out your console windows for tsc, babel, tests, verdaccio, etc...",
-  "keywords": [
-    "automation",
-    "cmd",
-    "keysender",
-    "windows",
-    "autostart",
-    "autorun"
-  ],
-  "main": "./index.js",
-  "bin": {
-    "my_wins": "bin/index.js"
-  },
-  "scripts": {
-    "start": "node index.js",
-    "startm": "node index.js -m",
-    "test": "node test/run-test.js"
-  },
-  "author": "Yuri Yaryshev",
-  "license": "Unlicense",
-  "dependencies": {
-    "@sumbat/keysender": "^2.3.0",
-    "inquirer": "^13.2.1",
-    "json5": "^2.2.3"
-  },
-  "devDependencies": {
-    "prettier": "^3.8.1"
-  },
-  "homepage": "https://github.com/yuyaryshev/my_wins",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yuyaryshev/my_wins.git"
-  }
-}
+    "name": "my_wins",
+    "version": "1.5.1",
+    "description": "Automates starting and laying out your console windows for tsc, babel, tests, verdaccio, etc...",
+    "keywords": [
+        "automation",
+        "cmd",
+        "keysender",
+        "windows",
+        "autostart",
+        "autorun"
+    ],
+    "main": "./index.js",
+    "bin": {
+        "my_wins": "bin/index.js"
+    },
+    "scripts": {
+        "start": "node index.js",
+        "startm": "node index.js -m",
+        "test": "node test/run-test.js"
+    },
+    "author": "Yuri Yaryshev",
+    "license": "Unlicense",
+    "dependencies": {
+        "@sumbat/keysender": "^2.3.0",
+        "inquirer": "^13.2.1",
+        "json5": "^2.2.3"
+    },
+    "devDependencies": {
+        "prettier": "^3.8.1"
+    },
+    "homepage": "https://github.com/yuyaryshev/my_wins",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/yuyaryshev/my_wins.git"
+    }
+}

package/readme.md

@@ -4,6 +4,9 @@ Automates starting your console windows for tsc, babel, tests, verdaccio, etc...
 
 my_wins opens **cmd** promts for you, position them nicely and types-in your commands into them.
 
+If you set `conemu`, my_wins will open tabs in that ConEmu instance instead of separate system `cmd` windows.
+Project docs are gradually being collected in [`docs`](./docs).
+
 ## Why?
 
 Why this is better than just running cmd/bat files?
@@ -35,9 +38,11 @@ Create "my_wins.json" in your project with contents:
 
 ```json
 {
+	"conemu": "D:\\ProgsReady\\ConEmu\\ConEmu64.exe",
 	"wins": {
 		"cmd1": "echo cm1",
-		"cmd2": "echo cmd2"
+		"cmd2": { "cmd": "echo cmd2", "conemu": false },
+		"cmd3": { "cmd": "echo cmd3", "conemu": true }
 	}
 }
 ```
@@ -104,13 +109,15 @@ It's recommended to gitignore "my_wins_personal.json".
 ```json
     {
         "startTimeout": 700,
+        "conemu": "D:\\ProgsReady\\ConEmu\\ConEmu64.exe",
         "x": 0,           
         "y": 0,         
         "height": 120,    
         "width": 500,     
         "wins": {          
             "foo":"my command line 1",
-            "baz":{"no_run":true, "cmd":"my command line 2"},
+            "baz":{"no_run":true, "cmd":"my command line 2", "conemu":false},
+            "qux":{"cmd":"my command line 3", "conemu":true},
             "webstorm": {"app":true, "cmd":"\"C:\\Program Files\\JetBrains\\WebStorm 2019.2\\bin\\webstorm64.exe\""} // notice escaped quotes !
             // "commented": "Comments and trailing commas are supported!",
         },
@@ -118,12 +125,16 @@ It's recommended to gitignore "my_wins_personal.json".
 ```
 **x,y,height,width** *number* - is first cmd window's position and size
 
+**conemu** *string* - optional full path to `ConEmu.exe` or `ConEmu64.exe`. When present, console commands use ConEmu by default and are sent through ConEmu GuiMacro instead of the window key sender.
+ConEmu tabs keep their visible title from the win `title` field even if commands later change the internal console title.
+
 **y** gets incremented by **height** for each next window
 
 **wins** *object*- your windows
 
 - if you enter a string it resolves to `{"cmd":"string"}`
 - **cmd** *string* - your command
+- **conemu** *boolean* - optional per-win override. `true` forces this win into ConEmu, `false` forces it into a normal system `cmd` window.
 - **no_run** *boolean* - types in the command, but won't hit "Enter".
 - **app** *boolean* - runs yours command as Windows application, not as console. (Incompartible with "no_run").
 

package/republish.bat

@@ -1 +1 @@
-npm publish && npm uninstall -g my_wins && npm install -g my_wins && my_wins
+version-select && npm publish && npm uninstall -g my_wins && npm install -g my_wins && my_wins

package/test/run-test.js

@@ -1,10 +1,15 @@
-const { spawn } = require("child_process");
+const { spawn, execFileSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
+const { shouldUseConEmuForWin } = require("../lib");
 
 const repoRoot = path.resolve(__dirname, "..");
 const tempDir = path.join(repoRoot, "temp");
-const testFile = path.join(tempDir, "my_wins_test.txt");
+const conemuTestFile = path.join(tempDir, "my_wins_conemu_test.txt");
+const conemuPath = "D:\\ProgsReady\\ConEmu\\ConEmu64.exe";
+const conemuTabTitle = "My Wins Visible Title";
+const conemuRuntimeTitle = "Changed By Command";
+const conemuBackgroundColor = "#123456";
 
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
@@ -20,29 +25,88 @@ async function waitForFile(filePath, timeoutMs) {
 }
 
 async function run() {
+	const fakeConEmu = { guiPath: conemuPath };
+	if (shouldUseConEmuForWin({ conemu: conemuPath }, { cmd: "echo default" }, fakeConEmu) !== true) {
+		throw new Error("Expected wins to use ConEmu by default when top-level conemu path is set");
+	}
+	if (shouldUseConEmuForWin({ conemu: conemuPath }, { cmd: "echo plain", conemu: false }, fakeConEmu) !== false) {
+		throw new Error("Expected win-level conemu:false to force a normal cmd window");
+	}
+	if (shouldUseConEmuForWin({ conemu: conemuPath }, { cmd: "echo tab", conemu: true }, fakeConEmu) !== true) {
+		throw new Error("Expected win-level conemu:true to force ConEmu");
+	}
+	if (shouldUseConEmuForWin({}, { cmd: "echo plain", conemu: true }, null) !== false) {
+		throw new Error("Expected win-level conemu:true to be ignored when no top-level ConEmu path is configured");
+	}
 	fs.mkdirSync(tempDir, { recursive: true });
-	if (fs.existsSync(testFile)) fs.unlinkSync(testFile);
-	if (fs.existsSync(testFile)) {
-		throw new Error(`Expected test file to be deleted: ${testFile}`);
+	if (fs.existsSync(conemuTestFile)) fs.unlinkSync(conemuTestFile);
+	if (fs.existsSync(conemuTestFile)) {
+		throw new Error(`Expected test file to be deleted: ${conemuTestFile}`);
 	}
 
-	const child = spawn("node", ["index.js", "--run", "test_file"], {
-		cwd: repoRoot,
+	if (!fs.existsSync(conemuPath)) {
+		console.log(`Skipping ConEmu integration test because ConEmu was not found at ${conemuPath}`);
+		return;
+	}
+
+	const conemuProjectDir = path.join(tempDir, "conemu-project");
+	fs.mkdirSync(conemuProjectDir, { recursive: true });
+	fs.writeFileSync(
+		path.join(conemuProjectDir, "my_wins.json"),
+		JSON.stringify(
+			{
+				conemu: conemuPath,
+				startTimeout: 2200,
+				wins: {
+					test_conemu: {
+						title: conemuTabTitle,
+						backgroundcolor: conemuBackgroundColor,
+						cmd: `title ${conemuRuntimeTitle} && echo my_wins conemu test> ${conemuTestFile} && ping -n 12 127.0.0.1 > nul`,
+					},
+				},
+			},
+			null,
+			2,
+		),
+	);
+
+	const conemuChild = spawn("node", [path.join(repoRoot, "index.js"), "--run", "test_conemu"], {
+		cwd: conemuProjectDir,
 		stdio: "inherit",
 	});
 
-	const exitCode = await new Promise((resolve, reject) => {
-		child.on("error", reject);
-		child.on("close", resolve);
+	const conemuExitCode = await new Promise((resolve, reject) => {
+		conemuChild.on("error", reject);
+		conemuChild.on("close", resolve);
 	});
 
-	if (exitCode !== 0) {
-		throw new Error(`my_wins exited with code ${exitCode}`);
+	if (conemuExitCode !== 0) {
+		throw new Error(`my_wins ConEmu run exited with code ${conemuExitCode}`);
+	}
+
+	const conemuCreated = await waitForFile(conemuTestFile, 10000);
+	if (!conemuCreated) {
+		throw new Error(`Expected ConEmu test file to exist: ${conemuTestFile}`);
 	}
 
-	const created = await waitForFile(testFile, 8000);
-	if (!created) {
-		throw new Error(`Expected test file to exist: ${testFile}`);
+	const macroPath = path.join(path.dirname(conemuPath), "ConEmu", "ConEmuC64.exe");
+	const guiPidsRaw = execFileSync("powershell", [
+		"-NoProfile",
+		"-Command",
+		"(Get-Process ConEmu64,ConEmu -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowHandle -ne 0 -and $_.MainWindowTitle -notlike 'About ConEmu*' } | Sort-Object Id -Descending | Select-Object -ExpandProperty Id)",
+	], { encoding: "utf8" }).trim();
+	const guiPids = guiPidsRaw
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const tabsByPid = guiPids.map((guiPid) => ({
+		guiPid,
+		tabs: execFileSync(macroPath, [`-GuiMacro:${guiPid}`, "Tab(12)"], { encoding: "utf8" }),
+	}));
+	const matchingWindow = tabsByPid.find((entry) => entry.tabs.includes(conemuTabTitle));
+	if (!matchingWindow) {
+		const allTabs = tabsByPid.map((entry) => `[${entry.guiPid}]\n${entry.tabs}`).join("\n---\n");
+		throw new Error(`Expected some ConEmu tabs list to include visible title '${conemuTabTitle}', got: ${allTabs}`);
 	}
 }