@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/core/modules/os/modules/windows/color-scheme.js

@@ -0,0 +1,26 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+const personalize = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize";
+/** `reg query` prints `AppsUseLightTheme    REG_DWORD    0x0`: 0 is the dark app mode. */
+export function parseAppsUseLightTheme(output) {
+    const match = /AppsUseLightTheme\s+REG_DWORD\s+0x([0-9a-f]+)/i.exec(output);
+    if (!match?.[1])
+        return;
+    return Number.parseInt(match[1], 16) === 0 ? "dark" : "light";
+}
+/** Windows app color mode. GTK's Win32 backend leaves `gtk-interface-color-scheme` unsupported. */
+export async function readWindowsColorScheme() {
+    try {
+        const reg = join(process.env.SystemRoot ?? "C:\\Windows", "System32", "reg.exe");
+        const { stdout } = await execute(reg, ["query", personalize, "/v", "AppsUseLightTheme"], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        return parseAppsUseLightTheme(stdout);
+    }
+    catch {
+        return;
+    }
+}

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

@@ -0,0 +1,101 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runPowerShell } from "./ps.js";
+export function dataHome() {
+    return (process.env.XDG_DATA_HOME || process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"));
+}
+export function configHome() {
+    return (process.env.XDG_CONFIG_HOME || process.env.APPDATA || join(homedir(), "AppData", "Roaming"));
+}
+export function desktopPaths() {
+    const roaming = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    return {
+        applications: join(roaming, "Microsoft", "Windows", "Start Menu", "Programs"),
+        icons: join(dataHome(), "icons"),
+        bin: join(dataHome(), "bin"),
+    };
+}
+function gitBashCandidates() {
+    const roots = [
+        process.env.ProgramFiles,
+        process.env["ProgramFiles(x86)"],
+        process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, "Programs"),
+    ].filter((root) => Boolean(root));
+    return roots.flatMap((root) => [
+        join(root, "Git", "bin", "bash.exe"),
+        join(root, "Git", "usr", "bin", "bash.exe"),
+    ]);
+}
+/** Git Bash understands the same `-c` scripts as Linux. WSL's System32 bash does not. */
+export function bashExecutable() {
+    const fromEnv = process.env.SHELL;
+    if (fromEnv &&
+        existsSync(fromEnv) &&
+        !/powershell|pwsh|cmd(?:\.exe)?$/i.test(fromEnv) &&
+        !/\\Windows\\(?:System32|Sysnative)\\bash\.exe$/i.test(fromEnv))
+        return fromEnv;
+    for (const candidate of gitBashCandidates())
+        if (existsSync(candidate))
+            return candidate;
+    try {
+        const found = bashOnPath();
+        const match = found.find((line) => line && !/\\Windows\\(?:System32|Sysnative)\\bash\.exe$/i.test(line));
+        return match || null;
+    }
+    catch {
+        return null;
+    }
+}
+function bashOnPath() {
+    return String(execFileSync("where.exe", ["bash"], {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "ignore"],
+    }))
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export function shell() {
+    return process.env.SHELL || bashExecutable() || "powershell.exe";
+}
+function bashStyle(file) {
+    return !/powershell|pwsh|cmd(?:\.exe)?$/i.test(file);
+}
+export function shellLaunch(spec) {
+    const file = shell();
+    if (!bashStyle(file)) {
+        if (spec.kind === "command")
+            return { file, args: ["-NoLogo", "-NoProfile", "-Command", spec.command] };
+        if (spec.kind === "program")
+            return { file, args: ["-NoLogo", "-NoProfile", "-Command", spec.executable] };
+        return { file, args: ["-NoLogo"] };
+    }
+    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 async function pickFolder() {
+    try {
+        const { stdout } = await runPowerShell(`
+Add-Type -AssemblyName System.Windows.Forms
+$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+$dialog.Description = 'Выберите проект'
+$dialog.ShowNewFolderButton = $true
+if ($dialog.ShowDialog() -ne [System.Windows.Forms.DialogResult]::OK) { exit 1 }
+$dialog.SelectedPath
+`, { timeout: 180000, sta: true });
+        return stdout.trim() || null;
+    }
+    catch (error) {
+        const code = error.code;
+        const status = error.status;
+        if (String(code) === "1" || status === 1)
+            return null;
+        throw error;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/** Docker Desktop is the only Windows daemon Projector can start. */
+export function dockerStartPlan() {
+    const bases = [process.env.ProgramFiles, process.env.ProgramW6432, "C:\\Program Files"];
+    for (const base of bases) {
+        if (!base)
+            continue;
+        const exe = join(base, "Docker", "Docker", "Docker Desktop.exe");
+        if (existsSync(exe))
+            return { label: "Запустить Docker Desktop", command: exe, args: [] };
+    }
+    return {
+        label: "Docker Desktop не найден",
+        manual: "Установите Docker Desktop: https://docs.docker.com/desktop/setup/install/windows-install/",
+    };
+}

package/packages/core/modules/os/modules/windows/git.js

@@ -0,0 +1,42 @@
+import { rename } from "node:fs/promises";
+/** Both values are spliced into script text, so anything but plain identifiers is refused. */
+export function checkAskpass({ username, tokenEnv }) {
+    if (!/^[\w.-]+$/.test(username) || !/^[A-Za-z_]\w*$/.test(tokenEnv))
+        throw new Error("Недопустимые параметры askpass");
+}
+/** Git cannot execute a shebang script on Windows, so the helper is a `.cmd` file. */
+export function gitAskpass(credentials) {
+    checkAskpass(credentials);
+    return {
+        filename: "askpass.cmd",
+        contents: [
+            "@echo off",
+            "setlocal EnableExtensions EnableDelayedExpansion",
+            // Quoted assignment and delayed expansion keep `&`, `^` and `%` in the prompt or token inert.
+            `set "ask=%~1"`,
+            `if not "!ask:Username=!"=="!ask!" (`,
+            `  echo(${credentials.username}`,
+            ") else (",
+            `  echo(!${credentials.tokenEnv}!`,
+            ")",
+            "",
+        ].join("\r\n"),
+    };
+}
+/** Windows refuses to rename onto an existing directory, so the rename is itself the atomic claim. */
+export async function publishDirectory(source, destination) {
+    try {
+        await rename(source, destination);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "EPERM" || code === "EACCES" || code === "ENOTEMPTY") {
+            const { lstat } = await import("node:fs/promises");
+            if (await lstat(destination).then(() => true, () => false))
+                throw Object.assign(new Error("Папка уже существует"), { code: "EEXIST" });
+        }
+        throw error;
+    }
+}
+/** Agent host sockets are named pipes here: nothing is left on disk. */
+export async function removeAgentHostAddress() { }

package/packages/core/modules/os/modules/windows/hwnd.js

@@ -0,0 +1,275 @@
+import { createInterface } from "node:readline";
+import { spawnPowerShell } from "./ps.js";
+/**
+ * The only place that touches HWNDs. The GTK palette (via its GdkWin32 surface), the Chromium
+ * app windows (found by the marker in their command line) and the tray all go through here.
+ */
+const WINDOW_HELPER = `
+Add-Type -TypeDefinition @"
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class ProjectorWindows {
+  public delegate bool EnumProc(IntPtr hWnd, IntPtr lParam);
+  [DllImport("user32.dll")] static extern bool EnumWindows(EnumProc lp, IntPtr l);
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);
+  [DllImport("user32.dll", CharSet=CharSet.Unicode)] static extern int GetWindowTextLength(IntPtr hWnd);
+  [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr hWnd, int cmd);
+  [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr hWnd);
+  [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] static extern bool PostMessage(IntPtr hWnd, uint msg, IntPtr w, IntPtr l);
+  [DllImport("user32.dll")] static extern bool SetProcessDpiAwarenessContext(IntPtr value);
+  [DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+  [DllImport("user32.dll")] static extern bool GetCursorPos(out POINT point);
+  [DllImport("user32.dll")] static extern IntPtr MonitorFromPoint(POINT point, uint flags);
+  [DllImport("user32.dll")] static extern IntPtr MonitorFromWindow(IntPtr hWnd, uint flags);
+  [DllImport("user32.dll", CharSet=CharSet.Unicode)] static extern bool GetMonitorInfo(IntPtr monitor, ref MONITORINFO info);
+  [DllImport("user32.dll")] static extern bool SetWindowPos(IntPtr hWnd, IntPtr insertAfter, int x, int y, int cx, int cy, uint flags);
+  [StructLayout(LayoutKind.Sequential)] public struct POINT { public int X, Y; }
+  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left, Top, Right, Bottom; }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] public struct MONITORINFO {
+    public int cbSize; public RECT rcMonitor; public RECT rcWork; public uint dwFlags;
+  }
+  static ProjectorWindows() { try { SetProcessDpiAwarenessContext(new IntPtr(-4)); } catch { } }
+  public static string Find(string pids) {
+    var wanted = new HashSet<uint>();
+    foreach (var part in pids.Split(',')) { uint id; if (uint.TryParse(part, out id)) wanted.Add(id); }
+    IntPtr found = IntPtr.Zero;
+    EnumWindows((h, l) => {
+      uint pid; GetWindowThreadProcessId(h, out pid);
+      if (wanted.Contains(pid) && GetWindowTextLength(h) > 0) { found = h; return false; }
+      return true;
+    }, IntPtr.Zero);
+    return found.ToInt64().ToString();
+  }
+  public static string Foreground() { return GetForegroundWindow().ToInt64().ToString(); }
+  public static void Show(long hwnd) { var h = new IntPtr(hwnd); ShowWindow(h, 9); SetForegroundWindow(h); }
+  public static void Place(long hwnd) {
+    var h = new IntPtr(hwnd);
+    RECT rect;
+    POINT point;
+    var monitor = GetCursorPos(out point) ? MonitorFromPoint(point, 2) : MonitorFromWindow(h, 2);
+    var info = new MONITORINFO();
+    info.cbSize = Marshal.SizeOf(typeof(MONITORINFO));
+    if (GetWindowRect(h, out rect) && monitor != IntPtr.Zero && GetMonitorInfo(monitor, ref info)) {
+      int width = rect.Right - rect.Left;
+      int height = rect.Bottom - rect.Top;
+      int x = info.rcWork.Left + (info.rcWork.Right - info.rcWork.Left - width) / 2;
+      int y = info.rcWork.Top + (info.rcWork.Bottom - info.rcWork.Top - height) / 2;
+      // TOPMOST, then NOTOPMOST. Both are async so the GTK thread is not waited on.
+      SetWindowPos(h, new IntPtr(-1), x, y, 0, 0, 0x4041);
+      SetWindowPos(h, new IntPtr(-2), 0, 0, 0, 0, 0x4003);
+    }
+  }
+  public static void Hide(long hwnd) { ShowWindow(new IntPtr(hwnd), 0); }
+  public static void Close(long hwnd) { PostMessage(new IntPtr(hwnd), 0x0010, IntPtr.Zero, IntPtr.Zero); }
+}
+"@
+function Emit([string]$text) {
+  [Console]::Out.WriteLine($text)
+  [Console]::Out.Flush()
+}
+Emit "ready"
+while ($true) {
+  $line = [Console]::In.ReadLine()
+  if ($null -eq $line -or $line -eq "quit") { break }
+  $parts = $line.Trim().Split(" ".ToCharArray(), 3)
+  if ($parts.Length -lt 2) { continue }
+  $id = $parts[0]
+  $op = $parts[1]
+  $arg = if ($parts.Length -ge 3) { $parts[2] } else { "" }
+  $result = ""
+  try {
+    switch ($op) {
+      "find" {
+        $marker = "--class=" + $arg
+        $pids = @(Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and $_.CommandLine.Contains($marker) } | ForEach-Object { $_.ProcessId }) -join ","
+        if ($pids) { $result = [ProjectorWindows]::Find($pids) }
+      }
+      "foreground" { $result = [ProjectorWindows]::Foreground() }
+      "show" { [ProjectorWindows]::Show([int64]$arg) }
+      "place" { [ProjectorWindows]::Place([int64]$arg) }
+      "hide" { [ProjectorWindows]::Hide([int64]$arg) }
+      "close" { [ProjectorWindows]::Close([int64]$arg) }
+    }
+  } catch {}
+  Emit "done $id $result"
+}
+`;
+let host;
+let input;
+let pending = new Map();
+let nextId = 0;
+let ready;
+const defaultSpawn = () => spawnPowerShell(WINDOW_HELPER);
+let spawnHost = defaultSpawn;
+function report(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    if (text)
+        console.error("Окно:", text);
+}
+function failPending() {
+    for (const request of pending.values()) {
+        clearTimeout(request.timer);
+        request.resolve("");
+    }
+    pending = new Map();
+}
+function dropHost(proc) {
+    if (host !== proc)
+        return;
+    host = undefined;
+    input = undefined;
+    ready = undefined;
+}
+/** One PowerShell process: compiling the Win32 helper on every show left the palette invisible for seconds. */
+function startHost() {
+    if (ready && host && host.exitCode === null && !host.signalCode)
+        return ready;
+    const proc = spawnHost();
+    proc.unref();
+    host = proc;
+    // Importing the OS facade on Linux must not register Windows process hooks.
+    const stopOnExit = () => proc.kill();
+    process.once("exit", stopOnExit);
+    proc.once("close", () => process.off("exit", stopOnExit));
+    ready = new Promise((resolve, reject) => {
+        const stdin = proc.stdin;
+        const stdout = proc.stdout;
+        // The process lives as long as the resident. An unread stderr pipe fills and blocks PowerShell.
+        let noted = false;
+        proc.stderr?.on("data", (chunk) => {
+            if (noted)
+                return;
+            const text = chunk.toString().trim();
+            if (!text)
+                return;
+            noted = true;
+            console.error("Окно:", text.slice(0, 500));
+        });
+        let opened = false;
+        let timer;
+        const settle = (error) => {
+            if (opened)
+                return;
+            opened = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        proc.once("error", (error) => {
+            settle(error);
+        });
+        proc.once("exit", () => {
+            failPending();
+            settle(new Error("window helper exited"));
+            dropHost(proc);
+        });
+        if (!stdin || !stdout) {
+            settle(new Error("window helper stdio"));
+            return;
+        }
+        input = stdin;
+        stdin.on("error", () => undefined);
+        const lines = createInterface({ input: stdout });
+        timer = setTimeout(() => {
+            proc.kill();
+            settle(new Error("window helper timeout"));
+        }, 8000);
+        lines.on("line", (line) => {
+            const text = line.trim();
+            if (text === "ready") {
+                settle();
+                return;
+            }
+            const match = /^done (\S+)(?: (.*))?$/.exec(text);
+            if (!match)
+                return;
+            const request = pending.get(match[1]);
+            if (!request)
+                return;
+            clearTimeout(request.timer);
+            pending.delete(match[1]);
+            request.resolve((match[2] ?? "").trim());
+        });
+    });
+    ready.catch((error) => {
+        report(error);
+        dropHost(proc);
+    });
+    return ready;
+}
+/** Tests stand in for PowerShell. `null` restores the real helper. */
+export function setWindowHostSpawn(spawn) {
+    spawnHost = spawn ?? defaultSpawn;
+}
+export function windowHostPid() {
+    return host && host.exitCode === null && !host.signalCode ? host.pid : undefined;
+}
+export async function stopWindowHost() {
+    const proc = host;
+    const stdin = input;
+    if (!proc || proc.exitCode !== null || proc.signalCode) {
+        if (proc)
+            dropHost(proc);
+        proc?.stdin?.destroy();
+        proc?.stdout?.destroy();
+        proc?.stderr?.destroy();
+        return;
+    }
+    stdin?.write("quit\n");
+    stdin?.end();
+    await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            proc.kill();
+            resolve();
+        }, 1000);
+        proc.once("exit", () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+    proc.stdin?.destroy();
+    proc.stdout?.destroy();
+    proc.stderr?.destroy();
+}
+export function warmWindowHelper() {
+    void startHost().catch(() => undefined);
+}
+export async function windowCall(op, arg = "") {
+    try {
+        await startHost();
+        const stdin = input;
+        if (!stdin)
+            return "";
+        const id = String(++nextId);
+        return await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                resolve("");
+            }, 8000);
+            pending.set(id, { resolve, timer });
+            stdin.write(`${id} ${op} ${arg}\n`);
+        });
+    }
+    catch {
+        return "";
+    }
+}
+export async function findWindow(appClass) {
+    const hwnd = await windowCall("find", appClass);
+    return hwnd && hwnd !== "0" ? hwnd : null;
+}
+/** Show, place, hide and close take an HWND. A class name used to be substituted and killed the helper. */
+function hwndCall(op, hwnd) {
+    return /^-?\d+$/.test(hwnd) ? windowCall(op, hwnd) : Promise.resolve("");
+}
+export const showWindow = (hwnd) => hwndCall("show", hwnd);
+/** Center on the work area of the monitor under the cursor, then raise. */
+export const placeWindow = (hwnd) => hwndCall("place", hwnd);
+export const hideWindow = (hwnd) => hwndCall("hide", hwnd);
+export const closeWindow = (hwnd) => hwndCall("close", hwnd);
+export const foregroundWindow = (appClass) => windowCall("foreground", appClass);

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

@@ -0,0 +1,28 @@
+export { processInfo, signalProcess, processIdentity, listProcesses, snapshotProcesses, recentProcesses, trackConsole, untrackConsole, descendants, 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 const catalog = () => import(new URL("./catalog.js", import.meta.url).href);
+export const resident = () => import(new URL("./resident.js", import.meta.url).href);
+export async function desktopPid(service) {
+    const { desktopPid: readPid } = await import(new URL("./resident.js", import.meta.url).href);
+    return readPid(service);
+}
+export async function shortcutStatus() {
+    const { shortcutStatus: readStatus } = await import(new URL("./shortcut.js", import.meta.url).href);
+    return readStatus();
+}
+export async function shortcutAvailable(shortcut) {
+    const { shortcutAvailable: readAvailable } = await import(new URL("./shortcut.js", import.meta.url).href);
+    return readAvailable(shortcut);
+}
+export { gitAskpass, publishDirectory, removeAgentHostAddress } from "./git.js";
+export { installDesktop } from "./install-desktop.js";
+export { alertHiddenFailure } from "./alert.js";
+export { agentEnv, agentLaunch, agentHostAddress, killAgentTree, spawnAgentHost, spawnAgentProcess, } from "./agent-process.js";
+const secrets = () => import(new URL("./secrets.js", import.meta.url).href);
+export const secretsAvailable = async () => (await secrets()).secretsAvailable();
+export const getSecret = async (...args) => (await secrets()).getSecret(...args);
+export const setSecret = async (...args) => (await secrets()).setSecret(...args);
+export const deleteSecret = async (...args) => (await secrets()).deleteSecret(...args);

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

@@ -0,0 +1,140 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { desktopPaths } from "./directories.js";
+import { runPowerShellSync } from "./ps.js";
+/** Quote a path for VBScript string literals: wrap in " and double inner quotes. */
+function vbsQuote(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+/**
+ * Command string for WScript.Shell.Run: each argv is quoted, then the whole
+ * command is wrapped once more so the Run call sees one VB string.
+ * Result: sh.Run """C:\node.exe"" ""C:\launch.ts""", 0, False
+ */
+function vbsRunCommand(argv) {
+    const inner = argv.map((part) => `"${part.replace(/"/g, '""')}"`).join(" ");
+    return vbsQuote(inner);
+}
+/** Single-size ICO that embeds a PNG (supported since Vista; Start Menu accepts it). */
+function writeIcoFromPng(pngPath, icoPath) {
+    const png = readFileSync(pngPath);
+    const header = Buffer.alloc(6);
+    header.writeUInt16LE(0, 0);
+    header.writeUInt16LE(1, 2);
+    header.writeUInt16LE(1, 4);
+    const entry = Buffer.alloc(16);
+    entry[0] = 0; // width 256
+    entry[1] = 0; // height 256
+    entry.writeUInt16LE(1, 4);
+    entry.writeUInt16LE(32, 6);
+    entry.writeUInt32LE(png.length, 8);
+    entry.writeUInt32LE(22, 12);
+    writeFileSync(icoPath, Buffer.concat([header, entry, png]));
+}
+/**
+ * Persist `%LOCALAPPDATA%\bin` (or user-level `XDG_DATA_HOME\bin`) on the User PATH.
+ * Skips when the install target is not that canonical directory — tests redirect
+ * LOCALAPPDATA into Temp, and GetFolderPath still reports the real profile folder.
+ */
+function ensureUserPath(bin) {
+    return runPowerShellSync(`
+$bin = $env:PROJECTOR_BIN
+$localBin = Join-Path ([Environment]::GetFolderPath('LocalApplicationData')) 'bin'
+$userXdg = [Environment]::GetEnvironmentVariable('XDG_DATA_HOME', 'User')
+$xdgBin = if ($userXdg) { Join-Path $userXdg 'bin' } else { $null }
+if ($bin -ne $localBin -and $bin -ne $xdgBin) {
+  Write-Output 'path-skipped'
+  exit 0
+}
+$user = [Environment]::GetEnvironmentVariable('Path', 'User')
+if ($null -eq $user) { $user = '' }
+$parts = @($user -split ';' | Where-Object { $_ -ne '' })
+foreach ($part in $parts) {
+  if ([string]::Equals($part, $bin, [StringComparison]::OrdinalIgnoreCase)) {
+    Write-Output 'path-ok'
+    exit 0
+  }
+}
+[Environment]::SetEnvironmentVariable('Path', (($parts + $bin) -join ';'), 'User')
+Write-Output 'path-added'
+`, { env: { PROJECTOR_BIN: bin } }).trim();
+}
+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 png = join(root, "resources", "icons", "256.png");
+    const svg = join(root, "resources", "icons", "projector.svg");
+    const { applications, icons, bin } = desktopPaths();
+    mkdirSync(applications, { recursive: true });
+    mkdirSync(icons, { recursive: true });
+    mkdirSync(bin, { recursive: true });
+    let installedIcon = "";
+    if (existsSync(png)) {
+        const installedPng = join(icons, "projector.png");
+        copyFileSync(png, installedPng);
+        const installedIco = join(icons, "projector.ico");
+        writeIcoFromPng(installedPng, installedIco);
+        installedIcon = installedIco;
+    }
+    else if (existsSync(svg)) {
+        installedIcon = join(icons, "projector.svg");
+        copyFileSync(svg, installedIcon);
+    }
+    const command = join(bin, "projector.cmd");
+    writeFileSync(command, `@echo off\r\n"${process.execPath}" "${launch}" %*\r\n`);
+    // Start Menu must not flash a console: node.exe is a console-subsystem binary.
+    // wscript + Run(..., 0) hides the window the way Linux .desktop uses Terminal=false.
+    const silent = join(bin, "projector.vbs");
+    writeFileSync(silent, [
+        "' Projector — silent Start Menu launch (no console window)",
+        'Set sh = CreateObject("WScript.Shell")',
+        `sh.CurrentDirectory = ${vbsQuote(root)}`,
+        // So launch.ts can show a MessageBox if the hidden process fails.
+        'sh.Environment("Process")("PROJECTOR_FROM_SHORTCUT") = "1"',
+        `sh.Run ${vbsRunCommand([process.execPath, launch])}, 0, False`,
+        "",
+    ].join("\r\n"));
+    const wscript = join(process.env.SystemRoot || "C:\\Windows", "System32", "wscript.exe");
+    const shortcut = join(applications, "Projector.lnk");
+    runPowerShellSync(`
+$shell = New-Object -ComObject WScript.Shell
+$link = $shell.CreateShortcut($env:PROJECTOR_SHORTCUT)
+$link.TargetPath = $env:PROJECTOR_WSCRIPT
+$link.Arguments = '"' + $env:PROJECTOR_SILENT + '"'
+$link.WorkingDirectory = $env:PROJECTOR_ROOT
+$link.WindowStyle = 1
+$link.Description = 'Поиск и запуск приложений и проектов'
+if ($env:PROJECTOR_ICON) { $link.IconLocation = $env:PROJECTOR_ICON }
+$link.Save()
+`, {
+        env: {
+            PROJECTOR_SHORTCUT: shortcut,
+            PROJECTOR_WSCRIPT: wscript,
+            PROJECTOR_SILENT: silent,
+            PROJECTOR_ROOT: root,
+            PROJECTOR_ICON: installedIcon,
+        },
+    });
+    console.log(`пункт меню: ${shortcut}`);
+    console.log(`команда: ${command}`);
+    try {
+        const pathStatus = ensureUserPath(bin);
+        if (pathStatus === "path-added")
+            console.log(`PATH: добавлен ${bin} (откройте новый терминал, чтобы вызвать projector)`);
+        else if (pathStatus === "path-ok")
+            console.log(`PATH: ${bin} уже есть`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(`PATH: не обновлён (${message}); добавьте ${bin} вручную`);
+    }
+    console.log("можно закрепить Projector в меню Пуск");
+}

package/packages/core/modules/os/modules/windows/kill-tree.js

@@ -0,0 +1,26 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+/**
+ * Stops a process and everything it started with `taskkill /T /F`, bounded to two seconds. The
+ * promise settles when taskkill is done, so callers that wait for exit do not race it. A
+ * crashed server leaves its agent trees behind; see docs/os.md.
+ */
+export function killTree(pid) {
+    return new Promise((resolve) => {
+        const killer = spawn(join(process.env.SystemRoot ?? "C:\\Windows", "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        const timer = setTimeout(() => {
+            killer.kill();
+            resolve();
+        }, 2000);
+        timer.unref();
+        const done = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        killer.once("exit", done);
+        killer.once("error", done);
+    });
+}