@blastlauncher/native 3.0.0-alpha.0 → 3.0.0-alpha.1

package/dist/index.d.ts

@@ -9,8 +9,12 @@ export type Runner = (command: string, args: string[], options: {
     stdout: string;
     code: number;
 }>;
-export declare function createNativeHandlers({ platform, run, env, }?: {
+export type BeforePaste = (options: {
+    closeMainWindow: boolean;
+}) => void | Promise<void>;
+export declare function createNativeHandlers({ platform, run, env, beforePaste, }?: {
     platform?: NodeJS.Platform;
     run?: Runner;
     env?: Record<string, string | undefined>;
+    beforePaste?: BeforePaste;
 }): Record<string, CapabilityHandler>;

package/dist/index.js

@@ -24,7 +24,7 @@ const text = (value) => {
         throw new Error("Expected string without NUL");
     return value;
 };
-export function createNativeHandlers({ platform = process.platform, run = defaultRun, env = process.env, } = {}) {
+export function createNativeHandlers({ platform = process.platform, run = defaultRun, env = process.env, beforePaste, } = {}) {
     const windows = platform === "win32", mac = platform === "darwin";
     const paths = windows ? win32 : posix;
     const absolute = (value) => {
@@ -107,7 +107,9 @@ export function createNativeHandlers({ platform = process.platform, run = defaul
             await copy("clipboard.copy", object(params));
         },
         "clipboard.paste": async (params) => {
-            await copy("clipboard.paste", object(params));
+            const pasteParams = object(params);
+            await copy("clipboard.paste", pasteParams);
+            await beforePaste?.({ closeMainWindow: pasteParams.closeMainWindow !== false });
             if (mac)
                 await command("clipboard.paste", "osascript", [
                     "-e",

package/dist/windows-macos.d.ts

@@ -1,3 +1,5 @@
 import type { JsonValue } from "@blastlauncher/protocol";
 import { type DesktopTools } from "./desktop.js";
+/** The one script used when yabai is unavailable. Inputs are op and JSON params argv. */
+export declare const macWindowsFallback: string;
 export declare function macWindows(t: DesktopTools, cap: string, op: string, p: Record<string, JsonValue>): Promise<JsonValue>;

package/dist/windows-macos.js

@@ -1,7 +1,129 @@
 import { params, string } from "./desktop.js";
 // yabai supplies actual Space/display identities that System Events lacks.
+// The fallback below uses display identities only and cannot distinguish Spaces.
 // No daemon is installed or configured by Blast.
+/** The one script used when yabai is unavailable. Inputs are op and JSON params argv. */
+export const macWindowsFallback = String.raw `
+ObjC.import('AppKit');
+ObjC.import('CoreGraphics');
+const args = $args;
+const op = args[0];
+const input = JSON.parse(args[1] || '{}');
+const cg = ObjC.unwrap($.CGWindowListCopyWindowInfo($.kCGWindowListOptionOnScreenOnly, $.kCGNullWindowID));
+const number = (value) => Number(ObjC.unwrap(value));
+const rect = (value) => {
+  const r = ObjC.unwrap(value);
+  return { position: { x: r.X, y: r.Y }, size: { width: r.Width, height: r.Height } };
+};
+const screens = $.NSScreen.screens;
+const screenInfo = [];
+for (let i = 0; i < screens.count; i++) {
+  const screen = screens.objectAtIndex(i);
+  const description = screen.deviceDescription;
+  const display = number(description.objectForKey('NSScreenNumber'));
+  const uuid = ObjC.unwrap($.CGDisplayCreateUUIDFromDisplayID(display).UUIDString);
+  // CG window bounds and CGDisplayBounds share global top-left coordinates.
+  // CGDisplayBounds is a CGRect struct (origin/size), not a bounds dictionary.
+  const d = $.CGDisplayBounds(display);
+  const frame = { position: { x: d.origin.x, y: d.origin.y }, size: { width: d.size.width, height: d.size.height } };
+  screenInfo.push({ id: 'screen:' + uuid, screenId: uuid, display, frame });
+}
+const screenFor = (bounds) => {
+  let best = screenInfo[0], bestArea = -1;
+  for (const screen of screenInfo) {
+    const f = screen.frame;
+    const width = Math.max(0, Math.min(bounds.X + bounds.Width, f.position.x + f.size.width) - Math.max(bounds.X, f.position.x));
+    const height = Math.max(0, Math.min(bounds.Y + bounds.Height, f.position.y + f.size.height) - Math.max(bounds.Y, f.position.y));
+    const area = width * height;
+    if (area > bestArea) { best = screen; bestArea = area; }
+  }
+  return best;
+};
+const systemEvents = Application('System Events');
+const axCache = new Map();
+// Reads stay available without Accessibility; capability flags are then false.
+const trusted = !!systemEvents.uiElementsEnabled();
+const axWindows = (pid) => {
+  if (!trusted) return [];
+  if (!axCache.has(pid)) axCache.set(pid, systemEvents.applicationProcesses.byId(pid).windows());
+  return axCache.get(pid);
+};
+const sameFrame = (window, bounds) => {
+  const p = window.position(), s = window.size();
+  return Math.abs(p.x - bounds.X) < 2 && Math.abs(p.y - bounds.Y) < 2 && Math.abs(s.width - bounds.Width) < 2 && Math.abs(s.height - bounds.Height) < 2;
+};
+const attribute = (window, name) => {
+  try { return window.attributes.byName(name); } catch (_) { return undefined; }
+};
+const canSet = (attr) => {
+  if (!attr) return false;
+  try { if (typeof attr.settable === 'function') return !!attr.settable(); } catch (_) {}
+  try { return attr.value() !== undefined; } catch (_) { return false; }
+};
+const frontmostWindow = () => {
+  const pid = number($.NSWorkspace.sharedWorkspace.frontmostApplication.processIdentifier);
+  return windows.find((window) => number(window.kCGWindowOwnerPID) === pid);
+};
+const requireAccessibility = () => {
+  if (!trusted) throw new Error('Accessibility permission is required');
+};
+const windows = cg.filter((w) => number(w.kCGWindowLayer) === 0 && !!ObjC.unwrap(w.kCGWindowIsOnscreen));
+const convert = (w, active) => {
+  const bounds = ObjC.unwrap(w.kCGWindowBounds);
+  const screen = screenFor(bounds);
+  let positionable = false, resizable = false, fullScreenSettable = false;
+  const match = axWindows(number(w.kCGWindowOwnerPID)).find((window) => sameFrame(window, bounds));
+  if (match) {
+    positionable = canSet(attribute(match, 'AXPosition'));
+    resizable = canSet(attribute(match, 'AXSize'));
+    fullScreenSettable = !!attribute(match, 'AXFullScreen');
+  }
+  return { id: String(number(w.kCGWindowNumber)), desktopId: screen.id, active, fullScreenSettable, resizable, positionable, bounds: rect(w.kCGWindowBounds) };
+};
+const front = frontmostWindow();
+if (op === 'desktops') {
+  const frontScreen = front ? screenFor(ObjC.unwrap(front.kCGWindowBounds)) : undefined;
+  console.log(JSON.stringify(screenInfo.map((s) => ({ id: s.id, screenId: s.screenId, active: s === frontScreen, type: 'User', size: s.frame.size }))));
+} else if (op === 'list' || op === 'active') {
+  if (op === 'active' && !front) throw new Error('No active window');
+  console.log(JSON.stringify(op === 'active' ? convert(front, true) : windows.map((w) => convert(w, w === front))));
+} else if (op === 'setBounds') {
+  requireAccessibility();
+  const id = String(input.id);
+  const target = windows.find((w) => String(number(w.kCGWindowNumber)) === id);
+  if (!target) throw new Error('Window not found');
+  const current = convert(target, false);
+  if (input.desktopId !== undefined && input.desktopId !== current.desktopId) throw new Error('Window cannot move to a different desktop without yabai');
+  const candidates = axWindows(number(target.kCGWindowOwnerPID));
+  const frame = ObjC.unwrap(target.kCGWindowBounds);
+  const match = candidates.find((window) => sameFrame(window, frame));
+  if (!match) throw new Error('Accessibility cannot identify this window');
+  if (input.bounds === 'fullscreen') {
+    const fullscreen = attribute(match, 'AXFullScreen');
+    if (!fullscreen) throw new Error('Window does not support fullscreen');
+    fullscreen.setValue(true);
+  } else {
+    const b = input.bounds || {}, p = b.position || {}, s = b.size || {};
+    if (p.x !== undefined || p.y !== undefined) match.position = [p.x ?? frame.X, p.y ?? frame.Y];
+    if (s.width !== undefined || s.height !== undefined) match.size = [s.width ?? frame.Width, s.height ?? frame.Height];
+  }
+  console.log('null');
+}`;
 export async function macWindows(t, cap, op, p) {
+    // Display IDs are only produced by the fallback backend; do not ask yabai
+    // to interpret one as a Mission Control Space index.
+    if (op === "setBounds" && typeof p.desktopId === "string" && p.desktopId.startsWith("screen:"))
+        return JSON.parse(await t.jxa(cap, macWindowsFallback, [op, JSON.stringify(p)]));
+    try {
+        return await yabaiWindows(t, cap, op, p);
+    }
+    catch (error) {
+        if (!missingExecutable(error))
+            throw error;
+        return JSON.parse(await t.jxa(cap, macWindowsFallback, [op, JSON.stringify(p)]));
+    }
+}
+async function yabaiWindows(t, cap, op, p) {
     const send = (args) => t.command(cap, "yabai", ["-m", ...args]);
     const query = async (args) => JSON.parse(await send(["query", ...args]));
     if (op === "desktops") {
@@ -69,3 +191,9 @@ function convert(w) {
             : { position: { x: f.x, y: f.y }, size: { width: f.w, height: f.h } },
     };
 }
+function missingExecutable(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const value = error;
+    return value.code === "ENOENT" || missingExecutable(value.cause);
+}

package/dist/windows.js

@@ -9,8 +9,10 @@ export function windowHandlers(t) {
             async (value) => {
                 const p = params(value);
                 if (t.platform === "darwin") {
-                    if (op === "setBounds")
+                    if (op === "setBounds") {
                         validateBounds(p);
+                        validateMacBounds(p);
+                    }
                     return macWindows(t, cap, op, p);
                 }
                 if (t.platform === "win32") {
@@ -144,3 +146,11 @@ function validateBounds(p) {
         }
     }
 }
+function validateMacBounds(p) {
+    if (!/^\d+$/.test(string(p.id)))
+        throw new Error("Invalid window id");
+    if (p.desktopId !== undefined &&
+        !/^\d+$/.test(string(p.desktopId)) &&
+        !/^screen:[^\s\0]+$/.test(string(p.desktopId)))
+        throw new Error("Invalid desktop id");
+}

package/package.json

@@ -9,10 +9,16 @@
     }
   },
   "dependencies": {
-    "@blastlauncher/protocol": "3.0.0-alpha.0"
+    "@blastlauncher/protocol": "3.0.0-alpha.1"
   },
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.1",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BlastLauncher/blast.git",
+    "directory": "packages/native"
+  },
+  "homepage": "https://github.com/BlastLauncher/blast#readme",
   "engines": {
     "node": ">=24.20.0"
   },