@quecue/dev-notify 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/claude-hook.js

@@ -0,0 +1,123 @@
+import path from 'node:path';
+import { ConfigError, decodeUtf8, loadConfig, ready } from './config.js';
+import { makePlan } from './channels.js';
+import { NOTIFICATION_MATCHER } from './claude-code.js';
+import { lifecycleHook, interactionHook, attachReply, mapReplies, notificationCoverage } from './reply-hooks.js';
+export const MAX_HOOK_BYTES = 8 * 1024 * 1024;
+export async function readHookInput(input = process.stdin, limit = MAX_HOOK_BYTES) {
+    const chunks = [];
+    let size = 0;
+    const timer = setTimeout(() => input.destroy(new ConfigError('Claude Code hook 输入超时，未发送通知')), 15000);
+    timer.unref();
+    try {
+        for await (const chunk of input) {
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            size += bytes.length;
+            if (size > limit)
+                throw new ConfigError('Claude Code hook 输入超过大小限制，未截断发送');
+            chunks.push(bytes);
+        }
+        return Buffer.concat(chunks);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function metadata(value, limit) {
+    if (typeof value !== 'string')
+        return '';
+    const clean = value.replace(/[\x00-\x1f\x7f]/g, ' ');
+    const chars = Array.from(clean);
+    return chars.length > limit ? chars.slice(0, limit).join('') + '…' : clean;
+}
+export function claudeHookMessage(bytes) {
+    if (bytes.byteLength > MAX_HOOK_BYTES)
+        throw new ConfigError('Claude Code hook 输入超过大小限制，未截断发送');
+    let data;
+    try {
+        data = JSON.parse(decodeUtf8(bytes));
+    }
+    catch {
+        throw new ConfigError('Claude Code hook 输入不是合法 UTF-8 JSON，未发送通知');
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        throw new ConfigError('Claude Code hook 输入必须是 JSON 对象');
+    if (data.hook_event_name !== 'Stop' && data.hook_event_name !== 'Notification')
+        return null;
+    const footer = [typeof data.cwd === 'string' ? `项目：${metadata(path.win32.basename(data.cwd), 120)}` : '',
+        typeof data.session_id === 'string' ? `会话：${metadata(data.session_id, 120)}` : ''].filter(Boolean).join('\n');
+    if (data.hook_event_name === 'Stop') {
+        if (data.stop_hook_active !== undefined && typeof data.stop_hook_active !== 'boolean')
+            throw new ConfigError('Claude Code Stop 状态字段无效');
+        if (data.stop_hook_active === true)
+            return null;
+        if (data.last_assistant_message !== undefined && typeof data.last_assistant_message !== 'string')
+            throw new ConfigError('Claude Code 最终回复字段无效');
+        return { title: 'Claude Code 回复完成', level: 'success', footer,
+            content: data.last_assistant_message?.trim() ? data.last_assistant_message
+                : '本轮回复已结束，但 Claude Code 未提供最终正文。请在终端查看回复；不会读取可能滞后的会话文件来代替正文。' };
+    }
+    // 空闲提醒在 Stop 之后重复触发；只转发明确需要用户处理的通知。
+    if (!NOTIFICATION_MATCHER.split('|').includes(data.notification_type))
+        return null;
+    if (data.message !== undefined && typeof data.message !== 'string')
+        throw new ConfigError('Claude Code 通知正文字段无效');
+    return { title: 'Claude Code 需要你处理', level: 'warn', footer,
+        content: data.message?.trim() ? data.message : 'Claude Code 正在等待你的确认或输入，请回到终端处理。' };
+}
+export async function dispatchClaudeHook(bytes, configFile, context) {
+    const message = claudeHookMessage(bytes);
+    const data = JSON.parse(decodeUtf8(bytes));
+    const options = { send: context.send, ...context.reply, env: context.env, err: context.err, response: context.response };
+    try {
+        await lifecycleHook(data, configFile, options);
+        await interactionHook(data, configFile, options);
+    }
+    catch {
+        context.err('Claude Code 回复状态或交互处理失败；未自动选择答案/批准权限，请在本机处理。');
+    }
+    if (!message)
+        return;
+    let binding = null;
+    try {
+        binding = await attachReply(message, data, configFile, options);
+    }
+    catch {
+        context.err('远程回复未就绪；仍尝试发送普通通知。');
+    }
+    const config = await loadConfig(configFile, true, context.env);
+    let covered = { telegram: [], feishu: false };
+    try {
+        covered = await notificationCoverage(data, configFile, config, options);
+    }
+    catch {
+        context.err('无法核验选择题通知覆盖情况；保留普通权限提醒。');
+    }
+    let channels = 0;
+    for (const channel of ['telegram', 'feishu']) {
+        if (!ready(config, channel))
+            continue;
+        channels++;
+        try {
+            if (channel === 'feishu' && covered.feishu)
+                continue;
+            const plan = makePlan(channel, message, config);
+            if (channel === 'telegram' && covered.telegram.length) {
+                plan.items = plan.items.filter(item => !covered.telegram.includes(item.recipient));
+                plan.recipients = new Set(plan.items.map(item => item.recipient)).size;
+                if (!plan.items.length)
+                    continue;
+            }
+            if (binding)
+                mapReplies(plan, binding);
+            const result = await context.send(plan, config);
+            if (!result.ok)
+                context.err(`${channel}: Claude Code 通知未完整发送；不自动重发整条消息。`);
+        }
+        catch {
+            context.err(`${channel}: Claude Code 通知发送失败；请检查配置、系统凭据及网络，不自动重发整条消息。`);
+        }
+    }
+    if (!channels)
+        throw new ConfigError('Claude Code 通知没有可用渠道，请运行 dev-notify doctor 检查');
+}

package/dist/cli.js

@@ -9,18 +9,29 @@ import { deliver, makePlan } from './channels.js';
 import { wizard, clearCredentials } from './setup.js';
 import { terminalPrompts, readText, Cancelled } from './prompts.js';
 import { CredentialError } from './credentials.js';
-const HELP = `dev-notify 0.1.0-alpha.1 — 跨平台开发任务通知
+import { claudeCodeStatus, configureClaudeCode, offerClaudeCode } from './claude-code.js';
+import { dispatchClaudeHook, readHookInput } from './claude-hook.js';
+import { accessReplies, configureReplies, disableReplies } from './reply-state.js';
+import { startBridge, stopBridge, bridgeStatus, runBridge } from './reply-bridge.js';
+const HELP = `dev-notify 0.1.0-alpha.3 — 跨平台开发任务通知
 
 命令：
   send --title 标题 [--content 正文 | --content-file 文件 | --stdin]
        [--channel all|telegram|feishu] [--level info|success|warn|error]
        [--footer 辅助信息] [--dry-run]
-  setup                     交互配置渠道并存入系统凭据，保存后可选测试
-  setup --template [--yes]   仅创建无密钥模板，不覆盖已有配置
+  setup                     配置渠道及系统凭据，可选测试与 Claude Code 通知
+  setup --template [--yes]   仅创建无密钥模板，不覆盖已有配置、不安装 hooks
   credentials clear         确认后移除当前 Node 凭据引用和条目
   paths                     显示配置路径，不写文件
   doctor / status           离线检查，不发消息
-  integration list          显示集成迁移状态
+  integration list          列出可用集成
+  integration claude-code install / status / remove
+                            单独安装、查询或移除用户级 hooks
+  reply setup               另行授权可信 Telegram 私聊用户
+  reply start / status / stop
+                            启动、查询或停止回复桥接
+  reply disable             确认后撤销远程回复授权并请求停止桥接
+  reply run                 前台运行桥接（排错用，不启用系统自启动）
 
 全局选项：--config 路径、--help、--version
 系统凭据使用 Windows Credential Manager / macOS Keychain；不调用 Python，不写入明文密钥。`;
@@ -30,6 +41,7 @@ const defaults = {
     err: text => console.error(text),
     stdin: async () => { const chunks = []; for await (const chunk of process.stdin)
         chunks.push(Buffer.from(chunk)); return Buffer.concat(chunks); },
+    hookStdin: () => readHookInput(),
     confirm: async () => {
         if (!process.stdin.isTTY)
             throw new ConfigError('非交互环境请使用 setup --template --yes');
@@ -39,6 +51,7 @@ const defaults = {
 };
 export async function main(argv = process.argv.slice(2), overrides = {}) {
     const context = { ...defaults, ...overrides };
+    const isHook = argv[0] === 'integration' && argv[1] === 'claude-code' && argv[2] === 'hook';
     try {
         let parsed;
         try {
@@ -58,15 +71,15 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
             return 0;
         }
         if (values.version) {
-            context.out('dev-notify 0.1.0-alpha.1');
+            context.out('dev-notify 0.1.0-alpha.3');
             return 0;
         }
-        const [command, action] = positionals;
+        const [command, action, integrationAction] = positionals;
         const allowed = {
             send: ['title', 'content', 'content-file', 'stdin', 'channel', 'level', 'footer', 'dry-run'],
-            setup: ['template', 'yes'], paths: [], doctor: [], status: [], integration: [], credentials: [],
+            setup: ['template', 'yes'], paths: [], doctor: [], status: [], integration: [], credentials: [], reply: [],
         };
-        if (!command || !Object.hasOwn(allowed, command) || positionals.length > (['integration', 'credentials'].includes(command) ? 2 : 1)
+        if (!command || !Object.hasOwn(allowed, command) || positionals.length > (command === 'integration' ? 3 : command === 'credentials' || command === 'reply' ? 2 : 1)
             || Object.keys(values).some(key => key !== 'config' && !allowed[command].includes(key)))
             throw new ConfigError('命令或选项组合无效，请使用 --help');
         const paths = appPaths(process.platform, context.env);
@@ -76,10 +89,69 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
             return 0;
         }
         if (command === 'integration') {
-            if (action !== 'list')
-                throw new ConfigError('当前只支持 integration list');
-            context.out('claude-code: 尚未迁入 Node 版，未安装 hooks 或启用远程回复');
-            return 0;
+            if (action === 'list' && !integrationAction) {
+                context.out('claude-code: 可选通知集成、Telegram 回复与结构化问题交互；通知 hooks 与 reply setup 输入授权分开，默认不开启远程输入。');
+                return 0;
+            }
+            if (action !== 'claude-code' || !['install', 'status', 'remove', 'hook'].includes(integrationAction))
+                throw new ConfigError('请使用 integration list 或 integration claude-code install / status / remove');
+            if (integrationAction === 'hook') {
+                await dispatchClaudeHook(await context.hookStdin(), file, { ...context, response: value => context.out(JSON.stringify(value)) });
+                return 0;
+            }
+            if (integrationAction === 'status') {
+                const status = await claudeCodeStatus({ env: context.env });
+                context.out(`Claude Code 用户级设置：${status.file}`);
+                context.out(`本工具 hooks：Stop ${status.stop} 个，Notification ${status.notification} 个，会话生命周期 ${status.lifecycle}/3 个，交互及结果确认 ${status.interaction}/5 个；其他处理器 ${status.others} 个。`);
+                context.out(status.disabled ? '当前文件设置了 disableAllHooks；本工具不会解除禁用。'
+                    : '仅检查用户级文件；实际是否加载或受项目、托管策略限制，请在 Claude Code /hooks 中确认。');
+                return status.stop === 1 && status.notification === 1 && status.lifecycle === 3 && status.interaction === 5 && !status.disabled ? 0 : 1;
+            }
+            const prompts = context.prompts ?? terminalPrompts();
+            if (integrationAction === 'install') {
+                const config = await loadConfig(file, true, context.env);
+                if (!ready(config, 'telegram') && !ready(config, 'feishu'))
+                    throw new ConfigError('请先运行 setup 配置可用通知渠道，再安装 Claude Code hooks');
+            }
+            return await configureClaudeCode(file, integrationAction, prompts, { env: context.env }) ? 0 : 130;
+        }
+        if (command === 'reply') {
+            if (!['setup', 'start', 'status', 'stop', 'disable', 'run'].includes(action))
+                throw new ConfigError('请使用 reply setup / start / status / stop / disable / run');
+            if (action === 'setup') {
+                const saved = await configureReplies(file, context.prompts ?? terminalPrompts(), context.env);
+                if (saved)
+                    context.out('授权已保存；请确认已安装本版 hooks，再运行 reply start。新授权不会恢复旧消息映射。');
+                return saved ? 0 : 130;
+            }
+            if (action === 'disable') {
+                if (!await disableReplies(file, context.prompts ?? terminalPrompts()))
+                    return 130;
+                const stopped = await stopBridge(file);
+                context.out(stopped ? '桥接已停止或未运行。' : '已撤销授权并请求停止；正在进行中的调用不能撤回。');
+                return 0;
+            }
+            if (action === 'stop') {
+                const stopped = await stopBridge(file);
+                context.out(stopped ? '桥接已停止或未运行；授权仍保留，下一次事件可再次启动。彻底关闭请用 reply disable。'
+                    : '停止请求已登记；桥接尚未退出，未强杀进程，请用 reply status 检查。');
+                return stopped ? 0 : 1;
+            }
+            if (action === 'status') {
+                const access = await accessReplies(file, context.env), status = await bridgeStatus(file);
+                context.out(access ? `远程回复：已另行授权 ${access.policy.users.length} 个私聊用户；逐次工具权限${access.policy.permissions ? '已启用' : '未启用'}。` : '远程回复：未启用。');
+                context.out(status.ready ? '桥接：已就绪。' : status.running ? '桥接：进程存在但未就绪。' : '桥接：未运行。');
+                if (status.error)
+                    context.err(status.error);
+                return access && status.ready ? 0 : 1;
+            }
+            if (action === 'run') {
+                await runBridge(file, { env: context.env, log: context.err });
+                return 0;
+            }
+            const ready = await startBridge(file, context.env);
+            context.out(ready ? '回复桥接已就绪；请从新任务通知进入。' : '桥接尚未就绪；请用 reply status / reply run 查看安全错误，不要同时运行旧 Python 桥接。');
+            return ready ? 0 : 1;
         }
         if (command === 'credentials') {
             if (action !== 'clear')
@@ -90,8 +162,9 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
             if (!values.template) {
                 if (values.yes)
                     throw new ConfigError('--yes 只允许与 --template 同时使用，不能跳过密钥保存确认');
-                return await wizard(file, {
-                    prompts: context.prompts, env: context.env,
+                const prompts = context.prompts ?? terminalPrompts();
+                const saved = await wizard(file, {
+                    prompts, store: context.store, env: context.env,
                     testSend: async (config) => {
                         let count = 0, ok = true;
                         for (const channel of ['telegram', 'feishu']) {
@@ -105,7 +178,26 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                         }
                         return count > 0 && ok;
                     },
-                }) ? 0 : 130;
+                });
+                if (!saved)
+                    return 130;
+                try {
+                    await offerClaudeCode(file, prompts, { env: context.env });
+                    const config = await loadConfig(file, true, context.env);
+                    if (ready(config, 'telegram') && /^(y|yes)$/i.test(await prompts.text('是否另行配置可信私聊用户回复 Claude？默认关闭。[y/N] '))) {
+                        await configureReplies(file, prompts, context.env);
+                        context.out('回复授权流程结束；确认 hooks 已安装后可运行 reply start，或由下一次支持的会话事件启动。');
+                    }
+                }
+                catch (error) {
+                    if (error instanceof Cancelled) {
+                        context.out('渠道配置已保存；已取消后续 Claude Code 集成/回复配置。');
+                        return 0;
+                    }
+                    context.err('渠道配置已保存，但 Claude Code hook 或回复配置未完成；请运行 integration claude-code status / reply status 检查后重试。');
+                    return 1;
+                }
+                return 0;
             }
             context.out(`将创建无密钥模板: ${file}；不会联网或修改 hooks`);
             if (!values.yes && !await context.confirm()) {
@@ -174,10 +266,11 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
     catch (error) {
         if (error instanceof Cancelled) {
             context.out('已取消，未继续执行。');
-            return 130;
+            return isHook ? 0 : 130;
         }
         context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : '操作失败，请检查文件、权限或输入；不输出可能含秘密的底层异常');
-        return 2;
+        // Stop hook 的退出码 2 会要求 Claude 继续；通知失败只能报告，不能阻塞或触发重试循环。
+        return isHook ? 0 : 2;
     }
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {

package/dist/reply-bridge.js

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { mkdir, open, unlink, realpath } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { appPaths, ConfigError } from './config.js';
+import { accessReplies, atomicJson, readJson, replyDirectory, stateTransaction } from './reply-state.js';
+import { telegramApi } from './reply-telegram.js';
+import { drainReplies, processUpdate } from './reply-engine.js';
+import { drainInteractionFeedback } from './reply-outcomes.js';
+const leasePath = (file) => path.join(replyDirectory(file), 'bridge.json');
+const controlPath = (file) => path.join(replyDirectory(file), 'stop.json');
+function alive(pid) {
+    if (!Number.isSafeInteger(pid) || Number(pid) <= 0)
+        return false;
+    try {
+        process.kill(Number(pid), 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function bridgeStatus(file) {
+    const lease = await readJson(leasePath(file));
+    const running = !!lease && alive(lease.pid) && Date.now() - lease.updated < 30000;
+    return { running, ready: !!lease?.ready && running, error: lease?.error };
+}
+export async function stopBridge(file) {
+    const lease = await readJson(leasePath(file));
+    if (!lease || !alive(lease.pid))
+        return true;
+    // 不按可复用 PID 杀进程；只有持有本次 owner 的桥接响应此控制文件。
+    await atomicJson(controlPath(file), { owner: lease.owner });
+    for (let attempt = 0; attempt < 16; attempt++) {
+        await delay(250);
+        const current = await readJson(leasePath(file));
+        if (!current || current.owner !== lease.owner || !alive(current.pid))
+            return true;
+    }
+    return false;
+}
+export async function startBridge(file, env = process.env) {
+    const access = await accessReplies(file, env);
+    if (!access)
+        throw new ConfigError('远程回复未授权，请先运行 reply setup');
+    const existing = await bridgeStatus(file);
+    if (existing.running)
+        return existing.ready;
+    const node = await realpath(process.execPath), cli = await realpath(fileURLToPath(new URL('./cli.js', import.meta.url)));
+    // 无 shell、无命令行秘密、无系统开机自启；worker 自己持有排他锁。
+    const child = spawn(node, [cli, 'reply', 'run', '--config', path.resolve(file)], {
+        detached: true, windowsHide: true, shell: false, stdio: 'ignore', env: { ...process.env, ...env },
+    });
+    let failed = false;
+    child.once('error', () => { failed = true; });
+    child.unref();
+    for (let attempt = 0; attempt < 20; attempt++) {
+        await delay(150);
+        if (failed)
+            return false;
+        const status = await bridgeStatus(file);
+        if (status.ready)
+            return true;
+        if (status.error)
+            return false;
+    }
+    return false;
+}
+export async function runBridge(file, options = {}) {
+    const env = options.env ?? process.env;
+    let access = await accessReplies(file, env);
+    if (!access)
+        throw new ConfigError('远程回复未授权');
+    const directory = replyDirectory(file);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const botDirectory = path.join(appPaths(process.platform, env).data, 'reply-bots');
+    await mkdir(botDirectory, { recursive: true, mode: 0o700 });
+    const lockPath = path.join(botDirectory, access.policy.bot + '.lock');
+    let lock;
+    try {
+        lock = await open(lockPath, 'wx', 0o600);
+    }
+    catch {
+        throw new ConfigError('本用户已有相同 Bot 桥接或残留锁；不会并发轮询。确认进程退出后再处理 reply-bots 中对应锁');
+    }
+    const owner = randomBytes(16).toString('hex'), lease = { pid: process.pid, owner, ready: false, updated: Date.now() };
+    let stopping = false;
+    const stop = () => { stopping = true; };
+    process.on('SIGTERM', stop);
+    process.on('SIGINT', stop);
+    const fresh = async () => await isStopped() ? null : accessReplies(file, env);
+    const log = options.log ?? (() => { });
+    let lastActivity = Date.now();
+    const isStopped = async () => stopping || options.stopped?.() === true || (await readJson(controlPath(file)))?.owner === owner;
+    try {
+        await lock.writeFile(JSON.stringify({ pid: process.pid, owner }));
+        await atomicJson(leasePath(file), lease);
+        let api = (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
+        const webhook = await api('getWebhookInfo', {});
+        if (webhook?.url)
+            throw new ConfigError('Bot 已设置 webhook，不能同时使用 getUpdates；不会自动删除 webhook');
+        await api('getMe', {});
+        const currentState = await stateTransaction(access, state => ({ offset: state.offset, empty: Object.keys(state.entries).length === 0 }));
+        if (!currentState.offset && currentState.empty) {
+            const old = await api('getUpdates', { offset: -1, timeout: 0, allowed_updates: ['message', 'callback_query'] });
+            if (Array.isArray(old) && old.length)
+                await stateTransaction(access, state => {
+                    const id = old[old.length - 1]?.update_id;
+                    if (Number.isSafeInteger(id))
+                        state.offset = Math.max(state.offset, id + 1);
+                });
+        }
+        lease.ready = true;
+        lease.updated = Date.now();
+        await atomicJson(leasePath(file), lease);
+        let iteration = 0, failures = 0;
+        while (!await isStopped() && iteration++ < (options.maxIterations ?? Infinity)) {
+            const current = await fresh();
+            if (!current)
+                break;
+            if (current.identity !== access.identity) {
+                // 修改授权或 Bot 必须重启并重新核验，丢弃旧长轮询结果。
+                break;
+            }
+            access = current;
+            api = (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
+            const context = { api, fresh, validate: options.validate, inject: options.inject };
+            await drainReplies(access, context);
+            await drainInteractionFeedback(access, api, fresh, log);
+            if (await isStopped())
+                break;
+            const offset = await stateTransaction(access, state => state.offset);
+            let updates;
+            try {
+                updates = await api('getUpdates', { offset, timeout: 2, allowed_updates: ['message', 'callback_query'] });
+            }
+            catch (error) {
+                if (error instanceof ConfigError && /冲突/.test(error.message))
+                    throw error;
+                log('Telegram 轮询失败；秘密和服务端正文未记录。');
+                if (++failures >= 5)
+                    throw new ConfigError('Telegram 连续轮询失败 5 次，桥接已退出；请检查网络、Token 或 API 冲突后重新启动');
+                lease.updated = Date.now();
+                await atomicJson(leasePath(file), lease);
+                await (options.sleep ?? delay)(3000);
+                continue;
+            }
+            failures = 0;
+            const after = await fresh();
+            if (!after || after.identity !== access.identity || await isStopped())
+                break;
+            if (!Array.isArray(updates))
+                throw new ConfigError('Telegram 更新格式无效');
+            for (const update of updates) {
+                if (await isStopped())
+                    break;
+                try {
+                    await processUpdate(access, update, context);
+                }
+                catch {
+                    log('回复处理失败；更新不重放，请检查终端或从最新通知重试。');
+                }
+            }
+            if (updates.length)
+                lastActivity = Date.now();
+            lease.updated = Date.now();
+            await atomicJson(leasePath(file), lease);
+            if (Date.now() - lastActivity > 24 * 60 * 60 * 1000)
+                break;
+        }
+    }
+    catch (error) {
+        lease.ready = false;
+        lease.error = error instanceof ConfigError ? error.message : '桥接启动或运行失败，未输出底层错误';
+        await atomicJson(leasePath(file), lease).catch(() => { });
+        throw error;
+    }
+    finally {
+        process.off('SIGTERM', stop);
+        process.off('SIGINT', stop);
+        const current = await readJson(leasePath(file)).catch(() => null);
+        if (current?.owner === owner && !lease.error)
+            await unlink(leasePath(file)).catch(() => { });
+        await lock.close();
+        await unlink(lockPath);
+    }
+}