om-memory-system 4.9.0 → 4.10.0

package/dist/cli/web-command.js

@@ -123,7 +123,7 @@ export async function runWebCommand(args, options = {}, online, handover = {}) {
     process.once("SIGTERM", stop);
     // The page's Stop and Restart buttons reach the same process through this callback.
     const { createPowerAction } = await import("./web-power.js");
-    server.setOnPowerAction(createPowerAction({
+    const powerAction = createPowerAction({
         stopServer: async () => {
             clearInterval(keeper);
             process.off("SIGINT", stop);
@@ -140,7 +140,16 @@ export async function runWebCommand(args, options = {}, online, handover = {}) {
         baseUrl: server.getUrl(),
         loginItem: action === "--login-item",
         autostart: options,
-    }));
+    });
+    server.setOnPowerAction(powerAction);
+    // The update button installs the npm release and restarts onto it through the launcher.
+    const { startWebUpdate } = await import("../services/web-update-runtime.js");
+    const { launcherPath } = await import("../services/runtime-record.js");
+    const { ommsDir } = await import("../services/runtime-handoff.js");
+    const { existsSync } = await import("node:fs");
+    // Every restart onto the new copy runs the launcher, the login item's included.
+    const canRestart = () => existsSync(launcherPath(ommsDir()));
+    server.setWebUpdate(startWebUpdate(() => powerAction("update"), canRestart));
     // A newer `web install` asked this web app to give up the port.
     server.setOnStepAside(async () => {
         clearInterval(keeper);

package/dist/cli/web-power.d.ts

@@ -1,6 +1,8 @@
 import type { WebAutostartOptions } from "../services/web-autostart.js";
 /** The two choices the page offers; the web server passes them through unchanged. */
 export type PowerAction = "stop" | "restart";
+/** A restart through the launcher, so the newest copy on the machine serves after an update. */
+export type ProcessAction = PowerAction | "update";
 interface SpawnedChild {
     pid?: number;
     unref(): void;
@@ -16,6 +18,7 @@ export interface PowerDeps {
         stdio: "ignore";
         cwd: string;
         windowsHide: true;
+        env: NodeJS.ProcessEnv;
     }) => SpawnedChild;
     /** Restart the login item through the service manager. False when it cannot. */
     restartLoginItem: () => boolean | Promise<boolean>;
@@ -23,14 +26,29 @@ export interface PowerDeps {
     writeStartLock: (pid: number) => void | Promise<void>;
     /** Remove the start lock when it names `pid`. */
     removeStartLock: (pid: number) => void | Promise<void>;
-    /** True when an OMMS web app answers health at `baseUrl`. */
-    probe: (baseUrl: string) => Promise<boolean>;
+    /**
+     * The OMMS web app that answers at `baseUrl`, or null when none does. The
+     * version is null when this process may not read it, for example behind basic auth.
+     */
+    readOwner: (baseUrl: string) => Promise<{
+        instance: string;
+        version: string | null;
+    } | null>;
+    /** Ask the web app at `baseUrl` to step aside for `version`. True when it agrees. */
+    stepAside: (baseUrl: string, version: string) => Promise<boolean>;
+    /** The instance id the copy reports, so the handoff knows its own copy. */
+    newInstance: () => string;
+    /** The version on disk now; an in-place upgrade changes it after this process started. */
+    version: () => string;
+    env: NodeJS.ProcessEnv;
     sleep: (ms: number) => Promise<void>;
     now: () => number;
     exit: (code: number) => void;
     /** The runtime and arguments of this process, for a detached copy. */
     execPath: string;
     args: string[];
+    /** The launcher at `~/.omms/bin`, or null when it is missing. */
+    launcher: string | null;
     cwd: string;
     pid: number;
     log: (message: string, data: Record<string, unknown>) => void | Promise<void>;
@@ -51,5 +69,5 @@ export declare function createPowerAction(options: {
     loginItem: boolean;
     autostart?: WebAutostartOptions;
     deps?: Partial<PowerDeps>;
-}): (action: PowerAction) => Promise<void>;
+}): (action: ProcessAction) => Promise<string | undefined>;
 export {};

package/dist/cli/web-power.js

@@ -1,10 +1,24 @@
 import { spawn as nodeSpawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
+import { packageVersion } from "../services/package-version.js";
+import { ommsDir } from "../services/runtime-handoff.js";
+import { launcherPath } from "../services/runtime-record.js";
+import { compareVersions } from "../services/version-compare.js";
 /** How long a fresh copy must stay up before the old process stops serving. */
 const SPAWN_CHECK_MS = 1_000;
 /** How long the old process waits for the copy to answer before it serves again. */
 export const HANDOFF_WAIT_MS = 15_000;
 const HANDOFF_POLL_MS = 250;
+let tokenHeader = null;
+/** The web app runs on this machine, so the local token file is enough. Read once. */
+function localTokenHeader() {
+    tokenHeader ??= import("../services/auth-token.js").then(({ AUTH_HEADER, getOrCreateAuthToken }) => ({
+        [AUTH_HEADER]: getOrCreateAuthToken(),
+    }));
+    return tokenHeader;
+}
 function productionDeps(options) {
     return {
         spawn: nodeSpawn,
@@ -14,23 +28,55 @@ function productionDeps(options) {
             nodeLockFs.replace(startLockPath(), JSON.stringify({ pid, at: Date.now() }));
         },
         removeStartLock: async (pid) => (await import("../services/web-ensure.js")).removeStartLockFor(pid),
-        probe: async (baseUrl) => {
+        readOwner: async (baseUrl) => {
+            // Health skips basic auth, so a restart can find its copy with basic auth on.
+            let instance;
+            try {
+                const health = await fetch(`${baseUrl}/api/health`, { signal: AbortSignal.timeout(1_000) });
+                const body = (await health.json());
+                if (!health.ok || typeof body.instance !== "string")
+                    return null;
+                instance = body.instance;
+            }
+            catch {
+                return null;
+            }
             try {
-                const response = await fetch(`${baseUrl}/api/health`, {
+                const response = await fetch(`${baseUrl}/api/web/status`, {
+                    headers: await localTokenHeader(),
                     signal: AbortSignal.timeout(1_000),
                 });
                 const body = (await response.json());
-                return response.ok && body.success === true && body.status === "ok";
+                const version = response.ok && typeof body.version === "string" ? body.version : null;
+                return { instance, version };
+            }
+            catch {
+                return { instance, version: null };
+            }
+        },
+        stepAside: async (baseUrl, version) => {
+            try {
+                const response = await fetch(`${baseUrl}/api/web/step-aside`, {
+                    method: "POST",
+                    headers: { ...(await localTokenHeader()), "content-type": "application/json" },
+                    body: JSON.stringify({ version }),
+                    signal: AbortSignal.timeout(1_000),
+                });
+                return response.status === 202;
             }
             catch {
                 return false;
             }
         },
+        newInstance: () => randomUUID(),
+        version: () => packageVersion(),
+        env: process.env,
         sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
         now: () => Date.now(),
         exit: (code) => process.exit(code),
         execPath: process.execPath,
         args: process.argv.slice(1),
+        launcher: existsSync(launcherPath(ommsDir())) ? launcherPath(ommsDir()) : null,
         cwd: homedir(),
         pid: process.pid,
         log: async (message, data) => (await import("../services/logger.js")).log(message, data),
@@ -49,14 +95,16 @@ export function createPowerAction(options) {
     const logFailure = (code) => Promise.resolve(deps.log("Web app restart failed", { code })).catch(() => undefined);
     let stopped = false;
     /** Start the copy, check it, stop serving, and wait until the copy answers. */
-    async function handOff() {
+    async function handOff(args) {
         let child;
+        const instance = deps.newInstance();
         try {
-            child = deps.spawn(deps.execPath, deps.args, {
+            child = deps.spawn(deps.execPath, args, {
                 detached: true,
                 stdio: "ignore",
                 cwd: deps.cwd,
                 windowsHide: true,
+                env: { ...deps.env, OMMS_WEB_INSTANCE: instance },
             });
         }
         catch {
@@ -82,12 +130,30 @@ export function createPowerAction(options) {
             stopped = true;
         }
         // The copy waits as a non-owner and takes the port within about 7 seconds.
-        const began = deps.now();
+        let began = deps.now();
+        // Each older owner is asked once; another older waiter can take the port after it.
+        const askedAside = new Set();
         while (deps.now() - began < HANDOFF_WAIT_MS) {
             if (exited)
                 return giveUp("copy-exit", copyPid);
-            if (await deps.probe(options.baseUrl))
-                return deps.exit(0);
+            const owner = await deps.readOwner(options.baseUrl);
+            if (owner?.instance === instance) {
+                deps.exit(0);
+                return undefined;
+            }
+            // Another web app that waited for the port took it first.
+            if (owner) {
+                const ownVersion = deps.version();
+                const order = owner.version === null ? null : compareVersions(owner.version, ownVersion);
+                if (order === null || order >= 0)
+                    return yieldTo(child, copyPid);
+                if (!askedAside.has(owner.instance)) {
+                    askedAside.add(owner.instance);
+                    // The copy needs a fresh wait once the older web app leaves.
+                    if (await deps.stepAside(options.baseUrl, ownVersion))
+                        began = deps.now();
+                }
+            }
             await deps.sleep(HANDOFF_POLL_MS);
         }
         if (exited)
@@ -96,7 +162,15 @@ export function createPowerAction(options) {
         child.kill("SIGTERM");
         return giveUp("handoff", copyPid);
     }
-    /** Keep or resume serving on the old process, and release the lock it wrote. */
+    /** A web app of the same or a newer version serves, so the copy would only wait. */
+    async function yieldTo(child, copyPid) {
+        child.kill("SIGTERM");
+        await deps.removeStartLock(copyPid);
+        await logFailure("other-owner");
+        deps.exit(0);
+        return undefined;
+    }
+    /** Keep or resume serving on the old process, and release the lock it wrote. Returns the code. */
     async function giveUp(code, copyPid) {
         if (copyPid !== undefined)
             await deps.removeStartLock(copyPid);
@@ -104,7 +178,7 @@ export function createPowerAction(options) {
             await deps.removeStartLock(deps.pid);
         await logFailure(code);
         if (!stopped)
-            return;
+            return code;
         try {
             await options.resumeServer();
             stopped = false;
@@ -113,29 +187,39 @@ export function createPowerAction(options) {
             await logFailure(error instanceof Error ? error.name : "resume-error");
             deps.exit(1);
         }
+        return code;
     }
     return async (action) => {
         if (action === "stop") {
             await options.stopServer();
             deps.exit(0);
-            return;
+            return undefined;
+        }
+        // After an update the copy of this process is the old version; the launcher picks the newest.
+        if (action === "update" && !deps.launcher) {
+            await logFailure("no-launcher");
+            return "no-launcher";
         }
+        const args = action === "update" ? [deps.launcher, "web"] : deps.args;
         stopped = false;
         try {
             if (options.loginItem) {
+                // The login item runs the launcher, so the service manager restart covers an update too.
                 await options.stopServer();
                 stopped = true;
-                if (await deps.restartLoginItem())
-                    return deps.exit(0);
+                if (await deps.restartLoginItem()) {
+                    deps.exit(0);
+                    return undefined;
+                }
             }
             else {
                 // Hold other hosts off until the copy owns the port.
                 await deps.writeStartLock(deps.pid);
             }
-            await handOff();
+            return await handOff(args);
         }
         catch (error) {
-            await giveUp(error instanceof Error ? error.name : "unknown");
+            return giveUp(error instanceof Error ? error.name : "unknown");
         }
     };
 }

package/dist/services/web-server.d.ts

@@ -1,3 +1,4 @@
+import type { WebUpdate } from "./web-update.js";
 import { WebAuth } from "./web-auth.js";
 type NodeEventSource = {
     on(event: string, listener: (...args: any[]) => void): unknown;
@@ -37,6 +38,7 @@ export declare class WebServer {
     private onPortsExhaustedCallback;
     private onStepAsideCallback;
     private onPowerActionCallback;
+    private webUpdate;
     private powerActionRunning;
     private stepAsideTimer;
     private holdOffTimer;
@@ -59,9 +61,13 @@ export declare class WebServer {
     /** Standalone web apps register this to exit when a newer OMMS asks them to step aside. */
     setOnStepAside(callback: () => void | Promise<void>): void;
     /** Standalone web apps register this to stop or restart from the page. */
-    setOnPowerAction(callback: (action: PowerAction) => void | Promise<void>): void;
+    setOnPowerAction(callback: (action: PowerAction) => unknown): void;
+    /** Standalone web apps register this to report and install npm releases. */
+    setWebUpdate(update: Pick<WebUpdate, "status" | "requestInstall">): void;
     /** Only a local caller may stop the web app; the token alone is not enough. */
     private handlePowerAction;
+    /** Install the npm release and restart onto it. Same guards as Restart. */
+    private handleUpdate;
     /** API token routes. Only a caller on this machine with the local token manages tokens. */
     private handleTokenRoute;
     /** Profile catch-up: a preview for anyone with API access; runs only from this machine. */
@@ -77,6 +83,7 @@ export declare class WebServer {
     start(): Promise<void>;
     private _start;
     private startHealthCheckLoop;
+    private ownerIsNewer;
     private stopHealthCheckLoop;
     private attemptTakeover;
     private notifyPortsExhausted;

package/dist/services/web-server.js

@@ -142,10 +142,19 @@ export function nextFallbackPort(currentPort, failedTakeovers, maxFallbackPort,
     return currentPort + 1;
 }
 const STEP_ASIDE_HOLD_OFF_MS = 60_000;
+/** What a web app without an npm check reports, such as one inside a host session. */
+const NO_UPDATE = { available: null, state: "idle", code: null, canInstall: false };
 /** Lets the 202 reply reach the caller before the server stops. */
 const STEP_ASIDE_REPLY_GRACE_MS = 100;
-/** Differs between processes, so the page can tell a restarted web app from the old one. */
-const PROCESS_INSTANCE = randomUUID();
+/**
+ * Differs between processes, so the page can tell a restarted web app from the old one.
+ * A restart names its copy's instance, so it can tell its copy from another web app.
+ */
+const PROCESS_INSTANCE = /^[0-9a-f-]{36}$/.test(process.env.OMMS_WEB_INSTANCE ?? "")
+    ? process.env.OMMS_WEB_INSTANCE
+    : randomUUID();
+// Child processes, such as an OpenCode model list, must not report the same instance.
+delete process.env.OMMS_WEB_INSTANCE;
 export class WebServer {
     server = null;
     config;
@@ -156,6 +165,7 @@ export class WebServer {
     onPortsExhaustedCallback = null;
     onStepAsideCallback = null;
     onPowerActionCallback = null;
+    webUpdate = null;
     powerActionRunning = false;
     stepAsideTimer = null;
     holdOffTimer = null;
@@ -222,6 +232,10 @@ export class WebServer {
     setOnPowerAction(callback) {
         this.onPowerActionCallback = callback;
     }
+    /** Standalone web apps register this to report and install npm releases. */
+    setWebUpdate(update) {
+        this.webUpdate = update;
+    }
     /** Only a local caller may stop the web app; the token alone is not enough. */
     handlePowerAction(action, remoteAddress) {
         const record = (outcome) => log("Web server power request", { action, outcome, ownVersion: packageVersion() });
@@ -234,6 +248,12 @@ export class WebServer {
             record("unsupported");
             return this.jsonResponse({ success: false, error: "Not supported by this web app" }, 409);
         }
+        // An update restarts through the same callback; a Stop or Restart now would cut npm off.
+        const updateState = this.webUpdate?.status().state;
+        if (updateState === "installing" || updateState === "restarting") {
+            record("refused_update_running");
+            return this.jsonResponse({ success: false, error: "An update is running" }, 409);
+        }
         // A repeated request must not start a second stop or restart while one runs.
         if (this.powerActionRunning) {
             record("already_running");
@@ -255,6 +275,24 @@ export class WebServer {
         }, STEP_ASIDE_REPLY_GRACE_MS).unref();
         return this.jsonResponse({ success: true }, 202);
     }
+    /** Install the npm release and restart onto it. Same guards as Restart. */
+    handleUpdate(remoteAddress) {
+        const record = (outcome) => log("Web server update request", { outcome, ownVersion: packageVersion() });
+        if (!isLoopbackAddress(remoteAddress)) {
+            record("refused_not_loopback");
+            return this.jsonResponse({ success: false, error: "Loopback caller required" }, 403);
+        }
+        if (this.powerActionRunning) {
+            record("refused_power_running");
+            return this.jsonResponse({ success: false, error: "A stop or restart is running" }, 409);
+        }
+        const reply = this.webUpdate?.requestInstall() ?? "cannot-install";
+        record(reply);
+        if (reply === "accepted")
+            return this.jsonResponse({ success: true }, 202);
+        const error = reply === "no-update" ? "No newer release" : "This web app cannot install";
+        return this.jsonResponse({ success: false, error }, 409);
+    }
     /** API token routes. Only a caller on this machine with the local token manages tokens. */
     async handleTokenRoute(req, path, method, remoteAddress) {
         if (!isLoopbackAddress(remoteAddress)) {
@@ -540,8 +578,34 @@ export class WebServer {
                 this.stopHealthCheckLoop();
                 await this.attemptTakeover();
             }
+            else if (this.onStepAsideCallback && (await this.ownerIsNewer())) {
+                // A standalone web app behind a newer one would serve old code after a restart.
+                this.stopHealthCheckLoop();
+                log("Web server waiter retired", { ownVersion: packageVersion() });
+                try {
+                    await this.onStepAsideCallback();
+                }
+                catch (error) {
+                    log("Step-aside callback error", { error: String(error) });
+                }
+            }
         }, 5000);
     }
+    async ownerIsNewer() {
+        try {
+            const response = await fetch(`${this.getUrl()}/api/web/status`, {
+                headers: { [AUTH_HEADER]: getOrCreateAuthToken() },
+                signal: AbortSignal.timeout(2_000),
+            });
+            if (!response.ok)
+                return false;
+            const { version } = (await response.json());
+            return typeof version === "string" && isOlderVersion(packageVersion(), version);
+        }
+        catch {
+            return false;
+        }
+    }
     stopHealthCheckLoop() {
         if (this.healthCheckInterval) {
             clearInterval(this.healthCheckInterval);
@@ -729,6 +793,8 @@ export class WebServer {
                     success: true,
                     status: "ok",
                     authEnabled: auth?.isEnabled() ?? false,
+                    // Opaque per process; a restart finds its copy by it even behind basic auth.
+                    instance: PROCESS_INSTANCE,
                 });
             }
             if (path === "/" || path === "/index.html" || path === "/settings") {
@@ -813,11 +879,15 @@ export class WebServer {
                     // Keys, tokens, and the embedder can be changed only from this machine.
                     isLocal: isLoopbackAddress(remoteAddress),
                     instance: PROCESS_INSTANCE,
+                    update: this.webUpdate?.status() ?? NO_UPDATE,
                 });
             }
             if ((path === "/api/web/stop" || path === "/api/web/restart") && method === "POST") {
                 return this.handlePowerAction(path === "/api/web/stop" ? "stop" : "restart", remoteAddress);
             }
+            if (path === "/api/web/update" && method === "POST") {
+                return this.handleUpdate(remoteAddress);
+            }
             if (path === "/api/web/step-aside" && method === "POST") {
                 const body = await req.json().catch(() => null);
                 return this.handleStepAside(remoteAddress, body);

package/dist/services/web-update-runtime.d.ts

@@ -0,0 +1,3 @@
+import { WebUpdate } from "./web-update.js";
+/** The npm check and installer of a standalone web app, with the real process, npm, and clock. */
+export declare function startWebUpdate(restart: () => Promise<string | undefined>, canRestart: () => boolean): WebUpdate;

package/dist/services/web-update-runtime.js

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { globalCommandVersion } from "./global-version.js";
+import { log } from "./logger.js";
+import { packageVersion } from "./package-version.js";
+import { WebUpdate } from "./web-update.js";
+/** The npm check and installer of a standalone web app, with the real process, npm, and clock. */
+export function startWebUpdate(restart, canRestart) {
+    const update = new WebUpdate({
+        version: packageVersion(),
+        enabled: process.env.OMMS_DISABLE_UPDATE_CHECK !== "1",
+        fetch,
+        setInterval: (callback, ms) => setInterval(callback, ms),
+        log,
+        execPath: process.execPath,
+        platform: process.platform,
+        exists: existsSync,
+        spawn: (command, args, options) => spawn(command, args, {
+            shell: options.shell,
+            stdio: ["ignore", "ignore", "pipe"],
+            windowsHide: true,
+        }),
+        // npm installs beside this Node.js, so read that install, not the first command on PATH.
+        globalVersion: () => globalCommandVersion({ find: () => null }).version,
+        restart,
+        canRestart,
+        // Resolves once npm has stopped. `taskkill /T` also stops npm under the cmd.exe
+        // wrapper that `shell: true` starts; the child's own exit confirms it.
+        killTree: (child) => new Promise((resolve) => {
+            child.on("exit", () => resolve());
+            if (process.platform === "win32" && child.pid) {
+                spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+                    stdio: "ignore",
+                    windowsHide: true,
+                }).on("error", () => child.kill("SIGKILL"));
+            }
+            else {
+                child.kill("SIGTERM");
+            }
+        }),
+        setTimeout: (callback, ms) => setTimeout(callback, ms),
+        clearTimeout: (handle) => clearTimeout(handle),
+        now: () => Date.now(),
+    });
+    update.start();
+    return update;
+}

package/dist/services/web-update.d.ts

@@ -0,0 +1,76 @@
+export declare const UPDATE_CHECK_INTERVAL_MS: number;
+/** An install that takes longer is stopped, and the web app keeps serving. */
+export declare const INSTALL_TIMEOUT_MS: number;
+export type UpdateState = "idle" | "installing" | "restarting" | "failed";
+/** The `update` field of `GET /api/web/status`. */
+export interface UpdateStatus {
+    /** The newer release on npm, or null. */
+    available: string | null;
+    state: UpdateState;
+    /** The failure code while `state` is `failed`. */
+    code: string | null;
+    /** True when this web app can install the release itself. */
+    canInstall: boolean;
+}
+export interface WebUpdateDeps {
+    /** The running version. */
+    version: string;
+    /** False when `OMMS_DISABLE_UPDATE_CHECK` is `1`. */
+    enabled: boolean;
+    fetch: typeof fetch;
+    setInterval: (callback: () => void, ms: number) => {
+        unref?: () => void;
+    };
+    log: (message: string, data: Record<string, unknown>) => void;
+    /** The runtime of this web app; npm must sit beside it. */
+    execPath: string;
+    platform: NodeJS.Platform;
+    exists: (path: string) => boolean;
+    spawn: (command: string, args: string[], options: {
+        shell: boolean;
+    }) => InstallChild;
+    /** The version of the global install after npm ran, or null. */
+    globalVersion: () => string | null;
+    /** False when no restart could serve the new copy, such as a missing launcher. Checked before npm runs. */
+    canRestart: () => boolean;
+    /** Stop npm and its children. On Windows the shell wrapper alone would leave npm running. */
+    killTree: (child: InstallChild) => Promise<void>;
+    /** Restart onto the newest copy. Returns a failure code when this web app keeps serving. */
+    restart: () => Promise<string | undefined>;
+    setTimeout: (callback: () => void, ms: number) => unknown;
+    clearTimeout: (handle: unknown) => void;
+    now: () => number;
+}
+/** The parts of a child process the install runner uses. */
+export interface InstallChild {
+    pid?: number;
+    stderr: {
+        on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    } | null;
+    on(event: "error", listener: () => void): unknown;
+    on(event: "exit", listener: (code: number | null) => void): unknown;
+    kill(signal?: NodeJS.Signals): boolean;
+}
+export type InstallRequest = "accepted" | "no-update" | "cannot-install";
+/** A failure code from npm's error stream. The text itself never leaves this function. */
+export declare function npmFailureCode(errorText: string): string;
+export declare class WebUpdate {
+    private readonly deps;
+    private available;
+    private state;
+    private code;
+    private started;
+    constructor(deps: WebUpdateDeps);
+    /** Check now, then every 6 hours. A second call does nothing. */
+    start(): void;
+    /** Read npm `latest`. A failed read keeps the last result. */
+    check(): Promise<void>;
+    /** The npm that installs into the prefix the launcher reads. */
+    private npmPath;
+    status(): UpdateStatus;
+    private canInstall;
+    /** Start the install and the restart. A request while one runs joins it. */
+    requestInstall(): InstallRequest;
+    private install;
+    private runNpm;
+}