@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

package/dist/core/remote/iroh/state-manager.js

@@ -0,0 +1,744 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import lockfile from "proper-lockfile";
+import { cloneIrohRemoteRpcGrant, parseIrohRemoteRpcGrant } from "./access-grant.js";
+import { authorizeIrohRemoteClient, } from "./authorization.js";
+import { createEmptyIrohRemoteHostState, normalizeIrohRemoteLiveActivityRegistrations, parseIrohRemoteLiveActivityRegistration, readIrohRemoteHostState, writeIrohRemoteHostState, } from "./state.js";
+import { findIrohRemoteWorkspace, getIrohRemoteWorkspaceStatuses, upsertIrohRemoteWorkspace, } from "./workspace.js";
+export const IROH_REMOTE_WORKSPACE_HAS_WORKTREES_ERROR = "workspace_has_worktrees";
+export const IROH_REMOTE_WORKTREE_PARENT_WORKSPACE_NOT_FOUND_ERROR = "worktree_parent_workspace_not_found";
+export const IROH_REMOTE_WORKTREE_PERSISTENCE_ERROR = "worktree_persistence_failed";
+/**
+ * A workspace with persisted worktree children cannot be unregistered. This
+ * typed conflict is thrown from the state mutation itself so every caller,
+ * including lower-level ones, gets the same non-destructive invariant.
+ */
+export class IrohRemoteWorkspaceHasWorktreesError extends Error {
+    code = IROH_REMOTE_WORKSPACE_HAS_WORKTREES_ERROR;
+    workspaceName;
+    worktreeIds;
+    constructor(workspaceName, worktrees) {
+        const worktreeIds = worktrees.map((worktree) => worktree.id).sort();
+        const noun = worktreeIds.length === 1 ? "worktree" : "worktrees";
+        super(`Workspace ${workspaceName} has ${worktreeIds.length} daemon-managed ${noun} (${worktreeIds.join(", ")}). ` +
+            `Remove each with "volt remote worktree remove <id> --workspace ${workspaceName}" before unregistering; ` +
+            "use --force only to explicitly discard dirty or busy worktrees.");
+        this.name = "IrohRemoteWorkspaceHasWorktreesError";
+        this.workspaceName = workspaceName;
+        this.worktreeIds = worktreeIds;
+    }
+}
+export function isIrohRemoteWorkspaceHasWorktreesError(error) {
+    return error instanceof IrohRemoteWorkspaceHasWorktreesError;
+}
+export class IrohRemoteWorktreeParentWorkspaceNotFoundError extends Error {
+    code = IROH_REMOTE_WORKTREE_PARENT_WORKSPACE_NOT_FOUND_ERROR;
+    workspaceName;
+    constructor(workspaceName) {
+        super(`Cannot persist a worktree for unregistered workspace ${workspaceName}`);
+        this.name = "IrohRemoteWorktreeParentWorkspaceNotFoundError";
+        this.workspaceName = workspaceName;
+    }
+}
+export function isIrohRemoteWorktreeParentWorkspaceNotFoundError(error) {
+    return error instanceof IrohRemoteWorktreeParentWorkspaceNotFoundError;
+}
+export class IrohRemoteWorktreePersistenceError extends Error {
+    code = IROH_REMOTE_WORKTREE_PERSISTENCE_ERROR;
+    workspaceName;
+    worktreeId;
+    constructor(workspaceName, worktreeId, cause) {
+        super(`Failed to persist worktree ${worktreeId} for workspace ${workspaceName}`, { cause });
+        this.name = "IrohRemoteWorktreePersistenceError";
+        this.workspaceName = workspaceName;
+        this.worktreeId = worktreeId;
+    }
+}
+export function isIrohRemoteWorktreePersistenceError(error) {
+    return error instanceof IrohRemoteWorktreePersistenceError;
+}
+export class IrohRemoteHostStateManager {
+    statePath;
+    store;
+    operationQueue = Promise.resolve();
+    state;
+    constructor(options = {}) {
+        if (options.initialState && options.statePath) {
+            throw new Error("Cannot provide both initialState and statePath for Iroh remote host state manager");
+        }
+        if (options.store && (options.statePath || options.initialState)) {
+            throw new Error("Cannot combine a custom store with statePath/initialState for Iroh remote host state manager");
+        }
+        this.statePath = options.statePath;
+        this.store = options.store;
+        this.state = options.initialState ? cloneHostState(options.initialState) : undefined;
+    }
+    async load() {
+        return this.runExclusive(async () => cloneHostState(await this.loadUnlocked()));
+    }
+    async save(state) {
+        await this.runExclusive(async () => {
+            if (state !== undefined && this.statePath) {
+                throw new Error("Cannot save explicit Iroh remote host state snapshots for file-backed state");
+            }
+            if (state === undefined && this.statePath) {
+                this.state = await this.loadUnlocked();
+            }
+            await this.saveUnlocked(state !== undefined ? cloneHostState(state) : this.state);
+        });
+    }
+    async getState() {
+        return this.runExclusive(async () => cloneHostState(await this.loadUnlocked()));
+    }
+    async upsertWorkspace(workspace, allowTools) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const savedWorkspace = upsertIrohRemoteWorkspace(state, workspace, allowTools);
+            await this.saveUnlocked(state);
+            return cloneWorkspace(savedWorkspace);
+        });
+    }
+    async unregisterWorkspace(name) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const index = state.workspaces.findIndex((workspace) => workspace.name === name);
+            if (index === -1) {
+                return undefined;
+            }
+            const worktrees = (state.worktrees ?? []).filter((worktree) => worktree.workspaceName === name);
+            if (worktrees.length > 0) {
+                throw new IrohRemoteWorkspaceHasWorktreesError(name, worktrees);
+            }
+            const [removedWorkspace] = state.workspaces.splice(index, 1);
+            state.pendingPairingTickets = (state.pendingPairingTickets ?? []).filter((ticket) => ticket.workspace !== name);
+            await this.saveUnlocked(state);
+            return removedWorkspace ? cloneWorkspace(removedWorkspace) : undefined;
+        });
+    }
+    /**
+     * Serialize a worktree create/adopt side effect with workspace unregister and
+     * commit its child record in the same state transaction. The operation runs
+     * while the state lock is held so an unregister cannot observe the gap between
+     * `git worktree add` and durable child persistence.
+     */
+    async runWorkspaceWorktreeLifecycle(workspaceName, operation) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const workspace = state.workspaces.find((entry) => entry.name === workspaceName);
+            if (!workspace) {
+                throw new IrohRemoteWorktreeParentWorkspaceNotFoundError(workspaceName);
+            }
+            const outcome = await operation({
+                workspace: cloneWorkspace(workspace),
+                worktrees: (state.worktrees ?? [])
+                    .filter((worktree) => worktree.workspaceName === workspaceName)
+                    .map((worktree) => cloneWorktree(worktree)),
+            });
+            if (!outcome.worktree) {
+                return outcome.result;
+            }
+            if (outcome.worktree.workspaceName !== workspaceName) {
+                throw new Error("Worktree lifecycle result does not match its parent workspace");
+            }
+            const previousState = cloneHostState(state);
+            state.worktrees = [
+                ...(state.worktrees ?? []).filter((entry) => entry.workspaceName !== workspaceName || entry.id !== outcome.worktree?.id),
+                cloneWorktree(outcome.worktree),
+            ];
+            try {
+                await this.saveUnlocked(state);
+            }
+            catch (error) {
+                await this.restoreAfterFailedWorktreePersistence(previousState);
+                throw new IrohRemoteWorktreePersistenceError(workspaceName, outcome.worktree.id, error);
+            }
+            return outcome.result;
+        });
+    }
+    async upsertWorktree(worktree) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            if (!state.workspaces.some((workspace) => workspace.name === worktree.workspaceName)) {
+                throw new IrohRemoteWorktreeParentWorkspaceNotFoundError(worktree.workspaceName);
+            }
+            const previousState = cloneHostState(state);
+            state.worktrees = [
+                ...(state.worktrees ?? []).filter((entry) => entry.workspaceName !== worktree.workspaceName || entry.id !== worktree.id),
+                cloneWorktree(worktree),
+            ];
+            try {
+                await this.saveUnlocked(state);
+            }
+            catch (error) {
+                await this.restoreAfterFailedWorktreePersistence(previousState);
+                throw new IrohRemoteWorktreePersistenceError(worktree.workspaceName, worktree.id, error);
+            }
+            return cloneWorktree(worktree);
+        });
+    }
+    async removeWorktree(workspaceName, worktreeId) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const worktrees = state.worktrees ?? [];
+            const removed = worktrees.find((entry) => entry.workspaceName === workspaceName && entry.id === worktreeId);
+            if (!removed) {
+                return undefined;
+            }
+            state.worktrees = worktrees.filter((entry) => entry !== removed);
+            await this.saveUnlocked(state);
+            return cloneWorktree(removed);
+        });
+    }
+    async listWorktrees(workspaceName) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            return (state.worktrees ?? [])
+                .filter((entry) => workspaceName === undefined || entry.workspaceName === workspaceName)
+                .map((entry) => cloneWorktree(entry));
+        });
+    }
+    async bindWorktreeSession(workspaceName, worktreeId, sessionId) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const worktree = (state.worktrees ?? []).find((entry) => entry.workspaceName === workspaceName && entry.id === worktreeId);
+            if (!worktree || worktree.sessionIds.includes(sessionId)) {
+                return;
+            }
+            worktree.sessionIds = [...worktree.sessionIds, sessionId];
+            await this.saveUnlocked(state);
+        });
+    }
+    async findWorktreeForSession(workspaceName, sessionId) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const worktree = (state.worktrees ?? []).find((entry) => entry.workspaceName === workspaceName && entry.sessionIds.includes(sessionId));
+            return worktree ? cloneWorktree(worktree) : undefined;
+        });
+    }
+    async listWorkspaceStatuses(options = {}) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            return await getIrohRemoteWorkspaceStatuses(state, options.classifyWorkspaceAvailability);
+        });
+    }
+    async addPendingPairingTicket(ticket) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            state.pendingPairingTickets = [
+                ...(state.pendingPairingTickets ?? []).filter((entry) => entry.secretHash !== ticket.secretHash),
+                clonePendingPairingTicket(ticket),
+            ];
+            await this.saveUnlocked(state);
+            return clonePendingPairingTicket(ticket);
+        });
+    }
+    async removePendingPairingTicket(secretHash) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const pending = state.pendingPairingTickets ?? [];
+            const remaining = pending.filter((entry) => entry.secretHash !== secretHash);
+            if (remaining.length === pending.length)
+                return false;
+            state.pendingPairingTickets = remaining;
+            await this.saveUnlocked(state);
+            return true;
+        });
+    }
+    async authorizeClient(hello, remoteNodeId, options) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const workspaceStatuses = await this.getWorkspaceStatuses(state, options);
+            const workspace = findIrohRemoteWorkspace(state, hello.workspace);
+            const workspaceStatus = workspaceStatuses.find((entry) => entry.name === hello.workspace)?.status;
+            const workspaceAvailable = workspace !== undefined &&
+                workspaceStatus === "available" &&
+                (options.validateWorkspace === undefined || (await options.validateWorkspace(workspace)));
+            const result = authorizeIrohRemoteClient(state, hello, remoteNodeId, {
+                ...options,
+                workspace: workspaceAvailable ? workspace : undefined,
+                workspaceStatuses,
+            });
+            await this.saveUnlocked(state);
+            return cloneAuthorizationResult(result);
+        });
+    }
+    async listClients() {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            return state.clients.map((client) => cloneClient(client));
+        });
+    }
+    async getClient(nodeId) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            return client ? cloneClient(client) : undefined;
+        });
+    }
+    async updateClientAccess(nodeId, expectedRevision, access) {
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1) {
+            throw new Error("expected RPC grant revision must be a safe integer greater than or equal to 1");
+        }
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client) {
+                return { ok: false, reason: "not_found" };
+            }
+            const currentGrant = parseIrohRemoteRpcGrant(client.rpcGrant, "client rpcGrant");
+            if (currentGrant.revision !== expectedRevision) {
+                return { ok: false, reason: "revision_conflict", currentRevision: currentGrant.revision };
+            }
+            if (currentGrant.revision === Number.MAX_SAFE_INTEGER) {
+                return { ok: false, reason: "revision_exhausted", currentRevision: currentGrant.revision };
+            }
+            client.allowedTools = access.allowedTools;
+            client.rpcGrant = {
+                ...cloneIrohRemoteRpcGrant(access.rpcGrant),
+                revision: expectedRevision + 1,
+            };
+            await this.saveUnlocked(state);
+            return { ok: true, client: cloneClient(client) };
+        });
+    }
+    async listRevokedClients() {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            return getRevokedClients(state).map((client) => cloneRevokedClient(client));
+        });
+    }
+    async setClientLastSessionId(nodeId, workspace, sessionId) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client) {
+                return undefined;
+            }
+            client.lastSessionIdByWorkspace = {
+                ...(client.lastSessionIdByWorkspace ?? {}),
+                [workspace]: sessionId,
+            };
+            await this.saveUnlocked(state);
+            return cloneClient(client);
+        });
+    }
+    async upsertClientPushTarget(nodeId, pushTarget) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client) {
+                return undefined;
+            }
+            let createdAt = pushTarget.createdAt;
+            const retainedTargets = [];
+            for (const existingTarget of client.pushTargets ?? []) {
+                if (isSamePushTargetSlot(existingTarget, pushTarget)) {
+                    createdAt = existingTarget.createdAt;
+                    continue;
+                }
+                retainedTargets.push(existingTarget);
+            }
+            client.pushTargets = [...retainedTargets, { ...pushTarget, createdAt }];
+            await this.saveUnlocked(state);
+            return cloneClient(client);
+        });
+    }
+    async disableClientPushTarget(nodeId, pushTargetId, now = Date.now()) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            const pushTarget = client?.pushTargets?.find((entry) => entry.id === pushTargetId);
+            if (!pushTarget) {
+                return undefined;
+            }
+            pushTarget.enabled = false;
+            delete pushTarget.liveActivity;
+            pushTarget.updatedAt = now;
+            await this.saveUnlocked(state);
+            return clonePushTarget(pushTarget);
+        });
+    }
+    async findClientLiveActivityDeliveryChannel(nodeId, lookup) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            const pushTarget = client?.pushTargets?.find((entry) => entry.platform === lookup.platform &&
+                entry.liveActivity?.tokenHash === lookup.tokenHash &&
+                entry.liveActivity.tokenEnvironment === lookup.tokenEnvironment);
+            return pushTarget ? clonePushTarget(pushTarget) : undefined;
+        });
+    }
+    async registerClientLiveActivity(nodeId, registration) {
+        const validatedRegistration = parseIrohRemoteLiveActivityRegistration(registration);
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client) {
+                return {};
+            }
+            let createdAt = validatedRegistration.createdAt;
+            let replacedRegistration;
+            const retainedRegistrations = [];
+            for (const existingRegistration of client.liveActivities ?? []) {
+                if ((existingRegistration.workspaceName === validatedRegistration.workspaceName &&
+                    existingRegistration.sessionId === validatedRegistration.sessionId) ||
+                    existingRegistration.activityId === validatedRegistration.activityId) {
+                    createdAt = existingRegistration.createdAt;
+                    replacedRegistration = existingRegistration;
+                    continue;
+                }
+                retainedRegistrations.push(existingRegistration);
+            }
+            const savedRegistration = { ...validatedRegistration, createdAt };
+            client.liveActivities = normalizeIrohRemoteLiveActivityRegistrations([
+                ...retainedRegistrations,
+                savedRegistration,
+            ]);
+            await this.saveUnlocked(state);
+            return {
+                client: cloneClient(client),
+                registration: cloneLiveActivityRegistration(savedRegistration),
+                ...(replacedRegistration
+                    ? { replacedRegistration: cloneLiveActivityRegistration(replacedRegistration) }
+                    : {}),
+            };
+        });
+    }
+    async unregisterClientLiveActivity(nodeId, workspaceName, sessionId, activityId) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client?.liveActivities) {
+                return false;
+            }
+            const beforeCount = client.liveActivities.length;
+            client.liveActivities = client.liveActivities.filter((entry) => entry.workspaceName !== workspaceName ||
+                entry.sessionId !== sessionId ||
+                entry.activityId !== activityId);
+            const removed = client.liveActivities.length !== beforeCount;
+            if (client.liveActivities.length === 0) {
+                delete client.liveActivities;
+            }
+            if (removed) {
+                await this.saveUnlocked(state);
+            }
+            return removed;
+        });
+    }
+    async pruneClientLiveActivityDeliveryChannel(nodeId, registration, now = Date.now()) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client) {
+                return { liveActivityRemoved: false, registrationsRemoved: 0 };
+            }
+            let registrationsRemoved = 0;
+            if (client.liveActivities) {
+                const beforeCount = client.liveActivities.length;
+                client.liveActivities = client.liveActivities.filter((entry) => !isSameLiveActivityRegistration(entry, registration));
+                registrationsRemoved = beforeCount - client.liveActivities.length;
+                if (client.liveActivities.length === 0) {
+                    delete client.liveActivities;
+                }
+            }
+            const pushTarget = client.pushTargets?.find((entry) => {
+                return (entry.id === registration.pushTargetId &&
+                    entry.platform === registration.platform &&
+                    entry.liveActivity?.tokenHash === registration.tokenHash &&
+                    entry.liveActivity.tokenEnvironment === registration.tokenEnvironment);
+            });
+            const liveActivityRemoved = pushTarget?.liveActivity !== undefined;
+            if (liveActivityRemoved && pushTarget) {
+                delete pushTarget.liveActivity;
+                pushTarget.updatedAt = now;
+            }
+            if (registrationsRemoved > 0 || liveActivityRemoved) {
+                await this.saveUnlocked(state);
+            }
+            return {
+                liveActivityRemoved,
+                registrationsRemoved,
+                ...(pushTarget ? { pushTarget: clonePushTarget(pushTarget) } : {}),
+            };
+        });
+    }
+    async removeClientLiveActivitiesForSession(nodeId, workspaceName, sessionId) {
+        return this.removeClientLiveActivities(nodeId, (entry) => {
+            return entry.workspaceName === workspaceName && entry.sessionId === sessionId;
+        });
+    }
+    async removeClientLiveActivitiesForWorkspace(nodeId, workspaceName) {
+        return this.removeClientLiveActivities(nodeId, (entry) => entry.workspaceName === workspaceName);
+    }
+    async removeLiveActivitiesForWorkspace(workspaceName) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            let removedCount = 0;
+            for (const client of state.clients) {
+                if (!client.liveActivities) {
+                    continue;
+                }
+                const beforeCount = client.liveActivities.length;
+                client.liveActivities = client.liveActivities.filter((entry) => entry.workspaceName !== workspaceName);
+                removedCount += beforeCount - client.liveActivities.length;
+                if (client.liveActivities.length === 0) {
+                    delete client.liveActivities;
+                }
+            }
+            if (removedCount > 0) {
+                await this.saveUnlocked(state);
+            }
+            return removedCount;
+        });
+    }
+    async revokeClient(nodeId, now = Date.now()) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const clientIndex = state.clients.findIndex((client) => client.nodeId === nodeId);
+            if (clientIndex === -1) {
+                const revokedClient = getRevokedClients(state).find((client) => client.nodeId === nodeId);
+                return {
+                    revoked: false,
+                    ...(revokedClient ? { revokedClient: cloneRevokedClient(revokedClient) } : {}),
+                };
+            }
+            const [client] = state.clients.splice(clientIndex, 1);
+            const revokedClient = {
+                nodeId: client.nodeId,
+                label: client.label,
+                allowedWorkspaces: [...client.allowedWorkspaces],
+                allowedTools: client.allowedTools,
+                rpcGrant: parseIrohRemoteRpcGrant(client.rpcGrant, "client rpcGrant"),
+                pairedAt: client.pairedAt,
+                lastSeenAt: client.lastSeenAt,
+                revokedAt: now,
+                ...(client.lastSessionIdByWorkspace
+                    ? { lastSessionIdByWorkspace: { ...client.lastSessionIdByWorkspace } }
+                    : {}),
+            };
+            state.revokedClients = [...getRevokedClients(state).filter((entry) => entry.nodeId !== nodeId), revokedClient];
+            await this.saveUnlocked(state);
+            return { revoked: true, client: cloneClient(client), revokedClient: cloneRevokedClient(revokedClient) };
+        });
+    }
+    async approveClientRePair(nodeId, now = Date.now()) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const revokedClient = getRevokedClients(state).find((client) => client.nodeId === nodeId);
+            if (!revokedClient) {
+                return { approved: false };
+            }
+            revokedClient.rePairApprovedAt = now;
+            await this.saveUnlocked(state);
+            return { approved: true, revokedClient: cloneRevokedClient(revokedClient) };
+        });
+    }
+    async getWorkspaceStatuses(state, options) {
+        return await getIrohRemoteWorkspaceStatuses(state, options.classifyWorkspaceAvailability);
+    }
+    runExclusive(operation) {
+        const run = this.operationQueue.then(() => this.withStateFileLock(operation), () => this.withStateFileLock(operation));
+        this.operationQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async withStateFileLock(operation) {
+        if (!this.statePath) {
+            return await operation();
+        }
+        await mkdir(dirname(this.statePath), { recursive: true });
+        let release;
+        let lockCompromised = false;
+        let lockCompromisedError;
+        const throwIfCompromised = () => {
+            if (lockCompromised) {
+                throw lockCompromisedError ?? new Error("Iroh remote host state lock was compromised");
+            }
+        };
+        try {
+            release = await lockfile.lock(this.statePath, {
+                lockfilePath: `${this.statePath}.lock`,
+                realpath: false,
+                retries: {
+                    retries: 10,
+                    factor: 2,
+                    minTimeout: 100,
+                    maxTimeout: 10000,
+                    randomize: true,
+                },
+                stale: 30000,
+                onCompromised: (error) => {
+                    lockCompromised = true;
+                    lockCompromisedError = error;
+                },
+            });
+            throwIfCompromised();
+            const result = await operation();
+            throwIfCompromised();
+            return result;
+        }
+        finally {
+            if (release) {
+                try {
+                    await release();
+                }
+                catch {
+                    // Ignore unlock errors after a compromised lock.
+                }
+            }
+        }
+    }
+    async loadUnlocked() {
+        if (this.store) {
+            this.state = cloneHostState(await this.store.read());
+            return this.state;
+        }
+        if (this.statePath) {
+            this.state = await readIrohRemoteHostState(this.statePath);
+            return this.state;
+        }
+        this.state ??= createEmptyIrohRemoteHostState();
+        return this.state;
+    }
+    async saveUnlocked(state) {
+        const stateToSave = state ? cloneHostState(state) : createEmptyIrohRemoteHostState();
+        this.state = stateToSave;
+        if (this.store) {
+            await this.store.write(cloneHostState(stateToSave));
+            return;
+        }
+        if (this.statePath) {
+            await writeIrohRemoteHostState(this.statePath, stateToSave);
+        }
+    }
+    async restoreAfterFailedWorktreePersistence(previousState) {
+        const restoredState = cloneHostState(previousState);
+        this.state = restoredState;
+        if (!this.store) {
+            return;
+        }
+        try {
+            await this.store.write(cloneHostState(restoredState));
+            this.state = restoredState;
+        }
+        catch {
+            // A failed rollback may leave the child record in the custom store, which
+            // is safer than deleting a checkout whose persistence outcome is unknown.
+        }
+    }
+    async removeClientLiveActivities(nodeId, shouldRemove) {
+        return this.runExclusive(async () => {
+            const state = await this.loadUnlocked();
+            const client = state.clients.find((entry) => entry.nodeId === nodeId);
+            if (!client?.liveActivities) {
+                return 0;
+            }
+            const beforeCount = client.liveActivities.length;
+            client.liveActivities = client.liveActivities.filter((entry) => !shouldRemove(entry));
+            const removedCount = beforeCount - client.liveActivities.length;
+            if (client.liveActivities.length === 0) {
+                delete client.liveActivities;
+            }
+            if (removedCount > 0) {
+                await this.saveUnlocked(state);
+            }
+            return removedCount;
+        });
+    }
+}
+function cloneAuthorizationResult(result) {
+    if (!result.ok) {
+        return {
+            ...result,
+            ...(result.client ? { client: cloneClient(result.client) } : {}),
+            ...(result.expiredPairingTickets
+                ? { expiredPairingTickets: result.expiredPairingTickets.map((ticket) => clonePendingPairingTicket(ticket)) }
+                : {}),
+            ...(result.workspace ? { workspace: cloneWorkspace(result.workspace) } : {}),
+        };
+    }
+    return {
+        ...result,
+        client: cloneClient(result.client),
+        ...(result.consumedPairingTicket
+            ? { consumedPairingTicket: clonePendingPairingTicket(result.consumedPairingTicket) }
+            : {}),
+        ...(result.expiredPairingTickets
+            ? { expiredPairingTickets: result.expiredPairingTickets.map((ticket) => clonePendingPairingTicket(ticket)) }
+            : {}),
+        workspace: cloneWorkspace(result.workspace),
+        workspaceNames: [...result.workspaceNames],
+        workspaces: result.workspaces.map((workspace) => ({ ...workspace })),
+    };
+}
+function cloneClient(client) {
+    return {
+        ...client,
+        allowedWorkspaces: [...client.allowedWorkspaces],
+        rpcGrant: parseIrohRemoteRpcGrant(client.rpcGrant, "client rpcGrant"),
+        ...(client.lastSessionIdByWorkspace ? { lastSessionIdByWorkspace: { ...client.lastSessionIdByWorkspace } } : {}),
+        ...(client.pushTargets ? { pushTargets: client.pushTargets.map((target) => clonePushTarget(target)) } : {}),
+        ...(client.liveActivities
+            ? { liveActivities: client.liveActivities.map((registration) => cloneLiveActivityRegistration(registration)) }
+            : {}),
+    };
+}
+function cloneHostState(state) {
+    return {
+        hostSecretKey: state.hostSecretKey ? [...state.hostSecretKey] : undefined,
+        pairingSecretTombstones: (state.pairingSecretTombstones ?? []).map((tombstone) => clonePairingSecretTombstone(tombstone)),
+        workspaces: state.workspaces.map((workspace) => cloneWorkspace(workspace)),
+        worktrees: (state.worktrees ?? []).map((worktree) => cloneWorktree(worktree)),
+        clients: state.clients.map((client) => cloneClient(client)),
+        revokedClients: (state.revokedClients ?? []).map((client) => cloneRevokedClient(client)),
+        pendingPairingTickets: (state.pendingPairingTickets ?? []).map((ticket) => clonePendingPairingTicket(ticket)),
+    };
+}
+function clonePairingSecretTombstone(tombstone) {
+    return { ...tombstone };
+}
+function clonePendingPairingTicket(ticket) {
+    return {
+        ...ticket,
+        ...(ticket.rpcGrant === undefined ? {} : { rpcGrant: cloneIrohRemoteRpcGrant(ticket.rpcGrant) }),
+    };
+}
+function clonePushTarget(pushTarget) {
+    return {
+        ...pushTarget,
+        ...(pushTarget.liveActivity ? { liveActivity: { ...pushTarget.liveActivity } } : {}),
+    };
+}
+function cloneLiveActivityRegistration(registration) {
+    return { ...registration };
+}
+function cloneRevokedClient(client) {
+    return {
+        ...client,
+        allowedWorkspaces: [...client.allowedWorkspaces],
+        rpcGrant: parseIrohRemoteRpcGrant(client.rpcGrant, "revoked client rpcGrant"),
+        ...(client.lastSessionIdByWorkspace ? { lastSessionIdByWorkspace: { ...client.lastSessionIdByWorkspace } } : {}),
+    };
+}
+function cloneWorkspace(workspace) {
+    return { ...workspace };
+}
+function cloneWorktree(worktree) {
+    return { ...worktree, sessionIds: [...worktree.sessionIds] };
+}
+function getRevokedClients(state) {
+    state.revokedClients ??= [];
+    return state.revokedClients;
+}
+function isSamePushTargetSlot(a, b) {
+    return a.id === b.id || (a.provider === b.provider && a.platform === b.platform);
+}
+function isSameLiveActivityRegistration(a, b) {
+    return (a.workspaceName === b.workspaceName &&
+        a.sessionId === b.sessionId &&
+        a.activityId === b.activityId &&
+        a.tokenHash === b.tokenHash &&
+        a.tokenEnvironment === b.tokenEnvironment &&
+        a.platform === b.platform &&
+        a.pushTargetId === b.pushTargetId);
+}
+//# sourceMappingURL=state-manager.js.map