@astralyn/sash 0.1.1 → 0.1.2

package/dist/runtime-owner.js

@@ -1,87 +1,48 @@
-import { assertCoreInstallationConsistent, coreInstalled, installCore } from "./core.js";
-import { recoverCoreInstallTransaction } from "./core-install-transaction.js";
-import { recoverCoordinatedCoreUpdate } from "./core-update-coordination.js";
+import fs from "node:fs";
+import { loadSettings } from "./app-state.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 };
-    }
+import { ensureDaemon, evaluateDaemon, stopDaemonFromCli, } from "./daemon-lifecycle.js";
+export async function resolveRuntimeOwner(ctx, deps = {}) {
+    const daemon = await (deps.evaluateDaemon ?? evaluateDaemon)(ctx.layout, ctx.settings);
+    if (daemon.kind === "healthy")
+        return {
+            kind: "daemon",
+            daemon,
+            client: (deps.clientFactory ?? ((port, secret) => new SashDaemonClient(port, secret)))(daemon.port, ctx.settings.daemonSecret),
+        };
     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) {
+export async function ensureManagement(ctx) {
+    await ensureDaemon({ layout: ctx.layout, settings: ctx.settings });
+    ctx.settings = loadSettings(ctx.layout);
     const owner = await resolveRuntimeOwner(ctx);
-    if (owner.kind !== "daemon") {
-        throw new Error("sashd did not become healthy after startup");
-    }
+    if (owner.kind !== "daemon")
+        throw new Error("sashd did not become healthy");
     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 };
-    });
+    const owner = await ensureManagement(ctx);
+    return { owner, result: await owner.client.startCore() };
 }
 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,
-        };
-    });
+    const initial = await resolveRuntimeOwner(ctx);
+    if (initial.kind === "unhealthy")
+        throw new Error("sashd is unresponsive or its ownership is unknown; refusing an unverified stop");
+    if (initial.kind === "offline") {
+        const leftovers = [
+            ctx.layout.pidFile,
+            ctx.layout.systemProxyStateFile,
+            ctx.layout.coreUpdateTransactionFile,
+        ];
+        if (!leftovers.some((file) => fs.existsSync(file)))
+            return { wasRunning: false };
+        await ensureManagement(ctx);
+    }
+    if (!(await stopDaemonFromCli({ layout: ctx.layout, settings: ctx.settings })))
+        throw new Error("sashd shutdown could not be verified");
+    return { wasRunning: initial.kind === "daemon" };
 }
-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 };
-    });
+export async function restartRuntime(ctx) {
+    const owner = await ensureManagement(ctx);
+    return { owner, result: await owner.client.restartCore() };
 }

package/dist/sash-client.js

@@ -1,4 +1,5 @@
-import { parseApiErrorBody, parseCoreReloadResult, parseCoreStartResult, parseDaemonStatus, parseHealthInfo, parseProfileActionResponse, parseProfileActivateResponse, parseProfileContentResponse, parseProfileRemoveResponse, parseProfileRenameResponse, parseProfilesIndex, parseProfilesUpdateAllResponse, parseProfileUpdateResponse, parsePublicSettings, parseSettingsFileContent, parseSettingsWriteResult, parseShutdownResult, parseSystemProxyStatusResponse, parseWebBootstrapInfo, parseWebSessionInfo, } from "./contracts.js";
+import { parseAutostartStatus } from "./autostart-contract.js";
+import { parseApiErrorBody, parseCoreStartResult, parseCoreUpdateResponse, parseDaemonStatus, parseHealthInfo, parseProfileActionResponse, parseProfileActivateResponse, parseProfileContentResponse, parseProfileRemoveResponse, parseProfileRenameResponse, parseProfilesIndex, parseProfilesUpdateAllResponse, parseProfileUpdateResponse, parsePublicSettings, parseSettingsWriteResult, parseSystemProxyStatusResponse, parseWebBootstrapInfo, parseWebSessionInfo, } from "./contracts.js";
 const defaultFetch = async (url, init) => {
     const response = await fetch(url, {
         method: init.method,
@@ -8,6 +9,7 @@ const defaultFetch = async (url, init) => {
     });
     return { status: response.status, text: () => response.text() };
 };
+const CORE_OPERATION_TIMEOUT_MS = 20 * 60_000;
 export class SashApiError extends Error {
     status;
     code;
@@ -96,22 +98,48 @@ export class SashClient {
         }));
     }
     async status(fresh = false) {
-        return parseDaemonStatus(await this.request(fresh ? "/sash/daemon/status?fresh=1" : "/sash/daemon/status"));
+        return parseDaemonStatus(await this.request(fresh ? "/sash/daemon/status?fresh=1" : "/sash/daemon/status", {
+            timeoutMs: 8000,
+        }));
     }
     async shutdown() {
-        return parseShutdownResult(await this.request("/sash/daemon/shutdown", { method: "POST", timeoutMs: 45_000 }));
+        await this.request("/sash/daemon/shutdown", { method: "POST", timeoutMs: 45_000 });
+    }
+    async autostartStatus() {
+        return parseAutostartStatus(await this.request("/sash/autostart", { timeoutMs: 15_000, attempts: 1 }));
+    }
+    async setAutostart(enabled) {
+        return parseAutostartStatus(await this.request("/sash/autostart", {
+            method: "PUT",
+            body: { enabled },
+            timeoutMs: 60_000,
+            attempts: 1,
+        }));
     }
     async startCore() {
-        return parseCoreStartResult(await this.request("/sash/core/start", { method: "POST", timeoutMs: 15_000 }));
+        return parseCoreStartResult(await this.request("/sash/core/start", {
+            method: "POST",
+            timeoutMs: CORE_OPERATION_TIMEOUT_MS,
+        }));
     }
     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 }));
+        return parseCoreStartResult(await this.request("/sash/core/restart", {
+            method: "POST",
+            timeoutMs: CORE_OPERATION_TIMEOUT_MS,
+        }));
     }
-    async reloadCoreConfig() {
-        return parseCoreReloadResult(await this.request("/sash/core/reload", { method: "POST", timeoutMs: 30_000 }));
+    async updateCore(version) {
+        return parseCoreUpdateResponse(await this.request("/sash/core/update", {
+            method: "POST",
+            body: version ? { version } : {},
+            timeoutMs: CORE_OPERATION_TIMEOUT_MS,
+        }));
+    }
+    async setMode(mode) {
+        await this.request("/sash/core/mode", { method: "PUT", body: { mode } });
     }
     async proxyStatus(fresh = false) {
         return parseSystemProxyStatusResponse(await this.request(fresh ? "/sash/proxy?fresh=1" : "/sash/proxy"));
@@ -122,19 +150,12 @@ export class SashClient {
     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 reorderProfiles(ids) {
+        return parseProfilesIndex(await this.request("/sash/profiles/order", { method: "PUT", body: { ids } }));
+    }
     async addProfile(url, opts = {}) {
         return parseProfileActionResponse(await this.request("/sash/profiles", {
             method: "POST",
@@ -168,10 +189,10 @@ export class SashClient {
     async getProfileContent(id) {
         return parseProfileContentResponse(await this.request(`/sash/profiles/${id}/content`));
     }
-    async writeProfileContent(id, content) {
+    async writeProfileContent(id, content, revision) {
         return parseProfileUpdateResponse(await this.request(`/sash/profiles/${id}/content`, {
             method: "PUT",
-            body: { content },
+            body: { content, revision },
             timeoutMs: 30_000,
         }));
     }

package/dist/settings-service.js

@@ -1,238 +1,43 @@
-import { commitManagedStateTransaction } from "./managed-state-transaction.js";
-import { ProfileConflictError, } from "./profile-service.js";
-import { sameSettings, validateSettingsCandidate } from "./settings.js";
+import { validateSettingsCandidate } from "./settings.js";
 export class SettingsInputError extends Error {
 }
-export class SettingsConflictError extends Error {
-}
 export class CoreUnhealthyError extends Error {
 }
-const CORE_SETTING_KEYS = ["mixedPort", "controller", "secret", "allowLan"];
+export { StateConflictError as SettingsConflictError } from "./app-state.js";
 export class SettingsService {
     options;
     constructor(options) {
         this.options = options;
     }
     async apply(patch) {
-        const previous = { ...this.options.getCommitted() };
-        let candidate;
-        try {
-            candidate = validateSettingsCandidate(mergePatch(previous, patch));
-        }
-        catch (err) {
-            throw new SettingsInputError(err.message);
-        }
-        const restartRequired = candidate.daemonPort !== previous.daemonPort;
-        const proxyChanged = candidate.systemProxy !== previous.systemProxy;
-        const coreChanged = CORE_SETTING_KEYS.some((key) => candidate[key] !== previous[key]);
-        const daemonChanged = restartRequired || candidate.daemonSecret !== previous.daemonSecret;
-        let committed = previous;
-        if (coreChanged || daemonChanged) {
-            const staged = { ...candidate, systemProxy: previous.systemProxy };
-            committed = coreChanged
-                ? await this.commitCoreChange(previous, staged)
-                : await this.commitSettingsOnly(previous, staged);
-        }
-        if (proxyChanged || patch.systemProxy === false) {
-            committed = await this.commitSystemProxy(committed, candidate);
-        }
-        return { settings: committed, restartRequired };
-    }
-    async applyFileSettings(next) {
-        const current = this.options.getCommitted();
-        const patch = {};
-        if (next.mixedPort !== current.mixedPort)
-            patch.mixedPort = next.mixedPort;
-        if (next.controller !== current.controller)
-            patch.controller = next.controller;
-        if (next.secret !== current.secret)
-            patch.secret = next.secret;
-        if (next.tun !== current.tun)
-            patch.tun = next.tun;
-        if (next.allowLan !== current.allowLan)
-            patch.allowLan = next.allowLan;
-        if (next.systemProxy !== current.systemProxy)
-            patch.systemProxy = next.systemProxy;
-        if (next.daemonPort !== current.daemonPort)
-            patch.daemonPort = next.daemonPort;
-        if (next.daemonSecret !== current.daemonSecret)
-            patch.daemonSecret = next.daemonSecret;
-        return this.apply(patch);
-    }
-    async commitSettingsOnly(previous, candidate) {
-        return this.options.commit("update daemon settings", async () => {
-            this.assertCurrent(previous);
-            this.options.setRuntime(candidate);
-            try {
-                await commitManagedStateTransaction(this.options.layout, { settings: candidate }, undefined);
-            }
-            catch (err) {
-                this.options.setRuntime(previous);
-                throw err;
-            }
-            this.options.setCommitted(candidate);
-            return candidate;
-        });
-    }
-    async commitCoreChange(previous, candidate) {
-        for (let attempt = 0;; attempt += 1) {
-            const prepared = await this.options.profiles.prepareActiveConfig(candidate, previous);
-            let retryableProfileConflict;
-            let callbackEntered = false;
-            try {
-                return await this.options.commit("update settings", async () => {
-                    this.assertCurrent(previous);
-                    try {
-                        return await this.options.profiles.withPreparedActivePublication(prepared, async (publication) => {
-                            callbackEntered = true;
-                            return this.commitCoreSettings(previous, candidate, publication);
-                        });
-                    }
-                    catch (err) {
-                        if (err instanceof ProfileConflictError && !callbackEntered) {
-                            retryableProfileConflict = err;
-                        }
-                        throw err;
-                    }
-                });
-            }
-            catch (err) {
-                if (err !== retryableProfileConflict || attempt >= 1)
-                    throw err;
-            }
-        }
-    }
-    async commitSystemProxy(previous, candidate) {
-        if (!candidate.systemProxy) {
-            return this.options.commit("disable system proxy", async () => {
-                this.assertCurrent(previous);
-                this.options.setRuntime(candidate);
-                try {
-                    if (!sameSettings(previous, candidate)) {
-                        await commitManagedStateTransaction(this.options.layout, { settings: candidate }, undefined);
-                    }
-                }
-                catch (err) {
-                    this.options.setRuntime(previous);
-                    throw err;
-                }
-                this.options.setCommitted(candidate);
-                if (this.options.lifecycle)
-                    await this.options.lifecycle.reconcileSystemProxy();
-                else
-                    await this.options.releaseSystemProxy?.();
-                return candidate;
-            });
-        }
-        const core = await this.options.supervisor?.status();
-        if (!core?.running || !core.healthy) {
-            throw new CoreUnhealthyError("Cannot enable system proxy: core is not healthy");
-        }
-        return this.options.commit("enable system proxy", async () => {
-            this.assertCurrent(previous);
-            this.options.setRuntime(candidate);
+        return this.options.commit("save settings", async () => {
+            const state = this.options.state.snapshot();
+            let settings;
             try {
-                await commitManagedStateTransaction(this.options.layout, {
-                    settings: candidate,
-                    applyRuntime: () => this.requireLifecycle().reconcileSystemProxy(),
-                }, undefined);
-                this.options.setCommitted(candidate);
-                return candidate;
-            }
-            catch (err) {
-                this.options.setRuntime(previous);
-                try {
-                    await this.requireLifecycle().reconcileSystemProxy();
-                }
-                catch (rollback) {
-                    throw new Error(`${err.message}; system proxy rollback failed: ${rollback.message}`);
-                }
-                throw err;
-            }
+                settings = validateSettingsCandidate({ ...state.settings, ...patch });
+            }
+            catch (error) {
+                throw new SettingsInputError(error instanceof Error ? error.message : String(error));
+            }
+            if (patch.systemProxy === true) {
+                const core = await this.options.supervisor.status();
+                if (!core.running || !core.healthy)
+                    throw new CoreUnhealthyError("Cannot enable system proxy: Core is not healthy");
+            }
+            this.options.state.assertCurrent(state.revision);
+            const changed = settings.mixedPort !== state.settings.mixedPort ||
+                settings.allowLan !== state.settings.allowLan ||
+                settings.systemProxy !== state.settings.systemProxy;
+            const saved = changed ? this.options.state.commit({ ...state, settings }) : state;
+            if (patch.systemProxy !== undefined) {
+                await this.options.lifecycle.reconcileSystemProxy();
+            }
+            const running = this.options.lifecycle.settings();
+            return {
+                settings: saved.settings,
+                restartRequired: saved.settings.mixedPort !== running.mixedPort ||
+                    saved.settings.allowLan !== running.allowLan,
+            };
         });
     }
-    async commitCoreSettings(previous, candidate, publication) {
-        const wasRunning = this.options.supervisor?.isRunning() ?? false;
-        this.options.setRuntime(candidate);
-        try {
-            await commitManagedStateTransaction(this.options.layout, {
-                ...(publication.index ? { index: publication.index } : {}),
-                ...(publication.profile
-                    ? {
-                        profile: {
-                            id: publication.profile.id,
-                            yamlText: publication.profile.yamlText,
-                        },
-                    }
-                    : {}),
-                config: publication.config,
-                settings: candidate,
-                reloadRuntime: false,
-                applyRuntime: async () => {
-                    if (!wasRunning)
-                        return;
-                    await this.requireLifecycle().restart();
-                },
-            }, undefined);
-            this.options.setCommitted(candidate);
-            return candidate;
-        }
-        catch (err) {
-            this.options.setRuntime(previous);
-            const rollbackErrors = [];
-            try {
-                await this.options.profiles.commitPreparedActiveReload(publication.rollback, {
-                    reloadRuntime: false,
-                    boundary: "already-held",
-                });
-            }
-            catch (rollback) {
-                rollbackErrors.push(`config rollback failed: ${rollback.message}`);
-            }
-            if (wasRunning) {
-                try {
-                    if (this.options.supervisor?.isRunning())
-                        await this.requireLifecycle().restart();
-                    else
-                        await this.requireLifecycle().start();
-                }
-                catch (rollback) {
-                    rollbackErrors.push(`runtime rollback failed: ${rollback.message}`);
-                }
-            }
-            if (rollbackErrors.length)
-                throw new Error(`${err.message}; ${rollbackErrors.join("; ")}`, { cause: err });
-            throw err;
-        }
-    }
-    requireLifecycle() {
-        if (!this.options.lifecycle)
-            throw new Error("No runtime lifecycle is available for this settings mutation");
-        return this.options.lifecycle;
-    }
-    assertCurrent(previous) {
-        if (!sameSettings(this.options.getCommitted(), previous)) {
-            throw new SettingsConflictError("Settings changed while preparing configuration");
-        }
-    }
-}
-function mergePatch(previous, patch) {
-    const candidate = { ...previous };
-    if (patch.mixedPort !== undefined)
-        candidate.mixedPort = patch.mixedPort;
-    if (patch.controller !== undefined)
-        candidate.controller = patch.controller;
-    if (patch.secret !== undefined)
-        candidate.secret = patch.secret;
-    if (patch.tun !== undefined)
-        candidate.tun = patch.tun;
-    if (patch.allowLan !== undefined)
-        candidate.allowLan = patch.allowLan;
-    if (patch.systemProxy !== undefined)
-        candidate.systemProxy = patch.systemProxy;
-    if (patch.daemonPort !== undefined)
-        candidate.daemonPort = patch.daemonPort;
-    if (patch.daemonSecret !== undefined)
-        candidate.daemonSecret = patch.daemonSecret;
-    return candidate;
 }