@vibesdotdev/session 1.0.0-rc.4 → 1.0.0-rc.8

package/dist/manager.js

@@ -18,7 +18,7 @@ import { getVibesClient } from '@vibesdotdev/kernel/client';
 import { JsonValueSchema as JsonSchema } from '@vibesdotdev/kernel/schemas/json';
 import { getLogger } from '@vibesdotdev/logging';
 import { StorageRecord } from '@vibesdotdev/storage/record';
-import { storageFailureCondition } from '@vibesdotdev/storage/record/failure-condition';
+import { isUniqueConstraintError, writeOrRecover } from "./storage/write-or-recover.js";
 import { ScratchpadContentTypeSchema } from "./schemas/index.js";
 import { HarnessSeatRegistrationSchema, HarnessSeatSchema, harnessSeatParticipantId, harnessSeatSlug } from "./schemas/harness-seat.js";
 import { ensureSessionContextWithManager, getOrCreateMCPParticipant, resolveParticipantReference, participantSlugOf, sanitizeSlugCandidate, scanParticipantsBySlug } from "./mcp/utils/participant.js";
@@ -31,44 +31,6 @@ const SESSION_STATE_MCP_PREFIX = 'mcp:';
 const PARTICIPANT_ACTIVE_WINDOW_MS = 5 * 60 * 1000;
 /** The runtime client id notifications register their delivery client under. */
 const NOTIFICATIONS_CLIENT_ID = 'notifications.delivery';
-/**
- * Whether a storage write lost a unique-index race. LocalDB's driver classifies
- * the collision on its typed refusal (`unique-constraint`); the adapter's text
- * is never read. A conflict another adapter reports untyped is not recognised
- * here and propagates (cross-lane: storage has no adapter-neutral conflict code).
- */
-function isUniqueConstraintError(failure) {
-    return storageFailureCondition(failure) === 'unique-constraint';
-}
-/**
- * Run `write`; when it fails with a failure `recoverable` admits, run
- * `recover` instead. Any other failure of `write`, and a recovery that finds
- * nothing (`null`), rethrows the write's own failure; a recovery that throws
- * carries its own failure. The write's failure is never dropped.
- */
-async function writeOrRecover(write, recover, recoverable) {
-    let lost;
-    const steps = [
-        write,
-        async () => {
-            if (!recoverable(CaughtFailureSchema.parse(lost)))
-                throw lost;
-            const recovered = await recover();
-            if (recovered === null)
-                throw lost;
-            return recovered;
-        }
-    ];
-    for (const step of steps) {
-        try {
-            return await step();
-        }
-        catch (error) {
-            lost = error;
-        }
-    }
-    throw lost;
-}
 /** Any write failure admits a recovery read (the recovery itself confirms the race). */
 function anyFailure() {
     return true;
@@ -1870,8 +1832,14 @@ export class SessionManager {
                 });
             }
         }
-        const kept = existing && SessionManager.isLiveInstance(existing, nowIso) ? existing.activeHandle ?? undefined : undefined;
+        // The handle this key's own row still holds, live or lapsed: handles are
+        // unique, so a lapsed row that still holds one holds it for no one else.
+        const kept = existing && !existing.disconnectedAt ? existing.activeHandle ?? undefined : undefined;
         const base = input.agentId ?? input.harness ?? input.clientName;
+        const preferred = chosen ? undefined : await this.usablePreferredHandle(input, existing);
+        // A conversation arriving under a new key (its id changed) keeps the handle
+        // it holds under the old one: one conversation is one seat.
+        const inherited = chosen || kept ? undefined : await this.conversationHandle(input, nowIso);
         const fields = {
             participantId: input.participantId ?? existing?.participantId,
             clientName: input.clientName,
@@ -1883,14 +1851,23 @@ export class SessionManager {
             agentId: input.agentId,
             harness: input.harness,
             harnessSessionId: input.harnessSessionId,
+            homeWorkspace: input.homeWorkspace ?? existing?.homeWorkspace ?? null,
             lastHeartbeatAt: nowAt,
             expiresAt,
             disconnectedAt: null
         };
+        // The handle to try, in order: the one demanded; else the one preferred (the
+        // seat's home handle), then the one already held, then a random one.
+        const candidates = chosen ? [] : [preferred, kept ?? inherited].filter((handle) => !!handle);
         for (let attempt = 0; attempt < SessionManager.INSTANCE_HANDLE_ATTEMPTS; attempt++) {
-            const handle = chosen ?? (attempt === 0 && kept ? kept : SessionManager.randomHandle(base));
-            if (handle !== existing?.activeHandle)
-                await this.releaseExpiredHandle(handle, input.instanceId, nowIso);
+            const handle = chosen ?? candidates[attempt] ?? SessionManager.randomHandle(base);
+            if (handle !== existing?.activeHandle) {
+                await this.releaseExpiredHandle(handle, input.instanceId, nowIso, {
+                    participantId: fields.participantId,
+                    harnessSessionId: input.harnessSessionId,
+                    transport: input.transport
+                });
+            }
             const row = { ...fields, handle, activeHandle: handle };
             const written = await settle(() => existing
                 ? storage.update(input.instanceId, row)
@@ -1919,8 +1896,50 @@ export class SessionManager {
             reason: 'instance-handle-exhausted'
         });
     }
-    /** Free `handle` when its holder is no longer live, so a new instance can take it. */
-    async releaseExpiredHandle(handle, claimant, nowIso) {
+    /** The handle `input`'s own conversation holds under another instance key it succeeds, if any. */
+    async conversationHandle(input, nowIso) {
+        if (!input.harnessSessionId || !input.participantId)
+            return undefined;
+        const rows = await this.connectionsStorage.list({
+            where: { harnessSessionId: input.harnessSessionId, participantId: input.participantId },
+            limit: 10
+        });
+        const sibling = rows.items.find((row) => row.connectionId !== input.instanceId &&
+            !!row.activeHandle &&
+            !row.disconnectedAt &&
+            SessionManager.succeeds(row, input.transport, nowIso));
+        return sibling?.activeHandle ?? undefined;
+    }
+    /**
+     * Whether a new key of the same conversation succeeds `row`: the row has
+     * lapsed, or it is on the same transport (a restart). A conversation live
+     * on two transports at once (an MCP connection and an in-process host) is
+     * two instances, and neither takes the other's handle or closes it.
+     */
+    static succeeds(row, transport, nowIso) {
+        return !SessionManager.isLiveInstance(row, nowIso) || (!!transport && row.transport === transport);
+    }
+    /**
+     * The preferred handle an instance may take: sanitized, and not another
+     * participant's name (a live handle resolves ahead of slugs, so it would
+     * capture that participant's messages). Undefined when there is none.
+     */
+    async usablePreferredHandle(input, existing) {
+        const preferred = input.preferredHandle?.trim() ? sanitizeSlugCandidate(input.preferredHandle) : undefined;
+        if (!preferred)
+            return undefined;
+        const named = (await scanParticipantsBySlug(this, preferred)).match;
+        const actsAs = input.participantId ?? existing?.participantId;
+        return named && named.participantId !== actsAs ? undefined : preferred;
+    }
+    /**
+     * Free `handle` for `claimant` when its holder is no longer live, or when the
+     * holder is the claimant's own conversation under another instance key the
+     * claimant succeeds (same participant, same harness conversation; lapsed or on
+     * the same transport): one conversation is one seat, so the stale key is
+     * closed and the handle moves with it.
+     */
+    async releaseExpiredHandle(handle, claimant, nowIso, seat = {}) {
         const held = await this.connectionsStorage.list({
             where: { activeHandle: handle },
             limit: 1
@@ -1928,6 +1947,14 @@ export class SessionManager {
         const holder = held.items[0];
         if (!holder || holder.connectionId === claimant)
             return;
+        const sameConversation = !!seat.harnessSessionId &&
+            holder.harnessSessionId === seat.harnessSessionId &&
+            !!seat.participantId &&
+            holder.participantId === seat.participantId;
+        if (sameConversation && SessionManager.succeeds(holder, seat.transport, nowIso)) {
+            await this.closeInstance(holder.connectionId);
+            return;
+        }
         if (SessionManager.isLiveInstance(holder, nowIso))
             return;
         await this.connectionsStorage.update(holder.connectionId, { activeHandle: null });
@@ -2170,6 +2197,11 @@ export class SessionManager {
                 });
                 for (const message of arrived.items) {
                     const createdAt = message.createdAt instanceof Date ? message.createdAt : new Date(message.createdAt);
+                    // A message the sender addressed to one instance (by its handle) wakes only that instance.
+                    if (message.toInstance && message.toInstance !== instanceId) {
+                        this.deliveryCursors.set(instanceId, createdAt);
+                        continue;
+                    }
                     const sender = await this.getParticipant(message.fromParticipant);
                     await this.hostRuntime.hooks('session').emit('messageArrived', {
                         instanceId,