@rynx-ai/daemon 0.1.10 → 0.1.11-beta.10

package/bundled-plugins/plugins/lark/ui/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Lark settings</title>
+    <script type="module" crossorigin src="./assets/index-D8Amoe6a.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-CGUVAMsv.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/agent-file.js

@@ -46,7 +46,6 @@ export function scaffoldAgentSpec(id) {
         instructions: "You are a helpful agent.",
         executor: {
             runtime: "claude",
-            model: "claude-sonnet-4-6",
             reasoningEffort: "medium",
             // Runtime budget (edit/remove as needed): timeout is enforced on every
             // runtime; retry maps to per-runtime env. maxIterations (claude only) and

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/bundled-plugins.d.ts

@@ -0,0 +1,15 @@
+export interface EnsureBundledPluginsResult {
+    status: "ready" | "unavailable";
+    installed: string[];
+    updated: string[];
+    unchanged: string[];
+    marketplacePath?: string;
+}
+export declare function ensureBundledOfficialPlugins(options?: {
+    bundleDirectory?: string;
+    defaultPlugins?: readonly string[];
+    onProgress?: (message: string) => void;
+    /** Reclaim supervisor leases left by a prior daemon process. The caller
+     * must already hold the exclusive RYNX_HOME daemon-owner lock. */
+    reclaimHostLeases?: boolean;
+}): Promise<EnsureBundledPluginsResult>;

package/dist/bundled-plugins.js

@@ -0,0 +1,134 @@
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, renameSync, rmSync, } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { isAbsolute, join } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import { removePluginRuntimeLease } from "@rynx-ai/plugin-sdk";
+import { pluginDataDir, preparePluginInstallation, } from "./plugin-installer.js";
+import { PLUGIN_HOST_RUNTIME_LEASE_IDS } from "./plugin-host-leases.js";
+import { addPluginMarketplace, resolveMarketplacePlugin, } from "./plugin-marketplace.js";
+import { DEFAULT_BUNDLED_PLUGINS, OFFICIAL_MARKETPLACE_ID, } from "./official-plugins.js";
+import { getPlugin, setPluginEnabled } from "./plugin-store.js";
+export async function ensureBundledOfficialPlugins(options = {}) {
+    const configuredBundle = options.bundleDirectory ?? process.env.RYNX_BUNDLED_PLUGINS_DIR?.trim();
+    const bundleDirectory = configuredBundle ?? fileURLToPath(new URL("../bundled-plugins", import.meta.url));
+    if (!isAbsolute(bundleDirectory)) {
+        throw new Error("bundled plugin directory must be an absolute path");
+    }
+    if (!existsSync(bundleDirectory)) {
+        if (configuredBundle) {
+            throw new Error(`bundled plugin directory not found: ${bundleDirectory}`);
+        }
+        return emptyResult("unavailable");
+    }
+    if (!lstatSync(bundleDirectory).isDirectory()) {
+        throw new Error(`bundled plugin path is not a directory: ${bundleDirectory}`);
+    }
+    const marketplacePath = syncBundledMarketplace(bundleDirectory);
+    await addPluginMarketplace(marketplacePath, {
+        allowSourceRebind: true,
+        builtIn: true,
+        onProgress: options.onProgress,
+    });
+    const result = {
+        ...emptyResult("ready"),
+        marketplacePath,
+    };
+    for (const identity of options.defaultPlugins ?? DEFAULT_BUNDLED_PLUGINS) {
+        if (options.reclaimHostLeases)
+            reclaimPluginHostLeases(identity);
+        const resolved = resolveMarketplacePlugin(identity);
+        const prepared = await preparePluginInstallation(resolved.spec, options.onProgress, {
+            marketplaceId: OFFICIAL_MARKETPLACE_ID,
+            expectedId: resolved.pluginId,
+            expectedIdentity: identity,
+        });
+        try {
+            if (prepared.existing?.integrity === prepared.integrity) {
+                result.unchanged.push(identity);
+                continue;
+            }
+            const updating = Boolean(prepared.existing);
+            await prepared.commit({ expectedDigest: prepared.integrity });
+            if (!updating)
+                setPluginEnabled(identity, false);
+            (updating ? result.updated : result.installed).push(identity);
+        }
+        finally {
+            prepared.discard();
+        }
+    }
+    return result;
+}
+function reclaimPluginHostLeases(identity) {
+    const installed = getPlugin(identity);
+    if (!installed)
+        return;
+    const dataDir = pluginDataDir(installed.marketplaceId, installed.pluginId);
+    for (const leaseId of PLUGIN_HOST_RUNTIME_LEASE_IDS) {
+        removePluginRuntimeLease(dataDir, leaseId);
+    }
+}
+function syncBundledMarketplace(bundleDirectory) {
+    const distributionRoot = join(rynxHome(), "distribution");
+    const marketplacePath = join(distributionRoot, "official-market");
+    mkdirSync(distributionRoot, { recursive: true, mode: 0o700 });
+    const transactionDirectory = mkdtempSync(join(distributionRoot, "official-market-stage-"));
+    const stagedMarketplace = join(transactionDirectory, "market");
+    const backupPath = join(distributionRoot, `official-market-backup-${process.pid}-${Date.now()}`);
+    let backedUp = false;
+    try {
+        copyBundledTree(bundleDirectory, stagedMarketplace);
+        if (existsSync(marketplacePath)) {
+            renameSync(marketplacePath, backupPath);
+            backedUp = true;
+        }
+        try {
+            renameSync(stagedMarketplace, marketplacePath);
+        }
+        catch (error) {
+            if (backedUp && !existsSync(marketplacePath)) {
+                renameSync(backupPath, marketplacePath);
+                backedUp = false;
+            }
+            throw error;
+        }
+        if (backedUp) {
+            rmSync(backupPath, { recursive: true, force: true });
+            backedUp = false;
+        }
+        return marketplacePath;
+    }
+    finally {
+        rmSync(transactionDirectory, { recursive: true, force: true });
+        if (backedUp && !existsSync(marketplacePath) && existsSync(backupPath)) {
+            renameSync(backupPath, marketplacePath);
+        }
+    }
+}
+function copyBundledTree(source, destination) {
+    const info = lstatSync(source);
+    const mode = info.mode & 0o777;
+    if (info.isSymbolicLink()) {
+        throw new Error(`bundled plugin tree must not contain symbolic links: ${source}`);
+    }
+    if (info.isDirectory()) {
+        mkdirSync(destination, { recursive: true, mode: 0o700 });
+        for (const entry of readdirSync(source)) {
+            copyBundledTree(join(source, entry), join(destination, entry));
+        }
+        return;
+    }
+    if (!info.isFile()) {
+        throw new Error(`bundled plugin tree contains an unsupported entry: ${source}`);
+    }
+    copyFileSync(source, destination);
+    chmodSync(destination, mode);
+}
+function emptyResult(status) {
+    return {
+        status,
+        installed: [],
+        updated: [],
+        unchanged: [],
+    };
+}

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/control-deps.d.ts

@@ -1,2 +1,6 @@
-import type { ControlPlaneDeps } from "@rynx-ai/server";
-export declare function buildControlDeps(): ControlPlaneDeps;
+import { type AgentRuntimeId, type AppConfig } from "@rynx-ai/core";
+import { type ControlPlaneDeps } from "@rynx-ai/server";
+import type { ControlAgentModelOption } from "@rynx-ai/protocol/control";
+export declare function buildControlDeps(config: AppConfig): ControlPlaneDeps;
+/** Project a Runtime-native model catalog into the control-plane option shape. */
+export declare function listControlAgentModels(config: AppConfig, runtime: AgentRuntimeId): Promise<ControlAgentModelOption[]>;