@astralyn/sash 0.1.1 → 0.1.2

package/dist/daemon/handlers/daemon.js

@@ -21,9 +21,10 @@ export async function redeemWebBootstrap(ctx, req) {
 }
 export async function daemonStatus(ctx, req) {
     const settings = ctx.settings.committed();
+    const ownership = ctx.supervisor.ownedCoreSnapshot();
     const runtimeCore = await ctx.supervisor.status();
     const installedVersion = currentCoreVersion(ctx.layout);
-    const core = runtimeCore.version || !installedVersion
+    let core = runtimeCore.version || !installedVersion
         ? runtimeCore
         : { ...runtimeCore, version: installedVersion };
     let actualProxy;
@@ -36,22 +37,33 @@ export async function daemonStatus(ctx, req) {
         proxyApplied = inspection.applied;
         proxyAppliedKnown = inspection.appliedKnown;
         proxyStateKnown = inspection.stateKnown;
-        if (proxyStateKnown)
-            actualProxy = inspection.state;
+        actualProxy = inspection.state;
         proxyQueryError = inspection.queryError;
     }
     catch (err) {
         proxyQueryError = err instanceof Error ? err.message : String(err);
     }
     const active = ctx.profiles.active();
+    if (core.running && (!ownership || !ctx.supervisor.ownsCore(ownership)))
+        core = { running: false };
+    const applied = ctx.lifecycle.configuration();
     const status = {
         daemon: {
             pid: process.pid,
+            bootId: ctx.token,
             startedAt: ctx.startedAt,
             port: settings.daemonPort,
         },
         revisions: {
             profiles: ctx.profileRevision(),
+            runtime: ctx.lifecycle.revision,
+        },
+        configuration: {
+            pending: ctx.pendingApply(),
+            appliedProfile: applied?.profile ?? null,
+            appliedSettings: applied
+                ? { mixedPort: applied.settings.mixedPort, allowLan: applied.settings.allowLan }
+                : null,
         },
         core,
         systemProxy: {
@@ -68,9 +80,8 @@ export async function daemonStatus(ctx, req) {
     return { status: 200, json: status };
 }
 export function shutdownDaemon(ctx) {
-    return ctx.shutdown().then((snapshot) => ({
-        status: 200,
-        json: { coreWasRunning: snapshot.coreWasRunning },
+    return ctx.shutdown().then(() => ({
+        status: 204,
         after: () => {
             void ctx
                 .closeListener()

package/dist/daemon/handlers/profiles.js

@@ -1,8 +1,15 @@
+import { requiredParam } from "../../daemon-http.js";
 import { ProfileInputError } from "../../profile-service.js";
-import { requiredParam } from "../router.js";
 export function listProfiles(ctx) {
     return { status: 200, json: ctx.profiles.list() };
 }
+export async function reorderProfiles(ctx, req) {
+    const { ids } = await req.readJson();
+    if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string")) {
+        throw new ProfileInputError("Missing profile ids array");
+    }
+    return { status: 200, json: await ctx.profiles.reorder(ids) };
+}
 export async function addProfile(ctx, req) {
     const body = await req.readJson();
     const url = typeof body.url === "string" ? body.url.trim() : "";
@@ -42,7 +49,10 @@ export function readProfileContent(ctx, req) {
 export async function writeProfileContent(ctx, req) {
     const body = await req.readJson(8 * 1024 * 1024);
     const content = typeof body.content === "string" ? body.content : "";
-    const result = await ctx.profiles.writeContent(requiredParam(req, "id"), content);
+    const revision = body.revision;
+    if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 1)
+        throw new ProfileInputError("A positive profile revision is required");
+    const result = await ctx.profiles.writeContent(requiredParam(req, "id"), content, revision);
     return { status: 200, json: result };
 }
 export async function renameProfile(ctx, req) {

package/dist/daemon/handlers/settings.js

@@ -1,13 +1,6 @@
-import fs from "node:fs";
-import { parseSettingsPatch, } from "../../contracts.js";
+import { parseSettingsPatch } from "../../contracts.js";
 import { HttpError } from "../../daemon-http.js";
-import { parseSettingsText, publicSettings } from "../../settings.js";
-function writeResultBody(result) {
-    return {
-        restartRequired: result.restartRequired,
-        settings: publicSettings(result.settings),
-    };
-}
+import { publicSettings } from "../../settings.js";
 export function readSettings(ctx) {
     return { status: 200, json: publicSettings(ctx.settings.committed()) };
 }
@@ -15,34 +8,14 @@ export async function patchSettings(ctx, req) {
     const body = await req.readJson();
     let patch;
     try {
-        patch = parseSettingsPatch(body, "request");
+        patch = parseSettingsPatch(body);
     }
-    catch (err) {
-        throw new HttpError(400, err.message);
+    catch (error) {
+        throw new HttpError(400, error instanceof Error ? error.message : String(error));
     }
     const result = await ctx.settingsService.apply(patch);
-    return { status: 200, json: writeResultBody(result) };
-}
-export function readSettingsFile(ctx) {
-    let content;
-    try {
-        content = fs.readFileSync(ctx.layout.settingsFile, "utf8");
-    }
-    catch {
-        throw new HttpError(404, "Settings file does not exist yet");
-    }
-    return { status: 200, json: { content } };
-}
-export async function writeSettingsFile(ctx, req) {
-    const body = await req.readJson(256 * 1024);
-    const content = typeof body.content === "string" ? body.content : "";
-    let parsed;
-    try {
-        parsed = parseSettingsText(content, ctx.layout.settingsFile);
-    }
-    catch (err) {
-        throw new HttpError(400, err.message);
-    }
-    const result = await ctx.settingsService.applyFileSettings(parsed);
-    return { status: 200, json: writeResultBody(result) };
+    return {
+        status: 200,
+        json: { restartRequired: result.restartRequired, settings: publicSettings(result.settings) },
+    };
 }

package/dist/daemon/router.js

@@ -3,11 +3,12 @@ import { parseJsonObjectBody, sendError, sendJson } from "../daemon-http.js";
 import { forwardHttpToCore } from "../daemon-proxy.js";
 import { serveStaticUi } from "../daemon-static.js";
 import { errorToHttp } from "./errors.js";
-import { reloadCoreConfig, restartCore, startCore, stopCore } from "./handlers/core.js";
+import { readAutostart, writeAutostart } from "./handlers/autostart.js";
+import { restartCore, setCoreMode, startCore, stopCore, updateCore } from "./handlers/core.js";
 import { createWebBootstrap, daemonStatus, health, redeemWebBootstrap, shutdownDaemon, } from "./handlers/daemon.js";
-import { activateProfile, addProfile, importProfile, listProfiles, readProfileContent, removeProfile, renameProfile, updateAllProfiles, updateProfile, writeProfileContent, } from "./handlers/profiles.js";
+import { activateProfile, addProfile, importProfile, listProfiles, readProfileContent, removeProfile, renameProfile, reorderProfiles, updateAllProfiles, updateProfile, writeProfileContent, } from "./handlers/profiles.js";
 import { proxyStatus } from "./handlers/proxy.js";
-import { patchSettings, readSettings, readSettingsFile, writeSettingsFile, } from "./handlers/settings.js";
+import { patchSettings, readSettings } from "./handlers/settings.js";
 export function parseDaemonRequestTarget(rawTarget, hostHeader) {
     if (!rawTarget.startsWith("/") || rawTarget.startsWith("//")) {
         throw new Error("Unsupported HTTP request-target form");
@@ -62,6 +63,7 @@ export function buildRoutes() {
             handler: redeemWebBootstrap,
         },
         { methods: ["POST"], pattern: path("/sash/core/start"), auth: "control", handler: startCore },
+        { methods: ["PUT"], pattern: path("/sash/core/mode"), auth: "control", handler: setCoreMode },
         { methods: ["POST"], pattern: path("/sash/core/stop"), auth: "control", handler: stopCore },
         {
             methods: ["POST"],
@@ -71,11 +73,18 @@ export function buildRoutes() {
         },
         {
             methods: ["POST"],
-            pattern: path("/sash/core/reload"),
+            pattern: path("/sash/core/update"),
             auth: "control",
-            handler: reloadCoreConfig,
+            handler: updateCore,
         },
         { methods: ["GET"], pattern: path("/sash/proxy"), auth: "public", handler: proxyStatus },
+        { methods: ["GET"], pattern: path("/sash/autostart"), auth: "control", handler: readAutostart },
+        {
+            methods: ["PUT"],
+            pattern: path("/sash/autostart"),
+            auth: "control",
+            handler: writeAutostart,
+        },
         { methods: ["GET"], pattern: path("/sash/settings"), auth: "public", handler: readSettings },
         {
             methods: ["PATCH"],
@@ -83,20 +92,14 @@ export function buildRoutes() {
             auth: "control",
             handler: patchSettings,
         },
-        {
-            methods: ["GET"],
-            pattern: path("/sash/settings/file"),
-            auth: "control",
-            handler: readSettingsFile,
-        },
+        { methods: ["GET"], pattern: path("/sash/profiles"), auth: "public", handler: listProfiles },
+        { methods: ["POST"], pattern: path("/sash/profiles"), auth: "control", handler: addProfile },
         {
             methods: ["PUT"],
-            pattern: path("/sash/settings/file"),
+            pattern: path("/sash/profiles/order"),
             auth: "control",
-            handler: writeSettingsFile,
+            handler: reorderProfiles,
         },
-        { methods: ["GET"], pattern: path("/sash/profiles"), auth: "public", handler: listProfiles },
-        { methods: ["POST"], pattern: path("/sash/profiles"), auth: "control", handler: addProfile },
         {
             methods: ["POST"],
             pattern: path("/sash/profiles/import"),
@@ -166,6 +169,14 @@ export function buildRoutes() {
     ];
 }
 function forwardToCore(ctx, req, res, target) {
+    const method = req.method?.toUpperCase() ?? "GET";
+    const pathname = coreApiTarget(target).split("?")[0] ?? "/";
+    const allowedMutation = (method === "PUT" && /^\/proxies\/[^/]+$/.test(pathname)) ||
+        (method === "DELETE" && /^\/connections(?:\/[^/]+)?$/.test(pathname));
+    if (isControlMutation(method) && !allowedMutation) {
+        sendError(res, 403, "conflict", "Use Sash controls to change managed Core configuration");
+        return;
+    }
     const runtime = ctx.settings.runtime();
     forwardHttpToCore(req, res, coreApiTarget(target), runtime.controller, runtime.secret);
 }
@@ -187,12 +198,6 @@ function methodOrder(method) {
     const index = METHOD_ORDER.indexOf(method);
     return index < 0 ? METHOD_ORDER.length : index;
 }
-export function requiredParam(req, name) {
-    const value = req.params[name];
-    if (value === undefined)
-        throw new Error(`Missing route parameter: ${name}`);
-    return value;
-}
 function writeResponse(res, response) {
     if (response.after) {
         const after = response.after;

package/dist/daemon/scheduler.js

@@ -1,4 +1,4 @@
-export function startProfileUpdateScheduler(profiles, scheduler = {}) {
+export function startProfileUpdateScheduler(profiles, scheduler = {}, isActive) {
     const intervalMs = scheduler.intervalMs ?? 15 * 60 * 1000;
     const kickoffMs = scheduler.kickoffMs ?? 10_000;
     const scheduleInterval = scheduler.setInterval ?? setInterval;
@@ -6,6 +6,8 @@ export function startProfileUpdateScheduler(profiles, scheduler = {}) {
     const scheduleTimeout = scheduler.setTimeout ?? setTimeout;
     const clearScheduledTimeout = scheduler.clearTimeout ?? clearTimeout;
     const autoUpdateProfiles = async () => {
+        if (!isActive())
+            return;
         try {
             await profiles.updateDue();
         }

package/dist/daemon/server.js

@@ -79,7 +79,10 @@ export function createDaemonServer(deps) {
                 rejectUpgrade(socket, 500, "WebSocket proxy failed");
         }
     });
-    const scheduler = startProfileUpdateScheduler(context.profiles, deps.scheduler ?? {});
+    let scheduler;
+    server.once("listening", () => {
+        scheduler = startProfileUpdateScheduler(context.profiles, deps.scheduler ?? {}, () => !context.gate.isClosing);
+    });
     let listenerClosePromise;
     const closeListener = () => {
         if (listenerClosePromise)
@@ -94,7 +97,7 @@ export function createDaemonServer(deps) {
                     socket.destroy();
                 await closed;
             }
-            scheduler.stop();
+            scheduler?.stop();
         })();
         listenerClosePromise = attempt;
         void attempt.catch(() => {

package/dist/daemon-client.js

@@ -8,6 +8,7 @@ const daemonFetch = async (url, init) => {
         ...(init.body !== undefined ? { body: init.body } : {}),
         direct: true,
         deadlineMs: init.timeoutMs,
+        headersTimeoutMs: init.timeoutMs,
         ...(init.attempts !== undefined ? { attempts: init.attempts } : {}),
     });
     return {
@@ -46,15 +47,24 @@ export class SashDaemonClient {
     status(fresh = false) {
         return this.client.status(fresh);
     }
+    autostartStatus() {
+        return this.client.autostartStatus();
+    }
+    setAutostart(enabled) {
+        return this.client.setAutostart(enabled);
+    }
     startCore() {
         return this.client.startCore();
     }
+    restartCore() {
+        return this.client.restartCore();
+    }
+    updateCore(version) {
+        return this.client.updateCore(version);
+    }
     patchSettings(patch) {
         return this.client.patchSettings(patch);
     }
-    maintenanceShutdown() {
-        return this.client.shutdown();
-    }
     async shutdown() {
         await this.client.shutdown();
     }

package/dist/daemon-http.js

@@ -9,6 +9,12 @@ export class HttpError extends Error {
         this.name = "HttpError";
     }
 }
+export function requiredParam(req, name) {
+    const value = req.params[name];
+    if (value === undefined)
+        throw new Error(`Missing route parameter: ${name}`);
+    return value;
+}
 export function parseJsonBody(req, maxBytes = 1024 * 1024) {
     return new Promise((resolve, reject) => {
         const chunks = [];

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,