@astralyn/sash 0.1.0 → 0.1.2

package/dist/daemon-lifecycle.js

@@ -3,13 +3,12 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { loadSettings } from "./app-state.js";
 import { SashDaemonClient } from "./daemon-client.js";
 import { isCanonicalIsoTimestamp, isPlainObject } from "./json-shape.js";
-import { log } from "./log.js";
 import { boundedLogTailSince, logTailCursor } from "./log-follow.js";
 import { sashLayout } from "./paths.js";
-import { buildSanitizedEnv, commandLineContains, isProcessAlive, killProcessGracefully, withPrivateAppendLogFds, } from "./process.js";
-import { loadSettings } from "./settings.js";
+import { buildSanitizedEnv, isProcessAlive, killProcessGracefully, withPrivateAppendLogFds, } from "./process.js";
 import { readStateLockRecord, withStateLock } from "./state-lock.js";
 export function readDaemonPidRecord(layout = sashLayout()) {
     try {
@@ -50,41 +49,11 @@ export async function evaluateDaemon(layout = sashLayout(), settings) {
         lease = readStateLockRecord(layout.daemonLeaseFile);
     }
     catch {
-        return {
-            kind: "unhealthy",
-            running: true,
-            healthy: false,
-            ...(record ? { stalePidFile: true } : {}),
-        };
+        return { kind: "unhealthy", running: true, healthy: false };
     }
-    if (!lease || !isProcessAlive(lease.pid)) {
-        if (record && isProcessAlive(record.pid)) {
-            const s = settings ?? loadSettings(layout);
-            const legacyClient = new SashDaemonClient(record.port || s.daemonPort, s.daemonSecret);
-            try {
-                const health = await legacyClient.health();
-                if (health.token === record.token && health.pid === record.pid) {
-                    return {
-                        kind: "healthy",
-                        running: true,
-                        healthy: true,
-                        legacyOwnership: true,
-                        pid: record.pid,
-                        port: record.port,
-                    };
-                }
-            }
-            catch {
-            }
-            return {
-                kind: "unhealthy",
-                running: true,
-                healthy: false,
-                legacyOwnership: true,
-                pid: record.pid,
-                ...(lease ? { staleLeaseFile: true } : {}),
-            };
-        }
+    const liveLease = lease && isProcessAlive(lease.pid);
+    const liveRecord = record && isProcessAlive(record.pid);
+    if (!liveLease && !liveRecord)
         return {
             kind: "stopped",
             running: false,
@@ -93,46 +62,19 @@ export async function evaluateDaemon(layout = sashLayout(), settings) {
             ...(record ? { stalePidFile: true } : {}),
             ...(lease ? { staleLeaseFile: true } : {}),
         };
+    if (!lease || !record || !liveLease || !liveRecord || lease.pid !== record.pid) {
+        return { kind: "unhealthy", running: true, healthy: false, pid: lease?.pid ?? record?.pid };
     }
-    if (!record || record.pid !== lease.pid || !isProcessAlive(record.pid)) {
-        return {
-            kind: "unhealthy",
-            running: true,
-            healthy: false,
-            pid: lease.pid,
-            ...(record ? { stalePidFile: true } : {}),
-        };
-    }
-    const s = settings ?? loadSettings(layout);
-    const client = new SashDaemonClient(record.port || s.daemonPort, s.daemonSecret);
     try {
+        const client = new SashDaemonClient(record.port, (settings ?? loadSettings(layout)).daemonSecret);
         const health = await client.health();
         if (health.token === record.token && health.pid === record.pid) {
-            return {
-                kind: "healthy",
-                running: true,
-                pid: record.pid,
-                healthy: true,
-                port: record.port,
-            };
+            return { kind: "healthy", running: true, healthy: true, pid: record.pid, port: record.port };
         }
-        return {
-            kind: "unhealthy",
-            running: true,
-            healthy: false,
-            stalePidFile: true,
-            pid: record.pid,
-        };
     }
     catch {
-        return {
-            kind: "unhealthy",
-            running: true,
-            pid: record.pid,
-            healthy: false,
-            port: record.port,
-        };
     }
+    return { kind: "unhealthy", running: true, healthy: false, pid: record.pid, port: record.port };
 }
 function resolveDaemonEntryPath() {
     const here = path.dirname(fileURLToPath(import.meta.url));
@@ -242,137 +184,18 @@ export async function ensureDaemon(opts = {}) {
         return;
     await spawnDaemon({ layout, settings });
 }
-async function waitForDaemonExit(pid, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline && isProcessAlive(pid))
-        await sleep(100);
-    if (isProcessAlive(pid)) {
-        throw new Error(`sashd PID ${pid} did not exit after maintenance shutdown`);
-    }
-}
-export async function prepareDaemonMaintenance(layout, settings, purpose, deps = {}) {
-    const daemonState = await (deps.evaluateDaemon ?? evaluateDaemon)(layout, settings);
-    if (daemonState.kind === "unhealthy") {
-        throw new Error(`sashd is running but unresponsive; refusing a competing ${purpose}`);
-    }
-    if (daemonState.kind === "stopped") {
-        return { daemonWasRunning: false, legacyDaemon: false, coreWasRunning: false };
-    }
-    const client = (deps.clientFactory ?? ((port, secret) => new SashDaemonClient(port, secret)))(daemonState.port, settings.daemonSecret);
-    if (daemonState.legacyOwnership) {
-        if (!client.status || !client.shutdown) {
-            throw new Error("Legacy sashd maintenance requires status and shutdown support");
-        }
-        log.warn("legacy sashd detected; using the pre-maintenance compatibility path");
-        const coreWasRunning = (await client.status()).core.running;
-        await client.shutdown();
-        await (deps.waitForDaemonExit ?? waitForDaemonExit)(daemonState.pid, 20_000);
-        return { daemonWasRunning: true, legacyDaemon: true, coreWasRunning };
-    }
-    const snapshot = await client.maintenanceShutdown();
-    await (deps.waitForDaemonExit ?? waitForDaemonExit)(daemonState.pid, 20_000);
-    return { daemonWasRunning: true, legacyDaemon: false, coreWasRunning: snapshot.coreWasRunning };
-}
 export async function stopDaemonFromCli(opts = {}) {
     const layout = opts.layout ?? sashLayout();
     const settings = opts.settings ?? loadSettings(layout);
-    const record = readDaemonPidRecord(layout);
-    if (!record) {
-        try {
-            const lease = readStateLockRecord(layout.daemonLeaseFile);
-            if (!lease || !isProcessAlive(lease.pid))
-                return true;
-            log.warn(`sashd is still starting or unresponsive (PID=${lease.pid}); try stopping again.`);
-            return false;
-        }
-        catch {
-            log.warn("Refusing to stop sashd: singleton ownership record is corrupt.");
-            return false;
-        }
-    }
-    const pid = record.pid;
-    if (!isProcessAlive(pid))
+    const state = await evaluateDaemon(layout, settings);
+    if (state.kind === "stopped")
         return true;
-    let lease;
-    try {
-        lease = readStateLockRecord(layout.daemonLeaseFile);
-    }
-    catch {
-        log.warn("Refusing to stop sashd: singleton ownership record is corrupt.");
-        return false;
-    }
-    if (lease && (!isProcessAlive(lease.pid) || lease.pid !== pid)) {
-        log.warn(`Refusing to stop PID ${pid}: daemon PID metadata does not match singleton ownership.`);
+    if (state.kind !== "healthy")
         return false;
-    }
-    const client = new SashDaemonClient(record.port || settings.daemonPort, settings.daemonSecret);
-    const legacyOwnership = !lease;
-    const healthMatchesRecord = async () => {
-        try {
-            const health = await client.health();
-            return health.token === record.token && health.pid === pid;
-        }
-        catch {
-            return false;
-        }
-    };
-    if (!(await healthMatchesRecord())) {
-        log.warn(`Refusing to stop unverified sashd PID ${pid}.`);
-        return false;
-    }
-    try {
-        await client.shutdown();
-    }
-    catch {
-    }
+    const client = new SashDaemonClient(state.port, settings.daemonSecret);
+    await client.shutdown();
     const deadline = Date.now() + (opts.timeoutMs ?? 20_000);
-    while (Date.now() < deadline && isProcessAlive(pid)) {
-        await sleep(200);
-    }
-    if (!isProcessAlive(pid))
-        return true;
-    if (legacyOwnership) {
-        log.warn(`Legacy sashd PID ${pid} did not stop gracefully; refusing force termination without a singleton lease.`);
-        return false;
-    }
-    return withStateLock(layout.mutationLockFile, { purpose: "verify forced sashd stop", timeoutMs: 10_000 }, async () => {
-        if (!isProcessAlive(pid))
-            return true;
-        try {
-            const status = await client.status(true);
-            const actual = status.systemProxy.actual;
-            if (status.daemon.pid !== pid ||
-                status.core.running ||
-                status.systemProxy.applied ||
-                !actual ||
-                actual.enabled ||
-                (actual.supported && Boolean(actual.details)) ||
-                fs.existsSync(layout.systemProxyStateFile) ||
-                fs.existsSync(`${layout.systemProxyStateFile}.lock`)) {
-                log.warn(`Refusing to force-terminate sashd PID ${pid}: managed runtime cleanup is incomplete or unknown.`);
-                return false;
-            }
-        }
-        catch {
-            log.warn(`Refusing to force-terminate unresponsive sashd PID ${pid}: runtime cleanup cannot be verified.`);
-            return false;
-        }
-        const verifyDaemonIdentity = async () => {
-            if (!(await healthMatchesRecord()))
-                return "mismatch";
-            return commandLineContains(pid, "daemon-entry") ? "match" : "unknown";
-        };
-        if ((await verifyDaemonIdentity()) !== "match") {
-            log.warn(`Refusing to terminate PID ${pid}: process identity no longer matches sashd. Verify manually.`);
-            return false;
-        }
-        const killed = await killProcessGracefully(pid, {
-            timeoutMs: 4000,
-            verify: verifyDaemonIdentity,
-        });
-        if (killed)
-            return true;
-        log.error(`sashd process is still running after termination attempt (PID=${pid}).`);
-        return false;
-    });
+    while (isProcessAlive(state.pid) && Date.now() < deadline)
+        await sleep(100);
+    return !isProcessAlive(state.pid);
 }

package/dist/github.js

@@ -21,10 +21,11 @@ function ghTokenHeaders() {
     const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
     return token ? { authorization: `Bearer ${token}` } : {};
 }
-export async function resolveLatestTag(repo) {
+export async function resolveLatestTag(repo, signal) {
     const latestUrl = `https://github.com/${repo}/releases/latest`;
     try {
         const res = await fetchWithRetry(latestUrl, {
+            signal,
             manualRedirect: true,
             attempts: 2,
             deadlineMs: 15_000,
@@ -50,6 +51,7 @@ export async function resolveLatestTag(repo) {
     }
     const apiUrl = `https://api.github.com/repos/${repo}/releases/latest`;
     const res = await fetchWithRetry(apiUrl, {
+        signal,
         headers: {
             accept: "application/vnd.github+json",
             ...ghTokenHeaders(),
@@ -74,9 +76,10 @@ export async function resolveLatestTag(repo) {
     }
     return data.tag_name;
 }
-export async function listReleaseAssets(repo, tag) {
+export async function listReleaseAssets(repo, tag, signal) {
     const apiUrl = `https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`;
     const res = await fetchWithRetry(apiUrl, {
+        signal,
         headers: {
             accept: "application/vnd.github+json",
             ...ghTokenHeaders(),
@@ -157,6 +160,7 @@ export async function downloadReleaseAsset(opts) {
     const deadlineAt = Date.now() + deadlineMs;
     let lastError;
     for (const url of urls) {
+        opts.signal?.throwIfAborted();
         const remainingMs = deadlineAt - Date.now();
         if (remainingMs <= 0) {
             lastError = new Error(`Core asset download deadline exceeded after ${deadlineMs}ms`);
@@ -164,6 +168,7 @@ export async function downloadReleaseAsset(opts) {
         }
         try {
             await downloadToFile(url, opts.dest, {
+                signal: opts.signal,
                 allowedHosts: GITHUB_DOWNLOAD_HOSTS,
                 maxBytes: RELEASE_ASSET_SIZE_LIMIT,
                 requireHttps: true,

package/dist/http.js

@@ -87,6 +87,7 @@ export async function fetchWithRetry(url, opts = {}) {
     const bodyInactivityTimeoutMs = positiveTimeout(opts.bodyInactivityTimeoutMs, 30_000, "bodyInactivityTimeoutMs");
     const deadlineMs = positiveTimeout(opts.deadlineMs, 60_000, "deadlineMs");
     const deadline = new AbortController();
+    const signal = opts.signal ? AbortSignal.any([deadline.signal, opts.signal]) : deadline.signal;
     const deadlineTimer = setTimeout(() => {
         deadline.abort(new Error(`HTTP request deadline exceeded after ${deadlineMs}ms`));
     }, deadlineMs);
@@ -108,7 +109,7 @@ export async function fetchWithRetry(url, opts = {}) {
                     body: opts.body,
                     headersTimeout: headersTimeoutMs,
                     bodyTimeout: bodyInactivityTimeoutMs,
-                    signal: deadline.signal,
+                    signal,
                     dispatcher: pickDispatcher(opts),
                 });
                 if (RETRYABLE_STATUS.has(res.statusCode) && attempt < attempts) {
@@ -166,10 +167,10 @@ export async function fetchWithRetry(url, opts = {}) {
             }
             catch (err) {
                 lastErr = err;
-                if (deadline.signal.aborted || attempt === attempts)
+                if (signal.aborted || attempt === attempts)
                     break;
-                await sleep(Math.min(4_000, 300 * 2 ** (attempt - 1)) + Math.random() * 200, deadline.signal);
-                if (deadline.signal.aborted)
+                await sleep(Math.min(4_000, 300 * 2 ** (attempt - 1)) + Math.random() * 200, signal);
+                if (signal.aborted)
                     break;
             }
         }
@@ -202,6 +203,7 @@ export async function downloadToFile(url, dest, opts) {
     const deadlineMs = positiveTimeout(opts.deadlineMs, 15 * 60_000, "deadlineMs");
     const maxRedirects = 5;
     const deadline = new AbortController();
+    const signal = opts.signal ? AbortSignal.any([deadline.signal, opts.signal]) : deadline.signal;
     const deadlineTimer = setTimeout(() => {
         deadline.abort(new Error(`Download deadline exceeded after ${deadlineMs}ms`));
     }, deadlineMs);
@@ -217,7 +219,7 @@ export async function downloadToFile(url, dest, opts) {
                 headers: { "user-agent": USER_AGENT, ...opts.headers },
                 headersTimeout: 30_000,
                 bodyTimeout: stallMs,
-                signal: deadline.signal,
+                signal,
                 dispatcher,
             });
             const isRedirect = res.statusCode >= 300 && res.statusCode < 400 && Boolean(res.headers.location);

package/dist/log-follow.js

@@ -193,7 +193,8 @@ export function followLogFile(file, options) {
             if (watcher || stopped)
                 return;
             try {
-                const watched = fs.watch(path.dirname(file), (_event, filename) => {
+                const directory = fs.realpathSync.native(path.dirname(file));
+                const watched = fs.watch(directory, (_event, filename) => {
                     if (filename === null || filename.toString() === path.basename(file))
                         scheduleDrain();
                 });

package/dist/mihomo-config.js

@@ -1,6 +1,7 @@
 import { isIP } from "node:net";
 import YAML from "yaml";
 import { ERROR_BODY_LIMIT, fetchWithRetry } from "./http.js";
+import { isPlainObject } from "./json-shape.js";
 export function buildDefaultConfig() {
     return {
         mode: "rule",
@@ -226,7 +227,7 @@ export function resolveSubscriptionRedirect(initial, current, location) {
     }
     return target;
 }
-export async function fetchSubscriptionProfile(url) {
+export async function fetchSubscriptionProfile(url, signal) {
     let initial;
     try {
         initial = new URL(url);
@@ -246,6 +247,7 @@ export async function fetchSubscriptionProfile(url) {
             throw new Error(`Subscription fetch deadline exceeded after ${PROFILE_FETCH_DEADLINE_MS}ms`);
         }
         res = await fetchWithRetry(current.href, {
+            signal,
             attempts: 3,
             deadlineMs: remainingDeadlineMs,
             manualRedirect: true,
@@ -312,14 +314,10 @@ export function overlayManagedKeys(base, settings) {
     out["allow-lan"] = settings.allowLan;
     out["external-controller"] = settings.controller;
     out.secret = settings.secret;
-    if (settings.tun) {
-        out.tun = {
-            enable: true,
-            stack: "mixed",
-            "auto-route": true,
-            "auto-detect-interface": true,
-            "dns-hijack": ["any:53"],
-        };
+    out.tun = { enable: false };
+    if (Array.isArray(out.listeners) &&
+        out.listeners.some((listener) => isPlainObject(listener) && listener.type === "tun")) {
+        throw new Error("TUN listeners are unavailable in this release");
     }
     return out;
 }

package/dist/paths.js

@@ -24,27 +24,25 @@ export function sashRoot() {
 }
 export function sashLayout(root = sashRoot()) {
     const exeName = process.platform === "win32" ? "mihomo.exe" : "mihomo";
+    const userControlDir = process.platform === "win32"
+        ? path.join(envPathOr(path.join(os.homedir(), "AppData", "Local"), process.env.LOCALAPPDATA), "Sash")
+        : path.join(root, "state");
     return {
         root,
         binDir: path.join(root, "bin"),
         coreExe: path.join(root, "bin", exeName),
-        configFile: path.join(root, "config.yaml"),
+        configFile: path.join(root, "runtime", "config.yaml"),
         settingsFile: path.join(root, "sash.json"),
         profilesDir: path.join(root, "profiles"),
-        profilesIndexFile: path.join(root, "profiles", "index.json"),
         uiDir: path.join(root, "ui"),
         stateDir: path.join(root, "state"),
         pidFile: path.join(root, "state", "sash.pid"),
         daemonPidFile: path.join(root, "state", "sashd.pid"),
         daemonLeaseFile: path.join(root, "state", "sashd.lock"),
         daemonStartLockFile: path.join(root, "state", "sashd-start.lock"),
-        runtimeOperationLockFile: path.join(root, "state", "runtime.lock"),
-        mutationLockFile: path.join(root, "state", "mutation.lock"),
-        settingsLockFile: path.join(root, "state", "settings.lock"),
         systemProxyStateFile: path.join(root, "state", "system-proxy.json"),
-        managedStateTransactionFile: path.join(root, "state", "managed-state-transaction.json"),
+        systemProxyLockFile: path.join(userControlDir, "system-proxy.lock"),
         installFile: path.join(root, "state", "install.json"),
-        coreInstallTransactionFile: path.join(root, "state", "core-install-transaction.json"),
         coreUpdateTransactionFile: path.join(root, "state", "core-update-transaction.json"),
         logsDir: path.join(root, "logs"),
         coreLogFile: path.join(root, "logs", "mihomo.log"),

package/dist/profile-model.js

@@ -0,0 +1,87 @@
+import { isCanonicalIsoTimestamp, isPlainObject } from "./json-shape.js";
+export const DEFAULT_PROFILE_INTERVAL_HOURS = 24;
+export const MAX_PROFILE_INTERVAL_HOURS = 24 * 365;
+export function parseProfilesIndex(value) {
+    if (!isPlainObject(value) ||
+        Object.keys(value).some((key) => key !== "activeId" && key !== "profiles") ||
+        !Array.isArray(value.profiles) ||
+        (value.activeId !== null && typeof value.activeId !== "string"))
+        throw new Error("Profiles index has an invalid shape");
+    const profiles = value.profiles.map(parseProfileMeta);
+    const ids = new Set(profiles.map((profile) => profile.id));
+    if (ids.size !== profiles.length)
+        throw new Error("Profiles index has duplicate profile ids");
+    if (value.activeId !== null && !ids.has(value.activeId))
+        throw new Error("Selected profile is missing");
+    return { activeId: value.activeId, profiles };
+}
+export function parseProfileMeta(item) {
+    if (!isPlainObject(item) ||
+        typeof item.id !== "string" ||
+        !/^[0-9]+$/.test(item.id) ||
+        typeof item.revision !== "number" ||
+        !Number.isSafeInteger(item.revision) ||
+        item.revision < 1 ||
+        typeof item.name !== "string" ||
+        !item.name.trim() ||
+        item.name.length > 120 ||
+        typeof item.url !== "string" ||
+        typeof item.intervalHours !== "number" ||
+        !Number.isSafeInteger(item.intervalHours) ||
+        item.intervalHours < 0 ||
+        item.intervalHours > MAX_PROFILE_INTERVAL_HOURS ||
+        !isCanonicalIsoTimestamp(item.createdAt) ||
+        !isCanonicalIsoTimestamp(item.updatedAt))
+        throw new Error("Profiles index has invalid profile metadata");
+    if (item.url) {
+        const url = new URL(item.url);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            throw new Error("Invalid profile URL");
+    }
+    let subInfo;
+    if (item.subInfo !== undefined) {
+        const info = item.subInfo;
+        if (!isPlainObject(info) ||
+            typeof info.upload !== "number" ||
+            !Number.isFinite(info.upload) ||
+            info.upload < 0 ||
+            typeof info.download !== "number" ||
+            !Number.isFinite(info.download) ||
+            info.download < 0 ||
+            typeof info.total !== "number" ||
+            !Number.isFinite(info.total) ||
+            info.total < 0 ||
+            (info.expire !== undefined &&
+                (typeof info.expire !== "number" || !Number.isFinite(info.expire) || info.expire < 0)))
+            throw new Error("Invalid subscription quota");
+        subInfo = {
+            upload: info.upload,
+            download: info.download,
+            total: info.total,
+            ...(typeof info.expire === "number" ? { expire: info.expire } : {}),
+        };
+    }
+    if (item.homePage !== undefined) {
+        if (typeof item.homePage !== "string")
+            throw new Error("Invalid profile home page");
+        const url = new URL(item.homePage);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            throw new Error("Invalid profile home page");
+    }
+    if (item.lastError !== undefined &&
+        (typeof item.lastError !== "string" || item.lastError.length > 300)) {
+        throw new Error("Invalid profile update error");
+    }
+    return {
+        id: item.id,
+        revision: item.revision,
+        name: item.name,
+        url: item.url,
+        intervalHours: item.intervalHours,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        ...(subInfo ? { subInfo } : {}),
+        ...(typeof item.homePage === "string" ? { homePage: item.homePage } : {}),
+        ...(typeof item.lastError === "string" ? { lastError: item.lastError } : {}),
+    };
+}