@astralyn/sash 0.1.0

package/dist/daemon-http.js

@@ -0,0 +1,93 @@
+import { apiErrorBody } from "./contracts.js";
+export class HttpError extends Error {
+    statusCode;
+    code;
+    constructor(statusCode, message, code) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = "HttpError";
+    }
+}
+export function parseJsonBody(req, maxBytes = 1024 * 1024) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let bytes = 0;
+        let settled = false;
+        function cleanup() {
+            req.removeListener("data", onData);
+            req.removeListener("end", onEnd);
+            req.removeListener("aborted", onAborted);
+            req.removeListener("error", onError);
+            req.removeListener("close", onClose);
+        }
+        function fail(error, drain = false) {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (drain && !req.destroyed)
+                req.resume();
+            reject(error);
+        }
+        function onData(chunk) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += buffer.length;
+            if (bytes > maxBytes) {
+                fail(new HttpError(413, `Request body too large (exceeds ${Math.ceil(maxBytes / 1024 / 1024)}MB)`), true);
+                return;
+            }
+            chunks.push(buffer);
+        }
+        function onEnd() {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            const raw = Buffer.concat(chunks).toString("utf8").trim();
+            if (!raw) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new HttpError(400, "Invalid JSON request body"));
+            }
+        }
+        function onAborted() {
+            fail(new HttpError(400, "Request body was aborted"));
+        }
+        function onError() {
+            fail(new HttpError(400, "Request body stream failed"));
+        }
+        function onClose() {
+            if (!req.complete)
+                onAborted();
+        }
+        req.on("data", onData);
+        req.once("end", onEnd);
+        req.once("aborted", onAborted);
+        req.once("error", onError);
+        req.once("close", onClose);
+    });
+}
+export async function parseJsonObjectBody(req, maxBytes = 1024 * 1024) {
+    const body = await parseJsonBody(req, maxBytes);
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new HttpError(400, "JSON request body must be an object");
+    }
+    return body;
+}
+export function sendJson(res, statusCode, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(statusCode, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(body),
+    });
+    res.end(body);
+}
+export function sendError(res, statusCode, code, message) {
+    sendJson(res, statusCode, apiErrorBody(code, message));
+}

package/dist/daemon-lifecycle.js

@@ -0,0 +1,378 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+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 { readStateLockRecord, withStateLock } from "./state-lock.js";
+export function readDaemonPidRecord(layout = sashLayout()) {
+    try {
+        if (!fs.existsSync(layout.daemonPidFile))
+            return undefined;
+        const parsed = JSON.parse(fs.readFileSync(layout.daemonPidFile, "utf8"));
+        if (!isPlainObject(parsed) ||
+            typeof parsed.pid !== "number" ||
+            !Number.isSafeInteger(parsed.pid) ||
+            parsed.pid <= 0 ||
+            typeof parsed.token !== "string" ||
+            !parsed.token.trim() ||
+            typeof parsed.port !== "number" ||
+            !Number.isInteger(parsed.port) ||
+            parsed.port < 1 ||
+            parsed.port > 65_535 ||
+            !isCanonicalIsoTimestamp(parsed.startedAt)) {
+            return undefined;
+        }
+        return {
+            pid: parsed.pid,
+            token: parsed.token,
+            port: parsed.port,
+            startedAt: parsed.startedAt,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function evaluateDaemon(layout = sashLayout(), settings) {
+    const record = readDaemonPidRecord(layout);
+    let lease;
+    try {
+        lease = readStateLockRecord(layout.daemonLeaseFile);
+    }
+    catch {
+        return {
+            kind: "unhealthy",
+            running: true,
+            healthy: false,
+            ...(record ? { stalePidFile: true } : {}),
+        };
+    }
+    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 } : {}),
+            };
+        }
+        return {
+            kind: "stopped",
+            running: false,
+            healthy: false,
+            ...(record || lease ? { pid: record?.pid ?? lease?.pid } : {}),
+            ...(record ? { stalePidFile: true } : {}),
+            ...(lease ? { staleLeaseFile: true } : {}),
+        };
+    }
+    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 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: "unhealthy",
+            running: true,
+            healthy: false,
+            stalePidFile: true,
+            pid: record.pid,
+        };
+    }
+    catch {
+        return {
+            kind: "unhealthy",
+            running: true,
+            pid: record.pid,
+            healthy: false,
+            port: record.port,
+        };
+    }
+}
+function resolveDaemonEntryPath() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidate = path.join(here, "daemon-entry.js");
+    if (fs.existsSync(candidate))
+        return candidate;
+    const tsCandidate = path.join(here, "daemon-entry.ts");
+    if (fs.existsSync(tsCandidate))
+        return tsCandidate;
+    return candidate;
+}
+function daemonStartupDiagnostics(layout, cursor) {
+    const details = boundedLogTailSince(layout.daemonErrLogFile, cursor, { maxLines: 20 });
+    return `${details ? `\nRecent errors:\n${details}` : ""}\nCheck logs at: ${layout.daemonErrLogFile}`;
+}
+async function spawnDaemonUnlocked(opts = {}) {
+    const layout = opts.layout ?? sashLayout();
+    const settings = opts.settings ?? loadSettings(layout);
+    const timeoutMs = opts.timeoutMs ?? 10_000;
+    const state = await evaluateDaemon(layout, settings);
+    if (state.kind === "healthy") {
+        return { pid: state.pid };
+    }
+    if (state.kind !== "stopped") {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            await sleep(200);
+            const current = await evaluateDaemon(layout, settings);
+            if (current.kind === "healthy")
+                return { pid: current.pid };
+            if (current.kind === "stopped")
+                break;
+        }
+        const owner = state.pid ? ` (PID=${state.pid})` : "";
+        throw new Error(`sashd is already starting or unresponsive${owner}; refusing to start a competing daemon`);
+    }
+    fs.mkdirSync(layout.logsDir, { recursive: true });
+    fs.mkdirSync(layout.stateDir, { recursive: true });
+    const entryPath = resolveDaemonEntryPath();
+    const sanitizedEnv = buildSanitizedEnv();
+    const nodeArgs = entryPath.endsWith(".ts")
+        ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx")).href, entryPath]
+        : [entryPath];
+    const errLogCursor = logTailCursor(layout.daemonErrLogFile);
+    const child = withPrivateAppendLogFds(layout.daemonLogFile, layout.daemonErrLogFile, ({ stdoutFd, stderrFd }) => spawn(process.execPath, nodeArgs, {
+        cwd: layout.root,
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd],
+        windowsHide: true,
+        env: { ...sanitizedEnv, SASH_HOME: layout.root },
+    }));
+    let spawnError;
+    child.once("error", (err) => {
+        spawnError = err;
+    });
+    child.unref();
+    const pid = child.pid;
+    if (!pid) {
+        throw new Error("Failed to start sashd process (no PID returned)");
+    }
+    const client = new SashDaemonClient(settings.daemonPort, settings.daemonSecret);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (spawnError) {
+            throw new Error(`Failed to start sashd: ${spawnError.message}${daemonStartupDiagnostics(layout, errLogCursor)}`);
+        }
+        if (!isProcessAlive(pid)) {
+            throw new Error(`sashd (PID=${pid}) exited unexpectedly during startup.${daemonStartupDiagnostics(layout, errLogCursor)}`);
+        }
+        try {
+            const record = readDaemonPidRecord(layout);
+            if (record) {
+                const health = await client.health();
+                if (record.pid === pid && health.token === record.token && health.pid === pid) {
+                    return { pid };
+                }
+            }
+        }
+        catch {
+        }
+        await sleep(200);
+    }
+    const terminated = await killProcessGracefully(pid, {
+        timeoutMs: 3000,
+        verify: () => child.pid === pid &&
+            (child.exitCode === null || child.exitCode === undefined) &&
+            (child.signalCode === null || child.signalCode === undefined)
+            ? "match"
+            : "mismatch",
+    });
+    const cleanup = terminated
+        ? ""
+        : " The daemon could not be confirmed stopped; ownership state was preserved.";
+    throw new Error(`sashd started (PID=${pid}) but control API did not respond within ${timeoutMs}ms.${cleanup}${daemonStartupDiagnostics(layout, errLogCursor)}`);
+}
+export async function spawnDaemon(opts = {}) {
+    const layout = opts.layout ?? sashLayout();
+    const settings = opts.settings ?? loadSettings(layout);
+    const timeoutMs = opts.timeoutMs ?? 10_000;
+    return withStateLock(layout.daemonStartLockFile, { purpose: "start sashd", timeoutMs: timeoutMs + 5000 }, () => spawnDaemonUnlocked({ layout, settings, timeoutMs }));
+}
+export async function ensureDaemon(opts = {}) {
+    const layout = opts.layout ?? sashLayout();
+    const settings = opts.settings ?? loadSettings(layout);
+    const state = await evaluateDaemon(layout, settings);
+    if (state.kind === "healthy")
+        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))
+        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.`);
+        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 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;
+    });
+}

package/dist/daemon-proxy.js

@@ -0,0 +1,176 @@
+import http from "node:http";
+import { coreWebSocketProtocols, webSocketAuthResponseProtocol } from "./daemon-auth.js";
+import { parseControllerAddress } from "./settings.js";
+export function parseHostPort(address) {
+    const parsed = parseControllerAddress(address);
+    if (!parsed) {
+        throw new Error(`Invalid controller address: ${address} (expected loopback host:port)`);
+    }
+    return { host: parsed.host, port: parsed.port };
+}
+export function forwardHttpToCore(req, res, targetPath, controller, secret) {
+    const { host, port } = parseHostPort(controller);
+    const upstreamHeaders = { ...req.headers };
+    delete upstreamHeaders.host;
+    delete upstreamHeaders.authorization;
+    delete upstreamHeaders["x-sash-token"];
+    if (secret) {
+        upstreamHeaders.authorization = `Bearer ${secret}`;
+    }
+    let completed = false;
+    const proxyReq = http.request({
+        hostname: host,
+        port,
+        path: targetPath,
+        method: req.method,
+        headers: upstreamHeaders,
+        timeout: 30_000,
+    }, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+        proxyRes.pipe(res);
+        proxyRes.on("end", () => {
+            completed = true;
+        });
+        proxyRes.on("error", () => {
+            res.destroy();
+        });
+    });
+    proxyReq.on("timeout", () => {
+        proxyReq.destroy(new Error("Core controller request timed out after 30000ms"));
+    });
+    proxyReq.on("error", (err) => {
+        if (!res.headersSent) {
+            const msg = JSON.stringify({
+                error: `Core controller unavailable: ${err.message}`,
+            });
+            res.writeHead(502, {
+                "Content-Type": "application/json; charset=utf-8",
+                "Content-Length": Buffer.byteLength(msg),
+            });
+            res.end(msg);
+        }
+    });
+    res.on("close", () => {
+        if (!completed) {
+            proxyReq.destroy();
+        }
+    });
+    req.pipe(proxyReq);
+}
+export function forwardWsToCore(req, socket, head, targetPath, controller, secret) {
+    const { host, port } = parseHostPort(controller);
+    const upstreamHeaders = { ...req.headers };
+    delete upstreamHeaders.host;
+    delete upstreamHeaders.authorization;
+    delete upstreamHeaders["x-sash-token"];
+    const coreProtocols = coreWebSocketProtocols(upstreamHeaders["sec-websocket-protocol"]);
+    if (coreProtocols) {
+        upstreamHeaders["sec-websocket-protocol"] = coreProtocols;
+    }
+    else {
+        delete upstreamHeaders["sec-websocket-protocol"];
+    }
+    if (secret) {
+        upstreamHeaders.authorization = `Bearer ${secret}`;
+    }
+    const proxyReq = http.request({
+        hostname: host,
+        port,
+        path: targetPath,
+        method: "GET",
+        headers: upstreamHeaders,
+        timeout: 10_000,
+    });
+    let upstreamTransportSocket;
+    let upstreamSocket;
+    let cleaned = false;
+    const cleanup = (closeDownstream) => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        proxyReq.destroy();
+        upstreamTransportSocket?.destroy();
+        upstreamSocket?.destroy();
+        if (closeDownstream && !socket.destroyed)
+            socket.destroy();
+    };
+    proxyReq.once("socket", (transportSocket) => {
+        upstreamTransportSocket = transportSocket;
+        if (cleaned)
+            transportSocket.destroy();
+    });
+    socket.once("error", () => cleanup(true));
+    socket.once("end", () => cleanup(true));
+    socket.once("close", () => cleanup(false));
+    const pendingClientChunks = [];
+    let pendingClientBytes = 0;
+    const readPendingClientData = () => {
+        while (true) {
+            const chunk = socket.read();
+            if (chunk === null)
+                return;
+            pendingClientBytes += chunk.length;
+            if (pendingClientBytes > 64 * 1024) {
+                cleanup(true);
+                return;
+            }
+            pendingClientChunks.push(chunk);
+        }
+    };
+    socket.on("readable", readPendingClientData);
+    proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+        readPendingClientData();
+        socket.removeListener("readable", readPendingClientData);
+        upstreamSocket = proxySocket;
+        proxySocket.once("error", () => cleanup(true));
+        proxySocket.once("close", () => cleanup(true));
+        if (cleaned || socket.destroyed || !socket.writable) {
+            proxySocket.destroy();
+            return;
+        }
+        try {
+            const statusLine = `HTTP/1.1 ${proxyRes.statusCode ?? 101} ${proxyRes.statusMessage ?? "Switching Protocols"}\r\n`;
+            const responseHeaders = { ...proxyRes.headers };
+            if (!responseHeaders["sec-websocket-protocol"]) {
+                const authProtocol = webSocketAuthResponseProtocol(req.headers["sec-websocket-protocol"]);
+                if (authProtocol)
+                    responseHeaders["sec-websocket-protocol"] = authProtocol;
+            }
+            const headerLines = Object.entries(responseHeaders)
+                .filter((entry) => entry[1] !== undefined)
+                .map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : value}`)
+                .join("\r\n");
+            socket.write(`${statusLine}${headerLines}\r\n\r\n`);
+            if (proxyHead.length > 0)
+                socket.write(proxyHead);
+            if (head.length > 0)
+                proxySocket.write(head);
+            for (const chunk of pendingClientChunks)
+                proxySocket.write(chunk);
+            proxySocket.pipe(socket);
+            socket.pipe(proxySocket);
+        }
+        catch {
+            cleanup(true);
+        }
+    });
+    proxyReq.on("response", (proxyRes) => {
+        proxyRes.once("error", () => cleanup(true));
+        if (cleaned || socket.destroyed || !socket.writable) {
+            proxyRes.destroy();
+            cleanup(false);
+            return;
+        }
+        const statusLine = `HTTP/1.1 ${proxyRes.statusCode ?? 502} ${proxyRes.statusMessage ?? "Bad Gateway"}\r\n\r\n`;
+        socket.end(statusLine);
+        proxyRes.resume();
+    });
+    proxyReq.on("timeout", () => {
+        proxyReq.destroy(new Error("Core WebSocket upgrade timed out after 10000ms"));
+    });
+    proxyReq.on("error", () => cleanup(true));
+    if (socket.destroyed || !socket.writable)
+        cleanup(false);
+    else
+        proxyReq.end();
+}