create-principles-disciple 1.147.6 → 1.147.8

package/release-manager/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;
@@ -3360,40 +3444,124 @@ function assertUsableWorkspaceDir(workspaceDir) {
         'Re-run with the path quoted, so the shell cannot strip its separators:\n' +
         '  --workspace "D:\\.openclaw\\workspace"');
 }
-async function createConfigFile(workspaceDir, channels) {
-    const configDir = getOpenClawDir();
-    const configPath = path.join(configDir, 'principles-disciple.json');
+/**
+ * Where the OpenClaw plugin (and therefore the MCP launcher) reads the
+ * Owner-declared governance workspace. The gateway process, hook processes and
+ * MCP children all run with different environments, and the MCP child has its
+ * environment sanitized by the host (PD_WORKSPACE_DIR / HOME are stripped), so
+ * this FILE is the only signal every one of them can see.
+ */
+const OPENCLAW_PD_CONFIG_FILENAME = 'principles-disciple.json';
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Same-directory identity for a workspace pointer (Windows is case-insensitive). */
+function sameWorkspaceTarget(left, right) {
+    const normalize = (value) => {
+        const resolved = path.resolve(value);
+        const trimmed = resolved.length > 1 ? resolved.replace(/[\\/]+$/, '') : resolved;
+        return process.platform === 'win32' ? trimmed.toLowerCase() : trimmed;
+    };
+    return normalize(left) === normalize(right);
+}
+/**
+ * Read the existing declaration as UNTRUSTED input (it is a plain file on disk)
+ * and classify it. Never overwrites and never silently repairs anything.
+ */
+export function inspectOpenClawWorkspaceDeclaration(workspaceDir) {
+    const configPath = path.join(getOpenClawDir(), OPENCLAW_PD_CONFIG_FILENAME);
+    if (!existsSync(configPath))
+        return { configPath, state: 'absent' };
+    let raw;
+    try {
+        raw = readFileSync(configPath, 'utf-8');
+    }
+    catch (e) {
+        return { configPath, state: 'unreadable', reason: describeError(e) };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        return { configPath, state: 'invalid', reason: `it is not valid JSON (${describeError(e)})` };
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return { configPath, state: 'invalid', reason: 'the root value is not a JSON object' };
+    }
+    const declaredRaw = Object.hasOwn(parsed, 'workspace') ? Reflect.get(parsed, 'workspace') : undefined;
+    if (typeof declaredRaw !== 'string' || declaredRaw.trim().length === 0) {
+        return { configPath, state: 'invalid', reason: 'it has no non-empty string "workspace" field' };
+    }
+    const declared = declaredRaw.trim();
+    if (!isUsableWorkspacePointer(declared)) {
+        return {
+            configPath,
+            state: 'invalid',
+            declaredWorkspace: declared,
+            reason: 'the "workspace" value does not name one fixed absolute directory',
+        };
+    }
+    if (!sameWorkspaceTarget(declared, workspaceDir)) {
+        return { configPath, state: 'conflict', declaredWorkspace: declared };
+    }
+    return { configPath, state: 'compatible', declaredWorkspace: declared };
+}
+function throwOnIncompatibleDeclaration(inspection, workspaceDir) {
+    if (inspection.state === 'absent' || inspection.state === 'compatible')
+        return;
+    if (inspection.state === 'conflict') {
+        throw new Error('An existing OpenClaw PD config declares a DIFFERENT workspace; it was left unchanged.\n' +
+            `  Config:    ${inspection.configPath}\n` +
+            `  Declared:  ${JSON.stringify(inspection.declaredWorkspace)}\n` +
+            `  Requested: ${JSON.stringify(path.resolve(workspaceDir))}\n` +
+            'The pd-recall MCP server can only serve the workspace declared in this file, so the installer\n' +
+            'never overwrites it. Otherwise the host would report a successful install while recall served\n' +
+            'another workspace.\n' +
+            `  To keep the existing workspace, re-run with --workspace ${JSON.stringify(inspection.declaredWorkspace)}.\n` +
+            `  To switch deliberately, back up ${inspection.configPath}, remove it, then re-run for the new workspace.`);
+    }
+    throw new Error(`The existing OpenClaw PD config cannot be verified and was left unchanged (${inspection.reason}).\n` +
+        `  Config: ${inspection.configPath}\n` +
+        'Expected a JSON object with an absolute "workspace" string.\n' +
+        '  Fix it manually, or back it up and remove it, then re-run the installer.');
+}
+/**
+ * Read-only preflight: refuse BEFORE any runtime mutation when the existing
+ * declaration points somewhere else (or cannot be trusted). This is the check
+ * that keeps an install from "succeeding" while pd-recall serves a different
+ * workspace.
+ */
+export function assertOpenClawWorkspaceDeclarationCompatible(workspaceDir) {
+    throwOnIncompatibleDeclaration(inspectOpenClawWorkspaceDeclaration(workspaceDir), workspaceDir);
+}
+/**
+ * Ensure the OpenClaw plugin can locate the governance workspace through the
+ * file declaration. Idempotent: a compatible existing declaration is left
+ * byte-identical (no rewrite, no installedAt churn). A conflicting/invalid one
+ * fails loud and is never overwritten.
+ */
+export async function ensureOpenClawWorkspaceDeclaration(workspaceDir, channels) {
     // Defense in depth: the same refusal the install entry makes, kept here
     // because this is the only writer of the pointer the plugin reads on every
     // hook, and other callers reach it without passing through install().
     assertUsableWorkspaceDir(workspaceDir);
-    let existingChannels = null;
-    let existingFeatures = null;
-    if (existsSync(configPath)) {
-        const existingRaw = readFileSync(configPath, 'utf-8');
-        const existing = JSON.parse(existingRaw);
-        if (existing !== null && typeof existing === 'object' && !Array.isArray(existing)) {
-            const existingObj = existing;
-            if (Object.hasOwn(existingObj, 'channels') && Array.isArray(existingObj.channels)) {
-                existingChannels = existingObj.channels.filter((c) => typeof c === 'string');
-            }
-            if (Object.hasOwn(existingObj, 'features') && Array.isArray(existingObj.features)) {
-                existingFeatures = existingObj.features.filter((f) => typeof f === 'string');
-            }
-        }
+    const inspection = inspectOpenClawWorkspaceDeclaration(workspaceDir);
+    throwOnIncompatibleDeclaration(inspection, workspaceDir);
+    if (inspection.state === 'compatible') {
+        return { configPath: inspection.configPath, action: 'unchanged' };
     }
+    const resolvedWorkspace = path.resolve(workspaceDir);
     const config = {
-        workspace: workspaceDir,
-        state: path.join(workspaceDir, '.state'),
-        channels: existingChannels ?? channels,
+        workspace: resolvedWorkspace,
+        state: path.join(resolvedWorkspace, '.state'),
+        channels,
         installedAt: new Date().toISOString(),
         mvpFirst: true,
     };
-    if (existingFeatures) {
-        config.features = existingFeatures;
-    }
-    await fse.ensureDir(configDir);
-    await fse.writeJson(configPath, config, { spaces: 2 });
+    await fse.ensureDir(path.dirname(inspection.configPath));
+    await fse.writeJson(inspection.configPath, config, { spaces: 2 });
+    return { configPath: inspection.configPath, action: 'created' };
 }
 /**
  * ADR-0020 §2.3: Run host installers for the selected HostTarget.
@@ -3788,6 +3956,14 @@ transaction) {
         // (permissions / invalid path) flows into the unified failure result
         // below instead of rejecting the install() promise (P1 review finding).
         await fse.ensureDir(path.resolve(options.workspaceDir));
+        // OpenClaw only: the MCP launcher re-derives the governance workspace from
+        // this PD-owned file, because the host strips PD_WORKSPACE_DIR / HOME from
+        // MCP children. An existing declaration for a DIFFERENT workspace must
+        // refuse the install BEFORE any runtime mutation — otherwise the install
+        // would report success while pd-recall served another workspace.
+        if (installsOpenClaw(options.host)) {
+            assertOpenClawWorkspaceDeclarationCompatible(options.workspaceDir);
+        }
         if (spinner)
             updateProgress(spinner, stepIndex, 'Checking built plugin...');
         await checkBuiltPlugin(pluginDir);
@@ -4032,7 +4208,9 @@ transaction) {
         stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Creating config...');
-        await createConfigFile(options.workspaceDir, options.channels);
+        if (installsOpenClaw(options.host)) {
+            await ensureOpenClawWorkspaceDeclaration(options.workspaceDir, options.channels);
+        }
         stepIndex++;
         // PRI-686 Fix C: after pinning PD canonical, check OpenClaw's resolved
         // main-agent workspace against it. Read-only; a divergence means PD