@ai-projector/ide 0.0.0-stage → 0.11.1

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

@@ -0,0 +1,82 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dataHome } from "./directories.js";
+import { processIdentity } from "./processes.js";
+import { runPowerShell } from "./ps.js";
+/**
+ * MOD_NOREPEAT plus the modifiers RegisterHotKey expects. VK_SPACE is 0x20. Win+Space is
+ * absent on purpose: Windows reserves it for switching the input language.
+ */
+export const hotkeys = {
+    "Ctrl+Alt+Space": { mod: 0x4003, vk: 0x20 },
+    "Alt+Space": { mod: 0x4001, vk: 0x20 },
+};
+const appDirectory = "projector";
+export function hotkeyPath(dataDirectory = join(dataHome(), appDirectory)) {
+    return join(dataDirectory, "hotkey.json");
+}
+async function readState(dataDirectory) {
+    try {
+        const data = JSON.parse(await readFile(hotkeyPath(dataDirectory), "utf8"));
+        return typeof data.shortcut === "string" && typeof data.active === "boolean" ? data : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function residentAlive() {
+    try {
+        const pid = Number((await readFile(join(dataHome(), appDirectory, "launcher.pid"), "utf8")).trim());
+        return (await processIdentity(pid)) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+const probeTtl = 30_000;
+const probed = new Map();
+/**
+ * A thread-level RegisterHotKey needs no window, so the probe skips WinForms. Compiling the
+ * P/Invoke stub still takes a moment: the check is async and cached per shortcut.
+ */
+function probe(shortcut, spec) {
+    const cached = probed.get(shortcut);
+    if (cached && Date.now() - cached.at < probeTtl)
+        return cached.free;
+    const free = runPowerShell(`
+Add-Type -TypeDefinition 'using System;
+using System.Runtime.InteropServices;
+public static class ProjectorHotkeyProbe {
+  [DllImport("user32.dll")] public static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+  [DllImport("user32.dll")] public static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+}'
+$ok = [ProjectorHotkeyProbe]::RegisterHotKey([IntPtr]::Zero, 1, ${spec.mod}, ${spec.vk})
+if ($ok) { [void][ProjectorHotkeyProbe]::UnregisterHotKey([IntPtr]::Zero, 1) }
+Write-Output $(if ($ok) { "free" } else { "busy" })
+`, { timeout: 8000 }).then(({ stdout }) => stdout.trim() === "free");
+    probed.set(shortcut, { at: Date.now(), free });
+    free.catch(() => probed.delete(shortcut));
+    return free;
+}
+export async function shortcutAvailable(shortcut) {
+    if (!shortcut)
+        return { supported: true, available: true };
+    const spec = hotkeys[shortcut];
+    if (!spec)
+        return { supported: false, available: false };
+    const state = await readState();
+    if (state?.active && state.shortcut === shortcut && (await residentAlive()))
+        return { supported: true, available: true };
+    try {
+        return { supported: true, available: await probe(shortcut, spec) };
+    }
+    catch {
+        return { supported: false, available: false };
+    }
+}
+export async function shortcutStatus() {
+    const state = await readState();
+    if (!state?.active || !(await residentAlive()))
+        return { supported: true, active: false, shortcut: "" };
+    return { supported: true, active: true, shortcut: state.shortcut };
+}

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

@@ -0,0 +1,273 @@
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { bashExecutable } from "./directories.js";
+import { quoteForCmd } from "./agent-process.js";
+import { killTree } from "./kill-tree.js";
+import { runPowerShell } from "./ps.js";
+import { runStreamingProcess } from "../../../os-posix/index.js";
+const execute = promisify(execFile);
+/** Starts a caller-defined process with the stdio it asked for; no shell unless requested. */
+export function spawnProcess(spec) {
+    return spawn(spec.command, spec.args, {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio: spec.stdio,
+        shell: spec.shell === true,
+        windowsHide: true,
+    });
+}
+export function commandExists(bin, env) {
+    if (existsSync(bin))
+        return true;
+    try {
+        execFileSync("where.exe", [bin], {
+            stdio: "ignore",
+            windowsHide: true,
+            env: (env ?? process.env),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function dockerEnv() {
+    const env = { ...process.env };
+    for (const key of Object.keys(env))
+        if (/^DOCKER_(HOST|CONTEXT|TLS_VERIFY|CERT_PATH|API_VERSION)$/.test(key))
+            delete env[key];
+    return env;
+}
+export function runDocker(args, options = {}) {
+    if (options.onOutput)
+        return runStreamingProcess("docker", args, {
+            cwd: options.cwd,
+            timeout: options.timeout ?? 15000,
+            signal: options.signal,
+            env: dockerEnv(),
+            onOutput: options.onOutput,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+    return execute("docker", args, {
+        cwd: options.cwd,
+        timeout: options.timeout ?? 15000,
+        signal: options.signal,
+        maxBuffer: 4 * 1024 * 1024,
+        windowsHide: true,
+        env: dockerEnv(),
+    });
+}
+export function runNodeScript(script, args, options = {}) {
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !/KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL/i.test(key) &&
+        !/^DOCKER_(HOST|CONTEXT|TLS_VERIFY|CERT_PATH|API_VERSION)$/.test(key)));
+    if (options.onOutput)
+        return runStreamingProcess(process.execPath, [script, ...args], {
+            cwd: options.cwd,
+            timeout: options.timeout ?? 30000,
+            signal: options.signal,
+            env,
+            onOutput: options.onOutput,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+    return execute(process.execPath, [script, ...args], {
+        cwd: options.cwd,
+        timeout: options.timeout ?? 30000,
+        signal: options.signal,
+        maxBuffer: 4 * 1024 * 1024,
+        windowsHide: true,
+        env,
+    });
+}
+export function runDockerSync(args) {
+    return execFileSync("docker", args, {
+        env: dockerEnv(),
+        timeout: 5000,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+}
+export function runBash(command, options) {
+    const bash = bashExecutable();
+    if (!bash)
+        return Promise.reject(new Error("Не найден Bash. Установите Git Bash или задайте SHELL"));
+    return new Promise((resolve, reject) => {
+        if (options.signal?.aborted)
+            return reject(new Error("Запрос остановлен"));
+        const child = spawn(bash, ["--noprofile", "--norc", "-c", command], {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            env: Object.fromEntries(Object.entries(process.env).filter(([key]) => !/KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL/i.test(key))),
+        });
+        const stdout = [], stderr = [];
+        let bytes = 0, terminated = false;
+        const kill = () => {
+            terminated = true;
+            try {
+                child.kill();
+            }
+            catch {
+                /* Already exited. */
+            }
+            child.stdout.destroy();
+            child.stderr.destroy();
+            if (child.pid)
+                void killTree(child.pid);
+        };
+        const capture = (target, chunk) => {
+            const available = 256 * 1024 - bytes;
+            if (available > 0)
+                target.push(chunk.subarray(0, available));
+            bytes += chunk.length;
+            if (bytes > 256 * 1024)
+                kill();
+        };
+        child.stdout.on("data", (chunk) => {
+            capture(stdout, chunk);
+            options.onOutput?.(chunk.toString("utf8"), "stdout");
+        });
+        child.stderr.on("data", (chunk) => {
+            capture(stderr, chunk);
+            options.onOutput?.(chunk.toString("utf8"), "stderr");
+        });
+        const timer = setTimeout(kill, 30000);
+        options.signal?.addEventListener("abort", kill, { once: true });
+        const cleanup = () => {
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", kill);
+        };
+        child.on("error", (error) => {
+            cleanup();
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            cleanup();
+            if (child.pid)
+                void killTree(child.pid);
+            if (options.signal?.aborted)
+                return reject(new Error("Запрос остановлен"));
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                exitCode,
+                terminated,
+            });
+        });
+    });
+}
+async function pathExists(path) {
+    return lstat(path).then(() => true, (error) => {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    });
+}
+/** Same result as GNU mv --update=none --no-copy: an existing target is left untouched. */
+export async function moveNoReplace(source, target) {
+    if (await pathExists(target))
+        return { stdout: "", stderr: "" };
+    try {
+        await runPowerShell(`
+$src = $env:PROJECTOR_MOVE_SOURCE
+$dst = $env:PROJECTOR_MOVE_TARGET
+if ((Get-Item -LiteralPath $src).PSIsContainer) { [IO.Directory]::Move($src, $dst) }
+else { [IO.File]::Move($src, $dst) }
+`, { env: { PROJECTOR_MOVE_SOURCE: source, PROJECTOR_MOVE_TARGET: target } });
+    }
+    catch (error) {
+        if ((await pathExists(target)) && (await pathExists(source)))
+            return { stdout: "", stderr: "" };
+        throw error;
+    }
+    return { stdout: "", stderr: "" };
+}
+export function runPython(helper, args, options) {
+    const bin = commandExists("py") ? "py" : "python";
+    const prefix = bin === "py" ? ["-3", "-I"] : ["-I"];
+    return execute(bin, [...prefix, helper, ...args], {
+        ...options,
+        windowsHide: true,
+        env: { ...process.env, PYTHONNOUSERSITE: "1" },
+    });
+}
+export function searchFiles(args, options) {
+    return execute("rg", args, { ...options, windowsHide: true });
+}
+/**
+ * node-pty looks for the exact file name on PATH, without PATHEXT: a bare `docker` is not found
+ * although `docker.exe` is. Batch files cannot be started by CreateProcess at all, so they run
+ * through cmd.exe.
+ */
+export function ptyCommand(file, args) {
+    const direct = /[\\/]/.test(file);
+    const directories = direct ? [""] : (process.env.Path ?? process.env.PATH ?? "").split(";");
+    const extensions = /\.[A-Za-z0-9]+$/.test(file)
+        ? [""]
+        : (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+    for (const directory of directories)
+        for (const extension of extensions) {
+            const candidate = directory ? join(directory, file + extension) : file + extension;
+            if (!existsSync(candidate))
+                continue;
+            if (/\.(?:cmd|bat)$/i.test(candidate))
+                return {
+                    file: process.env.ComSpec || "cmd.exe",
+                    args: ["/d", "/s", "/c", [candidate, ...args].map(quoteForCmd).join(" ")],
+                };
+            return { file: candidate, args };
+        }
+    return { file, args };
+}
+/** Windows has no execute bit: a file runs when its extension is one of PATHEXT (plus scripts). */
+export function isExecutableFile(name, _mode) {
+    const extensions = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .filter(Boolean)
+        .map((extension) => extension.toLowerCase());
+    const lower = name.toLowerCase();
+    return [...extensions, ".ps1"].some((extension) => lower.endsWith(extension));
+}
+/** Git for Windows puts its own coreutils (`whoami`, `find`…) on PATH; the system tools are meant. */
+const system32 = (name) => join(process.env.SystemRoot ?? "C:\\Windows", "System32", name);
+let ownerSid;
+function currentSid() {
+    ownerSid ??= String(execFileSync(system32("whoami.exe"), ["/user", "/fo", "csv", "/nh"], {
+        encoding: "utf8",
+        windowsHide: true,
+    }))
+        .trim()
+        .split(",")[1]
+        .replace(/"/g, "");
+    return ownerSid;
+}
+/** Well-known groups that carry explicit entries on new files: Administrators, SYSTEM, Everyone, Users, Authenticated Users. */
+const others = ["S-1-5-32-544", "S-1-5-18", "S-1-1-0", "S-1-5-32-545", "S-1-5-11"];
+/** Everything after the grant: inheritance is gone, and the groups above lose their entries. */
+const ownerOnly = (path) => [
+    path,
+    "/inheritance:r",
+    "/grant:r",
+    `*${currentSid()}:F`,
+    ...others.filter((sid) => sid !== currentSid()).flatMap((sid) => ["/remove:g", `*${sid}`]),
+];
+/**
+ * The Windows counterpart of 0600: the inherited entries are dropped and only the current user
+ * keeps access, so other local accounts cannot read tokens and passwords.
+ */
+export async function restrictToOwner(path) {
+    const args = ownerOnly(path);
+    try {
+        await execute(system32("icacls.exe"), args, { windowsHide: true });
+    }
+    catch {
+        // Antivirus and the indexer can hold a freshly written file for a moment: one retry.
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        await execute(system32("icacls.exe"), args, { windowsHide: true });
+    }
+}
+export function restrictToOwnerSync(path) {
+    execFileSync(system32("icacls.exe"), ownerOnly(path), { stdio: "ignore", windowsHide: true });
+}

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

@@ -0,0 +1,133 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { closeWindow, findWindow, foregroundWindow, hideWindow, placeWindow, showWindow, } from "./hwnd.js";
+const BROWSERS = [
+    join(process.env.ProgramFiles || "C:\\Program Files", "Google", "Chrome", "Application", "chrome.exe"),
+    join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "Application", "chrome.exe"),
+    join(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Microsoft", "Edge", "Application", "msedge.exe"),
+    join(process.env.ProgramFiles || "C:\\Program Files", "Microsoft", "Edge", "Application", "msedge.exe"),
+    join(process.env.ProgramFiles || "C:\\Program Files", "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+    join(process.env.LOCALAPPDATA || "", "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+];
+function findBrowser() {
+    return BROWSERS.find((path) => path && existsSync(path)) ?? null;
+}
+function spawnDetached(bin, args, env) {
+    const child = spawn(bin, args, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: env ? { ...process.env, ...env } : process.env,
+    });
+    child.unref();
+}
+function openDefault(url) {
+    if (!/^https?:\/\//i.test(url))
+        throw new Error("Можно открыть только http(s)-адрес");
+    // The address travels in the environment: it is never parsed as PowerShell source.
+    spawnDetached("powershell.exe", [
+        "-NoProfile",
+        "-WindowStyle",
+        "Hidden",
+        "-Command",
+        "Start-Process -FilePath $env:PROJECTOR_URL",
+    ], { PROJECTOR_URL: url });
+}
+export function openBrowser(url) {
+    openDefault(url);
+}
+/** Selects the entry in Explorer. */
+export async function revealInFileManager(path) {
+    spawnDetached("explorer.exe", [`/select,${path}`]);
+}
+export function openWindow(url) {
+    const browser = findBrowser();
+    if (browser) {
+        spawnDetached(browser, [`--app=${url}`]);
+        return;
+    }
+    openDefault(url);
+}
+export async function focusAppWindow(appClass) {
+    const hwnd = await findWindow(appClass);
+    if (!hwnd)
+        return false;
+    await showWindow(hwnd);
+    return true;
+}
+export async function openOrFocusApp(url, appClass, profile) {
+    if (await focusAppWindow(appClass))
+        return;
+    mkdirSync(profile, { recursive: true });
+    const browser = findBrowser();
+    if (!browser) {
+        openDefault(url);
+        return;
+    }
+    spawnDetached(browser, [
+        `--app=${url}`,
+        `--user-data-dir=${profile}`,
+        `--class=${appClass}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+    ]);
+}
+export async function hidePalette(appClass) {
+    const hwnd = await findWindow(appClass);
+    if (hwnd)
+        await hideWindow(hwnd);
+}
+export async function openWebPalette(url, toggle, appClass, profile) {
+    const hwnd = await findWindow(appClass);
+    if (hwnd) {
+        const active = await foregroundWindow(appClass);
+        if (toggle && active === hwnd)
+            await hidePalette(appClass);
+        else
+            await showWindow(hwnd);
+        return;
+    }
+    const browser = findBrowser();
+    if (!browser)
+        throw new Error("Не найден Chromium-совместимый браузер; выберите режим браузера");
+    mkdirSync(profile, { recursive: true });
+    spawnDetached(browser, [
+        `--app=${url}?surface=window`,
+        `--user-data-dir=${profile}`,
+        `--class=${appClass}`,
+        "--window-size=660,500",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-features=Translate",
+    ]);
+}
+export async function closePalette(appClass) {
+    const hwnd = await findWindow(appClass);
+    if (hwnd)
+        await closeWindow(hwnd);
+}
+export async function activateWindow(id) {
+    await showWindow(String(id));
+}
+function windowHandle(handle) {
+    if (typeof handle === "bigint" || typeof handle === "number")
+        return handle > 0 ? handle : null;
+    const value = Number(handle);
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+/** Win32 foreground rules ignore a plain present(); raise the HWND explicitly. */
+export async function activateSurface(surface) {
+    try {
+        const { default: GdkWin32 } = await import("gi:GdkWin32-4.0");
+        const Win32Surface = GdkWin32.Win32Surface;
+        if (!Win32Surface || !(surface instanceof Win32Surface))
+            return;
+        const handle = windowHandle(surface.getHandle());
+        if (handle !== null)
+            await placeWindow(String(handle));
+    }
+    catch {
+        /* The surface is not a Win32 window yet. */
+    }
+}

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

@@ -0,0 +1,175 @@
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import * as linux from "./modules/linux/index.js";
+import * as darwin from "./modules/darwin/index.js";
+import * as windows from "./modules/windows/index.js";
+import { clearSessionEnv } from "./session-env.js";
+export class UnsupportedPlatformError extends Error {
+    code = "ERR_OS_UNSUPPORTED";
+    constructor(platform, operation) {
+        super(`Операция ${operation} не поддерживается на ОС ${platform}`);
+        this.name = "UnsupportedPlatformError";
+    }
+}
+/** OS selection happens once; user environment/settings are read when needed. */
+export function createOs(platform = process.platform) {
+    const implementation = platform === "linux"
+        ? linux
+        : platform === "win32"
+            ? windows
+            : platform === "darwin"
+                ? darwin
+                : null;
+    const supported = implementation !== null;
+    const nativeDesktop = platform === "linux" ||
+        platform === "win32" ||
+        (platform === "darwin" && darwin.gtkAvailable());
+    const backend = (operation) => {
+        if (!implementation)
+            throw new UnsupportedPlatformError(platform, operation);
+        return implementation;
+    };
+    const adapter = {
+        platform,
+        supported,
+        capabilities: Object.freeze({
+            nativeDesktop,
+            /** Linux catalog reads GIO inside the helper. Windows loads GTK only for the palette. */
+            gtkPalette: platform === "linux" ||
+                platform === "win32" ||
+                (platform === "darwin" && darwin.gtkAvailable()),
+            giLoader: platform === "linux",
+            processInspection: supported,
+            /** Process queries that can be answered without waiting (/proc). */
+            syncProcessInspection: platform === "linux" || platform === "darwin",
+            fileOperations: supported,
+        }),
+        homeDirectory: homedir,
+        userIdentity: () => {
+            backend("userIdentity");
+            const { uid, gid } = userInfo();
+            if (platform === "win32" && uid < 0)
+                return { uid: 1000, gid: 1000 };
+            return { uid, gid };
+        },
+        configHome: () => backend("configHome").configHome(),
+        dataHome: () => backend("dataHome").dataHome(),
+        /** Removes the named variables from `env` in place; returns the names that were present. */
+        clearSessionEnv: (names, env = process.env) => clearSessionEnv(names, env),
+        shell: () => backend("shell").shell(),
+        shellLaunch: (spec) => backend("shellLaunch").shellLaunch(spec),
+        installDesktop: (root) => backend("installDesktop").installDesktop(root),
+        alertHiddenFailure: (message) => {
+            if (platform === "win32")
+                windows.alertHiddenFailure(message);
+        },
+        desktopPaths: () => backend("desktopPaths").desktopPaths(),
+        requireSupported: (operation) => {
+            if (!supported || (operation === "native desktop" && !nativeDesktop))
+                throw new UnsupportedPlatformError(platform, operation);
+        },
+        processes: {
+            /** Last known listing without waiting; null before one exists (Windows) or when unsupported. */
+            trackConsole: (pid) => supported ? backend("processes.trackConsole").trackConsole(pid) : undefined,
+            untrackConsole: (pid) => supported ? backend("processes.untrackConsole").untrackConsole(pid) : undefined,
+            /** The last listing only if it is younger than `maxAgeMs`. */
+            recent: (maxAgeMs) => supported ? backend("processes.recent").recentProcesses(maxAgeMs) : null,
+            snapshot: () => (supported ? backend("processes.snapshot").snapshotProcesses() : null),
+            list: async () => (supported ? await backend("processes.list").listProcesses() : null),
+            signal: (pid, signal) => backend("processes.signal").signalProcess(pid, signal),
+            descendants: async (pid) => await backend("processes.descendants").descendants(pid),
+            /** Only where `capabilities.syncProcessInspection`: needed while the process is exiting. */
+            descendantsSync: (pid) => backend("processes.descendantsSync").descendantsSync(pid),
+            identity: async (pid) => await backend("processes.identity").processIdentity(pid),
+            workingDirectories: (pid, fallback) => backend("processes.workingDirectories").workingDirectories(pid, fallback),
+            workingDirectory: (pid, fallback) => backend("processes.workingDirectory").workingDirectory(pid, fallback),
+            async waitForExit(pid, timeoutMs = 15000) {
+                if ((await adapter.processes.identity(pid)) === null)
+                    return;
+                // Signal 0 only probes existence. Reading the identity on every tick would start a
+                // process listing per tick on Windows; a pid cannot be recycled within the timeout.
+                const alive = () => {
+                    try {
+                        process.kill(pid, 0);
+                        return true;
+                    }
+                    catch (error) {
+                        return error.code === "EPERM";
+                    }
+                };
+                const deadline = Date.now() + timeoutMs;
+                while (alive()) {
+                    if (Date.now() >= deadline)
+                        throw new Error(`Процесс ${pid} не завершился`);
+                    await sleep(50);
+                }
+            },
+        },
+        tools: {
+            commandExists: (bin, env) => backend("commandExists").commandExists(bin, env),
+            agentEnv: (base) => backend("agentEnv").agentEnv(base),
+            spawnAgentProcess: (spec) => backend("spawnAgentProcess").spawnAgentProcess(spec),
+            agentLaunch: (spec) => backend("agentLaunch").agentLaunch(spec),
+            agentHostAddress: (dir) => backend("agentHostAddress").agentHostAddress(dir),
+            spawnAgentHost: (spec) => backend("spawnAgentHost").spawnAgentHost(spec),
+            killAgentTree: (pid) => backend("killAgentTree").killAgentTree(pid),
+            spawnProcess: (spec) => backend("spawnProcess").spawnProcess(spec),
+            dockerStartPlan: () => backend("dockerStartPlan").dockerStartPlan(),
+            runDockerSync: (args) => backend("runDockerSync").runDockerSync(args),
+            runDocker: (args, options) => backend("runDocker").runDocker(args, options),
+            runNodeScript: (script, args, options) => backend("runNodeScript").runNodeScript(script, args, options),
+            runBash: (command, options) => backend("runBash").runBash(command, options),
+            /** 0600 on POSIX; on Windows only the current user stays in the file's ACL. */
+            restrictToOwner: (path) => backend("restrictToOwner").restrictToOwner(path),
+            restrictToOwnerSync: (path) => backend("restrictToOwnerSync").restrictToOwnerSync(path),
+            isExecutableFile: (name, mode) => backend("isExecutableFile").isExecutableFile(name, mode),
+            ptyCommand: (file, args) => backend("ptyCommand").ptyCommand(file, args),
+            gitAskpass: (spec) => backend("gitAskpass").gitAskpass(spec),
+            /** Moves `source` to a new `destination`; an existing one rejects with code `EEXIST`. */
+            publishDirectory: (source, destination) => backend("publishDirectory").publishDirectory(source, destination),
+            removeAgentHostAddress: (dir, address) => backend("removeAgentHostAddress").removeAgentHostAddress(dir, address),
+            moveNoReplace: (source, target) => backend("moveNoReplace").moveNoReplace(source, target),
+            runPython: (helper, args, options) => backend("runPython").runPython(helper, args, options),
+            searchFiles: (args, options) => backend("searchFiles").searchFiles(args, options),
+        },
+        windows: {
+            focusApp: (appClass) => backend("focusApp").focusAppWindow(appClass),
+            open: (url) => backend("openWindow").openWindow(url),
+            openBrowser: (url) => backend("openBrowser").openBrowser(url),
+            openOrFocusApp: (url, appClass, profile) => backend("openOrFocusApp").openOrFocusApp(url, appClass, profile),
+            hidePalette: (appClass) => backend("hidePalette").hidePalette(appClass),
+            openPalette: (url, toggle, appClass, profile) => backend("openPalette").openWebPalette(url, toggle, appClass, profile),
+            closePalette: (appClass) => backend("closePalette").closePalette(appClass),
+            activate: (id) => backend("activateWindow").activateWindow(id),
+            activateSurface: (surface) => backend("activateSurface").activateSurface(surface),
+        },
+        /** OS secret store (Linux: Secret Service over D-Bus). `available` never throws. */
+        secrets: {
+            available: () => supported ? backend("secrets.available").secretsAvailable() : Promise.resolve(false),
+            get: (key) => backend("secrets.get").getSecret(key),
+            set: (key, label, value) => backend("secrets.set").setSecret(key, label, value),
+            delete: (key) => backend("secrets.delete").deleteSecret(key),
+        },
+        pickFolder: () => backend("pickFolder").pickFolder(),
+        /** Shows a file or folder in the desktop file manager; path must be absolute. */
+        revealInFileManager: (path) => backend("revealInFileManager").revealInFileManager(path),
+        catalog: () => backend("catalog").catalog(),
+        async runDesktop(url, action, options) {
+            if (!supported || (!options.webPalette && !nativeDesktop))
+                throw new UnsupportedPlatformError(platform, "runDesktop");
+            const { runResident } = await backend("runDesktop").resident();
+            return runResident(url, action, options);
+        },
+        desktopPid: (service) => supported ? backend("desktopPid").desktopPid(service) : Promise.resolve(undefined),
+        shortcutStatus: () => supported
+            ? backend("shortcutStatus").shortcutStatus()
+            : Promise.resolve({ supported: false, active: false, shortcut: "" }),
+        shortcutAvailable: (shortcut) => supported
+            ? backend("shortcutAvailable").shortcutAvailable(shortcut)
+            : Promise.resolve({ supported: false, available: false }),
+        toolchainBin: () => join(homedir(), ".vite-plus/bin"),
+    };
+    return Object.freeze(adapter);
+}
+export const os = createOs();

package/packages/core/modules/os/session-env.js

@@ -0,0 +1,11 @@
+/** Removes the named variables from `env` in place and returns the names that were present. */
+export function clearSessionEnv(names, env = process.env) {
+    const removed = [];
+    for (const name of names) {
+        if (env[name] === undefined)
+            continue;
+        delete env[name];
+        removed.push(name);
+    }
+    return removed;
+}