@actiondock/core 2.10.0 → 2.12.0

package/dist/service/remote.js

@@ -1,11 +1,13 @@
 import { parseActionRef } from "../catalog/resolve-action.js";
 import { ActionDockError, ACTION_CANCELLED, CAPABILITY_UNAVAILABLE, INVALID_ARGUMENT, TIMEOUT, } from "../errors.js";
-import { cancelRemoteRun, clearRemoteRuns, cleanExpiredRemoteRuns, clearRemoteState, deleteRemoteConfig, deleteRemoteStateKey, executeRemoteAction, fetchRemoteActionShow, fetchRemoteActions, fetchRemoteConfig, fetchRemoteInfo, fetchRemotePlaybookShow, fetchRemotePlaybooks, fetchRemoteRun, fetchRemoteRuns, fetchRemoteStateList, getRemoteStateKey, setRemoteConfig, setRemoteStateKey, } from "../profile/client.js";
+import { createAbortError } from "../ipc/service.js";
+import { cancelRemoteRun, clearRemoteRuns, cleanExpiredRemoteRuns, clearRemoteState, deleteRemoteConfig, deleteRemoteStateKey, executeRemoteAction, fetchRemoteActionShow, fetchRemoteActions, fetchRemoteConfig, fetchRemoteInfo, fetchRemotePlaybookShow, fetchRemotePlaybooks, fetchRemoteRun, fetchRemoteRuns, fetchRemoteStateList, getRemoteStateKey, setRemoteConfig, setRemoteStateKey, } from "../client/index.js";
 import { isRemoteStateKeyNotFound, wrapRemoteError } from "./remote-errors.js";
 import { formatTerminalRunResult, pollRunCompletion } from "./remote-polling.js";
 import { streamRemoteEvents } from "./sse-stream.js";
+import { SystemClock } from "../storage/clock.js";
 import { isTerminalRunStatus } from "../storage/types.js";
-import { ACTIONDOCK_PROTOCOL_VERSION, PROTOCOL_UNSUPPORTED, SERVICE_CLOSED, ServiceError, } from "./types.js";
+import { ACTIONDOCK_PROTOCOL_VERSION, PROTOCOL_UNSUPPORTED, SERVICE_CLOSED, } from "./types.js";
 /**
  * 远程 ActionDockService 端口实现。
  * 封装与远端 ActionDock 服务的 HTTP / SSE 协议交互，
@@ -19,6 +21,7 @@ export class RemoteActionDockService {
     allowInsecureHttp;
     insecure;
     dispatcher;
+    clock;
     isClosed = false;
     discovery;
     execution;
@@ -36,6 +39,7 @@ export class RemoteActionDockService {
         this.allowInsecureHttp = options.allowInsecureHttp;
         this.insecure = options.insecure;
         this.dispatcher = options.dispatcher;
+        this.clock = options.clock ?? new SystemClock();
         const self = this;
         this.discovery = {
             async listPackages() {
@@ -56,7 +60,7 @@ export class RemoteActionDockService {
                     const [remoteMajor] = protocolVersion.split(".");
                     const [currentMajor] = ACTIONDOCK_PROTOCOL_VERSION.split(".");
                     if (remoteMajor !== currentMajor) {
-                        throw new ServiceError(PROTOCOL_UNSUPPORTED, `PROTOCOL_UNSUPPORTED: Remote server protocol version '${protocolVersion}' is incompatible with expected '${ACTIONDOCK_PROTOCOL_VERSION}'`);
+                        throw new ActionDockError(PROTOCOL_UNSUPPORTED, `PROTOCOL_UNSUPPORTED: Remote server protocol version '${protocolVersion}' is incompatible with expected '${ACTIONDOCK_PROTOCOL_VERSION}'`);
                     }
                 }
                 if (Array.isArray(raw)) {
@@ -224,35 +228,121 @@ export class RemoteActionDockService {
             },
         };
         this.runs = {
-            async list(query) {
+            async list(query, options) {
                 self.assertNotClosed();
+                const effectiveSignal = options?.signal ?? query?.signal;
+                try {
+                    const SERVER_MAX_PAGE_SIZE = 500;
+                    const SERVER_MAX_OFFSET = 100_000;
+                    if (query?.offset !== undefined && (query.offset < 0 || query.offset > SERVER_MAX_OFFSET || !Number.isSafeInteger(query.offset))) {
+                        throw new ActionDockError(INVALID_ARGUMENT, `Invalid offset '${query.offset}': must be a non-negative safe integer <= ${SERVER_MAX_OFFSET}`);
+                    }
+                    const requestedLimit = query?.limit;
+                    let offset = query?.offset ?? 0;
+                    const allItems = [];
+                    while (true) {
+                        if (effectiveSignal?.aborted) {
+                            throw createAbortError(effectiveSignal.reason);
+                        }
+                        if (offset > SERVER_MAX_OFFSET) {
+                            throw new ActionDockError(INVALID_ARGUMENT, `Invalid offset '${offset}': must be a non-negative safe integer <= ${SERVER_MAX_OFFSET}`);
+                        }
+                        let batchLimit = SERVER_MAX_PAGE_SIZE;
+                        if (requestedLimit !== undefined) {
+                            const remaining = requestedLimit - allItems.length;
+                            if (remaining <= 0) {
+                                break;
+                            }
+                            batchLimit = Math.min(remaining, SERVER_MAX_PAGE_SIZE);
+                        }
+                        const res = await fetchRemoteRuns(self.serverUrl, self.token, {
+                            packageId: query?.packageId,
+                            actionId: query?.actionId,
+                            status: query?.status,
+                            intent: query?.intent,
+                            limit: batchLimit,
+                            offset,
+                            requestIds: query?.requestIds,
+                            allowInsecureHttp: self.allowInsecureHttp,
+                            insecure: self.insecure,
+                            dispatcher: self.dispatcher,
+                            signal: effectiveSignal,
+                        });
+                        if (effectiveSignal?.aborted) {
+                            throw createAbortError(effectiveSignal.reason);
+                        }
+                        const items = res.items || [];
+                        if (items.length === 0) {
+                            break;
+                        }
+                        allItems.push(...items);
+                        offset += items.length;
+                        if (requestedLimit !== undefined && allItems.length >= requestedLimit) {
+                            break;
+                        }
+                        if (typeof res.total === "number" && offset >= res.total) {
+                            break;
+                        }
+                        if (items.length < batchLimit) {
+                            break;
+                        }
+                        if (offset > SERVER_MAX_OFFSET) {
+                            throw new ActionDockError(INVALID_ARGUMENT, `Invalid offset '${offset}': must be a non-negative safe integer <= ${SERVER_MAX_OFFSET}`);
+                        }
+                    }
+                    return allItems;
+                }
+                catch (err) {
+                    if (effectiveSignal?.aborted || err?.name === "AbortError") {
+                        throw createAbortError(effectiveSignal?.reason ?? err);
+                    }
+                    wrapRemoteError(err);
+                }
+            },
+            async count(query, options) {
+                self.assertNotClosed();
+                const effectiveSignal = options?.signal ?? query?.signal;
                 try {
                     const res = await fetchRemoteRuns(self.serverUrl, self.token, {
                         packageId: query?.packageId,
                         actionId: query?.actionId,
                         status: query?.status,
                         intent: query?.intent,
-                        limit: query?.limit,
+                        limit: 1,
+                        offset: 0,
+                        requestIds: query?.requestIds,
                         allowInsecureHttp: self.allowInsecureHttp,
                         insecure: self.insecure,
                         dispatcher: self.dispatcher,
+                        signal: effectiveSignal,
                     });
-                    return res.items || [];
+                    if (typeof res.total === "number") {
+                        return res.total;
+                    }
+                    const all = await self.runs.list({ ...query, limit: undefined, offset: undefined }, options);
+                    return all.length;
                 }
                 catch (err) {
+                    if (effectiveSignal?.aborted || err?.name === "AbortError") {
+                        throw createAbortError(effectiveSignal?.reason ?? err);
+                    }
                     wrapRemoteError(err);
                 }
             },
-            async get(runId) {
+            async get(runId, options) {
                 self.assertNotClosed();
                 try {
                     return await fetchRemoteRun(self.serverUrl, runId, self.token, {
                         allowInsecureHttp: self.allowInsecureHttp,
                         insecure: self.insecure,
                         dispatcher: self.dispatcher,
+                        signal: options?.signal,
                     });
                 }
                 catch (err) {
+                    if (options?.signal?.aborted || err?.name === "AbortError") {
+                        throw createAbortError(options?.signal?.reason ?? err);
+                    }
                     const code = String(err?.code || "");
                     if (code === "RUN_NOT_FOUND" || code === "NOT_FOUND" || err?.status === 404) {
                         return undefined;
@@ -426,7 +516,7 @@ export class RemoteActionDockService {
                         try {
                             const res = await getRemoteStateKey(self.serverUrl, key, self.token, {
                                 package: packageId || undefined,
-                                action: actionId || undefined,
+                                action: actionId ?? undefined,
                                 namespace: opts?.namespace,
                                 allowInsecureHttp: self.allowInsecureHttp,
                                 insecure: self.insecure,
@@ -451,7 +541,7 @@ export class RemoteActionDockService {
                         try {
                             await setRemoteStateKey(self.serverUrl, key, value, self.token, {
                                 package: packageId || undefined,
-                                action: actionId || undefined,
+                                action: actionId ?? undefined,
                                 namespace: opts?.namespace,
                                 ttl: opts?.ttl,
                                 allowInsecureHttp: self.allowInsecureHttp,
@@ -468,7 +558,7 @@ export class RemoteActionDockService {
                         try {
                             const res = await deleteRemoteStateKey(self.serverUrl, key, self.token, {
                                 package: packageId || undefined,
-                                action: actionId || undefined,
+                                action: actionId ?? undefined,
                                 namespace: opts?.namespace,
                                 allowInsecureHttp: self.allowInsecureHttp,
                                 insecure: self.insecure,
@@ -488,7 +578,7 @@ export class RemoteActionDockService {
                         try {
                             const res = await fetchRemoteStateList(self.serverUrl, self.token, {
                                 package: packageId || undefined,
-                                action: actionId || undefined,
+                                action: actionId ?? undefined,
                                 namespace: opts?.namespace,
                                 prefix: opts?.prefix,
                                 allowInsecureHttp: self.allowInsecureHttp,
@@ -506,7 +596,7 @@ export class RemoteActionDockService {
                         try {
                             const res = await clearRemoteState(self.serverUrl, self.token, {
                                 package: packageId || undefined,
-                                action: actionId || undefined,
+                                action: actionId ?? undefined,
                                 namespace: opts?.namespace,
                                 prefix: opts?.prefix,
                                 all: opts?.all,
@@ -522,7 +612,7 @@ export class RemoteActionDockService {
                     },
                     async listEntries(_packageId, _opts) {
                         self.assertNotClosed();
-                        throw new ServiceError(CAPABILITY_UNAVAILABLE, "CAPABILITY_UNAVAILABLE: listStateEntries is not supported on remote service");
+                        throw new ActionDockError(CAPABILITY_UNAVAILABLE, "CAPABILITY_UNAVAILABLE: listStateEntries is not supported on remote service");
                     },
                 },
             };
@@ -530,14 +620,14 @@ export class RemoteActionDockService {
     }
     assertNotClosed() {
         if (this.isClosed) {
-            throw new ServiceError(SERVICE_CLOSED, "RemoteActionDockService is closed");
+            throw new ActionDockError(SERVICE_CLOSED, "RemoteActionDockService is closed");
         }
     }
     async info() {
         return this.discovery.listPackages();
     }
     async waitForRunCompletion(runId, signal, timeoutMs) {
-        const startTime = Date.now();
+        const startTime = this.clock.monotonic();
         const maxWaitMs = Math.max(this.baseTimeoutMs, timeoutMs ?? 0);
         // 服务已关闭时的统一失败结果
         const closedResult = () => ({
@@ -607,7 +697,7 @@ export class RemoteActionDockService {
         if (signal?.aborted) {
             return cancelledResult();
         }
-        const remainingWaitMs = Math.max(0, maxWaitMs - (Date.now() - startTime));
+        const remainingWaitMs = Math.max(0, maxWaitMs - (this.clock.monotonic() - startTime));
         if (remainingWaitMs <= 0) {
             if (this.isClosed) {
                 return closedResult();
@@ -624,7 +714,7 @@ export class RemoteActionDockService {
                 }
                 throw err;
             }
-            const waitedMs = Date.now() - startTime;
+            const waitedMs = Math.round(this.clock.monotonic() - startTime);
             return {
                 ok: false,
                 runId,
@@ -638,6 +728,7 @@ export class RemoteActionDockService {
             baseTimeoutMs: this.baseTimeoutMs,
             isClosed: () => this.isClosed,
             getRun: (id) => this.runs.get(id),
+            clock: this.clock,
         }, runId, signal, remainingWaitMs, startTime, maxWaitMs);
     }
     async close(_options) {

package/dist/service/sse-stream.js

@@ -1,7 +1,7 @@
 import { ActionDockError, EVENT_CURSOR_EXPIRED, REMOTE_STREAM_UNAVAILABLE } from "../errors.js";
-import { assertSecureTransport } from "../profile/client.js";
+import { assertSecureTransport } from "../client/index.js";
 import { normalizeServerUrl } from "../profile/manager.js";
-import { getInsecureDispatcher } from "../server/dispatcher.js";
+import { getInsecureDispatcher } from "../client/dispatcher.js";
 import { parseSseMessages } from "./sse-parser.js";
 /**
  * 将 SSE 消息载荷解码为统一执行事件。

package/dist/service/types.d.ts

@@ -4,7 +4,7 @@ import type { CancelResult, ExecutionTicket } from "../execution/types.js";
 import type { ActionDockHostOptions } from "../host/types.js";
 import type { RuntimePlatform } from "../platform/types.js";
 import type { StateEntry } from "../storage/types.js";
-import { ActionDockError, type ErrorCode, PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, SERVICE_CLOSED } from "../errors.js";
+import { PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, SERVICE_CLOSED } from "../errors.js";
 /**
  * 公开运行控制选项（RunOptions）。
  * 面向外部调用方的公开契约，彻底剥离内部 Lineage 字段，严禁污染内部运行时状态。
@@ -27,20 +27,6 @@ export declare const ACTIONDOCK_PROTOCOL_VERSION = "2.0";
  * 服务端/通信协议错误码常量（单一事实源引用自 errors.ts）。
  */
 export { PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, SERVICE_CLOSED };
-/**
- * 结构化服务通信异常类。
- */
-export declare class ServiceError extends ActionDockError {
-    readonly details?: Record<string, unknown>;
-    constructor(code: ErrorCode, message: string, details?: Record<string, unknown>);
-}
-/**
- * 服务关闭超时异常类。
- */
-export declare class CloseTimeoutError extends Error {
-    readonly runIds?: string[];
-    constructor(message?: string, runIds?: string[]);
-}
 /**
  * 配置项安全视图契约。
  * 屏蔽敏感配置原文，仅暴露是否已配置、是否为秘密及实际解析来源。
@@ -86,8 +72,23 @@ export interface ListRunsOptions {
     status?: string;
     /** 模糊意图检索模式 */
     intent?: string;
+    /** 幂等请求标识集合（经 idempotency_keys 反查关联运行记录） */
+    requestIds?: string[];
+    /** 偏移游标条数（跳过的记录数） */
+    offset?: number;
     /** 最大返回记录条数限制 */
     limit?: number;
+    /** 取消信号，用于中止读取请求 */
+    signal?: AbortSignal;
+    /** 包白名单过滤集合（可选） */
+    packageAllowlist?: string[];
+}
+/**
+ * 运行记录读取控制选项。
+ */
+export interface RunReadOptions {
+    /** 取消信号，用于中止读取请求 */
+    signal?: AbortSignal;
 }
 /**
  * 远程服务连接配置选项。
@@ -160,9 +161,11 @@ export interface EventsPort {
  */
 export interface RunsPort {
     /** 查询任务执行记录列表 */
-    list(query?: ListRunsOptions): Promise<RunRecord[]>;
+    list(query?: ListRunsOptions, options?: RunReadOptions): Promise<RunRecord[]>;
+    /** 统计符合条件的任务执行记录总数 */
+    count?(query?: ListRunsOptions, options?: RunReadOptions): Promise<number>;
     /** 查询指定运行标识的记录详情 */
-    get(runId: string): Promise<RunRecord | undefined>;
+    get(runId: string, options?: RunReadOptions): Promise<RunRecord | undefined>;
     /** 取消指定在运行的任务 */
     cancel(runId: string, reason?: string): Promise<CancelResult>;
     /** 清空历史任务运行记录 */
@@ -200,9 +203,9 @@ export interface StatePort {
     /** 删除指定包指定动作的作用域状态项 */
     delete(packageId: string, actionId: string, key: string, options?: StateScopeOptions): Promise<boolean>;
     /** 列出指定包指定动作在存储中的状态键名列表 */
-    list(packageId: string, actionId: string, options?: StateScopeOptions): Promise<string[]>;
+    list(packageId: string, actionId?: string, options?: StateScopeOptions): Promise<string[]>;
     /** 清空指定包指定动作在存储中的状态条目 */
-    clear(packageId: string, actionId: string, options?: StateScopeOptions): Promise<number>;
+    clear(packageId: string, actionId?: string, options?: StateScopeOptions): Promise<number>;
     /** 列出指定包在存储中的状态条目（含完整元数据） */
     listEntries?(packageId: string, options?: any): Promise<StateEntry[]>;
 }

package/dist/service/types.js

@@ -1,4 +1,4 @@
-import { ActionDockError, PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, SERVICE_CLOSED, } from "../errors.js";
+import { PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, SERVICE_CLOSED, } from "../errors.js";
 /**
  * 统一协议版本常量。
  */
@@ -7,26 +7,3 @@ export const ACTIONDOCK_PROTOCOL_VERSION = "2.0";
  * 服务端/通信协议错误码常量（单一事实源引用自 errors.ts）。
  */
 export { PROTOCOL_UNSUPPORTED, SERVICE_RESULT_UNKNOWN, SERVICE_CLOSED };
-/**
- * 结构化服务通信异常类。
- */
-export class ServiceError extends ActionDockError {
-    details;
-    constructor(code, message, details) {
-        super(code, message, details);
-        this.name = "ServiceError";
-        this.details = details;
-        Object.setPrototypeOf(this, ServiceError.prototype);
-    }
-}
-/**
- * 服务关闭超时异常类。
- */
-export class CloseTimeoutError extends Error {
-    runIds;
-    constructor(message = "Service close operation timed out", runIds) {
-        super(message);
-        this.name = "CloseTimeoutError";
-        this.runIds = runIds;
-    }
-}

package/dist/storage/clock.d.ts

@@ -1,7 +1,7 @@
 /**
  * 统一时间与时钟基础契约。
  *
- * 单一事实源：Clock 接口与 SystemClock 实现定义于此，runtime/clock.ts 与
+ * 单一事实源：Clock 接口与 SystemClock 实现定义于此，
  * storage/types.ts 一律从本文件引用或转发，禁止重复实现。
  */
 /**

package/dist/storage/clock.js

@@ -1,7 +1,7 @@
 /**
  * 统一时间与时钟基础契约。
  *
- * 单一事实源：Clock 接口与 SystemClock 实现定义于此，runtime/clock.ts 与
+ * 单一事实源：Clock 接口与 SystemClock 实现定义于此，
  * storage/types.ts 一律从本文件引用或转发，禁止重复实现。
  */
 /**

package/dist/storage/data-dir-lock.d.ts

@@ -1,4 +1,5 @@
-import { cleanStaleQuarantines, isProcessAlive, parseQuarantineTimestamp, safeRemoveStaleReclaimGuard, safeRollbackLock } from "./lock-core.js";
+import { isProcessAlive } from "../utils/index.js";
+import { type FileLockHandle } from "./file-lock.js";
 /**
  * 数据目录排他锁元数据契约。
  */
@@ -9,7 +10,7 @@ export interface DataDirLockInfo {
     hostname: string;
     /** 宿主会话令牌 */
     sessionToken: string;
-    /** 内部排他锁令牌（用于防护伪造 sessionToken 的所有权隔离） */
+    /** 内部排他锁令牌 */
     lockToken?: string;
     /** 创建时间戳（ISO 8601 格式） */
     createdAt: string;
@@ -18,12 +19,11 @@ export interface DataDirLockInfo {
     /** 宿主会话标识 */
     hostSessionId?: string;
 }
-export { isProcessAlive, parseQuarantineTimestamp, cleanStaleQuarantines, safeRemoveStaleReclaimGuard, safeRollbackLock, };
+export { isProcessAlive };
 /**
- * 安全释放主锁。
- * 仅当锁目录中持有当前 lockToken / sessionToken 时才删除，杜绝删除他人新锁。
+ * 安全释放主锁（兼容导出）。
  */
-export declare function safeReleaseLock(lockPath: string, expectedSessionToken: string, expectedLockToken?: string): void;
+export declare function safeReleaseLock(lockPath: string, expectedSessionToken?: string, expectedLockToken?: string): void;
 /**
  * 数据目录排他文件锁管理器。
  * 负责在数据目录下维护 .actiondock.data.lock 排他文件锁，记录宿主进程与子进程运行状态，
@@ -32,8 +32,9 @@ export declare function safeReleaseLock(lockPath: string, expectedSessionToken:
 export declare class DataDirLock {
     private readonly lockDirPath;
     private readonly info;
+    private readonly handle?;
     private released;
-    constructor(lockDirPath: string, info: DataDirLockInfo);
+    constructor(lockDirPath: string, info: DataDirLockInfo, handle?: FileLockHandle);
     /**
      * 获取当前排他锁元数据信息。
      */
@@ -52,7 +53,6 @@ export declare class DataDirLock {
     unregisterChildPid(pid: number): void;
     /**
      * 将当前锁元数据刷新持久化至磁盘文件。
-     * 先写入临时文件再通过 renameSync 原子替换，消除 truncate 空文件窗口。
      */
     private flush;
     /**
@@ -60,20 +60,8 @@ export declare class DataDirLock {
      */
     release(): void;
     /**
-     * 尝试获取指定数据目录的排他锁。
-     *
-     * 仲裁规则由目录锁内核（lock-core）统一承载：
-     * - 引入所有竞争者均遵守的原子 reclaim guard 机制（lockDirPath.reclaim），每个 guard 具备全局唯一 guardToken。
-     * - 基于原子目录创建 mkdirSync(lockDirPath, { mode: 0o700 }) 确立所有权，并在其下存放 metadata.json。
-     * - 兼容已有常规文件锁（如老版本或测试 mock 场景）。
-     * - 若检测到 reclaim guard 存在且处于宽限期内或持有者存活，必须等待，禁止抢先创建主锁。
-     * - 若锁目录已存在，通过宽限期机制防止将并发写入中的元数据误判为锁死亡。
-     * - 若主进程仍处于存活状态，抛出 DATA_DIR_IN_USE 错误拒绝并发启动。
-     * - 若主进程已退出但仍有子进程存活，抛出 DATA_DIR_RECOVERY_REQUIRED 错误。
-     * - 当识别到主锁为陈旧锁时，竞争者必须先原子竞争获取 reclaim guard。
-     * - 仅成功获取 reclaim guard 的唯一胜利者获准执行：复核主锁陈旧性 -> 验证并清理陈旧主锁 -> 原子创建新主锁并写入自身元数据 -> 清理 reclaim guard。
-     * - 竞争失败者等待并 continue 重试；若 reclaim guard 持有者意外崩溃，其他竞争者在超过宽限期且 PID 已死后通过 safeRemoveStaleReclaimGuard 核对 guardToken 并清理。
-     * - 严禁在获取新主锁遇到 EEXIST 时盲目 rmSync；后检发现他人活跃 guard 时，仅通过 safeRollbackLock 核对自身 sessionToken 回滚自身锁。
+     * 获取指定数据目录的排他锁。
+     * 基于统一轻量文件锁原语实现，非阻塞且支持原子抢占与崩溃恢复。
      *
      * @param dataDir 目标数据存储目录物理绝对路径
      * @param options 锁配置参数

package/dist/storage/data-dir-lock.js

@@ -1,17 +1,17 @@
 import { existsSync, mkdirSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { hostname } from "node:os";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { DATA_DIR_IN_USE, DATA_DIR_RECOVERY_REQUIRED } from "../errors.js";
-import { acquireDirectoryLock, cleanStaleQuarantines, isProcessAlive, parseQuarantineTimestamp, safeReleaseLock as coreSafeReleaseLock, safeRemoveStaleReclaimGuard, safeRollbackLock, } from "./lock-core.js";
+import { isProcessAlive } from "../utils/index.js";
+import { acquireFileLockSync, safeReleaseFileLockSync, } from "./file-lock.js";
 const LOCK_DIR_NAME = ".actiondock.data.lock";
-export { isProcessAlive, parseQuarantineTimestamp, cleanStaleQuarantines, safeRemoveStaleReclaimGuard, safeRollbackLock, };
+export { isProcessAlive };
 /**
- * 安全释放主锁。
- * 仅当锁目录中持有当前 lockToken / sessionToken 时才删除，杜绝删除他人新锁。
+ * 安全释放主锁（兼容导出）。
  */
 export function safeReleaseLock(lockPath, expectedSessionToken, expectedLockToken) {
-    coreSafeReleaseLock(lockPath, expectedSessionToken, expectedLockToken);
+    safeReleaseFileLockSync(lockPath, expectedLockToken, expectedSessionToken);
 }
 /**
  * 数据目录排他文件锁管理器。
@@ -21,10 +21,12 @@ export function safeReleaseLock(lockPath, expectedSessionToken, expectedLockToke
 export class DataDirLock {
     lockDirPath;
     info;
+    handle;
     released = false;
-    constructor(lockDirPath, info) {
+    constructor(lockDirPath, info, handle) {
         this.lockDirPath = lockDirPath;
         this.info = info;
+        this.handle = handle;
     }
     /**
      * 获取当前排他锁元数据信息。
@@ -65,7 +67,6 @@ export class DataDirLock {
     }
     /**
      * 将当前锁元数据刷新持久化至磁盘文件。
-     * 先写入临时文件再通过 renameSync 原子替换，消除 truncate 空文件窗口。
      */
     flush() {
         try {
@@ -91,9 +92,6 @@ export class DataDirLock {
             }
         }
         catch (err) {
-            // 元数据刷新失败不可中断宿主启动，但绝不能静默吞没：childPids 是
-            // DATA_DIR_RECOVERY_REQUIRED 判定的唯一依据，丢失会使恢复决策退化为直接接管。
-            // 输出单行告警携带原因，保证降级事件可观测。
             const reason = err instanceof Error ? err.message : String(err);
             console.warn(`[actiondock] data dir lock metadata flush failed (lock='${this.lockDirPath}'): ${reason}`);
         }
@@ -105,30 +103,21 @@ export class DataDirLock {
         if (this.released)
             return;
         this.released = true;
-        coreSafeReleaseLock(this.lockDirPath, this.info.sessionToken, this.info.lockToken);
-        cleanStaleQuarantines(dirname(this.lockDirPath), LOCK_DIR_NAME);
+        if (this.handle) {
+            this.handle.release();
+        }
+        else {
+            safeReleaseFileLockSync(this.lockDirPath, this.info.lockToken, this.info.sessionToken);
+        }
     }
     /**
-     * 尝试获取指定数据目录的排他锁。
-     *
-     * 仲裁规则由目录锁内核（lock-core）统一承载：
-     * - 引入所有竞争者均遵守的原子 reclaim guard 机制（lockDirPath.reclaim），每个 guard 具备全局唯一 guardToken。
-     * - 基于原子目录创建 mkdirSync(lockDirPath, { mode: 0o700 }) 确立所有权，并在其下存放 metadata.json。
-     * - 兼容已有常规文件锁（如老版本或测试 mock 场景）。
-     * - 若检测到 reclaim guard 存在且处于宽限期内或持有者存活，必须等待，禁止抢先创建主锁。
-     * - 若锁目录已存在，通过宽限期机制防止将并发写入中的元数据误判为锁死亡。
-     * - 若主进程仍处于存活状态，抛出 DATA_DIR_IN_USE 错误拒绝并发启动。
-     * - 若主进程已退出但仍有子进程存活，抛出 DATA_DIR_RECOVERY_REQUIRED 错误。
-     * - 当识别到主锁为陈旧锁时，竞争者必须先原子竞争获取 reclaim guard。
-     * - 仅成功获取 reclaim guard 的唯一胜利者获准执行：复核主锁陈旧性 -> 验证并清理陈旧主锁 -> 原子创建新主锁并写入自身元数据 -> 清理 reclaim guard。
-     * - 竞争失败者等待并 continue 重试；若 reclaim guard 持有者意外崩溃，其他竞争者在超过宽限期且 PID 已死后通过 safeRemoveStaleReclaimGuard 核对 guardToken 并清理。
-     * - 严禁在获取新主锁遇到 EEXIST 时盲目 rmSync；后检发现他人活跃 guard 时，仅通过 safeRollbackLock 核对自身 sessionToken 回滚自身锁。
+     * 获取指定数据目录的排他锁。
+     * 基于统一轻量文件锁原语实现，非阻塞且支持原子抢占与崩溃恢复。
      *
      * @param dataDir 目标数据存储目录物理绝对路径
      * @param options 锁配置参数
      */
     static acquire(dataDir, options = {}) {
-        const timeoutMs = options.acquireTimeoutMs ?? 5000;
         if (!existsSync(dataDir)) {
             mkdirSync(dataDir, { recursive: true, mode: 0o700 });
         }
@@ -144,45 +133,28 @@ export class DataDirLock {
             childPids: [],
             hostSessionId: options.hostSessionId,
         };
-        const content = JSON.stringify(newLockInfo, null, 2);
-        return acquireDirectoryLock({
-            lockPath: lockDirPath,
-            parentDir: dataDir,
-            basePrefix: LOCK_DIR_NAME,
-            metadataContent: content,
-            sessionToken: token,
-            lockToken,
-            acquireTimeoutMs: options.acquireTimeoutMs,
-            createLockError(message) {
-                const timeoutErr = new Error(message);
-                timeoutErr.code = DATA_DIR_IN_USE;
-                return timeoutErr;
-            },
-            messages: {
-                timeoutWaitingReclaimGuard: (holderPid) => `DATA_DIR_IN_USE: Timeout waiting for active reclaim guard (PID ${holderPid ?? "unknown"}) on data directory '${dataDir}' after ${timeoutMs}ms`,
-                timeoutAcquireBlockedByGuard: (holderPid) => `DATA_DIR_IN_USE: Timeout acquiring lock on data directory '${dataDir}' due to active reclaim guard (PID ${holderPid}) after ${timeoutMs}ms`,
-                timeoutAcquire: () => `DATA_DIR_IN_USE: Timeout acquiring lock on data directory '${dataDir}' after ${timeoutMs}ms`,
-                timeoutGracePeriod: () => `DATA_DIR_IN_USE: Timeout waiting for lock grace period on data directory '${dataDir}' after ${timeoutMs}ms`,
-                timeoutGuardContention: () => `DATA_DIR_IN_USE: Timeout contending for reclaim guard on data directory '${dataDir}' after ${timeoutMs}ms`,
-                timeoutReclaimStale: () => `DATA_DIR_IN_USE: Timeout reclaiming stale lock on data directory '${dataDir}' after ${timeoutMs}ms`,
-                timeoutCreate: () => `DATA_DIR_IN_USE: Timeout creating primary lock on data directory '${dataDir}' after ${timeoutMs}ms`,
+        const handle = acquireFileLockSync(lockDirPath, {
+            metadata: newLockInfo,
+            createLockError() {
+                const inUseErr = new Error(`DATA_DIR_IN_USE: Data directory '${dataDir}' is in use by another active Host process`);
+                inUseErr.code = DATA_DIR_IN_USE;
+                return inUseErr;
             },
-            assertStaleHolderReclaimable(info) {
+            assertHolderReclaimable(info) {
                 const holderPid = info.pid;
-                if (isProcessAlive(holderPid)) {
+                if (holderPid && isProcessAlive(holderPid)) {
                     const inUseErr = new Error(`DATA_DIR_IN_USE: Data directory '${dataDir}' is in use by another active Host process (PID ${holderPid})`);
                     inUseErr.code = DATA_DIR_IN_USE;
                     throw inUseErr;
                 }
-                // 主进程已死亡，检查关联子进程存活状态
-                const activeChildren = (info.childPids || []).filter((childPid) => isProcessAlive(childPid));
+                const activeChildren = info.childPids?.filter((childPid) => isProcessAlive(childPid)) ?? [];
                 if (activeChildren.length > 0) {
-                    const recoveryErr = new Error(`DATA_DIR_RECOVERY_REQUIRED: Data directory recovery required for '${dataDir}': previous host (PID ${holderPid}) exited but child processes (${activeChildren.join(", ")}) are still running`);
+                    const recoveryErr = new Error(`DATA_DIR_RECOVERY_REQUIRED: Data directory recovery required for '${dataDir}': previous host (PID ${holderPid ?? "unknown"}) exited but child processes (${activeChildren.join(", ")}) are still running`);
                     recoveryErr.code = DATA_DIR_RECOVERY_REQUIRED;
                     throw recoveryErr;
                 }
             },
-            onAcquired: () => new DataDirLock(lockDirPath, newLockInfo),
         });
+        return new DataDirLock(lockDirPath, newLockInfo, handle);
     }
 }