@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/coordinator/localSyncCoordinatorHost.js

@@ -0,0 +1,435 @@
+import { createHash, randomUUID } from 'crypto';
+import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
+import { LocalSyncCoordinatorError, } from './localSyncCoordinatorTypes.js';
+export class LocalSyncCoordinatorHost {
+    options;
+    serverInstanceId = randomUUID();
+    acceptingCommands = false;
+    transitionQueue = Promise.resolve();
+    now;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now || (() => new Date().toISOString());
+    }
+    start() {
+        if (!this.options.processLock.owned) {
+            throw new LocalSyncCoordinatorError('Another local Taskforce process owns workspace synchronization.', 'SYNC_COORDINATOR_OWNED_BY_OTHER_PROCESS');
+        }
+        const existing = this.options.store.readOrCreateState();
+        const recovered = this.options.store.recoverAfterRestart().state;
+        this.acceptingCommands = true;
+        if (existing.activeWorkspaceId === null
+            && recovered.activeWorkspaceId === null
+            && recovered.ownershipMode === 'stopped'
+            && recovered.transitionState === 'idle') {
+            return this.options.store.setLifecycleMode('browser-gateway', 'idle');
+        }
+        return recovered;
+    }
+    readState() {
+        return this.options.store.readOrCreateState();
+    }
+    resumeBrowserGatewayAfterAuthenticatedRestart(input) {
+        this.assertCommandIntake();
+        return this.options.store.resumeBrowserGatewayAfterAuthenticatedRestart(input);
+    }
+    resumeServerAfterAuthenticatedRestart(input, activateCommittedOwner) {
+        this.assertCommandIntake();
+        return this.options.store.resumeServerAfterAuthenticatedRestart(input, activateCommittedOwner);
+    }
+    readCommand(commandId) {
+        return this.options.store.readCommand(commandId);
+    }
+    assertActiveWorkspace(workspaceId, expectedGeneration) {
+        const state = this.readState();
+        if (state.coordinatorGeneration !== expectedGeneration) {
+            throw new LocalSyncCoordinatorError(`Coordinator generation ${expectedGeneration} is stale; current generation is ${state.coordinatorGeneration}.`, 'SYNC_COORDINATOR_STALE_GENERATION');
+        }
+        if (state.activeWorkspaceId !== workspaceId) {
+            throw new LocalSyncCoordinatorError(`Workspace ${workspaceId} is not the active local sync workspace.`, 'SYNC_COORDINATOR_INACTIVE_WORKSPACE');
+        }
+        return state;
+    }
+    acceptCommand(input) {
+        this.assertCommandIntake();
+        if (['SwitchWorkspace', 'TransferOwnership'].includes(input.type)) {
+            throw new LocalSyncCoordinatorError('Coordinator transitions must use their dedicated compare-and-set command path.', 'SYNC_COORDINATOR_COMMAND_INVALID');
+        }
+        const envelope = this.createCommandEnvelope(input);
+        return this.options.store.acceptCommand(envelope, {
+            requireActiveWorkspace: true,
+            requireServerOwnership: true,
+        });
+    }
+    createCommandEnvelope(input) {
+        const envelopeWithoutFingerprint = {
+            commandId: input.commandId || randomUUID(),
+            workspaceId: input.workspaceId,
+            expectedCoordinatorGeneration: input.expectedCoordinatorGeneration,
+            type: input.type,
+            version: input.version,
+            args: input.args,
+            requestedBy: input.requestedBy,
+            requestedAt: input.requestedAt || this.now(),
+        };
+        const canonicalFingerprint = createHash('sha256')
+            .update(canonicalWorkspaceSyncJson({
+            workspaceId: envelopeWithoutFingerprint.workspaceId,
+            expectedCoordinatorGeneration: envelopeWithoutFingerprint.expectedCoordinatorGeneration,
+            type: envelopeWithoutFingerprint.type,
+            version: envelopeWithoutFingerprint.version,
+            args: envelopeWithoutFingerprint.args,
+            requestedBy: envelopeWithoutFingerprint.requestedBy,
+        }))
+            .digest('hex');
+        return {
+            ...envelopeWithoutFingerprint,
+            canonicalFingerprint,
+        };
+    }
+    switchWorkspace(input) {
+        this.assertCommandIntake();
+        const envelope = this.createCommandEnvelope({
+            commandId: input.commandId,
+            requestedAt: input.requestedAt,
+            workspaceId: input.expectedActiveWorkspaceId,
+            expectedCoordinatorGeneration: input.expectedCoordinatorGeneration,
+            type: 'SwitchWorkspace',
+            version: 1,
+            args: {
+                expectedActiveWorkspaceId: input.expectedActiveWorkspaceId,
+                targetWorkspaceId: input.targetWorkspaceId,
+            },
+            requestedBy: input.requestedBy,
+        });
+        const run = async () => {
+            const existing = this.options.store.readCommand(envelope.commandId);
+            if (!existing) {
+                if (input.expectedActiveWorkspaceId) {
+                    await this.options.validateWorkspaceAccess(input.expectedActiveWorkspaceId, input.requestedBy);
+                }
+                await this.options.validateWorkspaceAccess(input.targetWorkspaceId, input.requestedBy);
+                this.assertCommandIntake();
+            }
+            const command = this.options.store.acceptCommand(envelope, {
+                expectedActiveWorkspaceId: input.expectedActiveWorkspaceId,
+                requireWorkspaceSwitchSource: true,
+            }).record;
+            const replay = this.options.store.readCommand(command.commandId);
+            if (replay.status === 'succeeded') {
+                const result = replay.result;
+                if (!result?.state) {
+                    throw new Error(`Coordinator command ${command.commandId} is missing its terminal state.`);
+                }
+                return result.state;
+            }
+            if (replay.status === 'failed' || replay.status === 'superseded') {
+                const terminalError = new Error(replay.errorMessage || `Coordinator command ${command.commandId} ${replay.status}.`);
+                terminalError.code = replay.errorCode || 'SYNC_COORDINATOR_COMMAND_TERMINAL';
+                throw terminalError;
+            }
+            this.assertCommandIntake();
+            this.options.store.markCommandRunning(command.commandId);
+            try {
+                const current = this.readState();
+                if (current.coordinatorGeneration !== input.expectedCoordinatorGeneration) {
+                    throw new LocalSyncCoordinatorError(`Coordinator generation ${input.expectedCoordinatorGeneration} is stale; current generation is ${current.coordinatorGeneration}.`, 'SYNC_COORDINATOR_STALE_GENERATION');
+                }
+                this.options.store.beginWorkspaceSwitch({
+                    commandId: command.commandId,
+                    expectedActiveWorkspaceId: input.expectedActiveWorkspaceId,
+                    expectedGeneration: input.expectedCoordinatorGeneration,
+                    targetWorkspaceId: input.targetWorkspaceId,
+                    requestedBy: input.requestedBy,
+                });
+                await this.options.drainSyncGateway?.(this.options.shutdownGraceMs ?? 15_000);
+                const state = this.options.store.completeWorkspaceSwitch({
+                    commandId: command.commandId,
+                    targetWorkspaceId: input.targetWorkspaceId,
+                    terminalResult: { workspaceId: input.targetWorkspaceId },
+                    activateTargetForCommit: input.activateTargetForCommit,
+                });
+                return state;
+            }
+            catch (error) {
+                let stateRollbackError = null;
+                let rollbackGeneration = input.expectedCoordinatorGeneration;
+                try {
+                    const rollbackState = this.options.store.failWorkspaceSwitch({
+                        commandId: command.commandId,
+                        errorCode: error?.code || 'SYNC_COORDINATOR_WORKSPACE_SWITCH_FAILED',
+                        errorMessage: String(error?.message || error),
+                    });
+                    rollbackGeneration = rollbackState.coordinatorGeneration;
+                }
+                catch (candidateStateRollbackError) {
+                    stateRollbackError = candidateStateRollbackError;
+                    rollbackGeneration = this.readState().coordinatorGeneration;
+                }
+                let credentialRollbackError = null;
+                try {
+                    input.rollbackTarget?.(rollbackGeneration);
+                }
+                catch (candidateCredentialRollbackError) {
+                    credentialRollbackError = candidateCredentialRollbackError;
+                }
+                if (stateRollbackError || credentialRollbackError) {
+                    throw new AggregateError([error, stateRollbackError, credentialRollbackError].filter(Boolean), 'Workspace switch rollback failed.');
+                }
+                throw error;
+            }
+        };
+        const result = this.transitionQueue.then(run, run);
+        this.transitionQueue = result.catch(() => undefined);
+        return result;
+    }
+    transferOwnership(input) {
+        return this.transferOwnershipWithReplay(input).then((result) => result.state);
+    }
+    transferOwnershipWithReplay(input) {
+        this.assertCommandIntake();
+        if (!['server', 'browser-gateway'].includes(input.targetMode)) {
+            throw new LocalSyncCoordinatorError(`Unsupported local sync ownership target ${String(input.targetMode)}.`, 'SYNC_COORDINATOR_COMMAND_INVALID');
+        }
+        const envelope = this.createCommandEnvelope({
+            commandId: input.commandId,
+            requestedAt: input.requestedAt,
+            workspaceId: input.workspaceId,
+            expectedCoordinatorGeneration: input.expectedCoordinatorGeneration,
+            type: 'TransferOwnership',
+            version: 1,
+            args: { targetMode: input.targetMode },
+            requestedBy: input.requestedBy,
+        });
+        const run = async () => {
+            const existing = this.options.store.readCommand(envelope.commandId);
+            if (existing) {
+                if (existing.canonicalFingerprint !== envelope.canonicalFingerprint) {
+                    throw new LocalSyncCoordinatorError(`Coordinator command ${envelope.commandId} was reused with different input.`, 'SYNC_COORDINATOR_COMMAND_IDENTITY_CONFLICT');
+                }
+                return {
+                    state: this.readTerminalTransfer(existing),
+                    replayed: true,
+                };
+            }
+            const lifecycle = this.options.ownershipRunnerLifecycle;
+            if (!lifecycle) {
+                throw new LocalSyncCoordinatorError('Ownership transfer requires an attached sync runner lifecycle.', 'SYNC_COORDINATOR_COMMAND_INVALID');
+            }
+            await this.options.validateWorkspaceAccess(input.workspaceId, input.requestedBy);
+            this.assertCommandIntake();
+            const stateBefore = this.readState();
+            if (stateBefore.coordinatorGeneration !== input.expectedCoordinatorGeneration
+                || stateBefore.activeWorkspaceId !== input.workspaceId
+                || stateBefore.transitionState !== 'idle'
+                || !['server', 'browser-gateway'].includes(stateBefore.ownershipMode)
+                || stateBefore.ownershipMode === input.targetMode) {
+                throw new LocalSyncCoordinatorError('The ownership transfer source or generation is stale.', 'SYNC_COORDINATOR_STALE_GENERATION');
+            }
+            const command = this.options.store.acceptCommand(envelope, {
+                requireActiveWorkspace: true,
+            }).record;
+            let began = false;
+            let serverMayBeLive = stateBefore.ownershipMode === 'server'
+                || input.targetMode === 'server';
+            let generationFenceAdvanced = false;
+            let credentialGenerationAdvanced = false;
+            const context = {
+                commandId: command.commandId,
+                workspaceId: input.workspaceId,
+                sourceGeneration: input.expectedCoordinatorGeneration,
+                targetGeneration: input.expectedCoordinatorGeneration + 1,
+                sourceMode: stateBefore.ownershipMode,
+                targetMode: input.targetMode,
+                requestedBy: input.requestedBy,
+            };
+            try {
+                this.options.store.beginOwnershipTransfer({
+                    commandId: command.commandId,
+                    workspaceId: input.workspaceId,
+                    expectedGeneration: input.expectedCoordinatorGeneration,
+                    targetMode: input.targetMode,
+                    version: 1,
+                    requestedBy: input.requestedBy,
+                });
+                began = true;
+                await lifecycle.prepareTransfer(context);
+                this.options.store.advanceOwnershipTransfer({
+                    commandId: command.commandId,
+                    expectedPhase: 'preparing',
+                    nextPhase: 'draining',
+                });
+                await lifecycle.drainCurrentOwner(context, this.options.shutdownGraceMs ?? 15_000);
+                this.options.store.advanceOwnershipTransferGeneration({
+                    commandId: command.commandId,
+                    expectedSourceGeneration: input.expectedCoordinatorGeneration,
+                });
+                generationFenceAdvanced = true;
+                await lifecycle.advanceCredentialGeneration(context);
+                credentialGenerationAdvanced = true;
+                if (input.targetMode === 'server') {
+                    this.options.store.advanceOwnershipTransfer({
+                        commandId: command.commandId,
+                        expectedPhase: 'generation-advanced',
+                        nextPhase: 'starting-target',
+                    });
+                    await lifecycle.prepareServerRunner(context);
+                    this.options.store.advanceOwnershipTransfer({
+                        commandId: command.commandId,
+                        expectedPhase: 'starting-target',
+                        nextPhase: 'committing',
+                    });
+                }
+                else {
+                    this.options.store.advanceOwnershipTransfer({
+                        commandId: command.commandId,
+                        expectedPhase: 'generation-advanced',
+                        nextPhase: 'stopping-source',
+                    });
+                    await lifecycle.stopServerRunner(context);
+                    serverMayBeLive = false;
+                    this.options.store.advanceOwnershipTransfer({
+                        commandId: command.commandId,
+                        expectedPhase: 'stopping-source',
+                        nextPhase: 'committing',
+                    });
+                }
+                return {
+                    state: this.options.store.completeOwnershipTransfer({
+                        commandId: command.commandId,
+                        targetMode: input.targetMode,
+                    }, input.targetMode === 'server'
+                        ? () => lifecycle.activateServerRunnerForCommit(context)
+                        : undefined),
+                    replayed: false,
+                };
+            }
+            catch (error) {
+                const errorCode = error?.code
+                    || 'SYNC_COORDINATOR_OWNERSHIP_TRANSFER_FAILED';
+                const errorMessage = String(error?.message || error);
+                if (began) {
+                    let serverStopProven = !serverMayBeLive;
+                    if (serverMayBeLive) {
+                        try {
+                            await lifecycle.stopServerRunner(context);
+                            serverStopProven = true;
+                            serverMayBeLive = false;
+                        }
+                        catch {
+                            serverStopProven = false;
+                        }
+                    }
+                    let fallbackMode = 'stopped';
+                    if (!generationFenceAdvanced
+                        && !credentialGenerationAdvanced
+                        && stateBefore.ownershipMode === 'browser-gateway') {
+                        fallbackMode = 'browser-gateway';
+                    }
+                    else if (credentialGenerationAdvanced && serverStopProven) {
+                        fallbackMode = 'browser-gateway';
+                    }
+                    this.options.store.failOwnershipTransfer({
+                        commandId: command.commandId,
+                        fallbackMode,
+                        errorCode,
+                        errorMessage,
+                    });
+                }
+                else {
+                    this.options.store.finishCommand({
+                        commandId: command.commandId,
+                        status: 'failed',
+                        errorCode,
+                        errorMessage,
+                    });
+                }
+                throw error;
+            }
+        };
+        const result = this.transitionQueue.then(run, run);
+        this.transitionQueue = result.catch(() => undefined);
+        return result;
+    }
+    readTerminalTransfer(command) {
+        if (command.status === 'succeeded') {
+            const result = command.result;
+            if (!result?.state) {
+                throw new Error(`Coordinator command ${command.commandId} is missing its terminal state.`);
+            }
+            return result.state;
+        }
+        if (command.status === 'failed' || command.status === 'superseded') {
+            const terminalError = new Error(command.errorMessage || `Coordinator command ${command.commandId} ${command.status}.`);
+            terminalError.code = command.errorCode || 'SYNC_COORDINATOR_COMMAND_TERMINAL';
+            throw terminalError;
+        }
+        throw new LocalSyncCoordinatorError(`Ownership transfer command ${command.commandId} is still active.`, 'SYNC_COORDINATOR_STALE_GENERATION');
+    }
+    async stop() {
+        this.beginShutdown();
+        await this.finishShutdown();
+        await this.releaseProcessLock();
+    }
+    beginShutdown() {
+        if (!this.options.processLock.owned || !this.acceptingCommands)
+            return;
+        this.closeCommandIntake();
+        this.options.store.setLifecycleMode('stopped', 'shutting-down');
+    }
+    /**
+     * Stops new coordinator commands without changing the persisted ownership
+     * fence. A server-owned runner must remain the active owner until its
+     * in-flight work and execution permits have drained.
+     */
+    closeCommandIntake() {
+        if (!this.options.processLock.owned)
+            return;
+        this.acceptingCommands = false;
+    }
+    async waitForTransitionDrain(graceMs) {
+        if (!this.options.processLock.owned)
+            return true;
+        const timeoutMs = Math.max(0, Math.floor(graceMs));
+        let graceTimer;
+        const drained = await Promise.race([
+            this.transitionQueue.then(() => true, () => true),
+            new Promise((resolve) => {
+                graceTimer = setTimeout(() => resolve(false), timeoutMs);
+                graceTimer.unref?.();
+            }),
+        ]);
+        if (graceTimer)
+            clearTimeout(graceTimer);
+        return drained;
+    }
+    completeShutdownAfterExternalDrain() {
+        if (!this.options.processLock.owned)
+            return;
+        this.options.store.setLifecycleMode('stopped', 'idle');
+    }
+    async finishShutdown() {
+        if (!this.options.processLock.owned)
+            return;
+        const graceMs = this.options.shutdownGraceMs ?? 15_000;
+        const drained = await this.waitForTransitionDrain(graceMs);
+        if (!drained) {
+            this.options.store.recoverAfterRestart();
+        }
+        await this.options.drainSyncGateway?.(graceMs);
+        this.completeShutdownAfterExternalDrain();
+    }
+    async releaseProcessLock() {
+        if (!this.options.processLock.owned)
+            return;
+        await this.options.processLock.release();
+    }
+    assertCommandIntake() {
+        if (!this.options.processLock.owned) {
+            throw new LocalSyncCoordinatorError('Another local Taskforce process owns workspace synchronization.', 'SYNC_COORDINATOR_OWNED_BY_OTHER_PROCESS');
+        }
+        if (!this.acceptingCommands) {
+            throw new LocalSyncCoordinatorError('The local sync coordinator is shutting down.', 'SYNC_COORDINATOR_SHUTTING_DOWN');
+        }
+    }
+}

package/dist/sync/coordinator/localSyncCoordinatorRouteServices.d.ts

@@ -0,0 +1,33 @@
+import type { LocalSyncCoordinatorHost } from './localSyncCoordinatorHost.js';
+import type { LocalSyncDispatchTracker } from './localSyncDispatchTracker.js';
+import type { LocalSyncExecutionPermitStore } from './localSyncExecutionPermitStore.js';
+import type { WorkspaceSyncCredentialBroker } from './workspaceSyncCredentialBroker.js';
+import type { WorkspaceSyncTransportGateway } from './workspaceSyncTransportGateway.js';
+import type { LocalSyncCoordinatorCommandRecord } from './localSyncCoordinatorTypes.js';
+import type { LocalSyncCoordinatorState } from './localSyncCoordinatorTypes.js';
+import type { LocalSyncCoordinatorWakeSource } from './localSyncCoordinatorTypes.js';
+import type { WorkspaceSyncCredentialSnapshot } from './workspaceSyncCredentialBroker.js';
+import type { LocalWorkspaceSyncRunnerStatus } from './localWorkspaceSyncRunner.js';
+import type { WorkspaceSyncV3LocalOutboxStatus } from '../v3/workspaceSyncV3LocalOutboxStatus.js';
+export interface LocalSyncCoordinatorWorkspaceStatus {
+    runner: LocalWorkspaceSyncRunnerStatus | null;
+    outbox: WorkspaceSyncV3LocalOutboxStatus;
+}
+export interface LocalSyncCoordinatorRouteServices {
+    host: LocalSyncCoordinatorHost;
+    permitStore: LocalSyncExecutionPermitStore;
+    credentialBroker: WorkspaceSyncCredentialBroker;
+    transportGateway: WorkspaceSyncTransportGateway;
+    serverOwnershipTransferEnabled?: boolean;
+    localDispatchTracker?: LocalSyncDispatchTracker;
+    onCommandAccepted?: (command: LocalSyncCoordinatorCommandRecord) => void;
+    requestWakeHint?: (input: {
+        workspaceId: string;
+        coordinatorGeneration: number;
+        source: Extract<LocalSyncCoordinatorWakeSource, 'realtime' | 'connectivity'>;
+        eventIds: string[];
+    }) => boolean;
+    onCredentialBound?: (credential: WorkspaceSyncCredentialSnapshot) => Promise<LocalSyncCoordinatorState | void>;
+    recordCommittedLocalApply?: (workspaceId: string, coordinatorGeneration: number, applyResult: unknown) => void;
+    readWorkspaceStatus?: (workspaceId: string, coordinatorGeneration: number) => LocalSyncCoordinatorWorkspaceStatus;
+}

package/dist/sync/coordinator/localSyncCoordinatorRouteServices.js

@@ -0,0 +1 @@
+export {};

package/dist/sync/coordinator/localSyncCoordinatorStore.d.ts

@@ -0,0 +1,122 @@
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+import { type LocalSyncCoordinatorCommandEnvelope, type LocalSyncCoordinatorCommandRecord, type LocalSyncCoordinatorCommandStatus, type LocalSyncCoordinatorOwnershipMode, type LocalSyncCoordinatorOwnershipTransferPhase, type LocalSyncCoordinatorOwnershipTransferTarget, type LocalSyncCoordinatorPrincipal, type LocalSyncCoordinatorState, type LocalSyncCoordinatorTransitionState } from './localSyncCoordinatorTypes.js';
+export declare const LOCAL_SYNC_COMMAND_RETENTION_MIN_AGE_MS: number;
+export declare const LOCAL_SYNC_COMMAND_RETENTION_SOFT_LIMIT = 1000;
+export declare const LOCAL_SYNC_COMMAND_RETENTION_DELETE_BATCH = 250;
+export declare class LocalSyncCoordinatorStore {
+    private readonly db;
+    private readonly now;
+    constructor(db: DatabaseAdapter, now?: () => string);
+    readOrCreateState(): LocalSyncCoordinatorState;
+    /**
+     * Advances the browser-visible data version after a committed local apply.
+     *
+     * This method deliberately does not open its own transaction. Apply callers
+     * must invoke it inside the same database transaction as the local writes so
+     * the version cannot become visible unless those writes commit.
+     */
+    advanceLocalDataVersion(input: {
+        workspaceId: string;
+        expectedCoordinatorGeneration: number;
+    }): number;
+    setLifecycleMode(ownershipMode: LocalSyncCoordinatorOwnershipMode, transitionState: LocalSyncCoordinatorTransitionState): LocalSyncCoordinatorState;
+    resumeBrowserGatewayAfterAuthenticatedRestart(input: {
+        workspaceId: string;
+        expectedCoordinatorGeneration: number;
+    }): LocalSyncCoordinatorState;
+    resumeServerAfterAuthenticatedRestart(input: {
+        workspaceId: string;
+        expectedCoordinatorGeneration: number;
+    }, activateCommittedOwner: (state: LocalSyncCoordinatorState) => void): LocalSyncCoordinatorState;
+    private resumeDesiredOwnerAfterAuthenticatedRestart;
+    acceptCommand(envelope: LocalSyncCoordinatorCommandEnvelope, options?: {
+        expectedActiveWorkspaceId?: string | null;
+        requireActiveWorkspace?: boolean;
+        requireWorkspaceSwitchSource?: boolean;
+        requireServerOwnership?: boolean;
+    }): {
+        record: LocalSyncCoordinatorCommandRecord;
+        replayed: boolean;
+    };
+    readCommand(commandId: string): LocalSyncCoordinatorCommandRecord | null;
+    listAcceptedRunnerCommands(input: {
+        workspaceId: string;
+        coordinatorGeneration: number;
+    }): LocalSyncCoordinatorCommandRecord[];
+    claimNextRunnerCommand(input: {
+        workspaceId: string;
+        coordinatorGeneration: number;
+        cloudCapabilityAvailable: boolean;
+    }): LocalSyncCoordinatorCommandRecord | null;
+    claimCommandForExecution(input: {
+        commandId: string;
+        workspaceId: string;
+        coordinatorGeneration: number;
+    }): {
+        record: LocalSyncCoordinatorCommandRecord | null;
+        claimed: boolean;
+    };
+    recoverRunnerCommandsForRecreation(input: {
+        workspaceId: string;
+        coordinatorGeneration: number;
+    }): number;
+    markCommandRunning(commandId: string): LocalSyncCoordinatorCommandRecord;
+    finishCommand(input: {
+        commandId: string;
+        status: Extract<LocalSyncCoordinatorCommandStatus, 'succeeded' | 'failed' | 'superseded'>;
+        result?: unknown;
+        errorCode?: string | null;
+        errorMessage?: string | null;
+    }): LocalSyncCoordinatorCommandRecord;
+    recoverAfterRestart(): {
+        state: LocalSyncCoordinatorState;
+        interruptedCommandCount: number;
+    };
+    pruneTerminalCommands(): number;
+    beginOwnershipTransfer(input: {
+        commandId: string;
+        workspaceId: string;
+        expectedGeneration: number;
+        targetMode: LocalSyncCoordinatorOwnershipTransferTarget;
+        version: number;
+        requestedBy: LocalSyncCoordinatorPrincipal;
+    }): LocalSyncCoordinatorState;
+    advanceOwnershipTransfer(input: {
+        commandId: string;
+        expectedPhase: LocalSyncCoordinatorOwnershipTransferPhase;
+        nextPhase: LocalSyncCoordinatorOwnershipTransferPhase;
+    }): LocalSyncCoordinatorState;
+    advanceOwnershipTransferGeneration(input: {
+        commandId: string;
+        expectedSourceGeneration: number;
+    }): LocalSyncCoordinatorState;
+    private advanceRunnerStateGenerationIfPresent;
+    completeOwnershipTransfer(input: {
+        commandId: string;
+        targetMode: LocalSyncCoordinatorOwnershipTransferTarget;
+    }, activateCommittedOwner?: (state: LocalSyncCoordinatorState) => void): LocalSyncCoordinatorState;
+    failOwnershipTransfer(input: {
+        commandId: string;
+        fallbackMode: Extract<LocalSyncCoordinatorOwnershipMode, 'browser-gateway' | 'stopped'>;
+        errorCode: string;
+        errorMessage: string;
+    }): LocalSyncCoordinatorState;
+    beginWorkspaceSwitch(input: {
+        commandId: string;
+        expectedActiveWorkspaceId: string | null;
+        expectedGeneration: number;
+        targetWorkspaceId: string;
+        requestedBy: LocalSyncCoordinatorPrincipal;
+    }): LocalSyncCoordinatorState;
+    completeWorkspaceSwitch(input: {
+        commandId: string;
+        targetWorkspaceId: string;
+        terminalResult: unknown;
+        activateTargetForCommit?: () => void;
+    }): LocalSyncCoordinatorState;
+    failWorkspaceSwitch(input: {
+        commandId: string;
+        errorCode: string;
+        errorMessage: string;
+    }): LocalSyncCoordinatorState;
+}