@rynx-ai/cli 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/autostart.d.ts

@@ -0,0 +1,27 @@
+export { renderSystemdUnit } from "./systemd-service.js";
+export type AutostartManager = "launchd" | "systemd-user" | "unsupported";
+export interface AutostartState {
+    supported: boolean;
+    registered: boolean;
+    active?: boolean;
+    lingerEnabled?: boolean;
+    lingerEnableCommand?: string;
+    manager: AutostartManager;
+    registrationPath?: string;
+    detail?: string;
+}
+export interface AutostartRenderInput {
+    cliPath: string;
+    dataDir: string;
+    environment?: NodeJS.ProcessEnv;
+    logDir: string;
+    nodePath: string;
+    pathEnv: string;
+}
+export declare function autostartPlatformLabel(platform?: NodeJS.Platform): string | undefined;
+export declare function inspectAutostart(): AutostartState;
+export declare function enableAutostart(): AutostartState;
+export declare function disableAutostart(): AutostartState;
+/** Refresh paths in an existing registration without enabling a new one. */
+export declare function refreshAutostart(): boolean;
+export declare function renderLaunchAgent(input: AutostartRenderInput): string;

package/dist/autostart.js

@@ -0,0 +1,229 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { rynxHome } from "@rynx-ai/core";
+import { disableLinuxAutostart, enableLinuxAutostart, inspectLinuxAutostart, refreshLinuxServiceIfPresent, } from "./systemd-service.js";
+export { renderSystemdUnit } from "./systemd-service.js";
+const LAUNCHD_LABEL = "ai.rynx.daemon";
+const COMMAND_TIMEOUT_MS = 5_000;
+export function autostartPlatformLabel(platform = process.platform) {
+    if (platform === "darwin")
+        return "macOS LaunchAgent";
+    if (platform === "linux")
+        return "Linux user systemd";
+    return undefined;
+}
+export function inspectAutostart() {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        return unsupportedState();
+    }
+    const context = currentContext();
+    return process.platform === "darwin" ? inspectMac(context) : inspectLinuxAutostart();
+}
+export function enableAutostart() {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        throw new Error(`Rynx autostart is not supported on ${process.platform}`);
+    }
+    const context = currentContext();
+    if (process.platform === "darwin")
+        enableMac(context);
+    else
+        enableLinuxAutostart();
+    return inspectAutostart();
+}
+export function disableAutostart() {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        throw new Error(`Rynx autostart is not supported on ${process.platform}`);
+    }
+    const context = currentContext();
+    if (process.platform === "darwin")
+        disableMac(context);
+    else
+        disableLinuxAutostart();
+    return inspectAutostart();
+}
+/** Refresh paths in an existing registration without enabling a new one. */
+export function refreshAutostart() {
+    if (process.platform === "darwin") {
+        const context = currentContext();
+        const registrationPath = launchAgentPath(context);
+        if (!existsSync(registrationPath))
+            return false;
+        return syncMacRegistration(context);
+    }
+    if (process.platform === "linux")
+        return refreshLinuxServiceIfPresent();
+    return false;
+}
+function unsupportedState() {
+    return {
+        supported: false,
+        registered: false,
+        manager: "unsupported",
+        detail: `Rynx autostart is not supported on ${process.platform}`,
+    };
+}
+export function renderLaunchAgent(input) {
+    const outLog = path.join(input.logDir, "autostart-out.log");
+    const errLog = path.join(input.logDir, "autostart-err.log");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(LAUNCHD_LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(input.nodePath)}</string>
+    <string>${escapeXml(input.cliPath)}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(input.dataDir)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(input.pathEnv)}</string>
+    <key>RYNX_HOME</key>
+    <string>${escapeXml(input.dataDir)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(outLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(errLog)}</string>
+</dict>
+</plist>
+`;
+}
+function currentContext() {
+    const dataDir = rynxHome();
+    const homeDir = homedir();
+    return {
+        homeDir,
+        dataDir,
+        logDir: path.join(dataDir, "logs"),
+        cliPath: fileURLToPath(new URL("./cli.js", import.meta.url)),
+        nodePath: process.execPath,
+        pathEnv: process.env.PATH || defaultPath(),
+    };
+}
+function defaultPath() {
+    if (process.platform === "darwin") {
+        return "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+    }
+    return "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+}
+function launchAgentPath(context) {
+    return path.join(context.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function inspectMac(context) {
+    const registrationPath = launchAgentPath(context);
+    return {
+        supported: true,
+        registered: existsSync(registrationPath),
+        active: launchctlLoaded(),
+        manager: "launchd",
+        registrationPath,
+    };
+}
+function enableMac(context) {
+    mkdirSync(context.logDir, { recursive: true, mode: 0o700 });
+    syncMacRegistration(context);
+}
+function syncMacRegistration(context) {
+    const registrationPath = launchAgentPath(context);
+    const previous = existsSync(registrationPath)
+        ? readFileSync(registrationPath, "utf8")
+        : undefined;
+    const content = renderLaunchAgent(context);
+    if (previous === content)
+        return false;
+    const wasLoaded = launchctlLoaded();
+    replaceFileAtomically(registrationPath, content);
+    if (!wasLoaded)
+        return true;
+    if (!launchctlBootout(registrationPath)) {
+        restoreRegistrationFile(registrationPath, previous);
+        throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}; the previous file was restored`);
+    }
+    if (launchctlBootstrap(registrationPath))
+        return true;
+    restoreRegistrationFile(registrationPath, previous);
+    if (previous !== undefined && launchctlBootstrap(registrationPath)) {
+        throw new Error(`launchctl could not load the updated registration; the previous job was restored`);
+    }
+    throw new Error(`launchctl could not load the updated registration and could not restore the previous job`);
+}
+function disableMac(context) {
+    const registrationPath = launchAgentPath(context);
+    if (launchctlLoaded() && !launchctlBootout(registrationPath)) {
+        throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}`);
+    }
+    rmSync(registrationPath, { force: true });
+}
+function launchctlLoaded() {
+    const uid = userInfo().uid;
+    return run("launchctl", ["print", `gui/${uid}/${LAUNCHD_LABEL}`]).status === 0;
+}
+function launchctlBootstrap(registrationPath) {
+    const uid = userInfo().uid;
+    const modern = run("launchctl", [
+        "bootstrap",
+        `gui/${uid}`,
+        registrationPath,
+    ]);
+    if (modern.status === 0)
+        return true;
+    return run("launchctl", ["load", "-w", registrationPath]).status === 0;
+}
+function launchctlBootout(registrationPath) {
+    const uid = userInfo().uid;
+    const modern = run("launchctl", [
+        "bootout",
+        `gui/${uid}/${LAUNCHD_LABEL}`,
+    ]);
+    if (modern.status === 0)
+        return true;
+    return run("launchctl", ["unload", "-w", registrationPath]).status === 0;
+}
+function run(command, args) {
+    return spawnSync(command, [...args], {
+        encoding: "utf8",
+        stdio: "pipe",
+        timeout: COMMAND_TIMEOUT_MS,
+        killSignal: "SIGTERM",
+    });
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function replaceFileAtomically(file, content) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        writeFileSync(temporary, content, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o644,
+        });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function restoreRegistrationFile(file, previous) {
+    if (previous === undefined)
+        rmSync(file, { force: true });
+    else
+        replaceFileAtomically(file, previous);
+}

package/dist/browser-cli-args.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeBrowserBootstrapCredential } from "@rynx-ai/protocol/runtime-browser-bootstrap";
-export type BrowserCliSubcommand = "install" | "update" | "version" | "clean" | "open" | "status" | "pages" | "endpoint" | "snapshot" | "navigate" | "click" | "type" | "screenshot" | "close";
+export type BrowserCliSubcommand = "install" | "update" | "version" | "clean" | "open" | "status" | "pages" | "endpoint" | "snapshot" | "navigate" | "click" | "type" | "screenshot" | "headers" | "close";
 export interface BrowserCliArgs {
     subcommand: BrowserCliSubcommand;
     json: boolean;
@@ -17,6 +17,12 @@ export interface BrowserCliArgs {
     quality?: number;
     x?: number;
     y?: number;
+    headersAction?: "get" | "set";
+    headers?: string[];
+    expectedRevision?: string;
+    headersEnabled?: boolean;
+    clearHeaders?: boolean;
+    showHeaderValues?: boolean;
 }
 export interface BrowserCliTarget {
     runtimeSelector: string;

package/dist/browser-cli-args.js

@@ -29,17 +29,23 @@ const SPECS = {
         values: ["--output", "--format", "--quality", "--session"],
         flags: ["--json"],
     },
+    headers: {
+        values: ["--session", "--runtime", "--header", "--expected-revision"],
+        flags: ["--json", "--enable", "--disable", "--clear", "--show-values"],
+        positionalAction: true,
+    },
     close: { values: ["--session", "--runtime"], flags: ["--json"] },
 };
 export function parseBrowserCliArgs(args) {
     const subcommand = args[0];
     if (!isBrowserSubcommand(subcommand)) {
         throw new Error("browser: expected install, update, version, clean, open, status, pages, endpoint, " +
-            "snapshot, navigate, click, type, screenshot, or close");
+            "snapshot, navigate, click, type, screenshot, headers, or close");
     }
     const spec = SPECS[subcommand];
     const values = new Map();
     const flags = new Set();
+    const headerValues = [];
     const positionals = [];
     for (let index = 1; index < args.length; index += 1) {
         const arg = args[index];
@@ -51,13 +57,17 @@ export function parseBrowserCliArgs(args) {
                 continue;
             }
             if (spec.values.includes(arg)) {
-                if (values.has(arg))
+                if (arg !== "--header" && values.has(arg)) {
                     throw new Error(`browser ${subcommand}: duplicate option ${arg}`);
+                }
                 const value = args[index + 1];
                 if (!value || value.startsWith("--")) {
                     throw new Error(`browser ${subcommand}: ${arg} requires a value`);
                 }
-                values.set(arg, value);
+                if (arg === "--header")
+                    headerValues.push(value);
+                else
+                    values.set(arg, value);
                 index += 1;
                 continue;
             }
@@ -65,13 +75,13 @@ export function parseBrowserCliArgs(args) {
         }
         positionals.push(arg);
     }
-    if (!spec.positionalUrl && positionals.length > 0) {
+    if (!spec.positionalUrl && !spec.positionalAction && positionals.length > 0) {
         throw new Error(`browser ${subcommand}: unexpected argument ${positionals[0]}`);
     }
     if (positionals.length > 1) {
         throw new Error(`browser ${subcommand}: unexpected extra argument ${positionals[1]}`);
     }
-    if (positionals.length === 1 && values.has("--url")) {
+    if (spec.positionalUrl && positionals.length === 1 && values.has("--url")) {
         throw new Error("browser open: pass the URL once, either positionally or with --url");
     }
     const result = {
@@ -82,10 +92,45 @@ export function parseBrowserCliArgs(args) {
         ...(values.has("--version") ? { version: values.get("--version") } : {}),
         ...(values.has("--runtime") ? { runtime: values.get("--runtime") } : {}),
         ...(values.has("--session") ? { session: values.get("--session") } : {}),
-        ...(values.has("--url") || positionals[0]
+        ...(spec.positionalUrl && (values.has("--url") || positionals[0])
             ? { url: values.get("--url") ?? positionals[0] }
             : {}),
     };
+    if (subcommand === "headers") {
+        const action = positionals[0];
+        if (action !== "get" && action !== "set") {
+            throw new Error("browser headers: expected get or set");
+        }
+        if (flags.has("--enable") && flags.has("--disable")) {
+            throw new Error("browser headers set: choose either --enable or --disable");
+        }
+        result.headersAction = action;
+        if (headerValues.length > 0)
+            result.headers = headerValues;
+        if (values.has("--expected-revision")) {
+            result.expectedRevision = nonEmpty(values.get("--expected-revision"), "--expected-revision");
+        }
+        if (flags.has("--enable"))
+            result.headersEnabled = true;
+        if (flags.has("--disable"))
+            result.headersEnabled = false;
+        if (flags.has("--clear"))
+            result.clearHeaders = true;
+        if (flags.has("--show-values"))
+            result.showHeaderValues = true;
+        if (action === "get" && (headerValues.length > 0 ||
+            result.expectedRevision !== undefined ||
+            result.headersEnabled !== undefined ||
+            result.clearHeaders)) {
+            throw new Error("browser headers get: update options are not allowed");
+        }
+        if (action === "set" && result.showHeaderValues) {
+            throw new Error("browser headers set: --show-values is only valid with get");
+        }
+        if (action === "set" && headerValues.length > 0 && result.clearHeaders) {
+            throw new Error("browser headers set: --clear cannot be combined with --header");
+        }
+    }
     if (values.has("--ref"))
         result.ref = nonEmpty(values.get("--ref"), "--ref");
     if (values.has("--selector"))

package/dist/commands/autostart.d.ts

@@ -0,0 +1 @@
+export declare function runAutostartCommand(args: readonly string[]): Promise<number>;

package/dist/commands/autostart.js

@@ -0,0 +1,58 @@
+import { autostartPlatformLabel, disableAutostart, enableAutostart, inspectAutostart, } from "../autostart.js";
+import { fail } from "./errors.js";
+export async function runAutostartCommand(args) {
+    if (process.env.RYNX_DISTRIBUTION === "app") {
+        fail("Rynx App manages startup. Use the App's launch-at-login setting.");
+    }
+    const [action, ...rest] = args;
+    if (rest.length > 0)
+        fail(`autostart: unexpected argument ${rest[0]}`);
+    if (action === "enable") {
+        const state = enableAutostart();
+        console.log(`Rynx autostart enabled with ${autostartPlatformLabel() ?? state.manager}.`);
+        if (state.registrationPath)
+            console.log(`Registration: ${state.registrationPath}`);
+        console.log("Rynx will start at the next login. Start it now with `rynx start`.");
+        printLingerWarning(state);
+        return 0;
+    }
+    if (action === "disable") {
+        const state = disableAutostart();
+        console.log("Rynx autostart disabled.");
+        console.log("The running daemon was not stopped; use `rynx stop` if needed.");
+        if (state.registered) {
+            console.warn("An autostart registration is still present; run `rynx autostart status`.");
+            return 1;
+        }
+        return 0;
+    }
+    if (action === "status") {
+        printAutostartState(inspectAutostart());
+        return 0;
+    }
+    fail("Usage: rynx autostart <enable|disable|status>");
+}
+function printAutostartState(state) {
+    console.log(`manager: ${state.manager}`);
+    console.log(`supported: ${state.supported ? "yes" : "no"}`);
+    console.log(`registered: ${state.registered ? "yes" : "no"}`);
+    if (state.active !== undefined) {
+        console.log(`active: ${state.active ? "yes" : "no"}`);
+    }
+    if (state.lingerEnabled !== undefined) {
+        console.log(`linger: ${state.lingerEnabled ? "yes" : "no"}`);
+    }
+    if (state.registrationPath) {
+        console.log(`registration: ${state.registrationPath}`);
+    }
+    if (state.detail)
+        console.log(`detail: ${state.detail}`);
+}
+function printLingerWarning(state) {
+    if (state.manager !== "systemd-user" || state.lingerEnabled !== false)
+        return;
+    console.warn("Linger is disabled; Rynx stops when this user logs out.");
+    if (state.lingerEnableCommand) {
+        console.warn(`To keep it running across logout and start it before login, run manually: ${state.lingerEnableCommand}`);
+    }
+}

package/dist/commands/browser.d.ts

@@ -1 +1,5 @@
+import type { RuntimeBrowserRequestHeadersPolicy } from "@rynx-ai/protocol/runtime-browser";
 export declare function runBrowserCommand(args: readonly string[]): Promise<number>;
+export declare function projectRequestHeadersPolicyForOutput(policy: RuntimeBrowserRequestHeadersPolicy, showValues: boolean): RuntimeBrowserRequestHeadersPolicy & {
+    valuesRedacted: boolean;
+};

package/dist/commands/browser.js

@@ -4,6 +4,7 @@ import { connectBrowserAutomation, } from "@rynx-ai/browser-cdp";
 import WebSocket from "ws";
 import { parseBrowserCliArgs, resolveBrowserCliTarget, } from "../browser-cli-args.js";
 import { callManagedRuntimeBrowser, callResidentRuntime, getResidentRuntimeLocalBrowserAutomationAccess, getResidentRuntimeLocalBrowserEndpoint, readOptionalManagedRuntimeBrowserCredential, } from "../control-client.js";
+import { createProgressDisplay } from "../progress-display.js";
 import { fail } from "./errors.js";
 export async function runBrowserCommand(args) {
     let parsed;
@@ -20,9 +21,18 @@ export async function runBrowserCommand(args) {
         const channel = browserReleaseChannel(parsed.channel);
         const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
         const artifacts = createBrowserArtifactManagementService();
-        const result = parsed.subcommand === "install"
-            ? await artifacts.install(parsed.version ? { version: parsed.version } : { channel }, parsed.json ? {} : { onProgress: (message) => console.error(message) })
-            : await artifacts.update({ channel }, parsed.json ? {} : { onProgress: (message) => console.error(message) });
+        const progress = parsed.json ? undefined : createProgressDisplay();
+        progress?.start(parsed.subcommand === "install" ? "正在安装 Rynx Browser" : "正在更新 Rynx Browser");
+        let result;
+        try {
+            result = parsed.subcommand === "install"
+                ? await artifacts.install(parsed.version ? { version: parsed.version } : { channel }, progress ? { onProgress: (message) => progress.update(message) } : {})
+                : await artifacts.update({ channel }, progress ? { onProgress: (message) => progress.update(message) } : {});
+        }
+        catch (error) {
+            progress?.clear();
+            throw error;
+        }
         if (parsed.json) {
             console.log(JSON.stringify({
                 resolved: result.resolved,
@@ -30,9 +40,7 @@ export async function runBrowserCommand(args) {
             }, null, 2));
         }
         else {
-            for (const message of result.messages)
-                console.log(message);
-            console.log(`Active Browser engine: Chrome for Testing ${result.installed.version}.`);
+            progress.succeed(`Rynx Browser 已就绪：Chrome for Testing ${result.installed.version}`);
         }
         return 0;
     }
@@ -75,6 +83,30 @@ export async function runBrowserCommand(args) {
         return 0;
     }
     const target = await resolveBrowserTarget(parsed);
+    if (parsed.subcommand === "headers") {
+        const current = await callBrowserRuntime(target, "browser.request-headers.get", {
+            sessionId: target.sessionId,
+        });
+        if (parsed.headersAction === "get") {
+            if (parsed.showHeaderValues && target.credential) {
+                fail("browser headers get: --show-values is unavailable inside a managed Session; " +
+                    "use the Session settings UI");
+            }
+            printRequestHeadersPolicy(current, parsed.json, parsed.showHeaderValues === true);
+            return 0;
+        }
+        const headers = parsed.clearHeaders
+            ? []
+            : parsed.headers?.map(parseCliRequestHeader) ?? current.headers;
+        const updated = await callBrowserRuntime(target, "browser.request-headers.set", {
+            sessionId: target.sessionId,
+            expectedRevision: parsed.expectedRevision ?? current.revision,
+            enabled: parsed.headersEnabled ?? current.enabled,
+            headers,
+        });
+        printRequestHeadersPolicy(updated, parsed.json, false);
+        return 0;
+    }
     if (isAutomationCommand(parsed.subcommand)) {
         return runBrowserAutomation(parsed, target);
     }
@@ -244,6 +276,43 @@ function printBrowserPages(state) {
         console.log(`${marker} ${page.pageId}  ${page.url}${title}`);
     }
 }
+function parseCliRequestHeader(value) {
+    const separator = value.indexOf(":");
+    if (separator <= 0) {
+        fail("browser headers set: --header must use 'Name: value'");
+    }
+    const name = value.slice(0, separator).trim();
+    const rawValue = value.slice(separator + 1);
+    return {
+        name,
+        value: rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue,
+    };
+}
+function printRequestHeadersPolicy(policy, json, showValues) {
+    const output = projectRequestHeadersPolicyForOutput(policy, showValues);
+    if (json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log(`Browser request headers ${output.enabled ? "enabled" : "disabled"} · revision ${output.revision}`);
+    if (output.headers.length === 0) {
+        console.log("  (no configured headers)");
+        return;
+    }
+    for (const header of output.headers)
+        console.log(`  ${header.name}: ${header.value}`);
+}
+export function projectRequestHeadersPolicyForOutput(policy, showValues) {
+    return {
+        enabled: policy.enabled,
+        revision: policy.revision,
+        valuesRedacted: !showValues,
+        headers: policy.headers.map((header) => ({
+            name: header.name,
+            value: showValues ? header.value : "[redacted]",
+        })),
+    };
+}
 function isAutomationCommand(subcommand) {
     return subcommand === "snapshot"
         || subcommand === "navigate"

package/dist/commands/lifecycle.d.ts

@@ -1 +1,3 @@
-export declare function runLifecycleCommand(command: string, args: readonly string[]): Promise<number>;
+export declare function runLifecycleCommand(command: string, args: readonly string[], options?: {
+    quiet?: boolean;
+}): Promise<number>;

package/dist/commands/lifecycle.js

@@ -1,14 +1,31 @@
 import { startStandaloneDaemon, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.js";
+import { refreshAutostart } from "../autostart.js";
+import { assertLinuxSystemdInvocation, stopLinuxServiceIfActive, } from "../systemd-service.js";
 import { fail } from "./errors.js";
-export async function runLifecycleCommand(command, args) {
+const SYSTEMD_SERVICE_FLAG = "--systemd-service";
+export async function runLifecycleCommand(command, args, options = {}) {
+    if (args.length === 1 && args[0] === SYSTEMD_SERVICE_FLAG) {
+        assertLinuxSystemdInvocation();
+        if (command === "start")
+            return startStandaloneDaemon();
+        if (command === "stop")
+            return stopStandaloneDaemon();
+        fail(`${SYSTEMD_SERVICE_FLAG} is only valid for start and stop`);
+    }
     if (args.length > 0)
         fail(`${command}: unexpected argument ${args[0]}`);
     switch (command) {
-        case "start":
-            return startStandaloneDaemon();
-        case "restart":
-            return startStandaloneDaemon({ restart: true });
+        case "start": {
+            refreshAutostart();
+            return startStandaloneDaemon(options.quiet ? { quiet: true } : undefined);
+        }
+        case "restart": {
+            refreshAutostart();
+            return startStandaloneDaemon({ restart: true, quiet: options.quiet });
+        }
         case "stop":
+            if (stopLinuxServiceIfActive())
+                return 0;
             return stopStandaloneDaemon();
         case "status":
             return statusStandaloneDaemon();