@clawling/clawchat-plugin-openclaw 2026.8.2-1 → 2026.8.4-1

package/dist/src/liveware-sample.js

@@ -15,6 +15,35 @@ export const LIVEWARE_SAMPLE_APP_NAME = "Liveware Sample";
 export const MAX_SAMPLE_FILE_BYTES = 512 * 1024;
 /** Files the agent owns at runtime; preserved across sample upgrades. */
 const USER_DATA_FILES = ["state.json", "events.jsonl"];
+/**
+ * Windows refuses to unlink or rename a directory while ANY file inside it is
+ * still open, and reports it as a sharing violation (EPERM/EBUSY/EACCES) or a
+ * non-empty directory. A still-draining sample server, an antivirus scan or the
+ * search indexer is enough to trigger it, and all of those clear within
+ * milliseconds — so a short bounded retry turns a hard install failure into a
+ * brief pause. On POSIX these codes essentially never appear here and the first
+ * attempt always wins, so the retry costs nothing.
+ */
+const FS_SWAP_RETRY_DELAYS_MS = [50, 150, 400];
+const TRANSIENT_FS_CODES = new Set(["EPERM", "EACCES", "EBUSY", "ENOTEMPTY"]);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function withFsSwapRetry(op) {
+    let lastError;
+    for (let attempt = 0; attempt <= FS_SWAP_RETRY_DELAYS_MS.length; attempt += 1) {
+        try {
+            return await op();
+        }
+        catch (err) {
+            lastError = err;
+            const code = err.code ?? "";
+            const delay = FS_SWAP_RETRY_DELAYS_MS[attempt];
+            if (!TRANSIENT_FS_CODES.has(code) || delay === undefined)
+                break;
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
 function livewaresBase(base, ref) {
     return `${(base ?? OFFICIAL_SKILLS_BASE).replace(/\/+$/, "")}/${ref}/livewares`;
 }
@@ -116,6 +145,14 @@ export async function downloadLivewareSample(opts) {
     if (await localInstallMatches(appDir, entry)) {
         return { version: entry.version, appDir, reused: true };
     }
+    // Sweep app.old-* left behind when a previous swap could not delete the old
+    // tree (a handle was still open then, but is not now). Best effort: a dir we
+    // still cannot remove is simply retried next run.
+    for (const name of await fs.promises.readdir(opts.sampleRoot).catch(() => [])) {
+        if (name.startsWith("app.old-")) {
+            await fs.promises.rm(path.join(opts.sampleRoot, name), { recursive: true, force: true }).catch(() => { });
+        }
+    }
     const tmpDir = path.join(opts.sampleRoot, `app.tmp-${process.pid}`);
     await fs.promises.rm(tmpDir, { recursive: true, force: true });
     await fs.promises.mkdir(tmpDir, { recursive: true });
@@ -138,8 +175,18 @@ export async function downloadLivewareSample(opts) {
                 await fs.promises.copyFile(prev, path.join(tmpDir, name));
             }
         }
-        await fs.promises.rm(appDir, { recursive: true, force: true });
-        await fs.promises.rename(tmpDir, appDir);
+        // Swap by moving the old tree ASIDE rather than deleting it first. On
+        // Windows the delete is the step most likely to lose a race with an open
+        // handle, and doing it first leaves no app/ at all when it fails. Renaming
+        // aside puts the new tree in place first and makes the delete best-effort:
+        // a leftover app.old-<pid> is swept on the next run, never a broken install.
+        const oldDir = path.join(opts.sampleRoot, `app.old-${process.pid}`);
+        await fs.promises.rm(oldDir, { recursive: true, force: true }).catch(() => { });
+        if (fs.existsSync(appDir)) {
+            await withFsSwapRetry(() => fs.promises.rename(appDir, oldDir));
+        }
+        await withFsSwapRetry(() => fs.promises.rename(tmpDir, appDir));
+        await fs.promises.rm(oldDir, { recursive: true, force: true }).catch(() => { });
         return { version: entry.version, appDir };
     }
     catch (err) {
@@ -147,6 +194,35 @@ export async function downloadLivewareSample(opts) {
         throw err;
     }
 }
+/**
+ * Terminate a child and everything it spawned.
+ *
+ * POSIX: `SIGTERM` to the child is what we want and what the child expects.
+ *
+ * Windows: there are no signals. `child.kill()` maps to TerminateProcess on
+ * that one process, so any grandchild the liveware agent spawned survives —
+ * orphaned, still holding the sample port, and invisible to the next boot,
+ * which then fails to bind. `taskkill /T /F` takes the whole tree down.
+ * Fire-and-forget: we never wait on it, and a failure (already dead, no such
+ * pid) falls through to the ordinary kill().
+ */
+export function killProcessTree(child, execFileFn = nodeExecFile) {
+    if (!child)
+        return;
+    if (process.platform === "win32" && typeof child.pid === "number") {
+        try {
+            execFileFn("taskkill", ["/pid", String(child.pid), "/T", "/F"], () => { });
+            return;
+        }
+        catch {
+            // taskkill missing or spawn refused — fall back to the plain kill below.
+        }
+    }
+    try {
+        child.kill("SIGTERM");
+    }
+    catch { /* already dead */ }
+}
 const SERVER_START_TIMEOUT_MS = 10_000;
 const TUNNEL_START_TIMEOUT_MS = 30_000;
 const CLI_TIMEOUT_MS = 30_000;
@@ -164,10 +240,7 @@ function waitForOutput(child, match, timeoutMs, label) {
             child.stderr?.removeListener("data", onData);
             child.removeListener("exit", onExit);
             if (err) {
-                try {
-                    child.kill("SIGTERM");
-                }
-                catch { /* already dead */ }
+                killProcessTree(child);
                 reject(err);
             }
             else {
@@ -535,10 +608,7 @@ export class LivewareSampleSupervisor {
     killChildren() {
         this.generation += 1; // invalidate pending exit handlers before killing
         for (const child of [this.serverChild, this.tunnelChild]) {
-            try {
-                child?.kill("SIGTERM");
-            }
-            catch { /* already dead */ }
+            killProcessTree(child, this.deps.execFileFn);
         }
         this.serverChild = null;
         this.tunnelChild = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.8.2-1",
+  "version": "2026.8.4-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/liveware-sample.ts

@@ -20,6 +20,36 @@ export const MAX_SAMPLE_FILE_BYTES = 512 * 1024;
 /** Files the agent owns at runtime; preserved across sample upgrades. */
 const USER_DATA_FILES = ["state.json", "events.jsonl"];
 
+/**
+ * Windows refuses to unlink or rename a directory while ANY file inside it is
+ * still open, and reports it as a sharing violation (EPERM/EBUSY/EACCES) or a
+ * non-empty directory. A still-draining sample server, an antivirus scan or the
+ * search indexer is enough to trigger it, and all of those clear within
+ * milliseconds — so a short bounded retry turns a hard install failure into a
+ * brief pause. On POSIX these codes essentially never appear here and the first
+ * attempt always wins, so the retry costs nothing.
+ */
+const FS_SWAP_RETRY_DELAYS_MS = [50, 150, 400];
+const TRANSIENT_FS_CODES = new Set(["EPERM", "EACCES", "EBUSY", "ENOTEMPTY"]);
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+async function withFsSwapRetry<T>(op: () => Promise<T>): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= FS_SWAP_RETRY_DELAYS_MS.length; attempt += 1) {
+    try {
+      return await op();
+    } catch (err) {
+      lastError = err;
+      const code = (err as NodeJS.ErrnoException).code ?? "";
+      const delay = FS_SWAP_RETRY_DELAYS_MS[attempt];
+      if (!TRANSIENT_FS_CODES.has(code) || delay === undefined) break;
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
 export interface LivewareSampleManifestFile {
   path: string;
   sha256: string;
@@ -151,6 +181,15 @@ export async function downloadLivewareSample(opts: {
   if (await localInstallMatches(appDir, entry)) {
     return { version: entry.version, appDir, reused: true };
   }
+  // Sweep app.old-* left behind when a previous swap could not delete the old
+  // tree (a handle was still open then, but is not now). Best effort: a dir we
+  // still cannot remove is simply retried next run.
+  for (const name of await fs.promises.readdir(opts.sampleRoot).catch(() => [])) {
+    if (name.startsWith("app.old-")) {
+      await fs.promises.rm(path.join(opts.sampleRoot, name), { recursive: true, force: true }).catch(() => {});
+    }
+  }
+
   const tmpDir = path.join(opts.sampleRoot, `app.tmp-${process.pid}`);
   await fs.promises.rm(tmpDir, { recursive: true, force: true });
   await fs.promises.mkdir(tmpDir, { recursive: true });
@@ -173,8 +212,18 @@ export async function downloadLivewareSample(opts: {
         await fs.promises.copyFile(prev, path.join(tmpDir, name));
       }
     }
-    await fs.promises.rm(appDir, { recursive: true, force: true });
-    await fs.promises.rename(tmpDir, appDir);
+    // Swap by moving the old tree ASIDE rather than deleting it first. On
+    // Windows the delete is the step most likely to lose a race with an open
+    // handle, and doing it first leaves no app/ at all when it fails. Renaming
+    // aside puts the new tree in place first and makes the delete best-effort:
+    // a leftover app.old-<pid> is swept on the next run, never a broken install.
+    const oldDir = path.join(opts.sampleRoot, `app.old-${process.pid}`);
+    await fs.promises.rm(oldDir, { recursive: true, force: true }).catch(() => {});
+    if (fs.existsSync(appDir)) {
+      await withFsSwapRetry(() => fs.promises.rename(appDir, oldDir));
+    }
+    await withFsSwapRetry(() => fs.promises.rename(tmpDir, appDir));
+    await fs.promises.rm(oldDir, { recursive: true, force: true }).catch(() => {});
     return { version: entry.version, appDir };
   } catch (err) {
     await fs.promises.rm(tmpDir, { recursive: true, force: true });
@@ -185,6 +234,34 @@ export async function downloadLivewareSample(opts: {
 export type SpawnLike = typeof nodeSpawn;
 export type ExecFileLike = typeof nodeExecFile;
 
+/**
+ * Terminate a child and everything it spawned.
+ *
+ * POSIX: `SIGTERM` to the child is what we want and what the child expects.
+ *
+ * Windows: there are no signals. `child.kill()` maps to TerminateProcess on
+ * that one process, so any grandchild the liveware agent spawned survives —
+ * orphaned, still holding the sample port, and invisible to the next boot,
+ * which then fails to bind. `taskkill /T /F` takes the whole tree down.
+ * Fire-and-forget: we never wait on it, and a failure (already dead, no such
+ * pid) falls through to the ordinary kill().
+ */
+export function killProcessTree(
+  child: ChildProcess | null | undefined,
+  execFileFn: ExecFileLike = nodeExecFile,
+): void {
+  if (!child) return;
+  if (process.platform === "win32" && typeof child.pid === "number") {
+    try {
+      execFileFn("taskkill", ["/pid", String(child.pid), "/T", "/F"], () => {});
+      return;
+    } catch {
+      // taskkill missing or spawn refused — fall back to the plain kill below.
+    }
+  }
+  try { child.kill("SIGTERM"); } catch { /* already dead */ }
+}
+
 const SERVER_START_TIMEOUT_MS = 10_000;
 const TUNNEL_START_TIMEOUT_MS = 30_000;
 const CLI_TIMEOUT_MS = 30_000;
@@ -207,7 +284,7 @@ function waitForOutput(
       child.stderr?.removeListener("data", onData);
       child.removeListener("exit", onExit);
       if (err) {
-        try { child.kill("SIGTERM"); } catch { /* already dead */ }
+        killProcessTree(child);
         reject(err);
       } else {
         resolve(value as string);
@@ -670,7 +747,7 @@ export class LivewareSampleSupervisor {
   private killChildren(): void {
     this.generation += 1; // invalidate pending exit handlers before killing
     for (const child of [this.serverChild, this.tunnelChild]) {
-      try { child?.kill("SIGTERM"); } catch { /* already dead */ }
+      killProcessTree(child, this.deps.execFileFn);
     }
     this.serverChild = null;
     this.tunnelChild = null;