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

package/dist/control-deps.js

@@ -1,107 +1,78 @@
 /**
  * Assemble the daemon-side {@link ControlPlaneDeps} the server needs to serve
- * the control console: db-backed channel + instance mutators, file-backed agent
- * specs, channel-type info from the loaded plugins, and a log tail. Plugins are
- * managed via the CLI, not here. Keeps `~/.rynx` knowledge in the daemon (the
+ * the control console: file-backed agent specs, skills, sessions, and a log
+ * tail. Plugin-private configuration is served by each plugin. Keeps `~/.rynx` knowledge in the daemon (the
  * composition root); the server stays storage-agnostic.
  */
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { listAgentSpecs, loadAgentSpec, rynxHome } from "@rynx-ai/core";
+import { listAgentSpecs, loadAgentSpec, rynxHome, scanLocalRuntimesInWorker, } from "@rynx-ai/core";
+import { listRuntimeModels } from "@rynx-ai/server";
 import { createEmulatorControlDeps } from "@rynx-ai/emulator";
-import { normalizePluginConfig } from "@rynx-ai/plugin-sdk";
 import { removeAgentSpec, writeAgentSpec } from "./agent-file.js";
-import { getCatalogSkill, installCatalogSkill, listCatalogSkills, readCatalogSkillFile, removeCatalogSkill, } from "./skills-catalog.js";
-import { createChannel, getChannel, listChannels, removeChannel, renameChannel, setChannelOptions, } from "./channel-store.js";
-import { createInstance, listInstances, removeInstance, setInstanceAgent, setInstanceEnabled, } from "./instance-store.js";
-import { getChannelType, listChannelTypes } from "./registry.js";
+import { getCatalogSkill, importLocalCatalogSkills, importCatalogSkillsFromArchive, installCatalogSkill, listCatalogSkills, readCatalogSkillFile, removeCatalogSkill, scanLocalCatalogSkillCandidates, } from "./skills-catalog.js";
 import { createSessionMeta, getSessionMeta, listSessionMetas, removeSessionMeta, setSessionTitle, } from "./session-meta-store.js";
 import { consumeControlLink } from "./control-link-store.js";
-export function buildControlDeps() {
+const RUNTIME_OPTIONS_CACHE_MS = 30_000;
+export function buildControlDeps(config) {
+    let runtimeOptionsCache;
+    let runtimeOptionsInFlight;
+    const listAgentRuntimeOptions = async (options = {}) => {
+        const now = Date.now();
+        if (!options.refresh && runtimeOptionsCache && runtimeOptionsCache.expiresAt > now) {
+            return runtimeOptionsCache.value;
+        }
+        if (!options.refresh && runtimeOptionsInFlight)
+            return runtimeOptionsInFlight;
+        const scan = async () => {
+            const runtimes = await scanLocalRuntimesInWorker();
+            const value = await Promise.all(runtimes.map(async (runtime) => {
+                return {
+                    id: runtime.id,
+                    name: runtime.displayName,
+                    binary: runtime.binary,
+                    ...(runtime.executablePath ? { executablePath: runtime.executablePath } : {}),
+                    ...(runtime.version ? { version: runtime.version } : {}),
+                    available: runtime.available,
+                    models: await listControlAgentModels(config, runtime.id),
+                };
+            }));
+            runtimeOptionsCache = { expiresAt: Date.now() + RUNTIME_OPTIONS_CACHE_MS, value };
+            return value;
+        };
+        runtimeOptionsInFlight = scan();
+        try {
+            return await runtimeOptionsInFlight;
+        }
+        finally {
+            runtimeOptionsInFlight = undefined;
+        }
+    };
     return {
-        // ── channel types (from loaded plugins) ──────────────────────────────
-        listChannelTypes: () => listChannelTypes().map((descriptor) => ({
-            type: descriptor.type,
-            configSchema: descriptor.configSchema,
-            authorize: Boolean(descriptor.authorize),
-        })),
-        // ── channels (config + credentials) ──────────────────────────────────
-        listChannels: () => listChannels(),
-        createChannel: (input) => {
-            if (!getChannelType(input.type))
-                throw new Error(`unknown chat channel type: ${input.type}`);
-            return {
-                id: createChannel({
-                    ...input,
-                    ...(input.options !== undefined
-                        ? { options: normalizeChannelOptions(input.type, input.options) }
-                        : {}),
-                }).id,
-            };
-        },
-        setChannel: (id, patch) => {
-            let normalizedOptions;
-            if (patch.options !== undefined) {
-                const current = getChannel(id);
-                if (!current)
-                    throw new Error(`channel not found: ${id}`);
-                normalizedOptions = normalizeChannelOptions(current.type, {
-                    ...(current.options ?? {}),
-                    ...patch.options,
-                });
-            }
-            if (patch.name !== undefined)
-                renameChannel(id, patch.name);
-            if (normalizedOptions !== undefined)
-                setChannelOptions(id, normalizedOptions);
-        },
-        removeChannel: (id) => {
-            removeChannel(id);
-        },
-        authorizeChannel: (type, context, emit, signal) => {
-            const descriptor = getChannelType(type);
-            if (!descriptor?.authorize) {
-                throw new Error(`channel type "${type}" has no authorize flow`);
-            }
-            return descriptor.authorize(emit, signal, context);
-        },
-        // ── instances (channel + agent binding) ──────────────────────────────
-        listInstancesConfig: () => listInstances().map((i) => ({
-            id: i.id,
-            channelId: i.channelId,
-            channelName: i.channelName,
-            type: i.type,
-            agent: i.agent,
-            enabled: i.enabled,
-        })),
-        createInstance: (input) => ({ id: createInstance(input).id }),
-        setInstance: (id, patch) => {
-            if (patch.agent !== undefined)
-                setInstanceAgent(id, patch.agent);
-            if (patch.enabled !== undefined)
-                setInstanceEnabled(id, patch.enabled);
-        },
-        removeInstance: (id) => {
-            removeInstance(id);
-        },
         // ── declarative agents ───────────────────────────────────────────────
         listAgents: async () => (await listAgentSpecs()).map((spec) => ({
             id: spec.id,
             name: spec.name,
+            description: spec.description,
             runtime: spec.executor?.runtime,
-            model: spec.executor?.model,
+            ...(spec.executor?.model ? { model: spec.executor.model } : {}),
+            skillCount: spec.skills?.length ?? 0,
         })),
         getAgent: (id) => loadAgentSpec(id),
         writeAgent: (id, spec) => {
             writeAgentSpec(id, spec);
         },
         removeAgent: (id) => removeAgentSpec(id),
+        listAgentRuntimeOptions,
         // ── skills catalog ───────────────────────────────────────────────────
         listSkills: () => listCatalogSkills(),
         getSkill: (name) => getCatalogSkill(name),
         readSkillFile: (name, file) => readCatalogSkillFile(name, file),
         installSkill: (recipe) => installCatalogSkill(recipe),
         removeSkill: (name) => removeCatalogSkill(name),
+        scanLocalSkills: (runtime) => scanLocalCatalogSkillCandidates(runtime),
+        importLocalSkills: (runtime, keys) => importLocalCatalogSkills(runtime, keys),
+        importSkillArchive: (filename, contentBase64) => importCatalogSkillsFromArchive(filename, contentBase64),
         // ── emulator proxy (single seam: the emulator package owns the surface) ─
         emulator: createEmulatorControlDeps(),
         // ── control-plane sessions (meta persisted; status held by the server) ─
@@ -114,12 +85,47 @@ export function buildControlDeps() {
         tailLogs: (instanceId, lines) => tailLogs(instanceId, lines),
     };
 }
-function normalizeChannelOptions(type, options) {
-    const descriptor = getChannelType(type);
-    if (!descriptor)
-        throw new Error(`unknown chat channel type: ${type}`);
-    const schema = descriptor.configSchema ?? [];
-    return schema.length > 0 ? normalizePluginConfig(schema, options) : { ...options };
+/** Project a Runtime-native model catalog into the control-plane option shape. */
+export async function listControlAgentModels(config, runtime) {
+    const catalog = await listRuntimeModels(config, runtime);
+    return (catalog?.data ?? [])
+        .filter((model) => model.hidden !== true)
+        .map((model) => ({
+        id: model.model || model.id,
+        label: model.displayName || model.model || model.id,
+        ...(model.description ? { description: model.description } : {}),
+        ...(model.isDefault ? { isDefault: true } : {}),
+        ...(model.defaultReasoningEffort
+            ? { defaultReasoningEffort: model.defaultReasoningEffort }
+            : {}),
+        reasoningOptions: model.supportedReasoningEfforts?.length
+            ? model.supportedReasoningEfforts.map((effort) => ({
+                value: effort.reasoningEffort,
+                label: reasoningLabel(effort.reasoningEffort),
+                ...(effort.description ? { description: effort.description } : {}),
+            }))
+            : fallbackReasoningOptions(runtime, model.model || model.id),
+    }));
+}
+function fallbackReasoningOptions(runtime, model) {
+    const values = runtime === "claude"
+        ? model.toLowerCase().includes("opus")
+            ? ["low", "medium", "high", "xhigh"]
+            : ["low", "medium", "high"]
+        : ["none", "minimal", "low", "medium", "high", "xhigh"];
+    return values.map((value) => ({ value, label: reasoningLabel(value) }));
+}
+function reasoningLabel(value) {
+    return {
+        none: "None",
+        minimal: "Minimal",
+        low: "Low",
+        medium: "Medium",
+        high: "High",
+        xhigh: "Extra high",
+        max: "Max",
+        ultra: "Ultra",
+    }[value] ?? value;
 }
 /** Tail the daemon's merged pm2 logs, best-effort filtered by instance id. */
 async function tailLogs(instanceId, lines) {

package/dist/daemon-server.d.ts

@@ -9,10 +9,16 @@ 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. */
     acquireOwner?: () => Promise<DaemonOwnerLease>;
+    /** Runs after the exclusive daemon-owner lock is acquired and before plugin
+     * records are loaded or runners are started. */
+    preparePlugins?: () => Promise<void>;
     /** Test/deployment seam for the always-available Direct Runtime socket. */
     loadDirectConfig?: () => Promise<DirectRuntimeConfig>;
     /** Test seam for listener lifecycle and bind failures. */
@@ -22,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, 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