@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/usage-analytics/limits.js

@@ -0,0 +1,144 @@
+import { expectedUsagePercent, limitPeriodSeconds, } from "../../../core/modules/usage-analytics/index.js";
+import { insertLimitSample, readLatestLimitSamples, readLimitSamples, } from "./store.js";
+const recordOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+const finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+/** One window of any adapter shape: `usedPercent`, optional reset and rate-limit flag. */
+function windowOf(value) {
+    const item = recordOf(value);
+    const raw = finite(item?.usedPercent);
+    if (!item || raw === null || raw < 0)
+        return null;
+    const resetsAt = finite(item.resetsAt);
+    return {
+        used: Math.min(100, raw),
+        resetsAt: resetsAt !== null && resetsAt > 0 ? resetsAt : null,
+        limited: item.limited === true || raw >= 100,
+    };
+}
+/** Windows of a usage answer: most adapters use `windows`, Codex keeps its only one as `weekly`. */
+export function usageWindowsOf(usage) {
+    const payload = recordOf(usage);
+    const windows = new Map();
+    if (!payload || payload.status !== "ready")
+        return windows;
+    const named = recordOf(payload.windows);
+    if (named) {
+        for (const [name, value] of Object.entries(named)) {
+            const window = windowOf(value);
+            if (window)
+                windows.set(name, window);
+        }
+    }
+    if (!windows.size) {
+        const weekly = windowOf(payload.weekly);
+        if (weekly)
+            windows.set("weekly", weekly);
+    }
+    return windows;
+}
+/**
+ * Remembers what an adapter just said. Called after every successful usage request, so the chart
+ * grows while the status bar polls and a cached answer never adds a second point.
+ */
+export function recordAgentLimits(agent, usage) {
+    try {
+        const payload = recordOf(usage);
+        if (!payload)
+            return;
+        const checkedAt = finite(payload.checkedAt);
+        const at = checkedAt !== null && checkedAt > 0 ? checkedAt : Date.now();
+        for (const [window, value] of usageWindowsOf(payload)) {
+            if (!value)
+                continue;
+            insertLimitSample({
+                agent,
+                window,
+                at,
+                used: value.used,
+                resetsAt: value.resetsAt,
+                limited: value.limited,
+            });
+        }
+    }
+    catch {
+        // A chart is not worth failing the usage request it was recorded from.
+    }
+}
+/** The last uninterrupted stretch of growth, so a reset inside the range does not skew the pace. */
+function growth(samples) {
+    let start = 0;
+    for (let index = 1; index < samples.length; index++) {
+        if (samples[index].used < samples[index - 1].used - 5)
+            start = index;
+    }
+    const stretch = samples.slice(start);
+    const points = stretch.map((sample) => ({ at: sample.at, used: sample.used }));
+    const first = stretch[0];
+    const last = stretch.at(-1);
+    if (!first || !last)
+        return { points, rate: null };
+    const hours = (last.at - first.at) / 3600000;
+    if (hours < 10 / 60)
+        return { points, rate: null };
+    const rate = (last.used - first.used) / hours;
+    return { points, rate: Number.isFinite(rate) && rate > 0 ? rate : null };
+}
+const MAX_POINTS = 240;
+function thin(points) {
+    if (points.length <= MAX_POINTS)
+        return [...points];
+    const step = Math.ceil(points.length / MAX_POINTS);
+    const kept = points.filter((_, index) => index % step === 0);
+    if (kept.at(-1) !== points.at(-1))
+        kept.push(points.at(-1));
+    return kept;
+}
+/**
+ * Limit windows as the analytics page shows them: samples of the range plus the newest look,
+ * two estimates of where the window is going, and the known cycle length for the pace.
+ */
+export function readLimitSeries(since, now = Date.now()) {
+    const latest = readLatestLimitSamples();
+    const samples = readLimitSamples(since);
+    const grouped = new Map();
+    for (const sample of samples) {
+        const key = `${sample.agent}\n${sample.window}`;
+        const list = grouped.get(key);
+        if (list)
+            list.push(sample);
+        else
+            grouped.set(key, [sample]);
+    }
+    const latestByKey = new Map(latest.map((sample) => [`${sample.agent}\n${sample.window}`, sample]));
+    for (const key of latestByKey.keys())
+        if (!grouped.has(key))
+            grouped.set(key, []);
+    const series = [];
+    for (const [key, list] of grouped) {
+        const newest = latestByKey.get(key);
+        if (!newest)
+            continue;
+        if (!list.length || list.at(-1).at !== newest.at)
+            list.push(newest);
+        const { points, rate } = growth(list);
+        const periodSeconds = limitPeriodSeconds(newest.window);
+        const resetsAt = newest.resetsAt;
+        const remainingHours = resetsAt !== null ? Math.max(0, resetsAt - now / 1000) / 3600 : null;
+        const projected = rate !== null && remainingHours !== null
+            ? Math.min(200, Math.max(0, newest.used + rate * remainingHours))
+            : null;
+        series.push({
+            agent: newest.agent,
+            window: newest.window,
+            points: thin(points),
+            usedPercent: newest.used,
+            resetsAt,
+            limited: newest.limited,
+            periodSeconds,
+            expectedPercent: expectedUsagePercent(periodSeconds, resetsAt, now),
+            projectedPercent: projected,
+            ratePerHour: rate,
+        });
+    }
+    return series.sort((a, b) => a.agent.localeCompare(b.agent) || a.window.localeCompare(b.window));
+}

package/packages/server/modules/usage-analytics/overview.js

@@ -0,0 +1,117 @@
+import { readAgentUsage } from "../agent/index.js";
+import { loadProjects } from "../projects/index.js";
+import { readLimitSeries } from "./limits.js";
+import { readProviderSpend } from "./providers.js";
+import { taskSpend } from "../spend/index.js";
+const emptyTotals = () => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    tokens: 0,
+    answers: 0,
+    cost: 0,
+    pricedAnswers: 0,
+});
+function add(totals, record) {
+    totals.input += record.input;
+    totals.output += record.output;
+    totals.cacheRead += record.cacheRead;
+    totals.cacheWrite += record.cacheWrite;
+    totals.tokens += record.input + record.output + record.cacheRead + record.cacheWrite;
+    totals.answers += 1;
+    if (record.cost !== undefined) {
+        totals.cost += record.cost;
+        totals.pricedAnswers += 1;
+    }
+}
+/** Local calendar day of a timestamp, `YYYY-MM-DD`. */
+function dayKey(ms) {
+    const date = new Date(ms);
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${date.getFullYear()}-${month}-${day}`;
+}
+/** Midnight of the day `days - 1` days ago: the range the charts show, today included. */
+export function rangeStart(now, days) {
+    const start = new Date(now);
+    start.setHours(0, 0, 0, 0);
+    start.setDate(start.getDate() - (days - 1));
+    return start.getTime();
+}
+function daysOf(start, count) {
+    const days = [];
+    for (let index = 0; index < count; index++) {
+        const date = new Date(start);
+        date.setDate(date.getDate() + index);
+        days.push({ day: dayKey(date.getTime()), at: date.getTime(), ...emptyTotals() });
+    }
+    return days;
+}
+function breakdown(records, keyOf) {
+    const groups = new Map();
+    for (const record of records) {
+        const key = keyOf(record) || "—";
+        const group = groups.get(key) ?? { key, ...emptyTotals() };
+        add(group, record);
+        groups.set(key, group);
+    }
+    return [...groups.values()].sort((a, b) => b.tokens - a.tokens);
+}
+/** Chat answers and Projector's service calls on one scale: where the tokens actually went. */
+function taskBreakdown(records, service) {
+    const groups = new Map();
+    for (const record of records) {
+        const key = record.backend === "projector" ? "chat" : `agent:${record.backend || "unknown"}`;
+        const group = groups.get(key) ?? { key, ...emptyTotals() };
+        add(group, record);
+        groups.set(key, group);
+    }
+    for (const item of service) {
+        const group = groups.get(item.key) ?? { key: item.key, ...emptyTotals() };
+        group.input += item.input;
+        group.output += item.output;
+        group.cacheRead += item.cacheRead;
+        group.cacheWrite += item.cacheWrite;
+        group.tokens += item.tokens;
+        group.answers += item.answers;
+        group.cost += item.cost;
+        group.pricedAnswers += item.pricedAnswers;
+        groups.set(item.key, group);
+    }
+    return [...groups.values()].sort((a, b) => b.tokens - a.tokens);
+}
+/**
+ * What the chats spent in the range and how full the subscription windows are. Chat usage comes
+ * from the saved answers; limit samples are written when an adapter answers a usage request.
+ */
+export async function usageAnalytics(days, now = Date.now()) {
+    const since = rangeStart(now, days);
+    const projects = await loadProjects();
+    const projectNames = new Map(projects.map((project) => [project.id, project.name]));
+    const records = readAgentUsage(since).filter((record) => record.at >= since);
+    const service = taskSpend(since);
+    const totals = emptyTotals();
+    const daily = new Map(daysOf(since, days).map((day) => [day.day, day]));
+    for (const record of records) {
+        add(totals, record);
+        const bucket = daily.get(dayKey(record.at));
+        if (bucket)
+            add(bucket, record);
+    }
+    return {
+        days,
+        since,
+        until: now,
+        totals,
+        daily: [...daily.values()],
+        byAgent: breakdown(records, (record) => record.backend || "неизвестный"),
+        byModel: breakdown(records, (record) => record.model ?? "модель не указана"),
+        byProject: breakdown(records, (record) => projectNames.get(record.project) ?? (record.project ? "другой проект" : "Без проекта")),
+        byTask: taskBreakdown(records, service.byTask),
+        service: service.totals,
+        serviceCalls: service.calls,
+        limits: readLimitSeries(since, now),
+        providers: readProviderSpend(since),
+    };
+}

package/packages/server/modules/usage-analytics/providers.js

@@ -0,0 +1,120 @@
+import { insertProviderSample, readProviderSamples } from "./store.js";
+const recordOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+const finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+/** Amounts arrive as decimal strings; `null` means the provider sent something unusable. */
+const amountOf = (value) => {
+    if (typeof value === "number")
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    if (typeof value !== "string" || !value.trim())
+        return null;
+    const amount = Number(value);
+    return Number.isFinite(amount) && amount >= 0 ? amount : null;
+};
+const MAX_POINTS = 240;
+function thin(points) {
+    if (points.length <= MAX_POINTS)
+        return [...points];
+    const step = Math.ceil(points.length / MAX_POINTS);
+    const kept = points.filter((_, index) => index % step === 0);
+    if (kept.at(-1) !== points.at(-1))
+        kept.push(points.at(-1));
+    return kept;
+}
+/**
+ * Remembers what a provider said about its money. Called after a balance request, so the chart
+ * grows while the status bar or the provider page polls and a cached answer adds no point.
+ */
+export function recordProviderBalance(balance) {
+    try {
+        const payload = recordOf(balance);
+        if (!payload || payload.status !== "ready")
+            return;
+        const entries = payload.entries;
+        if (!Array.isArray(entries))
+            return;
+        const provider = typeof payload.providerId === "string" && payload.providerId
+            ? payload.providerId
+            : "provider";
+        const providerName = typeof payload.providerName === "string" && payload.providerName
+            ? payload.providerName
+            : provider;
+        const checkedAt = finite(payload.checkedAt) ?? Date.now();
+        for (const item of entries) {
+            const entry = recordOf(item);
+            if (!entry || typeof entry.currency !== "string" || !entry.currency)
+                continue;
+            const total = amountOf(entry.total);
+            if (total === null)
+                continue;
+            insertProviderSample({
+                provider,
+                providerName,
+                currency: entry.currency,
+                at: checkedAt,
+                total,
+                granted: amountOf(entry.granted) ?? 0,
+                toppedUp: amountOf(entry.toppedUp) ?? 0,
+            });
+        }
+    }
+    catch {
+        // A chart is not worth failing the balance request it was recorded from.
+    }
+}
+/** Balance drops are money spent; increases are top-ups and grants, not negative spend. */
+function movement(points) {
+    let spent = 0;
+    let toppedUp = 0;
+    for (let index = 1; index < points.length; index++) {
+        const before = points[index - 1].total;
+        const after = points[index].total;
+        if (after < before)
+            spent += before - after;
+        else if (after > before)
+            toppedUp += after - before;
+    }
+    return { spent, toppedUp };
+}
+/**
+ * Money the provider's API actually had and lost in the range. A sample just before the range
+ * serves as the starting balance, so the first day's spend is not lost.
+ */
+export function readProviderSpend(since) {
+    const grouped = new Map();
+    for (const sample of readProviderSamples(0)) {
+        const key = `${sample.provider}\n${sample.currency}`;
+        const list = grouped.get(key);
+        if (list)
+            list.push(sample);
+        else
+            grouped.set(key, [sample]);
+    }
+    const result = [];
+    for (const list of grouped.values()) {
+        const newest = list.at(-1);
+        if (!newest)
+            continue;
+        // The last look before the range starts the money calculation and anchors the chart.
+        const before = list.filter((sample) => sample.at < since).at(-1);
+        const inRange = list.filter((sample) => sample.at >= since);
+        const counted = before ? [before, ...inRange] : inRange;
+        const movementOfRange = movement(counted);
+        const points = thin([...(before ? [before] : []), ...inRange]).map((sample) => ({
+            at: sample.at,
+            total: sample.total,
+        }));
+        result.push({
+            provider: newest.provider,
+            label: newest.providerName || newest.provider,
+            currency: newest.currency,
+            points,
+            total: newest.total,
+            spent: movementOfRange.spent,
+            toppedUp: movementOfRange.toppedUp,
+            checkedAt: newest.at,
+        });
+    }
+    return result.sort((a, b) => Number(b.currency === "USD") - Number(a.currency === "USD") ||
+        a.label.localeCompare(b.label) ||
+        a.currency.localeCompare(b.currency));
+}

package/packages/server/modules/usage-analytics/store.js

@@ -0,0 +1,152 @@
+import { mkdirSync } from "node:fs";
+import { chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+/**
+ * Samples are tiny and plentiful: a minute of polling per window for months. Recent samples stay
+ * as they are; older ones keep the last look of each hour, and a year is the hard limit.
+ */
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS limit_samples (
+    agent TEXT NOT NULL,
+    window TEXT NOT NULL,
+    at INTEGER NOT NULL,
+    used REAL NOT NULL,
+    resets_at INTEGER,
+    limited INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (agent, window, at)
+  );
+  CREATE INDEX IF NOT EXISTS limit_samples_time ON limit_samples (at);
+  CREATE TABLE IF NOT EXISTS provider_samples (
+    provider TEXT NOT NULL,
+    provider_name TEXT NOT NULL DEFAULT '',
+    currency TEXT NOT NULL,
+    at INTEGER NOT NULL,
+    total REAL NOT NULL,
+    granted REAL NOT NULL DEFAULT 0,
+    topped_up REAL NOT NULL DEFAULT 0,
+    PRIMARY KEY (provider, currency, at)
+  );
+  CREATE INDEX IF NOT EXISTS provider_samples_time ON provider_samples (at);
+`;
+const databases = new Map();
+let lastCompact = 0;
+export function analyticsDatabase() {
+    const directory = join(dataDir(), "agent");
+    const file = join(directory, "analytics.sqlite");
+    const open = databases.get(file);
+    if (open)
+        return open;
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(file);
+    db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA synchronous = NORMAL;");
+    db.exec(SCHEMA);
+    void chmod(file, 0o600).catch(() => { });
+    databases.set(file, db);
+    return db;
+}
+/** Closes the opened database (a test removing its data directory, a restart). */
+export function closeAnalyticsStore() {
+    for (const db of databases.values())
+        db.close();
+    databases.clear();
+    lastCompact = 0;
+}
+function compact(db, now) {
+    if (now - lastCompact < 3600000)
+        return;
+    lastCompact = now;
+    db.prepare("DELETE FROM limit_samples WHERE at < ?").run(now - 365 * 86400000);
+    db.prepare("DELETE FROM provider_samples WHERE at < ?").run(now - 365 * 86400000);
+    const cutoff = now - 48 * 3600000;
+    db.prepare(`DELETE FROM limit_samples WHERE at < ? AND rowid NOT IN (
+       SELECT MAX(rowid) FROM limit_samples
+       WHERE at < ? GROUP BY agent, window, CAST(at / 3600000 AS INTEGER)
+     )`).run(cutoff, cutoff);
+    db.prepare(`DELETE FROM provider_samples WHERE at < ? AND rowid NOT IN (
+       SELECT MAX(rowid) FROM provider_samples
+       WHERE at < ? GROUP BY provider, currency, CAST(at / 3600000 AS INTEGER)
+     )`).run(cutoff, cutoff);
+}
+/** Replaces a sample of the same look; polling a cached answer must not add points. */
+export function insertLimitSample(sample) {
+    const db = analyticsDatabase();
+    const known = db
+        .prepare("SELECT 1 FROM limit_samples WHERE agent = ? AND window = ? AND at = ?")
+        .get(sample.agent, sample.window, sample.at);
+    if (known)
+        return;
+    db.prepare(`INSERT OR REPLACE INTO limit_samples (agent, window, at, used, resets_at, limited)
+     VALUES (?, ?, ?, ?, ?, ?)`).run(sample.agent, sample.window, sample.at, sample.used, sample.resetsAt ?? null, sample.limited ? 1 : 0);
+    compact(db, Date.now());
+}
+const sampleOf = (row) => ({
+    agent: row.agent,
+    window: row.window,
+    at: row.at,
+    used: row.used,
+    resetsAt: row.resets_at,
+    limited: row.limited === 1,
+});
+/** Samples of every window since `since`, oldest first. */
+export function readLimitSamples(since) {
+    const rows = analyticsDatabase()
+        .prepare("SELECT * FROM limit_samples WHERE at >= ? ORDER BY at")
+        .all(since);
+    return rows.map(sampleOf);
+}
+/** The newest sample of every window, even when it lies outside the requested range. */
+export function readLatestLimitSamples() {
+    const rows = analyticsDatabase()
+        .prepare(`SELECT samples.* FROM limit_samples AS samples
+       JOIN (
+         SELECT agent, window, MAX(at) AS at FROM limit_samples GROUP BY agent, window
+       ) AS newest
+       ON samples.agent = newest.agent AND samples.window = newest.window
+       AND samples.at = newest.at`)
+        .all();
+    return rows.map(sampleOf);
+}
+/** Replaces a provider look of the same time; a cached balance adds no point. */
+export function insertProviderSample(sample) {
+    const db = analyticsDatabase();
+    const known = db
+        .prepare("SELECT 1 FROM provider_samples WHERE provider = ? AND currency = ? AND at = ?")
+        .get(sample.provider, sample.currency, sample.at);
+    if (known)
+        return;
+    db.prepare(`INSERT OR REPLACE INTO provider_samples
+       (provider, provider_name, currency, at, total, granted, topped_up)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(sample.provider, sample.providerName, sample.currency, sample.at, sample.total, sample.granted, sample.toppedUp);
+    compact(db, Date.now());
+}
+const providerOf = (row) => ({
+    provider: row.provider,
+    providerName: row.provider_name,
+    currency: row.currency,
+    at: row.at,
+    total: row.total,
+    granted: row.granted,
+    toppedUp: row.topped_up,
+});
+/** Provider balance samples since `since`, oldest first. */
+export function readProviderSamples(since) {
+    const rows = analyticsDatabase()
+        .prepare("SELECT * FROM provider_samples WHERE at >= ? ORDER BY at")
+        .all(since);
+    return rows.map(providerOf);
+}
+/** The newest sample of every provider currency, even when it lies outside the range. */
+export function readLatestProviderSamples() {
+    const rows = analyticsDatabase()
+        .prepare(`SELECT samples.* FROM provider_samples AS samples
+       JOIN (
+         SELECT provider, currency, MAX(at) AS at FROM provider_samples
+         GROUP BY provider, currency
+       ) AS newest
+       ON samples.provider = newest.provider AND samples.currency = newest.currency
+       AND samples.at = newest.at`)
+        .all();
+    return rows.map(providerOf);
+}

package/packages/server/modules/window/desktop.js

@@ -0,0 +1,24 @@
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { os } from "../../../core/modules/os/index.js";
+const require = createRequire(import.meta.url);
+const shellHelper = fileURLToPath(new URL("../../../cli/app/desktop.js", import.meta.url));
+/** Resolve the add-on from its own package: IDE installations never need vio or GTK. */
+function nativeHelper() {
+    let entry;
+    try {
+        entry = require.resolve("@ai-projector/native/entry");
+    }
+    catch (error) {
+        if (error.code === "MODULE_NOT_FOUND")
+            return;
+        throw error;
+    }
+    const loader = createRequire(entry).resolve("@zede/vio/register");
+    return ["--import", pathToFileURL(loader).href, entry];
+}
+export const hasNativePalette = () => nativeHelper() !== undefined;
+/** Catalog and shortcut checks. Linux preloads GIO; Windows reads the Start Menu without GTK. */
+export const desktopArgs = () => (os.capabilities.giLoader ? nativeHelper() : undefined) ?? [shellHelper];
+/** Palette process. Loads GTK when this OS can host the native window. */
+export const nativeArgs = () => nativeHelper() ?? [shellHelper];

package/packages/server/modules/window/index.js

@@ -0,0 +1,8 @@
+export { openBrowser } from "./window.js";
+export { openLauncher } from "./window.js";
+export { openRoute } from "./window.js";
+export { hidePalette } from "./window.js";
+export { openWindow } from "./window.js";
+export { startTray } from "./window.js";
+export { quitDesktop } from "./window.js";
+export { desktopArgs } from "./desktop.js";

package/packages/server/modules/window/window.js

@@ -0,0 +1,86 @@
+import { spawn } from "node:child_process";
+import { os } from "../../../core/modules/os/index.js";
+import { APP_CLASS, chromeProfileDir } from "../../../core/modules/app-paths/index.js";
+import { preferences } from "../preferences/index.js";
+import { hasNativePalette, nativeArgs } from "./desktop.js";
+const PALETTE_CLASS = "ProjectorLauncher";
+export const focusAppWindow = () => os.windows.focusApp(APP_CLASS);
+export const openWindow = (url) => os.windows.open(url);
+export const openBrowser = (url) => os.windows.openBrowser(url);
+export const openOrFocusApp = (url) => os.windows.openOrFocusApp(url, APP_CLASS, chromeProfileDir());
+export const hidePalette = () => os.windows.hidePalette(PALETTE_CLASS);
+function desktopCommand(url, action) {
+    os.requireSupported("desktop shell");
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [...nativeArgs(), "native", url, action], {
+            // Та же группа, что и сервер: Ctrl+C в `vp dev` доходит до резидента и снимает трей.
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        let errors = "";
+        const timeout = setTimeout(() => {
+            const detail = errors.trim();
+            child.kill();
+            reject(new Error(detail
+                ? `Системное окно не ответило. ${detail}`
+                : "Системное окно не ответило. Проверьте GTK4 и desktop-сессию."));
+        }, 45000);
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            errors = (errors + text).slice(-8000);
+            const line = text.trim();
+            if (line)
+                console.warn(line);
+        });
+        child.stdout.on("data", (chunk) => {
+            output += chunk.toString();
+            if (!output.includes("READY"))
+                return;
+            clearTimeout(timeout);
+            child.unref();
+            resolve();
+        });
+        child.once("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        child.once("exit", (code) => {
+            clearTimeout(timeout);
+            if (!output.includes("READY"))
+                reject(new Error(errors.trim() || `Системное окно завершилось (${code})`));
+        });
+    });
+}
+export function startTray(url) {
+    return desktopCommand(url, "tray");
+}
+export async function quitDesktop(url) {
+    await os.windows.closePalette(PALETTE_CLASS);
+    await desktopCommand(url, "quit").catch(() => undefined);
+}
+export async function openLauncher(url, mode, toggle = false) {
+    let selected = mode ?? (await preferences()).mode;
+    if (selected === "native" && !hasNativePalette())
+        selected = "browser";
+    if (selected === "native")
+        await desktopCommand(url, toggle ? "toggle" : "show");
+    else {
+        await startTray(url).catch((error) => console.warn("Трей недоступен:", error.message));
+        if (selected === "window")
+            await os.windows.openPalette(url, toggle, PALETTE_CLASS, `${chromeProfileDir()}-launcher`);
+        else
+            openBrowser(url);
+    }
+    return selected;
+}
+/** Opens a workspace route. The native palette is a launcher-only surface, so it opens a browser. */
+export async function openRoute(url, route, mode) {
+    const selected = mode ?? (await preferences()).mode;
+    const target = `${url}${route}`;
+    if (selected === "window")
+        openWindow(target);
+    else
+        openBrowser(target);
+    return selected === "native" ? "browser" : selected;
+}