@ai-projector/ide 0.0.0-stage → 0.11.1

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

@@ -0,0 +1,48 @@
+import dbus from "dbus-next";
+export function sessionBus() {
+    const bus = dbus.sessionBus();
+    // Surface errors without an unhandled EventEmitter error terminating GTK.
+    bus.on("error", (error) => console.error("D-Bus:", error.message));
+    return bus;
+}
+export async function call(bus, destination, path, iface, member, signature = "", body = []) {
+    const message = new dbus.Message({
+        destination,
+        path,
+        interface: iface,
+        member,
+        signature,
+        body,
+        flags: dbus.MessageFlag.NO_AUTO_START,
+    });
+    let timer;
+    try {
+        return await Promise.race([
+            bus.call(message),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`D-Bus: ${member} не ответил`)), 3000);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Watch service restarts (Plasma or kglobalaccel), and its initial presence. */
+export async function watchName(bus, name, appeared) {
+    const proxy = await bus.getProxyObject("org.freedesktop.DBus", "/org/freedesktop/DBus");
+    const daemon = proxy.getInterface("org.freedesktop.DBus");
+    const invoke = () => {
+        void appeared().catch((error) => console.error(`${name}:`, error.message));
+    };
+    const changed = (changedName, _old, owner) => {
+        if (changedName === name && owner)
+            invoke();
+    };
+    daemon.on("NameOwnerChanged", changed);
+    if (await daemon.NameHasOwner(name))
+        await appeared();
+    return () => {
+        daemon.off("NameOwnerChanged", changed);
+    };
+}

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

@@ -0,0 +1,47 @@
+import Gio from "gi:Gio-2.0";
+import GioUnix from "gi:GioUnix-2.0";
+export function desktopApp(id) {
+    const app = GioUnix.DesktopAppInfo.new(id);
+    if (!app || !app.shouldShow())
+        throw new Error("Приложение больше не доступно");
+    return app;
+}
+export function listApplications() {
+    return Gio.AppInfo.getAll()
+        .filter((app) => app.shouldShow() && app.getId())
+        .map((app) => {
+        const id = app.getId();
+        const desktop = GioUnix.DesktopAppInfo.new(id);
+        // GLib 2.80 moved this class from Gio; older typelibs incorrectly expose
+        // its instance methods as static in generated GioUnix declarations.
+        const keywordApp = desktop;
+        return {
+            id: `app:${id}`,
+            name: app.getDisplayName(),
+            description: app.getDescription() || "приложение",
+            keywords: [app.getExecutable() || "", ...(keywordApp?.getKeywords() || [])].join(" "),
+            kind: "application",
+            icon: `/api/launcher/icon?id=${encodeURIComponent(id)}`,
+        };
+    });
+}
+export function launchApplication(id) {
+    // GIO handles Exec field codes, Terminal=true and D-Bus activation.
+    if (!desktopApp(id).launch([], new Gio.AppLaunchContext()))
+        throw new Error("Не удалось запустить приложение");
+}
+export async function applicationIcon(id) {
+    const icon = desktopApp(id).getIcon();
+    if (icon instanceof Gio.FileIcon)
+        return icon.getFile().getPath() || "";
+    const { default: Gtk } = await import("gi:Gtk-4.0");
+    const { default: Gdk } = await import("gi:Gdk-4.0");
+    Gtk.init();
+    const display = Gdk.Display.getDefault();
+    if (!display || !icon)
+        return "";
+    return (Gtk.IconTheme.getForDisplay(display)
+        .lookupByGicon(icon, 48, 1, Gtk.TextDirection.NONE, Gtk.IconLookupFlags.PRELOAD)
+        .getFile()
+        ?.getPath() || "");
+}

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

@@ -0,0 +1,49 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+export { xdgDataHome as dataHome, configHome } from "../../../os-posix/index.js";
+import { xdgDataHome as dataHome } from "../../../os-posix/index.js";
+export function shell() {
+    return process.env.SHELL || "/bin/bash";
+}
+export function shellLaunch(spec) {
+    const file = shell();
+    if (spec.kind === "command")
+        return { file, args: ["-c", spec.command] };
+    if (spec.kind === "program")
+        return { file, args: ["-i", "-c", `exec ${spec.executable}`] };
+    return { file, args: ["-i"] };
+}
+export function desktopPaths() {
+    return {
+        applications: join(dataHome(), "applications"),
+        icons: join(dataHome(), "icons/hicolor"),
+        bin: join(homedir(), ".local/bin"),
+    };
+}
+export async function pickFolder() {
+    const dialogs = [
+        { bin: "zenity", args: ["--file-selection", "--directory", "--title=Выберите проект"] },
+        { bin: "yad", args: ["--file-selection", "--directory", "--title=Выберите проект"] },
+        { bin: "kdialog", args: ["--getexistingdirectory", homedir(), "Выберите проект"] },
+    ];
+    for (const dialog of dialogs) {
+        try {
+            const { stdout } = await execute(dialog.bin, dialog.args, {
+                timeout: 180000,
+                env: process.env,
+            });
+            return stdout.trim() || null;
+        }
+        catch (error) {
+            const code = error.code;
+            if (String(code) === "1")
+                return null;
+            if (code !== "ENOENT")
+                throw error;
+        }
+    }
+    throw new Error("Нет zenity / yad / kdialog для выбора папки");
+}

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

@@ -0,0 +1,48 @@
+import { execFileSync } from "node:child_process";
+import { commandExists } from "../../../os-posix/index.js";
+function unitExists(unit) {
+    try {
+        execFileSync("systemctl", ["--user", "cat", unit], { stdio: "ignore", timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Rootless Docker and Docker Desktop are user units; the system daemon needs root rights. */
+export function dockerStartPlan() {
+    if (!commandExists("docker"))
+        return {
+            label: "Docker не установлен",
+            manual: "Установите Docker Engine: https://docs.docker.com/engine/install/",
+        };
+    if (!commandExists("systemctl"))
+        return {
+            label: "Запустить daemon",
+            manual: "Запустите daemon вручную: sudo service docker start",
+        };
+    if (unitExists("docker.service"))
+        return {
+            label: "systemctl --user start docker",
+            command: "systemctl",
+            args: ["--user", "start", "docker"],
+        };
+    if (unitExists("docker-desktop.service"))
+        return {
+            label: "systemctl --user start docker-desktop",
+            command: "systemctl",
+            args: ["--user", "start", "docker-desktop"],
+        };
+    if (process.getuid?.() === 0)
+        return { label: "systemctl start docker", command: "systemctl", args: ["start", "docker"] };
+    if (commandExists("pkexec"))
+        return {
+            label: "systemctl start docker (запросит пароль)",
+            command: "pkexec",
+            args: ["systemctl", "start", "docker"],
+        };
+    return {
+        label: "Запустить daemon",
+        manual: "Выполните в терминале: sudo systemctl start docker",
+    };
+}

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

@@ -0,0 +1,53 @@
+export { processInfo, signalProcess, processIdentity, listProcesses, listProcesses as snapshotProcesses, recentProcesses, trackConsole, untrackConsole, descendants, descendants as descendantsSync, workingDirectory, workingDirectories, } from "./processes.js";
+export { moveNoReplace, runPython, searchFiles, runBash, runDocker, runDockerSync, runNodeScript, commandExists, ptyCommand, spawnProcess, isExecutableFile, restrictToOwner, restrictToOwnerSync, } from "./tools.js";
+export { dockerStartPlan } from "./docker.js";
+export { configHome, dataHome, shell, shellLaunch, desktopPaths, pickFolder, } from "./directories.js";
+export { focusAppWindow, openWindow, openBrowser, revealInFileManager, openOrFocusApp, hidePalette, openWebPalette, closePalette, activateWindow, activateSurface, } from "./windows.js";
+export 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) {
+    if (!process.env.DBUS_SESSION_BUS_ADDRESS)
+        return;
+    const { sessionBus, call } = await import(new URL("./bus.js", import.meta.url).href);
+    const bus = sessionBus();
+    try {
+        const reply = await call(bus, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "GetConnectionUnixProcessID", "s", [service]);
+        return reply?.body[0];
+    }
+    catch {
+        return;
+    }
+    finally {
+        bus.disconnect();
+    }
+}
+export async function shortcutStatus() {
+    const { shortcutStatus } = await import(new URL("./shortcut.js", import.meta.url).href);
+    const { sessionBus } = await import(new URL("./bus.js", import.meta.url).href);
+    const bus = sessionBus();
+    try {
+        return await shortcutStatus(bus);
+    }
+    finally {
+        bus.disconnect();
+    }
+}
+export async function shortcutAvailable(shortcut) {
+    const { available } = await import(new URL("./shortcut.js", import.meta.url).href);
+    const { sessionBus } = await import(new URL("./bus.js", import.meta.url).href);
+    const bus = sessionBus();
+    try {
+        return await available(bus, shortcut);
+    }
+    finally {
+        bus.disconnect();
+    }
+}
+export { gitAskpass, publishDirectory, removeAgentHostAddress } from "../../../os-posix/index.js";
+export { installDesktop } from "./install-desktop.js";
+export { agentEnv, agentLaunch, agentHostAddress, killAgentTree, spawnAgentHost, spawnAgentProcess, } from "../../../os-posix/index.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/linux/install-desktop.js

@@ -0,0 +1,66 @@
+import { copyFileSync, mkdirSync, chmodSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { desktopPaths } from "./directories.js";
+export function installDesktop(root) {
+    const BIN = join(root, "bin/projector");
+    const ICON_SRC = join(root, "resources/icons");
+    const { applications: APPLICATIONS, icons: ICONS, bin: LOCAL_BIN } = desktopPaths();
+    function ensureDir(path) {
+        mkdirSync(path, { recursive: true });
+    }
+    function tryExec(bin, args) {
+        try {
+            execFileSync(bin, args, { stdio: "ignore" });
+        }
+        catch {
+            /* optional */
+        }
+    }
+    function installIcons() {
+        const svg = join(ICON_SRC, "projector.svg");
+        ensureDir(join(ICONS, "scalable/apps"));
+        copyFileSync(svg, join(ICONS, "scalable/apps/projector.svg"));
+        for (const size of [16, 32, 48, 64, 128, 256, 512]) {
+            const png = join(ICON_SRC, `${size}.png`);
+            const destDir = join(ICONS, `${size}x${size}/apps`);
+            ensureDir(destDir);
+            copyFileSync(png, join(destDir, "projector.png"));
+        }
+    }
+    function installDesktopEntry() {
+        ensureDir(APPLICATIONS);
+        const icon = join(ICONS, "512x512/apps/projector.png");
+        const body = `[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Projector
+Comment=Поиск и запуск приложений и проектов
+Exec="${BIN.replace(/([\\"`$])/g, "\\$1").replace(/%/g, "%%")}"
+TryExec=${BIN}
+Icon=${icon}
+Terminal=false
+Categories=Utility;Development;
+Keywords=applications;search;vite;pnpm;projects;launcher;
+StartupNotify=true
+StartupWMClass=Projector
+SingleMainWindow=true
+X-GNOME-SingleWindow=true
+DBusActivatable=false
+`;
+        writeFileSync(join(APPLICATIONS, "projector.desktop"), body);
+    }
+    function installBin() {
+        chmodSync(BIN, 0o755);
+        ensureDir(LOCAL_BIN);
+        execFileSync("ln", ["-sfn", BIN, join(LOCAL_BIN, "projector")]);
+    }
+    installIcons();
+    installDesktopEntry();
+    installBin();
+    tryExec("update-desktop-database", [APPLICATIONS]);
+    tryExec("gtk-update-icon-cache", ["-f", ICONS]);
+    console.log(`пункт меню: ${join(APPLICATIONS, "projector.desktop")}`);
+    console.log(`команда: ${join(LOCAL_BIN, "projector")}`);
+    console.log("можно закрепить Projector в меню пуска");
+}

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

@@ -0,0 +1,85 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { readlink } from "node:fs/promises";
+export function processInfo(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const end = stat.lastIndexOf(")");
+        const fields = stat.slice(end + 2).split(" ");
+        return {
+            pid,
+            parent: Number(fields[1]),
+            name: stat.slice(stat.indexOf("(") + 1, end),
+            started: fields[19],
+            state: fields[0],
+            group: Number(fields[2]),
+            foreground: Number(fields[5]),
+        };
+    }
+    catch (error) {
+        if (["ENOENT", "ESRCH", "EACCES"].includes(error.code ?? ""))
+            return null;
+        throw error;
+    }
+}
+export function processIdentity(pid) {
+    const info = processInfo(pid);
+    return info && info.state !== "Z" ? info.started : null;
+}
+export function listProcesses() {
+    try {
+        return readdirSync("/proc")
+            .filter((name) => /^\d+$/.test(name))
+            .flatMap((name) => {
+            try {
+                const info = processInfo(Number(name));
+                return info ? [info] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export function descendants(pid) {
+    const processes = listProcesses() ?? [];
+    const family = new Set([pid]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const entry of processes)
+            if (family.has(entry.parent) && !family.has(entry.pid)) {
+                family.add(entry.pid);
+                changed = true;
+            }
+    }
+    return processes.filter((entry) => family.has(entry.pid));
+}
+export async function workingDirectory(pid, fallback) {
+    const foreground = processInfo(pid)?.foreground ?? 0;
+    try {
+        return await readlink(`/proc/${foreground > 0 ? foreground : pid}/cwd`);
+    }
+    catch {
+        try {
+            return await readlink(`/proc/${pid}/cwd`);
+        }
+        catch {
+            return fallback;
+        }
+    }
+}
+export function signalProcess(pid, signal) {
+    process.kill(pid, signal);
+}
+/** Linux parents every program to its shell; nothing needs tracking. */
+export function trackConsole(_pid) { }
+export function untrackConsole(_pid) { }
+export const recentProcesses = (_maxAgeMs) => listProcesses();
+export async function workingDirectories(pid, fallback) {
+    return [await workingDirectory(pid, fallback)];
+}

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

@@ -0,0 +1,139 @@
+import dbus from "dbus-next";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { sessionBus, call } from "./bus.js";
+import { Shortcut } from "./shortcut.js";
+import { startTray } from "./tray.js";
+const name = "dev.projector.Launcher";
+const path = "/dev/projector/Launcher";
+const iface = "dev.projector.Launcher.Control";
+const actions = ["show", "toggle", "tray", "quit"];
+class Control extends dbus.interface.Interface {
+    dispatch;
+    constructor(dispatch) {
+        super(iface);
+        this.dispatch = dispatch;
+    }
+    async Command(action) {
+        if (!actions.includes(action))
+            throw new dbus.DBusError(`${iface}.Error`, "Неизвестная команда");
+        await this.dispatch(action);
+        return "READY";
+    }
+}
+Control.configureMembers({ methods: { Command: { inSignature: "s", outSignature: "s" } } });
+export async function runResident(baseUrl, action, options) {
+    if (!actions.includes(action))
+        throw new Error("Неизвестная команда");
+    const bus = sessionBus();
+    const owner = await bus.requestName(name, dbus.NameFlag.DO_NOT_QUEUE);
+    if (owner !== dbus.RequestNameReply.PRIMARY_OWNER) {
+        try {
+            // A concurrent first invocation may own the name before exporting Control.
+            for (let attempt = 0;; attempt++) {
+                try {
+                    await call(bus, name, path, iface, "Command", "s", [action]);
+                    break;
+                }
+                catch (error) {
+                    if (!(error instanceof dbus.DBusError) ||
+                        ![
+                            "org.freedesktop.DBus.Error.UnknownObject",
+                            "org.freedesktop.DBus.Error.UnknownMethod",
+                        ].includes(error.type) ||
+                        attempt >= 40)
+                        throw error;
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                }
+            }
+            console.log("READY");
+        }
+        finally {
+            bus.disconnect();
+        }
+        return;
+    }
+    if (action === "quit") {
+        console.log("READY");
+        bus.disconnect();
+        return;
+    }
+    let palette;
+    let pulse;
+    const getPalette = () => (palette ??= createPalette());
+    async function createPalette() {
+        if (!options.webPalette) {
+            const { default: Gtk } = await import("gi:Gtk-4.0");
+            const { default: GLib } = await import("gi:GLib-2.0");
+            Gtk.init();
+            const context = GLib.MainContext.default();
+            let lastActive = Date.now();
+            const pump = () => {
+                for (let step = 0; step < 64 && context.iteration(false); step++)
+                    lastActive = Date.now();
+                pulse = setTimeout(pump, Date.now() - lastActive < 2000 ? 10 : 50);
+            };
+            pump();
+        }
+        return options.createPalette(baseUrl);
+    }
+    const invoke = (run) => {
+        void getPalette()
+            .then(run)
+            .catch((error) => console.error("Палитра:", error.message));
+    };
+    let stopping = false;
+    const shortcut = new Shortcut(bus, async () => {
+        try {
+            return (JSON.parse(await readFile(join(options.dataDirectory, "launcher.json"), "utf8"))
+                .shortcut ?? "Ctrl+Alt+Space");
+        }
+        catch {
+            return "Ctrl+Alt+Space";
+        }
+    }, () => {
+        invoke((item) => item.invokeSelected(true));
+    });
+    const removeTray = await startTray(bus, () => {
+        invoke((item) => item.invokeSelected());
+    }, (path) => invoke((item) => item.openPage(path)), () => {
+        invoke((item) => item.quitProjector());
+    }, () => {
+        invoke((item) => item.restartProjector());
+    });
+    await shortcut.start().catch((error) => console.error("Хоткей:", error.message));
+    async function stop() {
+        if (stopping)
+            return;
+        stopping = true;
+        await shortcut.stop();
+        if (palette)
+            (await palette.catch(() => undefined))?.dispose();
+        clearTimeout(pulse);
+        removeTray();
+        bus.disconnect();
+    }
+    const dispatch = async (requested) => {
+        if (requested === "quit") {
+            // Send the D-Bus reply before closing its connection.
+            setTimeout(() => {
+                void stop();
+            }, 50);
+        }
+        else if (requested === "tray")
+            await shortcut.configure();
+        else if (requested === "toggle")
+            await (await getPalette()).toggle();
+        else
+            await (await getPalette()).show();
+    };
+    bus.export(path, new Control(dispatch));
+    process.once("SIGTERM", () => {
+        void stop();
+    });
+    process.once("SIGINT", () => {
+        void stop();
+    });
+    await dispatch(action);
+    console.log("READY");
+}

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

@@ -0,0 +1,118 @@
+import dbus from "dbus-next";
+const SERVICE = "org.freedesktop.secrets";
+const ROOT = "/org/freedesktop/secrets";
+const PROMPT_TIMEOUT = 120_000;
+const CALL_TIMEOUT = 5_000;
+const attributes = ({ service, account }) => ({
+    application: "projector",
+    service,
+    account,
+});
+function withTimeout(promise, ms, what) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`Secret Service: ${what} не ответил`)), ms);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
+/** Waits for the user to answer a keyring unlock/confirmation dialog. */
+async function runPrompt(bus, path) {
+    if (path === "/")
+        return true;
+    const object = await bus.getProxyObject(SERVICE, path);
+    const prompt = object.getInterface("org.freedesktop.Secret.Prompt");
+    const done = new Promise((resolve) => {
+        prompt.once("Completed", (dismissed) => resolve(!dismissed));
+    });
+    await prompt.Prompt("");
+    return withTimeout(done, PROMPT_TIMEOUT, "диалог разблокировки");
+}
+async function withService(action) {
+    if (!process.env.DBUS_SESSION_BUS_ADDRESS)
+        throw new Error("Session D-Bus недоступна");
+    const bus = dbus.sessionBus();
+    bus.on("error", () => { });
+    try {
+        const object = await withTimeout(bus.getProxyObject(SERVICE, ROOT), CALL_TIMEOUT, "подключение");
+        const service = object.getInterface("org.freedesktop.Secret.Service");
+        // `plain` keeps the secret off disk; the transport is the user's private session bus.
+        const opened = await withTimeout(service.OpenSession("plain", new dbus.Variant("s", "")), CALL_TIMEOUT, "OpenSession");
+        const session = opened[1];
+        return await action({ bus, service, session });
+    }
+    finally {
+        bus.disconnect();
+    }
+}
+async function defaultCollection(bus, service) {
+    const path = await service.ReadAlias("default");
+    if (path === "/")
+        throw new Error("В системном хранилище нет коллекции по умолчанию");
+    const object = await bus.getProxyObject(SERVICE, path);
+    const properties = object.getInterface("org.freedesktop.DBus.Properties");
+    const locked = (await properties.Get("org.freedesktop.Secret.Collection", "Locked")).value;
+    if (locked) {
+        const [, prompt] = await service.Unlock([path]);
+        if (!(await runPrompt(bus, prompt)))
+            throw new Error("Хранилище секретов не разблокировано");
+    }
+    return { path, collection: object.getInterface("org.freedesktop.Secret.Collection") };
+}
+async function find(service, key) {
+    const [unlocked, locked] = await service.SearchItems(attributes(key));
+    return { unlocked, locked };
+}
+async function unlockItems(bus, service, items) {
+    if (!items.length)
+        return;
+    const [, prompt] = await service.Unlock(items);
+    if (!(await runPrompt(bus, prompt)))
+        throw new Error("Хранилище секретов не разблокировано");
+}
+export async function secretsAvailable() {
+    try {
+        return await withService(async ({ service }) => (await service.ReadAlias("default")) !== "/");
+    }
+    catch {
+        return false;
+    }
+}
+export function getSecret(key) {
+    return withService(async ({ bus, service, session }) => {
+        const { unlocked, locked } = await find(service, key);
+        let item = unlocked[0];
+        if (!item && locked[0]) {
+            await unlockItems(bus, service, [locked[0]]);
+            item = locked[0];
+        }
+        if (!item)
+            return undefined;
+        const proxy = await bus.getProxyObject(SERVICE, item);
+        const secret = await proxy.getInterface("org.freedesktop.Secret.Item").GetSecret(session);
+        return Buffer.from(secret[2]).toString("utf8");
+    });
+}
+export function setSecret(key, label, value) {
+    return withService(async ({ bus, service, session }) => {
+        const { collection } = await defaultCollection(bus, service);
+        const [, prompt] = await collection.CreateItem({
+            "org.freedesktop.Secret.Item.Label": new dbus.Variant("s", label),
+            "org.freedesktop.Secret.Item.Attributes": new dbus.Variant("a{ss}", attributes(key)),
+        }, [session, [], Buffer.from(value, "utf8"), "text/plain"], true);
+        if (!(await runPrompt(bus, prompt)))
+            throw new Error("Сохранение секрета отклонено");
+    });
+}
+export function deleteSecret(key) {
+    return withService(async ({ bus, service }) => {
+        const { unlocked, locked } = await find(service, key);
+        await unlockItems(bus, service, locked);
+        for (const path of [...unlocked, ...locked]) {
+            const proxy = await bus.getProxyObject(SERVICE, path);
+            const prompt = await proxy.getInterface("org.freedesktop.Secret.Item").Delete();
+            await runPrompt(bus, prompt);
+        }
+    });
+}