commandmate 0.48.0 → 0.49.0

package/dist/server/src/lib/session/waiting-episode-state-ops.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * The low-level episode writes: open / close / replace / rebind / updateKind
+ * (Issue #3798). Each one emits through the store's listeners.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openEpisode = openEpisode;
+exports.closeEpisode = closeEpisode;
+exports.replaceEpisode = replaceEpisode;
+exports.rebindEpisode = rebindEpisode;
+exports.updateEpisodeKind = updateEpisodeKind;
+const waiting_episode_state_store_1 = require("../../lib/session/waiting-episode-state-store");
+/**
+ * Open an episode (Issue #3798). Low-level: the caller has decided there is
+ * none open and what it is bound to. Emits the opening edge.
+ */
+function openEpisode(parts, next, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const view = { since: next.since, kind: next.kind };
+    const meta = {
+        episodeId: (0, waiting_episode_state_store_1.nextEpisodeId)(),
+        openedAt: at,
+        boundAt: at,
+        binding: next.binding,
+        openedBy: next.openedBy,
+        promptScreenKey: next.promptScreenKey ?? null,
+    };
+    waiting_episode_state_store_1.episodes.set(key, view);
+    waiting_episode_state_store_1.metas.set(view, meta);
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    (0, waiting_episode_state_store_1.emit)({
+        worktreeId: parts.worktreeId,
+        cliToolId: parts.cliToolId,
+        instanceId: parts.instanceId,
+        waiting: true,
+        since: view.since,
+        kind: view.kind,
+        at,
+        cause: 'opened',
+        episodeId: meta.episodeId,
+        previousEpisodeId: null,
+        closeReason: null,
+    });
+    return { ...view, ...meta };
+}
+/**
+ * Close the open episode when it is still `expectedId` (Issue #3798). A closer
+ * that names the episode it decided about cannot close a later one.
+ *
+ * @returns Whether an episode was closed
+ */
+function closeEpisode(parts, expectedId, reason, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const view = waiting_episode_state_store_1.episodes.get(key);
+    if (view === undefined)
+        return false;
+    const meta = (0, waiting_episode_state_store_1.metaOf)(view);
+    if (meta.episodeId !== expectedId)
+        return false;
+    waiting_episode_state_store_1.episodes.delete(key);
+    waiting_episode_state_store_1.lastClosed.set(key, { at, promptScreenKey: meta.promptScreenKey });
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    (0, waiting_episode_state_store_1.emit)({
+        worktreeId: parts.worktreeId,
+        cliToolId: parts.cliToolId,
+        instanceId: parts.instanceId,
+        waiting: false,
+        since: null,
+        kind: null,
+        at,
+        cause: 'closed',
+        episodeId: null,
+        previousEpisodeId: meta.episodeId,
+        closeReason: reason,
+    });
+    return true;
+}
+/**
+ * Put a new episode in place of `expectedId` as one operation (Issue #3798):
+ * listeners hear a single opening edge for the new wait and no closing one
+ * in between, so nothing reports "nobody is waiting" mid-swap.
+ *
+ * @returns The new episode, or null when `expectedId` is no longer open
+ */
+function replaceEpisode(parts, expectedId, next, reason, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const old = waiting_episode_state_store_1.episodes.get(key);
+    if (old === undefined)
+        return null;
+    const oldMeta = (0, waiting_episode_state_store_1.metaOf)(old);
+    if (oldMeta.episodeId !== expectedId)
+        return null;
+    waiting_episode_state_store_1.lastClosed.set(key, { at, promptScreenKey: oldMeta.promptScreenKey });
+    const view = { since: next.since, kind: next.kind };
+    const meta = {
+        episodeId: (0, waiting_episode_state_store_1.nextEpisodeId)(),
+        openedAt: at,
+        boundAt: at,
+        binding: next.binding,
+        openedBy: next.openedBy,
+        promptScreenKey: next.promptScreenKey ?? null,
+    };
+    waiting_episode_state_store_1.episodes.set(key, view);
+    waiting_episode_state_store_1.metas.set(view, meta);
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    (0, waiting_episode_state_store_1.emit)({
+        worktreeId: parts.worktreeId,
+        cliToolId: parts.cliToolId,
+        instanceId: parts.instanceId,
+        waiting: true,
+        since: view.since,
+        kind: view.kind,
+        at,
+        cause: 'replaced',
+        episodeId: meta.episodeId,
+        previousEpisodeId: oldMeta.episodeId,
+        closeReason: reason,
+    });
+    return { ...view, ...meta };
+}
+/**
+ * Change what the open episode `expectedId` is bound to (Issue #3798). Not an
+ * edge: the wait goes on, so nothing is emitted and `since` stays.
+ *
+ * @returns Whether the episode was rebound
+ */
+function rebindEpisode(parts, expectedId, binding, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const view = waiting_episode_state_store_1.episodes.get(key);
+    if (view === undefined)
+        return false;
+    const meta = (0, waiting_episode_state_store_1.metaOf)(view);
+    if (meta.episodeId !== expectedId)
+        return false;
+    meta.binding = binding;
+    meta.boundAt = at;
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    return true;
+}
+/**
+ * Refresh the kind of the open episode `expectedId` (Issue #3798, I10). The
+ * wait goes on: no edge, and the version does not move.
+ *
+ * @returns Whether the episode was still open
+ */
+function updateEpisodeKind(parts, expectedId, kind) {
+    const view = waiting_episode_state_store_1.episodes.get((0, waiting_episode_state_store_1.keyOf)(parts));
+    if (view === undefined || (0, waiting_episode_state_store_1.metaOf)(view).episodeId !== expectedId)
+        return false;
+    view.kind = kind;
+    return true;
+}

package/dist/server/src/lib/session/waiting-episode-state-store.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * The waiting-episode store's state tables, its listeners and the reads
+ * (Issue #1786 / #3798). The single place that initialises each `globalThis` slot.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKNOWN_BINDING = exports.lastClosed = exports.metas = exports.episodes = void 0;
+exports.nextEpisodeId = nextEpisodeId;
+exports.keyOf = keyOf;
+exports.bumpVersion = bumpVersion;
+exports.onWaitingTransition = onWaitingTransition;
+exports.onWaitingEpisodeTransition = onWaitingEpisodeTransition;
+exports.emit = emit;
+exports.metaOf = metaOf;
+exports.getWaitingEpisodeRecord = getWaitingEpisodeRecord;
+exports.getEpisodeVersion = getEpisodeVersion;
+exports.snapshotEpisodeVersions = snapshotEpisodeVersions;
+exports.getLastClosedEpisode = getLastClosedEpisode;
+exports.getWaitingEpisode = getWaitingEpisode;
+exports.hasOpenWaitingEpisode = hasOpenWaitingEpisode;
+exports.clearWaitingEpisodes = clearWaitingEpisodes;
+exports.clearWaitingTransitionListeners = clearWaitingTransitionListeners;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
+const logger = (0, logger_1.createLogger)('waiting-episode-state');
+/** compositeKey -> the wait currently in progress for that instance. */
+exports.episodes = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodes', () => new Map());
+/** Subscribers to the edge. See the module docblock. */
+const listeners = (0, global_state_1.getOrInitGlobal)('__sessionWaitingTransitionListeners', () => new Set());
+exports.metas = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeMeta', () => new WeakMap());
+const versions = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeVersions', () => new Map());
+exports.lastClosed = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeLastClosed', () => new Map());
+const episodeSeq = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeSeq', () => ({
+    value: 0,
+    nonce: Math.random().toString(36).slice(2, 10),
+}));
+const episodeListeners = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeListeners', () => new Set());
+/** The binding used when no resolver is registered: nothing is known. */
+exports.UNKNOWN_BINDING = {
+    kind: 'unattributed',
+    generation: { kind: 'none' },
+    lastClosedTurnId: null,
+};
+function nextEpisodeId() {
+    episodeSeq.value += 1;
+    return `wep-${episodeSeq.nonce}-${episodeSeq.value}`;
+}
+function keyOf(parts) {
+    return (0, auto_yes_state_1.buildCompositeKey)(parts.worktreeId, parts.cliToolId, parts.instanceId);
+}
+function bumpVersion(key) {
+    versions.set(key, (versions.get(key) ?? 0) + 1);
+}
+/**
+ * Subscribe to waiting edges.
+ *
+ * @returns An unsubscribe function. Idempotent — calling it twice is harmless.
+ */
+function onWaitingTransition(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/**
+ * Subscribe to waiting edges with the episode's identity (Issue #3798).
+ *
+ * The same crossings `onWaitingTransition` delivers, in the same order, with
+ * the cause, the episode ids and the close reason added.
+ */
+function onWaitingEpisodeTransition(listener) {
+    episodeListeners.add(listener);
+    return () => {
+        episodeListeners.delete(listener);
+    };
+}
+/** Notify subscribers, containing anything they throw. */
+function emit(transition) {
+    const { cause: _cause, episodeId: _id, previousEpisodeId: _prev, closeReason: _reason, ...plain } = transition;
+    for (const listener of listeners) {
+        try {
+            listener(plain);
+        }
+        catch (error) {
+            logListenerFailure(transition, error);
+        }
+    }
+    for (const listener of episodeListeners) {
+        try {
+            listener(transition);
+        }
+        catch (error) {
+            logListenerFailure(transition, error);
+        }
+    }
+}
+function logListenerFailure(transition, error) {
+    logger.error('waiting-transition-listener-failed', {
+        worktreeId: transition.worktreeId,
+        cliToolId: transition.cliToolId,
+        instanceId: transition.instanceId ?? transition.cliToolId,
+        waiting: transition.waiting,
+        error: error instanceof Error ? error.message : String(error),
+    });
+}
+/**
+ * The meta of an episode in the map. An episode put there without one (a test
+ * that wrote the map directly) is given an unattributed identity on first read.
+ */
+function metaOf(view) {
+    let meta = exports.metas.get(view);
+    if (meta === undefined) {
+        meta = {
+            episodeId: nextEpisodeId(),
+            openedAt: view.since,
+            boundAt: view.since,
+            binding: exports.UNKNOWN_BINDING,
+            openedBy: 'legacy-edge',
+            promptScreenKey: null,
+        };
+        exports.metas.set(view, meta);
+    }
+    return meta;
+}
+/** The open episode with its identity and binding, or null (Issue #3798). */
+function getWaitingEpisodeRecord(worktreeId, cliToolId, instanceId) {
+    const view = exports.episodes.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
+    if (view === undefined)
+        return null;
+    const meta = metaOf(view);
+    return { since: view.since, kind: view.kind, ...meta, binding: meta.binding };
+}
+/** The instance's episode version: it moves on every open, close, replacement and rebind. */
+function getEpisodeVersion(worktreeId, cliToolId, instanceId) {
+    return versions.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? 0;
+}
+/**
+ * Every instance version of one worktree, as of now (Issue #3798): the status
+ * probe fixes them before it lists the tmux sessions. An instance missing from
+ * the map is at version 0.
+ */
+function snapshotEpisodeVersions(worktreeId) {
+    const prefix = `${worktreeId}${auto_yes_state_1.COMPOSITE_KEY_SEPARATOR}`;
+    const snapshot = new Map();
+    for (const [key, version] of versions) {
+        if (key.startsWith(prefix))
+            snapshot.set(key, version);
+    }
+    return snapshot;
+}
+/** The last episode that ended for this instance, or null. */
+function getLastClosedEpisode(worktreeId, cliToolId, instanceId) {
+    return exports.lastClosed.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * @returns The wait in progress for this instance, or null when it is not
+ *   waiting. Read-only: observing the edge is {@link observeWaitingEdge}'s job.
+ */
+function getWaitingEpisode(worktreeId, cliToolId, instanceId) {
+    return exports.episodes.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * Whether **any** instance in this worktree is still waiting (Issue #2001).
+ *
+ * The cross-device dismissal is keyed on the worktree, because that is what the
+ * Service Worker `tag` names (`<worktreeId>:prompt`, `push-sender`): two agent
+ * instances waiting in one worktree share a single notification card on the
+ * phone. So one instance crossing the closing edge is not on its own a reason
+ * to clear that card — the card is still telling the truth until the last of
+ * them has been answered.
+ *
+ * The prefix test is exact rather than heuristic: `buildCompositeKey` puts the
+ * worktree id first and rejects a worktree id containing
+ * {@link COMPOSITE_KEY_SEPARATOR}, so no other worktree's key can start with
+ * `<worktreeId>:`.
+ */
+function hasOpenWaitingEpisode(worktreeId) {
+    const prefix = `${worktreeId}${auto_yes_state_1.COMPOSITE_KEY_SEPARATOR}`;
+    for (const key of exports.episodes.keys()) {
+        if (key.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+/**
+ * Drop every episode. Test seam.
+ *
+ * CI runs with `fileParallelism: false`, so one process holds this map for the
+ * whole suite: a test that opens an episode and does not clear it hands the next
+ * file a session that is already waiting.
+ */
+function clearWaitingEpisodes() {
+    exports.episodes.clear();
+    versions.clear();
+    exports.lastClosed.clear();
+}
+/** Drop every subscriber. Test seam, paired with {@link clearWaitingEpisodes}. */
+function clearWaitingTransitionListeners() {
+    listeners.clear();
+    episodeListeners.clear();
+}

package/dist/server/src/lib/session/waiting-episode-state-types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * The types of the waiting-episode store (Issue #1786 / #3798). No runtime
+ * state lives here; `waiting-episode-state` re-exports every public name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });