@kin-tio/cli 0.6.0

package/dist/src/runtime/single-instance-lock.js

@@ -0,0 +1,167 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+function errorCode(error) {
+    if (!error || typeof error !== 'object' || !('code' in error))
+        return '';
+    return String(error.code ?? '');
+}
+export function processIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) === 'EPERM';
+    }
+}
+function readOwner(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return { pid: 0, token: '', createdAt: 0, invalid: true };
+        }
+        const candidate = parsed;
+        if (!Number.isInteger(candidate.pid) ||
+            typeof candidate.token !== 'string' ||
+            !candidate.token ||
+            !Number.isFinite(candidate.createdAt)) {
+            return { pid: 0, token: '', createdAt: 0, invalid: true };
+        }
+        return {
+            pid: Number(candidate.pid),
+            token: candidate.token,
+            createdAt: Number(candidate.createdAt),
+        };
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return null;
+        return { pid: 0, token: '', createdAt: 0, invalid: true };
+    }
+}
+function writeExclusive(filePath, owner) {
+    const descriptor = fs.openSync(filePath, 'wx', 0o600);
+    try {
+        fs.writeFileSync(descriptor, `${JSON.stringify(owner)}\n`, 'utf8');
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function unlinkIfOwned(filePath, token) {
+    const owner = readOwner(filePath);
+    if (!owner || owner.token !== token)
+        return false;
+    try {
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export class SingleInstanceLockError extends Error {
+    code;
+    owner;
+    constructor(message, { code = 'instance_locked', owner = null, } = {}) {
+        super(message);
+        this.name = 'SingleInstanceLockError';
+        this.code = code;
+        this.owner = owner;
+    }
+}
+export function acquireSingleInstanceLock({ filePath, pid = process.pid, clock = Date.now, isProcessAlive = processIsAlive, hasActiveDatabaseOwner = () => false, recoveryStaleMs = 30_000, }) {
+    if (!filePath)
+        throw new Error('Single-instance lock filePath is required');
+    const lockPath = path.resolve(filePath);
+    const recoveryPath = `${lockPath}.recovery`;
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true, mode: 0o700 });
+    const token = randomUUID();
+    const owner = {
+        pid: Number(pid),
+        token,
+        createdAt: Number(clock()),
+    };
+    const recoveryOwner = readOwner(recoveryPath);
+    if (recoveryOwner) {
+        if (recoveryOwner.invalid) {
+            const age = Number(clock()) - fs.statSync(recoveryPath).mtimeMs;
+            if (age < Number(recoveryStaleMs)) {
+                throw new SingleInstanceLockError(`Single-instance lock recovery is already active: ${recoveryPath}`, { code: 'lock_recovery_in_progress', owner: recoveryOwner });
+            }
+            fs.unlinkSync(recoveryPath);
+        }
+        else if (isProcessAlive(Number(recoveryOwner.pid)) ||
+            hasActiveDatabaseOwner(recoveryOwner)) {
+            throw new SingleInstanceLockError(`Single-instance lock recovery is already active: ${recoveryPath}`, { code: 'lock_recovery_in_progress', owner: recoveryOwner });
+        }
+        else {
+            unlinkIfOwned(recoveryPath, recoveryOwner.token);
+        }
+    }
+    try {
+        writeExclusive(lockPath, owner);
+    }
+    catch (error) {
+        if (errorCode(error) !== 'EEXIST')
+            throw error;
+        const current = readOwner(lockPath);
+        if (current &&
+            !current.invalid &&
+            isProcessAlive(current.pid)) {
+            throw new SingleInstanceLockError(`Another Kintio instance is running with PID ${current.pid}`, { owner: current });
+        }
+        if (hasActiveDatabaseOwner(current)) {
+            throw new SingleInstanceLockError('The stale PID check failed but SQLite still reports an active owner', { code: 'database_owner_active', owner: current });
+        }
+        const recoveryToken = randomUUID();
+        const recovery = {
+            pid: Number(pid),
+            token: recoveryToken,
+            createdAt: Number(clock()),
+        };
+        try {
+            writeExclusive(recoveryPath, recovery);
+        }
+        catch (guardError) {
+            if (errorCode(guardError) === 'EEXIST') {
+                throw new SingleInstanceLockError('Another process is recovering the stale instance lock', { code: 'lock_recovery_in_progress', owner: readOwner(recoveryPath) });
+            }
+            throw guardError;
+        }
+        try {
+            const checked = readOwner(lockPath);
+            if (checked &&
+                !checked.invalid &&
+                isProcessAlive(Number(checked.pid))) {
+                throw new SingleInstanceLockError(`Another Kintio instance acquired the lock with PID ${checked.pid}`, { owner: checked });
+            }
+            if (checked && hasActiveDatabaseOwner(checked)) {
+                throw new SingleInstanceLockError('SQLite reports an active owner for the existing lock', { code: 'database_owner_active', owner: checked });
+            }
+            if (checked)
+                fs.unlinkSync(lockPath);
+            writeExclusive(lockPath, owner);
+        }
+        finally {
+            unlinkIfOwned(recoveryPath, recoveryToken);
+        }
+    }
+    let released = false;
+    return Object.freeze({
+        filePath: lockPath,
+        owner: Object.freeze({ ...owner }),
+        release() {
+            if (released)
+                return false;
+            released = true;
+            return unlinkIfOwned(lockPath, token);
+        },
+    });
+}

package/dist/src/runtime.js

@@ -0,0 +1,503 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { acquireSingleInstanceLock } from './runtime/single-instance-lock.js';
+import { ensurePrivateDirectory } from './lib/private-directory.js';
+import { CodexAgent, createCodexAppServer } from './services/codex-agent.js';
+import { ConversationProcessor } from './services/conversation-processor.js';
+import { cleanupStagedImageOrphans } from './services/image-stager.js';
+import { WecomMediaGateway } from './services/media-gateway.js';
+import { WecomApiClient } from './services/wecom-api.js';
+import { WecomSync } from './services/wecom-sync.js';
+import { WechatKfToolExecutor } from './mcp/wechat-kf-executor.js';
+import { createWechatKfMcpServer } from './mcp/wechat-kf-server.js';
+import { createIlinkMcpServer } from './mcp/ilink-server.js';
+import { McpIpcHost } from './mcp/ipc-host.js';
+import { IlinkSendExecutor } from './ilink/executor.js';
+import { IlinkListenerManager } from './ilink/listener.js';
+import { IlinkLoginManager } from './ilink/login-manager.js';
+import { IlinkMediaGateway } from './ilink/media-gateway.js';
+import { DEFAULT_ILINK_MEDIA_TIMEOUT_MS } from './ilink/media.js';
+import { DEFAULT_ILINK_IMAGE_TIMEOUT_MS } from './ilink/inbound-image.js';
+import { IlinkClient } from './ilink/protocol/client.js';
+import { IlinkSecretBox } from './ilink/secret-box.js';
+import { ConversationMemoryExecutor, createConversationMemoryMcpServer, } from './mcp/conversation-memory-server.js';
+import { StatePersistence, StatePersistenceUnclosedError, } from './state/persistence.js';
+function ilinkSecretGeneration(providerMessageId) {
+    return Number.parseInt(createHash('sha256').update(providerMessageId).digest('hex').slice(0, 12), 16);
+}
+function readOrCreatePrivateKey(filePath, label) {
+    const target = path.resolve(filePath);
+    ensurePrivateDirectory(path.dirname(target));
+    try {
+        const existing = fs.readFileSync(target, 'utf8').trim();
+        if (!/^[A-Za-z0-9_-]{43}$/u.test(existing)) {
+            throw new Error(`${label} file is invalid`);
+        }
+        fs.chmodSync(target, 0o600);
+        return existing;
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+    const token = randomBytes(32).toString('base64url');
+    try {
+        fs.writeFileSync(target, `${token}\n`, { flag: 'wx', mode: 0o600 });
+        return token;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'EEXIST') {
+            return readOrCreatePrivateKey(target, label);
+        }
+        throw error;
+    }
+}
+export async function createRuntime({ config, logger = console, }) {
+    if ((!config.wecom.api.enabled && !config.ilink.enabled) || !config.codex.enabled) {
+        logger.info('[runtime] message processing is disabled');
+        return {
+            messageProcessor: null,
+            async start() { },
+            stopAccepting() { },
+            async close() { },
+            async abort() { },
+        };
+    }
+    const enabledChannels = [
+        ...(config.wecom.api.enabled ? ['wechat_kf'] : []),
+        ...(config.ilink.enabled ? ['weixin_ilink'] : []),
+    ];
+    const instanceLock = acquireSingleInstanceLock({
+        filePath: config.state.lockFile,
+        hasActiveDatabaseOwner: () => StatePersistence.hasActiveWriter(config.state.databaseFile),
+    });
+    let persistence;
+    let cleanupTimer;
+    let ilinkOffers;
+    let mcpHost;
+    try {
+        persistence = new StatePersistence({ filePath: config.state.databaseFile });
+        const activePersistence = persistence;
+        const store = activePersistence.core;
+        const activeStore = store;
+        store.cleanup();
+        cleanupStagedImageOrphans(config.codex.imageTempDirectory);
+        cleanupTimer = setInterval(() => {
+            try {
+                activeStore.cleanup();
+                ilinkOffers?.cleanup();
+            }
+            catch (error) {
+                logger.error(`[cleanup] SQLite retention failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, 60 * 60 * 1000);
+        cleanupTimer.unref();
+        const startupInbound = store.recoverStartup().inbound.filter((record) => enabledChannels.includes(record.channel));
+        const apiClient = config.wecom.api.enabled
+            ? new WecomApiClient({
+                corpId: config.wecom.api.corpId,
+                kfSecret: config.wecom.api.kfSecret,
+                baseUrl: config.wecom.api.baseUrl,
+                timeoutMs: config.wecom.api.timeoutMs,
+            })
+            : undefined;
+        const mediaGateway = apiClient ? new WecomMediaGateway({ apiClient }) : undefined;
+        let ilinkLogin;
+        let ilinkListener;
+        let toolsUnavailable = false;
+        const wechatTools = apiClient && mediaGateway
+            ? new WechatKfToolExecutor({
+                store,
+                apiClient,
+                mediaGateway,
+                observeMs: config.wecom.api.observeMs,
+                logger,
+                ...(config.ilink.enabled ? {
+                    ilinkOffers: {
+                        offer(sessionToken) {
+                            if (!ilinkLogin)
+                                throw new Error('iLink login manager is unavailable');
+                            return ilinkLogin.offer(sessionToken);
+                        },
+                        cancel(offerId) {
+                            ilinkLogin?.cancel(offerId);
+                        },
+                    },
+                } : {}),
+            })
+            : undefined;
+        const ilinkSecretBox = config.ilink.enabled
+            ? new IlinkSecretBox(config.ilink.storageKey || readOrCreatePrivateKey(config.ilink.storageKeyFile, 'iLink storage key'))
+            : undefined;
+        const ilinkStore = config.ilink.enabled
+            ? activePersistence.createIlinkStore()
+            : undefined;
+        const recoveredIlinkReservations = ilinkStore?.recoverPendingAttempts() || 0;
+        if (recoveredIlinkReservations) {
+            logger.info?.(`[recovery] released pending iLink sends=${recoveredIlinkReservations}`);
+        }
+        const ilinkMedia = ilinkStore && ilinkSecretBox
+            ? new IlinkMediaGateway({ store: ilinkStore, secretBox: ilinkSecretBox })
+            : undefined;
+        const ilinkTools = ilinkStore && ilinkSecretBox
+            ? new IlinkSendExecutor({
+                store,
+                ilinkStore,
+                secretBox: ilinkSecretBox,
+                createClient: ({ token, baseUrl }) => new IlinkClient({
+                    token, baseUrl, timeoutMs: config.ilink.apiTimeoutMs,
+                }),
+                ...(ilinkMedia ? { mediaGateway: ilinkMedia } : {}),
+            })
+            : undefined;
+        if (ilinkStore && ilinkSecretBox) {
+            ilinkOffers = activePersistence.createIlinkLoginStore({
+                secretBox: ilinkSecretBox,
+            });
+            ilinkOffers.cleanup();
+            ilinkLogin = new IlinkLoginManager({
+                offers: ilinkOffers,
+                accounts: ilinkStore,
+                secretBox: ilinkSecretBox,
+                maxAccounts: config.ilink.maxAccounts,
+                logger,
+                client: new IlinkClient({
+                    baseUrl: config.ilink.baseUrl,
+                    timeoutMs: config.ilink.apiTimeoutMs,
+                    longPollTimeoutMs: config.ilink.longPollTimeoutMs,
+                }),
+                onAccountsChanged: () => ilinkListener?.refresh(),
+            });
+        }
+        const channelDispatcher = {
+            async kick(channel) {
+                if (channel === 'wechat_kf')
+                    return wechatTools?.kick();
+                if (channel === 'weixin_ilink')
+                    return;
+                await wechatTools?.kick();
+            },
+            async notifyQueued(record) {
+                if (record.channel === 'weixin_ilink' && ilinkTools) {
+                    await ilinkTools.notifyQueued(record.messageKey);
+                }
+            },
+        };
+        let conversationMemory;
+        const runtimeFile = fileURLToPath(import.meta.url);
+        const activeMcpHost = new McpIpcHost({
+            instanceKey: config.state.lockFile,
+            stateDirectory: path.dirname(config.state.lockFile),
+            relayFile: path.resolve(path.dirname(runtimeFile), '..', `mcp-relay${path.extname(runtimeFile)}`),
+            ...(wechatTools ? {
+                wechatKf: () => createWechatKfMcpServer({
+                    execute(name, input) {
+                        if (toolsUnavailable)
+                            throw new Error('service unavailable');
+                        return wechatTools.execute(name, input);
+                    },
+                }),
+            } : {}),
+            memory: () => createConversationMemoryMcpServer({
+                read(session) {
+                    if (toolsUnavailable || !conversationMemory) {
+                        throw new Error('service unavailable');
+                    }
+                    return conversationMemory.read(session);
+                },
+            }),
+            ...(ilinkTools ? {
+                ilink: () => createIlinkMcpServer({
+                    execute(name, input) {
+                        if (toolsUnavailable)
+                            throw new Error('service unavailable');
+                        return ilinkTools.execute(name, input);
+                    },
+                }),
+            } : {}),
+            logger,
+        });
+        mcpHost = activeMcpHost;
+        const mcpLaunches = await activeMcpHost.start();
+        const codex = createCodexAppServer({
+            logger,
+            mcpLaunches,
+            mcpToolTimeoutSec: Math.ceil((config.wecom.api.timeoutMs * 4 +
+                config.wecom.api.observeMs +
+                5_000) / 1_000),
+            ilinkMcpToolTimeoutSec: Math.ceil((DEFAULT_ILINK_IMAGE_TIMEOUT_MS +
+                DEFAULT_ILINK_MEDIA_TIMEOUT_MS +
+                config.ilink.apiTimeoutMs +
+                5_000) / 1_000),
+        });
+        const codexAgent = new CodexAgent({
+            codex,
+            config: config.codex,
+        });
+        conversationMemory = new ConversationMemoryExecutor({
+            store,
+            threads: codex,
+        });
+        const processor = new ConversationProcessor({
+            store,
+            agent: codexAgent,
+            mediaGateway: {
+                resolveForCodex(message) {
+                    if (message.conversation.channel === 'weixin_ilink' && ilinkMedia) {
+                        return ilinkMedia.resolveForCodex(message);
+                    }
+                    return mediaGateway?.resolveForCodex(message) || Promise.resolve([]);
+                },
+            },
+            channel: channelDispatcher,
+            allowedUserIds: config.wecom.allowedUserIds,
+            authorization: config.wecom.authorization,
+            logger,
+        });
+        let requestDeferredDrain = () => { };
+        const sync = apiClient
+            ? new WecomSync({
+                apiClient,
+                store,
+                processor,
+                logger,
+                startPaused: true,
+                onDeferredReady() {
+                    queueMicrotask(requestDeferredDrain);
+                },
+            })
+            : undefined;
+        ilinkListener = ilinkStore && ilinkSecretBox
+            ? new IlinkListenerManager({
+                logger,
+                host: {
+                    listActiveRuntimeAccounts() {
+                        const accounts = ilinkStore.listActiveAccountsWithSecrets();
+                        if (accounts.length > config.ilink.maxAccounts) {
+                            throw new Error('Active iLink account count exceeds configured limit');
+                        }
+                        return accounts.map(({ account, secret }) => ({
+                            accountKey: account.accountKey,
+                            providerAccountId: account.providerAccountId,
+                            ownerPeerId: account.ownerPeerId,
+                            generation: account.generation,
+                            cursor: ilinkStore.getCursor(account.accountKey)?.cursor || '',
+                            botToken: ilinkSecretBox.open(secret.sealedBotToken, {
+                                secretKind: 'bot_token',
+                                accountId: account.accountKey,
+                                peerId: account.ownerPeerId,
+                                generation: account.generation,
+                            }),
+                            baseUrl: account.baseUrl,
+                        }));
+                    },
+                    commitPage(input) {
+                        const committed = ilinkStore.commitPollPage({
+                            accountKey: input.accountKey,
+                            expectedGeneration: input.expectedGeneration,
+                            expectedCursor: input.expectedCursor,
+                            nextCursor: input.nextCursor,
+                            deferredBefore: input.deferredBefore,
+                            messages: input.messages.map(({ message, facts }) => {
+                                const { accountKey, peerId } = message.conversation;
+                                const secretGeneration = ilinkSecretGeneration(message.providerMessageId);
+                                return {
+                                    message,
+                                    ...(facts.providerSeq === undefined
+                                        ? {}
+                                        : { providerSeq: facts.providerSeq }),
+                                    secretGeneration,
+                                    sealedContextToken: ilinkSecretBox.seal(facts.contextToken, {
+                                        secretKind: 'context_token',
+                                        accountId: accountKey,
+                                        peerId,
+                                        generation: secretGeneration,
+                                    }),
+                                    sealedImages: facts.images.map((image) => {
+                                        const imageGeneration = ilinkSecretGeneration(`${message.providerMessageId}:image:${image.position}`);
+                                        return {
+                                            position: image.position,
+                                            secretGeneration: imageGeneration,
+                                            sealedLocator: ilinkSecretBox.seal(JSON.stringify({
+                                                downloadUrl: image.downloadUrl,
+                                                aesKey: image.aesKey,
+                                            }), {
+                                                secretKind: 'media_locator',
+                                                accountId: accountKey,
+                                                peerId,
+                                                generation: imageGeneration,
+                                            }),
+                                        };
+                                    }),
+                                };
+                            }),
+                        });
+                        return committed;
+                    },
+                    backlogReady() {
+                        queueMicrotask(requestDeferredDrain);
+                    },
+                    enqueue(messageKeys) {
+                        for (const key of messageKeys)
+                            void processor.enqueue(key);
+                    },
+                },
+                createClient: (account) => new IlinkClient({
+                    token: account.botToken,
+                    baseUrl: account.baseUrl,
+                    timeoutMs: config.ilink.apiTimeoutMs,
+                    longPollTimeoutMs: config.ilink.longPollTimeoutMs,
+                }),
+            })
+            : undefined;
+        let starting;
+        let startupRecovery;
+        let closing;
+        let accepting = true;
+        let ilinkClosing;
+        let deferredDrain;
+        let deferredDrainRequested = false;
+        const drainDeferred = async () => {
+            while (!closing) {
+                await sync?.waitForIdle();
+                await processor.waitForIdle();
+                const records = activeStore.activateNextDeferredConversation(enabledChannels);
+                if (!records.length)
+                    return;
+                await processor.recover(records, { priority: 'low' });
+                await processor.waitForIdle();
+            }
+        };
+        requestDeferredDrain = () => {
+            if (closing)
+                return;
+            deferredDrainRequested = true;
+            if (deferredDrain)
+                return;
+            deferredDrain = (async () => {
+                do {
+                    deferredDrainRequested = false;
+                    await drainDeferred();
+                } while (deferredDrainRequested && !closing);
+            })().catch((error) => {
+                logger.error(`[recovery] deferred backlog failed: ${error instanceof Error ? error.message : String(error)}`);
+            }).finally(() => {
+                deferredDrain = undefined;
+                if (deferredDrainRequested && !closing)
+                    queueMicrotask(requestDeferredDrain);
+            });
+        };
+        const runtime = {
+            messageProcessor: sync || null,
+            start() {
+                if (!accepting)
+                    return Promise.reject(new Error('Kintio runtime is stopping'));
+                starting ||= (async () => {
+                    const catchUp = sync?.catchUp() || Promise.resolve();
+                    const recovery = processor.recover(startupInbound, { priority: 'low' });
+                    sync?.startConsuming();
+                    await ilinkListener?.start();
+                    await ilinkLogin?.start();
+                    startupRecovery = Promise.all([catchUp, recovery])
+                        .then(async () => {
+                        await channelDispatcher.kick();
+                        if (!ilinkListener)
+                            requestDeferredDrain();
+                    })
+                        .catch((error) => {
+                        logger.error(`[recovery] startup backlog failed: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                })();
+                return starting;
+            },
+            stopAccepting() {
+                if (!accepting)
+                    return;
+                accepting = false;
+                sync?.stopAccepting();
+                processor.stopAccepting();
+                ilinkClosing ||= Promise.all([
+                    ilinkLogin?.close(),
+                    ilinkListener?.close(),
+                ]).then(() => undefined);
+            },
+            close() {
+                if (closing)
+                    return closing;
+                runtime.stopAccepting();
+                closing = (async () => {
+                    try {
+                        await starting?.catch(() => undefined);
+                        await startupRecovery?.catch(() => undefined);
+                        await deferredDrain?.catch(() => undefined);
+                        await sync?.close();
+                        await ilinkClosing;
+                        await processor.close();
+                    }
+                    finally {
+                        toolsUnavailable = true;
+                        await Promise.allSettled([
+                            ilinkTools?.waitForIdle(),
+                            wechatTools?.close(),
+                        ]);
+                        try {
+                            await activeMcpHost.close();
+                        }
+                        finally {
+                            if (cleanupTimer)
+                                clearInterval(cleanupTimer);
+                            try {
+                                activeStore.cleanup();
+                                ilinkOffers?.cleanup();
+                                activeStore.checkpoint('TRUNCATE');
+                            }
+                            finally {
+                                try {
+                                    activePersistence.close();
+                                }
+                                finally {
+                                    if (activePersistence.closed)
+                                        instanceLock.release();
+                                }
+                            }
+                        }
+                    }
+                })();
+                return closing;
+            },
+            async abort() {
+                runtime.stopAccepting();
+                toolsUnavailable = true;
+                wechatTools?.abort();
+                await Promise.all([
+                    processor.abort(),
+                    ilinkClosing,
+                    activeMcpHost.close(true),
+                ]);
+            },
+        };
+        return runtime;
+    }
+    catch (error) {
+        if (cleanupTimer)
+            clearInterval(cleanupTimer);
+        await mcpHost?.close(true).catch(() => undefined);
+        let persistenceClosed = persistence === undefined &&
+            !(error instanceof StatePersistenceUnclosedError);
+        try {
+            persistence?.close();
+            persistenceClosed = true;
+        }
+        catch (cleanupError) {
+            logger.error(`[runtime] startup cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+        }
+        finally {
+            if (persistence?.closed || persistenceClosed)
+                instanceLock.release();
+        }
+        throw error;
+    }
+}