@rynx-ai/daemon 0.1.9 → 0.1.10-beta.2

package/dist/cli.js

@@ -52,8 +52,8 @@ Lifecycle:
 
 Plugins (static manifest + isolated runner):
   plugin manage list
-  plugin manage install <npm|path|git|url> [--force] [--grant-all] [--allow-scripts] [--restart]
-  plugin manage update <id> [--grant-all] [--allow-scripts]
+  plugin manage install <npm|path|git|url> [...] [--expect-digest <sha256-...>]
+  plugin manage update <id> [...] [--expect-digest <sha256-...>]
   plugin manage uninstall <id>
   plugin manage enable|disable <id>
                          manage arbitrary installed plugins
@@ -147,8 +147,10 @@ async function pluginManageCommand(sub, arg) {
             const force = process.argv.includes("--force");
             const grantAll = process.argv.includes("--grant-all");
             const allowScripts = process.argv.includes("--allow-scripts");
+            const expectedDigest = digestOption(process.argv);
             const result = await installPlugin(arg, (line) => console.log(line), {
                 allowScripts,
+                ...(expectedDigest ? { expectedDigest } : {}),
                 onConflict: async (existing) => {
                     if (force)
                         return true;
@@ -197,9 +199,11 @@ async function pluginManageCommand(sub, arg) {
             if (!isRunnablePluginRecord(existing)) {
                 fail(`plugin "${arg}" uses the removed legacy format; reinstall it from an explicit source`);
             }
+            const expectedDigest = digestOption(process.argv);
             const result = await installPlugin(existing.spec, (line) => console.log(line), {
                 expectedId: existing.name,
                 allowScripts: process.argv.includes("--allow-scripts"),
+                ...(expectedDigest ? { expectedDigest } : {}),
                 onConflict: () => true,
                 approveCapabilities: (manifest, current) => approvePluginCapabilities(manifest, current?.grants ?? [], process.argv.includes("--grant-all")),
             });
@@ -641,6 +645,13 @@ function optionValue(args, option) {
         fail(`${option}: missing value`);
     return value;
 }
+function digestOption(args) {
+    const expected = optionValue(args, "--expect-digest");
+    const legacyAlias = optionValue(args, "--expected-digest");
+    if (expected && legacyAlias)
+        fail("pass only one digest expectation option");
+    return expected ?? legacyAlias;
+}
 async function readStdinBounded(maxBytes) {
     const chunks = [];
     let bytes = 0;

package/dist/control-client.d.ts

@@ -1,4 +1,5 @@
 import { type DaemonStatus } from "@rynx-ai/protocol/remote-runtime";
+import { type DaemonChromeInspectionConfigureInput, type DaemonChromeInspectionStatus, type DaemonShutdownIfIdleResult } from "@rynx-ai/protocol/control";
 import { type RemoteRuntimeRpcMethod, type RemoteRuntimeRpcParams, type RemoteRuntimeRpcResultFor } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { type PairingOffer } from "@rynx-ai/protocol/direct-runtime";
 import { type RuntimeBrowserBootstrapCredential, type RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
@@ -61,6 +62,14 @@ export declare function ensureResidentDaemon(): Promise<ResidentDaemon>;
 export declare function getResidentDaemonIdentity(): Promise<ResidentDaemonIdentity>;
 /** Read the transport-independent status of the resident daemon process. */
 export declare function getResidentDaemonRuntimeStatus(): Promise<DaemonStatus>;
+/**
+ * Ask the resident daemon to perform one final activity check and stop only
+ * when idle. Busy is a normal result so the caller can ask the user to resolve
+ * the listed work and explicitly retry.
+ */
+export declare function shutdownResidentDaemonIfIdle(): Promise<DaemonShutdownIfIdleResult>;
+export declare function getResidentChromeInspectionStatus(): Promise<DaemonChromeInspectionStatus>;
+export declare function configureResidentChromeInspection(input: DaemonChromeInspectionConfigureInput): Promise<DaemonChromeInspectionStatus>;
 /** Create one pairing offer on the resident daemon for a selected reachable route. */
 export declare function createResidentRemoteRuntimePairingOffer(input?: {
     clientLabel?: string;

package/dist/control-client.js

@@ -1,6 +1,7 @@
 import { open } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { isDaemonCoreCompatible, parseDaemonStatus, } from "@rynx-ai/protocol/remote-runtime";
+import { DAEMON_CHROME_INSPECTION_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonChromeInspectionConfigureInput, parseDaemonChromeInspectionStatus, parseDaemonShutdownIfIdleResult, } from "@rynx-ai/protocol/control";
 import { parseRemoteRuntimeRpcRequest, parseRemoteRuntimeRpcResponseForMethod, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { parsePairingOffer, } from "@rynx-ai/protocol/direct-runtime";
 import { RUNTIME_BROWSER_BOOTSTRAP_PATH, RUNTIME_BROWSER_CAPABILITY_ENV, RUNTIME_BROWSER_CAPABILITY_HEADER, RUNTIME_BROWSER_CONTEXT_FILE_ENV, RUNTIME_BROWSER_MANAGEMENT_PATH_PREFIX, RUNTIME_BROWSER_RPC_PATH, RUNTIME_BROWSER_SESSION_ID_ENV, RUNTIME_BROWSER_SESSION_ID_HEADER, parseRuntimeBrowserBootstrapCredential, parseRuntimeBrowserEndpointDescriptor, } from "@rynx-ai/protocol/runtime-browser-bootstrap";
@@ -9,6 +10,7 @@ import { ensureDaemonControlEndpoint } from "./control-endpoint.js";
 export { connectResidentDesktopBrowserHost, } from "./desktop-browser-host-client.js";
 const IDENTITY_TIMEOUT_MS = 5_000;
 const RUNTIME_STATUS_TIMEOUT_MS = 5_000;
+const DAEMON_SHUTDOWN_TIMEOUT_MS = 5_000;
 const PLUGIN_CLI_TIMEOUT_MS = 120_000;
 const PLUGIN_CLI_BODY_MAX_BYTES = 512 * 1024;
 const PLUGIN_CLI_STDIN_MAX_BYTES = 256 * 1024;
@@ -17,6 +19,9 @@ const PLUGIN_CLI_ARGS_TOTAL_MAX_BYTES = 32 * 1024;
 const PLUGIN_CLI_ARGS_MAX_COUNT = 64;
 const IDENTITY_RESPONSE_MAX_BYTES = 16 * 1024;
 const RUNTIME_STATUS_RESPONSE_MAX_BYTES = 64 * 1024;
+const DAEMON_SHUTDOWN_RESPONSE_MAX_BYTES = 4 * 1024;
+const CHROME_INSPECTION_TIMEOUT_MS = 30_000;
+const CHROME_INSPECTION_RESPONSE_MAX_BYTES = 256 * 1024;
 const REMOTE_RUNTIME_ADMIN_RESPONSE_MAX_BYTES = 64 * 1024;
 const RUNTIME_TARGET_RESPONSE_MAX_BYTES = 128 * 1024;
 const RUNTIME_TARGET_REQUEST_MAX_BYTES = 64 * 1024;
@@ -97,6 +102,45 @@ export async function getResidentDaemonRuntimeStatus() {
     }
     return status;
 }
+/**
+ * Ask the resident daemon to perform one final activity check and stop only
+ * when idle. Busy is a normal result so the caller can ask the user to resolve
+ * the listed work and explicitly retry.
+ */
+export async function shutdownResidentDaemonIfIdle() {
+    const endpoint = await ensureDaemonControlEndpoint();
+    assertLoopbackOrigin(endpoint.origin);
+    const response = await fetch(`${endpoint.origin}${DAEMON_SHUTDOWN_IF_IDLE_PATH}`, {
+        method: "POST",
+        headers: managementHeaders(endpoint.managementToken),
+        signal: AbortSignal.timeout(DAEMON_SHUTDOWN_TIMEOUT_MS),
+    });
+    const body = await readBoundedResponse(response, DAEMON_SHUTDOWN_RESPONSE_MAX_BYTES);
+    if (response.status !== 202 && response.status !== 409) {
+        throw daemonRequestError("daemon shutdown-if-idle request", response.status, body);
+    }
+    let result;
+    try {
+        result = parseDaemonShutdownIfIdleResult(JSON.parse(body));
+    }
+    catch (error) {
+        throw new Error(`daemon returned an invalid shutdown-if-idle response: ${messageOf(error)}`);
+    }
+    if (response.status === 202 && result.outcome !== "accepted" ||
+        response.status === 409 && result.outcome !== "busy") {
+        throw new Error("daemon returned a shutdown-if-idle outcome inconsistent with HTTP status");
+    }
+    return result;
+}
+export async function getResidentChromeInspectionStatus() {
+    const result = await chromeInspectionRequest("GET");
+    return parseDaemonChromeInspectionStatus(result);
+}
+export async function configureResidentChromeInspection(input) {
+    const normalized = parseDaemonChromeInspectionConfigureInput(input);
+    const result = await chromeInspectionRequest("PUT", normalized);
+    return parseDaemonChromeInspectionStatus(result);
+}
 /** Create one pairing offer on the resident daemon for a selected reachable route. */
 export async function createResidentRemoteRuntimePairingOffer(input = {}) {
     const endpoint = await ensureDaemonControlEndpoint();
@@ -545,6 +589,25 @@ export async function invokeResidentPluginCommand(pluginId, args, options = {})
 function managementHeaders(token) {
     return { "x-rynx-management-token": token };
 }
+async function chromeInspectionRequest(method, bodyValue) {
+    const endpoint = await ensureDaemonControlEndpoint();
+    assertLoopbackOrigin(endpoint.origin);
+    const body = bodyValue === undefined ? undefined : JSON.stringify(bodyValue);
+    const response = await fetch(`${endpoint.origin}${DAEMON_CHROME_INSPECTION_PATH}`, {
+        method,
+        headers: {
+            ...managementHeaders(endpoint.managementToken),
+            ...(body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        ...(body === undefined ? {} : { body }),
+        signal: AbortSignal.timeout(CHROME_INSPECTION_TIMEOUT_MS),
+    });
+    const responseBody = await readBoundedResponse(response, CHROME_INSPECTION_RESPONSE_MAX_BYTES);
+    if (!response.ok) {
+        throw daemonRequestError("Chrome inspection request", response.status, responseBody);
+    }
+    return parseJsonObject(responseBody, "daemon returned an invalid Chrome inspection response");
+}
 function assertLoopbackOrigin(origin) {
     const hostname = new URL(origin).hostname;
     if (hostname !== "127.0.0.1" && hostname !== "[::1]" && hostname !== "::1") {

package/dist/daemon-build-status.d.ts

@@ -0,0 +1,8 @@
+export interface DaemonBuildStatus {
+    restartRequired: boolean;
+}
+/** Detect a same-installation rebuild that happened after this daemon
+ * incarnation started. Package path/version changes are handled by the PM2
+ * lifecycle wrapper; this is the development and in-place-update fallback. */
+export declare function daemonEntryRestartRequired(entryPath: string, daemonStartedAtMs: number): boolean;
+export declare function createDaemonBuildStatus(entryPath: string, daemonStartedAtMs: number): () => DaemonBuildStatus;

package/dist/daemon-build-status.js

@@ -0,0 +1,18 @@
+import { statSync } from "node:fs";
+const FILE_TIMESTAMP_TOLERANCE_MS = 1_000;
+/** Detect a same-installation rebuild that happened after this daemon
+ * incarnation started. Package path/version changes are handled by the PM2
+ * lifecycle wrapper; this is the development and in-place-update fallback. */
+export function daemonEntryRestartRequired(entryPath, daemonStartedAtMs) {
+    try {
+        return statSync(entryPath).mtimeMs > daemonStartedAtMs + FILE_TIMESTAMP_TOLERANCE_MS;
+    }
+    catch {
+        return true;
+    }
+}
+export function createDaemonBuildStatus(entryPath, daemonStartedAtMs) {
+    return () => ({
+        restartRequired: daemonEntryRestartRequired(entryPath, daemonStartedAtMs),
+    });
+}

package/dist/daemon-server.d.ts

@@ -1,7 +1,11 @@
 import { type AppConfig } from "@rynx-ai/core";
-import { startServer, startDirectRuntimeServer } from "@rynx-ai/server";
+import { type DaemonActivitySnapshot } from "@rynx-ai/protocol/control";
+import { SessionBrowserService, startServer, startDirectRuntimeServer, type DirectRuntimeBrowserInspectHost, type SessionBrowserHost } from "@rynx-ai/server";
+import { AppBrowserHostSupervisor, type AppBrowserHostSupervisorOptions } from "./app-browser-host-supervisor.js";
+import { ChromeInspectionManager, type ChromeInspectionManagerOptions } from "./chrome-inspection-manager.js";
 import { type DaemonOwnerLease } from "./daemon-owner.js";
 import { type DirectRuntimeConfig } from "./direct-runtime-config.js";
+export declare function daemonActivityBlocksShutdown(activity: DaemonActivitySnapshot): boolean;
 export interface StartRynxDaemonServerOptions {
     config?: AppConfig;
     warn?: (message: string) => void;
@@ -13,5 +17,18 @@ export interface StartRynxDaemonServerOptions {
     loadDirectConfig?: () => Promise<DirectRuntimeConfig>;
     /** Test seam for listener lifecycle and bind failures. */
     startDirectServer?: typeof startDirectRuntimeServer;
+    /** Test seam for resident Chrome inspection settings and gateway lifecycle. */
+    createChromeInspectionManager?: (options: ChromeInspectionManagerOptions) => Promise<Pick<ChromeInspectionManager, "status" | "configure" | "shutdown">>;
+    /** Test seam for the App-only embedded Chromium process supervisor. */
+    createBrowserHostSupervisor?: (options: AppBrowserHostSupervisorOptions) => Pick<AppBrowserHostSupervisor, "ensureConnected" | "restart" | "stop">;
 }
-export declare function startRynxDaemonServer({ config, warn, writeEndpoint, acquireOwner, loadDirectConfig, startDirectServer, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;
+export declare function startRynxDaemonServer({ config, warn, writeEndpoint, acquireOwner, loadDirectConfig, startDirectServer, createChromeInspectionManager, createBrowserHostSupervisor, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;
+export declare function createSupervisedAppSessionBrowserHost(desktop: SessionBrowserHost, supervisor: Pick<AppBrowserHostSupervisor, "ensureConnected" | "restart">): SessionBrowserHost;
+/**
+ * Resolve the authenticated semantic target inside its owning Runtime and
+ * attach directly to that Page's loopback CDP WebSocket. No endpoint is ever
+ * projected into the Direct protocol.
+ */
+export declare function createDirectRuntimeBrowserInspectHost(browsers: Pick<SessionBrowserService, "getInspectionPageEndpoint">, options?: {
+    openTimeoutMs?: number;
+}): DirectRuntimeBrowserInspectHost;