@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/core/modules/launcher/query.js

@@ -0,0 +1,42 @@
+export const launchScopeTitles = {
+    projects: "Проекты",
+    github: "GitHub",
+    gitlab: "GitLab",
+    new: "Новый проект",
+};
+/** Any host with "gitlab" in its name: gitlab.com and self-hosted (gitlab.example.com, git.gitlab-x.org). */
+const GITLAB_URL = /^https?:\/\/[^/\s]*gitlab[^/\s]*(?::\d+)?(?:\/|$)/i;
+const GITHUB_URL = /^https?:\/\/(?:www\.)?github\.com(?:\/|$)/i;
+/** `owner/repo/tree/main?x#y` → `owner/repo`; one segment → `owner/` (list that owner). */
+function githubUrlText(rest) {
+    const [owner = "", repo = ""] = rest.split(/[?#]/)[0].split("/").filter(Boolean);
+    if (!owner)
+        return "";
+    return repo ? `${owner}/${repo.replace(/\.git$/i, "")}` : `${owner}/`;
+}
+/** `group/sub/project/-/tree/main?x` → `group/sub/project`; one segment → `group/`. */
+function gitlabUrlText(rest) {
+    const segments = rest.split(/[?#]/)[0].split("/-/")[0].split("/").filter(Boolean);
+    if (!segments.length)
+        return "";
+    const path = segments.join("/").replace(/\.git$/i, "");
+    return segments.length > 1 ? path : `${path}/`;
+}
+export function parseLaunchQuery(raw) {
+    const query = raw.trimStart();
+    const url = GITHUB_URL.exec(query);
+    if (url)
+        return { scope: "github", text: githubUrlText(query.slice(url[0].length)) };
+    const gitlabUrl = GITLAB_URL.exec(query);
+    if (gitlabUrl)
+        return { scope: "gitlab", text: gitlabUrlText(query.slice(gitlabUrl[0].length)) };
+    if (/^gh\//i.test(query))
+        return { scope: "github", text: query.slice(3).trim() };
+    if (/^new\//i.test(query))
+        return { scope: "new", text: query.slice(4).trim() };
+    if (/^gl\//i.test(query))
+        return { scope: "gitlab", text: query.slice(3).trim() };
+    if (query.startsWith("/"))
+        return { scope: "projects", text: query.slice(1).trim() };
+    return { scope: "all", text: raw.trim() };
+}

package/packages/core/modules/network-mode/index.js

@@ -0,0 +1,3 @@
+export { NETWORK_MODES } from "./network-mode.js";
+export { isNetworkMode } from "./network-mode.js";
+export { networkHost } from "./network-mode.js";

package/packages/core/modules/network-mode/network-mode.js

@@ -0,0 +1,8 @@
+export const NETWORK_MODES = ["local", "lan"];
+export function isNetworkMode(value) {
+    return value === "local" || value === "lan";
+}
+/** Хост Vite-сервера для режима доступа. */
+export function networkHost(mode) {
+    return mode === "lan" ? "0.0.0.0" : "localhost";
+}

package/packages/core/modules/os/bash.js

@@ -0,0 +1,11 @@
+/** Linux container shell, independent of the host's OS and preferred shell. */
+export function bashShellLaunch(spec, clean = false) {
+    const args = clean ? ["--noprofile", "--norc"] : [];
+    if (spec.kind === "command")
+        args.push("-c", spec.command);
+    else if (spec.kind === "program")
+        args.push("-i", "-c", `exec ${spec.executable}`);
+    else
+        args.push("-i");
+    return { file: "/bin/bash", args };
+}

package/packages/core/modules/os/contract.js

@@ -0,0 +1 @@
+export {};

package/packages/core/modules/os/index.js

@@ -0,0 +1,3 @@
+export { os, createOs, UnsupportedPlatformError } from "./os.js";
+export { clearSessionEnv } from "./session-env.js";
+export { bashShellLaunch } from "./bash.js";

package/packages/core/modules/os/modules/darwin/catalog.js

@@ -0,0 +1,108 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, join, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+function roots() {
+    return [
+        "/Applications",
+        "/Applications/Utilities",
+        "/System/Applications",
+        "/System/Applications/Utilities",
+        join(homedir(), "Applications"),
+    ];
+}
+function allowed(id) {
+    const path = resolve(id);
+    return (path.endsWith(".app") && roots().some((root) => path.startsWith(root + sep)) && existsSync(path));
+}
+/** Bundles have no Gio icon. The palette row falls back to the PNG from `applicationIcon`. */
+export function desktopApp(_id) {
+    return { getIcon: () => null };
+}
+/** Agents and background-only bundles have no window to open: the analogue of NoDisplay. */
+async function hidden(app) {
+    for (const key of ["LSUIElement", "LSBackgroundOnly"]) {
+        try {
+            const { stdout } = await execute("plutil", ["-extract", key, "raw", "-o", "-", join(app, "Contents/Info.plist")], { timeout: 5000 });
+            if (["true", "1"].includes(stdout.trim().toLowerCase()))
+                return true;
+        }
+        catch {
+            /* The key is absent. */
+        }
+    }
+    return false;
+}
+export async function listApplications() {
+    const seen = new Set();
+    const items = [];
+    for (const root of roots()) {
+        let names;
+        try {
+            names = readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of names) {
+            if (!entry.endsWith(".app"))
+                continue;
+            const path = join(root, entry);
+            const name = basename(entry, ".app");
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            items.push({
+                id: `app:${path}`,
+                name,
+                description: "приложение",
+                keywords: path,
+                kind: "application",
+                icon: `/api/launcher/icon?id=${encodeURIComponent(path)}`,
+            });
+        }
+    }
+    const visible = [];
+    for (let start = 0; start < items.length; start += 24) {
+        const batch = items.slice(start, start + 24);
+        const flags = await Promise.all(batch.map((item) => hidden(item.id.slice(4))));
+        visible.push(...batch.filter((_, index) => !flags[index]));
+    }
+    return visible.sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function launchApplication(id) {
+    if (!allowed(id))
+        throw new Error("Приложение больше не доступно");
+    await execute("open", ["-a", resolve(id)]);
+}
+/** Converts the bundle's .icns to a cached PNG; empty when the bundle has no usable icon. */
+export async function applicationIcon(id) {
+    if (!allowed(id))
+        return "";
+    const app = resolve(id);
+    try {
+        const { stdout } = await execute("plutil", ["-extract", "CFBundleIconFile", "raw", "-o", "-", join(app, "Contents/Info.plist")], { timeout: 5000 });
+        let file = stdout.trim();
+        if (!file)
+            return "";
+        if (!file.endsWith(".icns"))
+            file += ".icns";
+        const source = join(app, "Contents/Resources", file);
+        if (!existsSync(source))
+            return "";
+        const cache = join(tmpdir(), "projector-app-icons");
+        mkdirSync(cache, { recursive: true });
+        const target = join(cache, `${createHash("sha256").update(app).digest("hex").slice(0, 16)}.png`);
+        if (!existsSync(target))
+            await execute("sips", ["-s", "format", "png", "-Z", "64", source, "--out", target], {
+                timeout: 8000,
+            });
+        return target;
+    }
+    catch {
+        return "";
+    }
+}

package/packages/core/modules/os/modules/darwin/directories.js

@@ -0,0 +1,40 @@
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+export function dataHome() {
+    return process.env.XDG_DATA_HOME || join(homedir(), "Library", "Application Support");
+}
+export function configHome() {
+    return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+}
+export function shell() {
+    return process.env.SHELL || "/bin/zsh";
+}
+export function shellLaunch(spec) {
+    const file = shell();
+    if (spec.kind === "command")
+        return { file, args: ["-c", spec.command] };
+    if (spec.kind === "program")
+        return { file, args: ["-i", "-c", `exec ${spec.executable}`] };
+    return { file, args: ["-i"] };
+}
+export function desktopPaths() {
+    return {
+        applications: join(homedir(), "Applications"),
+        icons: join(dataHome(), "Projector", "icons"),
+        bin: join(homedir(), ".local/bin"),
+    };
+}
+export async function pickFolder() {
+    try {
+        const { stdout } = await execute("osascript", ["-e", 'POSIX path of (choose folder with prompt "Выберите проект")'], { timeout: 180000 });
+        return stdout.trim().replace(/\/$/, "") || null;
+    }
+    catch (error) {
+        if (/-128|User canceled/.test(String(error.stderr)))
+            return null;
+        throw error;
+    }
+}

package/packages/core/modules/os/modules/darwin/docker.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import { commandExists } from "../../../os-posix/index.js";
+/** Docker Desktop, OrbStack and Colima each bring up their own VM with the daemon. */
+export function dockerStartPlan() {
+    if (existsSync("/Applications/Docker.app"))
+        return { label: "Запустить Docker Desktop", command: "open", args: ["-ga", "Docker"] };
+    if (existsSync("/Applications/OrbStack.app"))
+        return { label: "Запустить OrbStack", command: "open", args: ["-ga", "OrbStack"] };
+    if (commandExists("colima"))
+        return { label: "colima start", command: "colima", args: ["start"] };
+    return {
+        label: "Docker не установлен",
+        manual: "Установите Docker Desktop, OrbStack или Colima (brew install colima docker)",
+    };
+}

package/packages/core/modules/os/modules/darwin/gtk.js

@@ -0,0 +1,6 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/** GTK4 comes from Homebrew; without it macOS keeps the Chromium palette. */
+export function gtkAvailable() {
+    return ["/opt/homebrew/lib", "/usr/local/lib"].some((dir) => existsSync(join(dir, "libgtk-4.1.dylib")));
+}

package/packages/core/modules/os/modules/darwin/helper.swift

@@ -0,0 +1,172 @@
+// Menu-bar item and global hotkey for Projector. Commands arrive on stdin, events leave on stdout.
+import AppKit
+import Carbon
+
+setbuf(stdout, nil)
+func emit(_ line: String) { print(line); fflush(stdout) }
+
+let hotkeys: [String: (modifiers: UInt32, code: UInt32)] = [
+  "Ctrl+Alt+Space": (UInt32(controlKey | optionKey), 49),
+  "Alt+Space": (UInt32(optionKey), 49),
+]
+var hotKeyRef: EventHotKeyRef? = nil
+var handlerInstalled = false
+
+func registerHotkey(_ name: String) -> String {
+  if let ref = hotKeyRef { UnregisterEventHotKey(ref); hotKeyRef = nil }
+  guard let spec = hotkeys[name] else { return "hotkey:none" }
+  if !handlerInstalled {
+    var type = EventTypeSpec(eventClass: OSType(kEventClassKeyboard), eventKind: UInt32(kEventHotKeyPressed))
+    InstallEventHandler(GetApplicationEventTarget(), { _, _, _ in emit("event:hotkey"); return noErr }, 1, &type, nil, nil)
+    handlerInstalled = true
+  }
+  let id = EventHotKeyID(signature: OSType(0x504A4B59), id: 1)
+  let status = RegisterEventHotKey(spec.code, spec.modifiers, id, GetApplicationEventTarget(), 0, &hotKeyRef)
+  return status == noErr ? "hotkey:ok" : "hotkey:busy"
+}
+
+let arguments = CommandLine.arguments
+if arguments.count > 2 && arguments[1] == "--probe" {
+  emit(registerHotkey(arguments[2]))
+  exit(0)
+}
+
+if arguments.count > 3 && arguments[1] == "--app" {
+  guard let pid = Int32(arguments[2]), let running = NSRunningApplication(processIdentifier: pid) else {
+    emit("gone")
+    exit(1)
+  }
+  switch arguments[3] {
+  case "activate":
+    running.unhide()
+    running.activate(options: [.activateIgnoringOtherApps])
+  case "hide": running.hide()
+  case "terminate": running.terminate()
+  default: break
+  }
+  RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
+  emit(running.isHidden ? "hidden" : running.isActive ? "active" : "visible")
+  exit(0)
+}
+
+func onScreenWindows(_ owner: Int, verbose: Bool) -> Int {
+  // On-screen, normal-layer windows of a process: proves a palette is really shown.
+  let list = (CGWindowListCopyWindowInfo([.optionOnScreenOnly], kCGNullWindowID) as? [[String: Any]]) ?? []
+  return list.filter { info in
+    guard (info[kCGWindowOwnerPID as String] as? Int) == owner, (info[kCGWindowLayer as String] as? Int) == 0,
+          let bounds = info[kCGWindowBounds as String] as? [String: Any] else { return false }
+    let big = ((bounds["Width"] as? Double) ?? 0) > 100 && ((bounds["Height"] as? Double) ?? 0) > 100
+    if verbose && big { emit("window:\(bounds) alpha=\(info[kCGWindowAlpha as String] ?? "?") name=\(info[kCGWindowName as String] ?? "")") }
+    return big
+  }.count
+}
+
+if arguments.count > 2 && arguments[1] == "--windows" {
+  emit("windows:\(onScreenWindows(Int(arguments[2]) ?? -1, verbose: arguments.contains("-v")))")
+  exit(0)
+}
+
+if arguments.count > 3 && arguments[1] == "--watch" {
+  // Polls fast for `seconds`: a window that appears only briefly is still seen.
+  let owner = Int(arguments[2]) ?? -1
+  let deadline = Date(timeIntervalSinceNow: Double(arguments[3]) ?? 5)
+  while Date() < deadline {
+    let count = onScreenWindows(owner, verbose: false)
+    if count > 0 { emit("windows:\(count)"); exit(0) }
+    usleep(10_000)
+  }
+  emit("windows:0")
+  exit(0)
+}
+
+final class Target: NSObject, NSMenuDelegate {
+  func menuWillOpen(_ menu: NSMenu) { emit("menu:open") }
+  func menu(_ menu: NSMenu, willHighlight item: NSMenuItem?) { emit("highlight:\(item?.title ?? "")") }
+  func menuDidClose(_ menu: NSMenu) { emit("menu:close") }
+  @objc func activate() { emit("event:activate") }
+  @objc func settings() { emit("event:settings") }
+  @objc func restart() { emit("event:restart") }
+  @objc func quit() { emit("event:quit") }
+}
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory)
+let target = Target()
+let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+if arguments.count > 1, let image = NSImage(contentsOfFile: arguments[1]) {
+  image.size = NSSize(width: 18, height: 18)
+  item.button?.image = image
+} else {
+  item.button?.title = "P"
+}
+let menu = NSMenu()
+for (title, action) in [("Открыть", #selector(Target.activate)), ("Настройки", #selector(Target.settings)),
+                        ("Перезапустить", #selector(Target.restart)), ("Выйти", #selector(Target.quit))] {
+  let entry = NSMenuItem(title: title, action: action, keyEquivalent: "")
+  entry.target = target
+  menu.addItem(entry)
+}
+menu.delegate = target
+item.menu = menu
+
+DispatchQueue.global().async {
+  while let line = readLine() {
+    DispatchQueue.main.async {
+      if line.hasPrefix("hotkey ") { emit(registerHotkey(String(line.dropFirst(7)))) }
+      else if line == "quit" { NSApp.terminate(nil) }
+      else if ProcessInfo.processInfo.environment["PROJECTOR_SHELL_TEST"] == "1" {
+        // Drives the same handlers a click or key press reaches, without needing input permissions.
+        if line.hasPrefix("menu "), let index = Int(line.dropFirst(5)) { menu.performActionForItem(at: index) }
+        else if line == "real-hotkey" {
+          // Hardware-level events: they travel the same path as a physical key press.
+          for down in [true, false] {
+            let event = CGEvent(keyboardEventSource: nil, virtualKey: 49, keyDown: down)
+            event?.flags = [.maskControl, .maskAlternate]
+            event?.post(tap: .cghidEventTap)
+          }
+        }
+        else if line == "real-click", let window = item.button?.window {
+          let frame = window.frame
+          let screenHeight = NSScreen.screens[0].frame.height
+          let point = CGPoint(x: frame.midX, y: screenHeight - frame.midY)
+          for type in [CGEventType.leftMouseDown, CGEventType.leftMouseUp] {
+            CGEvent(mouseEventSource: nil, mouseType: type, mouseCursorPosition: point, mouseButton: .left)?
+              .post(tap: .cghidEventTap)
+          }
+        }
+        else if line.hasPrefix("real-row "), let row = Int(line.dropFirst(9)) {
+          // Moves the real pointer over a row of the open menu and clicks it.
+          let screenHeight = NSScreen.screens[0].frame.height
+          let windows = NSApp.windows.filter { $0.frame.width > 100 && $0.level.rawValue > 0 && $0.frame.height > 60 && $0 != item.button?.window }
+          guard let window = windows.max(by: { $0.frame.height < $1.frame.height }) else { emit("row:nomenu"); return }
+          let frame = window.frame
+          let rowHeight = (frame.height - 10) / CGFloat(menu.numberOfItems)
+          let point = CGPoint(x: frame.midX, y: screenHeight - (frame.maxY - 5 - rowHeight * (CGFloat(row) + 0.5)))
+          CGEvent(mouseEventSource: nil, mouseType: .mouseMoved, mouseCursorPosition: point, mouseButton: .left)?
+            .post(tap: .cghidEventTap)
+          DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
+            for type in [CGEventType.leftMouseDown, CGEventType.leftMouseUp] {
+              CGEvent(mouseEventSource: nil, mouseType: type, mouseCursorPosition: point, mouseButton: .left)?
+                .post(tap: .cghidEventTap)
+            }
+          }
+        }
+        else if line.hasPrefix("real-key "), let code = UInt16(line.dropFirst(9)) {
+          for down in [true, false] {
+            CGEvent(keyboardEventSource: nil, virtualKey: code, keyDown: down)?.post(tap: .cghidEventTap)
+          }
+        }
+        else if line == "press-hotkey" {
+          var event: EventRef?
+          CreateEvent(nil, UInt32(kEventClassKeyboard), UInt32(kEventHotKeyPressed), 0, 0, &event)
+          var id = EventHotKeyID(signature: OSType(0x504A4B59), id: 1)
+          SetEventParameter(event, UInt32(kEventParamDirectObject), UInt32(typeEventHotKeyID), MemoryLayout<EventHotKeyID>.size, &id)
+          SendEventToEventTarget(event, GetApplicationEventTarget())
+        }
+      }
+    }
+  }
+  DispatchQueue.main.async { NSApp.terminate(nil) }
+}
+emit("ready")
+app.run()

package/packages/core/modules/os/modules/darwin/index.js

@@ -0,0 +1,12 @@
+export { processInfo, signalProcess, processIdentity, listProcesses, listProcesses as snapshotProcesses, recentProcesses, trackConsole, untrackConsole, descendants, descendants as descendantsSync, workingDirectory, workingDirectories, } from "./processes.js";
+export { moveNoReplace, runPython, searchFiles, runBash, runDocker, runDockerSync, runNodeScript, commandExists, ptyCommand, spawnProcess, isExecutableFile, restrictToOwner, restrictToOwnerSync, } from "./tools.js";
+export { dockerStartPlan } from "./docker.js";
+export { configHome, dataHome, shell, shellLaunch, desktopPaths, pickFolder, } from "./directories.js";
+export { focusAppWindow, openWindow, openBrowser, revealInFileManager, openOrFocusApp, hidePalette, openWebPalette, closePalette, activateWindow, activateSurface, } from "./windows.js";
+export { desktopPid, shortcutStatus, shortcutAvailable } from "./shortcut.js";
+export { deleteSecret, getSecret, secretsAvailable, setSecret } from "./secrets.js";
+export { installDesktop } from "./install-desktop.js";
+export { gitAskpass, publishDirectory, removeAgentHostAddress, agentEnv, agentLaunch, agentHostAddress, killAgentTree, spawnAgentHost, spawnAgentProcess, } from "../../../os-posix/index.js";
+export const catalog = () => import(new URL("./catalog.js", import.meta.url).href);
+export const resident = () => import(new URL("./resident.js", import.meta.url).href);
+export { gtkAvailable } from "./gtk.js";

package/packages/core/modules/os/modules/darwin/install-desktop.js

@@ -0,0 +1,135 @@
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { desktopPaths } from "./directories.js";
+import { gtkAvailable } from "./gtk.js";
+const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+function packageVersion(root) {
+    try {
+        const raw = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        return raw.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function tryExec(bin, args) {
+    try {
+        execFileSync(bin, args, { stdio: "ignore" });
+    }
+    catch {
+        /* optional helpers (Launch Services, iconutil) */
+    }
+}
+/** Build Projector.icns from the checkout PNG set for Spotlight / Raycast / Dock. */
+function installIcon(root, resources) {
+    const src = join(root, "resources", "icons");
+    const sizes = [
+        ["16.png", "icon_16x16.png"],
+        ["32.png", "icon_16x16@2x.png"],
+        ["32.png", "icon_32x32.png"],
+        ["64.png", "icon_32x32@2x.png"],
+        ["128.png", "icon_128x128.png"],
+        ["256.png", "icon_128x128@2x.png"],
+        ["256.png", "icon_256x256.png"],
+        ["512.png", "icon_256x256@2x.png"],
+        ["512.png", "icon_512x512.png"],
+        ["512.png", "icon_512x512@2x.png"],
+    ];
+    if (!sizes.every(([file]) => existsSync(join(src, file))))
+        return false;
+    const staging = mkdtempSync(join(tmpdir(), "projector-iconset-"));
+    const iconset = join(staging, "Projector.iconset");
+    const icns = join(resources, "Projector.icns");
+    try {
+        mkdirSync(iconset);
+        for (const [file, name] of sizes)
+            copyFileSync(join(src, file), join(iconset, name));
+        execFileSync("iconutil", ["-c", "icns", iconset, "-o", icns], { stdio: "ignore" });
+        return existsSync(icns);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+}
+/**
+ * Installs `~/.local/bin/projector` and `~/Applications/Projector.app`.
+ * The .app is what Raycast, Spotlight and Launchpad index; the CLI alone is invisible to them.
+ */
+function launchEntry(root) {
+    const directory = join(root, "packages", "cli", "app");
+    for (const name of ["launch.ts", "launch.js"]) {
+        const file = join(directory, name);
+        if (existsSync(file))
+            return file;
+    }
+    return join(directory, "launch.js");
+}
+export function installDesktop(root) {
+    const launch = launchEntry(root);
+    const { applications, bin } = desktopPaths();
+    mkdirSync(bin, { recursive: true });
+    const command = join(bin, "projector");
+    writeFileSync(command, `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(launch)} "$@"\n`);
+    chmodSync(command, 0o755);
+    console.log(`команда: ${command}`);
+    const app = join(applications, "Projector.app");
+    const contents = join(app, "Contents");
+    const macos = join(contents, "MacOS");
+    const resources = join(contents, "Resources");
+    mkdirSync(macos, { recursive: true });
+    mkdirSync(resources, { recursive: true });
+    const executable = join(macos, "Projector");
+    writeFileSync(executable, `#!/bin/sh\nexec ${quote(command)} "$@"\n`);
+    chmodSync(executable, 0o755);
+    const version = packageVersion(root);
+    const hasIcon = installIcon(root, resources);
+    const iconEntries = hasIcon
+        ? `  <key>CFBundleIconFile</key>
+  <string>Projector</string>
+`
+        : "";
+    writeFileSync(join(contents, "Info.plist"), `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key>
+  <string>Projector</string>
+  <key>CFBundleDisplayName</key>
+  <string>Projector</string>
+  <key>CFBundleIdentifier</key>
+  <string>dev.projector.app</string>
+  <key>CFBundleVersion</key>
+  <string>${version}</string>
+  <key>CFBundleShortVersionString</key>
+  <string>${version}</string>
+  <key>CFBundleExecutable</key>
+  <string>Projector</string>
+${iconEntries}  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>13.0</string>
+  <key>NSHighResolutionCapable</key>
+  <true/>
+</dict>
+</plist>
+`);
+    tryExec("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", app]);
+    console.log(`приложение: ${app}`);
+    console.log("откройте Projector из Spotlight, Raycast или Launchpad");
+    if (!gtkAvailable()) {
+        console.log("GTK4 не найден, ставлю через Homebrew…");
+        try {
+            execFileSync("brew", ["install", "gtk4", "gobject-introspection", "pkg-config"], {
+                stdio: "inherit",
+            });
+        }
+        catch {
+            console.log("Не удалось: выполните brew install gtk4 gobject-introspection pkg-config");
+        }
+    }
+}

package/packages/core/modules/os/modules/darwin/processes.js

@@ -0,0 +1,97 @@
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+// lstart is always five words: "Thu Oct  9 12:00:00 2026".
+const COLUMNS = "pid=,ppid=,pgid=,tpgid=,stat=,lstart=,comm=";
+const LINE = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(-?\d+)\s+(\S+)\s+(\S+\s+\S+\s+\d+\s+[\d:]+\s+\d+)\s+(.*)$/;
+function parse(output) {
+    return output.split("\n").flatMap((line) => {
+        const match = LINE.exec(line);
+        if (!match)
+            return [];
+        const foreground = Number(match[4]);
+        return [
+            {
+                pid: Number(match[1]),
+                parent: Number(match[2]),
+                name: match[7].split("/").pop(),
+                started: match[6],
+                state: match[5][0],
+                group: Number(match[3]),
+                foreground: foreground > 0 ? foreground : null,
+            },
+        ];
+    });
+}
+export function listProcesses() {
+    try {
+        return parse(execFileSync("ps", ["-axo", COLUMNS], {
+            encoding: "utf8",
+            env: { ...process.env, LC_ALL: "C" },
+            maxBuffer: 16 * 1024 * 1024,
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+export function processInfo(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        return (parse(execFileSync("ps", ["-p", String(pid), "-o", COLUMNS], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            env: { ...process.env, LC_ALL: "C" },
+        }))[0] ?? null);
+    }
+    catch {
+        return null;
+    }
+}
+export function processIdentity(pid) {
+    const info = processInfo(pid);
+    return info && info.state !== "Z" ? info.started : null;
+}
+export function descendants(pid) {
+    const processes = listProcesses() ?? [];
+    const family = new Set([pid]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const entry of processes)
+            if (family.has(entry.parent) && !family.has(entry.pid)) {
+                family.add(entry.pid);
+                changed = true;
+            }
+    }
+    return processes.filter((entry) => family.has(entry.pid));
+}
+async function cwdOf(pid) {
+    try {
+        const { stdout } = await execute("lsof", ["-a", "-d", "cwd", "-p", String(pid), "-Fn"], {
+            timeout: 5000,
+        });
+        return (stdout
+            .split("\n")
+            .find((line) => line.startsWith("n"))
+            ?.slice(1) || null);
+    }
+    catch {
+        return null;
+    }
+}
+export async function workingDirectory(pid, fallback) {
+    const foreground = processInfo(pid)?.foreground ?? 0;
+    return (foreground > 0 ? await cwdOf(foreground) : null) ?? (await cwdOf(pid)) ?? fallback;
+}
+export async function workingDirectories(pid, fallback) {
+    return [await workingDirectory(pid, fallback)];
+}
+export function signalProcess(pid, signal) {
+    process.kill(pid, signal);
+}
+/** macOS parents every program to its shell; nothing needs tracking. */
+export function trackConsole(_pid) { }
+export function untrackConsole(_pid) { }
+export const recentProcesses = (_maxAgeMs) => listProcesses();