@astralyn/sash 0.1.1 → 0.1.2

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

@@ -6,25 +6,15 @@ export async function runStart() {
     const { owner, result } = await ensureRunning(ctx);
     log.ok(`core started (PID=${result.pid}${result.version ? `, version ${result.version}` : ""})`);
     printEndpoints(ctx, owner.daemon.port);
-    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);
 }
 export function printEndpoints(ctx, daemonPort) {

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

@@ -13,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");
@@ -26,7 +30,7 @@ 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("core version", status.core.installedVersion || "(not installed)");

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,61 +1,25 @@
 import { openInBrowser } from "../browser.js";
 import { log } from "../log.js";
-import { resolveRuntimeOwner } from "../runtime-owner.js";
+import { ensureManagement } from "../runtime-owner.js";
 import { writeBootstrapFile } from "../web-bootstrap.js";
-import { runStart } from "./lifecycle.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 = {}, deps = {}) {
-    const logger = deps.log ?? log;
-    const resolve = deps.resolveRuntimeOwner ?? resolveRuntimeOwner;
     const ctx = (deps.runtimeContext ?? runtimeContext)();
-    let owner = await resolve(ctx);
-    let coreRunning = null;
-    if (owner.kind === "daemon") {
-        try {
-            coreRunning = (await owner.client.status()).core.running;
-        }
-        catch {
-            logger.warn("Core state is unavailable; opening the dashboard for recovery.");
-        }
-    }
-    if (owner.kind === "offline" || coreRunning === false) {
-        logger.info("sash is not running; starting it first...");
-        let started = false;
-        try {
-            await (deps.runStart ?? runStart)();
-            started = true;
-        }
-        catch (error) {
-            try {
-                owner = await resolve(ctx);
-            }
-            catch {
-                throw error;
-            }
-            if (owner.kind !== "daemon")
-                throw error;
-            logger.warn(`Core startup failed; opening the dashboard for recovery: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        if (started)
-            owner = await resolve(ctx);
-    }
-    if (owner.kind !== "daemon") {
-        throw new Error("sashd did not become healthy before opening the dashboard");
-    }
+    const owner = await (deps.ensureManagement ?? ensureManagement)(ctx);
     const url = dashboardUrl(owner.daemon.port);
-    if (opts.noOpen) {
-        logger.ok(`dashboard: ${url}`);
-        logger.info("run 'sash web' without --no-open to authorize a browser session");
-        return;
+    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);
     }
-    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}`);
 }