@astralyn/sash 0.1.1 → 0.1.2

package/dist/profiles.js

@@ -1,182 +1,54 @@
-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));
+import { readState } from "./app-state.js";
+import { buildDefaultConfig, isValidMihomoConfig, PROFILE_DOWNLOAD_SIZE_LIMIT, renderConfig, } from "./mihomo-config.js";
+export { DEFAULT_PROFILE_INTERVAL_HOURS, MAX_PROFILE_INTERVAL_HOURS } from "./profile-model.js";
+export function profileFilePath(layout, id, revision) {
+    if (!/^[0-9]+$/.test(id) || !Number.isSafeInteger(revision) || revision < 1) {
+        throw new Error("Invalid profile id or revision");
+    }
+    return path.join(layout.profilesDir, id, `${revision}.yaml`);
+}
+export function parseProfileText(text) {
+    if (!text.trim() || Buffer.byteLength(text) > PROFILE_DOWNLOAD_SIZE_LIMIT) {
+        throw new Error("Profile content must be non-empty and no larger than 8 MiB");
+    }
+    const doc = YAML.parse(text, { maxAliasCount: 50 });
+    if (!isValidMihomoConfig(doc))
+        throw new Error("Content is not a valid core configuration (missing proxies/rules)");
+    return doc;
+}
+export function readProfileSource(layout, profile) {
+    const file = profileFilePath(layout, profile.id, profile.revision);
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.size > PROFILE_DOWNLOAD_SIZE_LIMIT)
+        throw new Error("Profile must be a bounded regular file");
+    const yamlText = fs.readFileSync(file, "utf8");
+    return { yamlText, doc: parseProfileText(yamlText) };
+}
+export function loadProfiles(layout) {
+    return readState(layout)?.profiles ?? { activeId: null, profiles: [] };
 }
 export function getActiveProfile(index) {
-    return index.profiles.find((p) => p.id === index.activeId) ?? null;
+    return index.profiles.find((profile) => profile.id === index.activeId) ?? null;
 }
-export function findProfileByUrl(index, url) {
-    return index.profiles.find((p) => p.url !== "" && p.url === url) ?? null;
+export function renderActiveConfig(state, layout) {
+    const active = getActiveProfile(state.profiles);
+    return renderConfig(active ? readProfileSource(layout, active).doc : buildDefaultConfig(), state.settings, active ? "subscription" : "default");
 }
-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 allocateProfileId(index, layout) {
+    let id = BigInt(Date.now());
+    while (index.profiles.some((profile) => profile.id === String(id)) ||
+        fs.existsSync(path.join(layout.profilesDir, String(id))))
+        id += 1n;
+    return String(id);
 }
 export function profileNameFromUrl(url) {
-    try {
-        return new URL(url).hostname || "profile";
-    }
-    catch {
-        return "profile";
-    }
+    return new URL(url).hostname || "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;
+export function profileDueForUpdate(profile, nowMs = Date.now()) {
+    return Boolean(profile.url &&
+        profile.intervalHours > 0 &&
+        nowMs - Date.parse(profile.updatedAt) >= profile.intervalHours * 3_600_000);
 }

package/dist/runtime-lifecycle.js

@@ -1,205 +1,123 @@
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
+import { MihomoApi } from "./api.js";
+import { commitCoreUpdate, readCoreUpdateTransaction, recoverCoreUpdateTransaction, } from "./core-update.js";
+import { atomicWriteFileSync } from "./fs-atomic.js";
+import { recoverBinaryUnlockProbe } from "./process.js";
 export class RuntimeLifecycle {
-    supervisor;
-    systemProxy;
-    getSettings;
-    coreUpdate;
-    operationQueue = Promise.resolve();
-    phase;
-    generation = 0;
+    options;
+    runtimeRevision = 0;
+    applied;
+    runtimeSettings;
     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)
+        this.options = options;
+        this.runtimeSettings = { ...options.settings() };
+    }
+    get revision() {
+        return this.runtimeRevision;
+    }
+    settings() {
+        return { ...this.runtimeSettings };
+    }
+    configuration() {
+        return this.applied;
+    }
+    async recoverStartup() {
+        await this.options.systemProxy.release();
+        await this.options.supervisor.cleanStaleCore();
+        if (readCoreUpdateTransaction(this.options.layout))
+            await this.requireVacantController();
+        recoverBinaryUnlockProbe(this.options.layout.coreExe);
+        recoverCoreUpdateTransaction(this.options.layout, this.options.verifyExecutable);
+    }
+    async requireVacantController() {
+        const reachable = this.options.controllerProbe
+            ? await this.options.controllerProbe(this.runtimeSettings)
+            : await new MihomoApi(this.runtimeSettings.controller, this.runtimeSettings.secret).isReachable();
+        if (reachable)
+            throw new Error("An unowned Core controller is still active; refusing to replace its runtime");
+    }
+    startCore() {
+        this.runtimeRevision += 1;
+        return this.options.supervisor.start();
+    }
+    async start() {
+        const core = await this.options.supervisor.status();
+        if (!core.running || !core.healthy || !core.pid)
+            throw new Error("Core is no longer healthy; retry start");
+        await this.reconcileSystemProxy();
+        return { pid: core.pid, ...(core.version ? { version: core.version } : {}) };
+    }
+    async apply(configuration) {
+        await this.stop();
+        await this.requireVacantController();
+        this.applied = undefined;
+        atomicWriteFileSync(this.options.layout.configFile, configuration.generated.yaml);
+        this.runtimeSettings = { ...configuration.settings };
+        const result = await this.startCore();
+        this.applied = configuration;
+        await this.reconcileSystemProxy();
+        return result;
+    }
+    async stop() {
+        await this.options.systemProxy.release();
+        await this.options.supervisor.stop();
+        this.runtimeRevision += 1;
+    }
+    async reconcileSystemProxy() {
+        if (!this.options.settings().systemProxy) {
+            await this.options.systemProxy.release();
             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}`);
+        const { supervisor, systemProxy } = this.options;
+        const owner = supervisor.ownedCoreSnapshot();
+        const core = await supervisor.status();
+        if (!owner || !core.running || !core.healthy || !supervisor.ownsCore(owner)) {
+            throw new Error("Cannot enable system proxy without a healthy owned Core");
         }
+        await systemProxy.apply({ port: this.runtimeSettings.mixedPort });
+        const after = await supervisor.status();
+        if (after.running && after.healthy && supervisor.ownsCore(owner))
+            return;
+        await systemProxy.release();
         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");
+    async update(staged, configuration) {
+        const wasRunning = this.options.supervisor.isRunning();
+        if (!wasRunning) {
+            atomicWriteFileSync(this.options.layout.configFile, configuration.generated.yaml);
+            this.runtimeSettings = { ...configuration.settings };
         }
-        if (!this.supervisor.ownsCore(ownership)) {
-            throw new Error("Cannot enable system proxy: core ownership changed during health check");
+        return commitCoreUpdate({
+            layout: this.options.layout,
+            staged,
+            verifyExecutable: this.options.verifyExecutable,
+            runtime: {
+                wasRunning,
+                stop: async () => {
+                    await this.stop();
+                    await this.requireVacantController();
+                },
+                startAndVerify: async () => {
+                    await this.startCore();
+                    this.applied = configuration;
+                },
+                applySystemProxy: () => this.reconcileSystemProxy(),
+            },
+        });
+    }
+    async handleUnexpectedCoreExit() {
+        if (this.options.supervisor.isRunning())
+            return;
+        this.runtimeRevision += 1;
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                await this.options.systemProxy.release();
+                return;
+            }
+            catch (error) {
+                if (attempt === 2)
+                    throw error;
+                await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)));
+            }
         }
-        return ownership;
     }
 }