@ai-projector/ide 0.0.0-stage → 0.11.0

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

@@ -0,0 +1,235 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import net from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { gtkAvailable } from "./gtk.js";
+import { processIdentity } from "./processes.js";
+import { startDesktopShell } from "./shell.js";
+import { focusSelf, ownWindowVisible } from "./windows.js";
+const actions = ["show", "toggle", "tray", "quit"];
+const isAction = (value) => actions.includes(value);
+const pidPath = (directory) => join(directory, "launcher.pid");
+const tokenPath = (directory) => join(directory, "launcher.token");
+/** A unix socket path is limited to about 100 bytes, so a deep data directory falls back to /tmp. */
+function socketPath(directory) {
+    const path = join(directory, "launcher.sock");
+    return path.length < 100 ? path : join(tmpdir(), `projector-launcher-${process.getuid?.()}.sock`);
+}
+let lastFailure = "";
+async function forward(action, directory) {
+    const token = (await readFile(tokenPath(directory), "utf8").catch(() => "")).trim();
+    if (!token)
+        return false;
+    return new Promise((resolve) => {
+        const socket = net.connect(socketPath(directory));
+        let buffer = "";
+        const finish = (accepted) => {
+            socket.destroy();
+            resolve(accepted);
+        };
+        // Once the command is sent it is never re-sent: a retry would run it a second time.
+        let sent = false;
+        socket.setTimeout(30_000, () => {
+            lastFailure = "тайм-аут ответа";
+            finish(sent);
+        });
+        socket.on("error", (error) => {
+            lastFailure = error.message;
+            finish(false);
+        });
+        socket.on("connect", () => {
+            sent = true;
+            socket.write(`${token} ${action}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            if (buffer.includes("READY"))
+                finish(true);
+            else if (buffer.includes("ERROR ")) {
+                console.error(buffer.trim());
+                finish(true);
+            }
+        });
+        socket.on("end", () => {
+            if (!buffer.includes("READY"))
+                lastFailure = `соединение закрыто: ${buffer.trim()}`;
+            finish(buffer.includes("READY"));
+        });
+    });
+}
+function sameToken(given, token) {
+    const a = Buffer.from(given);
+    const b = Buffer.from(token);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/**
+ * Node owns the thread, so GTK is pumped from a timer: fast while events flow, slow while idle.
+ * Every show also asks the helper to raise the process: a bare binary is not frontmost by itself.
+ */
+async function gtkPalette(baseUrl, options, setTimer) {
+    if (!gtkAvailable())
+        throw new Error("GTK4 не установлен (brew install gtk4)");
+    const { default: Gtk } = await import("gi:Gtk-4.0");
+    const { default: GLib } = await import("gi:GLib-2.0");
+    Gtk.init();
+    const context = GLib.MainLoop.new(null, false).getContext();
+    let lastActive = Date.now();
+    let stopped = false;
+    const pump = () => {
+        if (stopped)
+            return;
+        try {
+            for (let step = 0; step < 64 && context.iteration(false); step++)
+                lastActive = Date.now();
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : error);
+        }
+        setTimer(setTimeout(pump, Date.now() - lastActive < 2000 ? 10 : 50));
+    };
+    pump();
+    const inner = await options.createPalette(baseUrl);
+    /** Raising after a hide would bring the app, and with it the window, back to the front. */
+    const raise = async (action, toggles) => {
+        const wasVisible = toggles && ownWindowVisible();
+        await action();
+        if (!wasVisible)
+            focusSelf();
+    };
+    return {
+        show: () => raise(() => inner.show(), false),
+        toggle: () => {
+            const wasVisible = ownWindowVisible();
+            return inner.toggle().then(async () => {
+                if (!wasVisible)
+                    focusSelf();
+            });
+        },
+        invokeSelected: (toggle) => raise(() => inner.invokeSelected(toggle), toggle === true),
+        openPage: (path) => inner.openPage(path),
+        quitProjector: () => inner.quitProjector(),
+        restartProjector: () => inner.restartProjector(),
+        dispose: () => {
+            stopped = true;
+            inner.dispose();
+        },
+    };
+}
+/** Owns the menu-bar item and hotkey. A second launch only forwards show, toggle, tray or quit. */
+export async function runResident(baseUrl, action, options) {
+    if (!isAction(action))
+        throw new Error("Неизвестная команда");
+    const directory = options.dataDirectory;
+    // A busy resident can answer slowly. While its process lives, never start a second one.
+    for (let attempt = 0; attempt < 5; attempt++) {
+        if (await forward(action, directory)) {
+            console.log("READY");
+            return;
+        }
+        const pid = Number((await readFile(pidPath(directory), "utf8").catch(() => "")).trim());
+        if (!pid || !processIdentity(pid))
+            break;
+        if (attempt === 4)
+            throw new Error(`Резидент не отвечает (${lastFailure})`);
+    }
+    if (action === "quit") {
+        console.log("READY");
+        return;
+    }
+    await mkdir(directory, { recursive: true });
+    const token = randomBytes(24).toString("hex");
+    let pulse;
+    const palette = options.webPalette
+        ? await options.createPalette(baseUrl)
+        : await gtkPalette(baseUrl, options, (timer) => (pulse = timer));
+    let stopping = false;
+    let release = () => { };
+    const untilStop = new Promise((resolve) => (release = resolve));
+    let configure = async () => { };
+    const configured = async () => {
+        try {
+            const shortcut = JSON.parse(await readFile(join(directory, "launcher.json"), "utf8")).shortcut;
+            return typeof shortcut === "string" ? shortcut : "Ctrl+Alt+Space";
+        }
+        catch {
+            return "Ctrl+Alt+Space";
+        }
+    };
+    const report = (error) => console.error("Хоткей:", error instanceof Error ? error.message : error);
+    const dispatch = async (requested) => {
+        if (requested === "quit")
+            setTimeout(() => void stop(), 50);
+        else if (requested === "tray")
+            await configure(await configured()).catch(report);
+        else if (requested === "toggle")
+            await palette.toggle();
+        else
+            await palette.show();
+    };
+    const server = net.createServer((socket) => {
+        let buffer = "";
+        socket.on("error", () => socket.destroy());
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            const [given = "", requested = ""] = buffer.slice(0, newline).trim().split(" ");
+            if (!sameToken(given, token) || !isAction(requested))
+                return void socket.destroy();
+            void dispatch(requested)
+                .then(() => socket.end("READY\n"))
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error("Команда резиденту:", message);
+                socket.end(`ERROR ${message.replace(/\s+/g, " ")}\n`);
+            });
+        });
+    });
+    const path = socketPath(directory);
+    await rm(path, { force: true });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(path, resolve);
+    });
+    await chmod(path, 0o600).catch(() => undefined);
+    await writeFile(pidPath(directory), `${process.pid}\n`);
+    await writeFile(tokenPath(directory), `${token}\n`, { mode: 0o600 });
+    async function stop() {
+        if (stopping)
+            return;
+        stopping = true;
+        clearTimeout(pulse);
+        await shell?.stop();
+        palette.dispose();
+        server.close();
+        await rm(path, { force: true });
+        await rm(pidPath(directory), { force: true });
+        await rm(tokenPath(directory), { force: true });
+        release();
+    }
+    let shell;
+    try {
+        shell = await startDesktopShell(directory, {
+            onActivate: () => void palette.invokeSelected(),
+            onHotkey: () => void palette.invokeSelected(true),
+            onSettings: () => palette.openPage("/settings"),
+            onRestart: () => void palette.restartProjector().catch(report),
+            onQuit: () => void palette.quitProjector().catch(() => void stop()),
+        });
+        const active = shell;
+        configure = (shortcut) => active.configure(shortcut);
+        await configure(await configured()).catch(report);
+    }
+    catch (error) {
+        await stop();
+        throw error;
+    }
+    process.once("SIGTERM", () => void stop());
+    process.once("SIGINT", () => void stop());
+    await dispatch(action);
+    console.log("PALETTE:gtk");
+    console.log("READY");
+    await untilStop;
+}

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

@@ -0,0 +1,53 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+const SECURITY = "/usr/bin/security";
+const encode = (value) => Buffer.from(value, "utf8").toString("base64");
+const quote = (value) => `"${value.replace(/["\\]/g, "\\$&")}"`;
+/** Runs `security -i` so the secret travels over stdin, not through argv visible in `ps`. */
+function interactive(command) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(SECURITY, ["-i"], { stdio: ["pipe", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => (stderr += chunk));
+        child.on("error", reject);
+        child.on("close", (code) => code === 0 && !/SecKeychain|security:/.test(stderr)
+            ? resolve()
+            : reject(new Error(`Keychain: ${stderr.trim() || `код ${code}`}`)));
+        child.stdin.end(`${command}\n`);
+    });
+}
+export async function secretsAvailable() {
+    try {
+        await execute(SECURITY, ["default-keychain"], { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getSecret({ service, account }) {
+    try {
+        const { stdout } = await execute(SECURITY, ["find-generic-password", "-s", service, "-a", account, "-w"], { timeout: 120_000 });
+        return Buffer.from(stdout.trim(), "base64").toString("utf8");
+    }
+    catch (error) {
+        if (error.code === 44)
+            return undefined;
+        throw error;
+    }
+}
+export async function setSecret({ service, account }, label, value) {
+    await interactive(`add-generic-password -U -s ${quote(service)} -a ${quote(account)} -l ${quote(label)} -w ${quote(encode(value))}`);
+}
+export async function deleteSecret({ service, account }) {
+    try {
+        await execute(SECURITY, ["delete-generic-password", "-s", service, "-a", account], {
+            timeout: 120_000,
+        });
+    }
+    catch (error) {
+        if (error.code !== 44)
+            throw error;
+    }
+}

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

@@ -0,0 +1,105 @@
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { dataHome } from "./directories.js";
+import { hotkeyPath, hotkeys } from "./shortcut.js";
+const execute = promisify(execFile);
+const source = fileURLToPath(new URL("./helper.swift", import.meta.url));
+const iconPath = fileURLToPath(new URL("../../../../../../resources/icons/64.png", import.meta.url));
+/** Compiles the Swift helper once per source version; compilation needs the Xcode command line tools. */
+export async function ensureHelper() {
+    const code = await readFile(source);
+    const hash = createHash("sha256").update(code).digest("hex").slice(0, 12);
+    const directory = join(dataHome(), "projector", "native");
+    const binary = join(directory, `shell-${hash}`);
+    if (existsSync(binary))
+        return binary;
+    await mkdir(directory, { recursive: true });
+    const partial = `${binary}.${process.pid}.tmp`;
+    try {
+        await execute("swiftc", ["-O", "-o", partial, source], { timeout: 180_000 });
+    }
+    catch (error) {
+        throw new Error(`Не удалось собрать системный помощник (нужны Xcode Command Line Tools): ${error.message}`);
+    }
+    await rename(partial, binary);
+    return binary;
+}
+/** Synchronous variant for window control, which the OS facade exposes without promises. */
+export function ensureHelperSync() {
+    const hash = createHash("sha256").update(readFileSync(source)).digest("hex").slice(0, 12);
+    const directory = join(dataHome(), "projector", "native");
+    const binary = join(directory, `shell-${hash}`);
+    if (existsSync(binary))
+        return binary;
+    mkdirSync(directory, { recursive: true });
+    const partial = `${binary}.${process.pid}.tmp`;
+    execFileSync("swiftc", ["-O", "-o", partial, source], { timeout: 180_000, stdio: "ignore" });
+    renameSync(partial, binary);
+    return binary;
+}
+/** Whether another application already owns the hotkey. */
+export async function probeHotkey(shortcut) {
+    const { stdout } = await execute(await ensureHelper(), ["--probe", shortcut], {
+        timeout: 10_000,
+    });
+    return stdout.trim() === "hotkey:ok";
+}
+export async function startDesktopShell(dataDirectory, handlers) {
+    const binary = await ensureHelper();
+    const child = spawn(binary, [iconPath], { stdio: ["pipe", "pipe", "inherit"] });
+    const lines = createInterface({ input: child.stdout });
+    let pending;
+    let ready;
+    const started = new Promise((resolve) => (ready = resolve));
+    child.once("error", () => ready());
+    lines.on("line", (line) => {
+        if (line === "ready")
+            ready();
+        else if (line.startsWith("hotkey:"))
+            pending?.(line);
+        else if (line === "event:activate")
+            handlers.onActivate();
+        else if (line === "event:hotkey")
+            handlers.onHotkey();
+        else if (line === "event:settings")
+            handlers.onSettings();
+        else if (line === "event:restart")
+            handlers.onRestart();
+        else if (line === "event:quit")
+            handlers.onQuit();
+    });
+    child.once("exit", (code, signal) => {
+        console.error(`Помощник меню завершился: code=${code} signal=${signal}`);
+        handlers.onQuit();
+    });
+    await started;
+    const writeState = (shortcut, active) => mkdir(dataDirectory, { recursive: true }).then(() => writeFile(hotkeyPath(dataDirectory), JSON.stringify({ shortcut, active })));
+    return {
+        async configure(shortcut) {
+            if (!shortcut)
+                return void (await writeState("", false));
+            if (!hotkeys[shortcut]) {
+                await writeState(shortcut, false);
+                throw new Error(`Сочетание ${shortcut} не поддерживается на macOS`);
+            }
+            const reply = await new Promise((resolve) => {
+                pending = resolve;
+                child.stdin.write(`hotkey ${shortcut}\n`);
+            });
+            await writeState(shortcut, reply === "hotkey:ok");
+            if (reply !== "hotkey:ok")
+                throw new Error(`Сочетание ${shortcut} уже занято`);
+        },
+        async stop() {
+            await writeState("", false).catch(() => undefined);
+            child.stdin?.write("quit\n");
+            setTimeout(() => child.kill(), 1000).unref();
+        },
+    };
+}

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

@@ -0,0 +1,61 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dataHome } from "./directories.js";
+import { processIdentity } from "./processes.js";
+/** Names the helper understands; see `hotkeys` in helper.swift. */
+export const hotkeys = { "Ctrl+Alt+Space": true, "Alt+Space": true };
+const appDirectory = "projector";
+export function hotkeyPath(dataDirectory = join(dataHome(), appDirectory)) {
+    return join(dataDirectory, "hotkey.json");
+}
+async function readState() {
+    try {
+        const data = JSON.parse(await readFile(hotkeyPath(), "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 processIdentity(pid) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+export async function shortcutAvailable(shortcut) {
+    if (!shortcut)
+        return { supported: true, available: true };
+    if (!hotkeys[shortcut])
+        return { supported: false, available: false };
+    const state = await readState();
+    if (state?.active && state.shortcut === shortcut && (await residentAlive()))
+        return { supported: true, available: true };
+    try {
+        const { probeHotkey } = await import(new URL("./shell.js", import.meta.url).href);
+        return { supported: true, available: await probeHotkey(shortcut) };
+    }
+    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 };
+}
+export async function desktopPid(name) {
+    if (name !== "dev.projector.Launcher")
+        return;
+    try {
+        const pid = Number((await readFile(join(dataHome(), appDirectory, "launcher.pid"), "utf8")).trim());
+        return processIdentity(pid) ? pid : undefined;
+    }
+    catch {
+        return;
+    }
+}

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

@@ -0,0 +1,52 @@
+import { chmodSync, existsSync } from "node:fs";
+import { lstat, mkdir, open, rename, rmdir, unlink } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { ptyCommand as posixPtyCommand } from "../../../os-posix/index.js";
+export { runDocker, runDockerSync, runNodeScript, runBash, commandExists, spawnProcess, isExecutableFile, restrictToOwner, restrictToOwnerSync, runPython, searchFiles, } from "../../../os-posix/index.js";
+/**
+ * BSD `mv` has no `--no-target-directory`. The destination is claimed atomically first (mkdir for
+ * a directory, exclusive create for anything else) and `rename` then replaces the empty claim.
+ * An existing destination stays untouched and the source stays in place, as with GNU `mv`.
+ */
+export async function moveNoReplace(source, target) {
+    const directory = (await lstat(source)).isDirectory();
+    try {
+        if (directory)
+            await mkdir(target);
+        else
+            await (await open(target, "wx")).close();
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            return;
+        throw error;
+    }
+    try {
+        await rename(source, target);
+    }
+    catch (error) {
+        await (directory ? rmdir(target) : unlink(target)).catch(() => { });
+        throw error;
+    }
+}
+let helperChecked = false;
+/** pnpm unpacks node-pty's prebuilt `spawn-helper` without the execute bit; spawning then fails. */
+function ensurePtyHelper() {
+    if (helperChecked)
+        return;
+    helperChecked = true;
+    try {
+        const root = dirname(createRequire(import.meta.url).resolve("node-pty/package.json"));
+        const helper = join(root, "prebuilds", `darwin-${process.arch}`, "spawn-helper");
+        if (existsSync(helper))
+            chmodSync(helper, 0o755);
+    }
+    catch {
+        /* node-pty is built from source, or already usable. */
+    }
+}
+export function ptyCommand(file, args) {
+    ensurePtyHelper();
+    return posixPtyCommand(file, args);
+}

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

@@ -0,0 +1,135 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { ensureHelperSync } from "./shell.js";
+const BROWSERS = ["Google Chrome", "Chromium", "Brave Browser", "Microsoft Edge", "Arc"].map((name) => ({ name, path: `/Applications/${name}.app` }));
+function findBrowser() {
+    return BROWSERS.find((browser) => existsSync(browser.path))?.name ?? null;
+}
+function run(bin, args) {
+    const child = spawn(bin, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => { });
+    child.unref();
+}
+function openApp(browser, args) {
+    run("open", ["-na", browser, "--args", ...args]);
+}
+function http(url) {
+    if (!/^https?:\/\//i.test(url))
+        throw new Error("Допустимы только http(s) адреса");
+    return url;
+}
+/**
+ * Chromium on macOS has no window class, but it ignores unknown switches and ps lists them:
+ * `--class=<name>` marks the app process so it can be found again.
+ */
+function appPid(appClass) {
+    try {
+        const rows = execFileSync("ps", ["-axo", "pid=,args="], { encoding: "utf8" }).split("\n");
+        for (const row of rows) {
+            const match = /^\s*(\d+)\s+(.*)$/.exec(row);
+            if (match && match[2].includes(`--class=${appClass}`) && !match[2].includes("--type="))
+                return Number(match[1]);
+        }
+    }
+    catch {
+        /* ps is unavailable: nothing can be found. */
+    }
+    return null;
+}
+/** Asks the helper to act on the app; returns its state, or null when the app is gone. */
+function control(pid, command) {
+    try {
+        return execFileSync(ensureHelperSync(), ["--app", String(pid), command], {
+            encoding: "utf8",
+            timeout: 10_000,
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function focusAppWindow(appClass) {
+    const pid = appPid(appClass);
+    return pid !== null && control(pid, "activate") !== null;
+}
+export function openWindow(url) {
+    const browser = findBrowser();
+    if (browser)
+        openApp(browser, [`--app=${http(url)}`]);
+    else
+        run("open", [http(url)]);
+}
+export function openBrowser(url) {
+    run("open", [http(url)]);
+}
+/** Selects the entry in Finder. */
+export async function revealInFileManager(path) {
+    run("open", ["-R", path]);
+}
+export function openOrFocusApp(url, appClass, profile) {
+    if (focusAppWindow(appClass))
+        return;
+    const browser = findBrowser();
+    if (!browser)
+        return run("open", [http(url)]);
+    mkdirSync(profile, { recursive: true });
+    openApp(browser, [
+        `--app=${http(url)}`,
+        `--user-data-dir=${profile}`,
+        `--class=${appClass}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+    ]);
+}
+export function hidePalette(appClass) {
+    const pid = appPid(appClass);
+    if (pid !== null)
+        control(pid, "hide");
+}
+export function closePalette(appClass) {
+    const pid = appPid(appClass);
+    if (pid !== null)
+        control(pid, "terminate");
+}
+export function openWebPalette(url, toggle, appClass, profile) {
+    const pid = appPid(appClass);
+    if (pid !== null) {
+        if (toggle && control(pid, "status") === "active")
+            control(pid, "hide");
+        else
+            control(pid, "activate");
+        return;
+    }
+    const browser = findBrowser();
+    if (!browser)
+        throw new Error("Не найден Chromium-совместимый браузер; выберите режим браузера");
+    mkdirSync(profile, { recursive: true });
+    openApp(browser, [
+        `--app=${http(url)}?surface=window`,
+        `--user-data-dir=${profile}`,
+        `--class=${appClass}`,
+        "--window-size=660,500",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-features=Translate",
+    ]);
+}
+export function activateWindow(_id) { }
+export async function activateSurface(_surface) { }
+/** Raises this very process (the GTK palette is a plain binary, not an app bundle). */
+export function focusSelf() {
+    control(process.pid, "activate");
+}
+/** Whether this process has a window on screen (the GTK palette is visible). */
+export function ownWindowVisible() {
+    try {
+        const out = execFileSync(ensureHelperSync(), ["--windows", String(process.pid)], {
+            encoding: "utf8",
+            timeout: 10_000,
+        });
+        return Number(/windows:(\d+)/.exec(out)?.[1] ?? 0) > 0;
+    }
+    catch {
+        return false;
+    }
+}