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

package/dist/daemon-server.js

@@ -6,26 +6,28 @@
  * session registry. Keeping that wiring here avoids a second app-specific fork.
  */
 import { randomBytes, randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import WebSocket from "ws";
-import { loadConfig, rynxHome } from "@rynx-ai/core";
+import { loadConfig, resolveExecutionSnapshot, rynxHome, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { LOCAL_MANAGEMENT_PROTOCOL, } from "@rynx-ai/protocol/control";
 import { REMOTE_RUNTIME_CORE_PROTOCOL } from "@rynx-ai/protocol/remote-runtime";
 import { RUNTIME_BROWSER_INSPECT_MAX_MESSAGE_BYTES, RUNTIME_BROWSER_INSPECT_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-browser-inspect";
 import { RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY } from "@rynx-ai/protocol/runtime-browser-surface";
 import { RUNTIME_EMULATOR_SURFACE_SEMANTIC_CAPABILITY } from "@rynx-ai/protocol/runtime-emulator-surface";
-import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
+import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, MachineSessionServiceFailure, listRuntimeModels, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
 import { APP_BROWSER_HOST_BOOTSTRAP_TYPE, AppBrowserHostSupervisor, parseAppBrowserHostLaunchConfig, } from "./app-browser-host-supervisor.js";
 import { buildControlDeps } from "./control-deps.js";
 import { createBrowserArtifactManagementService } from "./browser-artifact-management.js";
 import { createDaemonBuildStatus } from "./daemon-build-status.js";
 import { BrowserRunnerSessionContextProvider } from "./browser-runner-session-context.js";
+import { removeLegacyPluginSkillSnapshot, snapshotEnabledPluginSkillSources, } from "./plugin-skill-context.js";
 import { isChromeForTestingHostSupported } from "./chrome-for-testing-store.js";
 import { ChromeInspectionManager, } from "./chrome-inspection-manager.js";
 import { createHeadlessBrowserHost } from "./headless-browser-host.js";
+import { db } from "./db.js";
 import { acquireDaemonOwner } from "./daemon-owner.js";
 import { DaemonDirectRuntimeAuthenticator } from "./direct-runtime-authenticator.js";
 import { DurableEmbeddedBrowserProfileHost } from "./embedded-browser-profile-cleanup.js";
@@ -34,13 +36,15 @@ import { isDaemonDirectRuntimeHostingSupported, loadOrCreateDaemonDirectRuntimeE
 import { cleanupLegacySessions } from "./migrations/cleanup-legacy-sessions.js";
 import { createMaintenanceManagementService } from "./maintenance-management.js";
 import { PluginManagementService } from "./plugin-management-service.js";
+import { addPluginMarketplace, listPluginMarketplaces, refreshPluginMarketplace, removePluginMarketplace, } from "./plugin-marketplace.js";
 import { PluginSupervisor } from "./plugin-supervisor.js";
 import { pruneInactivePluginInstallations } from "./plugin-installer.js";
 import { runPluginCliCommand } from "./plugin-cli.js";
-import { getPlugin, isRunnablePluginRecord, listEnabledPlugins } from "./plugin-store.js";
-import { loadPlugins, resolveChannelInstances } from "./registry.js";
+import { listPlugins } from "./plugin-store.js";
 import { SqliteSessionLogStore } from "./session-log-store.js";
+import { SqliteSessionForkStore } from "./session-fork-store.js";
 import { SqliteSessionResourceStore } from "./session-resource-store.js";
+import { createSessionFallbackWorkspace, discardSessionFallbackWorkspace, } from "./session-fallback-workspace.js";
 import { SessionBrowserCapabilityStore } from "./session-browser-capability-store.js";
 import { SqliteSessionEmulatorBindingStore } from "./session-emulator-binding-store.js";
 import { sessionRegistry } from "./session-meta-store.js";
@@ -52,6 +56,7 @@ import { DaemonRuntimeConnectionManager } from "./remote-runtime-connection-mana
 import { DaemonRuntimeTargetControl } from "./remote-runtime-target-control.js";
 import { RemoteRuntimeTargetStore } from "./remote-runtime-target-store.js";
 import { ProviderCliService } from "./provider-cli-service.js";
+import { SqliteRuntimeProjectStore } from "./runtime-project-store.js";
 const PLUGIN_CLI_OUTPUT_MAX_BYTES = 256 * 1024;
 const BROWSER_INSPECT_OPEN_TIMEOUT_MS = 10_000;
 const BROWSER_INSPECT_CLOSE_TIMEOUT_MS = 1_000;
@@ -59,6 +64,72 @@ const BROWSER_INSPECT_MAX_QUEUED_BYTES = 32 * 1024 * 1024;
 const DIRECT_RUNTIME_HOSTING_UNSUPPORTED = "Direct Runtime hosting is supported only on macOS and Linux until protected server-key storage is available on other operating systems";
 const require = createRequire(import.meta.url);
 const DAEMON_PACKAGE_VERSION = readDaemonPackageVersion();
+async function resolveSessionExecutionSnapshot(input) {
+    return {
+        ...await resolveExecutionSnapshot({
+            ...input,
+            resolveDefaultModel: async (provider) => {
+                const models = await listRuntimeModels(input.config, provider);
+                return models?.data.find((candidate) => candidate.isDefault)?.model;
+            },
+        }),
+        pluginSkills: snapshotEnabledPluginSkillSources(),
+    };
+}
+async function resolveSessionWorkspace(projects, projectId, managedCwd) {
+    if (projectId) {
+        const project = await projects.get(projectId);
+        if (!project) {
+            throw new MachineSessionServiceFailure("not_found", "project not found");
+        }
+        await assertWorkspaceDirectories(project.directories);
+        return sessionWorkspaceSnapshotSchema.parse({
+            cwd: project.primary,
+            allowedDirs: [
+                project.primary,
+                ...project.directories.filter((directory) => directory !== project.primary),
+            ],
+        });
+    }
+    if (managedCwd) {
+        let canonical;
+        try {
+            canonical = await realpath(managedCwd);
+            await assertWorkspaceDirectories([canonical]);
+        }
+        catch (error) {
+            if (error instanceof MachineSessionServiceFailure)
+                throw error;
+            throw new MachineSessionServiceFailure("failed_precondition", "Session working directory is unavailable");
+        }
+        return sessionWorkspaceSnapshotSchema.parse({
+            cwd: canonical,
+            allowedDirs: [canonical],
+        });
+    }
+    return await createSessionFallbackWorkspace();
+}
+async function assertWorkspaceDirectories(directories) {
+    try {
+        await Promise.all(directories.map(async (directory) => {
+            if (!(await stat(directory)).isDirectory())
+                throw new Error(directory);
+        }));
+    }
+    catch {
+        throw new MachineSessionServiceFailure("failed_precondition", "one or more Project directories are unavailable");
+    }
+}
+function toMarketplaceItem(record) {
+    return {
+        id: record.marketplaceId,
+        source: record.sourceType,
+        builtIn: record.builtIn,
+        plugins: record.catalog.plugins.map((plugin) => ({ id: plugin.id })),
+        resolvedRevision: record.resolvedRevision,
+        refreshedAt: record.refreshedAt,
+    };
+}
 export function daemonActivityBlocksShutdown(activity) {
     return activity.runningTurns > 0 || activity.pendingInteractions > 0;
 }
@@ -179,10 +250,11 @@ async function removeControlEndpointForCurrentProcess() {
         // Best effort only; stale endpoint files are ignored by the client fallback.
     }
 }
-export async function startRynxDaemonServer({ config, warn = defaultWarn, writeEndpoint = writeControlEndpoint, acquireOwner = acquireDaemonOwner, loadDirectConfig = loadDirectRuntimeConfig, startDirectServer = startDirectRuntimeServer, createChromeInspectionManager = (options) => ChromeInspectionManager.create(options), createBrowserHostSupervisor = (options) => new AppBrowserHostSupervisor(options), } = {}) {
+export async function startRynxDaemonServer({ config, warn = defaultWarn, writeEndpoint = writeControlEndpoint, acquireOwner = acquireDaemonOwner, preparePlugins, loadDirectConfig = loadDirectRuntimeConfig, startDirectServer = startDirectRuntimeServer, createChromeInspectionManager = (options) => ChromeInspectionManager.create(options), createBrowserHostSupervisor = (options) => new AppBrowserHostSupervisor(options), } = {}) {
     const owner = await acquireOwner();
     let ownerManagedByServer = false;
     try {
+        await preparePlugins?.();
         const appConfig = config ?? loadConfig();
         const appBrowserHostLaunch = parseAppBrowserHostLaunchConfig();
         const directHostingSupported = isDaemonDirectRuntimeHostingSupported();
@@ -215,11 +287,13 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 "semantic.session.agent-options.v1",
                 "semantic.session.launch-options.v2",
                 "semantic.session.create.v1",
+                "semantic.session.fork.v1",
                 "semantic.session.message.v1",
                 "semantic.session.resources.v1",
                 "semantic.session.message-queue.v1",
                 "semantic.session.delete.v1",
                 "semantic.session.interaction.v1",
+                "semantic.project.manage.v1",
                 "semantic.provider-cli.status.v1",
                 ...(runtimeBrowserSupported ? ["semantic.browser.v1"] : []),
                 ...(runtimeBrowserSupported && directHostingSupported
@@ -259,7 +333,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
         catch (error) {
             warn(`plugin package cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const pluginSupervisor = new PluginSupervisor(listEnabledPlugins(), {
+        const pluginSupervisor = new PluginSupervisor(listPlugins(), {
             daemonInstanceId,
             log: (entry) => {
                 const output = entry.level === "error"
@@ -270,39 +344,14 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 output(JSON.stringify(entry));
             },
         });
-        const pluginManagement = new PluginManagementService();
+        const pluginManagement = new PluginManagementService(undefined, {
+            supervisor: pluginSupervisor,
+        });
         const browserArtifactManagement = createBrowserArtifactManagementService();
         const maintenanceManagement = createMaintenanceManagementService({
             codexStorePath: appConfig.AGENT_SESSION_STORE_PATH,
         });
-        await loadPlugins(pluginSupervisor, warn);
         logLegacyCleanup(appConfig);
-        const reloadPluginRuntime = async (pluginId) => {
-            const record = getPlugin(pluginId);
-            if (!record)
-                throw new Error(`plugin "${pluginId}" is not installed`);
-            if (!record.enabled)
-                throw new Error(`plugin "${pluginId}" is disabled`);
-            if (!isRunnablePluginRecord(record)) {
-                throw new Error(`plugin "${pluginId}" must be reinstalled before its runtime can start`);
-            }
-            const status = await pluginSupervisor.reloadPluginRuntime(record);
-            await loadPlugins(pluginSupervisor, warn);
-            return { pluginId, status };
-        };
-        const ensurePluginRuntime = async (pluginId) => {
-            const record = getPlugin(pluginId);
-            if (!record)
-                throw new Error(`plugin "${pluginId}" is not installed`);
-            if (!record.enabled)
-                throw new Error(`plugin "${pluginId}" is disabled`);
-            if (!isRunnablePluginRecord(record)) {
-                throw new Error(`plugin "${pluginId}" must be reinstalled before its runtime can start`);
-            }
-            const status = await pluginSupervisor.ensurePluginRuntime(record);
-            await loadPlugins(pluginSupervisor, warn);
-            return { pluginId, status };
-        };
         const invokePluginCli = async ({ pluginId, args, stdin }, { signal }) => {
             const result = await runPluginCliCommand(pluginId, args, {
                 stdio: "pipe",
@@ -310,14 +359,6 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 captureOutputBytes: PLUGIN_CLI_OUTPUT_MAX_BYTES,
                 signal,
             });
-            if (result.code === 0) {
-                const reload = result.effects.some((effect) => effect.effect === "runtime.reload");
-                const ensure = result.effects.some((effect) => effect.effect === "runtime.ensure");
-                if (reload)
-                    await reloadPluginRuntime(pluginId);
-                else if (ensure)
-                    await ensurePluginRuntime(pluginId);
-            }
             const output = result.output;
             return {
                 code: result.code,
@@ -326,6 +367,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 truncated: Boolean(output?.stdoutTruncated || output?.stderrTruncated),
             };
         };
+        let machineSessions;
         const pluginRuntime = {
             bindHostServices: (services) => pluginSupervisor.bindHostServices({
                 ...services,
@@ -335,10 +377,30 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                     publicKey: installationIdentity.publicKey,
                     sign: installationIdentity.sign,
                 },
+                sessionLaunch: {
+                    resolve: async (selection) => {
+                        const workspace = await resolveSessionWorkspace(runtimeProjects, selection.projectId, selection.managedCwd);
+                        return {
+                            workspace,
+                            execution: await resolveSessionExecutionSnapshot({
+                                config: appConfig,
+                                ...(selection.agent ? { agentName: selection.agent } : {}),
+                                ...(selection.config ? { spec: selection.config } : {}),
+                                ...((selection.provider || (!selection.agent && !selection.config))
+                                    ? { provider: selection.provider ?? appConfig.AGENT_RUNTIME }
+                                    : {}),
+                                ...(selection.model ? { model: selection.model } : {}),
+                                ...(selection.reasoningEffort
+                                    ? { reasoningEffort: selection.reasoningEffort }
+                                    : {}),
+                                cwd: workspace.cwd,
+                            }),
+                        };
+                    },
+                },
+                sessionFork: (input) => machineSessions.fork(input),
             }),
             startPluginRuntimes: pluginSupervisor.startPluginRuntimes.bind(pluginSupervisor),
-            reloadPluginRuntime,
-            ensurePluginRuntime,
             statusSnapshot: pluginSupervisor.statusSnapshot.bind(pluginSupervisor),
             dispose: pluginSupervisor.dispose.bind(pluginSupervisor),
         };
@@ -346,6 +408,8 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
         const directConnections = new DirectRuntimeConnectionHub();
         const sessionLog = new SqliteSessionLogStore();
         const sessionResources = new SqliteSessionResourceStore();
+        const sessionForks = new SqliteSessionForkStore();
+        const runtimeProjects = new SqliteRuntimeProjectStore();
         const providerClis = new ProviderCliService();
         const sessionBrowserCapabilities = new SessionBrowserCapabilityStore();
         const durableDesktopBrowserHost = new DurableEmbeddedBrowserProfileHost(desktopBrowserHosts, { warn });
@@ -359,10 +423,11 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             sessionContextProvider: browserRunnerSessionContexts,
             onMirrorError: (error, sessionId) => warn(`Session mirror failed for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`),
         });
+        const sessionBrowserHost = appBrowserHostSupervisor
+            ? createSupervisedAppSessionBrowserHost(durableDesktopBrowserHost, appBrowserHostSupervisor)
+            : createDesktopFirstSessionBrowserHost(durableDesktopBrowserHost, createHeadlessBrowserHost());
         const sessionBrowsers = new SessionBrowserService({
-            host: appBrowserHostSupervisor
-                ? createSupervisedAppSessionBrowserHost(durableDesktopBrowserHost, appBrowserHostSupervisor)
-                : createDesktopFirstSessionBrowserHost(durableDesktopBrowserHost, createHeadlessBrowserHost()),
+            host: sessionBrowserHost,
             sessions: {
                 exists: async (sessionId) => Boolean(sessionRegistry.get(sessionId) ??
                     await sessionRuntimeServices.sessionStore.get(sessionId)),
@@ -422,14 +487,35 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                     sessionEmulators?.cleanupSession(sessionId),
                 ]);
             },
-            afterDelete: (sessionId) => {
+            afterDelete: async (sessionId) => {
                 sessionBrowserCapabilities.revoke(sessionId);
+                removeLegacyPluginSkillSnapshot(sessionId);
+                await sessionRuntimeServices.sessionStore.delete(sessionId);
             },
         };
-        const machineSessions = new MachineSessionService({
+        const deletedSessions = db()
+            .prepare("SELECT session_id AS sessionId FROM session_snapshot_cleanup ORDER BY session_id")
+            .all();
+        for (const { sessionId } of deletedSessions) {
+            try {
+                await Promise.all([
+                    sessionBrowsers.cleanupSession(sessionId),
+                    sessionEmulators?.cleanupSession(sessionId),
+                ]);
+                sessionResources.deleteSession(sessionId);
+                removeLegacyPluginSkillSnapshot(sessionId);
+                await sessionRuntimeServices.sessionStore.delete(sessionId);
+                db().prepare("DELETE FROM session_snapshot_cleanup WHERE session_id = ?").run(sessionId);
+            }
+            catch (error) {
+                warn(`Legacy Session artifact cleanup will retry for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        machineSessions = new MachineSessionService({
             registry: sessionRegistry,
             log: sessionLog,
             events: sessionRuntimeServices.sessionBus,
+            publishEvent: sessionRuntimeServices.publishSessionEvent,
             runtimeState: sessionRuntimeServices.sessionRuntimeIndex,
             interruption: {
                 interrupt: (sessionId) => sessionRuntimeServices.runnerManager.interruptLiveSession(sessionId),
@@ -440,25 +526,34 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             },
             pendingMessages: sessionPendingMessageStore,
             resources: sessionResources,
+            forks: sessionForks,
             execution: {
                 runtime: sessionRuntimeServices.conversationRuntime,
+                resolve: ({ agent, provider, model, reasoningEffort, cwd }) => resolveSessionExecutionSnapshot({
+                    config: appConfig,
+                    ...(agent ? { agentName: agent } : {}),
+                    ...(provider ? { provider } : {}),
+                    ...(model ? { model } : {}),
+                    ...(reasoningEffort ? { reasoningEffort } : {}),
+                    cwd,
+                }),
                 runner: sessionRuntimeServices.runnerManager,
-                sessionStore: sessionRuntimeServices.sessionStore,
+            },
+            workspace: {
+                resolve: (projectId) => resolveSessionWorkspace(runtimeProjects, projectId),
+                discardUnbound: discardSessionFallbackWorkspace,
             },
         });
         const directAuthenticator = new DaemonDirectRuntimeAuthenticator(installationIdentity, remoteRuntime, remoteRuntimeAccess);
         const sessionTerminals = createRunnerSessionTerminalHost({
             runnerManager: sessionRuntimeServices.runnerManager,
             resolveLiveSession: async (sessionId) => {
-                const bound = await sessionRuntimeServices.sessionStore.get(sessionId);
                 const registered = sessionRegistry.get(sessionId);
-                const cwd = bound?.cwd ?? registered?.config?.osEnv?.cwd;
-                if ((!bound && !registered) ||
-                    !cwd ||
+                if (!registered ||
                     !sessionRuntimeServices.runnerManager.hasLiveSession(sessionId)) {
                     return undefined;
                 }
-                return { cwd };
+                return { cwd: registered.workspace.cwd };
             },
         });
         let shutdownAccepted = false;
@@ -478,8 +573,22 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 prepareInstallation: (input, context) => pluginManagement.prepareInstallation(input, context),
                 commitInstallation: (token, input, context) => pluginManagement.commitInstallation(token, input, context),
                 cancelPreparation: (token) => pluginManagement.cancelPreparation(token),
+                settingsUi: (pluginId) => pluginManagement.settingsUi(pluginId),
+                settingsUiAsset: (pluginId, assetGeneration, assetPath) => pluginManagement.settingsUiAsset(pluginId, assetGeneration, assetPath),
+                callSettings: (pluginId, generation, method, params, context) => pluginManagement.callSettings(pluginId, generation, method, params, context),
                 dispose: () => pluginManagement.dispose(),
             },
+            pluginMarketplaces: {
+                list: () => listPluginMarketplaces().map(toMarketplaceItem),
+                add: async (input, context) => toMarketplaceItem(await addPluginMarketplace(input.source, {
+                    ...(input.alias ? { alias: input.alias } : {}),
+                    signal: context.signal,
+                })),
+                refresh: async (id, context) => toMarketplaceItem(await refreshPluginMarketplace(id, {
+                    signal: context.signal,
+                })),
+                remove: (id) => removePluginMarketplace(id),
+            },
             browserArtifacts: browserArtifactManagement,
             maintenance: maintenanceManagement,
             shutdownIfIdle: () => {
@@ -516,6 +625,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             terminals: sessionTerminals,
             browsers: sessionBrowsers,
             providerClis,
+            projects: runtimeProjects,
             onError: (error) => warn(`Remote Runtime dispatch failed: ${error instanceof Error ? error.message : String(error)}`),
         });
         const remoteRuntimeAdmin = directConfig && directEncryptionIdentity
@@ -552,7 +662,6 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             };
             server = await startServer({
                 config: appConfig,
-                loadInstances: () => resolveChannelInstances(warn),
                 control,
                 sessionLog,
                 sessionRegistry,
@@ -564,6 +673,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 runtimeTargetControl,
                 runtimeConnectionResolver: runtimeConnectionManager,
                 localSessionResources: machineSessions,
+                localMachineSessions: machineSessions,
                 providerClis,
                 sessionEmulators,
                 sessionLifecycle: sessionResourceLifecycle,