@ai-projector/ide 0.0.0-stage → 0.11.1

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

@@ -0,0 +1,300 @@
+import { runPowerShell } from "./ps.js";
+function normalizeName(name) {
+    return name.replace(/\.exe$/i, "").toLowerCase();
+}
+function parseLine(line) {
+    const [pid, parent, name, started] = line.split("\t");
+    const id = Number(pid);
+    if (!Number.isSafeInteger(id) || id <= 0 || !name || !started)
+        return null;
+    // The console host is plumbing around every PTY, not a program the user started.
+    if (/^(?:conhost|openconsole)$/.test(normalizeName(name)))
+        return null;
+    return {
+        pid: id,
+        parent: Number(parent) || 0,
+        name: normalizeName(name),
+        started,
+        state: "S",
+        group: null,
+        foreground: null,
+    };
+}
+const ROW = "Write-Output ($p.ProcessId.ToString() + [char]9 + $p.ParentProcessId.ToString() + [char]9 + $name + [char]9 + $p.CreationDate.ToFileTime().ToString())";
+const LIST_SCRIPT = `
+Get-CimInstance Win32_Process | ForEach-Object {
+  $p = $_
+  if ($p.ProcessId -gt 0 -and $p.CreationDate) {
+    $name = $p.Name -replace '[\\r\\n]', ' '
+    ${ROW}
+  }
+}
+`;
+/**
+ * MSYS/Cygwin `exec` leaves the new program with a dead Win32 parent, so the parent chain loses
+ * every command run from Git Bash. The processes attached to a pseudo console are the reliable
+ * answer: that is what GetConsoleProcessList reports for the console of a tracked shell.
+ */
+const CONSOLE_SCRIPT = `
+if ($env:PROJECTOR_CONSOLE_ROOTS) {
+  Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+public static class ProjectorConsole {
+  [DllImport("kernel32.dll")] static extern bool FreeConsole();
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool AttachConsole(uint pid);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern uint GetConsoleProcessList(uint[] list, uint count);
+  public static string Members(uint pid) {
+    FreeConsole();
+    if (!AttachConsole(pid)) return "";
+    try {
+      var list = new uint[512];
+      uint n = GetConsoleProcessList(list, (uint)list.Length);
+      if (n == 0 || n > list.Length) return "";
+      var ids = new string[n];
+      for (int i = 0; i < n; i++) ids[i] = list[i].ToString();
+      return string.Join(",", ids);
+    } finally { FreeConsole(); }
+  }
+}
+"@
+  foreach ($root in $env:PROJECTOR_CONSOLE_ROOTS.Split(',')) {
+    $members = [ProjectorConsole]::Members([uint32]$root)
+    # The helper itself is attached to the console while it asks.
+    $others = @($members.Split(',') | Where-Object { $_ -ne [string]$PID }) -join ','
+    if ($others) { Write-Output ('console' + [char]9 + $root + [char]9 + $others) }
+  }
+}
+`;
+const ONE_SCRIPT = `
+$p = Get-CimInstance Win32_Process -Filter ("ProcessId=" + $env:PROJECTOR_PID)
+if (-not $p -or -not $p.CreationDate) { exit 2 }
+$name = $p.Name -replace '[\\r\\n]', ' '
+${ROW}
+`;
+let snapshot = null;
+let refreshing = null;
+/** Freshness for exact answers (kill lists, identity of unknown pids). */
+const TTL = 400;
+/** How old a listing may be before polling callers trigger a background refresh. */
+const STALE = 1500;
+const consoleRoots = new Set();
+/** Shells whose pseudo console is inspected for programs Win32 does not parent to them. */
+export function trackConsole(pid) {
+    consoleRoots.add(pid);
+    void refresh();
+}
+export function untrackConsole(pid) {
+    consoleRoots.delete(pid);
+}
+function parseRows(stdout) {
+    const lines = stdout.split(/\r?\n/).map((line) => line.trim());
+    const rows = lines
+        .map((line) => parseLine(line))
+        .filter((entry) => entry !== null);
+    const pids = new Set(rows.map((row) => row.pid));
+    for (const line of lines) {
+        const [tag, root, members] = line.split("\t");
+        if (tag !== "console" || !root || !members)
+            continue;
+        const attached = new Set(members.split(",").map(Number));
+        for (const row of rows)
+            if (attached.has(row.pid) && row.pid !== Number(root) && !attached.has(row.parent))
+                row.parent = pids.has(Number(root)) ? Number(root) : row.parent;
+    }
+    return rows;
+}
+function refresh() {
+    refreshing ??= runPowerShell(LIST_SCRIPT + CONSOLE_SCRIPT, {
+        env: { PROJECTOR_CONSOLE_ROOTS: [...consoleRoots].join(",") },
+    })
+        .then(({ stdout }) => {
+        const rows = parseRows(stdout);
+        snapshot = { at: Date.now(), rows };
+        return rows;
+    })
+        .catch(() => null)
+        .finally(() => {
+        refreshing = null;
+    });
+    return refreshing;
+}
+/**
+ * Polling view that never blocks and never spawns anything itself on the caller's time: the last
+ * known listing is returned at once and a stale one starts a background refresh. Before the first
+ * listing exists it is null.
+ */
+export function snapshotProcesses() {
+    if (!snapshot || Date.now() - snapshot.at >= STALE)
+        void refresh();
+    return snapshot?.rows ?? null;
+}
+/** The last listing if it is at most `maxAgeMs` old; never waits and never names reused pids. */
+export function recentProcesses(maxAgeMs) {
+    return snapshot && Date.now() - snapshot.at <= maxAgeMs ? snapshot.rows : null;
+}
+/** Exact view, for deciding what to signal: at most TTL old. */
+export async function listProcesses() {
+    if (snapshot && Date.now() - snapshot.at < TTL)
+        return snapshot.rows;
+    return refresh();
+}
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+};
+export async function processInfo(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    // A cached listing may still hold a process that has just exited.
+    if (!alive(pid))
+        return null;
+    if (snapshot && Date.now() - snapshot.at < TTL)
+        return snapshot.rows.find((entry) => entry.pid === pid) ?? null;
+    try {
+        const { stdout } = await runPowerShell(ONE_SCRIPT, {
+            env: { PROJECTOR_PID: String(pid) },
+            timeout: 8000,
+        });
+        const row = parseLine(stdout.trim());
+        return row?.pid === pid ? row : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function processIdentity(pid) {
+    return (await processInfo(pid))?.started ?? null;
+}
+export async function descendants(pid) {
+    const processes = (await 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));
+}
+/** Only POSIX can answer synchronously; Windows callers use `descendants`. */
+export function descendantsSync() {
+    throw new Error("Синхронный список потомков недоступен на Windows");
+}
+export function signalProcess(pid, signal) {
+    process.kill(pid, signal);
+}
+const CWD_SCRIPT = `
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class ProjectorCwd {
+  [StructLayout(LayoutKind.Sequential)]
+  struct PROCESS_BASIC_INFORMATION {
+    public IntPtr Reserved1;
+    public IntPtr PebBaseAddress;
+    public IntPtr Reserved2_0;
+    public IntPtr Reserved2_1;
+    public IntPtr UniqueProcessId;
+    public IntPtr InheritedFromUniqueProcessId;
+  }
+  [DllImport("ntdll.dll")]
+  static extern int NtQueryInformationProcess(IntPtr h, int cls, ref PROCESS_BASIC_INFORMATION info, int len, out int ret);
+  [DllImport("kernel32.dll")]
+  static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+  [DllImport("kernel32.dll")]
+  static extern bool CloseHandle(IntPtr h);
+  [DllImport("kernel32.dll")]
+  static extern bool ReadProcessMemory(IntPtr h, IntPtr addr, byte[] buf, int size, out IntPtr read);
+  static IntPtr ReadPtr(IntPtr h, IntPtr addr) {
+    var buf = new byte[8];
+    IntPtr read;
+    if (!ReadProcessMemory(h, addr, buf, 8, out read)) throw new Exception("read");
+    return new IntPtr(BitConverter.ToInt64(buf, 0));
+  }
+  public static string Read(int pid) {
+    var handle = OpenProcess(0x0410, false, pid);
+    if (handle == IntPtr.Zero) throw new Exception("open");
+    try {
+      var info = new PROCESS_BASIC_INFORMATION();
+      int ret;
+      if (NtQueryInformationProcess(handle, 0, ref info, Marshal.SizeOf(info), out ret) != 0)
+        throw new Exception("nt");
+      var parameters = ReadPtr(handle, info.PebBaseAddress + 0x20);
+      var header = new byte[16];
+      IntPtr read;
+      if (!ReadProcessMemory(handle, parameters + 0x38, header, 16, out read)) throw new Exception("cur");
+      int length = BitConverter.ToUInt16(header, 0);
+      var buffer = new IntPtr(BitConverter.ToInt64(header, 8));
+      var chars = new byte[length];
+      if (!ReadProcessMemory(handle, buffer, chars, length, out read)) throw new Exception("path");
+      return Encoding.Unicode.GetString(chars);
+    } finally { CloseHandle(handle); }
+  }
+}
+"@
+[ProjectorCwd]::Read([int]$env:PROJECTOR_PID)
+`;
+function normalizeDirectory(path) {
+    const stripped = path.replace(/^\\\?\?\\/, "").replace(/^\\\\\?\\/, "");
+    if (/^[A-Za-z]:\\$/.test(stripped))
+        return stripped;
+    return stripped.replace(/[\\/]+$/, "");
+}
+/**
+ * Git's `bin\\bash.exe` is a launcher that starts the real shell as a child and never changes
+ * directory itself. The deepest descendant with the same name is the shell the user is typing in.
+ */
+async function shellProcess(pid) {
+    const root = await processInfo(pid);
+    if (!root)
+        return pid;
+    let current = pid;
+    for (const entry of await descendants(pid))
+        if (entry.name === root.name && entry.parent === current)
+            current = entry.pid;
+    return current;
+}
+export async function workingDirectory(pid, fallback) {
+    if (!(await processInfo(pid)))
+        return fallback;
+    pid = await shellProcess(pid);
+    // PowerShell and the C# compile occasionally time out on a loaded machine; one more try is
+    // cheaper than reporting the project root as the shell's directory.
+    for (let attempt = 0; attempt < 2; attempt++)
+        try {
+            const { stdout } = await runPowerShell(CWD_SCRIPT, {
+                env: { PROJECTOR_PID: String(pid) },
+                timeout: 15000,
+            });
+            const directory = normalizeDirectory(stdout.trim());
+            if (directory)
+                return directory;
+        }
+        catch {
+            if (!(await processInfo(pid)))
+                return fallback;
+        }
+    return fallback;
+}
+/**
+ * Git Bash runs as a chain of `bash` processes, and which of them has the user's directory is
+ * not worth guessing: every one of them is asked, the deepest first.
+ */
+export async function workingDirectories(pid, fallback) {
+    const root = await processInfo(pid);
+    if (!root)
+        return [fallback];
+    const chain = (await descendants(pid)).filter((entry) => entry.name === root.name).reverse();
+    const found = await Promise.all(chain.map((entry) => workingDirectory(entry.pid, "")));
+    return [...new Set([...found.filter(Boolean), fallback])];
+}

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

@@ -0,0 +1,73 @@
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+export function decodeOutput(buffer) {
+    if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe)
+        return buffer.toString("utf16le").replace(/^\uFEFF/, "");
+    if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf)
+        return buffer.subarray(3).toString("utf8");
+    const sample = buffer.subarray(0, Math.min(buffer.length, 64));
+    let zeros = 0;
+    for (const byte of sample)
+        if (byte === 0)
+            zeros++;
+    if (sample.length > 0 && zeros > sample.length / 4)
+        return buffer.toString("utf16le").replace(/^\uFEFF/, "");
+    return buffer.toString("utf8");
+}
+function script(body) {
+    const encoded = Buffer.from([
+        "$ProgressPreference = 'SilentlyContinue'",
+        "[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $false",
+        body,
+    ].join("\n"), "utf16le").toString("base64");
+    return [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-EncodedCommand",
+        encoded,
+    ];
+}
+export function runPowerShell(body, options = {}) {
+    const args = script(body);
+    if (options.sta)
+        args.unshift("-STA");
+    const running = execute("powershell.exe", args, {
+        timeout: options.timeout ?? 15000,
+        maxBuffer: options.maxBuffer ?? 4 * 1024 * 1024,
+        windowsHide: true,
+        encoding: "buffer",
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+    });
+    running.child.stdin?.on("error", () => undefined);
+    running.child.stdin?.end(options.input ?? "");
+    return running.then(({ stdout, stderr }) => ({
+        stdout: decodeOutput(stdout),
+        stderr: decodeOutput(stderr),
+    }));
+}
+export function spawnPowerShell(body, options = {}) {
+    const args = script(body);
+    if (options.sta)
+        args.unshift("-STA");
+    return spawn("powershell.exe", args, {
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...options.env },
+    });
+}
+export function runPowerShellSync(body, options = {}) {
+    const args = script(body);
+    if (options.sta)
+        args.unshift("-STA");
+    const stdout = execFileSync("powershell.exe", args, {
+        timeout: options.timeout ?? 15000,
+        maxBuffer: 4 * 1024 * 1024,
+        windowsHide: true,
+        encoding: "buffer",
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+    });
+    return decodeOutput(stdout);
+}

package/packages/core/modules/os/modules/windows/resident-pipe.js

@@ -0,0 +1,206 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { userInfo } from "node:os";
+import { readFile, rm } from "node:fs/promises";
+import net from "node:net";
+import { join } from "node:path";
+import { dataHome } from "./directories.js";
+import { killTree } from "./kill-tree.js";
+import { processIdentity } from "./processes.js";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const service = "dev.projector.Launcher";
+const actions = ["show", "toggle", "tray", "quit"];
+/** Same directory as `dataDir()` without importing app-paths back into the OS adapter. */
+const appDirectory = "projector";
+export function isDesktopAction(value) {
+    return actions.includes(value);
+}
+/** One pipe per Windows user: a fixed name would let a second account's session collide with it. */
+function pipeName() {
+    const user = userInfo().username.replace(/[^\w.-]/g, "_");
+    return process.env.PROJECTOR_LAUNCHER_PIPE || `\\\\.\\pipe\\${service}.${user}`;
+}
+/** The pipe has the default DACL, so every command must prove it can read the user's profile. */
+function sameToken(given, token) {
+    const a = Buffer.from(given);
+    const b = Buffer.from(token);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+export function launcherPidPath(dataDirectory = join(dataHome(), appDirectory)) {
+    return join(dataDirectory, "launcher.pid");
+}
+export function launcherTokenPath(dataDirectory = join(dataHome(), appDirectory)) {
+    return join(dataDirectory, "launcher.token");
+}
+export function launcherIdentityPath(dataDirectory) {
+    return join(dataDirectory, "launcher.identity.json");
+}
+/** Named pipes carry no per-user ACL here, so commands must quote the secret kept in the profile. */
+async function readToken(dataDirectory) {
+    try {
+        return (await readFile(launcherTokenPath(dataDirectory), "utf8")).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export async function forward(action, dataDirectory, requestId = randomUUID()) {
+    const token = await readToken(dataDirectory);
+    if (!token)
+        return false;
+    return new Promise((resolve) => {
+        const socket = net.connect(pipeName());
+        let buffer = "";
+        let settled = false;
+        const finish = (accepted) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(accepted);
+        };
+        socket.setTimeout(1500, () => finish(false));
+        socket.on("error", () => finish(false));
+        socket.on("close", () => finish(false));
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            if (buffer.includes("READY"))
+                finish(true);
+        });
+        socket.on("connect", () => {
+            socket.write(`${token} ${action} ${requestId}\n`);
+        });
+    });
+}
+async function readPidFile(dataDirectory) {
+    try {
+        const pid = Number((await readFile(launcherPidPath(dataDirectory), "utf8")).trim());
+        return Number.isSafeInteger(pid) && pid > 0 ? pid : undefined;
+    }
+    catch {
+        return;
+    }
+}
+/**
+ * A busy resident can answer slowly (GTK + tray C# compile). While its pid file
+ * exists, keep forwarding instead of starting a second instance that loses on
+ * EADDRINUSE. Avoid calling processIdentity on every attempt — it shells out to
+ * PowerShell and can burn the whole READY budget under load.
+ */
+export async function waitForForward(action, dataDirectory, attempts = 8, requestId = randomUUID()) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        if (await forward(action, dataDirectory, requestId))
+            return true;
+        const pid = await readPidFile(dataDirectory);
+        if (!pid)
+            return false;
+        if (attempt + 1 >= attempts)
+            return false;
+        if (attempt === attempts - 2) {
+            const alive = await processIdentity(pid).catch(() => null);
+            if (!alive) {
+                await rm(launcherPidPath(dataDirectory), { force: true });
+                return false;
+            }
+        }
+        await sleep(100 + attempt * 100);
+    }
+    return false;
+}
+/** Drop a hung or abandoned pipe owner so this process can bind. */
+export async function reclaim(dataDirectory) {
+    const pid = await readPidFile(dataDirectory);
+    // A stale PID may have been reused. Legacy pid-only records are never enough
+    // authority to terminate a process; require the recorded Windows creation time.
+    if (pid) {
+        const identity = await readFile(launcherIdentityPath(dataDirectory), "utf8")
+            .then((value) => JSON.parse(value))
+            .catch(() => null);
+        if (identity?.pid === pid &&
+            typeof identity.started === "string" &&
+            identity.started &&
+            (await processIdentity(pid)) === identity.started)
+            await killTree(pid);
+    }
+    await rm(launcherPidPath(dataDirectory), { force: true });
+    await rm(launcherTokenPath(dataDirectory), { force: true });
+    await rm(launcherIdentityPath(dataDirectory), { force: true });
+    // Named-pipe teardown is not instantaneous after taskkill.
+    for (let attempt = 0; attempt < 20; attempt++) {
+        const free = await new Promise((resolve) => {
+            const probe = net.createServer();
+            probe.once("error", () => {
+                probe.close();
+                resolve(false);
+            });
+            probe.listen(pipeName(), () => {
+                probe.close(() => resolve(true));
+            });
+        });
+        if (free)
+            return;
+        await sleep(50);
+    }
+}
+export function pipeTaken(error) {
+    const code = error.code;
+    return code === "EADDRINUSE" || code === "EACCES";
+}
+export function bindPipe(token, dispatch) {
+    // Keep pending requests through disconnects and remember recent completions so
+    // retrying after a lost READY cannot execute a toggle twice.
+    const requests = new Map();
+    const completed = [];
+    const server = net.createServer((socket) => {
+        socket.on("error", () => socket.destroy());
+        let buffer = "";
+        let handled = false;
+        socket.on("data", (chunk) => {
+            if (handled)
+                return;
+            buffer += chunk.toString();
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            handled = true;
+            const [given, requested = "", requestId] = buffer.slice(0, newline).trim().split(" ");
+            if (!sameToken(given ?? "", token) || !isDesktopAction(requested)) {
+                socket.destroy();
+                return;
+            }
+            const previous = requestId ? requests.get(requestId) : undefined;
+            if (previous && previous.action !== requested) {
+                socket.destroy();
+                return;
+            }
+            const done = previous?.done ?? Promise.resolve().then(() => dispatch(requested));
+            if (requestId && !previous) {
+                requests.set(requestId, { action: requested, done });
+                const remember = () => {
+                    completed.push(requestId);
+                    if (completed.length > 128)
+                        requests.delete(completed.shift());
+                };
+                void done.then(remember, remember);
+            }
+            void done
+                .then(() => socket.end("READY\n"))
+                .catch((error) => {
+                console.error(error instanceof Error ? error.message : error);
+                socket.destroy();
+            });
+        });
+    });
+    return new Promise((resolve, reject) => {
+        const fail = (error) => {
+            server.close();
+            reject(error);
+        };
+        server.once("error", fail);
+        server.listen(pipeName(), () => {
+            server.off("error", fail);
+            resolve(server);
+        });
+    });
+}