@astralyn/sash 0.1.0

package/dist/commands/lifecycle.js

@@ -0,0 +1,50 @@
+import { log } from "../log.js";
+import { ensureRunning, restartRuntime, stopRuntime } from "../runtime-owner.js";
+import { tunPrivilegeGuidance } from "../tun-guidance.js";
+import { runtimeContext } from "./shared.js";
+export async function runStart() {
+    const ctx = runtimeContext();
+    const { owner, result } = await ensureRunning(ctx);
+    log.ok(`core started (PID=${result.pid}${result.version ? `, version ${result.version}` : ""})`);
+    printEndpoints(ctx, owner.daemon.port);
+    reportTunState(ctx, result);
+    if (ctx.settings.systemProxy)
+        log.ok("system proxy enabled");
+}
+export async function runStop() {
+    const ctx = runtimeContext();
+    const { wasRunning } = await stopRuntime(ctx);
+    if (wasRunning) {
+        log.ok("sash stopped; system proxy restored to its pre-Sash state");
+    }
+    else {
+        log.info("sash is not running; stale runtime state was reconciled");
+    }
+}
+export async function runRestart(deps = {}) {
+    const ctx = runtimeContext();
+    const { owner, result, daemonPid, daemonWasRunning } = await restartRuntime(ctx, deps);
+    const verb = daemonWasRunning ? "restarted" : "started";
+    log.ok(`sashd ${verb} (PID=${daemonPid})`);
+    log.ok(`core ${verb} (PID=${result.pid}${result.version ? `, version ${result.version}` : ""})`);
+    printEndpoints(ctx, owner.daemon.port);
+    reportTunState(ctx, result);
+}
+function reportTunState(ctx, result) {
+    if (!ctx.settings.tun)
+        return;
+    if (result.tunActive === true) {
+        log.ok("TUN active");
+    }
+    else if (result.tunActive === false) {
+        log.warn(`TUN was requested but is inactive; the core remains available without TUN. ${tunPrivilegeGuidance("runtime-inactive", { root: ctx.layout.root })}`);
+    }
+    else {
+        log.warn(`TUN was requested, but its runtime state could not be verified. ${tunPrivilegeGuidance("runtime-inactive", { root: ctx.layout.root })}`);
+    }
+}
+export function printEndpoints(ctx, daemonPort) {
+    log.kv("mixed port", `127.0.0.1:${ctx.settings.mixedPort}`);
+    log.kv("sash api", `http://127.0.0.1:${daemonPort}`);
+    log.kv("dashboard", `http://127.0.0.1:${daemonPort}/ui/  (sash web to open)`);
+}

package/dist/commands/logs.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import { log } from "../log.js";
+import { followLogFile, logCursorAtEnd, normalizeLines } from "../log-follow.js";
+import { tailFile } from "../process.js";
+import { runtimeContext } from "./shared.js";
+export async function runLogs(opts = {}) {
+    const ctx = runtimeContext();
+    let file;
+    if (opts.daemon) {
+        file = opts.errors ? ctx.layout.daemonErrLogFile : ctx.layout.daemonLogFile;
+    }
+    else {
+        file = opts.errors ? ctx.layout.coreErrLogFile : ctx.layout.coreLogFile;
+    }
+    const lines = normalizeLines(opts.lines);
+    const cursor = logCursorAtEnd(file);
+    if (cursor.identity === null) {
+        log.info(`${opts.follow ? "waiting for" : "no"} log file at ${file}`);
+        if (!opts.follow)
+            return;
+    }
+    else {
+        printTail(file, lines);
+    }
+    if (!opts.follow)
+        return;
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        await followLogFile(file, {
+            cursor,
+            signal: controller.signal,
+            onChunk: async (chunk) => {
+                if (process.stdout.write(chunk))
+                    return;
+                await new Promise((resolve) => process.stdout.once("drain", resolve));
+            },
+        });
+    }
+    finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+    }
+}
+function printTail(file, lines) {
+    if (!fs.existsSync(file))
+        return;
+    const tail = tailFile(file, lines);
+    if (!tail)
+        return;
+    process.stdout.write(`${tail}\n`);
+}

package/dist/commands/shared.js

@@ -0,0 +1,8 @@
+import { sashLayout } from "../paths.js";
+import { loadSettings } from "../settings.js";
+export { runOfflineMutation } from "../offline-mutation.js";
+export function runtimeContext() {
+    const layout = sashLayout();
+    const settings = loadSettings(layout);
+    return { layout, settings };
+}

package/dist/commands/status.js

@@ -0,0 +1,39 @@
+import { log } from "../log.js";
+import { collectRuntimeStatus, formatObservedProxy, formatTunObservation, markIncompleteObservation, runtimeStatusHeadline, shouldShowTunGuidance, } from "../status.js";
+import { tunPrivilegeGuidance } from "../tun-guidance.js";
+import { runtimeContext } from "./shared.js";
+export async function runStatus(opts = {}, collect = () => collectRuntimeStatus(runtimeContext())) {
+    const status = await collect();
+    if (opts.json) {
+        console.log(JSON.stringify(status, null, 2));
+        markIncompleteObservation(status.complete);
+        return;
+    }
+    const headline = runtimeStatusHeadline(status);
+    log[headline.level](headline.text);
+    if (status.queryError)
+        log.warn(`status incomplete: ${status.queryError}`);
+    log.kv("root", status.paths.root);
+    log.kv("config", status.paths.config);
+    log.kv("mixed port", status.endpoints.mixedProxy);
+    log.kv("proxy desired", status.systemProxy.desired ? "on" : "off");
+    log.kv("daemon applied", status.systemProxy.daemonApplied === null
+        ? status.daemon.state === "stopped"
+            ? "n/a (stopped)"
+            : "unknown"
+        : status.systemProxy.daemonApplied
+            ? "yes"
+            : "no");
+    log.kv("os proxy", formatObservedProxy(status.systemProxy.osObserved));
+    log.kv("sash api", status.endpoints.daemonApi);
+    log.kv("dashboard", status.endpoints.dashboard);
+    log.kv("active profile", status.activeProfile
+        ? `${status.activeProfile.name} (${status.activeProfile.url || "local file"})`
+        : "(none)");
+    log.kv("tun", formatTunObservation(status));
+    log.kv("core version", status.core.installedVersion || "(not installed)");
+    if (shouldShowTunGuidance(status)) {
+        log.warn(tunPrivilegeGuidance("runtime-inactive", { root: status.paths.root }));
+    }
+    markIncompleteObservation(status.complete);
+}

package/dist/commands/update.js

@@ -0,0 +1,5 @@
+import { runCoreUpdate } from "../core-update-service.js";
+import { runtimeContext } from "./shared.js";
+export async function runUpdate(opts = {}, deps = {}) {
+    await runCoreUpdate(runtimeContext(), opts, deps);
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,43 @@
+import spawn from "cross-spawn";
+import { log } from "../log.js";
+import { buildSanitizedEnv } from "../process.js";
+import { resolveRuntimeOwner } from "../runtime-owner.js";
+import { runtimeContext } from "./shared.js";
+const PACKAGE_NAME = "@astralyn/sash";
+const STRICT_SEMVER = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const SAFE_DIST_TAG = /^[A-Za-z][A-Za-z0-9._-]{0,63}$/;
+export function validateUpgradeVersion(value) {
+    if (value !== value.trim() || !value) {
+        throw new Error(`Invalid Sash package version or dist-tag: ${JSON.stringify(value)}`);
+    }
+    if (STRICT_SEMVER.test(value))
+        return value;
+    if (SAFE_DIST_TAG.test(value) && !/^v?\d+(?:\.|$)/i.test(value))
+        return value;
+    throw new Error(`Invalid Sash package version or dist-tag: ${JSON.stringify(value)}`);
+}
+export function buildUpgradeSpawnOptions(sourceEnv = process.env) {
+    return { stdio: "inherit", env: buildSanitizedEnv(sourceEnv) };
+}
+export async function runUpgrade(opts = {}) {
+    const ctx = runtimeContext();
+    const owner = await resolveRuntimeOwner(ctx);
+    if (owner.kind !== "offline") {
+        throw new Error("stop Sash with `sash stop` before upgrading the package");
+    }
+    const version = validateUpgradeVersion(opts.version ?? "latest");
+    const target = `${PACKAGE_NAME}@${version}`;
+    log.info(`upgrading Sash via npm: ${target}`);
+    const code = await new Promise((resolve) => {
+        const child = spawn("npm", ["install", "-g", target], buildUpgradeSpawnOptions());
+        child.on("error", (err) => {
+            log.error(`failed to launch npm: ${err.message}`);
+            resolve(1);
+        });
+        child.on("close", (exitCode) => resolve(exitCode ?? 1));
+    });
+    if (code !== 0) {
+        throw new Error(`npm exited with code ${code}. Try running the command manually: npm install -g ${target}`);
+    }
+    log.ok("Sash upgraded. Run `sash version` to verify, then start it normally.");
+}

package/dist/commands/web.js

@@ -0,0 +1,33 @@
+import { openInBrowser } from "../browser.js";
+import { log } from "../log.js";
+import { resolveRuntimeOwner } from "../runtime-owner.js";
+import { runStart } from "./lifecycle.js";
+import { runtimeContext } from "./shared.js";
+export function dashboardUrl(daemonPort) {
+    return `http://127.0.0.1:${daemonPort}/ui/`;
+}
+export async function runWeb(opts = {}) {
+    const ctx = runtimeContext();
+    let owner = await resolveRuntimeOwner(ctx);
+    let coreRunning = false;
+    if (owner.kind === "daemon") {
+        try {
+            coreRunning = (await owner.client.status()).core.running;
+        }
+        catch {
+            coreRunning = false;
+        }
+    }
+    if (!coreRunning) {
+        log.info("sash is not running; starting it first...");
+        await runStart();
+        owner = await resolveRuntimeOwner(ctx);
+    }
+    if (owner.kind !== "daemon") {
+        throw new Error("sashd did not become healthy before opening the dashboard");
+    }
+    const url = dashboardUrl(owner.daemon.port);
+    log.ok(`dashboard: ${url}`);
+    if (!opts.noOpen)
+        openInBrowser(url);
+}

package/dist/contracts.js

@@ -0,0 +1,412 @@
+import { isCanonicalIsoTimestamp, isPlainObject } from "./json-shape.js";
+export const WEB_SOCKET_AUTH_PROTOCOL = "sash";
+export const WEB_SOCKET_TOKEN_PROTOCOL_PREFIX = "sash-token.";
+export function apiErrorBody(code, message) {
+    return { error: { code, message } };
+}
+export function parseApiErrorBody(value) {
+    if (!isPlainObject(value) || !isPlainObject(value.error))
+        return undefined;
+    const { code, message } = value.error;
+    if (typeof code !== "string" || typeof message !== "string")
+        return undefined;
+    return { code, message };
+}
+function invalid(contract, path, expected) {
+    throw new TypeError(`${contract} response is invalid: ${path} must be ${expected}`);
+}
+function objectValue(value, contract, path) {
+    if (!isPlainObject(value))
+        invalid(contract, path, "a plain object");
+    return value;
+}
+function required(source, key, contract, path) {
+    if (!Object.hasOwn(source, key))
+        invalid(contract, path, "present");
+    return source[key];
+}
+function booleanValue(value, contract, path) {
+    if (typeof value !== "boolean")
+        invalid(contract, path, "a boolean");
+    return value;
+}
+function stringValue(value, contract, path, nonEmpty = false) {
+    if (typeof value !== "string" || (nonEmpty && !value.trim())) {
+        invalid(contract, path, nonEmpty ? "a non-empty string" : "a string");
+    }
+    return value;
+}
+function finiteNumber(value, contract, path) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        invalid(contract, path, "a finite number");
+    }
+    return value;
+}
+function positiveSafeInteger(value, contract, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+        invalid(contract, path, "a positive safe integer");
+    }
+    return value;
+}
+function nonNegativeSafeInteger(value, contract, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        invalid(contract, path, "a non-negative safe integer");
+    }
+    return value;
+}
+function portValue(value, contract, path) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 65_535) {
+        invalid(contract, path, "an integer port from 1 to 65535");
+    }
+    return value;
+}
+function timestampValue(value, contract, path) {
+    if (!isCanonicalIsoTimestamp(value))
+        invalid(contract, path, "a canonical ISO timestamp");
+    return value;
+}
+function optionalString(source, key, contract, path) {
+    return Object.hasOwn(source, key) ? stringValue(source[key], contract, path) : undefined;
+}
+function knownFlag(source, key, contract, path) {
+    return Object.hasOwn(source, key) ? booleanValue(source[key], contract, path) : false;
+}
+function parseSystemProxyState(value, contract, path) {
+    const source = objectValue(value, contract, path);
+    const server = optionalString(source, "server", contract, `${path}.server`);
+    const details = optionalString(source, "details", contract, `${path}.details`);
+    return {
+        supported: booleanValue(required(source, "supported", contract, `${path}.supported`), contract, `${path}.supported`),
+        enabled: booleanValue(required(source, "enabled", contract, `${path}.enabled`), contract, `${path}.enabled`),
+        ...(server !== undefined ? { server } : {}),
+        ...(details !== undefined ? { details } : {}),
+    };
+}
+function parseCoreState(value, contract) {
+    const source = objectValue(value, contract, "core");
+    const pid = Object.hasOwn(source, "pid")
+        ? positiveSafeInteger(source.pid, contract, "core.pid")
+        : undefined;
+    const startedAt = Object.hasOwn(source, "startedAt")
+        ? timestampValue(source.startedAt, contract, "core.startedAt")
+        : undefined;
+    const healthy = Object.hasOwn(source, "healthy")
+        ? booleanValue(source.healthy, contract, "core.healthy")
+        : undefined;
+    const version = optionalString(source, "version", contract, "core.version");
+    const tunActive = Object.hasOwn(source, "tunActive")
+        ? booleanValue(source.tunActive, contract, "core.tunActive")
+        : undefined;
+    return {
+        running: booleanValue(required(source, "running", contract, "core.running"), contract, "core.running"),
+        ...(pid !== undefined ? { pid } : {}),
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(healthy !== undefined ? { healthy } : {}),
+        ...(version !== undefined ? { version } : {}),
+        ...(tunActive !== undefined ? { tunActive } : {}),
+    };
+}
+export function parsePublicSettings(value) {
+    const contract = "sashd settings";
+    const source = objectValue(value, contract, "settings");
+    return {
+        mixedPort: portValue(required(source, "mixedPort", contract, "settings.mixedPort"), contract, "settings.mixedPort"),
+        controller: stringValue(required(source, "controller", contract, "settings.controller"), contract, "settings.controller", true),
+        tun: booleanValue(required(source, "tun", contract, "settings.tun"), contract, "settings.tun"),
+        allowLan: booleanValue(required(source, "allowLan", contract, "settings.allowLan"), contract, "settings.allowLan"),
+        daemonPort: portValue(required(source, "daemonPort", contract, "settings.daemonPort"), contract, "settings.daemonPort"),
+        systemProxy: booleanValue(required(source, "systemProxy", contract, "settings.systemProxy"), contract, "settings.systemProxy"),
+    };
+}
+function parseProfileMeta(value, contract, path) {
+    const source = objectValue(value, contract, path);
+    const subInfoValue = Object.hasOwn(source, "subInfo")
+        ? objectValue(source.subInfo, contract, `${path}.subInfo`)
+        : undefined;
+    const subInfo = subInfoValue
+        ? {
+            upload: finiteNumber(required(subInfoValue, "upload", contract, `${path}.subInfo.upload`), contract, `${path}.subInfo.upload`),
+            download: finiteNumber(required(subInfoValue, "download", contract, `${path}.subInfo.download`), contract, `${path}.subInfo.download`),
+            total: finiteNumber(required(subInfoValue, "total", contract, `${path}.subInfo.total`), contract, `${path}.subInfo.total`),
+            ...(Object.hasOwn(subInfoValue, "expire")
+                ? {
+                    expire: finiteNumber(subInfoValue.expire, contract, `${path}.subInfo.expire`),
+                }
+                : {}),
+        }
+        : undefined;
+    const homePage = optionalString(source, "homePage", contract, `${path}.homePage`);
+    const lastError = optionalString(source, "lastError", contract, `${path}.lastError`);
+    return {
+        id: stringValue(required(source, "id", contract, `${path}.id`), contract, `${path}.id`, true),
+        name: stringValue(required(source, "name", contract, `${path}.name`), contract, `${path}.name`),
+        url: stringValue(required(source, "url", contract, `${path}.url`), contract, `${path}.url`),
+        intervalHours: nonNegativeSafeInteger(required(source, "intervalHours", contract, `${path}.intervalHours`), contract, `${path}.intervalHours`),
+        createdAt: timestampValue(required(source, "createdAt", contract, `${path}.createdAt`), contract, `${path}.createdAt`),
+        updatedAt: timestampValue(required(source, "updatedAt", contract, `${path}.updatedAt`), contract, `${path}.updatedAt`),
+        ...(subInfo !== undefined ? { subInfo } : {}),
+        ...(homePage !== undefined ? { homePage } : {}),
+        ...(lastError !== undefined ? { lastError } : {}),
+    };
+}
+function optionalProxyCount(source, contract, path) {
+    return Object.hasOwn(source, "proxyCount")
+        ? { proxyCount: nonNegativeSafeInteger(source.proxyCount, contract, `${path}.proxyCount`) }
+        : {};
+}
+export function parseHealthInfo(value) {
+    const contract = "sashd health";
+    const source = objectValue(value, contract, "response");
+    return {
+        token: stringValue(required(source, "token", contract, "token"), contract, "token", true),
+        pid: positiveSafeInteger(required(source, "pid", contract, "pid"), contract, "pid"),
+        startedAt: timestampValue(required(source, "startedAt", contract, "startedAt"), contract, "startedAt"),
+    };
+}
+export function parseCoreStartResult(value) {
+    const contract = "sashd core start";
+    const source = objectValue(value, contract, "response");
+    const version = optionalString(source, "version", contract, "version");
+    const tunActive = Object.hasOwn(source, "tunActive")
+        ? booleanValue(source.tunActive, contract, "tunActive")
+        : undefined;
+    return {
+        pid: positiveSafeInteger(required(source, "pid", contract, "pid"), contract, "pid"),
+        ...(version !== undefined ? { version } : {}),
+        ...(tunActive !== undefined ? { tunActive } : {}),
+    };
+}
+export function parseCoreReloadResult(value) {
+    const contract = "sashd core reload";
+    const source = objectValue(value, contract, "response");
+    const sourceKind = stringValue(required(source, "source", contract, "source"), contract, "source");
+    if (sourceKind !== "subscription" && sourceKind !== "default") {
+        invalid(contract, "source", `"subscription" or "default"`);
+    }
+    return {
+        proxyCount: nonNegativeSafeInteger(required(source, "proxyCount", contract, "proxyCount"), contract, "proxyCount"),
+        source: sourceKind,
+    };
+}
+export function parseShutdownResult(value) {
+    const contract = "sashd shutdown";
+    const source = objectValue(value, contract, "response");
+    return {
+        coreWasRunning: booleanValue(required(source, "coreWasRunning", contract, "coreWasRunning"), contract, "coreWasRunning"),
+    };
+}
+export function parseSystemProxyStatusResponse(value) {
+    const contract = "sashd system proxy";
+    const source = objectValue(value, contract, "response");
+    const state = parseSystemProxyState(source, contract, "response");
+    const queryError = optionalString(source, "queryError", contract, "queryError");
+    return {
+        desired: booleanValue(required(source, "desired", contract, "desired"), contract, "desired"),
+        applied: booleanValue(required(source, "applied", contract, "applied"), contract, "applied"),
+        ...state,
+        appliedKnown: knownFlag(source, "appliedKnown", contract, "appliedKnown"),
+        stateKnown: knownFlag(source, "stateKnown", contract, "stateKnown"),
+        ...(queryError !== undefined ? { queryError } : {}),
+    };
+}
+export function parseSettingsPatch(value, direction = "response") {
+    const subject = `sashd settings patch ${direction}`;
+    const fail = (path, expected) => {
+        throw new TypeError(`${subject} is invalid: ${path} must be ${expected}`);
+    };
+    if (!isPlainObject(value))
+        fail("body", "a plain object");
+    const source = value;
+    const allowed = new Set([
+        "mixedPort",
+        "allowLan",
+        "tun",
+        "systemProxy",
+        "daemonPort",
+        "daemonSecret",
+    ]);
+    for (const key of Object.keys(source)) {
+        if (!allowed.has(key))
+            fail(key, "a known settings patch field");
+    }
+    const portField = (key) => {
+        if (!Object.hasOwn(source, key))
+            return undefined;
+        const field = source[key];
+        if (typeof field !== "number" || !Number.isInteger(field) || field < 1 || field > 65_535) {
+            return fail(key, "an integer port from 1 to 65535");
+        }
+        return field;
+    };
+    const boolField = (key) => {
+        if (!Object.hasOwn(source, key))
+            return undefined;
+        const field = source[key];
+        if (typeof field !== "boolean")
+            return fail(key, "a boolean");
+        return field;
+    };
+    const patch = {};
+    const mixedPort = portField("mixedPort");
+    if (mixedPort !== undefined)
+        patch.mixedPort = mixedPort;
+    const daemonPort = portField("daemonPort");
+    if (daemonPort !== undefined)
+        patch.daemonPort = daemonPort;
+    const allowLan = boolField("allowLan");
+    if (allowLan !== undefined)
+        patch.allowLan = allowLan;
+    const tun = boolField("tun");
+    if (tun !== undefined)
+        patch.tun = tun;
+    const systemProxy = boolField("systemProxy");
+    if (systemProxy !== undefined)
+        patch.systemProxy = systemProxy;
+    if (Object.hasOwn(source, "daemonSecret")) {
+        const secret = source.daemonSecret;
+        if (typeof secret !== "string" || !secret.trim()) {
+            fail("daemonSecret", "a non-empty string");
+        }
+        patch.daemonSecret = secret;
+    }
+    return patch;
+}
+export function parseSettingsWriteResult(value) {
+    const contract = "sashd settings write";
+    const source = objectValue(value, contract, "response");
+    return {
+        restartRequired: booleanValue(required(source, "restartRequired", contract, "restartRequired"), contract, "restartRequired"),
+        settings: parsePublicSettings(required(source, "settings", contract, "settings")),
+    };
+}
+export function parseSettingsFileContent(value) {
+    const contract = "sashd settings file";
+    const source = objectValue(value, contract, "response");
+    return {
+        content: stringValue(required(source, "content", contract, "content"), contract, "content"),
+    };
+}
+export function parseProfilesIndex(value) {
+    const contract = "sashd profiles";
+    const source = objectValue(value, contract, "response");
+    const activeValue = required(source, "activeId", contract, "activeId");
+    const profilesValue = required(source, "profiles", contract, "profiles");
+    if (!Array.isArray(profilesValue))
+        invalid(contract, "profiles", "an array");
+    return {
+        activeId: activeValue === null ? null : stringValue(activeValue, contract, "activeId", true),
+        profiles: profilesValue.map((entry, index) => parseProfileMeta(entry, contract, `profiles[${index}]`)),
+    };
+}
+export function parseProfileActionResponse(value) {
+    const contract = "sashd profile action";
+    const source = objectValue(value, contract, "response");
+    return {
+        profile: parseProfileMeta(required(source, "profile", contract, "profile"), contract, "profile"),
+        activated: booleanValue(required(source, "activated", contract, "activated"), contract, "activated"),
+        ...optionalProxyCount(source, contract, "response"),
+    };
+}
+export function parseProfileUpdateResponse(value) {
+    const contract = "sashd profile update";
+    const source = objectValue(value, contract, "response");
+    return {
+        profile: parseProfileMeta(required(source, "profile", contract, "profile"), contract, "profile"),
+        ...optionalProxyCount(source, contract, "response"),
+    };
+}
+export function parseProfilesUpdateAllResponse(value) {
+    const contract = "sashd profiles update-all";
+    const source = objectValue(value, contract, "response");
+    const failedValue = required(source, "failed", contract, "failed");
+    if (!Array.isArray(failedValue))
+        invalid(contract, "failed", "an array");
+    return {
+        updated: nonNegativeSafeInteger(required(source, "updated", contract, "updated"), contract, "updated"),
+        failed: failedValue.map((entry, index) => {
+            const path = `failed[${index}]`;
+            const failure = objectValue(entry, contract, path);
+            return {
+                id: stringValue(required(failure, "id", contract, `${path}.id`), contract, `${path}.id`),
+                name: stringValue(required(failure, "name", contract, `${path}.name`), contract, `${path}.name`),
+                error: stringValue(required(failure, "error", contract, `${path}.error`), contract, `${path}.error`),
+            };
+        }),
+        ...optionalProxyCount(source, contract, "response"),
+    };
+}
+export function parseProfileContentResponse(value) {
+    const contract = "sashd profile content";
+    const source = objectValue(value, contract, "response");
+    return {
+        name: stringValue(required(source, "name", contract, "name"), contract, "name"),
+        content: stringValue(required(source, "content", contract, "content"), contract, "content"),
+    };
+}
+export function parseProfileActivateResponse(value) {
+    const contract = "sashd profile activate";
+    const source = objectValue(value, contract, "response");
+    const activeValue = required(source, "activeId", contract, "activeId");
+    return {
+        activeId: activeValue === null ? null : stringValue(activeValue, contract, "activeId", true),
+        proxyCount: nonNegativeSafeInteger(required(source, "proxyCount", contract, "proxyCount"), contract, "proxyCount"),
+    };
+}
+export function parseProfileRemoveResponse(value) {
+    const contract = "sashd profile remove";
+    const source = objectValue(value, contract, "response");
+    return {
+        wasActive: booleanValue(required(source, "wasActive", contract, "wasActive"), contract, "wasActive"),
+        ...optionalProxyCount(source, contract, "response"),
+    };
+}
+export function parseProfileRenameResponse(value) {
+    const contract = "sashd profile rename";
+    const source = objectValue(value, contract, "response");
+    return {
+        profile: parseProfileMeta(required(source, "profile", contract, "profile"), contract, "profile"),
+    };
+}
+export function parseDaemonStatus(value) {
+    const contract = "sashd status";
+    const source = objectValue(value, contract, "response");
+    const daemonSource = objectValue(required(source, "daemon", contract, "daemon"), contract, "daemon");
+    const revisionsSource = objectValue(required(source, "revisions", contract, "revisions"), contract, "revisions");
+    const proxySource = objectValue(required(source, "systemProxy", contract, "systemProxy"), contract, "systemProxy");
+    const actual = Object.hasOwn(proxySource, "actual")
+        ? parseSystemProxyState(proxySource.actual, contract, "systemProxy.actual")
+        : undefined;
+    const queryError = optionalString(proxySource, "queryError", contract, "systemProxy.queryError");
+    const activeValue = required(source, "activeProfile", contract, "activeProfile");
+    const activeProfile = activeValue === null
+        ? null
+        : (() => {
+            const active = objectValue(activeValue, contract, "activeProfile");
+            return {
+                id: stringValue(required(active, "id", contract, "activeProfile.id"), contract, "activeProfile.id", true),
+                name: stringValue(required(active, "name", contract, "activeProfile.name"), contract, "activeProfile.name"),
+                url: stringValue(required(active, "url", contract, "activeProfile.url"), contract, "activeProfile.url"),
+            };
+        })();
+    return {
+        daemon: {
+            pid: positiveSafeInteger(required(daemonSource, "pid", contract, "daemon.pid"), contract, "daemon.pid"),
+            startedAt: timestampValue(required(daemonSource, "startedAt", contract, "daemon.startedAt"), contract, "daemon.startedAt"),
+            port: portValue(required(daemonSource, "port", contract, "daemon.port"), contract, "daemon.port"),
+        },
+        revisions: {
+            profiles: nonNegativeSafeInteger(required(revisionsSource, "profiles", contract, "revisions.profiles"), contract, "revisions.profiles"),
+        },
+        core: parseCoreState(required(source, "core", contract, "core"), contract),
+        systemProxy: {
+            desired: booleanValue(required(proxySource, "desired", contract, "systemProxy.desired"), contract, "systemProxy.desired"),
+            applied: booleanValue(required(proxySource, "applied", contract, "systemProxy.applied"), contract, "systemProxy.applied"),
+            ...(actual !== undefined ? { actual } : {}),
+            appliedKnown: knownFlag(proxySource, "appliedKnown", contract, "systemProxy.appliedKnown"),
+            stateKnown: knownFlag(proxySource, "stateKnown", contract, "systemProxy.stateKnown"),
+            ...(queryError !== undefined ? { queryError } : {}),
+        },
+        settings: parsePublicSettings(required(source, "settings", contract, "settings")),
+        activeProfile,
+    };
+}