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

package/dist/provider-cli-service.js

@@ -0,0 +1,510 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import { access, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { spawn } from "node:child_process";
+import { getRuntimeProfile } from "@rynx-ai/core";
+const STATUS_COMMAND_TIMEOUT_MS = 8_000;
+const OPERATION_TIMEOUT_MS = 10 * 60_000;
+const COMMAND_TERMINATION_GRACE_MS = 2_000;
+const OUTPUT_MAX_BYTES = 16 * 1024;
+const LATEST_CACHE_MS = 15 * 60_000;
+const TRAEX_INSTALLER_MAX_BYTES = 2 * 1024 * 1024;
+const TRAEX_INSTALLER_URL = "https://tosv-myabc.byted.org/obj/trae-common-2-asiasebd/traex/install/install_all_platforms.sh";
+const PROVIDER_PACKAGES = {
+    codex: "@openai/codex",
+    claude: "@anthropic-ai/claude-code",
+};
+const PROVIDER_CLI_IDS = ["codex", "claude", "traex"];
+export class ProviderCliService {
+    env;
+    platform;
+    now;
+    runCommand;
+    resolveCommand;
+    download;
+    latestCache = new Map();
+    jobs = new Map();
+    activeJobs = new Map();
+    constructor(deps = {}) {
+        this.env = { ...process.env, ...deps.env };
+        this.platform = deps.platform ?? process.platform;
+        this.now = deps.now ?? (() => new Date());
+        this.runCommand = deps.run ?? runCommand;
+        this.resolveCommand = deps.resolveExecutable ?? resolveExecutable;
+        this.download = deps.download ?? downloadBounded;
+    }
+    async listStatuses() {
+        const providerClis = await Promise.all(PROVIDER_CLI_IDS.map((id) => this.inspect(id)));
+        return { providerClis };
+    }
+    async startOperation(provider, operation) {
+        const activeId = this.activeJobs.get(provider);
+        if (activeId) {
+            const active = this.jobs.get(activeId);
+            if (active?.state === "running") {
+                if (active.operation === operation)
+                    return { ...active };
+                throw new ProviderCliOperationError("failed_precondition", `${provider} already has a ${active.operation} operation in progress`);
+            }
+        }
+        const status = await this.inspect(provider, operation === "update");
+        if (operation === "install" && status.availability === "installed") {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} is already installed`);
+        }
+        if (operation === "update" && status.availability !== "installed") {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} is not installed`);
+        }
+        if (operation === "install" && !status.canInstall) {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} cannot be installed automatically on this machine`);
+        }
+        if (operation === "update" && !status.canUpdate) {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} cannot be updated automatically on this machine`);
+        }
+        const job = {
+            id: randomUUID(),
+            provider,
+            operation,
+            state: "running",
+            stage: "starting",
+            startedAt: this.now().toISOString(),
+        };
+        this.jobs.set(job.id, job);
+        this.activeJobs.set(provider, job.id);
+        this.pruneJobs();
+        void this.execute(job.id, status).catch(() => undefined);
+        return { ...job };
+    }
+    getJob(id) {
+        const job = this.jobs.get(id);
+        return job ? { ...job } : undefined;
+    }
+    async inspect(provider, includeLatest = true) {
+        const profile = getRuntimeProfile(provider);
+        const checkedAt = this.now().toISOString();
+        const executablePath = await this.resolveProviderExecutable(provider);
+        const npmPath = provider === "traex"
+            ? null
+            : await this.resolveCommand("npm", this.env, this.platform);
+        const canInstall = provider === "traex"
+            ? this.platform !== "win32"
+            : npmPath !== null && this.platform !== "win32";
+        if (!executablePath) {
+            const latestVersion = includeLatest
+                ? await this.latestVersion(provider, undefined, npmPath)
+                : undefined;
+            return {
+                id: provider,
+                name: profile.displayName,
+                binary: profile.defaultBinary,
+                availability: "missing",
+                ...(latestVersion ? { latestVersion } : {}),
+                updateState: "unknown",
+                authState: "unknown",
+                canInstall,
+                canUpdate: false,
+                checkedAt,
+            };
+        }
+        let currentVersion;
+        let versionError;
+        try {
+            const result = await this.runCommand(executablePath, ["--version"], {
+                timeoutMs: STATUS_COMMAND_TIMEOUT_MS,
+                env: this.env,
+            });
+            if (result.exitCode !== 0)
+                throw new Error(commandFailure(result));
+            currentVersion = extractVersion(`${result.stdout}\n${result.stderr}`);
+            if (!currentVersion)
+                throw new Error("version output was not recognized");
+        }
+        catch (error) {
+            versionError = errorMessage(error);
+        }
+        const [auth, latestVersion] = await Promise.all([
+            currentVersion
+                ? this.authStatus(provider, executablePath)
+                : Promise.resolve({ state: "unknown" }),
+            includeLatest
+                ? this.latestVersion(provider, executablePath, npmPath)
+                : Promise.resolve(undefined),
+        ]);
+        const updateState = currentVersion && latestVersion
+            ? (compareVersions(currentVersion, latestVersion) < 0 ? "available" : "current")
+            : "unknown";
+        return {
+            id: provider,
+            name: profile.displayName,
+            binary: profile.defaultBinary,
+            executablePath,
+            availability: currentVersion ? "installed" : "broken",
+            ...(currentVersion ? { currentVersion } : {}),
+            ...(latestVersion ? { latestVersion } : {}),
+            updateState,
+            authState: auth.state,
+            ...(auth.mode ? { authMode: auth.mode } : {}),
+            canInstall: !currentVersion && canInstall,
+            canUpdate: Boolean(currentVersion) && this.platform !== "win32",
+            checkedAt,
+            ...(versionError ? { error: versionError } : {}),
+        };
+    }
+    async resolveProviderExecutable(provider) {
+        const candidates = provider === "traex" ? ["traex", "traecli"] : [provider];
+        for (const candidate of candidates) {
+            const resolved = await this.resolveCommand(candidate, this.env, this.platform);
+            if (resolved)
+                return resolved;
+        }
+        return null;
+    }
+    async authStatus(provider, executablePath) {
+        try {
+            const args = provider === "claude" ? ["auth", "status", "--json"] : ["login", "status"];
+            const result = await this.runCommand(executablePath, args, {
+                timeoutMs: STATUS_COMMAND_TIMEOUT_MS,
+                env: this.env,
+            });
+            const output = `${result.stdout}\n${result.stderr}`.trim();
+            if (provider === "claude") {
+                const parsed = JSON.parse(output);
+                if (parsed.loggedIn === true) {
+                    const mode = [parsed.authMethod, parsed.apiProvider]
+                        .filter((value) => typeof value === "string" && value.length > 0)
+                        .join(" · ");
+                    return { state: "ready", ...(mode ? { mode } : {}) };
+                }
+                if (parsed.loggedIn === false)
+                    return { state: "required" };
+                return { state: "unknown" };
+            }
+            if (result.exitCode === 0 && /logged in/i.test(output)) {
+                const match = /logged in(?: using| as)?\s+(.+)/i.exec(output);
+                return { state: "ready", ...(match?.[1]?.trim() ? { mode: match[1].trim() } : {}) };
+            }
+            if (/not logged in|logged out|login required/i.test(output))
+                return { state: "required" };
+            return { state: result.exitCode === 0 ? "unknown" : "required" };
+        }
+        catch {
+            return { state: "unknown" };
+        }
+    }
+    async latestVersion(provider, executablePath, npmPath) {
+        const now = this.now().getTime();
+        const cached = this.latestCache.get(provider);
+        if (cached && cached.expiresAt > now)
+            return cached.value;
+        let value;
+        try {
+            if (provider === "traex") {
+                if (!executablePath)
+                    return undefined;
+                const result = await this.runCommand(executablePath, ["update", "check"], {
+                    timeoutMs: STATUS_COMMAND_TIMEOUT_MS,
+                    env: this.env,
+                });
+                if (result.exitCode === 0) {
+                    value = /Latest TRAE CLI version:\s*([^\s]+)/i.exec(`${result.stdout}\n${result.stderr}`)?.[1];
+                }
+            }
+            else if (npmPath) {
+                const packageName = PROVIDER_PACKAGES[provider];
+                const result = await this.runCommand(npmPath, ["view", `${packageName}@latest`, "version", "--json"], { timeoutMs: STATUS_COMMAND_TIMEOUT_MS, env: this.env });
+                if (result.exitCode === 0)
+                    value = extractVersion(result.stdout);
+            }
+        }
+        catch {
+            value = undefined;
+        }
+        this.latestCache.set(provider, { value, expiresAt: now + LATEST_CACHE_MS });
+        return value;
+    }
+    async execute(jobId, previousStatus) {
+        const job = this.jobs.get(jobId);
+        if (!job)
+            return;
+        try {
+            job.stage = job.operation === "install" ? "installing" : "updating";
+            if (job.operation === "install") {
+                await this.install(job.provider);
+            }
+            else {
+                await this.update(job.provider, previousStatus.executablePath);
+            }
+            job.stage = "verifying";
+            this.latestCache.delete(job.provider);
+            const verified = await this.inspect(job.provider, false);
+            if (verified.availability !== "installed") {
+                throw new Error(verified.error ?? `${verified.name} was not found on the daemon PATH after the operation`);
+            }
+            if (job.operation === "update") {
+                const previousVersion = previousStatus.currentVersion;
+                const verifiedVersion = verified.currentVersion;
+                if (!previousVersion || !verifiedVersion || compareVersions(verifiedVersion, previousVersion) <= 0) {
+                    throw new Error(`${verified.name} reported success but its version did not change`);
+                }
+                if (previousStatus.latestVersion
+                    && compareVersions(verifiedVersion, previousStatus.latestVersion) < 0) {
+                    throw new Error(`${verified.name} updated to ${verifiedVersion}, below the expected ${previousStatus.latestVersion}`);
+                }
+            }
+            job.stage = "complete";
+            job.state = "succeeded";
+            job.finishedAt = this.now().toISOString();
+        }
+        catch (error) {
+            job.state = "failed";
+            job.finishedAt = this.now().toISOString();
+            job.error = boundError(errorMessage(error));
+        }
+        finally {
+            if (this.activeJobs.get(job.provider) === job.id)
+                this.activeJobs.delete(job.provider);
+        }
+    }
+    async install(provider) {
+        if (provider === "traex") {
+            await this.installTraex();
+            return;
+        }
+        const npmPath = await this.resolveCommand("npm", this.env, this.platform);
+        if (!npmPath)
+            throw new Error("npm is not available on PATH");
+        const result = await this.runCommand(npmPath, ["install", "--global", `${PROVIDER_PACKAGES[provider]}@latest`, "--no-audit", "--no-fund"], { timeoutMs: OPERATION_TIMEOUT_MS, env: this.env });
+        if (result.exitCode !== 0)
+            throw new Error(commandFailure(result));
+    }
+    async update(provider, executablePath) {
+        const result = await this.runCommand(executablePath, ["update"], {
+            timeoutMs: OPERATION_TIMEOUT_MS,
+            env: this.env,
+        });
+        if (result.exitCode !== 0)
+            throw new Error(commandFailure(result));
+    }
+    async installTraex() {
+        if (this.platform === "win32")
+            throw new Error("automatic Traex installation is not supported on Windows");
+        const script = await this.download(TRAEX_INSTALLER_URL, TRAEX_INSTALLER_MAX_BYTES);
+        const directory = await mkdtemp(join(tmpdir(), "rynx-traex-install-"));
+        const scriptPath = join(directory, "install.sh");
+        try {
+            await writeFile(scriptPath, script, { mode: 0o700 });
+            const shPath = await this.resolveCommand("sh", this.env, this.platform);
+            if (!shPath)
+                throw new Error("sh is not available on PATH");
+            const result = await this.runCommand(shPath, [scriptPath], {
+                timeoutMs: OPERATION_TIMEOUT_MS,
+                env: installerEnvironment(this.env, {
+                    TRAEX_INSTALL_ASSUME_YES: "1",
+                    TRAEX_INSTALL_MIGRATE_BREW: "0",
+                    TRAEX_INSTALL_REMOVE_BREW: "0",
+                    TRAEX_INSTALL_CHANNEL: "stable",
+                }),
+            });
+            if (result.exitCode !== 0)
+                throw new Error(commandFailure(result));
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+    pruneJobs() {
+        if (this.jobs.size <= 50)
+            return;
+        const finished = [...this.jobs.values()]
+            .filter((job) => job.state !== "running")
+            .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+        for (const job of finished.slice(0, this.jobs.size - 50))
+            this.jobs.delete(job.id);
+    }
+}
+export class ProviderCliOperationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ProviderCliOperationError";
+    }
+}
+async function resolveExecutable(binary, env, platform) {
+    const pathValue = env.PATH ?? env.Path ?? env.path ?? "";
+    const extensions = platform === "win32"
+        ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+        : [""];
+    for (const directory of pathValue.split(delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = join(directory, platform === "win32" ? `${binary}${extension}` : binary);
+            try {
+                await access(candidate, fsConstants.X_OK);
+                return candidate;
+            }
+            catch {
+                // Continue through the daemon's effective PATH.
+            }
+        }
+    }
+    return null;
+}
+function runCommand(executable, args, options) {
+    return new Promise((resolve, reject) => {
+        const detached = process.platform !== "win32";
+        const child = spawn(executable, args, {
+            env: options.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            detached,
+        });
+        let timedOut = false;
+        let settled = false;
+        let forceTimer;
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        const append = (current, chunk) => Buffer.concat([current, chunk]).subarray(0, OUTPUT_MAX_BYTES);
+        child.stdout.on("data", (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr.on("data", (chunk) => { stderr = append(stderr, chunk); });
+        const clearTimers = () => {
+            clearTimeout(timer);
+            if (forceTimer)
+                clearTimeout(forceTimer);
+        };
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            reject(error);
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminateCommand(child.pid, child, "SIGTERM", detached);
+            forceTimer = setTimeout(() => {
+                terminateCommand(child.pid, child, "SIGKILL", detached);
+                rejectOnce(new Error(`command timed out after ${options.timeoutMs}ms`));
+            }, COMMAND_TERMINATION_GRACE_MS);
+            forceTimer.unref();
+        }, options.timeoutMs);
+        timer.unref();
+        child.once("error", (error) => {
+            if (!timedOut)
+                rejectOnce(error);
+        });
+        child.once("close", (code) => {
+            if (settled || timedOut)
+                return;
+            settled = true;
+            clearTimers();
+            resolve({
+                exitCode: code ?? -1,
+                stdout: stdout.toString("utf8"),
+                stderr: stderr.toString("utf8"),
+            });
+        });
+    });
+}
+async function downloadBounded(url, maximumBytes) {
+    const requestedUrl = new URL(url);
+    if (requestedUrl.protocol !== "https:")
+        throw new Error("installer URL must use HTTPS");
+    const response = await fetch(url, { redirect: "follow" });
+    if (!response.ok)
+        throw new Error(`installer download failed with HTTP ${response.status}`);
+    const finalUrl = new URL(response.url || url);
+    if (finalUrl.protocol !== "https:" || finalUrl.origin !== requestedUrl.origin) {
+        throw new Error("installer download redirected outside the trusted origin");
+    }
+    const expectedMd5 = response.headers.get("content-md5");
+    if (!expectedMd5)
+        throw new Error("installer response did not include integrity metadata");
+    const declaredLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+    if (Number.isFinite(declaredLength) && declaredLength > maximumBytes) {
+        throw new Error("installer download exceeded the accepted size");
+    }
+    if (!response.body)
+        throw new Error("installer download returned an empty response");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        length += value.byteLength;
+        if (length > maximumBytes) {
+            await reader.cancel();
+            throw new Error("installer download exceeded the accepted size");
+        }
+        chunks.push(value);
+    }
+    if (length === 0)
+        throw new Error("installer download returned an empty response");
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    const actualMd5 = createHash("md5").update(bytes).digest("base64");
+    if (actualMd5 !== expectedMd5)
+        throw new Error("installer response failed its integrity check");
+    return bytes;
+}
+function terminateCommand(pid, child, signal, detached) {
+    try {
+        if (detached && pid)
+            process.kill(-pid, signal);
+        else
+            child.kill(signal);
+    }
+    catch {
+        // The process may have exited between the timeout and signal delivery.
+    }
+}
+function installerEnvironment(env, additions) {
+    const allowed = [
+        "PATH", "HOME", "USER", "SHELL", "TMPDIR",
+        "LANG", "LC_ALL",
+        "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME",
+        "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY",
+        "http_proxy", "https_proxy", "no_proxy",
+        "SSL_CERT_FILE", "SSL_CERT_DIR",
+    ];
+    const result = { ...additions };
+    for (const key of allowed) {
+        if (env[key] !== undefined)
+            result[key] = env[key];
+    }
+    return result;
+}
+function extractVersion(output) {
+    return /\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/.exec(output)?.[0];
+}
+function compareVersions(left, right) {
+    const a = left.split(/[.+-]/).slice(0, 3).map((value) => Number.parseInt(value, 10));
+    const b = right.split(/[.+-]/).slice(0, 3).map((value) => Number.parseInt(value, 10));
+    for (let index = 0; index < 3; index += 1) {
+        const delta = (a[index] ?? 0) - (b[index] ?? 0);
+        if (delta !== 0)
+            return delta;
+    }
+    const leftPrerelease = left.includes("-");
+    const rightPrerelease = right.includes("-");
+    if (leftPrerelease !== rightPrerelease)
+        return leftPrerelease ? -1 : 1;
+    return left.localeCompare(right);
+}
+function commandFailure(result) {
+    return boundError(result.stderr.trim() || result.stdout.trim() || `command exited ${result.exitCode}`);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function boundError(message) {
+    return message.replace(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, 1024) || "operation failed";
+}

package/dist/registry.d.ts

@@ -1,23 +1,10 @@
-import { type ChannelInstanceDescriptor, type ChannelTypeDescriptor, type RynxPlugin } from "@rynx-ai/core";
-import { type PluginRecord } from "./plugin-store.js";
-/** Directory npm-installed plugins live under (override via `RYNX_PLUGINS_DIR`). */
+import { type ChannelInstanceDescriptor, type ChannelTypeDescriptor } from "@rynx-ai/core";
+import type { PluginSupervisor } from "./plugin-supervisor.js";
+/** Directory plugin packages and staging data live under. */
 export declare function pluginsDir(): string;
-/** All channel types currently available (from loaded plugins). */
 export declare function listChannelTypes(): ChannelTypeDescriptor[];
 export declare function getChannelType(type: string): ChannelTypeDescriptor | undefined;
-/** Absolute package directory a plugin record resolves to. */
-export declare function pluginPkgDir(rec: Pick<PluginRecord, "source" | "spec">): string;
-/** Import a package directory's `plugin` manifest export (or null if absent). */
-export declare function importPluginManifest(pkgDir: string): Promise<RynxPlugin | null>;
-/**
- * Rebuild the channel-type catalog from the enabled plugins in the registry.
- * Call at boot and after an install/enable/disable change. Failures to load a
- * single plugin are warned and skipped — one bad plugin can't break the rest.
- */
-export declare function loadPlugins(warn?: (message: string) => void): Promise<void>;
-/**
- * Resolve every enabled instance (joined with its channel) to a mountable
- * descriptor, binding each to the factory its channel `type` resolves to in the
- * catalog. Unknown types (no plugin providing them) are skipped.
- */
+/** Rebuild the catalog from static manifests projected by the supervisor. */
+export declare function loadPlugins(supervisor: PluginSupervisor, warn?: (message: string) => void): Promise<void>;
+/** Join enabled channel instances to their remote runner-backed factories. */
 export declare function resolveChannelInstances(warn?: (message: string) => void): Promise<ChannelInstanceDescriptor[]>;

package/dist/registry.js

@@ -1,117 +1,52 @@
 /**
- * Plugin loader + channel-type catalog.
+ * Static plugin catalog.
  *
- * There are no built-in channels: the daemon imports whatever plugins are
- * recorded (enabled) in the `plugins` table, reads each one's `plugin` manifest,
- * and collects the channel types they contribute into an in-memory catalog.
- * `loadPlugins()` (re)builds the catalog from the registry; everything else
- * reads the catalog synchronously. The installer calls `loadPlugins()` after a
- * change so a freshly-installed plugin's types appear without a restart.
+ * Installation records already contain validated pure-data manifests. This
+ * module joins their chat-channel declarations to host-side remote lifecycle
+ * adapters supplied by PluginSupervisor. It never imports an installed plugin
+ * entry point.
  */
-import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { pathToFileURL } from "node:url";
 import { rynxHome, } from "@rynx-ai/core";
 import { listEnabledDescriptors } from "./instance-store.js";
-import { listEnabledPlugins } from "./plugin-store.js";
-/** Directory npm-installed plugins live under (override via `RYNX_PLUGINS_DIR`). */
+/** Directory plugin packages and staging data live under. */
 export function pluginsDir() {
     return process.env.RYNX_PLUGINS_DIR?.trim() || join(rynxHome(), "plugins");
 }
-/** type → descriptor, rebuilt by {@link loadPlugins}. */
 const catalog = new Map();
-/** All channel types currently available (from loaded plugins). */
 export function listChannelTypes() {
     return [...catalog.values()];
 }
 export function getChannelType(type) {
     return catalog.get(type);
 }
-/** Resolve a plugin record to the file URL of its entry module. */
-function entryUrl(pkgDir) {
-    const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
-    let rel = pkg.rynx?.plugin;
-    if (!rel) {
-        const dot = pkg.exports && typeof pkg.exports === "object" && "." in pkg.exports
-            ? pkg.exports["."]
-            : pkg.exports;
-        if (typeof dot === "string") {
-            rel = dot;
-        }
-        else if (dot && typeof dot === "object") {
-            const cond = dot;
-            rel = cond.import ?? cond.default ?? cond.require;
-        }
-        rel = rel ?? pkg.main ?? "index.js";
-    }
-    return pathToFileURL(join(pkgDir, rel)).href;
-}
-/** Absolute package directory a plugin record resolves to. */
-export function pluginPkgDir(rec) {
-    // local: spec is an absolute directory; npm: resolve under the plugins prefix.
-    return rec.source === "local" ? rec.spec : join(pluginsDir(), "node_modules", ...rec.spec.split("/"));
-}
-/** Import a package directory's `plugin` manifest export (or null if absent). */
-export async function importPluginManifest(pkgDir) {
-    const mod = (await import(entryUrl(pkgDir)));
-    const plugin = (mod.plugin ?? mod.default);
-    return plugin && typeof plugin === "object" ? plugin : null;
-}
-function importPlugin(rec) {
-    return importPluginManifest(pluginPkgDir(rec));
-}
-/**
- * Rebuild the channel-type catalog from the enabled plugins in the registry.
- * Call at boot and after an install/enable/disable change. Failures to load a
- * single plugin are warned and skipped — one bad plugin can't break the rest.
- */
-export async function loadPlugins(warn = () => { }) {
+/** Rebuild the catalog from static manifests projected by the supervisor. */
+export async function loadPlugins(supervisor, warn = () => { }) {
     catalog.clear();
-    for (const rec of listEnabledPlugins()) {
-        let plugin;
-        try {
-            plugin = await importPlugin(rec);
-        }
-        catch (error) {
-            warn(`plugin "${rec.name}" failed to load: ${messageOf(error)}`);
-            continue;
-        }
-        if (!plugin) {
-            warn(`plugin "${rec.name}" has no \`plugin\` export — skipped`);
+    for (const channel of supervisor.createChannelTypeDescriptors()) {
+        if (catalog.has(channel.type)) {
+            warn(`chat channel type "${channel.type}" is declared by more than one plugin; later declaration ignored`);
             continue;
         }
-        for (const channel of plugin.channels ?? []) {
-            if (catalog.has(channel.type)) {
-                warn(`channel type "${channel.type}" already provided; "${rec.name}" ignored for it`);
-                continue;
-            }
-            catalog.set(channel.type, channel);
-        }
+        catalog.set(channel.type, channel);
     }
 }
-/**
- * Resolve every enabled instance (joined with its channel) to a mountable
- * descriptor, binding each to the factory its channel `type` resolves to in the
- * catalog. Unknown types (no plugin providing them) are skipped.
- */
+/** Join enabled channel instances to their remote runner-backed factories. */
 export async function resolveChannelInstances(warn = () => { }) {
     const instances = [];
-    for (const d of listEnabledDescriptors()) {
-        const descriptor = catalog.get(d.type);
-        if (!descriptor) {
-            warn(`unknown channel type "${d.type}" (instance "${d.instanceId}") — no installed plugin provides it; skipped`);
+    for (const descriptor of listEnabledDescriptors()) {
+        const channel = catalog.get(descriptor.type);
+        if (!channel) {
+            warn(`unknown chat channel type "${descriptor.type}" (instance "${descriptor.instanceId}") — no enabled plugin declares it; skipped`);
             continue;
         }
         instances.push({
-            instanceId: d.instanceId,
-            type: d.type,
-            factory: descriptor.factory,
-            options: d.options,
-            agent: d.agent,
+            instanceId: descriptor.instanceId,
+            type: descriptor.type,
+            factory: channel.factory,
+            options: descriptor.options,
+            agent: descriptor.agent,
         });
     }
     return instances;
 }
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}