@rynx-ai/cli 0.1.11-beta.5 → 0.1.11-beta.50

package/dist/autostart-environment.d.ts

@@ -0,0 +1,5 @@
+import type { AutostartRenderInput } from "./autostart.js";
+export declare function renderAutostartEnvironmentFile(input: AutostartRenderInput): string;
+export declare function serviceEnvironmentPath(input: AutostartRenderInput): string;
+export declare function currentShell(): string;
+export declare function autostartLauncherArguments(input: AutostartRenderInput, serviceFlag: string): string[];

package/dist/autostart-environment.js

@@ -0,0 +1,64 @@
+import { readlinkSync } from "node:fs";
+import { userInfo } from "node:os";
+import path from "node:path";
+// These describe a particular service invocation or IPC connection. The new
+// service/Node process supplies its own values; all other variables are captured.
+const BLOCKED_SERVICE_ENVIRONMENT = new Set([
+    "INVOCATION_ID",
+    "JOURNAL_STREAM",
+    "LISTEN_FDS",
+    "LISTEN_FDNAMES",
+    "LISTEN_PID",
+    "MAINPID",
+    "MANAGERPID",
+    "NOTIFY_SOCKET",
+    "ELECTRON_RUN_AS_NODE",
+    "NODE_CHANNEL_FD",
+    "NODE_UNIQUE_ID",
+    "PM2_HOME",
+    "RYNX_DAEMON_LIFECYCLE",
+    "RYNX_HOME",
+    "RYNX_REFRESH_LOGIN_SHELL_PATH",
+    "RYNX_SYSTEMD_SERVICE",
+    "RYNX_LAUNCHD_SERVICE",
+    "XPC_SERVICE_NAME",
+    "SYSTEMD_EXEC_PID",
+    "SYSTEMD_INVOCATION_ID",
+    "WATCHDOG_PID",
+    "WATCHDOG_USEC",
+]);
+export function renderAutostartEnvironmentFile(input) {
+    const env = { ...input.environment, PATH: input.pathEnv };
+    return Object.entries(env)
+        .filter(([name, value]) => value !== undefined &&
+        /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) &&
+        !BLOCKED_SERVICE_ENVIRONMENT.has(name))
+        .sort(([left], [right]) => left.localeCompare(right))
+        // Preserve literal newlines and quote metacharacters. The launcher parses
+        // this as data; it must not execute the assignments in a shell.
+        .map(([name, value]) => `${name}="${value.replace(/[\\"$`]/g, "\\$&")}"`)
+        .join("\n") + "\n";
+}
+export function serviceEnvironmentPath(input) {
+    return path.join(input.dataDir, "autostart.env");
+}
+export function currentShell() {
+    try {
+        const parent = readlinkSync(`/proc/${process.ppid}/exe`);
+        if (/^(?:ba|z|fi|da|k|mk|c|tc)?sh$/.test(path.basename(parent)))
+            return parent;
+    }
+    catch {
+        // The caller may be a launcher, or /proc may be unavailable.
+    }
+    return process.env.SHELL || userInfo().shell || "/bin/sh";
+}
+export function autostartLauncherArguments(input, serviceFlag) {
+    return [
+        path.join(path.dirname(input.cliPath), "autostart-launcher.js"),
+        input.shellPath ?? "/bin/sh",
+        input.cliPath,
+        input.dataDir,
+        serviceFlag,
+    ];
+}

package/dist/autostart-launcher.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/autostart-launcher.js

@@ -0,0 +1,48 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+// Keep this entry independent of CLI initialization: restore the environment
+// and initialize the user's shell before loading any Rynx runtime code.
+const [shellPath, cliPath, dataDir, serviceFlag] = process.argv.slice(2);
+if (!shellPath || !cliPath || !dataDir ||
+    (serviceFlag !== "--systemd-service" && serviceFlag !== "--launchd-service")) {
+    throw new Error("invalid autostart launcher arguments");
+}
+const contents = readFileSync(path.join(dataDir, "autostart.env"), "utf8");
+// Parse only the quoted format emitted by renderAutostartEnvironmentFile.
+// Never source assignments: a saved SHELLOPTS/UID may be readonly in a shell.
+const assignments = [...contents.matchAll(/([A-Za-z_][A-Za-z0-9_]*)="((?:\\[\\"$`]|[^"\\])*)"\n/g)];
+if (assignments.map(([assignment]) => assignment).join("") !== contents) {
+    throw new Error("invalid autostart environment snapshot");
+}
+const snapshot = Object.fromEntries(assignments.map(([, name = "", value = ""]) => [
+    name,
+    value.replace(/\\([\\"$`])/g, "$1"),
+]));
+const isCShell = /^(?:t?csh)$/.test(path.basename(shellPath));
+const command = "exec " + [
+    "/usr/bin/env",
+    `RYNX_HOME=${dataDir}`,
+    serviceFlag === "--systemd-service"
+        ? "RYNX_SYSTEMD_SERVICE=rynx.service"
+        : "RYNX_LAUNCHD_SERVICE=ai.rynx.daemon",
+    process.execPath,
+    cliPath,
+    "start",
+    serviceFlag,
+].map((value) => {
+    const quoted = `'${value.replaceAll("'", "'\\''")}'`;
+    return isCShell ? quoted.replaceAll("!", "\\!").replaceAll("\n", "\\\n") : quoted;
+}).join(" ");
+// csh/tcsh require -l on its own. Reading the command from stdin preserves
+// their login AND interactive startup, including configuration guarded by prompt.
+const result = spawnSync(shellPath, isCShell ? ["-l"] : ["-lic", command], {
+    env: { ...process.env, ...snapshot },
+    stdio: [isCShell ? "pipe" : "inherit", "inherit", "inherit"],
+    ...(isCShell ? { input: `${command}\n` } : {}),
+});
+// The shell passes its final environment directly to Rynx. Do not merge the
+// snapshot again: that would undo configuration overrides and unset operations.
+if (result.error)
+    throw result.error;
+process.exitCode = result.status ?? 1;

package/dist/autostart.d.ts

@@ -0,0 +1,29 @@
+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;
+    shellPath?: 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 an existing registration and its environment without enabling a new one. */
+export declare function refreshAutostart(): boolean;
+export declare function renderLaunchAgent(input: AutostartRenderInput): string;
+export declare function assertMacLaunchdInvocation(): void;

package/dist/autostart.js

@@ -0,0 +1,266 @@
+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 { autostartLauncherArguments, currentShell, renderAutostartEnvironmentFile, serviceEnvironmentPath, } from "./autostart-environment.js";
+import { disableLinuxAutostart, enableLinuxAutostart, inspectLinuxAutostart, refreshLinuxServiceIfPresent, } from "./systemd-service.js";
+export { renderSystemdUnit } from "./systemd-service.js";
+const LAUNCHD_LABEL = "ai.rynx.daemon";
+const LAUNCHD_SERVICE_ENV = "RYNX_LAUNCHD_SERVICE";
+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 an existing registration and its environment 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");
+    const argv = [input.nodePath, ...autostartLauncherArguments(input, "--launchd-service")];
+    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>
+${argv.map((value) => `    <string>${escapeXml(value)}</string>`).join("\n")}
+  </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>
+    <key>${LAUNCHD_SERVICE_ENV}</key>
+    <string>${LAUNCHD_LABEL}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(outLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(errLog)}</string>
+</dict>
+</plist>
+`;
+}
+export function assertMacLaunchdInvocation() {
+    if (process.platform !== "darwin") {
+        throw new Error("--launchd-service is only valid on macOS");
+    }
+    if (process.env[LAUNCHD_SERVICE_ENV] !== LAUNCHD_LABEL) {
+        throw new Error("--launchd-service requires the Rynx launchd environment");
+    }
+}
+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)),
+        environment: process.env,
+        nodePath: process.execPath,
+        pathEnv: process.env.PATH || defaultPath(),
+        shellPath: currentShell(),
+    };
+}
+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);
+    const changed = previous !== content;
+    const environmentPath = serviceEnvironmentPath(context);
+    const environment = renderAutostartEnvironmentFile(context);
+    const previousEnvironment = existsSync(environmentPath)
+        ? readFileSync(environmentPath, "utf8")
+        : undefined;
+    const environmentChanged = previousEnvironment !== environment;
+    if (!changed && !environmentChanged)
+        return false;
+    const wasLoaded = changed && launchctlLoaded();
+    const restore = () => {
+        if (environmentChanged)
+            restoreRegistrationFile(environmentPath, previousEnvironment, 0o600);
+        if (changed)
+            restoreRegistrationFile(registrationPath, previous);
+    };
+    try {
+        if (environmentChanged)
+            replaceFileAtomically(environmentPath, environment, 0o600);
+        if (changed)
+            replaceFileAtomically(registrationPath, content);
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+    // An environment-only refresh needs no reload: the job reads it on every run.
+    if (!wasLoaded)
+        return true;
+    if (!launchctlBootout(registrationPath)) {
+        restore();
+        throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}; the previous file was restored`);
+    }
+    if (launchctlBootstrap(registrationPath))
+        return true;
+    restore();
+    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 });
+    rmSync(serviceEnvironmentPath(context), { 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, mode = 0o644) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        writeFileSync(temporary, content, {
+            encoding: "utf8",
+            flag: "wx",
+            mode,
+        });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function restoreRegistrationFile(file, previous, mode = 0o644) {
+    if (previous === undefined)
+        rmSync(file, { force: true });
+    else
+        replaceFileAtomically(file, previous, mode);
+}

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

@@ -1,22 +1,22 @@
 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 = "exec" | "install" | "update" | "version" | "clean" | "open" | "status" | "pages" | "endpoint" | "headers" | "close";
 export interface BrowserCliArgs {
     subcommand: BrowserCliSubcommand;
     json: boolean;
     ensure: boolean;
+    argv?: string[];
     channel?: string;
     version?: string;
     runtime?: string;
     session?: string;
+    page?: string;
     url?: string;
-    ref?: string;
-    selector?: string;
-    text?: string;
-    output?: string;
-    format?: "png" | "jpeg" | "webp";
-    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

@@ -1,4 +1,5 @@
 const SPECS = {
+    exec: { values: ["--session", "--page"], flags: ["--json"] },
     install: { values: ["--channel", "--version"], flags: ["--json"] },
     update: { values: ["--channel"], flags: ["--json"] },
     version: { values: [], flags: ["--json"] },
@@ -11,35 +12,31 @@ const SPECS = {
     status: { values: ["--session", "--runtime"], flags: ["--json"] },
     pages: { values: ["--session", "--runtime"], flags: ["--json"] },
     endpoint: { values: ["--session"], flags: ["--ensure", "--json"] },
-    snapshot: { values: ["--session"], flags: ["--json"] },
-    navigate: {
-        values: ["--url", "--session"],
-        flags: ["--json"],
-        positionalUrl: true,
-    },
-    click: {
-        values: ["--ref", "--selector", "--x", "--y", "--session"],
-        flags: ["--json"],
-    },
-    type: {
-        values: ["--ref", "--selector", "--text", "--session"],
-        flags: ["--json"],
-    },
-    screenshot: {
-        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) {
+    let argv;
+    if (args[0] === "exec") {
+        const boundary = args.indexOf("--");
+        if (boundary < 1 || boundary === args.length - 1)
+            throw new Error("browser exec: use rynx browser exec [--page <id>] -- <agent-browser command and arguments>");
+        argv = args.slice(boundary + 1);
+        args = args.slice(0, boundary);
+    }
     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");
+            "exec, headers, or close; page actions use browser exec -- <agent-browser command>");
     }
     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 +48,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,69 +66,63 @@ 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 = {
         subcommand,
         json: flags.has("--json"),
         ensure: flags.has("--ensure"),
+        ...(argv ? { argv } : {}),
         ...(values.has("--channel") ? { channel: values.get("--channel") } : {}),
         ...(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]
+        ...(values.has("--page") ? { page: nonEmpty(values.get("--page"), "--page") } : {}),
+        ...(spec.positionalUrl && (values.has("--url") || positionals[0])
             ? { url: values.get("--url") ?? positionals[0] }
             : {}),
     };
-    if (values.has("--ref"))
-        result.ref = nonEmpty(values.get("--ref"), "--ref");
-    if (values.has("--selector"))
-        result.selector = nonEmpty(values.get("--selector"), "--selector");
-    if (values.has("--text"))
-        result.text = values.get("--text");
-    if (values.has("--output"))
-        result.output = nonEmpty(values.get("--output"), "--output");
-    if (values.has("--format")) {
-        const format = values.get("--format");
-        if (format !== "png" && format !== "jpeg" && format !== "webp") {
-            throw new Error(`browser screenshot: --format must be png, jpeg, or webp`);
+    if (subcommand === "headers") {
+        const action = positionals[0];
+        if (action !== "get" && action !== "set") {
+            throw new Error("browser headers: expected get or set");
         }
-        result.format = format;
-    }
-    if (values.has("--quality")) {
-        result.quality = integer(values.get("--quality"), "--quality", 0, 100);
-    }
-    if (values.has("--x"))
-        result.x = finiteNumber(values.get("--x"), "--x");
-    if (values.has("--y"))
-        result.y = finiteNumber(values.get("--y"), "--y");
-    if (subcommand === "navigate" && !result.url) {
-        throw new Error("browser navigate: URL is required");
-    }
-    if (subcommand === "click") {
-        const targets = Number(result.ref !== undefined)
-            + Number(result.selector !== undefined)
-            + Number(result.x !== undefined || result.y !== undefined);
-        if (targets !== 1 || (result.x === undefined) !== (result.y === undefined)) {
-            throw new Error("browser click: pass exactly one of --ref, --selector, or both --x and --y");
+        if (flags.has("--enable") && flags.has("--disable")) {
+            throw new Error("browser headers set: choose either --enable or --disable");
         }
-    }
-    if (subcommand === "type") {
-        if ((result.ref === undefined) === (result.selector === undefined)) {
-            throw new Error("browser type: pass exactly one of --ref or --selector");
+        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 (result.text === undefined)
-            throw new Error("browser type: --text is required");
-    }
-    if (subcommand === "screenshot" && !result.output) {
-        throw new Error("browser screenshot: --output is required");
     }
     return result;
 }
@@ -166,16 +161,3 @@ function nonEmpty(value, option) {
         throw new Error(`${option} must not be empty`);
     return value;
 }
-function finiteNumber(value, option) {
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed))
-        throw new Error(`${option} must be a finite number`);
-    return parsed;
-}
-function integer(value, option, minimum, maximum) {
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum) {
-        throw new Error(`${option} must be an integer from ${minimum} to ${maximum}`);
-    }
-    return parsed;
-}

package/dist/commands/autostart.d.ts

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