@bobfrankston/winpos 2.0.20

package/index.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * tswinpos - TypeScript Windows Positioning Utility
+ * Cross-platform Node.js/Bun implementation with FFI
+ */
+
+import { user32, RECT } from './ffi-wrapper.js';
+import { enumerateScreens, sortScreens, ScreenInfo } from './screens.js';
+import {
+    enumerateWindows,
+    findWindowsByPattern,
+    loadIgnorePatterns,
+    WindowInfo,
+    WindowState,
+    getWindowState,
+    setWindowState,
+    isMinimized,
+    isMaximized,
+    isNormal,
+    minimizeWindow,
+    maximizeWindow,
+    restoreWindow
+} from './windows.js';
+import { enumerateTabs, TabInfo, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
+import { join } from 'path';
+import * as packageJson from './package.json' with { type: 'json' };
+
+// Re-export public API for library usage
+export {
+    RECT,
+    ScreenInfo,
+    WindowInfo,
+    WindowState,
+    TabInfo,
+    enumerateScreens,
+    sortScreens,
+    enumerateWindows,
+    findWindowsByPattern,
+    getWindowState,
+    setWindowState,
+    isMinimized,
+    isMaximized,
+    isNormal,
+    minimizeWindow,
+    maximizeWindow,
+    restoreWindow,
+    enumerateTabs,
+    mightHaveTabs,
+    TAB_ENUMERATION_NOTE,
+    user32
+};
+
+let dbg = false;
+let screens: ScreenInfo[] = [];
+
+function parseDimension(input: string, fullDimension: number): number {
+    if (input.endsWith('%')) {
+        const percentage = parseFloat(input.slice(0, -1)) / 100.0;
+        return Math.floor(fullDimension * percentage);
+    }
+    const val = parseInt(input, 10);
+    return val < 0 ? fullDimension + val : val;
+}
+
+function adjustWindow(args: string[]) {
+    const windowTitle = args[0];
+
+    // Check if user wants to minimize the window (min or -min in position)
+    const shouldMinimize = args[1].toLowerCase() === 'min' || args[1].toLowerCase() === '-min';
+
+    if (shouldMinimize) {
+        if (dbg)
+            console.log(`Minimizing window '${windowTitle}'`);
+
+        let matchedWindows = findWindowsByPattern(windowTitle);
+
+        // Filter out command windows running tswinpos
+        matchedWindows = matchedWindows.filter(w => !w.title.toLowerCase().includes('tswinpos'));
+
+        for (const window of matchedWindows) {
+            if (dbg)
+                console.log(`Minimizing window '${window.title}'`);
+
+            minimizeWindow(window.hwnd);
+        }
+
+        if (matchedWindows.length === 0)
+            console.log(`No windows found matching '${windowTitle}'.`);
+
+        return;
+    }
+
+    const screenIndex = parseInt(args[3], 10);
+
+    if (screenIndex < 0 || screenIndex >= screens.length) {
+        usage(`Invalid screen number: ${screenIndex}. Must be between 0 and ${screens.length - 1}`);
+        return;
+    }
+
+    const targetScreen = screens[screenIndex];
+    const bounds = targetScreen.bounds;
+
+    const x = parseDimension(args[1], bounds.Width) + bounds.Left;
+    const y = parseDimension(args[2], bounds.Height) + bounds.Top;
+    let width = args.length > 4 ? parseDimension(args[4], bounds.Width) : 0;
+    let height = args.length > 5 ? parseDimension(args[5], bounds.Height) : 0;
+
+    if (dbg)
+        console.log(`Trying window '${windowTitle}'`);
+
+    let matchedWindows = findWindowsByPattern(windowTitle);
+
+    // Filter out command windows running tswinpos
+    matchedWindows = matchedWindows.filter(w => !w.title.toLowerCase().includes('tswinpos'));
+
+    for (const window of matchedWindows) {
+        if (dbg)
+            console.log(`Moving window '${window.title}' to (${x}, ${y}) on screen ${screenIndex}.`);
+
+        if (width === 0)
+            width = window.rect.Right - window.rect.Left;
+        if (height === 0)
+            height = window.rect.Bottom - window.rect.Top;
+
+        // Restore window if minimized or maximized to ensure it moves to the correct position
+        if (isMinimized(window.hwnd) || isMaximized(window.hwnd)) {
+            restoreWindow(window.hwnd);
+        }
+
+        user32.MoveWindow(window.hwnd, x, y, width, height, true);
+        user32.SetForegroundWindow(window.hwnd);
+    }
+
+    if (matchedWindows.length === 0)
+        console.log(`No windows found matching '${windowTitle}'.`);
+}
+
+function getScreenForWindow(windowRect: RECT): number {
+    // Find which screen contains the center of the window
+    const centerX = (windowRect.Left + windowRect.Right) / 2;
+    const centerY = (windowRect.Top + windowRect.Bottom) / 2;
+
+    for (let i = 0; i < screens.length; i++) {
+        const screen = screens[i];
+        if (centerX >= screen.bounds.Left && centerX < screen.bounds.Right &&
+            centerY >= screen.bounds.Top && centerY < screen.bounds.Bottom) {
+            return i;
+        }
+    }
+
+    // If not found, return the primary screen (or first screen)
+    return screens.findIndex(s => s.primary) || 0;
+}
+
+function listAllWindows(includeIgnored: boolean = false) {
+    console.log('====================================');
+    console.log('Screens');
+    for (let i = 0; i < screens.length; i++) {
+        const screen = screens[i];
+        console.log(`${i} Screen: ${screen.deviceName} (${screen.bounds.Top}/${screen.bounds.Bottom}x${screen.bounds.Left}/${screen.bounds.Right})`);
+    }
+    console.log();
+
+    const windows = enumerateWindows(includeIgnored).sort((a, b) => a.title.localeCompare(b.title));
+
+    console.log('Title                                           X      Y    Scr   Width  Height');
+    console.log('-----------------------------------------------------------------------------------');
+    for (const window of windows) {
+        const screenIndex = getScreenForWindow(window.rect);
+        const screen = screens[screenIndex];
+
+        // Normalize coordinates relative to the screen
+        const x = window.rect.Left - screen.bounds.Left;
+        const y = window.rect.Top - screen.bounds.Top;
+        const width = window.rect.Right - window.rect.Left;
+        const height = window.rect.Bottom - window.rect.Top;
+
+        // Truncate title if too long
+        const title = window.title.length > 45 ? window.title.substring(0, 42) + '...' : window.title;
+
+        console.log(`${title.padEnd(45)} ${x.toString().padStart(6)} ${y.toString().padStart(6)} ${screenIndex.toString().padStart(5)} ${width.toString().padStart(7)} ${height.toString().padStart(7)}`);
+    }
+    console.log();
+    console.log('Command format: tswinpos <title> <x> <y> <screen> [<width> <height>]');
+}
+
+function usage(msg: string = '') {
+    if (msg)
+        console.log(msg);
+
+    console.log('Usage: tswinpos [-d -c -version *] <window title> <x> <y> <screen> [<width> <height>]');
+    console.log('       tswinpos <window title> min | -min');
+    console.log('  -d debug, -c return count, -version (or -v) show version');
+    console.log('  where <screen> is a number from 0 to N-1, where N is the number of screens.');
+    console.log('  <x> and <y> can be a number of pixels or a percentage (e.g. 50%)');
+    console.log('  Use "min" or "-min" in place of <x> to minimize the window to the taskbar');
+    console.log('  title can be a regex pattern (if enclosed in /.../) or a prefix (if it ends with \'*\')');
+    console.log('  <width> and <height> are optional and can be a number of pixels or a percentage (e.g. 50%) or 0 (to keep the current size)');
+    console.log('To list all windows: tswinpos *');
+    console.log('To list all windows (including ignored): tswinpos **');
+    console.log('To return the window count use -c');
+    console.log();
+    console.log('  +---+---+');
+    console.log('  | 2 | 3 |');
+    console.log('  +---+---+');
+    console.log('  | 0 | 1 |');
+    console.log('  +---+---+');
+    console.log();
+    console.log('Screen |   X     Y   |   W     H   ');
+    console.log('------------------------------------');
+    for (let i = 0; i < screens.length; i++) {
+        const screen = screens[i];
+        console.log(`${i.toString().padStart(6)} | ${screen.bounds.Left.toString().padStart(5)} ${screen.bounds.Top.toString().padStart(5)} | ${screen.bounds.Width.toString().padStart(5)} ${screen.bounds.Height.toString().padStart(5)}`);
+    }
+    console.log();
+    console.log('0-Lower right, 1-Lower Left, 2-Upper left, 3-Upper right');
+
+    process.exit(1);
+}
+
+export function run(args: string[]) {
+    // Initialize screens
+    try {
+        screens = sortScreens(enumerateScreens());
+    } catch (e: any) {
+        if (e.message && e.message.includes('Bun')) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        throw e; // Re-throw if it's a different error
+    }
+
+    // Load ignore patterns from the same directory as the script
+    const ignoresPath = join(import.meta.dirname, 'ignores.txt');
+    loadIgnorePatterns(ignoresPath);
+
+    // Parse options
+    while (args.length > 0 && args[0].startsWith('-')) {
+        const opt = args[0].substring(1);
+        switch (opt) {
+            case 'd':
+                dbg = true;
+                console.log('Debug mode enabled.');
+                break;
+            case 'c':
+                console.log(screens.length);
+                process.exit(screens.length);
+                break;
+            case 'version':
+            case 'v':
+                console.log(`tswinpos version ${packageJson.default.version}`);
+                process.exit(0);
+                break;
+            default:
+                usage(`Unknown option: ${args[0]}`);
+                break;
+        }
+        args = args.slice(1);
+    }
+
+    // Handle commands
+
+    // console.log(DEBUG: args.length=', args.length, 'args[0]=', args[0], 'check=', args.length === 1 && args[0] === '*');
+    if (dbg)
+        console.log(`DEBUG[${packageJson.default.version}]: ${args.join(' ')}`);
+    if (args.length === 1 && args[0] === '*') {
+        listAllWindows();
+        return;
+    }
+
+    if (args.length === 1 && args[0] === '**') {
+        listAllWindows(true);
+        return;
+    }
+
+    // Check for minimize command (title + min/-min)
+    // TODO: Refactor to eliminate duplicate min/minimize check - consolidate with adjustWindow logic
+    if (args.length === 2 && (args[1].toLowerCase() === 'min' || args[1].toLowerCase() === '-min')) {
+        adjustWindow(args);
+        return;
+    }
+
+    if (args.length < 4) {
+        usage();
+        return;
+    }
+
+    adjustWindow(args);
+}
+
+// CLI entry point using import.meta.main
+if (import.meta.main) {
+    run(process.argv.slice(2));
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@bobfrankston/winpos",
+    "version": "2.0.20",
+    "description": "TypeScript implementation of winpos - Windows window positioning utility",
+    "type": "module",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "bin": {
+        "winpos": "./index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "watch": "tsc -w",
+        "prerelease:local": "git add -A && (git diff-index --quiet HEAD || git commit -m \"Pre-release commit\")",
+        "preversion": "npm run build && git add -A",
+        "postversion": "git push && git push --tags",
+        "release": "npm run prerelease:local && npm version patch && npm publish",
+        "release:ps1": "releaseapp.ps1",
+        "installer": "npm run release && npm install -g @bobfrankston/winpos"
+    },
+    "keywords": [
+        "windows",
+        "window-management",
+        "positioning",
+        "multi-monitor"
+    ],
+    "author": "Bob Frankston",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    },
+    "devDependencies": {
+        "@types/node": "^24.9.1"
+    },
+    "dependencies": {
+        "koffi": "^2.9.2"
+    },
+    "engines": {
+        "node": ">=24.0.0"
+    }
+}

package/screens.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Screen management - enumerate and sort displays
+ */
+export interface ScreenInfo {
+    deviceName: string;
+    bounds: {
+        Left: number;
+        Top: number;
+        Right: number;
+        Bottom: number;
+        Width: number;
+        Height: number;
+    };
+    primary: boolean;
+}
+export declare function enumerateScreens(): ScreenInfo[];
+export declare function sortScreens(screens: ScreenInfo[]): ScreenInfo[];
+//# sourceMappingURL=screens.d.ts.map

package/screens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screens.d.ts","sourceRoot":"","sources":["screens.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,WAAW,UAAU;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,gBAAgB,IAAI,UAAU,EAAE,CAwE/C;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAO/D"}

package/screens.js

@@ -0,0 +1,83 @@
+/**
+ * Screen management - enumerate and sort displays
+ */
+import { user32, isBun, MONITORINFOF_PRIMARY } from './ffi-wrapper.js';
+export function enumerateScreens() {
+    const screens = [];
+    let monitorIndex = 0;
+    // Bun FFI for monitor enumeration not yet implemented
+    if (isBun) {
+        throw new Error('Multi-monitor support is not yet implemented for Bun. Please use Node.js.');
+    }
+    try {
+        // Define callback function - closures should work in Node.js koffi
+        const monitorCallback = (hMonitor, hdcMonitor, lprcMonitor, dwData) => {
+            try {
+                const monitorInfo = {};
+                if (user32.GetMonitorInfoW(hMonitor, monitorInfo)) {
+                    const rcMonitor = monitorInfo.rcMonitor;
+                    screens.push({
+                        deviceName: `\\\\.\\DISPLAY${monitorIndex + 1}`,
+                        bounds: {
+                            Left: rcMonitor.Left,
+                            Top: rcMonitor.Top,
+                            Right: rcMonitor.Right,
+                            Bottom: rcMonitor.Bottom,
+                            Width: rcMonitor.Right - rcMonitor.Left,
+                            Height: rcMonitor.Bottom - rcMonitor.Top,
+                        },
+                        primary: (monitorInfo.dwFlags & MONITORINFOF_PRIMARY) !== 0,
+                    });
+                    monitorIndex++;
+                }
+            }
+            catch (e) {
+                console.error('Error in monitor callback:', e);
+            }
+            return true; // Continue enumeration
+        };
+        // Enumerate all display monitors
+        user32.EnumDisplayMonitors(monitorCallback, 0n);
+    }
+    catch (e) {
+        console.error('Error enumerating monitors:', e);
+        // Fallback to single screen
+        screens.push({
+            deviceName: '\\\\.\\DISPLAY1',
+            bounds: {
+                Left: 0,
+                Top: 0,
+                Right: 1920,
+                Bottom: 1080,
+                Width: 1920,
+                Height: 1080,
+            },
+            primary: true,
+        });
+    }
+    // If no screens were found, add a default one
+    if (screens.length === 0) {
+        screens.push({
+            deviceName: '\\\\.\\DISPLAY1',
+            bounds: {
+                Left: 0,
+                Top: 0,
+                Right: 1920,
+                Bottom: 1080,
+                Width: 1920,
+                Height: 1080,
+            },
+            primary: true,
+        });
+    }
+    return screens;
+}
+export function sortScreens(screens) {
+    // Sort by top (descending), then by left (ascending)
+    return screens.sort((a, b) => {
+        if (a.bounds.Top === b.bounds.Top)
+            return a.bounds.Left - b.bounds.Left;
+        return b.bounds.Top - a.bounds.Top;
+    });
+}
+//# sourceMappingURL=screens.js.map

package/screens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screens.js","sourceRoot":"","sources":["screens.ts"],"names":[],"mappings":"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"}

package/screens.ts

@@ -0,0 +1,101 @@
+/**
+ * Screen management - enumerate and sort displays
+ */
+
+import { user32, RECT, isBun, MONITORINFOF_PRIMARY } from './ffi-wrapper.js';
+
+export interface ScreenInfo {
+    deviceName: string;
+    bounds: {
+        Left: number;
+        Top: number;
+        Right: number;
+        Bottom: number;
+        Width: number;
+        Height: number;
+    };
+    primary: boolean;
+}
+
+export function enumerateScreens(): ScreenInfo[] {
+    const screens: ScreenInfo[] = [];
+    let monitorIndex = 0;
+
+    // Bun FFI for monitor enumeration not yet implemented
+    if (isBun) {
+        throw new Error('Multi-monitor support is not yet implemented for Bun. Please use Node.js.');
+    }
+    
+    try {
+        // Define callback function - closures should work in Node.js koffi
+        const monitorCallback = (hMonitor: any, hdcMonitor: any, lprcMonitor: any, dwData: any): boolean => {
+            try {
+                const monitorInfo: any = {};
+                if (user32.GetMonitorInfoW(hMonitor, monitorInfo)) {
+                    const rcMonitor = monitorInfo.rcMonitor;
+                    screens.push({
+                        deviceName: `\\\\.\\DISPLAY${monitorIndex + 1}`,
+                        bounds: {
+                            Left: rcMonitor.Left,
+                            Top: rcMonitor.Top,
+                            Right: rcMonitor.Right,
+                            Bottom: rcMonitor.Bottom,
+                            Width: rcMonitor.Right - rcMonitor.Left,
+                            Height: rcMonitor.Bottom - rcMonitor.Top,
+                        },
+                        primary: (monitorInfo.dwFlags & MONITORINFOF_PRIMARY) !== 0,
+                    });
+                    monitorIndex++;
+                }
+            } catch (e) {
+                console.error('Error in monitor callback:', e);
+            }
+            return true; // Continue enumeration
+        };
+        
+        // Enumerate all display monitors
+        user32.EnumDisplayMonitors(monitorCallback, 0n);
+    } catch (e) {
+        console.error('Error enumerating monitors:', e);
+        // Fallback to single screen
+        screens.push({
+            deviceName: '\\\\.\\DISPLAY1',
+            bounds: {
+                Left: 0,
+                Top: 0,
+                Right: 1920,
+                Bottom: 1080,
+                Width: 1920,
+                Height: 1080,
+            },
+            primary: true,
+        });
+    }
+
+    // If no screens were found, add a default one
+    if (screens.length === 0) {
+        screens.push({
+            deviceName: '\\\\.\\DISPLAY1',
+            bounds: {
+                Left: 0,
+                Top: 0,
+                Right: 1920,
+                Bottom: 1080,
+                Width: 1920,
+                Height: 1080,
+            },
+            primary: true,
+        });
+    }
+
+    return screens;
+}
+
+export function sortScreens(screens: ScreenInfo[]): ScreenInfo[] {
+    // Sort by top (descending), then by left (ascending)
+    return screens.sort((a, b) => {
+        if (a.bounds.Top === b.bounds.Top)
+            return a.bounds.Left - b.bounds.Left;
+        return b.bounds.Top - a.bounds.Top;
+    });
+}

package/tabs.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Tab enumeration support using Windows UI Automation API
+ *
+ * NOTE: Tab enumeration is application-specific and not all apps expose tabs
+ * through Windows APIs. This module uses UI Automation to attempt to find tabs.
+ *
+ * Windows Terminal, Chrome, Edge, and other modern apps may expose tabs via
+ * UI Automation, but success varies by application.
+ */
+export interface TabInfo {
+    name: string;
+    automationId: string;
+    index: number;
+}
+/**
+ * Attempt to enumerate tabs for a window
+ *
+ * @param hwnd Window handle
+ * @returns Array of tab information, or null if not supported/available
+ *
+ * NOTE: This is a placeholder for future implementation. Tab enumeration
+ * requires COM interop with UI Automation API which is complex with FFI.
+ *
+ * For now, this returns null. A full implementation would require:
+ * - COM initialization (CoInitialize)
+ * - IUIAutomation interface
+ * - Element tree traversal
+ * - Property reading from automation elements
+ */
+export declare function enumerateTabs(hwnd: bigint): Promise<TabInfo[] | null>;
+/**
+ * Check if a window potentially has tabs
+ * This is a heuristic based on window class name
+ */
+export declare function mightHaveTabs(windowTitle: string): boolean;
+/**
+ * Alternative approach: Enumerate child windows
+ * Some applications implement tabs as child windows
+ */
+export declare function enumerateChildWindows(hwnd: bigint): bigint[];
+export declare const TAB_ENUMERATION_NOTE = "\nTab Enumeration Limitations:\n\nWindows does not provide a standard API for enumerating tabs within applications.\nTabs are application-specific UI elements. To enumerate tabs, you would need:\n\n1. UI Automation API (requires COM interop - complex with FFI)\n2. Application-specific APIs (e.g., Chrome DevTools Protocol)\n3. Accessibility APIs (Windows Automation)\n\nCurrent status: Not implemented due to COM complexity.\n\nAlternative approaches:\n- Use application-specific automation (e.g., Puppeteer for Chrome)\n- Use Windows Automation PowerShell cmdlets\n- Use specialized tools like UIAutomationSpy\n\nFor Windows Terminal specifically, tabs are accessible via Windows.UI.Xaml\nautomation, but require UWP/WinRT interop.\n";
+//# sourceMappingURL=tabs.d.ts.map

package/tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["tabs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,WAAW,OAAO;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACjB;AA8BD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAiB3E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAgB1D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI5D;AAGD,eAAO,MAAM,oBAAoB,ouBAmBhC,CAAC"}