principles-disciple 1.7.1 → 1.7.3

package/dist/utils/file-lock.js

@@ -10,6 +10,16 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+export class LockAcquisitionError extends Error {
+    filePath;
+    lockPath;
+    constructor(message, filePath, lockPath) {
+        super(message);
+        this.name = 'LockAcquisitionError';
+        this.filePath = filePath;
+        this.lockPath = lockPath;
+    }
+}
 /** 默认锁选项 */
 const DEFAULT_OPTIONS = {
     maxRetries: 50,
@@ -134,15 +144,39 @@ function calculateBackoff(attempt, baseMs, maxMs) {
     const jitter = exponentialDelay * 0.2 * Math.random();
     return Math.floor(exponentialDelay + jitter);
 }
-/**
- * 同步 sleep
- */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function sleepSync(ms) {
     const end = Date.now() + ms;
     while (Date.now() < end) {
-        // busy wait（同步函数无法使用 setTimeout）
+        // busy wait for synchronous retry
     }
 }
+function buildLockError(filePath, lockPath) {
+    const holderPid = readLockPid(lockPath);
+    const holderStatus = holderPid !== null
+        ? (isProcessAlive(holderPid) ? `alive (PID ${holderPid})` : `dead (PID ${holderPid})`)
+        : 'unknown';
+    return new LockAcquisitionError(`Failed to acquire lock for ${filePath}. Lock holder: ${holderStatus}.`, filePath, lockPath);
+}
+function tryAcquireWithStaleCleanup(filePath, opts, pid) {
+    const lockPath = filePath + opts.lockSuffix;
+    if (tryAcquireLock(lockPath, pid)) {
+        const actualPid = readLockPid(lockPath);
+        if (actualPid === pid) {
+            return { lockPath, pid, acquiredAt: Date.now() };
+        }
+    }
+    cleanupStaleLock(lockPath, opts.lockStaleMs);
+    if (tryAcquireLock(lockPath, pid)) {
+        const actualPid = readLockPid(lockPath);
+        if (actualPid === pid) {
+            return { lockPath, pid, acquiredAt: Date.now() };
+        }
+    }
+    return null;
+}
 /**
  * 获取文件锁
  *
@@ -153,37 +187,33 @@ function sleepSync(ms) {
  */
 export function acquireLock(filePath, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
-    const lockPath = filePath + opts.lockSuffix;
     const pid = process.pid;
     for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-        // 1. 尝试原子获取锁
-        if (tryAcquireLock(lockPath, pid)) {
-            // 2. 二次验证：确保我们真的持有锁
-            const actualPid = readLockPid(lockPath);
-            if (actualPid === pid) {
-                return {
-                    lockPath,
-                    pid,
-                    acquiredAt: Date.now(),
-                };
-            }
-            // PID 不匹配，说明被其他进程抢占，继续重试
+        const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
+        if (ctx) {
+            return ctx;
         }
-        // 3. 获取失败，检查是否需要清理过期锁
-        cleanupStaleLock(lockPath, opts.lockStaleMs);
-        // 4. 计算退避时间并等待
         if (attempt < opts.maxRetries - 1) {
             const delay = calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs);
             sleepSync(delay);
         }
     }
-    // 5. 所有重试都失败，抛出异常（不静默丢弃！）
-    const holderPid = readLockPid(lockPath);
-    const holderStatus = holderPid !== null
-        ? (isProcessAlive(holderPid) ? `alive (PID ${holderPid})` : `dead (PID ${holderPid})`)
-        : 'unknown';
-    throw new Error(`Failed to acquire lock for ${filePath} after ${opts.maxRetries} attempts. ` +
-        `Lock holder: ${holderStatus}. Consider increasing maxRetries or checking for zombie processes.`);
+    throw buildLockError(filePath, filePath + opts.lockSuffix);
+}
+export async function acquireLockAsync(filePath, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const pid = process.pid;
+    for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
+        const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
+        if (ctx) {
+            return ctx;
+        }
+        if (attempt < opts.maxRetries - 1) {
+            const delay = calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs);
+            await sleep(delay);
+        }
+    }
+    throw buildLockError(filePath, filePath + opts.lockSuffix);
 }
 /**
  * 释放文件锁
@@ -210,6 +240,15 @@ export function withLock(filePath, fn, options = {}) {
         releaseLock(ctx);
     }
 }
+export async function withLockAsync(filePath, fn, options = {}) {
+    const ctx = await acquireLockAsync(filePath, options);
+    try {
+        return await fn();
+    }
+    finally {
+        releaseLock(ctx);
+    }
+}
 /**
  * 异步版本的文件锁（使用 Promise 链）
  *

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "skills": [
     "./skills"
   ],
@@ -54,7 +54,7 @@
               "forced"
             ],
             "default": "auto",
-            "description": "auto: 遇到困难自动触发; forced: 每次回答前都强制反思(极耗时间，不推荐)"
+            "description": "auto: 遇到困难自动触发; forced: 每次回答前都强制反思 (极耗时间，不推荐)"
           }
         }
       }
@@ -69,7 +69,7 @@
       "placeholder": "medium"
     },
     "riskPaths": {
-      "label": "☠️ 绝对高危目录 (空表示不设限)"
+      "label": "⚠️ 绝对高危目录 (空表示不设限)"
     },
     "deep_reflection": {
       "label": "💡 AI 深度反思功能"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/index.js",