@astralyn/sash 0.1.0

package/dist/core-version.js

@@ -0,0 +1,18 @@
+const CORE_VERSION_TOKEN_CHARACTER = /^[A-Za-z0-9._-]$/;
+function isCoreVersionTokenCharacter(value) {
+    return value !== undefined && CORE_VERSION_TOKEN_CHARACTER.test(value);
+}
+export function containsCoreVersionToken(observed, expected) {
+    if (expected.length === 0)
+        return false;
+    let index = observed.indexOf(expected);
+    while (index >= 0) {
+        const end = index + expected.length;
+        if (!isCoreVersionTokenCharacter(index === 0 ? undefined : observed[index - 1]) &&
+            !isCoreVersionTokenCharacter(end === observed.length ? undefined : observed[end])) {
+            return true;
+        }
+        index = observed.indexOf(expected, index + 1);
+    }
+    return false;
+}

package/dist/core.js

@@ -0,0 +1,206 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import zlib from "node:zlib";
+import AdmZip from "adm-zip";
+import { currentCoreVersion, readInstallRecord, validateCoreReleaseTag, writeInstallRecord, } from "./core-install-record.js";
+import { beginCoreInstallTransaction, clearCoreInstallTransaction, markCoreInstallTransactionCommitted, recoverCoreInstallTransaction, } from "./core-install-transaction.js";
+import { containsCoreVersionToken } from "./core-version.js";
+import { durableRenameSync, pathEntryExists } from "./fs-atomic.js";
+import { downloadReleaseAsset, listReleaseAssets, MIHOMO_REPO, RELEASE_ASSET_SIZE_LIMIT, resolveLatestTag, } from "./github.js";
+import { sashLayout } from "./paths.js";
+import { buildSanitizedEnv, recoverBinaryUnlockProbe } from "./process.js";
+export function goOsArch(platform = process.platform, arch = process.arch) {
+    const osMap = { win32: "windows", darwin: "darwin", linux: "linux" };
+    const archMap = { x64: "amd64", arm64: "arm64" };
+    const goOs = osMap[platform];
+    const goArch = archMap[arch];
+    if (!goOs || !goArch) {
+        throw new Error(`Unsupported platform: ${platform}/${arch} (supported: win32/darwin/linux × x64/arm64)`);
+    }
+    return { os: goOs, arch: goArch };
+}
+export function mihomoAssetCandidates(tag, platform = process.platform, arch = process.arch) {
+    const { os, arch: goArch } = goOsArch(platform, arch);
+    const ext = platform === "win32" ? "zip" : "gz";
+    if (goArch === "amd64") {
+        return [
+            `mihomo-${os}-amd64-compatible-${tag}.${ext}`,
+            `mihomo-${os}-amd64-v1-${tag}.${ext}`,
+            `mihomo-${os}-amd64-${tag}.${ext}`,
+        ];
+    }
+    return [`mihomo-${os}-arm64-${tag}.${ext}`];
+}
+const EXTRACT_SIZE_LIMIT = 512 * 1024 * 1024;
+function createCoreExtractionLimiter() {
+    let bytes = 0;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            bytes += chunk.length;
+            if (bytes > EXTRACT_SIZE_LIMIT) {
+                callback(new Error("Extracted binary exceeds 512MB safety limit"));
+                return;
+            }
+            callback(null, chunk);
+        },
+    });
+}
+export async function extractCoreArchive(archivePath, assetName, destExe) {
+    const extracted = `${destExe}.extracted`;
+    try {
+        if (assetName.endsWith(".zip")) {
+            if (fs.statSync(archivePath).size > RELEASE_ASSET_SIZE_LIMIT) {
+                throw new Error("Core archive exceeds the download safety limit");
+            }
+            const zip = new AdmZip(archivePath);
+            const entry = zip
+                .getEntries()
+                .find((candidate) => !candidate.isDirectory && /^mihomo.*\.exe$/i.test(path.basename(candidate.entryName)));
+            if (!entry)
+                throw new Error(`No mihomo*.exe found inside ${assetName}`);
+            if (entry.header.size > EXTRACT_SIZE_LIMIT) {
+                throw new Error("Extracted binary exceeds 512MB safety limit");
+            }
+            const header = entry.header;
+            if (header.encrypted) {
+                throw new Error("Encrypted Core archives are not supported");
+            }
+            if (header.method !== 0 && header.method !== 8) {
+                throw new Error(`Unsupported ZIP compression method: ${header.method}`);
+            }
+            const compressed = entry.getCompressedData();
+            const output = fs.createWriteStream(extracted, { mode: 0o755 });
+            if (header.method === 0) {
+                await pipeline(Readable.from([compressed]), createCoreExtractionLimiter(), output);
+            }
+            else {
+                await pipeline(Readable.from([compressed]), zlib.createInflateRaw(), createCoreExtractionLimiter(), output);
+            }
+        }
+        else if (assetName.endsWith(".gz")) {
+            await pipeline(fs.createReadStream(archivePath), zlib.createGunzip(), createCoreExtractionLimiter(), fs.createWriteStream(extracted, { mode: 0o755 }));
+        }
+        else {
+            throw new Error(`Unsupported archive type: ${assetName}`);
+        }
+        fs.renameSync(extracted, destExe);
+    }
+    catch (err) {
+        fs.rmSync(extracted, { force: true });
+        throw err;
+    }
+}
+export { currentCoreVersion, readInstallRecord, validateCoreReleaseTag, writeInstallRecord };
+export function verifyCoreExecutable(exe, timeoutMs = 5000, expectedVersion) {
+    try {
+        const output = execFileSync(exe, ["-v"], {
+            encoding: "utf8",
+            env: buildSanitizedEnv(),
+            timeout: timeoutMs,
+            windowsHide: true,
+        });
+        if (expectedVersion && !containsCoreVersionToken(output, expectedVersion)) {
+            throw new Error(`version output does not contain expected release ${expectedVersion}: ${output.trim()}`);
+        }
+    }
+    catch (err) {
+        throw new Error(`Downloaded core binary failed validation: ${err.message}`);
+    }
+}
+export async function stageCore(opts = {}) {
+    const layout = opts.layout ?? sashLayout();
+    const tag = validateCoreReleaseTag(opts.tag ?? (await resolveLatestTag(MIHOMO_REPO)));
+    const assets = await listReleaseAssets(MIHOMO_REPO, tag);
+    const candidates = mihomoAssetCandidates(tag);
+    fs.mkdirSync(layout.tempDir, { recursive: true });
+    fs.mkdirSync(layout.binDir, { recursive: true });
+    const archivePath = path.join(layout.tempDir, `mihomo-${tag}-${process.pid}.download`);
+    const stagedExe = `${layout.coreExe}.${process.pid}.new`;
+    try {
+        const assetName = await downloadReleaseAsset({
+            repo: MIHOMO_REPO,
+            tag,
+            assets,
+            candidates,
+            dest: archivePath,
+            onProgress: opts.onProgress,
+        });
+        await extractCoreArchive(archivePath, assetName, stagedExe);
+        fs.chmodSync(stagedExe, 0o755);
+        verifyCoreExecutable(stagedExe, 5000, tag);
+        return { version: tag, exe: stagedExe };
+    }
+    catch (err) {
+        fs.rmSync(stagedExe, { force: true });
+        throw err;
+    }
+    finally {
+        fs.rmSync(archivePath, { force: true });
+    }
+}
+export async function installCore(opts = {}) {
+    const layout = opts.layout ?? sashLayout();
+    recoverCoreInstallTransaction(layout);
+    assertCoreInstallationConsistent(layout);
+    if (coreInstalled(layout)) {
+        throw new Error(`Core executable already exists at ${layout.coreExe}; use the update flow`);
+    }
+    const staged = await stageCore({ ...opts, layout });
+    let transactionStarted = false;
+    let committed = false;
+    try {
+        const transaction = beginCoreInstallTransaction(staged.version, layout);
+        transactionStarted = true;
+        durableRenameSync(staged.exe, layout.coreExe);
+        writeInstallRecord({ coreVersion: staged.version, installedAt: transaction.createdAt }, layout);
+        markCoreInstallTransactionCommitted(transaction, layout);
+        committed = true;
+        clearCoreInstallTransaction(layout);
+        return { version: staged.version, exe: layout.coreExe };
+    }
+    catch (err) {
+        if (transactionStarted && !committed) {
+            try {
+                recoverCoreInstallTransaction(layout);
+            }
+            catch (recoveryErr) {
+                throw new Error(`${err.message}; Core install recovery also failed: ${recoveryErr.message}`);
+            }
+        }
+        throw err;
+    }
+    finally {
+        fs.rmSync(staged.exe, { force: true });
+    }
+}
+function isRegularFile(file) {
+    try {
+        return fs.lstatSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function coreInstalled(layout = sashLayout()) {
+    return isRegularFile(layout.coreExe) && readInstallRecord(layout) !== undefined;
+}
+export function assertCoreInstallationConsistent(layout = sashLayout()) {
+    recoverBinaryUnlockProbe(layout.coreExe);
+    const binaryExists = pathEntryExists(layout.coreExe);
+    const installRecordExists = pathEntryExists(layout.installFile);
+    const binaryValid = isRegularFile(layout.coreExe);
+    const record = readInstallRecord(layout);
+    if ((!binaryExists && !installRecordExists) || (binaryValid && record))
+        return;
+    const reason = binaryExists
+        ? record
+            ? "the Core executable is not a regular file"
+            : "the Core executable exists without valid install metadata"
+        : record
+            ? "Core install metadata exists but the executable is missing"
+            : "Core install metadata is malformed without an executable";
+    throw new Error(`Core installation is incomplete or invalid: ${reason}. Run \`sash update --force\` to repair it.`);
+}

package/dist/daemon/app.js

@@ -0,0 +1,157 @@
+import crypto from "node:crypto";
+import { MihomoApi } from "../api.js";
+import { currentCoreVersion } from "../core.js";
+import { validateCoreConfigText } from "../core-config-validation.js";
+import { pendingCoreUpdateVersion, readCoreUpdateTransaction } from "../core-update.js";
+import { completeCoordinatedCoreUpdateAfterStart, rollbackCoordinatedCoreUpdate, } from "../core-update-coordination.js";
+import { ProfileConflictError, ProfileService, } from "../profile-service.js";
+import { RuntimeLifecycle } from "../runtime-lifecycle.js";
+import { saveSettings } from "../settings.js";
+import { SettingsService } from "../settings-service.js";
+import { StateMutationQueue } from "../state-lock.js";
+import { CoreSupervisor } from "../supervisor.js";
+import { SystemProxyManager } from "../system-proxy-manager.js";
+import { DaemonGate } from "./context.js";
+export function buildDaemonContext(deps) {
+    const layout = deps.layout;
+    let committedSettings = saveSettings({ ...deps.settings }, layout);
+    let runtimeSettings = committedSettings;
+    const token = deps.token ?? crypto.randomBytes(24).toString("hex");
+    const startedAt = new Date().toISOString();
+    const systemProxy = deps.systemProxy ?? new SystemProxyManager({ layout });
+    const mutations = new StateMutationQueue(layout.mutationLockFile);
+    let profileRevision = 0;
+    let lifecycle;
+    const supervisor = deps.supervisor ??
+        new CoreSupervisor({
+            layout,
+            settings: () => runtimeSettings,
+            expectedVersion: () => pendingCoreUpdateVersion(layout) || currentCoreVersion(layout) || undefined,
+            onExit: async () => {
+                try {
+                    await lifecycle?.handleUnexpectedCoreExit();
+                }
+                catch (err) {
+                    console.error(`[sashd] failed to restore system proxy after Core exit: ${err.message}`);
+                }
+            },
+        });
+    lifecycle = new RuntimeLifecycle({
+        supervisor,
+        systemProxy,
+        settings: () => runtimeSettings,
+        coreUpdate: {
+            pending: () => readCoreUpdateTransaction(layout) !== undefined,
+            completeAfterStart: () => {
+                completeCoordinatedCoreUpdateAfterStart(layout);
+            },
+            rollbackAfterStartFailure: () => rollbackCoordinatedCoreUpdate(layout),
+        },
+    });
+    const gate = new DaemonGate(mutations, async () => {
+        const coreWasRunning = supervisor.isRunning();
+        await lifecycle.close();
+        return { coreWasRunning };
+    });
+    const mutate = (purpose, action) => gate.mutate(purpose, action);
+    const profiles = new ProfileService({
+        layout,
+        settings: () => committedSettings,
+        ...(deps.fetchProfileFn ? { fetchProfile: deps.fetchProfileFn } : {}),
+        validateConfig: deps.validateConfigFn ?? ((generated) => validateCoreConfigText(generated.yaml, layout)),
+        reloadConfig: async (configPath) => {
+            if (!supervisor.isRunning())
+                return;
+            const api = new MihomoApi(runtimeSettings.controller, runtimeSettings.secret);
+            await api.reloadConfig(configPath);
+        },
+        commit: mutate,
+        onChange: () => {
+            profileRevision += 1;
+        },
+    });
+    const settingsService = new SettingsService({
+        layout,
+        getCommitted: () => committedSettings,
+        setCommitted: (next) => {
+            committedSettings = { ...next };
+        },
+        setRuntime: (next) => {
+            runtimeSettings = { ...next };
+        },
+        profiles,
+        supervisor,
+        lifecycle,
+        commit: mutate,
+    });
+    const commitPreparedReload = (prepared, reloadRuntime) => profiles.commitPreparedActiveReload(prepared, {
+        reloadRuntime,
+        boundary: "already-held",
+    });
+    const startCore = async () => {
+        const retryAfterPreparation = Symbol("retry Core start after preparation");
+        for (;;) {
+            let prepared;
+            if (!supervisor.isRunning()) {
+                try {
+                    prepared = await profiles.prepareActiveReload();
+                }
+                catch (err) {
+                    if (supervisor.isRunning())
+                        continue;
+                    throw err;
+                }
+            }
+            const preparedForStart = prepared;
+            const result = await mutate("start core", async () => {
+                if (!preparedForStart && !supervisor.isRunning())
+                    return retryAfterPreparation;
+                return lifecycle.start(preparedForStart
+                    ? async () => {
+                        await commitPreparedReload(preparedForStart, false);
+                    }
+                    : undefined);
+            });
+            if (result !== retryAfterPreparation)
+                return result;
+        }
+    };
+    const withPreparedReloadRetry = async (purpose, action) => {
+        for (let attempt = 0;; attempt += 1) {
+            const prepared = await profiles.prepareActiveReload();
+            try {
+                return await mutate(purpose, () => action(prepared));
+            }
+            catch (err) {
+                if (!(err instanceof ProfileConflictError) || attempt >= 1)
+                    throw err;
+            }
+        }
+    };
+    const context = {
+        layout,
+        token,
+        startedAt,
+        profiles,
+        settingsService,
+        lifecycle,
+        supervisor,
+        systemProxy,
+        gate,
+        settings: {
+            committed: () => committedSettings,
+            runtime: () => runtimeSettings,
+        },
+        mutate,
+        profileRevision: () => profileRevision,
+        startCore,
+        restartCore: () => withPreparedReloadRetry("restart core", (prepared) => lifecycle.restart(async () => {
+            await commitPreparedReload(prepared, false);
+        })),
+        reloadCoreConfig: () => withPreparedReloadRetry("reload core config", (prepared) => commitPreparedReload(prepared, true)),
+        shutdown: () => gate.shutdown(),
+        closeListener: () => Promise.reject(new Error("listener close is not wired yet")),
+        ...(deps.onShutdown ? { onShutdown: deps.onShutdown } : {}),
+    };
+    return { context, supervisor, lifecycle, token };
+}

package/dist/daemon/context.js

@@ -0,0 +1,40 @@
+import { ShuttingDownError } from "./errors.js";
+export class DaemonGate {
+    queue;
+    cleanup;
+    closing = false;
+    cleanupPromise;
+    constructor(queue, cleanup) {
+        this.queue = queue;
+        this.cleanup = cleanup;
+    }
+    get isClosing() {
+        return this.closing;
+    }
+    async mutate(purpose, action) {
+        if (this.closing)
+            throw new ShuttingDownError();
+        return this.queue.run(purpose, () => {
+            if (this.closing)
+                throw new ShuttingDownError();
+            return action();
+        });
+    }
+    shutdown() {
+        if (this.cleanupPromise)
+            return this.cleanupPromise;
+        this.closing = true;
+        const attempt = this.queue.run("close daemon", this.cleanup);
+        this.cleanupPromise = attempt;
+        void attempt.catch(() => {
+            if (this.cleanupPromise === attempt) {
+                this.cleanupPromise = undefined;
+                this.closing = false;
+            }
+        });
+        return attempt;
+    }
+    reopen() {
+        this.closing = false;
+    }
+}

package/dist/daemon/entry.js

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

package/dist/daemon/errors.js

@@ -0,0 +1,47 @@
+import { HttpError } from "../daemon-http.js";
+import { ProfileConflictError, ProfileInputError, ProfileNotFoundError, } from "../profile-service.js";
+import { CoreUnhealthyError, SettingsInputError } from "../settings-service.js";
+export class ShuttingDownError extends Error {
+    constructor(message = "sashd is shutting down") {
+        super(message);
+        this.name = "ShuttingDownError";
+    }
+}
+function defaultCodeForStatus(status) {
+    if (status === 400 || status === 413)
+        return "invalid_input";
+    if (status === 401 || status === 403)
+        return "unauthorized";
+    if (status === 404)
+        return "not_found";
+    if (status === 409)
+        return "conflict";
+    if (status === 503)
+        return "shutting_down";
+    if (status >= 500)
+        return "internal";
+    return "http";
+}
+export function errorToHttp(err) {
+    if (err instanceof HttpError) {
+        return {
+            status: err.statusCode,
+            code: err.code ?? defaultCodeForStatus(err.statusCode),
+            message: err.message,
+        };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof ProfileNotFoundError)
+        return { status: 404, code: "not_found", message };
+    if (err instanceof ProfileInputError)
+        return { status: 400, code: "invalid_input", message };
+    if (err instanceof SettingsInputError)
+        return { status: 400, code: "invalid_input", message };
+    if (err instanceof ProfileConflictError)
+        return { status: 409, code: "conflict", message };
+    if (err instanceof CoreUnhealthyError)
+        return { status: 409, code: "core_unhealthy", message };
+    if (err instanceof ShuttingDownError)
+        return { status: 503, code: "shutting_down", message };
+    return { status: 500, code: "internal", message };
+}

package/dist/daemon/handlers/core.js

@@ -0,0 +1,17 @@
+export async function startCore(ctx) {
+    const result = await ctx.startCore();
+    return { status: 200, json: result };
+}
+export async function stopCore(ctx) {
+    await ctx.mutate("stop core", () => ctx.lifecycle.stop());
+    return { status: 204 };
+}
+export async function restartCore(ctx) {
+    const result = await ctx.restartCore();
+    return { status: 200, json: result };
+}
+export async function reloadCoreConfig(ctx) {
+    const result = await ctx.reloadCoreConfig();
+    const body = { proxyCount: result.proxyCount, source: result.source };
+    return { status: 200, json: body };
+}

package/dist/daemon/handlers/daemon.js

@@ -0,0 +1,66 @@
+import { currentCoreVersion } from "../../core.js";
+import { publicSettings } from "../../settings.js";
+export function health(ctx) {
+    const body = { token: ctx.token, pid: process.pid, startedAt: ctx.startedAt };
+    return { status: 200, json: body };
+}
+export async function daemonStatus(ctx, req) {
+    const settings = ctx.settings.committed();
+    const runtimeCore = await ctx.supervisor.status();
+    const installedVersion = currentCoreVersion(ctx.layout);
+    const core = runtimeCore.version || !installedVersion
+        ? runtimeCore
+        : { ...runtimeCore, version: installedVersion };
+    let actualProxy;
+    let proxyApplied = false;
+    let proxyAppliedKnown = false;
+    let proxyStateKnown = false;
+    let proxyQueryError;
+    try {
+        const inspection = await ctx.systemProxy.inspect(req.searchParams.get("fresh") === "1");
+        proxyApplied = inspection.applied;
+        proxyAppliedKnown = inspection.appliedKnown;
+        proxyStateKnown = inspection.stateKnown;
+        if (proxyStateKnown)
+            actualProxy = inspection.state;
+        proxyQueryError = inspection.queryError;
+    }
+    catch (err) {
+        proxyQueryError = err instanceof Error ? err.message : String(err);
+    }
+    const active = ctx.profiles.active();
+    const status = {
+        daemon: {
+            pid: process.pid,
+            startedAt: ctx.startedAt,
+            port: settings.daemonPort,
+        },
+        revisions: {
+            profiles: ctx.profileRevision(),
+        },
+        core,
+        systemProxy: {
+            desired: settings.systemProxy,
+            applied: proxyApplied,
+            actual: actualProxy,
+            appliedKnown: proxyAppliedKnown,
+            stateKnown: proxyStateKnown,
+            ...(proxyQueryError ? { queryError: proxyQueryError } : {}),
+        },
+        settings: publicSettings(settings),
+        activeProfile: active ? { id: active.id, name: active.name, url: active.url } : null,
+    };
+    return { status: 200, json: status };
+}
+export function shutdownDaemon(ctx) {
+    return ctx.shutdown().then((snapshot) => ({
+        status: 200,
+        json: { coreWasRunning: snapshot.coreWasRunning },
+        after: () => {
+            void ctx
+                .closeListener()
+                .then(() => ctx.onShutdown?.())
+                .catch(() => undefined);
+        },
+    }));
+}

package/dist/daemon/handlers/profiles.js

@@ -0,0 +1,57 @@
+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 addProfile(ctx, req) {
+    const body = await req.readJson();
+    const url = typeof body.url === "string" ? body.url.trim() : "";
+    const name = typeof body.name === "string" ? body.name.trim() : undefined;
+    const result = await ctx.profiles.addRemote(url, {
+        ...(name ? { name } : {}),
+        activate: body.activate === true,
+    });
+    return { status: 200, json: result };
+}
+export async function importProfile(ctx, req) {
+    const body = await req.readJson(8 * 1024 * 1024);
+    const name = typeof body.name === "string" ? body.name : "imported";
+    const content = typeof body.content === "string" ? body.content : "";
+    const result = await ctx.profiles.importLocal(name, content);
+    return { status: 200, json: result };
+}
+export async function activateProfile(ctx, req) {
+    const body = await req.readJson();
+    const id = body.id === null ? null : typeof body.id === "string" ? body.id : undefined;
+    if (id === undefined)
+        throw new ProfileInputError("Missing profile id string or null");
+    const result = await ctx.profiles.activate(id);
+    return { status: 200, json: result };
+}
+export async function updateAllProfiles(ctx) {
+    const result = await ctx.profiles.updateAll();
+    return { status: 200, json: result };
+}
+export async function updateProfile(ctx, req) {
+    const result = await ctx.profiles.update(requiredParam(req, "id"));
+    return { status: 200, json: result };
+}
+export function readProfileContent(ctx, req) {
+    return { status: 200, json: ctx.profiles.readContent(requiredParam(req, "id")) };
+}
+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);
+    return { status: 200, json: result };
+}
+export async function renameProfile(ctx, req) {
+    const body = await req.readJson();
+    const name = typeof body.name === "string" ? body.name : "";
+    const result = await ctx.profiles.rename(requiredParam(req, "id"), name);
+    return { status: 200, json: result };
+}
+export async function removeProfile(ctx, req) {
+    const result = await ctx.profiles.remove(requiredParam(req, "id"));
+    return { status: 200, json: result };
+}