@astralyn/sash 0.1.1 → 0.1.2

package/dist/core.js

@@ -6,12 +6,11 @@ import { pipeline } from "node:stream/promises";
 import zlib from "node:zlib";
 import AdmZip from "adm-zip";
 import { currentCoreVersion, readInstallRecord, validateCoreReleaseTag, writeInstallRecord, } from "./core-install-record.js";
-import { beginCoreInstallTransaction, clearCoreInstallTransaction, markCoreInstallTransactionCommitted, recoverCoreInstallTransaction, } from "./core-install-transaction.js";
 import { containsCoreVersionToken } from "./core-version.js";
-import { durableRenameSync, pathEntryExists } from "./fs-atomic.js";
+import { pathEntryExists } from "./fs-atomic.js";
 import { downloadReleaseAsset, listReleaseAssets, MIHOMO_REPO, RELEASE_ASSET_SIZE_LIMIT, resolveLatestTag, } from "./github.js";
 import { sashLayout } from "./paths.js";
-import { buildSanitizedEnv, recoverBinaryUnlockProbe } from "./process.js";
+import { buildSanitizedEnv } from "./process.js";
 export function goOsArch(platform = process.platform, arch = process.arch) {
     const osMap = { win32: "windows", darwin: "darwin", linux: "linux" };
     const archMap = { x64: "amd64", arm64: "arm64" };
@@ -56,9 +55,12 @@ export async function extractCoreArchive(archivePath, assetName, destExe) {
                 throw new Error("Core archive exceeds the download safety limit");
             }
             const zip = new AdmZip(archivePath);
-            const entry = zip
-                .getEntries()
-                .find((candidate) => !candidate.isDirectory && /^mihomo.*\.exe$/i.test(path.basename(candidate.entryName)));
+            const entries = zip.getEntries();
+            if (entries.some((entry) => entry.entryName.split(/[\\/]/).includes("..") ||
+                /^(?:[\\/]|[A-Za-z]:)/.test(entry.entryName))) {
+                throw new Error("Core archive contains an unsafe path");
+            }
+            const entry = entries.find((candidate) => !candidate.isDirectory && /^mihomo.*\.exe$/i.test(path.basename(candidate.entryName)));
             if (!entry)
                 throw new Error(`No mihomo*.exe found inside ${assetName}`);
             if (entry.header.size > EXTRACT_SIZE_LIMIT) {
@@ -112,15 +114,17 @@ export function verifyCoreExecutable(exe, timeoutMs = 5000, expectedVersion) {
 }
 export async function stageCore(opts = {}) {
     const layout = opts.layout ?? sashLayout();
-    const tag = validateCoreReleaseTag(opts.tag ?? (await resolveLatestTag(MIHOMO_REPO)));
-    const assets = await listReleaseAssets(MIHOMO_REPO, tag);
+    const tag = validateCoreReleaseTag(opts.tag ?? (await resolveLatestTag(MIHOMO_REPO, opts.signal)));
+    const assets = await listReleaseAssets(MIHOMO_REPO, tag, opts.signal);
     const candidates = mihomoAssetCandidates(tag);
     fs.mkdirSync(layout.tempDir, { recursive: true });
     fs.mkdirSync(layout.binDir, { recursive: true });
-    const archivePath = path.join(layout.tempDir, `mihomo-${tag}-${process.pid}.download`);
-    const stagedExe = `${layout.coreExe}.${process.pid}.new`;
+    const directory = fs.mkdtempSync(path.join(layout.tempDir, "core-download-"));
+    const archivePath = path.join(directory, "archive.download");
+    const stagedExe = path.join(directory, path.basename(layout.coreExe));
     try {
         const assetName = await downloadReleaseAsset({
+            signal: opts.signal,
             repo: MIHOMO_REPO,
             tag,
             assets,
@@ -129,6 +133,7 @@ export async function stageCore(opts = {}) {
             onProgress: opts.onProgress,
         });
         await extractCoreArchive(archivePath, assetName, stagedExe);
+        opts.signal?.throwIfAborted();
         fs.chmodSync(stagedExe, 0o755);
         verifyCoreExecutable(stagedExe, 5000, tag);
         return { version: tag, exe: stagedExe };
@@ -139,41 +144,11 @@ export async function stageCore(opts = {}) {
     }
     finally {
         fs.rmSync(archivePath, { force: true });
-    }
-}
-export async function installCore(opts = {}) {
-    const layout = opts.layout ?? sashLayout();
-    recoverCoreInstallTransaction(layout);
-    assertCoreInstallationConsistent(layout);
-    if (coreInstalled(layout)) {
-        throw new Error(`Core executable already exists at ${layout.coreExe}; use the update flow`);
-    }
-    const staged = await stageCore({ ...opts, layout });
-    let transactionStarted = false;
-    let committed = false;
-    try {
-        const transaction = beginCoreInstallTransaction(staged.version, layout);
-        transactionStarted = true;
-        durableRenameSync(staged.exe, layout.coreExe);
-        writeInstallRecord({ coreVersion: staged.version, installedAt: transaction.createdAt }, layout);
-        markCoreInstallTransactionCommitted(transaction, layout);
-        committed = true;
-        clearCoreInstallTransaction(layout);
-        return { version: staged.version, exe: layout.coreExe };
-    }
-    catch (err) {
-        if (transactionStarted && !committed) {
-            try {
-                recoverCoreInstallTransaction(layout);
-            }
-            catch (recoveryErr) {
-                throw new Error(`${err.message}; Core install recovery also failed: ${recoveryErr.message}`);
-            }
+        try {
+            fs.rmdirSync(directory);
+        }
+        catch {
         }
-        throw err;
-    }
-    finally {
-        fs.rmSync(staged.exe, { force: true });
     }
 }
 function isRegularFile(file) {
@@ -188,7 +163,6 @@ export function coreInstalled(layout = sashLayout()) {
     return isRegularFile(layout.coreExe) && readInstallRecord(layout) !== undefined;
 }
 export function assertCoreInstallationConsistent(layout = sashLayout()) {
-    recoverBinaryUnlockProbe(layout.coreExe);
     const binaryExists = pathEntryExists(layout.coreExe);
     const installRecordExists = pathEntryExists(layout.installFile);
     const binaryValid = isRegularFile(layout.coreExe);
@@ -202,5 +176,5 @@ export function assertCoreInstallationConsistent(layout = sashLayout()) {
         : record
             ? "Core install metadata exists but the executable is missing"
             : "Core install metadata is malformed without an executable";
-    throw new Error(`Core installation is incomplete or invalid: ${reason}. Run \`sash update --force\` to repair it.`);
+    throw new Error(`Core installation is incomplete or invalid: ${reason}. Preserve these files and reinstall into a clean data directory.`);
 }

package/dist/daemon/app.js

@@ -1,163 +1,175 @@
 import crypto from "node:crypto";
-import { MihomoApi } from "../api.js";
-import { currentCoreVersion } from "../core.js";
-import { validateCoreConfigText } from "../core-config-validation.js";
-import { pendingCoreUpdateVersion, readCoreUpdateTransaction } from "../core-update.js";
-import { completeCoordinatedCoreUpdateAfterStart, rollbackCoordinatedCoreUpdate, } from "../core-update-coordination.js";
-import { ProfileConflictError, ProfileService, } from "../profile-service.js";
+import fs from "node:fs";
+import path from "node:path";
+import { SashStateStore, StateConflictError } from "../app-state.js";
+import { AutostartService } from "../autostart.js";
+import { assertCoreInstallationConsistent, coreInstalled, currentCoreVersion, stageCore, } from "../core.js";
+import { validateCoreConfig } from "../core-config-validation.js";
+import { readCoreUpdateTransaction } from "../core-update.js";
+import { ProfileService } from "../profile-service.js";
+import { getActiveProfile, renderActiveConfig } from "../profiles.js";
 import { RuntimeLifecycle } from "../runtime-lifecycle.js";
-import { saveSettings } from "../settings.js";
 import { SettingsService } from "../settings-service.js";
-import { StateMutationQueue } from "../state-lock.js";
 import { CoreSupervisor } from "../supervisor.js";
 import { SystemProxyManager } from "../system-proxy-manager.js";
 import { DaemonGate } from "./context.js";
 import { WebAuthManager } from "./web-auth.js";
 export function buildDaemonContext(deps) {
-    const layout = deps.layout;
-    let committedSettings = saveSettings({ ...deps.settings }, layout);
-    let runtimeSettings = committedSettings;
+    const { layout } = deps;
+    const state = deps.state ?? new SashStateStore(layout, deps.settings);
+    const settings = () => state.snapshot().settings;
     const token = deps.token ?? crypto.randomBytes(24).toString("hex");
-    const startedAt = new Date().toISOString();
     const systemProxy = deps.systemProxy ?? new SystemProxyManager({ layout });
-    const mutations = new StateMutationQueue(layout.mutationLockFile);
-    let profileRevision = 0;
     let lifecycle;
+    let gate;
     const supervisor = deps.supervisor ??
         new CoreSupervisor({
             layout,
-            settings: () => runtimeSettings,
-            expectedVersion: () => pendingCoreUpdateVersion(layout) || currentCoreVersion(layout) || undefined,
-            onExit: async () => {
-                try {
-                    await lifecycle?.handleUnexpectedCoreExit();
-                }
-                catch (err) {
-                    console.error(`[sashd] failed to restore system proxy after Core exit: ${err.message}`);
-                }
-            },
+            settings: () => lifecycle?.settings() ?? settings(),
+            expectedVersion: () => currentCoreVersion(layout) || undefined,
+            onExit: () => gate
+                .mutate("recover Core exit", () => lifecycle.handleUnexpectedCoreExit())
+                .catch((error) => {
+                console.error(`[sashd] Core exit cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+            }),
         });
     lifecycle = new RuntimeLifecycle({
+        layout,
         supervisor,
         systemProxy,
-        settings: () => runtimeSettings,
-        coreUpdate: {
-            pending: () => readCoreUpdateTransaction(layout) !== undefined,
-            completeAfterStart: () => {
-                completeCoordinatedCoreUpdateAfterStart(layout);
-            },
-            rollbackAfterStartFailure: () => rollbackCoordinatedCoreUpdate(layout),
-        },
-    });
-    const gate = new DaemonGate(mutations, async () => {
-        const coreWasRunning = supervisor.isRunning();
-        await lifecycle.close();
-        return { coreWasRunning };
+        settings,
+        verifyExecutable: deps.verifyCoreFn,
+        controllerProbe: deps.controllerProbe,
     });
+    let downloading = false;
+    let preparation = new AbortController();
+    let profiles;
+    const cancelPreparations = () => {
+        preparation.abort(new StateConflictError("Core operation cancelled"));
+        preparation = new AbortController();
+        profiles.cancelDownloads();
+    };
+    gate = new DaemonGate(() => lifecycle.stop(), cancelPreparations);
     const mutate = (purpose, action) => gate.mutate(purpose, action);
-    const profiles = new ProfileService({
+    profiles = new ProfileService({
         layout,
-        settings: () => committedSettings,
-        ...(deps.fetchProfileFn ? { fetchProfile: deps.fetchProfileFn } : {}),
-        validateConfig: deps.validateConfigFn ?? ((generated) => validateCoreConfigText(generated.yaml, layout)),
-        reloadConfig: async (configPath) => {
-            if (!supervisor.isRunning())
-                return;
-            const api = new MihomoApi(runtimeSettings.controller, runtimeSettings.secret);
-            await api.reloadConfig(configPath);
-        },
-        commit: mutate,
-        onChange: () => {
-            profileRevision += 1;
-        },
-    });
-    const settingsService = new SettingsService({
-        layout,
-        getCommitted: () => committedSettings,
-        setCommitted: (next) => {
-            committedSettings = { ...next };
-        },
-        setRuntime: (next) => {
-            runtimeSettings = { ...next };
-        },
-        profiles,
-        supervisor,
-        lifecycle,
+        state,
         commit: mutate,
+        fetchProfile: deps.fetchProfileFn,
     });
-    const commitPreparedReload = (prepared, reloadRuntime) => profiles.commitPreparedActiveReload(prepared, {
-        reloadRuntime,
-        boundary: "already-held",
-    });
-    const startCore = async () => {
-        if (readCoreUpdateTransaction(layout)) {
-            return mutate("start pending Core update", () => lifecycle.start());
+    const settingsService = new SettingsService({ state, commit: mutate, lifecycle, supervisor });
+    const validate = (generated, executable, signal) => Promise.resolve(deps.validateConfigFn
+        ? deps.validateConfigFn(generated, executable, signal)
+        : validateCoreConfig(executable, generated.yaml, layout, { signal }));
+    const savedConfiguration = () => {
+        const snapshot = state.snapshot();
+        const profile = getActiveProfile(snapshot.profiles);
+        return {
+            generated: renderActiveConfig(snapshot, layout),
+            settings: snapshot.settings,
+            profile: profile
+                ? { id: profile.id, revision: profile.revision, name: profile.name, url: profile.url }
+                : null,
+        };
+    };
+    const requireRecoveredInstall = () => {
+        assertCoreInstallationConsistent(layout);
+        if (readCoreUpdateTransaction(layout))
+            throw new StateConflictError("Core update recovery is pending; run sash stop, then sash start");
+    };
+    const updateCore = async (version) => {
+        if (gate.isClosing)
+            throw new Error("sashd is shutting down");
+        if (downloading)
+            throw new StateConflictError("A Core download is already in progress");
+        requireRecoveredInstall();
+        const revision = state.snapshot().revision;
+        const epoch = lifecycle.revision;
+        const configuration = supervisor.isRunning() ? lifecycle.configuration() : savedConfiguration();
+        if (!configuration)
+            throw new Error("Running Core configuration is unknown");
+        const { signal } = preparation;
+        downloading = true;
+        let staged;
+        try {
+            staged = await (deps.stageCoreFn ?? stageCore)({ layout, tag: version, signal });
+            signal.throwIfAborted();
+            await validate(configuration.generated, staged.exe, signal);
+            const candidate = staged;
+            return await mutate("update Core", async () => {
+                signal.throwIfAborted();
+                state.assertCurrent(revision);
+                if (lifecycle.revision !== epoch)
+                    throw new StateConflictError("Core changed during download; retry the update");
+                return lifecycle.update(candidate, configuration);
+            });
         }
-        const retryAfterPreparation = Symbol("retry Core start after preparation");
-        for (;;) {
-            let prepared;
-            if (!supervisor.isRunning()) {
+        catch (error) {
+            signal.throwIfAborted();
+            throw error;
+        }
+        finally {
+            downloading = false;
+            if (staged) {
+                fs.rmSync(staged.exe, { force: true });
                 try {
-                    prepared = await profiles.prepareActiveReload();
+                    fs.rmdirSync(path.dirname(staged.exe));
                 }
-                catch (err) {
-                    if (supervisor.isRunning())
-                        continue;
-                    throw err;
+                catch {
                 }
             }
-            const preparedForStart = prepared;
-            const result = await mutate("start core", async () => {
-                if (!preparedForStart && !supervisor.isRunning())
-                    return retryAfterPreparation;
-                return lifecycle.start(preparedForStart
-                    ? async () => {
-                        await commitPreparedReload(preparedForStart, false);
-                    }
-                    : undefined);
-            });
-            if (result !== retryAfterPreparation)
-                return result;
         }
     };
-    const withPreparedReloadRetry = async (purpose, action) => {
-        for (let attempt = 0;; attempt += 1) {
-            const prepared = await profiles.prepareActiveReload();
-            try {
-                return await mutate(purpose, () => action(prepared));
-            }
-            catch (err) {
-                if (!(err instanceof ProfileConflictError) || attempt >= 1)
-                    throw err;
-            }
-        }
+    const applyCore = async (onlyIfStopped = false) => {
+        const { signal } = preparation;
+        if (!coreInstalled(layout))
+            await updateCore();
+        return mutate("apply saved configuration", async () => {
+            signal.throwIfAborted();
+            requireRecoveredInstall();
+            if (onlyIfStopped && supervisor.isRunning())
+                return lifecycle.start();
+            const configuration = savedConfiguration();
+            await validate(configuration.generated, layout.coreExe, signal);
+            signal.throwIfAborted();
+            return lifecycle.apply(configuration);
+        });
     };
     const context = {
         layout,
+        state,
         token,
-        startedAt,
+        startedAt: new Date().toISOString(),
         webAuth: new WebAuthManager(),
         profiles,
         settingsService,
         lifecycle,
         supervisor,
         systemProxy,
+        autostart: deps.autostart ?? new AutostartService({ layout }),
         gate,
-        settings: {
-            committed: () => committedSettings,
-            runtime: () => runtimeSettings,
-        },
         mutate,
-        profileRevision: () => profileRevision,
-        startCore,
-        restartCore: () => readCoreUpdateTransaction(layout)
-            ? startCore()
-            : withPreparedReloadRetry("restart core", (prepared) => lifecycle.restart(async () => {
-                await commitPreparedReload(prepared, false);
-            })),
-        reloadCoreConfig: () => withPreparedReloadRetry("reload core config", (prepared) => commitPreparedReload(prepared, true)),
+        settings: { committed: settings, runtime: () => lifecycle.settings() },
+        profileRevision: () => state.snapshot().revision,
+        pendingApply: () => {
+            const saved = state.snapshot();
+            const active = getActiveProfile(saved.profiles);
+            const applied = lifecycle.configuration();
+            return (!applied ||
+                applied.profile?.id !== active?.id ||
+                applied.profile?.revision !== active?.revision ||
+                applied.settings.mixedPort !== saved.settings.mixedPort ||
+                applied.settings.allowLan !== saved.settings.allowLan);
+        },
+        startCore: () => applyCore(true),
+        restartCore: () => applyCore(),
+        updateCore,
+        stopCore: () => {
+            cancelPreparations();
+            return mutate("stop Core", () => lifecycle.stop());
+        },
         shutdown: () => gate.shutdown(),
-        closeListener: () => Promise.reject(new Error("listener close is not wired yet")),
+        closeListener: () => Promise.reject(new Error("Listener is not ready")),
         ...(deps.onShutdown ? { onShutdown: deps.onShutdown } : {}),
     };
     return { context, supervisor, lifecycle, token };

package/dist/daemon/context.js

@@ -1,30 +1,35 @@
 import { ShuttingDownError } from "./errors.js";
 export class DaemonGate {
-    queue;
     cleanup;
+    cancel;
+    tail = Promise.resolve();
     closing = false;
     cleanupPromise;
-    constructor(queue, cleanup) {
-        this.queue = queue;
+    constructor(cleanup, cancel) {
         this.cleanup = cleanup;
+        this.cancel = cancel;
     }
     get isClosing() {
         return this.closing;
     }
-    async mutate(purpose, action) {
+    mutate(_purpose, action) {
         if (this.closing)
-            throw new ShuttingDownError();
-        return this.queue.run(purpose, () => {
+            return Promise.reject(new ShuttingDownError());
+        const next = this.tail.then(() => {
             if (this.closing)
                 throw new ShuttingDownError();
             return action();
         });
+        this.tail = next.then(() => undefined, () => undefined);
+        return next;
     }
     shutdown() {
         if (this.cleanupPromise)
             return this.cleanupPromise;
         this.closing = true;
-        const attempt = this.queue.run("close daemon", this.cleanup);
+        this.cancel();
+        const attempt = this.tail.then(this.cleanup);
+        this.tail = attempt.then(() => undefined, () => undefined);
         this.cleanupPromise = attempt;
         void attempt.catch(() => {
             if (this.cleanupPromise === attempt) {
@@ -36,5 +41,6 @@ export class DaemonGate {
     }
     reopen() {
         this.closing = false;
+        this.cleanupPromise = undefined;
     }
 }

package/dist/daemon/entry.js

@@ -1,67 +1,50 @@
-import { assertCoreInstallationConsistent } from "../core.js";
-import { recoverCoreInstallTransaction } from "../core-install-transaction.js";
-import { atomicWriteFileSync } from "../fs-atomic.js";
-import { readManagedStateTransactionStatus, recoverManagedStateTransaction, } from "../managed-state-transaction.js";
+import { SashStateStore } from "../app-state.js";
+import { atomicWriteFileSync, durableRemoveFileSync } from "../fs-atomic.js";
 import { sashLayout } from "../paths.js";
-import { clearPidRecord } from "../process.js";
-import { migrateProfileState } from "../profile-migration.js";
-import { reconcileOrphanedRuntime } from "../runtime-recovery.js";
-import { loadSettings } from "../settings.js";
-import { acquireStateLock, StateMutationQueue } from "../state-lock.js";
+import { acquireStateLock } from "../state-lock.js";
 import { createDaemonServer } from "./server.js";
 export async function runDaemon(opts = {}) {
     const layout = opts.layout ?? sashLayout();
-    const daemonLease = await acquireStateLock(layout.daemonLeaseFile, {
+    const lease = await acquireStateLock(layout.daemonLeaseFile, {
         purpose: "sashd singleton",
         timeoutMs: 0,
     });
     let onSignal;
+    let published = false;
     try {
-        const initialization = new StateMutationQueue(layout.mutationLockFile);
-        const settings = await initialization.run("initialize daemon state", async () => {
-            recoverCoreInstallTransaction(layout);
-            const managed = readManagedStateTransactionStatus(layout);
-            if (managed?.coordination !== "core-update") {
-                recoverManagedStateTransaction(layout);
-            }
-            let loaded = loadSettings(layout);
-            const pendingUpdate = await reconcileOrphanedRuntime({ layout, settings: loaded });
-            assertCoreInstallationConsistent(layout);
-            loaded = loadSettings(layout);
-            if (!pendingUpdate) {
-                await migrateProfileState(loaded, layout);
-            }
-            return loaded;
-        });
-        const instance = createDaemonServer({ layout, settings });
-        const serverClosed = new Promise((resolve) => instance.server.once("close", resolve));
-        const port = settings.daemonPort;
+        const state = new SashStateStore(layout);
+        const instance = createDaemonServer({ layout, state });
+        await instance.lifecycle.recoverStartup();
+        const closed = new Promise((resolve) => instance.server.once("close", resolve));
+        const port = state.snapshot().settings.daemonPort;
         await new Promise((resolve, reject) => {
-            instance.server.listen(port, "127.0.0.1", () => resolve());
             instance.server.once("error", reject);
+            instance.server.listen(port, "127.0.0.1", resolve);
         });
-        const pidRecord = {
+        const record = {
             pid: process.pid,
             token: instance.token,
             port,
             startedAt: new Date().toISOString(),
         };
-        atomicWriteFileSync(layout.daemonPidFile, `${JSON.stringify(pidRecord, null, 2)}\n`);
+        atomicWriteFileSync(layout.daemonPidFile, `${JSON.stringify(record, null, 2)}\n`);
+        published = true;
         onSignal = () => {
-            void instance.close().catch((err) => {
-                console.error(`[sashd] shutdown blocked: ${err.message}`);
-            });
+            void instance
+                .close()
+                .catch((error) => console.error(`[sashd] shutdown blocked: ${error instanceof Error ? error.message : String(error)}`));
         };
         process.on("SIGTERM", onSignal);
         process.on("SIGINT", onSignal);
-        await serverClosed;
+        await closed;
     }
     finally {
         if (onSignal) {
             process.removeListener("SIGTERM", onSignal);
             process.removeListener("SIGINT", onSignal);
         }
-        clearPidRecord(layout.daemonPidFile);
-        daemonLease.release();
+        if (published)
+            durableRemoveFileSync(layout.daemonPidFile);
+        lease.release();
     }
 }

package/dist/daemon/errors.js

@@ -1,3 +1,4 @@
+import { AutostartUnavailableError } from "../autostart.js";
 import { HttpError } from "../daemon-http.js";
 import { ProfileConflictError, ProfileInputError, ProfileNotFoundError, } from "../profile-service.js";
 import { CoreUnhealthyError, SettingsConflictError, SettingsInputError, } from "../settings-service.js";
@@ -31,6 +32,8 @@ export function errorToHttp(err) {
         };
     }
     const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof AutostartUnavailableError)
+        return { status: 409, code: "conflict", message };
     if (err instanceof ProfileNotFoundError)
         return { status: 404, code: "not_found", message };
     if (err instanceof ProfileInputError)

package/dist/daemon/handlers/autostart.js

@@ -0,0 +1,18 @@
+import { parseAutostartEnabled } from "../../autostart-contract.js";
+import { HttpError } from "../../daemon-http.js";
+import { errorMessage } from "../../error-utils.js";
+export async function readAutostart(ctx) {
+    return { status: 200, json: await ctx.autostart.inspect() };
+}
+export async function writeAutostart(ctx, req) {
+    const body = await req.readJson();
+    let enabled;
+    try {
+        enabled = parseAutostartEnabled(body);
+    }
+    catch (error) {
+        throw new HttpError(400, errorMessage(error));
+    }
+    const status = await ctx.mutate("configure login startup", () => ctx.autostart.set(enabled));
+    return { status: 200, json: status };
+}

package/dist/daemon/handlers/core.js

@@ -1,17 +1,40 @@
+import { MihomoApi } from "../../api.js";
+import { validateCoreReleaseTag } from "../../core-install-record.js";
+import { HttpError } from "../../daemon-http.js";
 export async function startCore(ctx) {
-    const result = await ctx.startCore();
-    return { status: 200, json: result };
+    return { status: 200, json: await ctx.startCore() };
 }
 export async function stopCore(ctx) {
-    await ctx.mutate("stop core", () => ctx.lifecycle.stop());
+    await ctx.stopCore();
     return { status: 204 };
 }
 export async function restartCore(ctx) {
-    const result = await ctx.restartCore();
-    return { status: 200, json: result };
+    return { status: 200, json: await ctx.restartCore() };
 }
-export async function reloadCoreConfig(ctx) {
-    const result = await ctx.reloadCoreConfig();
-    const body = { proxyCount: result.proxyCount, source: result.source };
-    return { status: 200, json: body };
+export async function updateCore(ctx, req) {
+    const body = await req.readJson(1024);
+    if (Object.keys(body).some((key) => key !== "version") ||
+        (body.version !== undefined && typeof body.version !== "string")) {
+        throw new HttpError(400, "Expected an optional Core version string");
+    }
+    let version;
+    try {
+        version = typeof body.version === "string" ? validateCoreReleaseTag(body.version) : undefined;
+    }
+    catch (error) {
+        throw new HttpError(400, error instanceof Error ? error.message : String(error));
+    }
+    return { status: 200, json: await ctx.updateCore(version) };
+}
+export async function setCoreMode(ctx, req) {
+    const body = await req.readJson(1024);
+    const mode = body.mode;
+    if (Object.keys(body).some((key) => key !== "mode") ||
+        (mode !== "rule" && mode !== "global" && mode !== "direct"))
+        throw new HttpError(400, "Invalid routing mode");
+    await ctx.mutate("set routing mode", async () => {
+        const settings = ctx.settings.runtime();
+        await new MihomoApi(settings.controller, settings.secret).setMode(mode);
+    });
+    return { status: 204 };
 }