@astralyn/sash 0.1.0 → 0.1.2

package/dist/managed-state-transaction.js

@@ -1,377 +0,0 @@
-import fs from "node:fs";
-import { atomicWriteFileSync, durableRemoveFileSync } from "./fs-atomic.js";
-import { hasExactOwnKeys, isCanonicalIsoTimestamp, isPlainObject } from "./json-shape.js";
-import { profileFilePath, serializeProfiles } from "./profiles.js";
-const MAX_JOURNAL_BYTES = 36 * 1024 * 1024;
-const MAX_SNAPSHOT_BYTES = 24 * 1024 * 1024;
-export const defaultManagedStateFileOperations = {
-    write: atomicWriteFileSync,
-    remove: durableRemoveFileSync,
-};
-function decodeSnapshot(value, role) {
-    if (!isPlainObject(value) || !hasExactOwnKeys(value, ["data"])) {
-        throw new Error(`Managed-state transaction journal has invalid ${role} snapshot`);
-    }
-    if (value.data === null)
-        return null;
-    if (typeof value.data !== "string") {
-        throw new Error(`Managed-state transaction journal has invalid ${role} snapshot data`);
-    }
-    const decoded = Buffer.from(value.data, "base64");
-    if (decoded.toString("base64") !== value.data) {
-        throw new Error(`Managed-state transaction journal has non-canonical ${role} snapshot data`);
-    }
-    return decoded;
-}
-function parseJournal(raw) {
-    if (!isPlainObject(raw)) {
-        throw new Error("Managed-state transaction journal has an invalid root shape");
-    }
-    const legacy = raw.version === 1;
-    const coordinated = raw.version === 3;
-    const allowed = legacy
-        ? ["version", "createdAt", "index", "profile", "config"]
-        : [
-            "version",
-            "phase",
-            "createdAt",
-            "index",
-            "profile",
-            "config",
-            "settings",
-            ...(coordinated ? ["coordination"] : []),
-        ];
-    const required = legacy
-        ? ["version", "createdAt", "index"]
-        : ["version", "phase", "createdAt", ...(coordinated ? ["coordination"] : [])];
-    if (Object.keys(raw).some((key) => !allowed.includes(key)) ||
-        !required.every((key) => key in raw)) {
-        throw new Error("Managed-state transaction journal has an invalid root shape");
-    }
-    if (raw.version !== 1 && raw.version !== 2 && raw.version !== 3) {
-        throw new Error("Managed-state transaction journal has an unsupported version");
-    }
-    let phase;
-    if (raw.version === 1) {
-        phase = "publishing";
-    }
-    else if (raw.phase === "publishing" ||
-        raw.phase === "committed" ||
-        (raw.version === 3 && raw.phase === "retained")) {
-        phase = raw.phase;
-    }
-    else {
-        throw new Error("Managed-state transaction journal has an invalid phase");
-    }
-    if (!isCanonicalIsoTimestamp(raw.createdAt)) {
-        throw new Error("Managed-state transaction journal has an invalid timestamp");
-    }
-    const coordination = raw.version === 3 && raw.coordination === "core-update" ? raw.coordination : undefined;
-    if (raw.version === 3 && !coordination) {
-        throw new Error("Managed-state transaction journal has invalid coordination");
-    }
-    const index = raw.index === undefined ? undefined : decodeSnapshot(raw.index, "index");
-    let profile;
-    if (raw.profile !== undefined) {
-        if (!isPlainObject(raw.profile) || !hasExactOwnKeys(raw.profile, ["id", "data"])) {
-            throw new Error("Managed-state transaction journal has an invalid profile snapshot");
-        }
-        if (typeof raw.profile.id !== "string" || !/^[0-9]+$/.test(raw.profile.id)) {
-            throw new Error("Managed-state transaction journal has an invalid profile id");
-        }
-        profile = { id: raw.profile.id, data: decodeSnapshot({ data: raw.profile.data }, "profile") };
-    }
-    const config = raw.config === undefined ? undefined : decodeSnapshot(raw.config, "config");
-    const settings = raw.settings === undefined ? undefined : decodeSnapshot(raw.settings, "settings");
-    const decodedSize = (index?.length ?? 0) +
-        (profile?.data?.length ?? 0) +
-        (config?.length ?? 0) +
-        (settings?.length ?? 0);
-    if (decodedSize > MAX_SNAPSHOT_BYTES) {
-        throw new Error("Managed-state transaction journal snapshots exceed the size limit");
-    }
-    return {
-        phase,
-        createdAt: raw.createdAt,
-        ...(coordination ? { coordination } : {}),
-        snapshots: [
-            ...(profile ? [{ path: profile.id, data: profile.data }] : []),
-            ...(index !== undefined ? [{ path: "index", data: index }] : []),
-            ...(config !== undefined ? [{ path: "config", data: config }] : []),
-            ...(settings !== undefined ? [{ path: "settings", data: settings }] : []),
-        ],
-    };
-}
-function readJournal(layout) {
-    let text;
-    try {
-        const stat = fs.lstatSync(layout.managedStateTransactionFile);
-        if (!stat.isFile() || stat.size > MAX_JOURNAL_BYTES) {
-            throw new Error("Managed-state transaction journal is not a bounded regular file");
-        }
-        text = fs.readFileSync(layout.managedStateTransactionFile, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return undefined;
-        throw err;
-    }
-    let raw;
-    try {
-        raw = JSON.parse(text);
-    }
-    catch (err) {
-        throw new Error(`Managed-state transaction journal is invalid JSON: ${err.message}`);
-    }
-    return parseJournal(raw);
-}
-export function readManagedStateTransactionStatus(layout) {
-    const stored = readJournal(layout);
-    if (!stored)
-        return undefined;
-    return {
-        phase: stored.phase,
-        createdAt: stored.createdAt,
-        ...(stored.coordination ? { coordination: stored.coordination } : {}),
-    };
-}
-function snapshot(paths) {
-    return [...new Set(paths)].map((file) => {
-        try {
-            return { path: file, data: fs.readFileSync(file) };
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return { path: file, data: null };
-            throw err;
-        }
-    });
-}
-function journalFromSnapshots(snapshots, layout, profileId, coordination) {
-    const indexEntry = snapshots.find((entry) => entry.path === layout.profilesIndexFile);
-    const profileEntry = profileId
-        ? snapshots.find((entry) => entry.path === profileFilePath(layout, profileId))
-        : undefined;
-    const configEntry = snapshots.find((entry) => entry.path === layout.configFile);
-    const settingsEntry = snapshots.find((entry) => entry.path === layout.settingsFile);
-    const size = (indexEntry?.data?.length ?? 0) +
-        (profileEntry?.data?.length ?? 0) +
-        (configEntry?.data?.length ?? 0) +
-        (settingsEntry?.data?.length ?? 0);
-    if (size > MAX_SNAPSHOT_BYTES) {
-        throw new Error("Managed-state transaction snapshots exceed the journal size limit");
-    }
-    const entries = {
-        createdAt: new Date().toISOString(),
-        ...(indexEntry ? { index: { data: indexEntry.data?.toString("base64") ?? null } } : {}),
-        ...(profileEntry && profileId
-            ? {
-                profile: {
-                    id: profileId,
-                    data: profileEntry.data?.toString("base64") ?? null,
-                },
-            }
-            : {}),
-        ...(configEntry ? { config: { data: configEntry.data?.toString("base64") ?? null } } : {}),
-        ...(settingsEntry
-            ? { settings: { data: settingsEntry.data?.toString("base64") ?? null } }
-            : {}),
-    };
-    return coordination
-        ? { version: 3, phase: "publishing", coordination, ...entries }
-        : { version: 2, phase: "publishing", ...entries };
-}
-function restore(snapshots, files) {
-    const errors = [];
-    for (const entry of snapshots) {
-        try {
-            if (entry.data === null)
-                files.remove(entry.path);
-            else
-                files.write(entry.path, entry.data);
-        }
-        catch (err) {
-            errors.push(`${entry.path}: ${err.message}`);
-        }
-    }
-    return errors;
-}
-function resolvedSnapshots(stored, layout) {
-    return stored.snapshots.map((entry) => ({
-        path: entry.path === "index"
-            ? layout.profilesIndexFile
-            : entry.path === "config"
-                ? layout.configFile
-                : entry.path === "settings"
-                    ? layout.settingsFile
-                    : profileFilePath(layout, entry.path),
-        data: entry.data,
-    }));
-}
-function transactionSnapshots(layout, transaction) {
-    const profilePath = transaction.profile
-        ? profileFilePath(layout, transaction.profile.id)
-        : undefined;
-    return {
-        ...(profilePath ? { profilePath } : {}),
-        snapshots: snapshot([
-            ...(profilePath ? [profilePath] : []),
-            ...(transaction.index ? [layout.profilesIndexFile] : []),
-            ...(transaction.config ? [layout.configFile] : []),
-            ...(transaction.settings ? [layout.settingsFile] : []),
-        ]),
-    };
-}
-function publishFiles(layout, transaction, profilePath, files) {
-    if (profilePath && transaction.profile) {
-        if (transaction.profile.yamlText === null)
-            files.remove(profilePath);
-        else
-            files.write(profilePath, transaction.profile.yamlText);
-    }
-    if (transaction.index) {
-        files.write(layout.profilesIndexFile, serializeProfiles(transaction.index));
-    }
-    if (transaction.config)
-        files.write(layout.configFile, transaction.config.yaml);
-    if (transaction.settings) {
-        files.write(layout.settingsFile, `${JSON.stringify(transaction.settings, null, 2)}\n`);
-    }
-}
-function writeJournal(layout, journal) {
-    atomicWriteFileSync(layout.managedStateTransactionFile, `${JSON.stringify(journal)}\n`);
-}
-function restoreAndClear(stored, layout, files, errorPrefix) {
-    const errors = restore(resolvedSnapshots(stored, layout), files);
-    if (errors.length === 0) {
-        try {
-            durableRemoveFileSync(layout.managedStateTransactionFile);
-        }
-        catch (err) {
-            errors.push(`journal: ${err.message}`);
-        }
-    }
-    if (errors.length)
-        throw new Error(`${errorPrefix}: ${errors.join("; ")}`);
-}
-export function recoverManagedStateTransaction(layout, files = defaultManagedStateFileOperations) {
-    const stored = readJournal(layout);
-    if (!stored)
-        return;
-    if (stored.phase === "committed") {
-        durableRemoveFileSync(layout.managedStateTransactionFile);
-        return;
-    }
-    if (stored.phase === "retained") {
-        throw new Error("A retained managed-state transaction requires coordinated Core update recovery");
-    }
-    restoreAndClear(stored, layout, files, "Managed-state transaction recovery failed");
-}
-export async function retainManagedStateTransaction(layout, transaction, files = defaultManagedStateFileOperations) {
-    if (transaction.applyRuntime || transaction.reloadRuntime === true || transaction.settings) {
-        throw new Error("Retained Core update publications cannot transition runtime or publish settings");
-    }
-    recoverManagedStateTransaction(layout, files);
-    const { profilePath, snapshots } = transactionSnapshots(layout, transaction);
-    const journal = journalFromSnapshots(snapshots, layout, transaction.profile?.id, "core-update");
-    if (journal.version !== 3) {
-        throw new Error("Failed to create a coordinated managed-state transaction");
-    }
-    writeJournal(layout, journal);
-    try {
-        publishFiles(layout, transaction, profilePath, files);
-        writeJournal(layout, { ...journal, phase: "retained" });
-    }
-    catch (err) {
-        const rollbackErrors = restore(snapshots, files);
-        if (rollbackErrors.length === 0) {
-            try {
-                durableRemoveFileSync(layout.managedStateTransactionFile);
-            }
-            catch (clearErr) {
-                rollbackErrors.push(`journal: ${clearErr.message}`);
-            }
-        }
-        const suffix = rollbackErrors.length
-            ? `; managed-state transaction rollback failed: ${rollbackErrors.join("; ")}`
-            : "";
-        throw new Error(`${err.message}${suffix}`);
-    }
-}
-export function rollbackRetainedManagedStateTransaction(layout, files = defaultManagedStateFileOperations) {
-    const stored = readJournal(layout);
-    if (!stored)
-        return false;
-    if (stored.coordination !== "core-update" || stored.phase === "committed") {
-        throw new Error("Managed-state transaction is not a retained Core update publication");
-    }
-    restoreAndClear(stored, layout, files, "Retained managed-state transaction rollback failed");
-    return true;
-}
-export function markRetainedManagedStateTransactionCommitted(layout) {
-    const stored = readJournal(layout);
-    if (!stored)
-        return false;
-    if (stored.coordination !== "core-update" || stored.phase !== "retained") {
-        throw new Error("Managed-state transaction is not ready for coordinated commit");
-    }
-    const raw = JSON.parse(fs.readFileSync(layout.managedStateTransactionFile, "utf8"));
-    if (raw?.version !== 3 || raw.coordination !== "core-update") {
-        throw new Error("Managed-state transaction changed during coordinated commit");
-    }
-    writeJournal(layout, { ...raw, phase: "committed" });
-    return true;
-}
-export function clearCommittedManagedStateTransaction(layout) {
-    const stored = readJournal(layout);
-    if (!stored)
-        return false;
-    if (stored.coordination !== "core-update" || stored.phase !== "committed") {
-        throw new Error("Managed-state transaction is not committed coordinated state");
-    }
-    durableRemoveFileSync(layout.managedStateTransactionFile);
-    return true;
-}
-export async function commitManagedStateTransaction(layout, transaction, reloadConfig, files = defaultManagedStateFileOperations) {
-    recoverManagedStateTransaction(layout, files);
-    const { profilePath, snapshots } = transactionSnapshots(layout, transaction);
-    const journal = journalFromSnapshots(snapshots, layout, transaction.profile?.id);
-    writeJournal(layout, journal);
-    let reloadAttempted = false;
-    try {
-        publishFiles(layout, transaction, profilePath, files);
-        if (transaction.config && transaction.reloadRuntime !== false && reloadConfig) {
-            reloadAttempted = true;
-            await reloadConfig(layout.configFile);
-        }
-        await transaction.applyRuntime?.();
-        writeJournal(layout, { ...journal, phase: "committed" });
-        durableRemoveFileSync(layout.managedStateTransactionFile);
-    }
-    catch (err) {
-        const rollbackErrors = restore(snapshots, files);
-        if (reloadAttempted && transaction.config && reloadConfig) {
-            const oldConfig = snapshots.find((entry) => entry.path === layout.configFile);
-            if (oldConfig?.data !== null) {
-                try {
-                    await reloadConfig(layout.configFile);
-                }
-                catch (reloadErr) {
-                    rollbackErrors.push(`config rollback reload failed: ${reloadErr.message}`);
-                }
-            }
-        }
-        if (rollbackErrors.length === 0) {
-            try {
-                durableRemoveFileSync(layout.managedStateTransactionFile);
-            }
-            catch (clearErr) {
-                rollbackErrors.push(`journal: ${clearErr.message}`);
-            }
-        }
-        const suffix = rollbackErrors.length
-            ? `; managed-state transaction rollback failed: ${rollbackErrors.join("; ")}`
-            : "";
-        throw new Error(`${err.message}${suffix}`);
-    }
-}

package/dist/offline-mutation.js

@@ -1,58 +0,0 @@
-import fs from "node:fs";
-import { assertCoreInstallationConsistent } from "./core.js";
-import { recoverCoreInstallTransaction } from "./core-install-transaction.js";
-import { recoverCoordinatedCoreUpdate } from "./core-update-coordination.js";
-import { evaluateDaemon } from "./daemon-lifecycle.js";
-import { readManagedStateTransactionStatus, recoverManagedStateTransaction, } from "./managed-state-transaction.js";
-import { isProcessAlive, readPidRecord } from "./process.js";
-import { migrateProfileState } from "./profile-migration.js";
-import { reconcileOrphanedRuntime } from "./runtime-recovery.js";
-import { loadSettings } from "./settings.js";
-import { withStateLock } from "./state-lock.js";
-export async function runOfflineMutation(ctx, purpose, action, options = {}) {
-    return withStateLock(ctx.layout.mutationLockFile, { purpose, timeoutMs: 30_000 }, async () => {
-        ctx.settings = loadSettings(ctx.layout);
-        const daemon = await evaluateDaemon(ctx.layout, ctx.settings);
-        if (daemon.kind !== "stopped") {
-            const owner = daemon.pid ? ` (PID=${daemon.pid})` : "";
-            throw new Error(`sashd owns the data directory${owner} but is not accepting this operation; stop or recover it before retrying`);
-        }
-        const reconciliation = options.reconcileRuntime;
-        if (!reconciliation) {
-            const core = readPidRecord(ctx.layout.pidFile);
-            if (!core && fs.existsSync(ctx.layout.pidFile)) {
-                throw new Error(`Core PID record is corrupt: ${ctx.layout.pidFile}; reconcile it before modifying state`);
-            }
-            if (core && isProcessAlive(core.pid)) {
-                throw new Error(`Core PID ${core.pid} is still alive without sashd; run \`sash stop\` to reconcile it before modifying state`);
-            }
-        }
-        recoverCoreInstallTransaction(ctx.layout);
-        if (reconciliation) {
-            const managed = readManagedStateTransactionStatus(ctx.layout);
-            if (managed?.coordination !== "core-update") {
-                recoverManagedStateTransaction(ctx.layout);
-            }
-            ctx.settings = loadSettings(ctx.layout);
-            await reconcileOrphanedRuntime({
-                layout: ctx.layout,
-                settings: ctx.settings,
-                ...(reconciliation.legacyDaemon ? { legacyDaemon: reconciliation.legacyDaemon } : {}),
-                ...(reconciliation.verifyControllerVacant
-                    ? { verifyControllerVacant: reconciliation.verifyControllerVacant }
-                    : {}),
-            }, reconciliation.deps);
-        }
-        else {
-            recoverCoordinatedCoreUpdate(ctx.layout);
-            if (options.allowInconsistentCore !== "force-update") {
-                assertCoreInstallationConsistent(ctx.layout);
-            }
-        }
-        ctx.settings = loadSettings(ctx.layout);
-        if (options.migrateProfiles) {
-            await migrateProfileState(ctx.settings, ctx.layout);
-        }
-        return action();
-    });
-}

package/dist/profile-migration.js

@@ -1,101 +0,0 @@
-import fs from "node:fs";
-import { isDeepStrictEqual } from "node:util";
-import YAML from "yaml";
-import { commitManagedStateTransaction, defaultManagedStateFileOperations, } from "./managed-state-transaction.js";
-import { buildDefaultConfig, isValidMihomoConfig, PROFILE_DOWNLOAD_SIZE_LIMIT, stripManagedKeys, } from "./mihomo-config.js";
-import { allocateProfileId, DEFAULT_PROFILE_INTERVAL_HOURS, findProfileByUrl, loadProfiles, NEVER_UPDATED, profileNameFromUrl, } from "./profiles.js";
-export const IMPORTED_CONFIG_PROFILE_NAME = "Imported config";
-export async function migrateLegacyProfileSetting(settings, layout, files = defaultManagedStateFileOperations) {
-    if (!("subscriptionUrl" in settings))
-        return false;
-    const candidate = { ...settings };
-    const url = candidate.subscriptionUrl?.trim() ?? "";
-    delete candidate.subscriptionUrl;
-    let migratedIndex;
-    if (url) {
-        const index = loadProfiles(layout);
-        if (!findProfileByUrl(index, url)) {
-            const now = new Date().toISOString();
-            const profile = {
-                id: allocateProfileId(index, layout),
-                name: profileNameFromUrl(url),
-                url,
-                intervalHours: DEFAULT_PROFILE_INTERVAL_HOURS,
-                createdAt: now,
-                updatedAt: NEVER_UPDATED,
-            };
-            migratedIndex = {
-                activeId: index.activeId ?? profile.id,
-                profiles: [...index.profiles, profile],
-            };
-        }
-    }
-    await commitManagedStateTransaction(layout, { ...(migratedIndex ? { index: migratedIndex } : {}), settings: candidate }, undefined, files);
-    delete settings.subscriptionUrl;
-    return true;
-}
-function hasMeaningfulRoutingContent(doc) {
-    const unmanaged = stripManagedKeys(doc);
-    const defaultConfig = buildDefaultConfig();
-    if (isDeepStrictEqual(unmanaged, defaultConfig))
-        return false;
-    if (Array.isArray(unmanaged.proxies) && unmanaged.proxies.length > 0)
-        return true;
-    const providers = unmanaged["proxy-providers"];
-    if (typeof providers === "object" &&
-        providers !== null &&
-        !Array.isArray(providers) &&
-        Object.keys(providers).length > 0) {
-        return true;
-    }
-    const groups = unmanaged["proxy-groups"];
-    if (Array.isArray(groups) &&
-        groups.length > 0 &&
-        !isDeepStrictEqual(groups, defaultConfig["proxy-groups"])) {
-        return true;
-    }
-    return (Array.isArray(unmanaged.rules) &&
-        unmanaged.rules.length > 0 &&
-        !isDeepStrictEqual(unmanaged.rules, defaultConfig.rules));
-}
-export async function migrateUnmanagedConfig(layout, files = defaultManagedStateFileOperations) {
-    if (fs.existsSync(layout.profilesIndexFile) || !fs.existsSync(layout.configFile))
-        return false;
-    const stat = fs.lstatSync(layout.configFile);
-    if (!stat.isFile() || stat.size > PROFILE_DOWNLOAD_SIZE_LIMIT) {
-        throw new Error(`Unmanaged config must be a regular file no larger than ${PROFILE_DOWNLOAD_SIZE_LIMIT} bytes: ${layout.configFile}`);
-    }
-    const yamlText = fs.readFileSync(layout.configFile, "utf8");
-    let doc;
-    try {
-        doc = YAML.parse(yamlText);
-    }
-    catch (err) {
-        throw new Error(`Unmanaged config is invalid YAML and was left unchanged: ${layout.configFile}: ${err.message}`);
-    }
-    if (!isValidMihomoConfig(doc)) {
-        throw new Error(`Unmanaged config is not a valid core configuration and was left unchanged: ${layout.configFile}`);
-    }
-    if (!hasMeaningfulRoutingContent(doc))
-        return false;
-    const now = new Date().toISOString();
-    const id = allocateProfileId({ activeId: null, profiles: [] }, layout);
-    const profile = {
-        id,
-        name: IMPORTED_CONFIG_PROFILE_NAME,
-        url: "",
-        intervalHours: 0,
-        createdAt: now,
-        updatedAt: now,
-    };
-    await commitManagedStateTransaction(layout, {
-        index: { activeId: id, profiles: [profile] },
-        profile: { id, yamlText },
-    }, undefined, files);
-    return true;
-}
-export async function migrateProfileState(settings, layout, files = defaultManagedStateFileOperations) {
-    const legacySubscription = await migrateLegacyProfileSetting(settings, layout, files);
-    const unmanagedConfig = await migrateUnmanagedConfig(layout, files);
-    return { legacySubscription, unmanagedConfig };
-}

package/dist/runtime-recovery.js

@@ -1,31 +0,0 @@
-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;
-}