@astralyn/sash 0.1.0

package/dist/profiles.js

@@ -0,0 +1,182 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { atomicWriteFileSync } from "./fs-atomic.js";
+import { isPlainObject } from "./json-shape.js";
+import { isValidMihomoConfig, PROFILE_DOWNLOAD_SIZE_LIMIT, } from "./mihomo-config.js";
+import { sashLayout } from "./paths.js";
+export const DEFAULT_PROFILE_INTERVAL_HOURS = 24;
+export const MAX_PROFILE_INTERVAL_HOURS = 24 * 365;
+export const PROFILE_INDEX_SIZE_LIMIT = 2 * 1024 * 1024;
+export const NEVER_UPDATED = new Date(0).toISOString();
+export function profileFilePath(layout, id) {
+    if (!/^[0-9]+$/.test(id))
+        throw new Error(`invalid profile id: ${id}`);
+    return path.join(layout.profilesDir, `${id}.yaml`);
+}
+function isSubscriptionUserinfo(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const info = value;
+    return (Number.isFinite(info.upload) &&
+        Number.isFinite(info.download) &&
+        Number.isFinite(info.total) &&
+        (info.expire === undefined || Number.isFinite(info.expire)));
+}
+function isProfileMeta(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const p = value;
+    return (typeof p.id === "string" &&
+        /^[0-9]+$/.test(p.id) &&
+        typeof p.name === "string" &&
+        typeof p.url === "string" &&
+        typeof p.intervalHours === "number" &&
+        Number.isSafeInteger(p.intervalHours) &&
+        p.intervalHours >= 0 &&
+        p.intervalHours <= MAX_PROFILE_INTERVAL_HOURS &&
+        typeof p.createdAt === "string" &&
+        Number.isFinite(new Date(p.createdAt).getTime()) &&
+        typeof p.updatedAt === "string" &&
+        Number.isFinite(new Date(p.updatedAt).getTime()) &&
+        (p.subInfo === undefined || isSubscriptionUserinfo(p.subInfo)) &&
+        (p.homePage === undefined || typeof p.homePage === "string") &&
+        (p.lastError === undefined || typeof p.lastError === "string"));
+}
+export function loadProfiles(layout = sashLayout()) {
+    let stat;
+    try {
+        stat = fs.lstatSync(layout.profilesIndexFile);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { activeId: null, profiles: [] };
+        }
+        throw err;
+    }
+    if (!stat.isFile() || stat.size > PROFILE_INDEX_SIZE_LIMIT) {
+        throw new Error(`Profiles index must be a regular file no larger than ${PROFILE_INDEX_SIZE_LIMIT} bytes: ${layout.profilesIndexFile}`);
+    }
+    const content = fs.readFileSync(layout.profilesIndexFile);
+    if (content.length > PROFILE_INDEX_SIZE_LIMIT) {
+        throw new Error(`Profiles index must be a regular file no larger than ${PROFILE_INDEX_SIZE_LIMIT} bytes: ${layout.profilesIndexFile}`);
+    }
+    const text = content.toString("utf8");
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`Profiles index is invalid JSON: ${layout.profilesIndexFile}: ${err.message}`);
+    }
+    if (!isPlainObject(raw)) {
+        throw new Error(`Profiles index root must be a plain object: ${layout.profilesIndexFile}`);
+    }
+    if (Object.keys(raw).some((key) => key !== "activeId" && key !== "profiles")) {
+        throw new Error(`Profiles index has unexpected root fields: ${layout.profilesIndexFile}`);
+    }
+    if (!Array.isArray(raw.profiles) || !raw.profiles.every(isProfileMeta)) {
+        throw new Error(`Profiles index has invalid profile metadata: ${layout.profilesIndexFile}`);
+    }
+    if (raw.activeId !== null && raw.activeId !== undefined && typeof raw.activeId !== "string") {
+        throw new Error(`Profiles index has an invalid activeId: ${layout.profilesIndexFile}`);
+    }
+    const profiles = raw.profiles;
+    if (new Set(profiles.map((profile) => profile.id)).size !== profiles.length) {
+        throw new Error(`Profiles index has duplicate profile ids: ${layout.profilesIndexFile}`);
+    }
+    const activeId = typeof raw.activeId === "string" && profiles.some((p) => p.id === raw.activeId)
+        ? raw.activeId
+        : null;
+    return { activeId, profiles };
+}
+export function serializeProfiles(index) {
+    const activeId = index.profiles.some((p) => p.id === index.activeId) ? index.activeId : null;
+    return `${JSON.stringify({ ...index, activeId }, null, 2)}\n`;
+}
+export function saveProfiles(index, layout = sashLayout()) {
+    atomicWriteFileSync(layout.profilesIndexFile, serializeProfiles(index));
+}
+export function getActiveProfile(index) {
+    return index.profiles.find((p) => p.id === index.activeId) ?? null;
+}
+export function findProfileByUrl(index, url) {
+    return index.profiles.find((p) => p.url !== "" && p.url === url) ?? null;
+}
+function readProfileBytes(layout, id) {
+    const file = profileFilePath(layout, id);
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+    if (!stat.isFile() || stat.size > PROFILE_DOWNLOAD_SIZE_LIMIT) {
+        throw new Error(`Profile ${id} must be a regular file no larger than ${PROFILE_DOWNLOAD_SIZE_LIMIT} bytes: ${file}`);
+    }
+    const content = fs.readFileSync(file);
+    if (content.length > PROFILE_DOWNLOAD_SIZE_LIMIT) {
+        throw new Error(`Profile ${id} must be a regular file no larger than ${PROFILE_DOWNLOAD_SIZE_LIMIT} bytes: ${file}`);
+    }
+    return content;
+}
+export function profileContentDigest(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+export function readProfileSource(layout, id) {
+    const content = readProfileBytes(layout, id);
+    if (!content)
+        return undefined;
+    const yamlText = content.toString("utf8");
+    let doc;
+    try {
+        doc = YAML.parse(yamlText);
+    }
+    catch (err) {
+        throw new Error(`Profile ${id} contains invalid YAML: ${err.message}`);
+    }
+    if (!isValidMihomoConfig(doc)) {
+        throw new Error(`Profile ${id} is not a valid core configuration`);
+    }
+    return { doc, yamlText, digest: profileContentDigest(content) };
+}
+export function readProfileDigest(layout, id) {
+    const content = readProfileBytes(layout, id);
+    return content ? profileContentDigest(content) : null;
+}
+export function readProfileDoc(layout, id) {
+    return readProfileSource(layout, id)?.doc;
+}
+export function allocateProfileId(index, layout, nowMs = Date.now()) {
+    let candidate = BigInt(nowMs);
+    for (;;) {
+        const id = candidate.toString();
+        if (!index.profiles.some((profile) => profile.id === id) &&
+            !fs.existsSync(profileFilePath(layout, id))) {
+            return id;
+        }
+        candidate += 1n;
+    }
+}
+export function profileNameFromUrl(url) {
+    try {
+        return new URL(url).hostname || "profile";
+    }
+    catch {
+        return "profile";
+    }
+}
+export function profileDueForUpdate(profile, fileExists, nowMs = Date.now()) {
+    if (!profile.url || profile.intervalHours <= 0)
+        return false;
+    if (!fileExists)
+        return true;
+    const updatedMs = new Date(profile.updatedAt).getTime();
+    if (!Number.isFinite(updatedMs))
+        return true;
+    return nowMs - updatedMs >= profile.intervalHours * 3_600_000;
+}

package/dist/runtime-lifecycle.js

@@ -0,0 +1,205 @@
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class RuntimeLifecycle {
+    supervisor;
+    systemProxy;
+    getSettings;
+    coreUpdate;
+    operationQueue = Promise.resolve();
+    phase;
+    generation = 0;
+    constructor(options) {
+        this.supervisor = options.supervisor;
+        this.systemProxy = options.systemProxy;
+        this.getSettings = options.settings;
+        this.coreUpdate = options.coreUpdate;
+        this.phase = this.supervisor.isRunning() ? "running" : "stopped";
+    }
+    state() {
+        return { phase: this.phase, generation: this.generation };
+    }
+    start(prepare) {
+        return this.enqueue(() => this.startUnlocked(prepare));
+    }
+    stop() {
+        return this.enqueue(() => this.stopUnlocked());
+    }
+    restart(prepare) {
+        return this.enqueue(() => this.restartUnlocked(prepare));
+    }
+    reconcileSystemProxy() {
+        return this.enqueue(() => this.reconcileSystemProxyUnlocked());
+    }
+    recoverStartup() {
+        return this.enqueue(async () => {
+            await this.systemProxy.release();
+            this.phase = this.supervisor.isRunning() ? "running" : "stopped";
+        });
+    }
+    handleUnexpectedCoreExit() {
+        return this.enqueue(async () => {
+            if (this.supervisor.isRunning())
+                return;
+            this.generation++;
+            this.phase = "failed";
+            let lastError;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    await this.systemProxy.release();
+                    this.phase = "stopped";
+                    return;
+                }
+                catch (err) {
+                    lastError = err;
+                    if (attempt < 2)
+                        await sleep(250 * (attempt + 1));
+                }
+            }
+            throw lastError;
+        });
+    }
+    close() {
+        return this.enqueue(() => this.stopUnlocked());
+    }
+    enqueue(operation) {
+        const next = this.operationQueue.then(operation, operation);
+        this.operationQueue = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    async startUnlocked(prepare) {
+        if (this.supervisor.isRunning()) {
+            const status = await this.supervisor.status();
+            if (!status.pid)
+                throw new Error("Core reports running without a process identifier");
+            if (!status.healthy) {
+                throw new Error(`Core process is running but unhealthy (PID=${status.pid})`);
+            }
+            this.coreUpdate?.completeAfterStart();
+            await this.reconcileSystemProxyUnlocked();
+            return {
+                pid: status.pid,
+                ...(status.version ? { version: status.version } : {}),
+                ...(status.tunActive !== undefined ? { tunActive: status.tunActive } : {}),
+            };
+        }
+        this.generation++;
+        this.phase = "starting";
+        let startAttempted = false;
+        try {
+            await this.systemProxy.release();
+            await prepare?.();
+            startAttempted = true;
+            const result = await this.supervisor.start();
+            this.coreUpdate?.completeAfterStart();
+            this.phase = "running";
+            await this.applyDesiredProxyUnlocked();
+            return result;
+        }
+        catch (err) {
+            if (startAttempted && !this.supervisor.isRunning() && this.coreUpdate) {
+                let pending;
+                try {
+                    pending = this.coreUpdate.pending();
+                }
+                catch (inspectError) {
+                    this.phase = "failed";
+                    throw new Error(`${err.message}; pending Core update inspection failed: ${inspectError.message}`);
+                }
+                if (pending) {
+                    let previous;
+                    try {
+                        previous = this.coreUpdate.rollbackAfterStartFailure();
+                        if (previous) {
+                            await this.supervisor.start();
+                            this.phase = "running";
+                            await this.applyDesiredProxyUnlocked();
+                        }
+                        else {
+                            this.phase = "stopped";
+                        }
+                    }
+                    catch (rollbackError) {
+                        this.phase = this.supervisor.isRunning() ? "running" : "failed";
+                        throw new Error(`${err.message}; Core update rollback failed: ${rollbackError.message}`);
+                    }
+                    const destination = previous ? ` to ${previous.coreVersion}` : "";
+                    throw new Error(`${err.message}; Core update rolled back${destination}`);
+                }
+            }
+            this.phase = this.supervisor.isRunning() ? "running" : "failed";
+            throw err;
+        }
+    }
+    async stopUnlocked() {
+        this.generation++;
+        this.phase = "stopping";
+        try {
+            await this.systemProxy.release();
+            await this.supervisor.stop();
+            this.phase = "stopped";
+        }
+        catch (err) {
+            this.phase = this.supervisor.isRunning() ? "running" : "failed";
+            throw err;
+        }
+    }
+    async restartUnlocked(prepare) {
+        this.generation++;
+        this.phase = "restarting";
+        try {
+            await prepare?.();
+            await this.systemProxy.release();
+            const result = await this.supervisor.restart();
+            this.phase = "running";
+            await this.applyDesiredProxyUnlocked();
+            return result;
+        }
+        catch (err) {
+            this.phase = this.supervisor.isRunning() ? "running" : "failed";
+            throw err;
+        }
+    }
+    async reconcileSystemProxyUnlocked() {
+        const settings = this.getSettings();
+        if (!settings.systemProxy) {
+            await this.systemProxy.release();
+            return;
+        }
+        await this.applyProxyToHealthyOwnedCoreUnlocked(settings.mixedPort);
+    }
+    async applyDesiredProxyUnlocked() {
+        const settings = this.getSettings();
+        if (!settings.systemProxy)
+            return;
+        await this.applyProxyToHealthyOwnedCoreUnlocked(settings.mixedPort);
+    }
+    async applyProxyToHealthyOwnedCoreUnlocked(port) {
+        const ownership = await this.requireHealthyOwnedCoreUnlocked();
+        await this.systemProxy.apply({ port });
+        const coreAfterApply = await this.supervisor.status();
+        if (coreAfterApply.running && coreAfterApply.healthy && this.supervisor.ownsCore(ownership)) {
+            return;
+        }
+        try {
+            await this.systemProxy.release();
+        }
+        catch (err) {
+            throw new Error(`Core ownership was lost while applying the system proxy; proxy release also failed: ${err.message}`);
+        }
+        throw new Error("Core ownership was lost while applying the system proxy");
+    }
+    async requireHealthyOwnedCoreUnlocked() {
+        const ownership = this.supervisor.ownedCoreSnapshot();
+        if (!ownership)
+            throw new Error("Cannot enable system proxy: core is not running");
+        const core = await this.supervisor.status();
+        if (!core.running || !core.healthy) {
+            throw new Error("Cannot enable system proxy: core is not healthy");
+        }
+        if (!this.supervisor.ownsCore(ownership)) {
+            throw new Error("Cannot enable system proxy: core ownership changed during health check");
+        }
+        return ownership;
+    }
+}

package/dist/runtime-owner.js

@@ -0,0 +1,87 @@
+import { assertCoreInstallationConsistent, coreInstalled, installCore } from "./core.js";
+import { recoverCoreInstallTransaction } from "./core-install-transaction.js";
+import { recoverCoordinatedCoreUpdate } from "./core-update-coordination.js";
+import { SashDaemonClient } from "./daemon-client.js";
+import { ensureDaemon, evaluateDaemon, prepareDaemonMaintenance, spawnDaemon, stopDaemonFromCli, } from "./daemon-lifecycle.js";
+import { log } from "./log.js";
+import { runOfflineMutation } from "./offline-mutation.js";
+import { withStateLock } from "./state-lock.js";
+export async function resolveRuntimeOwner(ctx, dependencies = {}) {
+    const daemon = await (dependencies.evaluateDaemon ?? evaluateDaemon)(ctx.layout, ctx.settings);
+    if (daemon.kind === "healthy") {
+        const client = (dependencies.clientFactory ?? ((port, secret) => new SashDaemonClient(port, secret)))(daemon.port, ctx.settings.daemonSecret);
+        return { kind: "daemon", daemon, client };
+    }
+    return daemon.kind === "stopped" ? { kind: "offline", daemon } : { kind: "unhealthy", daemon };
+}
+export async function ensureCore(ctx) {
+    recoverCoreInstallTransaction(ctx.layout);
+    recoverCoordinatedCoreUpdate(ctx.layout);
+    assertCoreInstallationConsistent(ctx.layout);
+    if (coreInstalled(ctx.layout))
+        return;
+    log.info("mihomo core not installed; downloading latest release...");
+    const { version } = await installCore({ layout: ctx.layout });
+    log.ok(`mihomo core ${version} installed`);
+}
+function withRuntimeOperation(ctx, purpose, action) {
+    return withStateLock(ctx.layout.runtimeOperationLockFile, { purpose, timeoutMs: 120_000 }, () => action());
+}
+async function healthyDaemonOwner(ctx) {
+    const owner = await resolveRuntimeOwner(ctx);
+    if (owner.kind !== "daemon") {
+        throw new Error("sashd did not become healthy after startup");
+    }
+    return owner;
+}
+export async function ensureRunning(ctx) {
+    return withRuntimeOperation(ctx, "start runtime", async () => {
+        const initialOwner = await resolveRuntimeOwner(ctx);
+        if (initialOwner.kind === "unhealthy") {
+            throw new Error("sashd is already starting or unresponsive; refusing a competing start");
+        }
+        if (initialOwner.kind === "offline") {
+            await runOfflineMutation(ctx, "install Core before start", () => ensureCore(ctx));
+        }
+        await ensureDaemon({ layout: ctx.layout, settings: ctx.settings });
+        const owner = await healthyDaemonOwner(ctx);
+        const result = await owner.client.startCore();
+        return { owner, result };
+    });
+}
+export async function stopRuntime(ctx) {
+    return withRuntimeOperation(ctx, "stop runtime", async () => {
+        const owner = await resolveRuntimeOwner(ctx);
+        if (owner.kind !== "offline") {
+            const stopped = await stopDaemonFromCli({ layout: ctx.layout, settings: ctx.settings });
+            if (!stopped)
+                throw new Error("sashd could not be stopped safely");
+        }
+        await runOfflineMutation(ctx, "finalize stopped runtime", () => undefined, {
+            reconcileRuntime: {
+                ...(owner.kind !== "offline" && owner.daemon.legacyOwnership ? { legacyDaemon: true } : {}),
+            },
+        });
+        return {
+            wasRunning: owner.kind !== "offline",
+            legacyDaemon: owner.kind !== "offline" && owner.daemon.legacyOwnership === true,
+        };
+    });
+}
+export async function restartRuntime(ctx, deps = {}) {
+    return withRuntimeOperation(ctx, "restart runtime", async () => {
+        const maintenance = await prepareDaemonMaintenance(ctx.layout, ctx.settings, "runtime restart", deps);
+        if (maintenance.legacyDaemon) {
+            await runOfflineMutation(ctx, "clean up legacy runtime", () => undefined, {
+                reconcileRuntime: { legacyDaemon: true },
+            });
+        }
+        if (!maintenance.daemonWasRunning) {
+            await runOfflineMutation(ctx, "install Core before restart", () => ensureCore(ctx));
+        }
+        const { pid: daemonPid } = await spawnDaemon({ layout: ctx.layout, settings: ctx.settings });
+        const owner = await healthyDaemonOwner(ctx);
+        const result = await owner.client.startCore();
+        return { owner, result, daemonPid, daemonWasRunning: maintenance.daemonWasRunning };
+    });
+}

package/dist/runtime-recovery.js

@@ -0,0 +1,31 @@
+import { MihomoApi } from "./api.js";
+import { recoverCoordinatedCoreUpdate } from "./core-update-coordination.js";
+import { CoreSupervisor } from "./supervisor.js";
+import { disableLegacySystemProxyIfOwned } from "./sysproxy.js";
+import { SystemProxyManager } from "./system-proxy-manager.js";
+export async function assertCoreControllerVacant(settings, probe = (current) => new MihomoApi(current.controller, current.secret).isReachable()) {
+    if (await probe(settings)) {
+        throw new Error("A Core controller is active without a live Sash PID owner; refusing to replace the executable");
+    }
+}
+export async function reconcileOrphanedRuntime(options, deps = {}) {
+    const { layout, settings } = options;
+    if (options.legacyDaemon && settings.systemProxy) {
+        await (deps.disableLegacyProxy ?? disableLegacySystemProxyIfOwned)({
+            port: settings.mixedPort,
+        });
+    }
+    const systemProxy = deps.systemProxy ?? new SystemProxyManager({ layout });
+    await systemProxy.release();
+    const supervisor = deps.supervisor ??
+        new CoreSupervisor({
+            layout,
+            settings: () => settings,
+        });
+    await supervisor.cleanStaleCore();
+    const pending = (deps.recoverCoreUpdate ?? recoverCoordinatedCoreUpdate)(layout);
+    if (options.verifyControllerVacant) {
+        await assertCoreControllerVacant(settings, deps.controllerReachable);
+    }
+    return pending;
+}

package/dist/sash-client.js

@@ -0,0 +1,163 @@
+import { parseApiErrorBody, parseCoreReloadResult, parseCoreStartResult, parseDaemonStatus, parseHealthInfo, parseProfileActionResponse, parseProfileActivateResponse, parseProfileContentResponse, parseProfileRemoveResponse, parseProfileRenameResponse, parseProfilesIndex, parseProfilesUpdateAllResponse, parseProfileUpdateResponse, parsePublicSettings, parseSettingsFileContent, parseSettingsWriteResult, parseShutdownResult, parseSystemProxyStatusResponse, } from "./contracts.js";
+const defaultFetch = async (url, init) => {
+    const response = await fetch(url, {
+        method: init.method,
+        headers: init.headers,
+        ...(init.body !== undefined ? { body: init.body } : {}),
+        ...(init.timeoutMs !== undefined ? { signal: AbortSignal.timeout(init.timeoutMs) } : {}),
+    });
+    return { status: response.status, text: () => response.text() };
+};
+export class SashApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "SashApiError";
+    }
+}
+export class SashClient {
+    baseUrl;
+    token;
+    tokenHeader;
+    fetchFn;
+    timeoutMs;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        if (options.token)
+            this.token = options.token;
+        this.tokenHeader = options.tokenHeader ?? "authorization";
+        this.fetchFn = options.fetchFn ?? defaultFetch;
+        this.timeoutMs = options.timeoutMs ?? 5_000;
+    }
+    async request(endpoint, options = {}) {
+        const headers = {};
+        const token = this.token?.() ?? "";
+        if (token) {
+            if (this.tokenHeader === "x-sash-token")
+                headers["X-Sash-Token"] = token;
+            else
+                headers.Authorization = `Bearer ${token}`;
+        }
+        let body;
+        if (options.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(options.body);
+        }
+        const response = await this.fetchFn(`${this.baseUrl}${endpoint}`, {
+            method: options.method ?? "GET",
+            headers,
+            ...(body !== undefined ? { body } : {}),
+            timeoutMs: options.timeoutMs ?? this.timeoutMs,
+            ...(options.attempts !== undefined ? { attempts: options.attempts } : {}),
+        });
+        const text = await response.text();
+        let data;
+        try {
+            data = text ? JSON.parse(text) : undefined;
+        }
+        catch (err) {
+            if (response.status >= 200 && response.status < 300) {
+                throw new Error(`Invalid JSON response from ${endpoint}: ${err.message}`);
+            }
+            data = text;
+        }
+        if (response.status < 200 || response.status >= 300) {
+            const parsedError = parseApiErrorBody(data);
+            const message = parsedError?.message ?? (typeof data === "string" ? data.slice(0, 300).trim() : "");
+            throw new SashApiError(response.status, parsedError?.code, message || `HTTP ${response.status}`);
+        }
+        return data;
+    }
+    async health() {
+        return parseHealthInfo(await this.request("/sash/daemon/health", { timeoutMs: 2_000, attempts: 1 }));
+    }
+    async status(fresh = false) {
+        return parseDaemonStatus(await this.request(fresh ? "/sash/daemon/status?fresh=1" : "/sash/daemon/status"));
+    }
+    async shutdown() {
+        return parseShutdownResult(await this.request("/sash/daemon/shutdown", { method: "POST", timeoutMs: 45_000 }));
+    }
+    async startCore() {
+        return parseCoreStartResult(await this.request("/sash/core/start", { method: "POST", timeoutMs: 15_000 }));
+    }
+    async stopCore() {
+        await this.request("/sash/core/stop", { method: "POST", timeoutMs: 30_000 });
+    }
+    async restartCore() {
+        return parseCoreStartResult(await this.request("/sash/core/restart", { method: "POST", timeoutMs: 30_000 }));
+    }
+    async reloadCoreConfig() {
+        return parseCoreReloadResult(await this.request("/sash/core/reload", { method: "POST", timeoutMs: 30_000 }));
+    }
+    async proxyStatus(fresh = false) {
+        return parseSystemProxyStatusResponse(await this.request(fresh ? "/sash/proxy?fresh=1" : "/sash/proxy"));
+    }
+    async getSettings() {
+        return parsePublicSettings(await this.request("/sash/settings"));
+    }
+    async patchSettings(patch) {
+        return parseSettingsWriteResult(await this.request("/sash/settings", { method: "PATCH", body: patch, timeoutMs: 45_000 }));
+    }
+    async getSettingsFile() {
+        return parseSettingsFileContent(await this.request("/sash/settings/file"));
+    }
+    async writeSettingsFile(content) {
+        return parseSettingsWriteResult(await this.request("/sash/settings/file", {
+            method: "PUT",
+            body: { content },
+            timeoutMs: 45_000,
+        }));
+    }
+    async listProfiles() {
+        return parseProfilesIndex(await this.request("/sash/profiles"));
+    }
+    async addProfile(url, opts = {}) {
+        return parseProfileActionResponse(await this.request("/sash/profiles", {
+            method: "POST",
+            body: { url, ...opts },
+            timeoutMs: 60_000,
+        }));
+    }
+    async importProfile(name, content) {
+        return parseProfileActionResponse(await this.request("/sash/profiles/import", {
+            method: "POST",
+            body: { name, content },
+            timeoutMs: 30_000,
+        }));
+    }
+    async activateProfile(id) {
+        return parseProfileActivateResponse(await this.request("/sash/profiles/active", {
+            method: "PUT",
+            body: { id },
+            timeoutMs: 30_000,
+        }));
+    }
+    async updateProfile(id) {
+        return parseProfileUpdateResponse(await this.request(`/sash/profiles/${id}/update`, {
+            method: "POST",
+            timeoutMs: 60_000,
+        }));
+    }
+    async updateAllProfiles() {
+        return parseProfilesUpdateAllResponse(await this.request("/sash/profiles/update-all", { method: "POST", timeoutMs: 120_000 }));
+    }
+    async getProfileContent(id) {
+        return parseProfileContentResponse(await this.request(`/sash/profiles/${id}/content`));
+    }
+    async writeProfileContent(id, content) {
+        return parseProfileUpdateResponse(await this.request(`/sash/profiles/${id}/content`, {
+            method: "PUT",
+            body: { content },
+            timeoutMs: 30_000,
+        }));
+    }
+    async renameProfile(id, name) {
+        return parseProfileRenameResponse(await this.request(`/sash/profiles/${id}`, { method: "PATCH", body: { name } }));
+    }
+    async removeProfile(id) {
+        return parseProfileRemoveResponse(await this.request(`/sash/profiles/${id}`, { method: "DELETE", timeoutMs: 30_000 }));
+    }
+}