@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/lock-service/index.d.ts

@@ -1,6 +1,9 @@
-import EventEmitter from "node:events";
-import { type ErrorEventMap } from "../errors/error-handler.js";
 import type { Tracer } from "@opentelemetry/api";
+import { ConflictError, TracedEventEmitter } from "@superblocksteam/shared";
+import type { LockInfo } from "@superblocksteam/shared";
+import { type ErrorEventMap } from "../errors/error-handler.js";
+import type { AutoConnectingRpcClient } from "../server-rpc/index.js";
+import type { Logger } from "../util/logger.js";
 export declare enum LockServiceStatus {
     /** The lock service is not currently active */
     IDLE = "IDLE",
@@ -23,71 +26,393 @@ export declare enum LockType {
 }
 /** Configuration for the LockService passed to the constructor */
 export interface LockServiceConfig {
-    authToken: string;
     superblocksBaseUrl: string;
     applicationId: string;
     branchName: string;
     lockType: LockType;
-    lockTimeoutMs?: number;
+    /**
+     * How long a gateway peer's liveness signal counts for before it must be
+     * refreshed. Default {@link GATEWAY_LIVENESS_TTL_MS}.
+     */
+    gatewayLivenessTtlMs?: number;
     heartbeatIntervalMs?: number;
+    inactivityThresholdMs: number;
+    lockBufferMs?: number;
+    rpcClient: AutoConnectingRpcClient;
     tracer: Tracer;
+    logger: Logger;
 }
 interface EventMap extends ErrorEventMap {
     /** Emitted when the lock service status changes */
-    statusChange: [status: LockServiceStatus];
+    statusChange: [status: LockServiceStatus, lockInfo?: LockInfo];
     /** Emitted when the lock is acquired */
     lockAcquired: [lockId: string];
     /** Emitted when the lock is released */
     lockReleased: [];
     /** Emitted when the lock heartbeat is received */
     lockHeartbeat: [lockId: string];
+    /** Emitted when the lock is released by the server */
+    closedByServer: [
+        {
+            initiatedByEmail?: string;
+            switchingTo?: "local" | "cloud" | "none";
+        }
+    ];
 }
-export declare class LockService extends EventEmitter<EventMap> {
-    private readonly authToken;
-    private readonly superblocksBaseUrl;
+/**
+ * The methods {@link LockService} reports as spans.
+ *
+ * `addTracingToMethods` matches by string, so an entry naming a method that no
+ * longer exists is dropped at runtime rather than failing to compile — tracing
+ * disappears and nothing says so. Exported so a test can assert every name here
+ * still resolves to a method.
+ */
+export declare const TRACED_LOCK_SERVICE_METHODS: readonly ["acquireLock", "releaseLock", "relinquishLock", "notifyClosedByServer", "checkAndUpdateLockIfPossible", "ensureLockForWrite", "shutdownAndExit", "restartInactivityTimer", "switchBranch"];
+export declare class LockService extends TracedEventEmitter<EventMap> {
     private readonly applicationId;
-    private readonly branchName;
+    private branchName;
     private readonly lockType;
     private readonly heartbeatIntervalMs;
-    private rpcClient;
     private syncCallback;
+    private waitForGenerationCompleteCallback;
+    private onGatewayLivenessLapsed;
+    private onLockConflict;
     private _status;
     private _lockId;
     private _heartbeatTimeout;
-    private _shutdownTimeout;
-    private _connectedUserPeerIdsMap;
+    private _heartbeatGeneration;
+    private _heartbeatStoppedForIdle;
+    private _lockGivenUp;
+    private _closedByServer;
+    /**
+     * True only while the last-chance sync of a session that is ending is in
+     * flight. That write is not gated on still holding the lock — see
+     * {@link ensureLockForWrite}.
+     */
+    private _flushingFinalWork;
+    /** The evaluation overlapping callers join rather than starting their own. */
+    private _inFlightLockEvaluation;
+    private _inactivityTimeout;
+    private _bufferPeriodTimeout;
+    private _isRestarting;
     private _tracer;
+    private _logger;
+    private _rpcClient;
+    private _inactivityThresholdMs;
+    private _lockBufferMs;
+    /** In-flight acquisition kicked off by a client attaching, if any. */
+    private _clientLockAcquisition;
+    private readonly _lockOperationQueue;
+    private _activityTracker;
+    /** Gateway peer id -> when its liveness was last refreshed. */
+    private readonly _gatewayLivenessByPeerId;
+    private readonly _gatewayLivenessTtlMs;
+    private _gatewayLivenessSweep;
     constructor(config: LockServiceConfig);
+    private getLogger;
     setSyncCallback(callback: () => Promise<void>): void;
+    setWaitForGenerationCompleteCallback(callback: () => Promise<void>): void;
+    /**
+     * Called when a gateway peer's liveness expires without a clean close.
+     *
+     * Half-open TCP leaves the socket map entry and the headless turn binding
+     * in place until something else tears them down. The lock already stops
+     * protecting the sandbox here; this hook lets the turn router release the
+     * same peer so Clark stops targeting a dead gateway.
+     */
+    setOnGatewayLivenessLapsed(callback: (peerId: string) => void): void;
+    /**
+     * Called when a client attached and somebody else already holds the lock.
+     *
+     * What a conflict means is the host's to decide, not this service's: a CLI
+     * with a person at it can describe the holder and offer a takeover, a
+     * sandbox can only write it down. This is the hook that used to be the
+     * `ConflictError` catch around the boot-time acquire.
+     */
+    setOnLockConflict(callback: (error: ConflictError) => Promise<void> | void): void;
     get status(): LockServiceStatus;
     private set status(value);
     get isLocked(): boolean;
     get lockId(): string | undefined;
+    get currentBranchName(): string;
     get connectedUsers(): string[];
+    get isRestarting(): boolean;
+    get wasRecentlyActive(): boolean;
+    get timeSinceLastActivity(): number | null;
+    /** Whether any client — a browser editor or a headless gateway peer — is here. */
+    private get hasAttachedClient();
+    /**
+     * A client attached and this pod has never held the lock: take it for them.
+     *
+     * The lock is a mutual-exclusion marker between clients, not a capability the
+     * pod needs in order to serve — no write path on either side gates on holding
+     * it. So it belongs to whoever is attached, and a pod that grabs it at boot
+     * only invents a state nobody wants: a lock held on behalf of nobody, which
+     * then needs a watchdog to clean up. Claiming it on attach makes that state
+     * unreachable instead.
+     *
+     * Deliberately narrower than {@link reclaimLockForActiveClient}: neither a
+     * lock this pod handed back nor one it was refused is taken here. A tab left
+     * open reconnects its socket on its own, so an attach is no evidence its user
+     * came back, and treating it as evidence would hand the app to somebody who
+     * walked away (APPS-4840).
+     */
+    private claimLockForFirstClient;
     /**
-     * Acquire a lock on the specified application and branch
+     * The client proved it is still there: take the lock if we do not have it.
+     *
+     * Driven by editor activity pings and by a gateway peer starting a turn —
+     * both are a client doing something, which is the evidence a lock we are not
+     * holding needs before it is worth asking for again.
+     *
+     * That includes a lock we were refused. A refusal is what happened to one
+     * attempt, not a mode this pod is stuck in: the other session ends, and the
+     * user sitting here still wants to edit. Without this a pod that lost one
+     * race could never take the lock again for the rest of its life — and since
+     * SABS hands running pods to the next caller, it would go on failing for
+     * people who had nothing to do with the race.
+     */
+    private reclaimLockForActiveClient;
+    /**
+     * Fire-and-forget by design: the sockets, pings and branch switches that ask
+     * for this have nothing to do with the answer.
+     *
+     * What keeps a retry from becoming a stream of 409s is the trigger, not the
+     * status: the only thing that asks repeatedly is the editor's activity ping,
+     * which the pod acts on solely while the user is genuinely active. A blocked
+     * session asks about as often as a held lock heartbeats; one nobody is
+     * sitting at goes quiet on its own.
+     */
+    private acquireLockForAttachedClient;
+    /**
+     * Record an acquisition so anything that settles can see it.
+     *
+     * Every source goes through here — a client attaching, an activity ping, a
+     * force takeover, the reacquire after a heartbeat grab misses, a branch
+     * switch. Tracking only the attach path left the others invisible:
+     * `isLockedWhenSettled` would answer "no lock" for one that was an rpc away
+     * from landing, and `relinquishLock` would find nothing to release and let
+     * the lock land on a pod that had already gone.
+     *
+     * What is stored is a swallowed copy. Callers of
+     * {@link settleClientLockAcquisition} only want the state to have stopped
+     * moving; a rejection surfacing as theirs would turn a refused lock into a
+     * failed disconnect. The promise handed back keeps its rejection for whoever
+     * asked for the lock.
+     */
+    private trackAcquisition;
+    /**
+     * Wait for an acquisition a client attach kicked off, if one is in flight.
+     *
+     * Anything that decides what to do about the lock has to do this first, or it
+     * decides on a half-known state. While the RPC is out `isLocked` is false and
+     * `_lockId` is unset, so a disconnect would "release" nothing and the lock
+     * would land moments later with nobody left to hold it for — and a branch
+     * switch would move on and leave it attached to the branch it came from.
+     *
+     * Never rejects: the acquisition's own catch has already handled failure.
+     */
+    private settleClientLockAcquisition;
+    /**
+     * Whether this pod holds the lock after attach and queued turn operations
+     * already in flight have settled. The synchronous getter remains the current
+     * state for status reporting.
+     */
+    isLockedWhenSettled(): Promise<boolean>;
+    /**
+     * Nothing is awaiting the acquisition a client triggers, so this is where a
+     * failure stops: swallowing it here is what keeps a conflict from surfacing
+     * as an unhandled rejection. `acquireLock` has already logged it and moved
+     * the status to `FAILED_TO_ACQUIRE_LOCK`; the host is told separately because
+     * only it knows whether there is anyone to tell.
+     */
+    private reportLockConflict;
+    /**
+     * Serializes branch changes with lock acquisition and handback. Omitting
+     * `reacquireLock` preserves the lock state observed inside that operation.
+     */
+    switchBranch(nextBranchName: string, options?: {
+        reacquireLock?: boolean;
+    }): Promise<void>;
+    private switchBranchNow;
+    /**
+     * Acquire a lock on the specified application and branch.
+     *
+     * Not `async`: the body has to start and be registered in the same tick, so
+     * a caller that immediately settles sees this acquisition rather than
+     * missing it by a microtask.
      */
     acquireLock(): Promise<void>;
+    private acquireLockImpl;
+    /**
+     * Take write access for a turn that is about to start.
+     *
+     * The lock is permission to write for one turn, not a lease on the session: a
+     * headless turn takes it on the way in and hands it back when it ends, so the
+     * app sits unlocked between prompts and a person can open it in the editor.
+     *
+     * Deliberately not routed through {@link claimLockForFirstClient} or
+     * {@link reclaimLockForActiveClient}. Those weigh up whether a signal is
+     * evidence of a client that wants the lock; a turn starting is not evidence
+     * of that, it *is* that, so it asks directly and a lock we handed back
+     * earlier is taken again without ceremony.
+     *
+     * Unlike an attach, this is awaited and its failure is the caller's: a turn
+     * that cannot write must fail before routing is bound, carrying the server's
+     * own reason. Failing does not take the pod down — the lock is per app+branch
+     * while a pod is per live edit, so somebody editing in the browser says
+     * nothing about whether this pod can serve the turn after them.
+     */
+    acquireLockForTurn(): Promise<void>;
+    /**
+     * Hand back the write access a turn took, once that turn has finished.
+     *
+     * The wait belongs here rather than in the callers. A turn ends in more than
+     * one way — the gateway releases it, its socket drops, its liveness lapses —
+     * and only the first of those arrives with the generation already complete.
+     * The other two reach this while Clark may still be writing, and handing the
+     * lock back there gives write access away mid-generation.
+     *
+     * Before the queue, never inside it, for the reason spelled out on
+     * {@link handBackTurnLockWhenGenerationSettles}: that queue serialises the
+     * handback, branch switches and the next turn's acquisition, so a wait
+     * inside it lets one hung turn stall all of them.
+     *
+     * `isStillNeeded` is re-read after that wait, because waiting is exactly
+     * what makes the caller's decision stale: a replacement gateway can attach
+     * and take a turn while the old one's generation is finishing, and releasing
+     * then would pull write access out from under it. The caller owns the
+     * question — this cannot ask "is a gateway attached?" itself, since the
+     * explicit `editor.releaseTurnLock` path runs with one attached by
+     * definition.
+     */
+    relinquishLockForTurn(isStillNeeded?: () => boolean): Promise<void>;
     /**
      * Release the currently held lock
      */
     releaseLock(): Promise<boolean>;
+    private grabLockImpl;
+    /**
+     * Inspect lock information for the current application and branch
+     */
+    inspectLock(): Promise<LockInfo>;
+    /**
+     * Force takeover of the lock from another user (only allowed when user is inactive)
+     */
+    forceTakeover(): Promise<void>;
+    private forceTakeoverImpl;
     checkAndUpdateLockIfPossible(): Promise<boolean>;
     /**
-     * Cleanup method to be called when the class is destroyed
-     * This ensures the lock is released
+     * Make sure this pod holds the lock a write is about to need.
+     *
+     * The write is itself the demand for the lock, which is what separates this
+     * from the heartbeat's check above. That one asks whether a lock we already
+     * hold is still there, and answers for a lock id; this one is asked before a
+     * sync, when there may be no lock at all.
+     *
+     * The distinction is load-bearing at boot. Nothing acquires the lock at
+     * startup any more — a client attaching is what claims it — but the dev
+     * server still uploads the user's local files before any editor connects.
+     * With no lock id {@link checkAndUpdateLockIfPossible} skips the grab
+     * entirely and reports false without ever asking the server, so routing that
+     * upload through it failed the sync and took the dev server down with it.
+     *
+     * A lock this session handed back is still not taken back here: a write
+     * queued before the handback belongs to the session that ended.
+     */
+    ensureLockForWrite(): Promise<boolean>;
+    /**
+     * Flush what this client left behind and hand the lock back.
+     *
+     * The only way to give the lock up, and the whole of what this service does
+     * about a session ending. Whether the process then stops is the caller's
+     * business and this cannot tell: the same call serves a tab closing on a
+     * sandbox that keeps serving, a `superblocks dev` the user is quitting, and
+     * every exit path in `dev()`. So it says nothing about the server's fate —
+     * that used to be `shutdown()`'s job, and a lock service asserting a process
+     * was exiting is precisely the tangle that made a lock release look like a
+     * teardown.
+     *
+     * Releasing the lock and stopping the dev server used to be one action, so a
+     * client going away took the sandbox with it. On the cloud path it did not
+     * even stop — it closed the rpc client and returned, leaving a pod still
+     * bound to its port with no lock, no heartbeat and nothing behind it: healthy
+     * to every probe and unable to do anything. SABS hands such a pod straight
+     * back to the next caller, whose requests then go nowhere.
+     *
+     * Where the pod does stay up, reopening is cheap for the same reason keeping
+     * it was worth it: Vite is still running, packages are installed, files are
+     * downloaded. A returning editor reacquires through
+     * {@link restartInactivityTimer}.
      */
-    shutdown(): Promise<void>;
+    relinquishLock(): Promise<void>;
+    private relinquishLockNow;
     /**
-     * Shutdown the lock service and exit the dev server
+     * The server closed this session: tell the editor, flush, and stop
+     * heartbeating — but do not release.
+     *
+     * The lock is already gone. `/_sb_disconnect` is the server saying it has
+     * taken it, typically to hand the app to a session moving the other way
+     * across local↔cloud, so releasing from here would give back something that
+     * is not ours; on a switch it belongs to whoever is taking over. What is
+     * still ours is the heartbeat, which would otherwise keep refreshing a lock
+     * the server reassigned.
+     *
+     * The editor needs both halves of {@link EventMap.closedByServer}: it has to
+     * distinguish "the server closed you" from a socket dropping, and a switch
+     * from an ending.
+     */
+    notifyClosedByServer({ switchingTo, initiatedByEmail, }: {
+        switchingTo?: "local" | "cloud" | "none";
+        initiatedByEmail?: string;
+    }): Promise<void>;
+    /**
+     * Push whatever the editor has not synced yet.
+     *
+     * Both ways of giving a session up run this first, and neither can be held up
+     * by it: the caller is either handing the lock to the next client or on its
+     * way out of the process, and a sync that fails is strictly better than one
+     * that blocks the handover. An unheld lock means nothing to flush — the files
+     * belong to whoever holds it now.
+     */
+    private flushPendingWork;
+    /**
+     * Hand the lock back and end the process.
+     *
+     * The only method here that ends anything, and it exists for the four callers
+     * inside this service that have already decided the pod cannot continue: a
+     * heartbeat that failed, a reacquire lost to another user, and the two
+     * {@link LockType.LOCAL} disconnect branches, where the dev server is the
+     * user's foreground process and they expect their terminal back.
+     *
+     * Callers outside this service drive {@link relinquishLock} and own their own
+     * exit. That is not a style preference: `process.exit` is synchronous, so
+     * folding it in here makes everything a caller sequences after it dead code —
+     * which is exactly how the fatal-exit paths in `dev()` came to skip their
+     * telemetry flush on every pod that had a lock service.
+     *
+     * The release is best effort and the exit is not. A lock left held TTL-expires
+     * in two minutes, the same as any pod that dies; a process that fails to exit
+     * is a zombie until something reaps it.
      */
     shutdownAndExit(): Promise<void>;
     /**
-     * Add a connected user to the lock service.
+     * Add a connected user to the activity tracker.
      */
     addConnectedPeerIdToUser(userId: string, peerId: string): void;
     /**
-     * Remove a connected user from the lock service.
+     * Make sure something is still due to ask whether this lock is idle.
+     *
+     * The inactivity timer is one-shot, and the evaluation it fires returns
+     * early on a service that has never held a lock without arming another. So
+     * any path that ends up holding one for something other than an attached
+     * client has to put the question back on the clock, or the lock is refreshed
+     * by the heartbeat for a client that never arrives.
+     */
+    private ensureIdleEvaluationArmed;
+    private evaluateLockStateInBackground;
+    /**
+     * Remove a connected user from the activity tracker.
      */
     removeConnectedPeerIdFromUser(userId: string, peerId: string): void;
     private scheduleNextHeartbeat;
@@ -97,12 +422,83 @@ export declare class LockService extends EventEmitter<EventMap> {
      */
     private stopHeartbeat;
     /**
-     * Start the shutdown timer when no socket connection is detected
+     * Evaluate if the lock should be released (user disconnected) or marked as ready for takeover (user inactive but connected)
+     */
+    evaluateLockState(): Promise<void>;
+    private evaluateLockStateOnce;
+    /**
+     * Restart the inactivity timer when user activity is detected.
+     * This timer tracks if the user goes inactive (no pings for N minutes).
+     */
+    restartInactivityTimer(): Promise<void>;
+    private scheduleInactivityEvaluation;
+    /**
+     * Mark the user's activity from UI ping
+     */
+    markActivity(isUserActive: boolean): void;
+    /**
+     * A gateway peer attached and is driving headless work.
+     *
+     * Gateway peers are deliberately not connected-user presence — they are not
+     * a browser editor and must not keep an editor's lock alive — so they need
+     * their own liveness signal. Without it the inactivity reaper would take the
+     * sandbox out from under a headless build that nobody is watching. Tracked
+     * per peer id so a reattach that closes the socket it replaced does not hand
+     * the sandbox back while its successor is still working.
+     */
+    markGatewayAttached(peerId: string): void;
+    /**
+     * A gateway peer detached. The sandbox stays protected while any other
+     * gateway peer is still attached.
+     */
+    markGatewayDetached(peerId: string): void;
+    /**
+     * The last gateway peer is gone, so no turn is running.
+     *
+     * Write access was taken for the turn, so it goes back now rather than being
+     * left to TTL out — that would leave the app unopenable for up to the lock's
+     * two-minute lifetime after a headless build had already finished. This is
+     * also the backstop for a gateway that dies mid-turn.
+     *
+     * Deliberately not a shutdown: the gateway drops its socket after every turn
+     * and opens a new one for the next prompt, and in between the pod keeps
+     * serving. The next turn takes the lock again through
+     * {@link acquireLockForTurn}. What bounds the pod's life is SABS's live-edit
+     * expiry, not this.
+     *
+     * Only when no editor is attached. An editor disconnect releases on its own
+     * buffer in {@link evaluateLockState}, and a second releaser over the top of
+     * that would race it.
+     */
+    private handleLastGatewayPeerGone;
+    /**
+     * Wait for the turn to finish, then hand its lock back.
+     *
+     * The wait sits outside the lock queue, the way {@link evaluateLockState}
+     * does it. That queue serialises the handback itself, branch switches,
+     * `isLockedWhenSettled` and the next turn's acquisition, so waiting inside
+     * it lets a single hung generation stall all of them — including a graceful
+     * shutdown, which awaits the handback with no timeout of its own.
+     */
+    private handBackTurnLockWhenGenerationSettles;
+    /**
+     * Watches for the last gateway signal lapsing.
+     *
+     * The inactivity reaper a gateway defers fires once and is then only
+     * re-examined when something happens. A silent gateway is the absence of
+     * anything happening, so this is what notices it and puts the lock back up
+     * for evaluation.
+     */
+    private armGatewayLivenessSweep;
+    private clearGatewayLivenessSweep;
+    /**
+     * Whether any gateway peer's liveness is still current. Lapsed entries are
+     * dropped as they are found: the socket they belong to may never close, and
+     * the sandbox must become available again either way.
      */
-    startShutdownTimer(): Promise<void>;
-    stopShutdownTimerIfNeeded(): Promise<void>;
-    private closeRpcClient;
-    private getRpcClient;
+    private get hasAttachedGatewayPeer();
+    /** when the dev server is restarting, we will use the 5-minute shutdown timer instead of the instant one */
+    setIsRestarting(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/lock-service/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lock-service/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lock-service/index.ts"],"names":[],"mappings":"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"}