commandmate 0.31.2 → 0.31.3

package/dist/server/src/lib/realtime/model-change-broadcast.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * What happens when an agent instance changes model (Issue #2357).
+ *
+ * ## The edge, and its three receivers
+ *
+ * `agent-event-state` judges the model edge — the merged hook/frame value moving
+ * from one model to another, with the first sighting, the value going quiet
+ * and a spelling change all ruled out there — and hands it out through
+ * `onAgentModelChange`. This module is that subscription, and it is the ONE
+ * subscription: the three things the Issue asks for on the receiving side are
+ * fanned out from here, in the order that leaves the most durable trace first.
+ *
+ *  1. **The history row.** One assistant row in `chat_messages`, in the
+ *     readers' language, so the chat transcript and the History tab both keep
+ *     "the model changed from A to B" where the conversation is. Written
+ *     first, because it is the receiver that survives a phone being off.
+ *  2. **The room frames.** The row is pushed as a `message` frame — the same
+ *     frame `sendUserMessage` publishes — so a transcript that is open shows
+ *     the line without waiting for its poll; then the `model_changed` frame
+ *     itself, which is what the phone's session row turns amber on.
+ *  3. **The push.** `notifyModelChangePush`, fire-and-forget; it has its own
+ *     dedup and its own logging.
+ *
+ * Each receiver is wrapped separately: a database that cannot be written must
+ * not cost the reader the socket frame, and a socket with no owner must not
+ * cost them the push.
+ *
+ * ## Why `publish` is injected, and who arms this
+ *
+ * The same shape as `waiting-broadcast`, and armed by it: `ws-server` owns the
+ * rooms and calls `startWaitingStatusBroadcast(handleBroadcast)` from
+ * `setupWebSocket`, which is the one place in the process that knows which
+ * bundle's `rooms` a frame has to reach. That call now arms this subscription
+ * too, with the same publisher, and `stopWaitingStatusBroadcast` (from
+ * `closeWebSocket`) disarms both — so the listener's lifetime is the server's,
+ * and a suite that stands a server up and tears it down leaves nothing pointed
+ * at a dead room map.
+ *
+ * ## Authorization
+ *
+ * None is bypassed: the publisher is the room broadcaster, and a socket only
+ * joins a room through the authenticated `subscribe` path.
+ *
+ * @module lib/realtime/model-change-broadcast
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModelChangedEvent = buildModelChangedEvent;
+exports.handleAgentModelChange = handleAgentModelChange;
+exports.startModelChangeBroadcast = startModelChangeBroadcast;
+exports.stopModelChangeBroadcast = stopModelChangeBroadcast;
+exports.isModelChangeBroadcastActive = isModelChangeBroadcastActive;
+const db_instance_1 = require("../../lib/db/db-instance");
+const chat_db_1 = require("../../lib/db/chat-db");
+const logger_1 = require("../../lib/logger");
+const model_change_push_notifier_1 = require("../../lib/push/model-change-push-notifier");
+const types_1 = require("../../lib/realtime/types");
+const agent_event_state_1 = require("../../lib/session/agent-event-state");
+const logger = (0, logger_1.createLogger)('model-change-broadcast');
+/**
+ * Translate a model edge into the frame clients receive.
+ *
+ * Field for field the producer's record; `instance` is already resolved there
+ * (`instanceId ?? cliToolId`), so a client can match it against its own pane
+ * without re-deriving the convention.
+ */
+function buildModelChangedEvent(change) {
+    return {
+        type: types_1.MODEL_CHANGED_EVENT_TYPE,
+        worktreeId: change.worktreeId,
+        cliTool: change.cliToolId,
+        instance: change.instanceId,
+        from: change.from,
+        to: change.to,
+        source: change.source,
+        at: change.at,
+    };
+}
+/**
+ * Write the history row and hand back the `message` frame for it, or null
+ * when the database could not take it.
+ *
+ * Never throws. The sentence is localized once, for the readers' registered
+ * language (`resolveReadersLocale`) — a stored row cannot be re-rendered per
+ * viewer the way the push body is.
+ */
+function recordModelChangeHistory(change) {
+    try {
+        const db = (0, db_instance_1.getDbInstance)();
+        const locale = (0, model_change_push_notifier_1.resolveReadersLocale)(db);
+        const message = (0, chat_db_1.createModelChangeMessage)(db, {
+            worktreeId: change.worktreeId,
+            cliToolId: change.cliToolId,
+            instanceId: change.instanceId,
+            content: (0, model_change_push_notifier_1.buildModelChangedSentence)(locale, change.from, change.to),
+            at: change.at,
+        });
+        return { type: 'message', worktreeId: change.worktreeId, message };
+    }
+    catch (error) {
+        logger.warn('model-change-history-failed', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+/**
+ * Deliver one edge to all three receivers. Exported so a suite can drive the
+ * fan-out without a live subscription; never throws.
+ */
+function handleAgentModelChange(change, publish) {
+    logger.info('model-changed', {
+        worktreeId: change.worktreeId,
+        cliToolId: change.cliToolId,
+        instanceId: change.instanceId,
+        from: change.from,
+        to: change.to,
+        source: change.source,
+    });
+    const messageFrame = recordModelChangeHistory(change);
+    try {
+        if (messageFrame)
+            publish(change.worktreeId, messageFrame);
+        publish(change.worktreeId, buildModelChangedEvent(change));
+    }
+    catch (error) {
+        logger.warn('model-change-broadcast-failed', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    // Fire-and-forget: `notifyModelChangePush` contains its own failures and
+    // logs its own decision, and nothing here has anything to do with the result.
+    void (0, model_change_push_notifier_1.notifyModelChangePush)(change);
+}
+/**
+ * Subscribe to the model edge and fan it out.
+ *
+ * Idempotent: calling it again replaces the previous subscription rather than
+ * adding a second one, so a re-entered `setupWebSocket` cannot double-send.
+ *
+ * @param publish - Room broadcaster, normally `ws-server`'s internal one.
+ * @returns The unsubscribe function (also reachable as
+ *   {@link stopModelChangeBroadcast}).
+ */
+function startModelChangeBroadcast(publish) {
+    stopModelChangeBroadcast();
+    const unsubscribe = (0, agent_event_state_1.onAgentModelChange)((change) => {
+        handleAgentModelChange(change, publish);
+    });
+    globalThis.__modelChangeBroadcastUnsubscribe = unsubscribe;
+    return unsubscribe;
+}
+/**
+ * Drop the subscription, if any. Safe to call when none is active — and called
+ * from `stopWaitingStatusBroadcast`, i.e. from `closeWebSocket`.
+ */
+function stopModelChangeBroadcast() {
+    const existing = globalThis.__modelChangeBroadcastUnsubscribe;
+    if (existing) {
+        existing();
+        globalThis.__modelChangeBroadcastUnsubscribe = undefined;
+    }
+}
+/** Whether a subscription is currently active. Test seam. */
+function isModelChangeBroadcastActive() {
+    return globalThis.__modelChangeBroadcastUnsubscribe !== undefined;
+}

package/dist/server/src/lib/realtime/types.js

@@ -9,7 +9,7 @@
  * the canonical {@link RealtimeEvent}.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MESSAGES_INVALIDATED_EVENT_TYPE = exports.MAX_CHAT_TURN_PROGRESS_BODY_LENGTH = exports.CHAT_TURN_PROGRESS_MIN_INTERVAL_MS = exports.CHAT_TURN_PROGRESS_EVENT_TYPE = exports.VERSION_MISMATCH_EVENT_TYPE = exports.CLIENT_VERSION_MESSAGE_TYPE = void 0;
+exports.MODEL_CHANGED_EVENT_TYPE = exports.MESSAGES_INVALIDATED_EVENT_TYPE = exports.MAX_CHAT_TURN_PROGRESS_BODY_LENGTH = exports.CHAT_TURN_PROGRESS_MIN_INTERVAL_MS = exports.CHAT_TURN_PROGRESS_EVENT_TYPE = exports.VERSION_MISMATCH_EVENT_TYPE = exports.CLIENT_VERSION_MESSAGE_TYPE = void 0;
 exports.isVersionMismatch = isVersionMismatch;
 exports.truncateChatTurnProgressBody = truncateChatTurnProgressBody;
 exports.parseRealtimeEvent = parseRealtimeEvent;
@@ -143,6 +143,24 @@ function truncateChatTurnProgressBody(body, maxLength = exports.MAX_CHAT_TURN_PR
  * an omitted field would simply never match.
  */
 exports.MESSAGES_INVALIDATED_EVENT_TYPE = 'messages_invalidated';
+/**
+ * "This instance is now on a different model" (Issue #2357).
+ *
+ * Emitted once per transition from `agent-event-state`'s model edge, on the
+ * same room broadcast `session_status_changed` rides — so every client that
+ * subscribed to the worktree hears it, and one that never subscribed does not.
+ * It is its own type rather than a field on `session_status_changed` because
+ * the consumers do not overlap: the phone's session row is the only thing that
+ * reacts, and every `session_status_changed` listener would otherwise have to
+ * learn to ignore it.
+ *
+ * `from` and `to` are the resolved values `sessionStatusByInstance[].model`
+ * publishes, verbatim — the client shows them, it does not compare them. The
+ * suppression rules (`null → value`, `value → null`, a first sighting, a
+ * spelling change) are applied by the producer, and there is nothing here for
+ * a client to re-judge.
+ */
+exports.MODEL_CHANGED_EVENT_TYPE = 'model_changed';
 /**
  * Parse a raw WebSocket frame into the inner realtime event.
  *

package/dist/server/src/lib/realtime/waiting-broadcast.js

@@ -37,6 +37,7 @@ exports.buildWaitingStatusEvent = buildWaitingStatusEvent;
 exports.startWaitingStatusBroadcast = startWaitingStatusBroadcast;
 exports.stopWaitingStatusBroadcast = stopWaitingStatusBroadcast;
 exports.isWaitingStatusBroadcastActive = isWaitingStatusBroadcastActive;
+const model_change_broadcast_1 = require("../../lib/realtime/model-change-broadcast");
 const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
 /**
  * Translate a waiting crossing into the frame clients receive.
@@ -63,6 +64,14 @@ function buildWaitingStatusEvent(transition) {
  * Idempotent: calling it again replaces the previous subscription rather than
  * adding a second one, so a re-entered `setupWebSocket` cannot double-send.
  *
+ * Issue #2357: this is also where the model edge is armed. `setupWebSocket`
+ * calls exactly one function to start the edge → room subscriptions, and it
+ * is this one; the model-change fan-out (`model-change-broadcast`) needs the
+ * same publisher for the same reason the waiting edge does — the closure has
+ * to hold the bundle's own `rooms` — so it is started here with it, and
+ * stopped with it below, rather than growing a second arming call in
+ * `ws-server` for every edge that comes along.
+ *
  * @param publish - Room broadcaster, normally `ws-server`'s internal one.
  * @returns The unsubscribe function (also reachable as
  *   {@link stopWaitingStatusBroadcast}).
@@ -73,12 +82,15 @@ function startWaitingStatusBroadcast(publish) {
         publish(transition.worktreeId, buildWaitingStatusEvent(transition));
     });
     globalThis.__waitingStatusBroadcastUnsubscribe = unsubscribe;
+    (0, model_change_broadcast_1.startModelChangeBroadcast)(publish);
     return unsubscribe;
 }
 /**
  * Drop the subscription, if any. Safe to call when none is active — and called
  * from `closeWebSocket`, so a suite that stands a server up and tears it down
  * does not leave a listener pointed at a dead room map.
+ *
+ * Issue #2357: drops the model edge's subscription with it, for the same reason.
  */
 function stopWaitingStatusBroadcast() {
     const existing = globalThis.__waitingStatusBroadcastUnsubscribe;
@@ -86,6 +98,7 @@ function stopWaitingStatusBroadcast() {
         existing();
         globalThis.__waitingStatusBroadcastUnsubscribe = undefined;
     }
+    (0, model_change_broadcast_1.stopModelChangeBroadcast)();
 }
 /** Whether a subscription is currently active. Test seam. */
 function isWaitingStatusBroadcastActive() {