@moxt-ai/mobius 0.0.4 → 0.0.6

package/dist/run-daemon.js

@@ -1,15 +1,24 @@
 import { randomUUID } from "node:crypto";
 import { basename } from "node:path";
-import { AGENT_ACTIVITY_KIND, AGENT_MESSAGE_DELTA_KIND, decodeMessageKind, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentMessageDeltaEvent, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, MOBIUS_PROTOCOL_VERSION, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
+import { AGENT_ACTIVITY_KIND, AGENT_INSTALL_AWAITING_APPROVAL_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_MESSAGE_DELTA_KIND, decodeAgentInstallCancelCommand, decodeAgentInstallRequestCommand, decodeMessageKind, decodeNativeSessionCancel, decodeNativeSessionCommand, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallAwaitingApprovalEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, encodeAgentMessageDeltaEvent, encodeNativeSessionResult, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, MOBIUS_PROTOCOL_VERSION, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_KIND, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
 import { WebSocket } from "undici";
 import { AcpExecutionError, AcpSessionManager, NullAcpSessionObserver, } from "./acp/session-manager.js";
 import { SqliteAcpSessionStore } from "./acp/session-store.js";
-import { LocalAuthorizationError } from "./authorization/authorize-binding.js";
+import { supportedLocalAgentSpecifications } from "./agent-catalog/discover-local-agents.js";
+import { LocalAgentCatalogError } from "./agent-catalog/local-agent.js";
+import { publishAgentCatalog } from "./agent-catalog/publish-agent-catalog.js";
+import { AgentInstallationManager, AwaitingLocalApproval, CancelledInstallation, FailedInstallation, RequestedInstallation, RunningInstallation, SucceededInstallation, } from "./agent-installation/agent-installation-manager.js";
+import { AutomaticAdapterProvisioner } from "./agent-installation/automatic-adapter-provisioner.js";
+import { FixedInstallationExecutor } from "./agent-installation/fixed-installation-executor.js";
+import { ConsoleInstallationAuthorizer } from "./agent-installation/local-installation-authorizer.js";
+import { ManagedAdapterInstaller } from "./agent-installation/managed-adapter-installer.js";
+import { LocalAuthorizationError } from "./authorization/local-authorization-error.js";
 import { WorkspaceDirectoryService } from "./authorization/workspace-directory.js";
-import { findLocalAgent } from "./config.js";
+import { NativeSessionService } from "./native-sessions/service.js";
 import { connectRelay } from "./relay-connection/connect.js";
 import { RelayConnectionLiveness } from "./relay-connection/liveness.js";
 import { systemDaemonTimer, } from "./relay-connection/timer.js";
+import { readStateDirectory } from "./storage/state-directory.js";
 const RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
 const RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1_000;
 class RelayConnectionRefreshState {
@@ -104,6 +113,110 @@ class DaemonAcpObserver {
         return Promise.resolve();
     };
 }
+class AuditInstallationEvents {
+    #audit;
+    constructor(audit) {
+        this.#audit = audit;
+    }
+    record = (event, requestId, agentId, details = {}) => {
+        this.#audit.record({
+            commandId: requestId,
+            details,
+            event,
+            sessionId: `agent-installation:${agentId}`,
+        });
+    };
+}
+class DaemonInstallationObserver {
+    #started = new Set();
+    #socket = null;
+    connect = (socket) => {
+        this.#socket = socket;
+    };
+    disconnect = (socket) => {
+        if (this.#socket === socket) {
+            this.#socket = null;
+        }
+    };
+    #send = (socket, message) => {
+        try {
+            send(socket, message);
+        }
+        catch {
+            if (this.#socket === socket) {
+                this.#socket = null;
+            }
+        }
+    };
+    onState = (state) => {
+        const socket = this.#socket;
+        if (socket === null || socket.readyState !== WebSocket.OPEN) {
+            return Promise.resolve();
+        }
+        if (state instanceof RequestedInstallation) {
+            return Promise.resolve();
+        }
+        if (state instanceof AwaitingLocalApproval) {
+            this.#send(socket, encodeAgentInstallAwaitingApprovalEvent({
+                agentId: state.agentId,
+                kind: AGENT_INSTALL_AWAITING_APPROVAL_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                requestId: state.requestId,
+            }));
+            return Promise.resolve();
+        }
+        if (state instanceof RunningInstallation) {
+            if (!this.#started.has(state.requestId)) {
+                this.#started.add(state.requestId);
+                this.#send(socket, encodeAgentInstallStartedEvent({
+                    agentId: state.agentId,
+                    kind: AGENT_INSTALL_STARTED_KIND,
+                    protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                    requestId: state.requestId,
+                }));
+            }
+            this.#send(socket, encodeAgentInstallProgressEvent({
+                agentId: state.agentId,
+                kind: AGENT_INSTALL_PROGRESS_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                requestId: state.requestId,
+                stage: state.stage,
+            }));
+            return Promise.resolve();
+        }
+        if (state instanceof SucceededInstallation) {
+            this.#send(socket, encodeAgentInstallCompletedEvent({
+                agentId: state.agentId,
+                authenticationMayBeRequired: state.authenticationMayBeRequired,
+                kind: AGENT_INSTALL_COMPLETED_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                requestId: state.requestId,
+            }));
+            return Promise.resolve();
+        }
+        if (state instanceof FailedInstallation) {
+            this.#send(socket, encodeAgentInstallFailedEvent({
+                agentId: state.agentId,
+                code: state.code,
+                kind: AGENT_INSTALL_FAILED_KIND,
+                message: state.message,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                requestId: state.requestId,
+            }));
+            return Promise.resolve();
+        }
+        if (state instanceof CancelledInstallation) {
+            this.#send(socket, encodeAgentInstallCancelledEvent({
+                agentId: state.agentId,
+                kind: AGENT_INSTALL_CANCELLED_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                requestId: state.requestId,
+            }));
+            return Promise.resolve();
+        }
+        throw new Error("Unsupported Agent installation state");
+    };
+}
 class ResolvedSessionDirectories {
     additionalDirectories;
     additionalDirectoryEntries;
@@ -159,14 +272,16 @@ function reportFailure(socket, command, code, message) {
 }
 function operationErrorCode(error) {
     if (error instanceof AcpExecutionError ||
-        error instanceof LocalAuthorizationError) {
+        error instanceof LocalAuthorizationError ||
+        error instanceof LocalAgentCatalogError) {
         return error.code;
     }
     return "session_operation_failed";
 }
 function operationErrorMessage(error) {
     if (error instanceof AcpExecutionError ||
-        error instanceof LocalAuthorizationError) {
+        error instanceof LocalAuthorizationError ||
+        error instanceof LocalAgentCatalogError) {
         return error.message;
     }
     return "The local agent operation could not be completed";
@@ -184,13 +299,13 @@ function reportOperationFailure(socket, requestId, sessionId, error) {
         sessionId,
     }));
 }
-async function resolveSessionDirectories(directories, bindingId, directoryId, additionalDirectoryIds) {
-    const cwd = await directories.resolve(bindingId, directoryId);
+async function resolveSessionDirectories(directories, bindingId, directoryId, additionalDirectoryIds, signal) {
+    const cwd = await directories.resolve(bindingId, directoryId, signal);
     const additionalDirectories = [];
     const additionalDirectoryEntries = [];
     const unique = new Set([cwd]);
     for (const additionalDirectoryId of additionalDirectoryIds) {
-        const directory = await directories.resolve(bindingId, additionalDirectoryId);
+        const directory = await directories.resolve(bindingId, additionalDirectoryId, signal);
         if (unique.has(directory)) {
             throw new LocalAuthorizationError("Workspace directories must resolve to distinct locations");
         }
@@ -203,9 +318,9 @@ async function resolveSessionDirectories(directories, bindingId, directoryId, ad
     }
     return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
 }
-async function executeWorkspaceList(socket, command, directories, audit) {
+async function executeWorkspaceList(socket, command, directories, audit, signal) {
     try {
-        const listing = await directories.list(command.bindingId, command.directoryId);
+        const listing = await directories.list(command.bindingId, command.directoryId, signal);
         audit.record({
             commandId: command.requestId,
             event: "workspace_list_authorized",
@@ -228,8 +343,8 @@ async function executeWorkspaceList(socket, command, directories, audit) {
 }
 async function executeSessionPrepare(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
-        const agent = findLocalAgent(config.agents, command.agentId);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
+        const agent = config.catalog.find(command.agentId);
         const prepared = await sessions.prepareSession({
             additionalDirectories: resolved.additionalDirectories,
             agent,
@@ -237,7 +352,7 @@ async function executeSessionPrepare(socket, command, config, directories, audit
             sessionId: command.sessionId,
             signal,
         });
-        const listing = await directories.list(command.bindingId, command.directoryId);
+        const listing = await directories.list(command.bindingId, command.directoryId, signal);
         audit.record({
             commandId: command.requestId,
             event: "session_prepared",
@@ -266,10 +381,10 @@ async function executeSessionPrepare(socket, command, config, directories, audit
 }
 async function executeSessionConfigure(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const configOptions = await sessions.configureSession({
             additionalDirectories: resolved.additionalDirectories,
-            agent: findLocalAgent(config.agents, command.agentId),
+            agent: config.catalog.find(command.agentId),
             booleanValue: command.booleanValue,
             configId: command.configId,
             cwd: resolved.cwd,
@@ -298,8 +413,8 @@ async function executeSessionConfigure(socket, command, config, directories, aud
 }
 async function executePrompt(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
-        const agent = findLocalAgent(config.agents, command.agentId);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
+        const agent = config.catalog.find(command.agentId);
         const processAttemptId = randomUUID();
         audit.record({
             commandId: command.commandId,
@@ -375,7 +490,10 @@ async function executePrompt(socket, command, config, directories, audit, sessio
             event: "session_failed",
             sessionId: command.sessionId,
         });
-        reportFailure(socket, command, "agent_execution_failed", "The local agent could not complete the request");
+        const code = operationErrorCode(error);
+        reportFailure(socket, command, code === "session_operation_failed" ? "agent_execution_failed" : code, code === "session_operation_failed"
+            ? "The local agent could not complete the request"
+            : operationErrorMessage(error));
         console.error("Mobius daemon command failed", error);
     }
 }
@@ -393,198 +511,322 @@ function waitForRelayRetry(signal, timer) {
         signal.addEventListener("abort", finish, { once: true });
     });
 }
-async function runRelayConnection(config, directories, audit, sessions, signal, timer) {
+async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, signal, timer) {
     const relayUrl = new URL(config.relayUrl);
     relayUrl.searchParams.set("liveness", "1");
     const socket = await connectRelay(relayUrl, signal);
     const activeTurns = new Map();
     const connectionController = new AbortController();
+    const nativeRequests = new Map();
     sessions.setObserver(new DaemonAcpObserver(socket));
-    await new Promise((resolve, reject) => {
-        let finished = false;
-        const cleanup = () => {
-            connectionRefresh.close();
-            connectionLiveness.close();
-            signal.removeEventListener("abort", stop);
-            socket.removeEventListener("close", handleClose);
-            socket.removeEventListener("error", handleError);
-            socket.removeEventListener("message", handleMessage);
-            connectionController.abort();
-            for (const turn of activeTurns.values()) {
-                turn.abortConnection();
-            }
-            activeTurns.clear();
-        };
-        const resolveConnection = () => {
-            if (finished) {
-                return;
-            }
-            finished = true;
-            cleanup();
-            resolve();
-        };
-        const rejectConnection = () => {
-            if (finished) {
-                return;
-            }
-            finished = true;
-            cleanup();
-            reject(new Error("Relay WebSocket failed"));
-        };
-        const stop = () => {
-            socket.close(1000, "Daemon stopped");
-            resolveConnection();
-        };
-        const refreshConnection = () => {
-            socket.close(1000, "Refreshing idle relay connection");
-            resolveConnection();
-        };
-        const connectionLiveness = new RelayConnectionLiveness(timer, {
-            send: (message) => send(socket, message),
-            unresponsive: () => {
-                socket.close(4001, "Relay liveness check timed out");
-                resolveConnection();
-            },
-        });
-        const connectionRefresh = new RelayConnectionRefresh(timer, () => activeTurns.size === 0, refreshConnection);
-        signal.addEventListener("abort", stop, { once: true });
-        const handleClose = () => {
-            resolveConnection();
-        };
-        const handleError = () => {
-            if (signal.aborted) {
-                resolveConnection();
-                return;
-            }
-            rejectConnection();
-        };
-        const handleMessage = (event) => {
-            const encoded = event.data;
-            if (typeof encoded !== "string") {
-                socket.close(4003, "Text message required");
-                rejectConnection();
-                return;
-            }
-            try {
-                const kind = decodeMessageKind(encoded);
-                if (kind === RUNTIME_LIVENESS_READY_KIND) {
-                    decodeRuntimeLivenessReadyEvent(encoded);
-                    connectionLiveness.start();
-                    return;
-                }
-                if (kind === RUNTIME_HEARTBEAT_ACK_KIND) {
-                    connectionLiveness.acknowledge(decodeRuntimeHeartbeatAckEvent(encoded));
-                    return;
+    installationObserver.connect(socket);
+    try {
+        await new Promise((resolve, reject) => {
+            let finished = false;
+            const cleanup = () => {
+                connectionRefresh.close();
+                connectionLiveness.close();
+                signal.removeEventListener("abort", stop);
+                socket.removeEventListener("close", handleClose);
+                socket.removeEventListener("error", handleError);
+                socket.removeEventListener("message", handleMessage);
+                installationObserver.disconnect(socket);
+                connectionController.abort();
+                for (const turn of activeTurns.values()) {
+                    turn.abortConnection();
                 }
-                if (kind === SESSION_CANCEL_KIND) {
-                    const cancellation = decodeSessionCancelCommand(encoded);
-                    const turn = activeTurns.get(cancellation.commandId);
-                    if (turn === undefined || !turn.matches(cancellation)) {
-                        console.warn("Mobius daemon ignored cancellation for an inactive turn");
-                        return;
-                    }
-                    if (!turn.requestCancellation()) {
-                        return;
-                    }
-                    audit.record({
-                        commandId: cancellation.commandId,
-                        event: "session_cancellation_requested",
-                        sessionId: cancellation.sessionId,
-                    });
-                    void sessions.cancelPrompt(cancellation.sessionId).catch((error) => {
-                        console.error("Mobius daemon could not cancel the agent turn", error);
-                    });
+                activeTurns.clear();
+            };
+            const resolveConnection = () => {
+                if (finished) {
                     return;
                 }
-                if (kind === WORKSPACE_LIST_KIND) {
-                    const command = decodeWorkspaceListCommand(encoded);
-                    void executeWorkspaceList(socket, command, directories, audit);
+                finished = true;
+                cleanup();
+                resolve();
+            };
+            const rejectConnection = () => {
+                if (finished) {
                     return;
                 }
-                if (kind === SESSION_PREPARE_KIND) {
-                    const command = decodeSessionPrepareCommand(encoded);
-                    void executeSessionPrepare(socket, command, config, directories, audit, sessions, connectionController.signal);
+                finished = true;
+                cleanup();
+                reject(new Error("Relay WebSocket failed"));
+            };
+            const stop = () => {
+                socket.close(1000, "Daemon stopped");
+                resolveConnection();
+            };
+            const refreshConnection = () => {
+                socket.close(1000, "Refreshing idle relay connection");
+                resolveConnection();
+            };
+            const connectionLiveness = new RelayConnectionLiveness(timer, {
+                send: (message) => send(socket, message),
+                unresponsive: () => {
+                    socket.close(4001, "Relay liveness check timed out");
+                    resolveConnection();
+                },
+            });
+            const connectionRefresh = new RelayConnectionRefresh(timer, () => activeTurns.size === 0, refreshConnection);
+            signal.addEventListener("abort", stop, { once: true });
+            const handleClose = () => {
+                resolveConnection();
+            };
+            const handleError = () => {
+                if (signal.aborted) {
+                    resolveConnection();
                     return;
                 }
-                if (kind === SESSION_CONFIGURE_KIND) {
-                    const command = decodeSessionConfigureCommand(encoded);
-                    void executeSessionConfigure(socket, command, config, directories, audit, sessions, connectionController.signal);
+                rejectConnection();
+            };
+            const handleMessage = (event) => {
+                const encoded = event.data;
+                if (typeof encoded !== "string") {
+                    socket.close(4003, "Text message required");
+                    rejectConnection();
                     return;
                 }
-                if (kind === SESSION_PERMISSION_RESPOND_KIND) {
-                    const command = decodeSessionPermissionRespondCommand(encoded);
-                    void sessions
-                        .respondPermission(command)
-                        .then(() => {
-                        audit.record({
-                            commandId: command.interactionId,
-                            event: "session_permission_resolved",
+                try {
+                    const kind = decodeMessageKind(encoded);
+                    if (kind === NATIVE_SESSION_CANCEL_KIND) {
+                        const command = decodeNativeSessionCancel(encoded);
+                        const pending = nativeRequests.get(command.requestId);
+                        if (pending?.sessionId === command.sessionId)
+                            pending.controller.abort(new AcpExecutionError("Native session operation cancelled", {}, "native_session_cancelled"));
+                        return;
+                    }
+                    if (kind === NATIVE_SESSION_REQUEST_KIND) {
+                        const command = decodeNativeSessionCommand(encoded);
+                        const previous = [...nativeRequests.values()].filter((request) => request.agentId === command.agentId);
+                        if (nativeRequests.has(command.requestId) ||
+                            nativeRequests.size >= 4 ||
+                            previous.some((request) => !request.controller.signal.aborted)) {
+                            reportOperationFailure(socket, command.requestId, command.sessionId, new AcpExecutionError("Another native session operation is running", {}, "native_session_busy"));
+                            return;
+                        }
+                        const controller = new AbortController();
+                        const operationSignal = AbortSignal.any([
+                            connectionController.signal,
+                            controller.signal,
+                        ]);
+                        const timeout = timer.schedule(() => controller.abort(new AcpExecutionError("Native session operation timed out", {}, "native_session_timeout")), 90_000);
+                        const completion = (async () => {
+                            try {
+                                operationSignal.throwIfAborted();
+                                if (previous.length > 0) {
+                                    await new Promise((resolve, reject) => {
+                                        const cancel = () => reject(operationSignal.reason);
+                                        operationSignal.addEventListener("abort", cancel, {
+                                            once: true,
+                                        });
+                                        void Promise.all(previous.map((request) => request.completion)).then(() => {
+                                            operationSignal.removeEventListener("abort", cancel);
+                                            resolve();
+                                        }, (error) => {
+                                            operationSignal.removeEventListener("abort", cancel);
+                                            reject(error);
+                                        });
+                                    });
+                                }
+                                operationSignal.throwIfAborted();
+                                const result = await nativeSessions.execute(command, operationSignal);
+                                if (socket.readyState === WebSocket.OPEN)
+                                    send(socket, encodeNativeSessionResult(result));
+                            }
+                            catch (error) {
+                                const failure = operationSignal.aborted
+                                    ? (controller.signal.reason ??
+                                        new AcpExecutionError("Native session operation cancelled", {}, "native_session_cancelled"))
+                                    : error;
+                                audit.record({
+                                    commandId: command.requestId,
+                                    sessionId: command.sessionId,
+                                    event: "native_session_operation_failed",
+                                    details: { code: operationErrorCode(failure) },
+                                });
+                                reportOperationFailure(socket, command.requestId, command.sessionId, failure);
+                            }
+                            finally {
+                                timeout.cancel();
+                                nativeRequests.delete(command.requestId);
+                            }
+                        })();
+                        nativeRequests.set(command.requestId, {
+                            agentId: command.agentId,
                             sessionId: command.sessionId,
+                            controller,
+                            completion,
                         });
-                    })
-                        .catch((error) => {
-                        reportOperationFailure(socket, command.interactionId, command.sessionId, error);
-                    });
-                    return;
-                }
-                if (kind === SESSION_ELICITATION_RESPOND_KIND) {
-                    const command = decodeSessionElicitationRespondCommand(encoded);
-                    void sessions
-                        .respondElicitation(command)
-                        .then(() => {
+                        return;
+                    }
+                    if (kind === RUNTIME_LIVENESS_READY_KIND) {
+                        decodeRuntimeLivenessReadyEvent(encoded);
+                        connectionLiveness.start();
+                        return;
+                    }
+                    if (kind === RUNTIME_HEARTBEAT_ACK_KIND) {
+                        connectionLiveness.acknowledge(decodeRuntimeHeartbeatAckEvent(encoded));
+                        return;
+                    }
+                    if (kind === SESSION_CANCEL_KIND) {
+                        const cancellation = decodeSessionCancelCommand(encoded);
+                        const turn = activeTurns.get(cancellation.commandId);
+                        if (turn === undefined || !turn.matches(cancellation)) {
+                            console.warn("Mobius daemon ignored cancellation for an inactive turn");
+                            return;
+                        }
+                        if (!turn.requestCancellation()) {
+                            return;
+                        }
                         audit.record({
-                            commandId: command.interactionId,
-                            event: "session_elicitation_resolved",
-                            sessionId: command.sessionId,
+                            commandId: cancellation.commandId,
+                            event: "session_cancellation_requested",
+                            sessionId: cancellation.sessionId,
                         });
-                    })
+                        void sessions
+                            .cancelPrompt(cancellation.sessionId)
+                            .catch((error) => {
+                            console.error("Mobius daemon could not cancel the agent turn", error);
+                        });
+                        return;
+                    }
+                    if (kind === WORKSPACE_LIST_KIND) {
+                        const command = decodeWorkspaceListCommand(encoded);
+                        void executeWorkspaceList(socket, command, directories, audit, connectionController.signal);
+                        return;
+                    }
+                    if (kind === SESSION_PREPARE_KIND) {
+                        const command = decodeSessionPrepareCommand(encoded);
+                        void executeSessionPrepare(socket, command, config, directories, audit, sessions, connectionController.signal);
+                        return;
+                    }
+                    if (kind === SESSION_CONFIGURE_KIND) {
+                        const command = decodeSessionConfigureCommand(encoded);
+                        void executeSessionConfigure(socket, command, config, directories, audit, sessions, connectionController.signal);
+                        return;
+                    }
+                    if (kind === SESSION_PERMISSION_RESPOND_KIND) {
+                        const command = decodeSessionPermissionRespondCommand(encoded);
+                        void sessions
+                            .respondPermission(command)
+                            .then(() => {
+                            audit.record({
+                                commandId: command.interactionId,
+                                event: "session_permission_resolved",
+                                sessionId: command.sessionId,
+                            });
+                        })
+                            .catch((error) => {
+                            reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                        });
+                        return;
+                    }
+                    if (kind === SESSION_ELICITATION_RESPOND_KIND) {
+                        const command = decodeSessionElicitationRespondCommand(encoded);
+                        void sessions
+                            .respondElicitation(command)
+                            .then(() => {
+                            audit.record({
+                                commandId: command.interactionId,
+                                event: "session_elicitation_resolved",
+                                sessionId: command.sessionId,
+                            });
+                        })
+                            .catch((error) => {
+                            reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                        });
+                        return;
+                    }
+                    if (kind === AGENT_INSTALL_REQUEST_KIND) {
+                        const command = decodeAgentInstallRequestCommand(encoded);
+                        void installations
+                            .request(command, signal)
+                            .catch((error) => {
+                            console.error("Mobius Agent installation failed", error);
+                        });
+                        return;
+                    }
+                    if (kind === AGENT_INSTALL_CANCEL_KIND) {
+                        const command = decodeAgentInstallCancelCommand(encoded);
+                        void installations
+                            .cancel(command.requestId)
+                            .catch((error) => {
+                            reportOperationFailure(socket, command.requestId, "", error);
+                        });
+                        return;
+                    }
+                    if (kind !== SESSION_PROMPT_KIND) {
+                        throw new Error("Unsupported protocol message");
+                    }
+                    const command = decodeSessionPromptCommand(encoded);
+                    if (activeTurns.has(command.commandId)) {
+                        reportFailure(socket, command, "duplicate_command", "The command is already running");
+                        return;
+                    }
+                    const turn = new ActiveDaemonTurn(command, new AbortController());
+                    activeTurns.set(command.commandId, turn);
+                    void executePrompt(socket, command, config, directories, audit, sessions, turn.signal)
                         .catch((error) => {
-                        reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                        console.error("Mobius daemon turn failed", error);
+                    })
+                        .finally(() => {
+                        activeTurns.delete(command.commandId);
+                        connectionRefresh.afterTurnFinished();
                     });
-                    return;
                 }
-                if (kind !== SESSION_PROMPT_KIND) {
-                    throw new Error("Unsupported protocol message");
+                catch (error) {
+                    console.error("Mobius daemon rejected a message", error);
+                    socket.close(4008, "Invalid protocol message");
+                    rejectConnection();
                 }
-                const command = decodeSessionPromptCommand(encoded);
-                if (activeTurns.has(command.commandId)) {
-                    reportFailure(socket, command, "duplicate_command", "The command is already running");
-                    return;
-                }
-                const turn = new ActiveDaemonTurn(command, new AbortController());
-                activeTurns.set(command.commandId, turn);
-                void executePrompt(socket, command, config, directories, audit, sessions, turn.signal)
-                    .catch((error) => {
-                    console.error("Mobius daemon turn failed", error);
-                })
-                    .finally(() => {
-                    activeTurns.delete(command.commandId);
-                    connectionRefresh.afterTurnFinished();
-                });
-            }
-            catch (error) {
-                console.error("Mobius daemon rejected a message", error);
-                socket.close(4008, "Invalid protocol message");
-                rejectConnection();
+            };
+            socket.addEventListener("close", handleClose);
+            socket.addEventListener("error", handleError);
+            socket.addEventListener("message", handleMessage);
+            if (signal.aborted) {
+                stop();
             }
-        };
-        socket.addEventListener("close", handleClose);
-        socket.addEventListener("error", handleError);
-        socket.addEventListener("message", handleMessage);
-        if (signal.aborted) {
-            stop();
-        }
-    });
+        });
+    }
+    finally {
+        connectionController.abort();
+        await Promise.all([...nativeRequests.values()].map((request) => request.completion));
+    }
 }
 export async function runDaemon(config, audit, signal, timer = systemDaemonTimer) {
+    const installationAudit = new AuditInstallationEvents(audit);
+    const stateDirectory = readStateDirectory();
+    const specifications = supportedLocalAgentSpecifications();
+    const installationExecutor = new FixedInstallationExecutor({
+        defaultWorkspace: config.defaultWorkspace,
+        audit: installationAudit,
+        catalog: config.catalog,
+        environment: process.env,
+        publishCatalog: async (installationSignal) => await publishAgentCatalog(config, installationSignal),
+        stateDirectory,
+    });
+    await new AutomaticAdapterProvisioner({
+        defaultWorkspace: config.defaultWorkspace,
+        audit: installationAudit,
+        catalog: config.catalog,
+        environment: process.env,
+    }, new ManagedAdapterInstaller({
+        environment: process.env,
+        stateDirectory,
+    }), specifications).prepare(signal);
     const sessionStore = new SqliteAcpSessionStore(config.auditDatabasePath);
     const sessions = new AcpSessionManager(new NullAcpSessionObserver(), sessionStore);
-    const directories = new WorkspaceDirectoryService(config.bindingId, config.approvedRoot);
+    const directories = new WorkspaceDirectoryService(config.bindingId, config.defaultWorkspace);
+    const installationObserver = new DaemonInstallationObserver();
+    const nativeSessions = new NativeSessionService(config, directories, sessions, audit);
+    const installations = new AgentInstallationManager(specifications, new ConsoleInstallationAuthorizer(stateDirectory), installationExecutor, installationObserver, installationAudit);
     let retryAnnounced = false;
     try {
         while (!signal.aborted) {
             try {
-                await runRelayConnection(config, directories, audit, sessions, signal, timer);
+                await publishAgentCatalog(config, signal);
+                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, signal, timer);
                 retryAnnounced = false;
             }
             catch {
@@ -600,8 +842,17 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
         }
     }
     finally {
-        await sessions.close();
-        sessionStore.close();
+        try {
+            await installations.close();
+        }
+        finally {
+            try {
+                await sessions.close();
+            }
+            finally {
+                sessionStore.close();
+            }
+        }
     }
 }
 //# sourceMappingURL=run-daemon.js.map