@moxt-ai/mobius 0.0.3 → 0.0.5

package/dist/relay-connection/liveness.js

@@ -0,0 +1,102 @@
+import { randomUUID } from "node:crypto";
+import { encodeRuntimeHeartbeatEvent, MOBIUS_PROTOCOL_VERSION, RUNTIME_HEARTBEAT_KIND, } from "@moxt-ai/mobius-protocol";
+const HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 10_000;
+const HEARTBEAT_INTERVAL_MILLISECONDS = 20_000;
+class RelayLivenessState {
+}
+class UnsupportedRelayLivenessState extends RelayLivenessState {
+}
+class AwaitingHeartbeatAckState extends RelayLivenessState {
+    heartbeatId;
+    timeout;
+    constructor(heartbeatId, timeout) {
+        super();
+        this.heartbeatId = heartbeatId;
+        this.timeout = timeout;
+    }
+}
+class WaitingForHeartbeatState extends RelayLivenessState {
+    schedule;
+    constructor(schedule) {
+        super();
+        this.schedule = schedule;
+    }
+}
+class FinishedRelayLivenessState extends RelayLivenessState {
+}
+export class RelayConnectionLiveness {
+    #timer;
+    #transport;
+    #state = new UnsupportedRelayLivenessState();
+    constructor(timer, transport) {
+        this.#timer = timer;
+        this.#transport = transport;
+    }
+    acknowledge = (event) => {
+        if (!(this.#state instanceof AwaitingHeartbeatAckState)) {
+            throw new Error("Unexpected relay heartbeat acknowledgement");
+        }
+        if (event.heartbeatId !== this.#state.heartbeatId) {
+            throw new Error("Relay acknowledged the wrong heartbeat");
+        }
+        this.#state.timeout.cancel();
+        this.#state = new WaitingForHeartbeatState(this.#timer.schedule(this.#sendHeartbeat, HEARTBEAT_INTERVAL_MILLISECONDS));
+    };
+    close = () => {
+        if (this.#state instanceof AwaitingHeartbeatAckState) {
+            this.#state.timeout.cancel();
+        }
+        else if (this.#state instanceof WaitingForHeartbeatState) {
+            this.#state.schedule.cancel();
+        }
+        else if (!(this.#state instanceof UnsupportedRelayLivenessState) &&
+            !(this.#state instanceof FinishedRelayLivenessState)) {
+            throw new Error("Unknown relay liveness state");
+        }
+        this.#state = new FinishedRelayLivenessState();
+    };
+    start = () => {
+        if (this.#state instanceof UnsupportedRelayLivenessState) {
+            this.#sendHeartbeat();
+            return;
+        }
+        if (this.#state instanceof AwaitingHeartbeatAckState ||
+            this.#state instanceof WaitingForHeartbeatState) {
+            return;
+        }
+        if (this.#state instanceof FinishedRelayLivenessState) {
+            return;
+        }
+        throw new Error("Unknown relay liveness state");
+    };
+    #handleTimeout = () => {
+        if (this.#state instanceof FinishedRelayLivenessState) {
+            return;
+        }
+        if (!(this.#state instanceof AwaitingHeartbeatAckState)) {
+            throw new Error("Heartbeat timeout occurred in an invalid state");
+        }
+        this.#state.timeout.cancel();
+        this.#state = new FinishedRelayLivenessState();
+        this.#transport.unresponsive();
+    };
+    #sendHeartbeat = () => {
+        if (this.#state instanceof WaitingForHeartbeatState) {
+            this.#state.schedule.cancel();
+        }
+        else if (!(this.#state instanceof UnsupportedRelayLivenessState)) {
+            if (this.#state instanceof FinishedRelayLivenessState) {
+                return;
+            }
+            throw new Error("Heartbeat was scheduled in an invalid state");
+        }
+        const heartbeatId = randomUUID();
+        this.#state = new AwaitingHeartbeatAckState(heartbeatId, this.#timer.schedule(this.#handleTimeout, HEARTBEAT_ACK_TIMEOUT_MILLISECONDS));
+        this.#transport.send(encodeRuntimeHeartbeatEvent({
+            heartbeatId,
+            kind: RUNTIME_HEARTBEAT_KIND,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+        }));
+    };
+}
+//# sourceMappingURL=liveness.js.map

package/dist/relay-connection/liveness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveness.js","sourceRoot":"","sources":["../../src/relay-connection/liveness.ts"],"names":[],"mappings":"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"}

package/dist/relay-connection/timer.d.ts

@@ -0,0 +1,8 @@
+export interface DaemonScheduledTask {
+    readonly cancel: () => void;
+}
+export interface DaemonTimer {
+    readonly schedule: (callback: () => void, milliseconds: number) => DaemonScheduledTask;
+}
+export declare const systemDaemonTimer: DaemonTimer;
+//# sourceMappingURL=timer.d.ts.map

package/dist/relay-connection/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/relay-connection/timer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CACjB,QAAQ,EAAE,MAAM,IAAI,EACpB,YAAY,EAAE,MAAM,KACjB,mBAAmB,CAAC;CAC1B;AAYD,eAAO,MAAM,iBAAiB,EAAE,WAAqC,CAAC"}

package/dist/relay-connection/timer.js

@@ -0,0 +1,8 @@
+class SystemDaemonTimer {
+    schedule = (callback, milliseconds) => {
+        const timeout = setTimeout(callback, milliseconds);
+        return { cancel: () => clearTimeout(timeout) };
+    };
+}
+export const systemDaemonTimer = new SystemDaemonTimer();
+//# sourceMappingURL=timer.js.map

package/dist/relay-connection/timer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.js","sourceRoot":"","sources":["../../src/relay-connection/timer.ts"],"names":[],"mappings":"AAWA,MAAM,iBAAiB;IACZ,QAAQ,GAAG,CAClB,QAAoB,EACpB,YAAoB,EACC,EAAE;QACvB,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QACnD,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;IACjD,CAAC,CAAC;CACH;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAgB,IAAI,iBAAiB,EAAE,CAAC"}

package/dist/run-daemon.d.ts

@@ -1,4 +1,5 @@
 import type { AuditStore } from "./audit/audit-store.ts";
-import { type DaemonConfig } from "./config.ts";
-export declare function runDaemon(config: DaemonConfig, audit: AuditStore, signal: AbortSignal): Promise<void>;
+import type { DaemonConfig } from "./config.ts";
+import { type DaemonTimer } from "./relay-connection/timer.ts";
+export declare function runDaemon(config: DaemonConfig, audit: AuditStore, signal: AbortSignal, timer?: DaemonTimer): Promise<void>;
 //# sourceMappingURL=run-daemon.d.ts.map

package/dist/run-daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-daemon.d.ts","sourceRoot":"","sources":["../src/run-daemon.ts"],"names":[],"mappings":"AAkEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,EAAE,KAAK,YAAY,EAAkB,MAAM,aAAa,CAAC;AA8sBhE,wBAAsB,SAAS,CAC7B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,IAAI,CAAC,CAiCf"}
+{"version":3,"file":"run-daemon.d.ts","sourceRoot":"","sources":["../src/run-daemon.ts"],"names":[],"mappings":"AAyGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,6BAA6B,CAAC;AAu9BrC,wBAAsB,SAAS,CAC7B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,EACnB,KAAK,GAAE,WAA+B,GACrC,OAAO,CAAC,IAAI,CAAC,CAqFf"}

package/dist/run-daemon.js

@@ -1,14 +1,75 @@
 import { randomUUID } from "node:crypto";
 import { basename } from "node:path";
-import { AGENT_ACTIVITY_KIND, AGENT_MESSAGE_DELTA_KIND, decodeMessageKind, 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, 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, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallAwaitingApprovalEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, 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 { WebSocket } from "undici";
 import { AcpExecutionError, AcpSessionManager, NullAcpSessionObserver, } from "./acp/session-manager.js";
 import { SqliteAcpSessionStore } from "./acp/session-store.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/authorize-binding.js";
 import { WorkspaceDirectoryService } from "./authorization/workspace-directory.js";
-import { findLocalAgent } from "./config.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 {
+}
+class ScheduledRelayConnectionRefreshState extends RelayConnectionRefreshState {
+}
+class DueRelayConnectionRefreshState extends RelayConnectionRefreshState {
+}
+class FinishedRelayConnectionRefreshState extends RelayConnectionRefreshState {
+}
+class RelayConnectionRefresh {
+    #isSafe;
+    #refresh;
+    #scheduledTask;
+    #state = new ScheduledRelayConnectionRefreshState();
+    constructor(timer, isSafe, refresh) {
+        this.#isSafe = isSafe;
+        this.#refresh = refresh;
+        this.#scheduledTask = timer.schedule(this.#request, RELAY_CONNECTION_REFRESH_MILLISECONDS);
+    }
+    afterTurnFinished = () => {
+        if (this.#state instanceof DueRelayConnectionRefreshState) {
+            this.#request();
+            return;
+        }
+        if (this.#state instanceof ScheduledRelayConnectionRefreshState ||
+            this.#state instanceof FinishedRelayConnectionRefreshState) {
+            return;
+        }
+        throw new Error("Unknown relay connection refresh state");
+    };
+    close = () => {
+        this.#scheduledTask.cancel();
+        this.#state = new FinishedRelayConnectionRefreshState();
+    };
+    #request = () => {
+        if (this.#state instanceof FinishedRelayConnectionRefreshState) {
+            return;
+        }
+        if (!(this.#state instanceof ScheduledRelayConnectionRefreshState) &&
+            !(this.#state instanceof DueRelayConnectionRefreshState)) {
+            throw new Error("Unknown relay connection refresh state");
+        }
+        if (!this.#isSafe()) {
+            this.#state = new DueRelayConnectionRefreshState();
+            return;
+        }
+        this.#state = new FinishedRelayConnectionRefreshState();
+        this.#scheduledTask.cancel();
+        this.#refresh();
+    };
+}
 class DaemonAcpObserver {
     #socket;
     constructor(socket) {
@@ -51,6 +112,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;
@@ -106,14 +271,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";
@@ -176,7 +343,7 @@ 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 agent = config.catalog.find(command.agentId);
         const prepared = await sessions.prepareSession({
             additionalDirectories: resolved.additionalDirectories,
             agent,
@@ -216,7 +383,7 @@ async function executeSessionConfigure(socket, command, config, directories, aud
         const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
         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,
@@ -246,7 +413,7 @@ 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 agent = config.catalog.find(command.agentId);
         const processAttemptId = randomUUID();
         audit.record({
             commandId: command.commandId,
@@ -322,36 +489,45 @@ 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);
     }
 }
-function waitForRelayRetry(signal) {
+function waitForRelayRetry(signal, timer) {
     if (signal.aborted) {
         return Promise.resolve();
     }
     return new Promise((resolve) => {
-        const timeout = setTimeout(finish, RELAY_RECONNECT_DELAY_MILLISECONDS);
+        const retry = timer.schedule(finish, RELAY_RECONNECT_DELAY_MILLISECONDS);
         function finish() {
-            clearTimeout(timeout);
+            retry.cancel();
             signal.removeEventListener("abort", finish);
             resolve();
         }
         signal.addEventListener("abort", finish, { once: true });
     });
 }
-async function runRelayConnection(config, directories, audit, sessions, signal) {
-    const socket = await connectRelay(config.relayUrl, signal);
+async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, 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();
     sessions.setObserver(new DaemonAcpObserver(socket));
+    installationObserver.connect(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);
+            installationObserver.disconnect(socket);
             connectionController.abort();
             for (const turn of activeTurns.values()) {
                 turn.abortConnection();
@@ -378,6 +554,18 @@ async function runRelayConnection(config, directories, audit, sessions, signal)
             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();
@@ -392,11 +580,21 @@ async function runRelayConnection(config, directories, audit, sessions, signal)
         const handleMessage = (event) => {
             const encoded = event.data;
             if (typeof encoded !== "string") {
-                socket.close(1003, "Text message required");
+                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;
+                }
                 if (kind === SESSION_CANCEL_KIND) {
                     const cancellation = decodeSessionCancelCommand(encoded);
                     const turn = activeTurns.get(cancellation.commandId);
@@ -464,10 +662,27 @@ async function runRelayConnection(config, directories, audit, sessions, signal)
                     });
                     return;
                 }
-                if (kind !== SESSION_PROMPT_KIND) {
-                    socket.close(1008, "Unsupported protocol message");
+                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");
@@ -481,11 +696,13 @@ async function runRelayConnection(config, directories, audit, sessions, signal)
                 })
                     .finally(() => {
                     activeTurns.delete(command.commandId);
+                    connectionRefresh.afterTurnFinished();
                 });
             }
             catch (error) {
                 console.error("Mobius daemon rejected a message", error);
-                socket.close(1008, "Invalid protocol message");
+                socket.close(4008, "Invalid protocol message");
+                rejectConnection();
             }
         };
         socket.addEventListener("close", handleClose);
@@ -496,15 +713,39 @@ async function runRelayConnection(config, directories, audit, sessions, signal)
         }
     });
 }
-export async function runDaemon(config, audit, signal) {
+export async function runDaemon(config, audit, signal, timer = systemDaemonTimer) {
+    const installationAudit = new AuditInstallationEvents(audit);
+    const stateDirectory = readStateDirectory();
+    const specifications = supportedLocalAgentSpecifications();
+    const installationExecutor = new FixedInstallationExecutor({
+        approvedRoot: config.approvedRoot,
+        audit: installationAudit,
+        catalog: config.catalog,
+        environment: process.env,
+        publishCatalog: async (installationSignal) => await publishAgentCatalog(config, installationSignal),
+        stateDirectory,
+    });
+    await new AutomaticAdapterProvisioner({
+        approvedRoot: config.approvedRoot,
+        audit: installationAudit,
+        catalog: config.catalog,
+        environment: process.env,
+    }, new ManagedAdapterInstaller({
+        approvedRoot: config.approvedRoot,
+        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 installationObserver = new DaemonInstallationObserver();
+    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);
+                await publishAgentCatalog(config, signal);
+                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, signal, timer);
                 retryAnnounced = false;
             }
             catch {
@@ -516,12 +757,21 @@ export async function runDaemon(config, audit, signal) {
                     retryAnnounced = true;
                 }
             }
-            await waitForRelayRetry(signal);
+            await waitForRelayRetry(signal, timer);
         }
     }
     finally {
-        await sessions.close();
-        sessionStore.close();
+        try {
+            await installations.close();
+        }
+        finally {
+            try {
+                await sessions.close();
+            }
+            finally {
+                sessionStore.close();
+            }
+        }
     }
 }
 //# sourceMappingURL=run-daemon.js.map