create-principles-disciple 1.147.5 → 1.147.7

package/dist/installer.js

@@ -1553,6 +1553,11 @@ export async function checkBuiltPlugin(pluginDir) {
         }
     }
 }
+function filesystemErrorCode(error) {
+    if (typeof error !== 'object' || error === null || !Object.hasOwn(error, 'code'))
+        return undefined;
+    return error.code;
+}
 /**
  * PRI-1102: a target that exists as a DANGLING link (an interrupted install
  * left a reparse point whose target is gone) is not a directory the installer
@@ -1574,14 +1579,23 @@ export async function preparePluginInstallTarget(targetDir) {
         throw new Error(`Cannot inspect plugin install target ${targetDir}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
     if (stats !== undefined && stats.isSymbolicLink()) {
-        let resolves = true;
+        let targetAbsent = false;
         try {
             realpathSync(targetDir);
         }
-        catch {
-            resolves = false;
+        catch (error) {
+            const code = filesystemErrorCode(error);
+            if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+                // EACCES/EPERM/... means the link target may still be a live install
+                // this process cannot read. Removing the link would destroy it, so
+                // fail closed and let the caller report the refusal.
+                throw new Error(`Cannot resolve plugin install target ${targetDir}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+            // Confirmed absent target (ENOENT/ENOTDIR) — the link itself is the
+            // residue of an interrupted install.
+            targetAbsent = true;
         }
-        if (!resolves) {
+        if (targetAbsent) {
             // fs-extra's remove unlinks the reparse point instead of traversing it.
             await fse.remove(targetDir);
             logger.warn(`Removed dangling link at ${targetDir} (target missing) — rebuilding the plugin install directory.`);
@@ -1589,35 +1603,105 @@ export async function preparePluginInstallTarget(targetDir) {
     }
     await fse.ensureDir(targetDir);
 }
-/**
- * PRI-1102: a rollback is only as good as the state it returns to. The
- * pre-run state can itself be incomplete (a component directory the previous
- * run never finished, a link whose target is gone), so "restored" must not be
- * reported as a healthy install without checking what the restored paths
- * actually resolve to.
- */
-export function describeRestoredStateGaps() {
-    const gaps = [];
-    for (const dir of [getPluginExtDir(), getPdRuntimeDir()]) {
-        let stats;
+function restoredTreeRequirements() {
+    return [
+        // The runtime root itself (type + link resolution only).
+        { dir: getPdRuntimeDir(), entries: [], openClawOnly: false },
+        {
+            dir: getInstalledConsoleDir(),
+            entries: [path.join('dist', 'server.js'), path.join('dist', 'web', 'index.html')],
+            openClawOnly: false,
+        },
+        { dir: getInstalledPdCliDir(), entries: [path.join('dist', 'index.js')], openClawOnly: false },
+        { dir: getInstalledPluginDir(), entries: [path.join('dist', 'bundle.js'), 'openclaw.plugin.json'], openClawOnly: false },
+        {
+            dir: getPluginExtDir(),
+            entries: [path.join('dist', 'bundle.js'), 'openclaw.plugin.json', 'package.json'],
+            openClawOnly: true,
+        },
+    ];
+}
+function describeRestoredDirGap(dir, gaps) {
+    let stats;
+    try {
+        stats = lstatSync(dir, { throwIfNoEntry: false });
+    }
+    catch (error) {
+        gaps.push(`${dir} (unreadable: ${error instanceof Error ? error.message : String(error)})`);
+        return false;
+    }
+    if (stats === undefined) {
+        gaps.push(`${dir} (missing)`);
+        return false;
+    }
+    if (stats.isSymbolicLink()) {
         try {
-            stats = lstatSync(dir, { throwIfNoEntry: false });
+            realpathSync(dir);
         }
         catch (error) {
-            gaps.push(`${dir} (unreadable: ${error instanceof Error ? error.message : String(error)})`);
-            continue;
+            const code = filesystemErrorCode(error);
+            gaps.push(`${dir} (${code === 'ENOENT' || code === 'ENOTDIR' ? 'dangling link' : 'unresolvable link'})`);
+            return false;
         }
-        if (stats === undefined) {
-            gaps.push(`${dir} (missing)`);
-            continue;
+    }
+    else if (!stats.isDirectory()) {
+        gaps.push(`${dir} (not a directory)`);
+        return false;
+    }
+    return true;
+}
+function describeRestoredEntryGap(entry, gaps) {
+    let stats;
+    try {
+        stats = lstatSync(entry, { throwIfNoEntry: false });
+    }
+    catch (error) {
+        gaps.push(`${entry} (unreadable: ${error instanceof Error ? error.message : String(error)})`);
+        return;
+    }
+    if (stats === undefined) {
+        gaps.push(`${entry} (missing)`);
+        return;
+    }
+    if (stats.isSymbolicLink()) {
+        try {
+            realpathSync(entry);
         }
-        if (stats.isSymbolicLink()) {
-            try {
-                realpathSync(dir);
-            }
-            catch {
-                gaps.push(`${dir} (dangling link)`);
-            }
+        catch (error) {
+            const code = filesystemErrorCode(error);
+            gaps.push(`${entry} (${code === 'ENOENT' || code === 'ENOTDIR' ? 'dangling link' : 'unresolvable link'})`);
+            return;
+        }
+        // realpath only proves the target EXISTS. The entry is consumed as a file
+        // at runtime, so a link to a directory is just as unusable as a missing
+        // file path. stat follows the link and reports the target type.
+        let targetStats;
+        try {
+            targetStats = statSync(entry);
+        }
+        catch (error) {
+            const code = filesystemErrorCode(error);
+            gaps.push(`${entry} (${code === 'ENOENT' || code === 'ENOTDIR' ? 'dangling link' : 'unresolvable link'})`);
+            return;
+        }
+        if (!targetStats.isFile()) {
+            gaps.push(`${entry} (not a file)`);
+        }
+        return;
+    }
+    if (!stats.isFile()) {
+        gaps.push(`${entry} (not a file)`);
+    }
+}
+export function describeRestoredStateGaps() {
+    const gaps = [];
+    for (const requirement of restoredTreeRequirements()) {
+        if (requirement.openClawOnly && !installsOpenClaw(activeHostTarget))
+            continue;
+        if (!describeRestoredDirGap(requirement.dir, gaps))
+            continue;
+        for (const entry of requirement.entries) {
+            describeRestoredEntryGap(path.join(requirement.dir, entry), gaps);
         }
     }
     return gaps;