@astralyn/sash 0.1.0 → 0.1.2

package/dist/autostart/windows.js

@@ -0,0 +1,59 @@
+import path from "node:path";
+import { assertLauncherValue, launcherFilesExist, } from "./context.js";
+import { readRegistration, registerFile, removeRegistration } from "./files.js";
+import { readWindowsRegistration, setWindowsRegistration, windowsSystemPath, } from "./windows-registry.js";
+export function windowsLauncherContents(node, entry, dataDir) {
+    for (const value of [node, entry, dataDir]) {
+        assertLauncherValue(value);
+        if (value.includes('"'))
+            throw new Error("Windows autostart paths cannot contain quotes");
+    }
+    const script = [
+        "' Sash login launcher; generated by sash auto.",
+        "Option Explicit",
+        "Dim shell, environment",
+        'Set shell = CreateObject("WScript.Shell")',
+        'Set environment = shell.Environment("PROCESS")',
+        `environment("SASH_HOME") = "${dataDir}"`,
+        `environment("SASH_AUTOSTART_NODE") = "${node}"`,
+        `environment("SASH_AUTOSTART_ENTRY") = "${entry}"`,
+        'shell.Run """%SASH_AUTOSTART_NODE%"" ""%SASH_AUTOSTART_ENTRY%""", 0, False',
+        "",
+    ].join("\r\n");
+    return Buffer.from(`\uFEFF${script}`, "utf16le");
+}
+export function windowsAutostart(ctx) {
+    const file = path.join(ctx.controlDir, "start.vbs");
+    const launcherCommand = () => {
+        const wscript = windowsSystemPath(ctx, "wscript.exe");
+        for (const value of [wscript, file]) {
+            assertLauncherValue(value);
+            if (value.includes('"'))
+                throw new Error("Windows autostart paths cannot contain quotes");
+        }
+        return `"${wscript}" //B //Nologo "${file}"`;
+    };
+    const contents = () => windowsLauncherContents(ctx.nodePath, ctx.entryPath, ctx.dataDir);
+    return {
+        async inspect() {
+            const registration = await readWindowsRegistration(ctx);
+            if (registration.command === null)
+                return "off";
+            if (!launcherFilesExist(ctx) ||
+                registration.command.toLowerCase() !== launcherCommand().toLowerCase() ||
+                !readRegistration(file)?.equals(contents())) {
+                return "stale";
+            }
+            return registration.disabled ? "disabled" : "on";
+        },
+        async set(enabled) {
+            if (enabled) {
+                await registerFile(file, contents(), () => setWindowsRegistration(ctx, launcherCommand()));
+            }
+            else {
+                await setWindowsRegistration(ctx, null);
+                removeRegistration(file);
+            }
+        },
+    };
+}

package/dist/autostart-contract.js

@@ -0,0 +1,31 @@
+import { hasExactOwnKeys, isPlainObject } from "./json-shape.js";
+export const AUTOSTART_STATES = [
+    "on",
+    "off",
+    "stale",
+    "disabled",
+    "unknown",
+    "unsupported",
+];
+export function parseAutostartStatus(value) {
+    if (!isPlainObject(value) ||
+        !hasExactOwnKeys(value, ["state", "canEnable", "reason"]) ||
+        !AUTOSTART_STATES.some((state) => state === value.state) ||
+        typeof value.canEnable !== "boolean" ||
+        (value.reason !== null && typeof value.reason !== "string")) {
+        throw new Error("Invalid autostart status");
+    }
+    return {
+        state: value.state,
+        canEnable: value.canEnable,
+        reason: value.reason,
+    };
+}
+export function parseAutostartEnabled(value) {
+    if (!isPlainObject(value) ||
+        !hasExactOwnKeys(value, ["enabled"]) ||
+        typeof value.enabled !== "boolean") {
+        throw new Error("Expected an object containing only an enabled boolean");
+    }
+    return value.enabled;
+}

package/dist/autostart-entry.js

@@ -0,0 +1,10 @@
+import "./node-version-guard.js";
+import { startAtLogin } from "./autostart/start.js";
+import { errorMessage } from "./error-utils.js";
+try {
+    await startAtLogin();
+}
+catch (error) {
+    console.error(`[sash] Login startup failed: ${errorMessage(error)}`);
+    process.exitCode = 1;
+}

package/dist/autostart.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { autostartContext, } from "./autostart/context.js";
+import { installationIssue } from "./autostart/installation.js";
+import { windowsAutostart } from "./autostart/windows.js";
+import { errorMessage } from "./error-utils.js";
+import { StateMutationQueue } from "./state-lock.js";
+export class AutostartUnavailableError extends Error {
+}
+export class AutostartService {
+    context;
+    backend;
+    queue;
+    checkInstallation;
+    constructor(options = {}) {
+        this.context = autostartContext(options);
+        this.backend =
+            options.backend ??
+                (this.context.platform === "win32" ? windowsAutostart(this.context) : undefined);
+        this.queue = new StateMutationQueue(path.join(this.context.controlDir, "registration.lock"));
+        this.checkInstallation = options.checkInstallation ?? installationIssue;
+    }
+    async inspect() {
+        if (!this.backend) {
+            return {
+                state: "unsupported",
+                canEnable: false,
+                reason: `Autostart is not supported on ${this.context.platform}`,
+            };
+        }
+        const issue = this.checkInstallation(this.context);
+        try {
+            return {
+                state: await this.backend.inspect(),
+                canEnable: issue === null,
+                reason: issue,
+            };
+        }
+        catch (error) {
+            return {
+                state: "unknown",
+                canEnable: issue === null,
+                reason: errorMessage(error),
+            };
+        }
+    }
+    async set(enabled) {
+        const backend = this.backend;
+        if (!backend) {
+            throw new AutostartUnavailableError(`Autostart is not supported on ${this.context.platform}`);
+        }
+        return this.queue.run("configure autostart", async () => {
+            if (enabled) {
+                const issue = this.checkInstallation(this.context);
+                if (issue)
+                    throw new AutostartUnavailableError(issue);
+            }
+            await backend.set(enabled);
+            if (!enabled) {
+                const issue = this.checkInstallation(this.context);
+                return { state: "off", canEnable: issue === null, reason: issue };
+            }
+            const status = await this.inspect();
+            if (status.state !== "on") {
+                throw new Error(`Could not verify autostart: ${status.reason ?? status.state}`);
+            }
+            return status;
+        });
+    }
+}

package/dist/cli.js

@@ -3,13 +3,13 @@ import "./node-version-guard.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { Command, CommanderError, InvalidArgumentError } from "commander";
+import { Argument, Command, CommanderError, InvalidArgumentError } from "commander";
 import { withCliErrors } from "./cli-errors.js";
+import { runAuto } from "./commands/auto.js";
 import { runRestart, runStart, runStop } from "./commands/lifecycle.js";
 import { runLogs } from "./commands/logs.js";
 import { runStatus } from "./commands/status.js";
 import { runUpdate } from "./commands/update.js";
-import { runUpgrade } from "./commands/upgrade.js";
 import { runWeb } from "./commands/web.js";
 import { parseLogLineCount } from "./log-follow.js";
 function packageVersion() {
@@ -35,7 +35,6 @@ Examples:
   $ sash web                   open the web dashboard
   $ sash status                show runtime state, endpoints, and system proxy status
   $ sash update                upgrade the core binary
-  $ sash upgrade               upgrade Sash itself via npm
 
 Data directory: %LOCALAPPDATA%\\Sash (Windows), ~/Library/Application Support/Sash (macOS),
 $XDG_DATA_HOME/sash (Linux). Override with the SASH_HOME environment variable.`);
@@ -49,8 +48,13 @@ program
     .action(withCliErrors(() => runStop()));
 program
     .command("restart")
-    .description("restart the daemon and core")
+    .description("apply saved configuration and restart the core")
     .action(withCliErrors(() => runRestart()));
+program
+    .command("auto")
+    .description("inspect or set automatic startup at login for the current user")
+    .addArgument(new Argument("[mode]", "set autostart or inspect its state").choices(["on", "off", "status"]))
+    .action(withCliErrors((mode) => runAuto(mode)));
 program
     .command("status")
     .description("show runtime state, versions, endpoints, and system proxy status")
@@ -63,26 +67,22 @@ program
     .option("-f, --follow", "follow the log output")
     .option("--errors", "read the stderr log instead of stdout")
     .option("--daemon", "read sashd daemon logs instead of core logs")
+    .option("--startup", "read login startup diagnostics")
     .action(withCliErrors((opts) => runLogs({
     lines: opts.lines ?? 50,
     follow: opts.follow,
     errors: opts.errors,
     daemon: opts.daemon,
+    startup: opts.startup,
 })));
 program
     .command("update")
     .description("upgrade the core binary")
     .option("--version <tag>", "install a specific core version, e.g. v1.19.30")
-    .option("--force", "reinstall the target version and repair inconsistent Core state")
     .action(withCliErrors((opts) => runUpdate(opts)));
-program
-    .command("upgrade")
-    .description("upgrade Sash itself via npm")
-    .option("--version <version>", "install a specific Sash version")
-    .action(withCliErrors((opts) => runUpgrade(opts)));
 program
     .command("web")
-    .description("open the web dashboard (installs/starts components as needed)")
+    .description("open the web dashboard without starting the core")
     .option("--no-open", "print the URL without opening a browser")
     .action(withCliErrors((opts) => runWeb({ noOpen: !opts.open })));
 program

package/dist/commands/auto.js

@@ -0,0 +1,15 @@
+import { AutostartService } from "../autostart.js";
+import { log } from "../log.js";
+import { ensureManagement } from "../runtime-owner.js";
+import { runtimeContext } from "./shared.js";
+export async function runAuto(mode = "status", controller = {
+    inspect: () => new AutostartService().inspect(),
+    set: async (enabled) => (await ensureManagement(runtimeContext())).client.setAutostart(enabled),
+}) {
+    const status = mode === "status" ? await controller.inspect() : await controller.set(mode === "on");
+    log.kv("autostart", status.state);
+    if (status.reason)
+        log.warn(status.reason);
+    if (mode === "status" && status.state === "unknown")
+        process.exitCode = 2;
+}

package/dist/commands/lifecycle.js

@@ -1,47 +1,21 @@
 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");
-    }
+    const result = await stopRuntime(runtimeContext());
+    log.info(result.wasRunning ? "sash stopped; previous system proxy state restored" : "sash is stopped");
 }
-export async function runRestart(deps = {}) {
+export async function runRestart() {
     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}` : ""})`);
+    const { owner, result } = await restartRuntime(ctx);
+    log.ok(`core restarted (PID=${result.pid})`);
     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}`);

package/dist/commands/logs.js

@@ -1,16 +1,23 @@
 import fs from "node:fs";
 import { log } from "../log.js";
 import { followLogFile, logCursorAtEnd, normalizeLines } from "../log-follow.js";
+import { sashLayout } from "../paths.js";
 import { tailFile } from "../process.js";
 import { runtimeContext } from "./shared.js";
 export async function runLogs(opts = {}) {
-    const ctx = runtimeContext();
+    if (opts.startup && (opts.daemon || opts.errors)) {
+        throw new Error("--startup cannot be combined with --daemon or --errors");
+    }
+    const layout = opts.startup ? sashLayout() : runtimeContext().layout;
     let file;
-    if (opts.daemon) {
-        file = opts.errors ? ctx.layout.daemonErrLogFile : ctx.layout.daemonLogFile;
+    if (opts.startup) {
+        file = layout.sashLogFile;
+    }
+    else if (opts.daemon) {
+        file = opts.errors ? layout.daemonErrLogFile : layout.daemonLogFile;
     }
     else {
-        file = opts.errors ? ctx.layout.coreErrLogFile : ctx.layout.coreLogFile;
+        file = opts.errors ? layout.coreErrLogFile : layout.coreLogFile;
     }
     const lines = normalizeLines(opts.lines);
     const cursor = logCursorAtEnd(file);

package/dist/commands/shared.js

@@ -1,8 +1,6 @@
+import { loadSettings } from "../app-state.js";
 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 };
+    return { layout, settings: loadSettings(layout) };
 }

package/dist/commands/status.js

@@ -1,6 +1,5 @@
 import { log } from "../log.js";
-import { collectRuntimeStatus, formatObservedProxy, formatTunObservation, markIncompleteObservation, runtimeStatusHeadline, shouldShowTunGuidance, } from "../status.js";
-import { tunPrivilegeGuidance } from "../tun-guidance.js";
+import { collectRuntimeStatus, formatObservedProxy, markIncompleteObservation, runtimeStatusHeadline, } from "../status.js";
 import { runtimeContext } from "./shared.js";
 export async function runStatus(opts = {}, collect = () => collectRuntimeStatus(runtimeContext())) {
     const status = await collect();
@@ -14,6 +13,10 @@ export async function runStatus(opts = {}, collect = () => collectRuntimeStatus(
     if (status.queryError)
         log.warn(`status incomplete: ${status.queryError}`);
     log.kv("root", status.paths.root);
+    log.kv("autostart", status.autostart.state);
+    if (status.autostart.state === "stale" || status.autostart.state === "disabled") {
+        log.warn("Run sash auto on to repair the login startup registration");
+    }
     log.kv("config", status.paths.config);
     log.kv("mixed port", status.endpoints.mixedProxy);
     log.kv("proxy desired", status.systemProxy.desired ? "on" : "off");
@@ -27,13 +30,9 @@ export async function runStatus(opts = {}, collect = () => collectRuntimeStatus(
     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
+    log.kv("selected 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

@@ -1,5 +1,9 @@
-import { runCoreUpdate } from "../core-update-service.js";
+import { log } from "../log.js";
+import { ensureManagement } from "../runtime-owner.js";
 import { runtimeContext } from "./shared.js";
-export async function runUpdate(opts = {}, deps = {}) {
-    await runCoreUpdate(runtimeContext(), opts, deps);
+export async function runUpdate(opts = {}) {
+    const owner = await ensureManagement(runtimeContext());
+    log.info("downloading and verifying Core; the dashboard remains available");
+    const result = await owner.client.updateCore(opts.version);
+    log.ok(`core updated to ${result.version}`);
 }

package/dist/commands/web.js

@@ -1,33 +1,25 @@
 import { openInBrowser } from "../browser.js";
 import { log } from "../log.js";
-import { resolveRuntimeOwner } from "../runtime-owner.js";
-import { runStart } from "./lifecycle.js";
+import { ensureManagement } from "../runtime-owner.js";
+import { writeBootstrapFile } from "../web-bootstrap.js";
 import { runtimeContext } from "./shared.js";
-export function dashboardUrl(daemonPort) {
-    return `http://127.0.0.1:${daemonPort}/ui/`;
+export function dashboardUrl(port) {
+    return `http://127.0.0.1:${port}/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");
-    }
+export async function runWeb(opts = {}, deps = {}) {
+    const ctx = (deps.runtimeContext ?? runtimeContext)();
+    const owner = await (deps.ensureManagement ?? ensureManagement)(ctx);
     const url = dashboardUrl(owner.daemon.port);
-    log.ok(`dashboard: ${url}`);
-    if (!opts.noOpen)
-        openInBrowser(url);
+    const logger = deps.log ?? log;
+    if (!opts.noOpen) {
+        const bootstrap = await owner.client.createWebBootstrap();
+        const file = (deps.writeBootstrap ?? writeBootstrapFile)(ctx.layout, {
+            dashboardUrl: url,
+            ...bootstrap,
+        });
+        (deps.openInBrowser ?? openInBrowser)(file.fileUrl);
+    }
+    else
+        logger.info("run 'sash web' without --no-open to authorize a browser session");
+    logger.ok(`dashboard: ${url}`);
 }