@aiyiran/myclaw 1.1.126 → 1.1.128

package/index.js

@@ -1383,8 +1383,8 @@ function runUpdate() {
 
       if (detectPlatform() === 'wsl' || detectPlatform() === 'linux' || detectPlatform() === 'mac') {
         console.log('');
-        console.log('如果需要同时升级 OpenClaw 核心，请运行:');
-        console.log('  ' + colors.yellow + 'myclaw install' + colors.nc);
+        console.log('如需重装 OpenClaw 核心（锁定版本 ' + OPENCLAW_VERSION + '），请运行:');
+        console.log('  ' + colors.yellow + 'mc longxia' + colors.nc);
       }
       break;
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiyiran/myclaw",
-  "version": "1.1.126",
+  "version": "1.1.128",
   "description": "",
   "main": "index.js",
   "bin": {

package/server/sync_workspace.py

@@ -13,8 +13,6 @@ import threading
 import socketserver
 from http.server import HTTPServer, BaseHTTPRequestHandler
 from urllib.parse import urlparse, parse_qs, unquote
-from watchdog.observers import Observer
-from watchdog.events import FileSystemEventHandler
 from qiniu import Auth, put_file_v2, CdnManager, BucketManager
 
 # 确保同目录的共享模块可导入
@@ -63,7 +61,9 @@ HISTORY_FILENAME = "history.json"
 # 回滚压制表：{ abs_path: 写入时间戳 }
 # 回滚时往 workspace 写文件会触发 on_modified，用此表跳过快照，避免产生多余版本
 _rollback_suppressed: dict = {}
-_ROLLBACK_SUPPRESS_TTL = 3.0  # 秒
+# 轮询模式下，回滚写盘后要等到下一轮扫描才会被发现，故 TTL 必须 > 轮询间隔，
+# 否则压制提前过期会导致回滚被误判为"修改"而多生成一个历史快照。
+_ROLLBACK_SUPPRESS_TTL = 30.0  # 秒
 
 # 时间窗口合并：同一文件在此时间窗口内的多次变更只保留最新快照（覆盖，不新增版本）
 _HISTORY_MERGE_WINDOW = 20.0  # 秒
@@ -226,53 +226,8 @@ def _path_has_ignored_dir(filepath):
     return any(part in IGNORE_DIR_PATTERNS for part in parts)
 
 
-class MyHandler(FileSystemEventHandler):
-
-    def _is_file_event(self, event):
-        return not getattr(event, "is_directory", False)
-
-    def _should_ignore(self, filepath):
-        basename = os.path.basename(filepath)
-        if basename in IGNORE_FILE_PATTERNS:
-            return True
-        if _path_has_ignored_dir(filepath):
-            return True
-        # 忽略 .openclaw 根目录下的隐藏文件（非 workspace 目录内的）
-        if basename.startswith('.') and 'workspace' not in filepath:
-            return True
-        return False
-
-    # def on_created(self, event):
-    #     if not self._is_file_event(event):
-    #         return
-    #     print(f"🟢 新建: {event.src_path}")
-    #     file_gen(event.src_path, "add")
-
-    def on_modified(self, event):
-        if not self._is_file_event(event):
-            return
-        if self._should_ignore(event.src_path):
-            return
-        print(f"🟡 修改: {event.src_path}")
-        file_gen(event.src_path, "add")
-
-    def on_deleted(self, event):
-        if not self._is_file_event(event):
-            return
-        if self._should_ignore(event.src_path):
-            return
-        print(f"🔴 删除: {event.src_path}")
-        file_gen(event.src_path, "delete")
-
-    def on_moved(self, event):
-        if not self._is_file_event(event):
-            return
-        if self._should_ignore(event.src_path):
-            return
-        print(f"🔵 移动: {event.src_path} -> {getattr(event, 'dest_path', '')}")
-        file_gen(event.src_path, "delete")
-        if getattr(event, 'dest_path', ''):
-            file_gen(event.dest_path, "add")
+# 注：原 watchdog 事件监听器 MyHandler 已移除，
+# 改为轮询对账引擎（见下方「轮询对账同步引擎」段落 / reconcile_loop）。
 
 
 def now_iso():
@@ -347,65 +302,201 @@ def init_config(workspace_id, file_path, method="add"):
         json.dump(data, f, ensure_ascii=False, indent=2)
 
 
-def file_gen(path, method):
-    # 规范化路径，兼容 Windows 和 *nix
-    norm_path = os.path.normpath(path)
-    parts = norm_path.split(os.sep)
+# ═══════════════════════════════════════════════════════════════
+# 轮询对账同步引擎（替代 watchdog 事件监听）
+#
+# 设计原则（AK47：少零件、自愈、可排查）：
+#   · 磁盘是唯一真相，七牛是镜像，manifest.json 只是加速缓存
+#   · 每轮：扫描 → 对比 size+mtime → 变化的顺序上传（同 key 覆盖，天然去重）
+#   · 服务中断不丢：重启后扫描发现「磁盘有 / manifest 无」自动补传
+#   · manifest 损坏/丢失 → 当空清单 → 自动全量重传（覆盖无副作用）
+#   · 单文件出错只跳过 + 退避重试，循环永不退出
+#   · 本地删除：七牛永久保留，仅从 manifest 和 artifacts.json 移除本地记录
+# ═══════════════════════════════════════════════════════════════
 
-    # 查找包含 workspace 标识的分段（例如 workspace 或 workspace-xxx）
-    space_idx = -1
-    for i, p in enumerate(parts):
-        if "workspace" in p:
-            space_idx = i
-            break
+# 扫描间隔（秒），可用环境变量覆盖；扫描本身极快（约 1.8 万文件 < 0.3s）
+SYNC_INTERVAL = float(os.environ.get("MYCLAW_SYNC_INTERVAL", "5"))
+
+# manifest：单一状态文件，记录已上传文件的 [size, mtime]
+MANIFEST_PATH = os.path.join(get_openclaw_path(), ".myclaw-sync-manifest.json")
+
+# 每上传 N 个文件 checkpoint 一次 manifest（抗崩溃，首次全量时尤其重要）
+_MANIFEST_CHECKPOINT_EVERY = 50
+
+# 失败退避表（内存，进程重启即清空 = 重启等于自然重试一遍）
+# { rel: {"retries": n, "next_try": ts} }
+_upload_failures = {}
+_RETRY_BACKOFF = [10, 30, 60, 120, 300]  # 秒，指数退避封顶 5 分钟
+
+# 连续无变化时，每隔多少轮打一次心跳（既不刷屏，又能用时间戳证明进程活着）
+_HEARTBEAT_EVERY = 12
+
+
+def _eng_log(tag, msg):
+    """结构化单行日志，便于 AI 排查（grep BOOT / SCAN / PUT / HEAL / ERR）"""
+    print(f"[{datetime.now().strftime('%H:%M:%S')}] {tag:<5} {msg}", flush=True)
+
+
+def load_manifest():
+    """读取 manifest；任何异常都当空清单 → 触发全量重传（自愈，覆盖无副作用）"""
+    try:
+        with open(MANIFEST_PATH, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            return data
+        _eng_log("HEAL", "manifest 格式异常 → 当空清单，本轮全量重传")
+    except FileNotFoundError:
+        pass
+    except Exception as e:
+        _eng_log("HEAL", f"manifest 损坏（{e}）→ 当空清单，本轮全量重传")
+    return {}
 
-    if space_idx == -1:
-        # 路径中不包含 workspace，不处理
-        return
 
-    space_id = parts[space_idx]
-    # 相对路径：workspace 后面的所有段，使用 '/' 作为存储格式（保证跨平台一致）
-    relative_parts = parts[space_idx + 1:]
-    if not relative_parts:
-        # 没有文件名，可能是目录事件，忽略
+def save_manifest(manifest):
+    """原子写：临时文件 + os.replace，断电也不会写出半个文件"""
+    tmp = MANIFEST_PATH + ".tmp"
+    try:
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(manifest, f, ensure_ascii=False)
+        os.replace(tmp, MANIFEST_PATH)
+    except Exception as e:
+        _eng_log("ERR", f"manifest 写入失败: {e}")
+
+
+def scan_workspace_files():
+    """扫描所有 workspace* 目录，返回 { rel_path: [size, mtime] }。
+    rel_path 相对 .openclaw 根、含 workspace 段，例如 workspace/学生作品报表/x.html"""
+    base_path = get_openclaw_path()
+    result = {}
+    for entry in os.scandir(base_path):
+        if not (entry.is_dir() and "workspace" in entry.name):
+            continue
+        for root, dirs, files in os.walk(entry.path):
+            # 剪枝：跳过忽略目录（.git / node_modules / __history__ 等），不递归进入
+            dirs[:] = [d for d in dirs if d not in IGNORE_DIR_PATTERNS]
+            for fn in files:
+                if fn == ARTIFACTS_FILENAME or fn in IGNORE_FILE_PATTERNS:
+                    continue
+                abs_path = os.path.join(root, fn)
+                try:
+                    st = os.stat(abs_path)
+                except OSError:
+                    continue
+                rel = os.path.relpath(abs_path, base_path).replace(os.sep, "/")
+                result[rel] = [st.st_size, int(st.st_mtime)]
+    return result
+
+
+def upload_one(rel_path, save_history):
+    """上传单个文件到七牛 + 写入 artifacts.json 记录。
+    rel_path 相对 .openclaw 根（含 workspace 段）。失败时抛异常由调用方处理。"""
+    base_path = get_openclaw_path()
+    abs_path = os.path.join(base_path, rel_path)
+    parts = rel_path.split("/")
+    space_id = parts[0]
+    relative_path = "/".join(parts[1:])
+    if not relative_path:
         return
-    relative_path = "/".join(relative_parts)
+    key = f"{claw}/{rel_path}"
+
+    # 历史快照：仅对「已存在又变化」的文件存档（首次全量不存，避免快照爆炸）；
+    # 回滚写盘触发的变更通过压制表跳过，避免多生成版本。
+    is_artifacts = os.path.basename(abs_path) == ARTIFACTS_FILENAME
+    if save_history and not is_artifacts and not _is_rollback_suppressed(abs_path):
+        try:
+            save_history_version(space_id, relative_path, abs_path)
+        except Exception as e:
+            _eng_log("ERR", f"history 快照失败 {relative_path}: {e}")
 
-    # 上传 key 保留 workspace 段（用于 CDN 存储），但写入 JSON 时只保存相对路径
-    path_url = f"{space_id}/{relative_path}"
-    key = f"{claw}/{path_url}"
+    # 上传到七牛（同 key 覆盖 = 天然去重，不会产生多份）
+    token = q.upload_token(bucket_name, key, 3600)
+    ret, info = put_file_v2(token, key, abs_path)
+    if not (info and getattr(info, "status_code", None) == 200):
+        raise RuntimeError(f"七牛上传失败 status={getattr(info, 'status_code', '?')}")
+    cdn_manager.refresh_urls([f"https://cdn.yiranlaoshi.com/{key}"])
+
+    # __MY_ARTIFACTS__.json 本身不写入记录（防循环）；普通文件写入 artifacts 列表
+    if not is_artifacts:
+        init_config(space_id, relative_path, method="add")
 
-    if method == "delete":
-        # 删除时不需要上传，只清理配置文件记录，传入的 file_path 不包含 space_id（relative_path）
-        init_config(space_id, relative_path, method="delete")
-        print(f"🗑️ 已删除配置记录: {relative_path}")
-    else:
-        # ── 历史版本：把当前内容作为快照存档（仅覆盖行为，非配置文件）──
-        # 回滚写盘触发的 on_modified 跳过，避免产生多余版本
-        if os.path.basename(path) != ARTIFACTS_FILENAME and not _is_rollback_suppressed(path):
-            save_history_version(space_id, relative_path, path)
 
-        # ── 上传到 OSS ───────────────────────────────────────────
+def reconcile_loop():
+    """主循环：每 SYNC_INTERVAL 秒对账一次。整个循环包 try，任何异常都不退出。"""
+    base_path = get_openclaw_path()
+    manifest = load_manifest()
+    _eng_log("BOOT",
+             f"claw={claw} interval={SYNC_INTERVAL}s 监听={base_path}/workspace* "
+             f"忽略={','.join(sorted(IGNORE_DIR_PATTERNS))} manifest={len(manifest)}条")
+
+    idle_rounds = 0
+    while True:
+        t0 = time.time()
         try:
-            token = q.upload_token(bucket_name, key, 3600)
-            # 直接使用 put_file_v2 上传文件路径，避免读取到空内容时导致 SDK 报错缺少 data 参数
-            ret, info = put_file_v2(token, key, path)
-
-            # 刷新 CDN
-            cdn_url = f"https://cdn.yiranlaoshi.com/{key}"
-            cdn_ret, cdn_info = cdn_manager.refresh_urls([cdn_url])
-
-            # 如果是 __MY_ARTIFACTS__.json 配置文件，只上传不写入（防止循环触发）
-            if os.path.basename(path) == ARTIFACTS_FILENAME:
-                print(f"🚀 已上传配置文件: {relative_path}")
-                print(f"风 CDN刷新: {cdn_url} - {cdn_info.status_code if info else 'unknown'}")
+            current = scan_workspace_files()
+            now = time.time()
+
+            # 1) 找出需要上传的：新文件 or size/mtime 变化
+            changed = [rel for rel, sm in current.items() if manifest.get(rel) != sm]
+
+            # 2) 顺序上传（单线程，日志线性可读，无锁无竞态）
+            uploaded = failed = skipped = 0
+            since_ckpt = 0
+            for rel in changed:
+                fb = _upload_failures.get(rel)
+                if fb and now < fb["next_try"]:
+                    skipped += 1  # 退避中，本轮先跳过
+                    continue
+                is_update = rel in manifest  # 已在清单 = 修改，触发 history 快照
+                try:
+                    upload_one(rel, save_history=is_update)
+                    manifest[rel] = current[rel]
+                    _upload_failures.pop(rel, None)
+                    uploaded += 1
+                    since_ckpt += 1
+                    _eng_log("PUT", f"ok   {rel} {current[rel][0]}B")
+                    if since_ckpt >= _MANIFEST_CHECKPOINT_EVERY:
+                        save_manifest(manifest)
+                        since_ckpt = 0
+                except Exception as e:
+                    failed += 1
+                    n = _upload_failures.get(rel, {}).get("retries", 0) + 1
+                    backoff = _RETRY_BACKOFF[min(n - 1, len(_RETRY_BACKOFF) - 1)]
+                    _upload_failures[rel] = {"retries": n, "next_try": now + backoff}
+                    _eng_log("PUT", f"FAIL {rel} 原因={e} 重试={n} 下次+{backoff}s")
+
+            # 3) 清理 manifest 中磁盘已删的条目：七牛永久保留，仅同步本地视图
+            #    （从 manifest 移除 + 从 artifacts.json 剔除该记录，但不删七牛）
+            stale = [k for k in manifest if k not in current]
+            for k in stale:
+                manifest.pop(k, None)
+                _upload_failures.pop(k, None)
+                p = k.split("/")
+                if len(p) >= 2:
+                    try:
+                        init_config(p[0], "/".join(p[1:]), method="delete")
+                    except Exception:
+                        pass
+
+            if uploaded or stale:
+                save_manifest(manifest)
+
+            dt = (time.time() - t0) * 1000
+            if changed or stale:
+                idle_rounds = 0
+                _eng_log("SCAN",
+                         f"文件={len(current)} 变化={len(changed)} 上传={uploaded} "
+                         f"失败={failed} 跳过={skipped} 删除={len(stale)} 耗时={dt:.0f}ms")
             else:
-                # 记录时使用不包含 workspace 的相对路径
-                init_config(space_id, relative_path, method="add")
-                print(f"🚀 已上传并记录: {relative_path}")
-                print(f"风 CDN刷新: {cdn_url} - {cdn_info.status_code if info else 'unknown'}")
+                idle_rounds += 1
+                if idle_rounds % _HEARTBEAT_EVERY == 0:
+                    _eng_log("SCAN", f"文件={len(current)} 变化=0 (心跳) 耗时={dt:.0f}ms")
+
         except Exception as e:
-            print(f"❌ 上传/读取文件失败: {e}")
+            import traceback
+            _eng_log("ERR", f"对账循环异常（已忽略，循环继续）: {e}")
+            _eng_log("ERR", traceback.format_exc().replace("\n", " | "))
+
+        time.sleep(SYNC_INTERVAL)
 
 
 def sync_all(workspace_id):
@@ -1491,33 +1582,23 @@ if __name__ == "__main__":
     API_PORT = args.port
 
     base_path = get_openclaw_path()
-    path = base_path
 
     # 启动时清理所有 workspace 中的忽略文件记录
     for entry in os.scandir(base_path):
         if entry.is_dir() and "workspace" in entry.name:
             cleanup_ignored_assets(entry.name)
 
-    # 如果指定了 --agent，先全量同步
+    # 如果指定了 --agent，先全量同步（向后兼容旧调用方式）
     if args.agent:
         if not sync_all(args.agent):
             sys.exit(1)
         print("")
 
-    # 启动 HTTP API 服务
+    # 启动 HTTP API 服务（前端业务接口，原样保留）
     start_api_server()
 
-    event_handler = MyHandler()
-    observer = Observer()
-    observer.schedule(event_handler, path, recursive=True)
-
-    observer.start()
-    print(f"开始监听目录: {path}")
-
+    # 启动轮询对账引擎（前台主循环，替代 watchdog 事件监听）
     try:
-        while True:
-            time.sleep(1)
+        reconcile_loop()
     except KeyboardInterrupt:
-        observer.stop()
-
-    observer.join()
+        print("\n[exit] 收到中断，退出")