@moxt-ai/mobius 0.0.3 → 0.0.4

package/dist/cli.js

@@ -519,7 +519,7 @@ async function resumeLocalMachine(arguments_) {
 }
 
 // src/run-daemon.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { basename as basename3 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/external.js
@@ -19734,6 +19734,9 @@ var encodeAgentContentEvent = (message) => encode3(message, agentContentEventSch
 // ../protocol/src/messages.ts
 var SESSION_PROMPT_KIND = "session.prompt";
 var SESSION_CANCEL_KIND = "session.cancel";
+var RUNTIME_LIVENESS_READY_KIND = "runtime.liveness.ready";
+var RUNTIME_HEARTBEAT_KIND = "runtime.heartbeat";
+var RUNTIME_HEARTBEAT_ACK_KIND = "runtime.heartbeat.ack";
 var SESSION_STARTED_KIND = "session.started";
 var AGENT_MESSAGE_DELTA_KIND = "agent.message.delta";
 var AGENT_ACTIVITY_KIND = "agent.activity";
@@ -19956,6 +19959,38 @@ function decodeSessionCancelCommand(encoded) {
     sessionId: readIdentifier(value, "sessionId")
   };
 }
+function decodeRuntimeLivenessReadyEvent(encoded) {
+  const value = parseJson2(encoded);
+  assertExactKeys(value, ["kind", "protocolVersion"]);
+  assertProtocolVersion(value);
+  assertKind(value, RUNTIME_LIVENESS_READY_KIND);
+  return {
+    kind: RUNTIME_LIVENESS_READY_KIND,
+    protocolVersion: MOBIUS_PROTOCOL_VERSION
+  };
+}
+function decodeRuntimeHeartbeatEvent(encoded) {
+  const value = parseJson2(encoded);
+  assertExactKeys(value, ["heartbeatId", "kind", "protocolVersion"]);
+  assertProtocolVersion(value);
+  assertKind(value, RUNTIME_HEARTBEAT_KIND);
+  return {
+    heartbeatId: readIdentifier(value, "heartbeatId"),
+    kind: RUNTIME_HEARTBEAT_KIND,
+    protocolVersion: MOBIUS_PROTOCOL_VERSION
+  };
+}
+function decodeRuntimeHeartbeatAckEvent(encoded) {
+  const value = parseJson2(encoded);
+  assertExactKeys(value, ["heartbeatId", "kind", "protocolVersion"]);
+  assertProtocolVersion(value);
+  assertKind(value, RUNTIME_HEARTBEAT_ACK_KIND);
+  return {
+    heartbeatId: readIdentifier(value, "heartbeatId"),
+    kind: RUNTIME_HEARTBEAT_ACK_KIND,
+    protocolVersion: MOBIUS_PROTOCOL_VERSION
+  };
+}
 function decodeSessionStartedEvent(encoded) {
   const value = parseJson2(encoded);
   assertExactKeys(value, [
@@ -20073,6 +20108,9 @@ function decodeSessionFailedEvent(encoded) {
     sessionId: readIdentifier(value, "sessionId")
   };
 }
+function encodeRuntimeHeartbeatEvent(message) {
+  return JSON.stringify(decodeRuntimeHeartbeatEvent(JSON.stringify(message)));
+}
 function encodeSessionStartedEvent(message) {
   return JSON.stringify(decodeSessionStartedEvent(JSON.stringify(message)));
 }
@@ -22610,8 +22648,179 @@ function connectRelay(url2, signal) {
   });
 }
 
+// src/relay-connection/liveness.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 1e4;
+var HEARTBEAT_INTERVAL_MILLISECONDS = 2e4;
+var RelayLivenessState = class {
+};
+var UnsupportedRelayLivenessState = class extends RelayLivenessState {
+};
+var AwaitingHeartbeatAckState = class extends RelayLivenessState {
+  heartbeatId;
+  timeout;
+  constructor(heartbeatId, timeout) {
+    super();
+    this.heartbeatId = heartbeatId;
+    this.timeout = timeout;
+  }
+};
+var WaitingForHeartbeatState = class extends RelayLivenessState {
+  schedule;
+  constructor(schedule) {
+    super();
+    this.schedule = schedule;
+  }
+};
+var FinishedRelayLivenessState = class extends RelayLivenessState {
+};
+var RelayConnectionLiveness = class {
+  #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 = randomUUID2();
+    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
+      })
+    );
+  };
+};
+
+// src/relay-connection/timer.ts
+var SystemDaemonTimer = class {
+  schedule = (callback, milliseconds) => {
+    const timeout = setTimeout(callback, milliseconds);
+    return { cancel: () => clearTimeout(timeout) };
+  };
+};
+var systemDaemonTimer = new SystemDaemonTimer();
+
 // src/run-daemon.ts
 var RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
+var RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1e3;
+var RelayConnectionRefreshState = class {
+};
+var ScheduledRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
+};
+var DueRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
+};
+var FinishedRelayConnectionRefreshState = class extends RelayConnectionRefreshState {
+};
+var RelayConnectionRefresh = class {
+  #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();
+  };
+};
 var DaemonAcpObserver = class {
   #socket;
   constructor(socket) {
@@ -22889,7 +23098,7 @@ async function executePrompt(socket, command, config2, directories, audit, sessi
       command.additionalDirectoryIds
     );
     const agent = findLocalAgent(config2.agents, command.agentId);
-    const processAttemptId = randomUUID2();
+    const processAttemptId = randomUUID3();
     audit.record({
       commandId: command.commandId,
       event: "session_authorized",
@@ -22982,28 +23191,32 @@ async function executePrompt(socket, command, config2, directories, audit, sessi
     console.error("Mobius daemon command failed", error61);
   }
 }
-function waitForRelayRetry(signal) {
+function waitForRelayRetry(signal, timer) {
   if (signal.aborted) {
     return Promise.resolve();
   }
   return new Promise((resolve2) => {
-    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);
       resolve2();
     }
     signal.addEventListener("abort", finish, { once: true });
   });
 }
-async function runRelayConnection(config2, directories, audit, sessions, signal) {
-  const socket = await connectRelay(config2.relayUrl, signal);
+async function runRelayConnection(config2, directories, audit, sessions, signal, timer) {
+  const relayUrl = new URL(config2.relayUrl);
+  relayUrl.searchParams.set("liveness", "1");
+  const socket = await connectRelay(relayUrl, signal);
   const activeTurns = /* @__PURE__ */ new Map();
   const connectionController = new AbortController();
   sessions.setObserver(new DaemonAcpObserver(socket));
   await new Promise((resolve2, reject) => {
     let finished = false;
     const cleanup = () => {
+      connectionRefresh.close();
+      connectionLiveness.close();
       signal.removeEventListener("abort", stop);
       socket.removeEventListener("close", handleClose);
       socket.removeEventListener("error", handleError);
@@ -23034,6 +23247,22 @@ async function runRelayConnection(config2, directories, audit, sessions, signal)
       socket.close(1e3, "Daemon stopped");
       resolveConnection();
     };
+    const refreshConnection = () => {
+      socket.close(1e3, "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();
@@ -23048,11 +23277,23 @@ async function runRelayConnection(config2, 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 turn2 = activeTurns.get(cancellation.commandId);
@@ -23146,8 +23387,7 @@ async function runRelayConnection(config2, directories, audit, sessions, signal)
           return;
         }
         if (kind !== SESSION_PROMPT_KIND) {
-          socket.close(1008, "Unsupported protocol message");
-          return;
+          throw new Error("Unsupported protocol message");
         }
         const command = decodeSessionPromptCommand(encoded);
         if (activeTurns.has(command.commandId)) {
@@ -23173,10 +23413,12 @@ async function runRelayConnection(config2, directories, audit, sessions, signal)
           console.error("Mobius daemon turn failed", error61);
         }).finally(() => {
           activeTurns.delete(command.commandId);
+          connectionRefresh.afterTurnFinished();
         });
       } catch (error61) {
         console.error("Mobius daemon rejected a message", error61);
-        socket.close(1008, "Invalid protocol message");
+        socket.close(4008, "Invalid protocol message");
+        rejectConnection();
       }
     };
     socket.addEventListener("close", handleClose);
@@ -23187,7 +23429,7 @@ async function runRelayConnection(config2, directories, audit, sessions, signal)
     }
   });
 }
-async function runDaemon(config2, audit, signal) {
+async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
   const sessionStore = new SqliteAcpSessionStore(config2.auditDatabasePath);
   const sessions = new AcpSessionManager(
     new NullAcpSessionObserver(),
@@ -23201,7 +23443,14 @@ async function runDaemon(config2, audit, signal) {
   try {
     while (!signal.aborted) {
       try {
-        await runRelayConnection(config2, directories, audit, sessions, signal);
+        await runRelayConnection(
+          config2,
+          directories,
+          audit,
+          sessions,
+          signal,
+          timer
+        );
         retryAnnounced = false;
       } catch {
         if (signal.aborted) {
@@ -23212,7 +23461,7 @@ async function runDaemon(config2, audit, signal) {
           retryAnnounced = true;
         }
       }
-      await waitForRelayRetry(signal);
+      await waitForRelayRetry(signal, timer);
     }
   } finally {
     await sessions.close();