@clawos-dev/clawd 0.2.60 → 0.2.61-beta.98.15637d6

package/dist/cli.cjs

@@ -601,8 +601,8 @@ var init_parseUtil = __esm({
     init_errors2();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path27, errorMaps, issueData } = params;
-      const fullPath = [...path27, ...issueData.path || []];
+      const { data, path: path28, errorMaps, issueData } = params;
+      const fullPath = [...path28, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -913,11 +913,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path27, key) {
+      constructor(parent, value, path28, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path27;
+        this._path = path28;
         this._key = key;
       }
       get path() {
@@ -5367,8 +5367,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path27 = req.path;
-        _req.url = typeof path27 === "string" ? path27 : req.url ? req.url.path || req.url : void 0;
+        const path28 = req.path;
+        _req.url = typeof path28 === "string" ? path28 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -5533,14 +5533,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path27) {
+    function parsePath(path28) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path27.length; i++) {
-        const char = path27[i];
+      for (let i = 0; i < path28.length; i++) {
+        const char = path28[i];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -5671,10 +5671,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path27 of paths) {
-        const parts = parsePath(path27);
+      for (const path28 of paths) {
+        const parts = parsePath(path28);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path27, remove);
+          redactWildcardPath(obj, parts, censor, path28, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -5759,8 +5759,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path27) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path27];
+            const wrappedCensor = typeof censor === "function" ? (value, path28) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path28];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -5795,8 +5795,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path27 of pathsToClone) {
-        const parts = parsePath(path27);
+      for (const path28 of pathsToClone) {
+        const parts = parsePath(path28);
         let current = pathStructure;
         for (let i = 0; i < parts.length; i++) {
           const part = parts[i];
@@ -5848,24 +5848,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path27) {
-      if (typeof path27 !== "string") {
+    function validatePath(path28) {
+      if (typeof path28 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path27 === "") {
+      if (path28 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path27.includes("..")) {
-        throw new Error(`Invalid redaction path (${path27})`);
+      if (path28.includes("..")) {
+        throw new Error(`Invalid redaction path (${path28})`);
       }
-      if (path27.includes(",")) {
-        throw new Error(`Invalid redaction path (${path27})`);
+      if (path28.includes(",")) {
+        throw new Error(`Invalid redaction path (${path28})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path27.length; i++) {
-        const char = path27[i];
+      for (let i = 0; i < path28.length; i++) {
+        const char = path28[i];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -5879,20 +5879,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path27})`);
+            throw new Error(`Invalid redaction path (${path28})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path27})`);
+        throw new Error(`Invalid redaction path (${path28})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path27 of paths) {
-        validatePath(path27);
+      for (const path28 of paths) {
+        validatePath(path28);
       }
     }
     function slowRedact(options = {}) {
@@ -6060,8 +6060,8 @@ var require_redaction = __commonJS({
         if (shape[k2] === null) {
           o[k2] = (value) => topCensor(value, [k2]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path27) => {
-            return censor(value, [k2, ...path27]);
+          const wrappedCensor = typeof censor === "function" ? (value, path28) => {
+            return censor(value, [k2, ...path28]);
           } : censor;
           o[k2] = Redact({
             paths: shape[k2],
@@ -6279,10 +6279,10 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js"(exports2, module2) {
     "use strict";
-    var fs25 = require("fs");
+    var fs26 = require("fs");
     var EventEmitter2 = require("events");
     var inherits = require("util").inherits;
-    var path27 = require("path");
+    var path28 = require("path");
     var sleep = require_atomic_sleep();
     var assert = require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -6336,20 +6336,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs25.mkdirSync(path27.dirname(file), { recursive: true });
-          const fd = fs25.openSync(file, flags, mode);
+          if (sonic.mkdir) fs26.mkdirSync(path28.dirname(file), { recursive: true });
+          const fd = fs26.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs25.mkdir(path27.dirname(file), { recursive: true }, (err) => {
+        fs26.mkdir(path28.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs25.open(file, flags, mode, fileOpened);
+          fs26.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs25.open(file, flags, mode, fileOpened);
+        fs26.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -6390,8 +6390,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs25.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs25.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs26.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs26.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -6400,15 +6400,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs25.writeSync(this.fd, this._writingBuf);
+            return fs26.writeSync(this.fd, this._writingBuf);
           }
-          return fs25.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs26.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs25.write(this.fd, this._writingBuf, this.release);
+            return fs26.write(this.fd, this._writingBuf, this.release);
           }
-          return fs25.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs26.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -6465,7 +6465,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs25.fsyncSync(this.fd);
+          fs26.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -6579,7 +6579,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs25.fsync(this.fd, (err) => {
+            fs26.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -6681,7 +6681,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs25.close(fd, (err) => {
+          fs26.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -6730,7 +6730,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = Buffer.isBuffer(buf) ? fs25.writeSync(this.fd, buf) : fs25.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs26.writeSync(this.fd, buf) : fs26.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -6746,7 +6746,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs25.fsyncSync(this.fd);
+        fs26.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -6767,7 +6767,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs25.writeSync(this.fd, buf);
+          const n = fs26.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -6795,13 +6795,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs25.writeSync(this.fd, this._writingBuf) : fs25.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs26.writeSync(this.fd, this._writingBuf) : fs26.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs25.write(this.fd, this._writingBuf, release);
+        fs26.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -6810,7 +6810,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs25.writeSync(this.fd, this._writingBuf);
+          const written = fs26.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -6819,7 +6819,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs25.write(this.fd, this._writingBuf, release);
+        fs26.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -6835,12 +6835,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs25.fsync(sonic.fd, closeWrapped);
+        fs26.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs25.close(sonic.fd, done);
+          fs26.close(sonic.fd, done);
         } else {
           done();
         }
@@ -9975,11 +9975,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path27, added, removed, oldPosInc, options) {
-        var last = path27.lastComponent;
+      addToPath: function addToPath(path28, added, removed, oldPosInc, options) {
+        var last = path28.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path27.oldPos + oldPosInc,
+            oldPos: path28.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -9989,7 +9989,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path27.oldPos + oldPosInc,
+            oldPos: path28.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -10420,10 +10420,10 @@ function attachmentToHistoryMessage(o, ts) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec = m2;
-      const path27 = typeof rec.path === "string" ? rec.path : null;
+      const path28 = typeof rec.path === "string" ? rec.path : null;
       const content = typeof rec.content === "string" ? rec.content : null;
-      if (!path27 || content == null) return null;
-      const entry = { path: path27, content };
+      if (!path28 || content == null) return null;
+      const entry = { path: path28, content };
       if (typeof rec.mtimeMs === "number") entry.mtimeMs = rec.mtimeMs;
       return entry;
     }).filter((m2) => m2 !== null);
@@ -11227,10 +11227,10 @@ function parseAttachment(obj) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec = m2;
-      const path27 = typeof rec.path === "string" ? rec.path : null;
+      const path28 = typeof rec.path === "string" ? rec.path : null;
       const content = typeof rec.content === "string" ? rec.content : null;
-      if (!path27 || content == null) return null;
-      const out = { path: path27, content };
+      if (!path28 || content == null) return null;
+      const out = { path: path28, content };
       if (typeof rec.mtimeMs === "number") out.mtimeMs = rec.mtimeMs;
       return out;
     }).filter((m2) => m2 !== null);
@@ -20144,7 +20144,7 @@ var require_websocket_server = __commonJS({
 // src/run-case/recorder.ts
 function startRunCaseRecorder(opts) {
   const now = opts.now ?? Date.now;
-  const dir = import_node_path23.default.dirname(opts.recordPath);
+  const dir = import_node_path24.default.dirname(opts.recordPath);
   let stream = null;
   let closing = false;
   let closedSettled = false;
@@ -20158,8 +20158,8 @@ function startRunCaseRecorder(opts) {
   });
   const ensureStream = () => {
     if (stream) return stream;
-    import_node_fs22.default.mkdirSync(dir, { recursive: true });
-    stream = import_node_fs22.default.createWriteStream(opts.recordPath, { flags: "a" });
+    import_node_fs23.default.mkdirSync(dir, { recursive: true });
+    stream = import_node_fs23.default.createWriteStream(opts.recordPath, { flags: "a" });
     stream.on("close", () => closedResolve());
     return stream;
   };
@@ -20184,12 +20184,12 @@ function startRunCaseRecorder(opts) {
   };
   return { tap, close, closed };
 }
-var import_node_fs22, import_node_path23;
+var import_node_fs23, import_node_path24;
 var init_recorder = __esm({
   "src/run-case/recorder.ts"() {
     "use strict";
-    import_node_fs22 = __toESM(require("fs"), 1);
-    import_node_path23 = __toESM(require("path"), 1);
+    import_node_fs23 = __toESM(require("fs"), 1);
+    import_node_path24 = __toESM(require("path"), 1);
   }
 });
 
@@ -20232,7 +20232,7 @@ var init_wire = __esm({
 // src/run-case/controller.ts
 async function runController(opts) {
   const now = opts.now ?? Date.now;
-  const cwd = opts.cwd ?? (0, import_node_fs23.mkdtempSync)(import_node_path24.default.join(import_node_os15.default.tmpdir(), "clawd-runcase-"));
+  const cwd = opts.cwd ?? (0, import_node_fs24.mkdtempSync)(import_node_path25.default.join(import_node_os15.default.tmpdir(), "clawd-runcase-"));
   const ownsCwd = opts.cwd === void 0;
   const recorder = startRunCaseRecorder({ recordPath: opts.record, now });
   const spawnCtx = { cwd };
@@ -20393,19 +20393,19 @@ async function runController(opts) {
   if (sigintHandler) process.off("SIGINT", sigintHandler);
   if (ownsCwd) {
     try {
-      (0, import_node_fs23.rmSync)(cwd, { recursive: true, force: true });
+      (0, import_node_fs24.rmSync)(cwd, { recursive: true, force: true });
     } catch {
     }
   }
   return exitCode ?? 0;
 }
-var import_node_fs23, import_node_os15, import_node_path24;
+var import_node_fs24, import_node_os15, import_node_path25;
 var init_controller = __esm({
   "src/run-case/controller.ts"() {
     "use strict";
-    import_node_fs23 = require("fs");
+    import_node_fs24 = require("fs");
     import_node_os15 = __toESM(require("os"), 1);
-    import_node_path24 = __toESM(require("path"), 1);
+    import_node_path25 = __toESM(require("path"), 1);
     init_claude();
     init_stdout_splitter();
     init_permission_stdio();
@@ -20637,8 +20637,8 @@ Env (advanced):
 `;
 
 // src/index.ts
-var import_node_path22 = __toESM(require("path"), 1);
-var import_node_fs21 = __toESM(require("fs"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
+var import_node_fs22 = __toESM(require("fs"), 1);
 
 // src/logger.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -26055,10 +26055,10 @@ var StateFileManager = class {
 };
 
 // src/tunnel/tunnel-manager.ts
-var import_node_fs16 = __toESM(require("fs"), 1);
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs17 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_node_crypto4 = __toESM(require("crypto"), 1);
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 
 // src/tunnel/tunnel-store.ts
 var import_node_fs14 = __toESM(require("fs"), 1);
@@ -26309,12 +26309,126 @@ async function extractFrpcFromTarball(tarball, binDir, version2, platform, destB
   }
 }
 
+// src/tunnel/frpc-process.ts
+var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
+function frpcPidFilePath(dataDir) {
+  return import_node_path17.default.join(dataDir, "frpc.pid");
+}
+function writeFrpcPid(dataDir, pid) {
+  try {
+    import_node_fs16.default.writeFileSync(frpcPidFilePath(dataDir), String(pid), { mode: 384 });
+  } catch {
+  }
+}
+function clearFrpcPid(dataDir) {
+  try {
+    import_node_fs16.default.unlinkSync(frpcPidFilePath(dataDir));
+  } catch {
+  }
+}
+function defaultIsPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    return code === "EPERM";
+  }
+}
+function defaultReadPidFile(file) {
+  try {
+    return import_node_fs16.default.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function defaultKillPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
+function defaultSleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function killStaleFrpc(deps) {
+  const pidFile = frpcPidFilePath(deps.dataDir);
+  const tomlPath = import_node_path17.default.join(deps.dataDir, "frpc.toml");
+  const readPidFile = deps.readPidFileImpl ?? defaultReadPidFile;
+  const isAlive = deps.isPidAliveImpl ?? defaultIsPidAlive;
+  const killPid = deps.killPidImpl ?? defaultKillPid;
+  const scanPids = deps.scanFrpcPidsImpl ?? ((tp) => defaultScanFrpcPidsByCmdline(tp, deps.logger));
+  const sleep = deps.sleepImpl ?? defaultSleep;
+  const victims = /* @__PURE__ */ new Set();
+  const raw = readPidFile(pidFile);
+  if (raw) {
+    const pid = parseInt(raw.trim(), 10);
+    if (Number.isFinite(pid) && pid > 0 && pid !== deps.ownPid && isAlive(pid)) {
+      victims.add(pid);
+    }
+  }
+  try {
+    const scanned = await scanPids(tomlPath);
+    for (const pid of scanned) {
+      if (pid > 0 && pid !== deps.ownPid && isAlive(pid)) victims.add(pid);
+    }
+  } catch (e) {
+    deps.logger?.warn("tunnel: stale-frpc cmdline scan failed", { err: e.message });
+  }
+  if (victims.size === 0) {
+    try {
+      import_node_fs16.default.unlinkSync(pidFile);
+    } catch {
+    }
+    return;
+  }
+  for (const pid of victims) {
+    deps.logger?.warn("tunnel: killing stale frpc before respawn", { pid });
+    killPid(pid, "SIGKILL");
+  }
+  await sleep(deps.reapWaitMs ?? 300);
+  try {
+    import_node_fs16.default.unlinkSync(pidFile);
+  } catch {
+  }
+}
+async function defaultScanFrpcPidsByCmdline(tomlPath, logger) {
+  if (process.platform === "win32") return [];
+  return new Promise((resolve2) => {
+    const ps = (0, import_node_child_process4.spawn)("ps", ["-axo", "pid=,command="], { stdio: ["ignore", "pipe", "ignore"] });
+    let buf = "";
+    ps.stdout.on("data", (c) => {
+      buf += c.toString();
+    });
+    ps.on("exit", () => {
+      const pids = [];
+      for (const line of buf.split("\n")) {
+        const m2 = /^\s*(\d+)\s+(.*)$/.exec(line);
+        if (!m2) continue;
+        const cmd = m2[2];
+        if (!/\bfrpc\b/.test(cmd)) continue;
+        if (!cmd.includes(tomlPath)) continue;
+        const pid = parseInt(m2[1], 10);
+        if (Number.isFinite(pid) && pid > 0) pids.push(pid);
+      }
+      resolve2(pids);
+    });
+    ps.on("error", (e) => {
+      logger?.warn("tunnel: ps scan failed", { err: e.message });
+      resolve2([]);
+    });
+  });
+}
+
 // src/tunnel/tunnel-manager.ts
 var DEFAULT_TUNNEL_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var TunnelManager = class {
   constructor(deps) {
     this.deps = deps;
-    this.store = deps.store ?? new TunnelStore(import_node_path17.default.join(deps.dataDir, "tunnel.json"));
+    this.store = deps.store ?? new TunnelStore(import_node_path18.default.join(deps.dataDir, "tunnel.json"));
     this.ttlMs = deps.ttlMs ?? DEFAULT_TUNNEL_TTL_MS;
     this.startupTimeoutMs = deps.startupTimeoutMs ?? 15e3;
   }
@@ -26332,6 +26446,11 @@ var TunnelManager = class {
   }
   async start(opts) {
     const { logger } = this.deps;
+    await (this.deps.killStaleImpl ?? killStaleFrpc)({
+      dataDir: this.deps.dataDir,
+      ownPid: process.pid,
+      logger
+    });
     if (!this.deps.noPersist) {
       const cached = await this.store.get();
       if (cached && this.isFresh(cached)) {
@@ -26372,7 +26491,10 @@ var TunnelManager = class {
     this.stopping = true;
     const proc = this.proc;
     this.proc = null;
-    if (!proc) return;
+    if (!proc) {
+      clearFrpcPid(this.deps.dataDir);
+      return;
+    }
     proc.kill("SIGTERM");
     await new Promise((resolve2) => {
       const t = setTimeout(() => {
@@ -26387,12 +26509,14 @@ var TunnelManager = class {
         resolve2();
       });
     });
+    clearFrpcPid(this.deps.dataDir);
   }
   // 同步杀子进程：父进程崩溃 / SIGHUP / process.exit 路径下使用，
   // async stop() 跑不完时的兜底，避免留下孤儿 frpc。
   killSync() {
     const proc = this.proc;
     this.proc = null;
+    clearFrpcPid(this.deps.dataDir);
     if (!proc) return;
     try {
       proc.kill("SIGTERM");
@@ -26431,7 +26555,7 @@ var TunnelManager = class {
         dataDir: this.deps.dataDir,
         override: this.deps.frpcBinaryOverride ?? void 0
       });
-      const tomlPath = import_node_path17.default.join(this.deps.dataDir, "frpc.toml");
+      const tomlPath = import_node_path18.default.join(this.deps.dataDir, "frpc.toml");
       const proxyName = `clawd-${t.subdomain}-${localPort}-${import_node_crypto4.default.randomBytes(3).toString("hex")}`;
       const toml = buildFrpcToml({
         serverAddr: t.frpsHost,
@@ -26442,12 +26566,12 @@ var TunnelManager = class {
         localPort,
         logLevel: "info"
       });
-      await import_node_fs16.default.promises.writeFile(tomlPath, toml, { mode: 384 });
-      const proc = (this.deps.spawnImpl ?? import_node_child_process4.spawn)(frpcBin, ["-c", tomlPath], {
+      await import_node_fs17.default.promises.writeFile(tomlPath, toml, { mode: 384 });
+      const proc = (this.deps.spawnImpl ?? import_node_child_process5.spawn)(frpcBin, ["-c", tomlPath], {
         stdio: ["ignore", "pipe", "pipe"]
       });
-      const logFilePath = import_node_path17.default.join(this.deps.dataDir, "frpc.log");
-      const logStream = import_node_fs16.default.createWriteStream(logFilePath, { flags: "a", mode: 384 });
+      const logFilePath = import_node_path18.default.join(this.deps.dataDir, "frpc.log");
+      const logStream = import_node_fs17.default.createWriteStream(logFilePath, { flags: "a", mode: 384 });
       logStream.on("error", () => {
       });
       const tee = (chunk) => {
@@ -26469,7 +26593,8 @@ var TunnelManager = class {
 ${tail}` : ready.error;
         return { ok: false, error: new Error(msg) };
       }
-      this.deps.logger?.info("tunnel: frpc up", { subdomain: t.subdomain, url: t.url });
+      if (typeof proc.pid === "number") writeFrpcPid(this.deps.dataDir, proc.pid);
+      this.deps.logger?.info("tunnel: frpc up", { subdomain: t.subdomain, url: t.url, pid: proc.pid ?? null });
       return { ok: true, proc };
     } catch (err) {
       if (err instanceof TunnelRegisterError) throw err;
@@ -26539,12 +26664,12 @@ function deriveStableDeviceKey(opts = {}) {
 }
 
 // src/auth-store.ts
-var import_node_fs17 = __toESM(require("fs"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs18 = __toESM(require("fs"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 var import_node_crypto6 = __toESM(require("crypto"), 1);
 var AUTH_FILE_NAME = "auth.json";
 function authFilePath(dataDir) {
-  return import_node_path18.default.join(dataDir, AUTH_FILE_NAME);
+  return import_node_path19.default.join(dataDir, AUTH_FILE_NAME);
 }
 function loadOrCreateAuthToken(opts) {
   const file = authFilePath(opts.dataDir);
@@ -26560,7 +26685,7 @@ function defaultGenerate() {
 }
 function readAuthFile(file) {
   try {
-    const raw = import_node_fs17.default.readFileSync(file, "utf8");
+    const raw = import_node_fs18.default.readFileSync(file, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.token === "string" && parsed.token.length > 0) {
       return {
@@ -26576,25 +26701,25 @@ function readAuthFile(file) {
   }
 }
 function writeAuthFile(file, content) {
-  import_node_fs17.default.mkdirSync(import_node_path18.default.dirname(file), { recursive: true });
-  import_node_fs17.default.writeFileSync(file, JSON.stringify(content, null, 2), { mode: 384 });
+  import_node_fs18.default.mkdirSync(import_node_path19.default.dirname(file), { recursive: true });
+  import_node_fs18.default.writeFileSync(file, JSON.stringify(content, null, 2), { mode: 384 });
   try {
-    import_node_fs17.default.chmodSync(file, 384);
+    import_node_fs18.default.chmodSync(file, 384);
   } catch {
   }
 }
 
 // src/owner-profile.ts
-var import_node_fs18 = __toESM(require("fs"), 1);
+var import_node_fs19 = __toESM(require("fs"), 1);
 var import_node_os11 = __toESM(require("os"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 var PROFILE_FILENAME = "profile.json";
 function loadOwnerDisplayName(dataDir) {
   const fallback = import_node_os11.default.userInfo().username;
-  const profilePath = import_node_path19.default.join(dataDir, PROFILE_FILENAME);
+  const profilePath = import_node_path20.default.join(dataDir, PROFILE_FILENAME);
   let raw;
   try {
-    raw = import_node_fs18.default.readFileSync(profilePath, "utf8");
+    raw = import_node_fs19.default.readFileSync(profilePath, "utf8");
   } catch {
     return fallback;
   }
@@ -26623,12 +26748,12 @@ init_protocol();
 init_protocol();
 
 // src/session/fork.ts
-var import_node_fs19 = __toESM(require("fs"), 1);
+var import_node_fs20 = __toESM(require("fs"), 1);
 var import_node_os12 = __toESM(require("os"), 1);
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 init_claude_history();
 function readJsonlEntries(file) {
-  const raw = import_node_fs19.default.readFileSync(file, "utf8");
+  const raw = import_node_fs20.default.readFileSync(file, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     const t = line.trim();
@@ -26641,10 +26766,10 @@ function readJsonlEntries(file) {
   return out;
 }
 function forkSession(input) {
-  const baseDir = input.baseDir ?? import_node_path20.default.join(import_node_os12.default.homedir(), ".claude");
-  const projectDir = import_node_path20.default.join(baseDir, "projects", cwdToHashDir(input.cwd));
-  const sourceFile = import_node_path20.default.join(projectDir, `${input.toolSessionId}.jsonl`);
-  if (!import_node_fs19.default.existsSync(sourceFile)) {
+  const baseDir = input.baseDir ?? import_node_path21.default.join(import_node_os12.default.homedir(), ".claude");
+  const projectDir = import_node_path21.default.join(baseDir, "projects", cwdToHashDir(input.cwd));
+  const sourceFile = import_node_path21.default.join(projectDir, `${input.toolSessionId}.jsonl`);
+  if (!import_node_fs20.default.existsSync(sourceFile)) {
     throw new Error(`fork: source transcript not found: ${sourceFile}`);
   }
   const entries = readJsonlEntries(sourceFile);
@@ -26674,9 +26799,9 @@ function forkSession(input) {
     }
     forkedLines.push(JSON.stringify(forked));
   }
-  const forkedFilePath = import_node_path20.default.join(projectDir, `${forkedToolSessionId}.jsonl`);
-  import_node_fs19.default.mkdirSync(projectDir, { recursive: true });
-  import_node_fs19.default.writeFileSync(forkedFilePath, forkedLines.join("\n") + "\n", { mode: 384 });
+  const forkedFilePath = import_node_path21.default.join(projectDir, `${forkedToolSessionId}.jsonl`);
+  import_node_fs20.default.mkdirSync(projectDir, { recursive: true });
+  import_node_fs20.default.writeFileSync(forkedFilePath, forkedLines.join("\n") + "\n", { mode: 384 });
   return { forkedToolSessionId, forkedFilePath };
 }
 
@@ -26996,12 +27121,12 @@ function buildWorkspaceHandlers(deps) {
 init_protocol();
 
 // src/workspace/git.ts
-var import_node_child_process5 = require("child_process");
-var import_node_fs20 = __toESM(require("fs"), 1);
+var import_node_child_process6 = require("child_process");
+var import_node_fs21 = __toESM(require("fs"), 1);
 var import_node_os13 = __toESM(require("os"), 1);
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path22 = __toESM(require("path"), 1);
 var import_node_util = require("util");
-var pexec = (0, import_node_util.promisify)(import_node_child_process5.execFile);
+var pexec = (0, import_node_util.promisify)(import_node_child_process6.execFile);
 function formatChildProcessError(err) {
   const e = err;
   const stderrLine = (e.stderr ?? "").split("\n").map((s) => s.trim()).find((s) => s.length > 0);
@@ -27014,9 +27139,9 @@ function formatChildProcessError(err) {
   return e.message ?? "unknown error";
 }
 function normalizePath(p2) {
-  const resolved = import_node_path21.default.resolve(p2);
+  const resolved = import_node_path22.default.resolve(p2);
   try {
-    return import_node_fs20.default.realpathSync(resolved);
+    return import_node_fs21.default.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -27117,13 +27242,13 @@ function flattenToDirName(branch) {
 }
 function encodeClaudeProjectDir(absPath) {
   if (!absPath || typeof absPath !== "string") return "";
-  let canonical = import_node_path21.default.resolve(absPath);
+  let canonical = import_node_path22.default.resolve(absPath);
   try {
-    canonical = import_node_fs20.default.realpathSync(canonical);
+    canonical = import_node_fs21.default.realpathSync(canonical);
   } catch {
     try {
-      const parent = import_node_fs20.default.realpathSync(import_node_path21.default.dirname(canonical));
-      canonical = import_node_path21.default.join(parent, import_node_path21.default.basename(canonical));
+      const parent = import_node_fs21.default.realpathSync(import_node_path22.default.dirname(canonical));
+      canonical = import_node_path22.default.join(parent, import_node_path22.default.basename(canonical));
     } catch {
     }
   }
@@ -27147,11 +27272,11 @@ async function createWorktree(input) {
   if (!isGitRoot) {
     throw new Error(`\u76EE\u5F55 ${cwd} \u4E0D\u662F git repo \u6839`);
   }
-  const parent = import_node_path21.default.dirname(import_node_path21.default.resolve(cwd));
-  if (parent === "/" || parent === import_node_path21.default.resolve(cwd)) {
+  const parent = import_node_path22.default.dirname(import_node_path22.default.resolve(cwd));
+  if (parent === "/" || parent === import_node_path22.default.resolve(cwd)) {
     throw new Error("repo \u5728\u78C1\u76D8\u6839\u76EE\u5F55\uFF0C\u65E0\u6CD5\u5728\u540C\u7EA7\u521B\u5EFA worktree");
   }
-  const worktreeRoot = import_node_path21.default.join(parent, dirName);
+  const worktreeRoot = import_node_path22.default.join(parent, dirName);
   try {
     await pexec("git", ["-C", cwd, "fetch", "origin", baseBranch, "--no-tags"], {
       timeout: 3e4
@@ -27170,7 +27295,7 @@ async function createWorktree(input) {
     const msg = err.message;
     if (msg.startsWith("\u5206\u652F ")) throw err;
   }
-  if (import_node_fs20.default.existsSync(worktreeRoot)) {
+  if (import_node_fs21.default.existsSync(worktreeRoot)) {
     throw new Error(`\u76EE\u5F55 ${worktreeRoot} \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E00\u4E2A label \u6216\u6E05\u7406\u540E\u91CD\u8BD5`);
   }
   try {
@@ -27198,8 +27323,8 @@ async function removeWorktree(input) {
     );
     const gitCommonDir = stdout.trim();
     if (!gitCommonDir) throw new Error("empty git-common-dir");
-    const absGitCommon = import_node_path21.default.isAbsolute(gitCommonDir) ? gitCommonDir : import_node_path21.default.resolve(worktreeRoot, gitCommonDir);
-    repoRoot = import_node_path21.default.dirname(absGitCommon);
+    const absGitCommon = import_node_path22.default.isAbsolute(gitCommonDir) ? gitCommonDir : import_node_path22.default.resolve(worktreeRoot, gitCommonDir);
+    repoRoot = import_node_path22.default.dirname(absGitCommon);
   } catch {
     repoRoot = null;
   }
@@ -27211,7 +27336,7 @@ async function removeWorktree(input) {
     } catch (err) {
       const stderr = err.stderr ?? "";
       const lower = stderr.toLowerCase();
-      const vanished = lower.includes("not a working tree") || lower.includes("is not a working tree") || !import_node_fs20.default.existsSync(worktreeRoot);
+      const vanished = lower.includes("not a working tree") || lower.includes("is not a working tree") || !import_node_fs21.default.existsSync(worktreeRoot);
       if (!vanished) {
         throw new Error(`\u6E05\u7406 worktree \u5931\u8D25\uFF1A${formatChildProcessError(err)}`);
       }
@@ -27230,10 +27355,10 @@ async function removeWorktree(input) {
   try {
     const encoded = encodeClaudeProjectDir(worktreeRoot);
     if (encoded) {
-      const projectsRoot = import_node_path21.default.join(import_node_os13.default.homedir(), ".claude", "projects");
-      const target = import_node_path21.default.resolve(projectsRoot, encoded);
-      if (target.startsWith(projectsRoot + import_node_path21.default.sep) && target !== projectsRoot) {
-        import_node_fs20.default.rmSync(target, { recursive: true, force: true });
+      const projectsRoot = import_node_path22.default.join(import_node_os13.default.homedir(), ".claude", "projects");
+      const target = import_node_path22.default.resolve(projectsRoot, encoded);
+      if (target.startsWith(projectsRoot + import_node_path22.default.sep) && target !== projectsRoot) {
+        import_node_fs21.default.rmSync(target, { recursive: true, force: true });
       }
     }
   } catch {
@@ -27466,7 +27591,7 @@ function buildMethodHandlers(deps) {
 async function startDaemon(config) {
   const logger = createLogger({
     level: config.logLevel,
-    file: import_node_path22.default.join(config.dataDir, "clawd.log")
+    file: import_node_path23.default.join(config.dataDir, "clawd.log")
   });
   logger.info("starting clawd", { version, config: { port: config.port, host: config.host, dataDir: config.dataDir } });
   const stateMgr = new StateFileManager({ dataDir: config.dataDir });
@@ -27498,7 +27623,7 @@ async function startDaemon(config) {
   const agents = new AgentsScanner();
   const history = new ClaudeHistoryReader();
   let transport = null;
-  const personaStore = new PersonaStore(import_node_path22.default.join(config.dataDir, "personas"));
+  const personaStore = new PersonaStore(import_node_path23.default.join(config.dataDir, "personas"));
   const defaultsRoot = findDefaultsRoot();
   if (defaultsRoot) {
     seedDefaultPersonas({ store: personaStore, defaultsRoot, logger });
@@ -27512,7 +27637,7 @@ async function startDaemon(config) {
     getAdapter,
     historyReader: history,
     dataDir: config.dataDir,
-    personaRoot: import_node_path22.default.join(config.dataDir, "personas"),
+    personaRoot: import_node_path23.default.join(config.dataDir, "personas"),
     personaStore,
     ownerDisplayName,
     mode: config.mode,
@@ -27730,8 +27855,8 @@ async function startDaemon(config) {
       const lines = [
         `Tunnel:      ${r.url}`,
         ...resolvedAuthToken ? [`Connect:     ${connectUrl}`] : [],
-        `Frpc config: ${import_node_path22.default.join(config.dataDir, "frpc.toml")}`,
-        `Frpc log:    ${import_node_path22.default.join(config.dataDir, "frpc.log")}`
+        `Frpc config: ${import_node_path23.default.join(config.dataDir, "frpc.toml")}`,
+        `Frpc log:    ${import_node_path23.default.join(config.dataDir, "frpc.log")}`
       ];
       const width = Math.max(...lines.map((l) => l.length));
       const bar = "\u2550".repeat(width + 4);
@@ -27744,8 +27869,8 @@ ${bar}
 
 `);
       try {
-        const connectPath = import_node_path22.default.join(config.dataDir, "connect.txt");
-        import_node_fs21.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
+        const connectPath = import_node_path23.default.join(config.dataDir, "connect.txt");
+        import_node_fs22.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
       } catch {
       }
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.60",
+  "version": "0.2.61-beta.98.15637d6",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",