@rynx-ai/daemon 0.1.11-beta.2 → 0.1.11-beta.3

package/bundled-plugins/plugins/lark/dist/runtime.js

@@ -126032,9 +126032,6 @@ function isAgentRuntimeId(value) {
   return value === "codex" || value === "traex" || value === "claude";
 }
 function normalizeRuntimeId(value) {
-  if (value === "traecli") {
-    return "traex";
-  }
   return isAgentRuntimeId(value) ? value : void 0;
 }
 var RUNTIME_PROFILES = {
@@ -126100,7 +126097,7 @@ var envSchema = external_exports.object({
    * `/runtime` card. `codex` keeps the legacy behaviour; `traex` targets the
    * ByteDance Codex fork. Per-conversation overrides are stored separately.
    */
-  AGENT_RUNTIME: external_exports.enum(["codex", "traex", "claude"]).default("codex"),
+  DEFAULT_RUNTIME: external_exports.enum(["codex", "traex", "claude"]).default("codex"),
   /**
    * Default declarative agent (a spec under `~/.rynx/agents/<name>.json`) for
    * conversations that haven't selected one via `/agent`. Empty ⇒ no default;
@@ -126352,7 +126349,7 @@ var CHROME_INSPECTION_ERROR_MAX_BYTES = 4 * 1024;
 import path from "node:path";
 var SESSION_EXECUTION_SNAPSHOT_VERSION = 1;
 var nonEmptyString = external_exports.string().trim().min(1);
-var absolutePath = nonEmptyString.refine((value) => path.isAbsolute(value) && path.normalize(value) === value, "path must be normalized and absolute");
+var absolutePath = external_exports.string().min(1).refine((value) => Boolean(value.trim()) && path.isAbsolute(value) && path.normalize(value) === value, "path must be normalized and absolute");
 var sessionWorkspaceSnapshotSchema = external_exports.object({
   cwd: absolutePath,
   allowedDirs: external_exports.array(absolutePath).min(1)

package/bundled-plugins/plugins/lark/dist/settings.js

@@ -126033,7 +126033,7 @@ var envSchema = external_exports.object({
    * `/runtime` card. `codex` keeps the legacy behaviour; `traex` targets the
    * ByteDance Codex fork. Per-conversation overrides are stored separately.
    */
-  AGENT_RUNTIME: external_exports.enum(["codex", "traex", "claude"]).default("codex"),
+  DEFAULT_RUNTIME: external_exports.enum(["codex", "traex", "claude"]).default("codex"),
   /**
    * Default declarative agent (a spec under `~/.rynx/agents/<name>.json`) for
    * conversations that haven't selected one via `/agent`. Empty ⇒ no default;
@@ -126217,7 +126217,7 @@ var CHROME_INSPECTION_ERROR_MAX_BYTES = 4 * 1024;
 import path from "node:path";
 var SESSION_EXECUTION_SNAPSHOT_VERSION = 1;
 var nonEmptyString = external_exports.string().trim().min(1);
-var absolutePath = nonEmptyString.refine((value) => path.isAbsolute(value) && path.normalize(value) === value, "path must be normalized and absolute");
+var absolutePath = external_exports.string().min(1).refine((value) => Boolean(value.trim()) && path.isAbsolute(value) && path.normalize(value) === value, "path must be normalized and absolute");
 var sessionWorkspaceSnapshotSchema = external_exports.object({
   cwd: absolutePath,
   allowedDirs: external_exports.array(absolutePath).min(1)

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11",
+  "version": "0.1.11-beta.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/browser-artifact-management.d.ts

@@ -1,8 +1,10 @@
 import type { DaemonBrowserArtifactCleanResult, DaemonBrowserArtifactInstallInput, DaemonBrowserArtifactInstallResult, DaemonBrowserArtifactUpdateInput, DaemonBrowserArtifactVersionResult } from "@rynx-ai/protocol/control";
 import { type ChromeForTestingReleaseSelector, type ResolvedChromeForTestingRelease } from "./chrome-for-testing-release-resolver.js";
-import { type ChromeForTestingArtifactStore } from "./chrome-for-testing-store.js";
+import { type InstalledChromeForTestingBuild, type ChromeForTestingArtifactStore } from "./chrome-for-testing-store.js";
+import { type EnsureChromeForTestingRuntimeOptions } from "./chrome-for-testing-runtime.js";
 export interface BrowserArtifactManagementContext {
     signal?: AbortSignal;
+    onProgress?: (message: string) => void;
 }
 export interface BrowserArtifactManagementService {
     install(input: DaemonBrowserArtifactInstallInput, context?: BrowserArtifactManagementContext): Promise<DaemonBrowserArtifactInstallResult>;
@@ -15,6 +17,7 @@ export interface BrowserArtifactManagementServiceOptions {
         signal?: AbortSignal;
     }) => Promise<ResolvedChromeForTestingRelease>;
     createStore?: () => ChromeForTestingArtifactStore;
+    ensureRuntime?: (build: InstalledChromeForTestingBuild, options?: EnsureChromeForTestingRuntimeOptions) => Promise<void>;
 }
 /** Daemon-owned Browser artifact operations exposed through local management. */
 export declare function createBrowserArtifactManagementService(options?: BrowserArtifactManagementServiceOptions): BrowserArtifactManagementService;

package/dist/browser-artifact-management.js

@@ -1,5 +1,6 @@
 import { resolveChromeForTestingRelease, } from "./chrome-for-testing-release-resolver.js";
 import { createChromeForTestingArtifactStore, } from "./chrome-for-testing-store.js";
+import { ensureChromeForTestingRuntime, } from "./chrome-for-testing-runtime.js";
 const MAX_PROGRESS_MESSAGES = 64;
 const MAX_PROGRESS_MESSAGE_BYTES = 2 * 1024;
 const MAX_PROGRESS_TOTAL_BYTES = 32 * 1024;
@@ -7,6 +8,7 @@ const MAX_PROGRESS_TOTAL_BYTES = 32 * 1024;
 export function createBrowserArtifactManagementService(options = {}) {
     const resolveRelease = options.resolveRelease ?? resolveChromeForTestingRelease;
     const createStore = options.createStore ?? createChromeForTestingArtifactStore;
+    const ensureRuntime = options.ensureRuntime ?? ensureChromeForTestingRuntime;
     let store;
     const artifactStore = () => store ??= createStore();
     const install = async (input, context = {}) => {
@@ -19,18 +21,24 @@ export function createBrowserArtifactManagementService(options = {}) {
         const resolved = await resolveRelease(selector, { signal: context.signal });
         const messages = [];
         let messageBytes = 0;
+        const onProgress = (message) => {
+            context.onProgress?.(message);
+            if (messages.length >= MAX_PROGRESS_MESSAGES)
+                return;
+            const bounded = boundedUtf8(message, MAX_PROGRESS_MESSAGE_BYTES);
+            const bytes = Buffer.byteLength(bounded, "utf8");
+            if (messageBytes + bytes > MAX_PROGRESS_TOTAL_BYTES)
+                return;
+            messageBytes += bytes;
+            messages.push(bounded);
+        };
         const installed = await artifactStore().installResolved(resolved, {
             signal: context.signal,
-            onProgress: (message) => {
-                if (messages.length >= MAX_PROGRESS_MESSAGES)
-                    return;
-                const bounded = boundedUtf8(message, MAX_PROGRESS_MESSAGE_BYTES);
-                const bytes = Buffer.byteLength(bounded, "utf8");
-                if (messageBytes + bytes > MAX_PROGRESS_TOTAL_BYTES)
-                    return;
-                messageBytes += bytes;
-                messages.push(bounded);
-            },
+            onProgress,
+            verifyBeforeActivate: (build) => ensureRuntime(build, {
+                signal: context.signal,
+                onProgress,
+            }),
         });
         return { resolved, installed, messages };
     };

package/dist/browser-artifacts.d.ts

@@ -0,0 +1 @@
+export { createBrowserArtifactManagementService, type BrowserArtifactManagementContext, type BrowserArtifactManagementService, type BrowserArtifactManagementServiceOptions, } from "./browser-artifact-management.js";

package/dist/browser-artifacts.js

@@ -0,0 +1 @@
+export { createBrowserArtifactManagementService, } from "./browser-artifact-management.js";

package/dist/chrome-for-testing-runtime.d.ts

@@ -0,0 +1,27 @@
+import type { InstalledChromeForTestingBuild } from "./chrome-for-testing-store.js";
+export interface BrowserRuntimeCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    errorCode?: string;
+}
+export interface BrowserRuntimeCommandOptions {
+    signal?: AbortSignal;
+    timeoutMs: number;
+}
+export type BrowserRuntimeCommandRunner = (command: string, args: readonly string[], options: BrowserRuntimeCommandOptions) => Promise<BrowserRuntimeCommandResult>;
+export interface EnsureChromeForTestingRuntimeOptions {
+    signal?: AbortSignal;
+    onProgress?: (message: string) => void;
+    platform?: string;
+    getuid?: () => number | undefined;
+    findSystemExecutable?: (name: string) => Promise<string | undefined>;
+    runCommand?: BrowserRuntimeCommandRunner;
+}
+/**
+ * Verifies that a managed Chrome build can start. On Linux, known missing
+ * shared libraries are installed with a fixed package allowlist before a
+ * second probe; arbitrary output from ldd is never passed to a shell.
+ */
+export declare function ensureChromeForTestingRuntime(build: InstalledChromeForTestingBuild, options?: EnsureChromeForTestingRuntimeOptions): Promise<void>;
+export declare function parseMissingSharedLibraries(output: string): string[];

package/dist/chrome-for-testing-runtime.js

@@ -0,0 +1,193 @@
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+const PROBE_TIMEOUT_MS = 10_000;
+const INSTALL_TIMEOUT_MS = 5 * 60_000;
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+const SYSTEM_PACKAGES = {
+    apt: {
+        "libasound.so.2": "libasound2",
+        "libatk-1.0.so.0": "libatk1.0-0",
+        "libatk-bridge-2.0.so.0": "libatk-bridge2.0-0",
+        "libatspi.so.0": "libatspi2.0-0",
+        "libcairo.so.2": "libcairo2",
+        "libcups.so.2": "libcups2",
+        "libdbus-1.so.3": "libdbus-1-3",
+        "libdrm.so.2": "libdrm2",
+        "libexpat.so.1": "libexpat1",
+        "libfontconfig.so.1": "libfontconfig1",
+        "libfreetype.so.6": "libfreetype6",
+        "libgbm.so.1": "libgbm1",
+        "libglib-2.0.so.0": "libglib2.0-0",
+        "libgobject-2.0.so.0": "libglib2.0-0",
+        "libgtk-3.so.0": "libgtk-3-0",
+        "libnspr4.so": "libnspr4",
+        "libnss3.so": "libnss3",
+        "libpango-1.0.so.0": "libpango-1.0-0",
+        "libX11.so.6": "libx11-6",
+        "libxcb.so.1": "libxcb1",
+        "libXcomposite.so.1": "libxcomposite1",
+        "libXdamage.so.1": "libxdamage1",
+        "libXext.so.6": "libxext6",
+        "libXfixes.so.3": "libxfixes3",
+        "libxkbcommon.so.0": "libxkbcommon0",
+        "libXrandr.so.2": "libxrandr2",
+    },
+    rpm: {
+        "libasound.so.2": "alsa-lib",
+        "libatk-1.0.so.0": "atk",
+        "libatk-bridge-2.0.so.0": "at-spi2-atk",
+        "libatspi.so.0": "at-spi2-core",
+        "libcairo.so.2": "cairo",
+        "libcups.so.2": "cups-libs",
+        "libdbus-1.so.3": "dbus-libs",
+        "libdrm.so.2": "libdrm",
+        "libexpat.so.1": "expat",
+        "libfontconfig.so.1": "fontconfig",
+        "libfreetype.so.6": "freetype",
+        "libgbm.so.1": "mesa-libgbm",
+        "libglib-2.0.so.0": "glib2",
+        "libgobject-2.0.so.0": "glib2",
+        "libgtk-3.so.0": "gtk3",
+        "libnspr4.so": "nspr",
+        "libnss3.so": "nss",
+        "libpango-1.0.so.0": "pango",
+        "libX11.so.6": "libX11",
+        "libxcb.so.1": "libxcb",
+        "libXcomposite.so.1": "libXcomposite",
+        "libXdamage.so.1": "libXdamage",
+        "libXext.so.6": "libXext",
+        "libXfixes.so.3": "libXfixes",
+        "libxkbcommon.so.0": "libxkbcommon",
+        "libXrandr.so.2": "libXrandr",
+    },
+};
+/**
+ * Verifies that a managed Chrome build can start. On Linux, known missing
+ * shared libraries are installed with a fixed package allowlist before a
+ * second probe; arbitrary output from ldd is never passed to a shell.
+ */
+export async function ensureChromeForTestingRuntime(build, options = {}) {
+    const runCommand = options.runCommand ?? runBrowserRuntimeCommand;
+    const findSystemExecutable = options.findSystemExecutable ?? findSystemCommand;
+    const run = async (command, args, timeoutMs = PROBE_TIMEOUT_MS) => {
+        options.signal?.throwIfAborted();
+        const result = await runCommand(command, args, { signal: options.signal, timeoutMs });
+        options.signal?.throwIfAborted();
+        return result;
+    };
+    const initialProbe = await run(build.executablePath, ["--version"]);
+    if (initialProbe.exitCode === 0) {
+        options.onProgress?.(`verified Chrome for Testing ${build.version} can start`);
+        return;
+    }
+    if ((options.platform ?? process.platform) !== "linux") {
+        throw browserLaunchError(build, initialProbe);
+    }
+    const ldd = await findSystemExecutable("ldd");
+    if (!ldd) {
+        throw new Error(`${browserLaunchError(build, initialProbe).message}; ldd is unavailable`);
+    }
+    const dependencyCheck = await run(ldd, [build.executablePath]);
+    const missingLibraries = parseMissingSharedLibraries(`${dependencyCheck.stdout}\n${dependencyCheck.stderr}`);
+    if (missingLibraries.length === 0)
+        throw browserLaunchError(build, initialProbe);
+    const packageManager = await resolvePackageManager(findSystemExecutable);
+    if (!packageManager) {
+        throw new Error(`Chrome for Testing is missing ${missingLibraries.join(", ")}, ` +
+            "but no supported system package manager (apt-get, dnf, or yum) is available");
+    }
+    const packages = packagesForLibraries(packageManager.family, missingLibraries);
+    const installArgs = packageManager.family === "apt"
+        ? ["install", "-y", "--no-install-recommends", ...packages]
+        : ["install", "-y", ...packages];
+    let command = packageManager.path;
+    let args = installArgs;
+    const getuid = options.getuid ?? (() => process.getuid?.());
+    if (getuid() !== 0) {
+        const sudo = await findSystemExecutable("sudo");
+        if (!sudo || (await run(sudo, ["-n", "true"])).exitCode !== 0) {
+            throw new Error(`Chrome for Testing is missing ${missingLibraries.join(", ")}. ` +
+                `Install these packages as an administrator and retry: ${packages.join(" ")}`);
+        }
+        command = sudo;
+        args = ["-n", packageManager.path, ...installArgs];
+    }
+    options.onProgress?.(`installing Chrome for Testing system dependencies: ${packages.join(" ")}`);
+    const installation = await run(command, args, INSTALL_TIMEOUT_MS);
+    if (installation.exitCode !== 0) {
+        throw new Error(`failed to install Chrome for Testing system dependencies (${packages.join(" ")}): ` +
+            commandFailure(installation));
+    }
+    const finalProbe = await run(build.executablePath, ["--version"]);
+    if (finalProbe.exitCode !== 0)
+        throw browserLaunchError(build, finalProbe);
+    options.onProgress?.(`verified Chrome for Testing ${build.version} can start`);
+}
+export function parseMissingSharedLibraries(output) {
+    const libraries = new Set();
+    for (const line of output.split(/\r?\n/u)) {
+        const match = /^\s*(\S+)\s+=>\s+not found\s*$/u.exec(line);
+        if (match?.[1])
+            libraries.add(match[1]);
+    }
+    return [...libraries].sort();
+}
+function packagesForLibraries(family, libraries) {
+    const mapping = SYSTEM_PACKAGES[family];
+    const unsupported = libraries.filter((library) => !mapping[library]);
+    if (unsupported.length > 0) {
+        throw new Error(`Chrome for Testing is missing unsupported system libraries: ${unsupported.join(", ")}`);
+    }
+    return [...new Set(libraries.map((library) => mapping[library]))].sort();
+}
+async function resolvePackageManager(findExecutable) {
+    const apt = await findExecutable("apt-get");
+    if (apt)
+        return { family: "apt", path: apt };
+    const dnf = await findExecutable("dnf");
+    if (dnf)
+        return { family: "rpm", path: dnf };
+    const yum = await findExecutable("yum");
+    return yum ? { family: "rpm", path: yum } : undefined;
+}
+async function findSystemCommand(name) {
+    for (const directory of ["/usr/bin", "/bin", "/usr/sbin", "/sbin"]) {
+        const candidate = `${directory}/${name}`;
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next standard system directory.
+        }
+    }
+    return undefined;
+}
+function runBrowserRuntimeCommand(command, args, options) {
+    return new Promise((resolveResult) => {
+        execFile(command, [...args], {
+            encoding: "utf8",
+            env: { ...process.env, LC_ALL: "C" },
+            maxBuffer: MAX_OUTPUT_BYTES,
+            signal: options.signal,
+            timeout: options.timeoutMs,
+        }, (error, stdout, stderr) => {
+            resolveResult({
+                exitCode: error
+                    ? typeof error.code === "number" ? error.code : null
+                    : 0,
+                stdout,
+                stderr,
+                ...(error && typeof error.code === "string" ? { errorCode: error.code } : {}),
+            });
+        });
+    });
+}
+function browserLaunchError(build, result) {
+    return new Error(`Chrome for Testing ${build.version} was installed but cannot start: ${commandFailure(result)}`);
+}
+function commandFailure(result) {
+    const detail = result.stderr.trim() || result.stdout.trim() || result.errorCode;
+    return detail ? detail.slice(0, 2_000) : `exit code ${result.exitCode ?? "unknown"}`;
+}

package/dist/chrome-for-testing-store.d.ts

@@ -58,6 +58,8 @@ export interface ChromeForTestingArtifactStoreOptions {
 export interface InstallChromeForTestingOptions {
     signal?: AbortSignal;
     onProgress?: (message: string) => void;
+    /** Runs after the build is complete but before it becomes active. */
+    verifyBeforeActivate?: (build: InstalledChromeForTestingBuild) => Promise<void>;
 }
 export interface PruneChromeForTestingStagingOptions {
     olderThanMs?: number;

package/dist/chrome-for-testing-store.js

@@ -86,6 +86,11 @@ export function createChromeForTestingArtifactStore(options = {}) {
         });
     };
     const installDownloadedBuild = async (release, expectedSha256, installOptions) => {
+        const verifyBeforeActivate = async (build) => {
+            throwIfAborted(installOptions.signal);
+            await installOptions.verifyBeforeActivate?.(build);
+            throwIfAborted(installOptions.signal);
+        };
         const paths = ensureStorePaths(rootDir, platform.hostPlatform);
         if (expectedSha256 !== undefined) {
             const finalPath = buildPath(paths.buildsRoot, release.version, expectedSha256);
@@ -94,6 +99,7 @@ export function createChromeForTestingArtifactStore(options = {}) {
                 sha256: expectedSha256,
             });
             if (existing) {
+                await verifyBeforeActivate(existing);
                 writeActiveManifest(paths.root, existing);
                 return existing;
             }
@@ -105,6 +111,7 @@ export function createChromeForTestingArtifactStore(options = {}) {
             if (active?.version === release.version &&
                 active.artifactPlatform === release.platform &&
                 active.sourceUrl === release.url) {
+                await verifyBeforeActivate(active);
                 return active;
             }
         }
@@ -134,6 +141,7 @@ export function createChromeForTestingArtifactStore(options = {}) {
             const finalPath = buildPath(paths.buildsRoot, build.version, build.sha256);
             const existing = readInstalledBuild(finalPath, paths.buildsRoot, platform, build);
             if (existing) {
+                await verifyBeforeActivate(existing);
                 writeActiveManifest(paths.root, existing);
                 return existing;
             }
@@ -164,6 +172,7 @@ export function createChromeForTestingArtifactStore(options = {}) {
                     throw error;
             }
             const installed = requireInstalledBuild(finalPath, paths.buildsRoot, platform, build);
+            await verifyBeforeActivate(installed);
             writeActiveManifest(paths.root, installed);
             installOptions.onProgress?.(`installed Chrome for Testing ${build.version} (${build.sha256})`);
             return installed;

package/dist/daemon-server.d.ts

@@ -9,6 +9,9 @@ export declare function daemonActivityBlocksShutdown(activity: DaemonActivitySna
 export interface StartRynxDaemonServerOptions {
     config?: AppConfig;
     warn?: (message: string) => void;
+    /** Process-owner callback after every daemon resource and owner lease has
+     * shut down successfully. Library callers normally leave this unset. */
+    onShutdownComplete?: () => void;
     /** Test/deployment seam; failures roll back the already-listening server. */
     writeEndpoint?: (config: AppConfig, managementToken: string) => Promise<void>;
     /** Test seam for owner-lock failure injection. Production always uses the RYNX_HOME lease. */
@@ -25,7 +28,7 @@ export interface StartRynxDaemonServerOptions {
     /** 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, preparePlugins, loadDirectConfig, startDirectServer, createChromeInspectionManager, createBrowserHostSupervisor, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;
+export declare function startRynxDaemonServer({ config, warn, onShutdownComplete, writeEndpoint, acquireOwner, preparePlugins, 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