create-principles-disciple 1.132.2 → 1.132.4

package/dist/installer.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, mkdirSync, rmSync, copyFileSync, cpSync, renameSync, chmodSync, symlinkSync } from 'fs';
 import { createHash, randomUUID } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
 import fse from 'fs-extra';
 import * as path from 'path';
 import * as http from 'http';
@@ -12,6 +13,7 @@ import { t } from './i18n.js';
 import { generateConfigYamlContent, ExistingConfigVerifyInfraError, validateExistingConfigYamlForPreserve, getConfigYamlPath, readEnabledChannelsFromConfigYaml, getOpenClawDir, getPdDir, getPdRuntimeDir, getInstallManifestPath, getPdRuntimeBackupsDir, getPluginExtDir, getInstalledPluginDir, getInstalledLayoutPackageDir, getPdBackupsDir, getInstalledPdCliDir, getInstalledBinDir, getInstalledConsoleDir, isWindows, } from './mvp-config.js';
 import { getHostInstallers } from './installers/index.js';
 import { mergeInstallManifestWorkspaces, parseInstallManifest } from '@principles/install-layout';
+import { detectOpenClawMainWorkspaceDivergence } from './utils/workspace-divergence.js';
 import { applySkillLanguageSelection } from './skill-language.js';
 import { parseReleaseAssetIdentity, parseReleaseAssetManifest, ReleaseAssetManifestError, verifyReleaseAssetManifestAsync, verifyReleaseAssetTarget, } from './update/release-asset-manifest.js';
 import { appendJournalTransition } from './update/transaction-journal.js';
@@ -253,6 +255,90 @@ function legacyNpmInstallEnabled() {
     const value = process.env.PD_ALLOW_LEGACY_NPM_INSTALL;
     return value === '1' || value === 'true';
 }
+const NPM_DISTRIBUTED_COMPONENTS = [
+    ['Core', 'core'],
+    ['Host runtime', 'host-runtime'],
+    ['Codex adapter', 'codex-adapter'],
+    ['Plugin', 'plugin'],
+    ['PD CLI', 'pd-cli'],
+    ['Console', 'console'],
+    ['Install layout', 'install-layout'],
+];
+// Components whose install step demands MORE than the generic
+// package.json+dist shape check — the per-component extra files are
+// preflighted here so the form-gate refusal is exact (a truncated package
+// must fail BEFORE any mutation, matching the per-component install
+// requirements instead of discovering them mid-deployment).
+const NPM_DISTRIBUTED_REQUIRED_FILES = {
+    'release-manager': ['package.json', path.join('dist', 'update', 'release-manager-authority.js')],
+    console: ['package.json', path.join('dist', 'server.js'), path.join('dist', 'web', 'index.html')],
+};
+function releaseAssetPresent(pluginDir) {
+    return existsSync(path.join(pluginDir, '_release', 'asset.json'));
+}
+/**
+ * Form-gate for the npm-distributed package shape: every bundled component
+ * directory must carry its required files. Returns the missing items
+ * (empty = complete) so the refusal can name them (rc-3: fail loud with
+ * specifics, not a generic "invalid asset"). release-manager and console
+ * are checked against their ACTUAL install-time requirements — they are
+ * consumed unconditionally during deployment, so a package missing them
+ * must be refused before the backup step, not mid-copy (review blocker,
+ * PR #1525).
+ */
+function missingNpmDistributedComponents(pluginDir) {
+    const missing = [];
+    // Components with exact install-time file demands replace the generic
+    // package.json+dist check (console appears in both lists — the exact list
+    // subsumes the generic one, so dedupe to avoid reporting each miss twice).
+    const exactShapeComponents = new Set(Object.keys(NPM_DISTRIBUTED_REQUIRED_FILES));
+    const componentDirs = [
+        ...NPM_DISTRIBUTED_COMPONENTS.map(([, directory]) => directory).filter((directory) => !exactShapeComponents.has(directory)),
+        ...exactShapeComponents,
+    ];
+    for (const componentDirectory of componentDirs) {
+        const componentDir = path.join(pluginDir, componentDirectory);
+        const requiredFiles = NPM_DISTRIBUTED_REQUIRED_FILES[componentDirectory]
+            ?? ['package.json', componentDirectory === 'plugin' ? '' : 'dist'];
+        for (const requiredFile of requiredFiles) {
+            if (!existsSync(path.join(componentDir, requiredFile))) {
+                missing.push(`${componentDirectory}/${requiredFile}`);
+            }
+        }
+    }
+    return missing;
+}
+/**
+ * Decide which payload shape this package instance carries and whether
+ * registry dependency resolution (npm install) is required. Env override
+ * first (explicit operator intent), then the physical shape: a present
+ * `_release/asset.json` always takes the self-contained path (a present
+ * but CORRUPT asset still fails hard inside the preflight — never
+ * silently falling back to registry resolution); a package without the
+ * release asset but with complete component trees is the npm-distributed
+ * shape and resolves dependencies from the registry.
+ */
+export function decideInstallPayloadMode(pluginDir) {
+    if (legacyNpmInstallEnabled())
+        return 'npm-distributed';
+    if (releaseAssetPresent(pluginDir))
+        return 'self-contained';
+    return 'npm-distributed';
+}
+// Per-run payload mode, set by install() alongside activeHostTarget (same
+// module-level idiom) — prepareComponentDependencies' call sites are the
+// per-component wrappers, which have no natural parameter path from install().
+let activePayloadMode = 'self-contained';
+/**
+ * Whether registry dependency resolution (npm install / global root
+ * discovery) may run: true for the npm-distributed payload shape and the
+ * PD_ALLOW_LEGACY_NPM_INSTALL recovery path. Host installers consume this
+ * gate instead of re-reading the env (their concern is payload shape, not
+ * the specific env var).
+ */
+export function isNpmDependencyResolutionEnabled() {
+    return activePayloadMode === 'npm-distributed';
+}
 /**
  * Supported release assets are self-contained: installation validates the
  * copied component and never resolves dependencies or runs lifecycle scripts.
@@ -363,7 +449,7 @@ export async function preflightSelfContainedReleaseAsset(assetDir) {
     }
 }
 async function prepareComponentDependencies(cwd, componentName) {
-    if (!legacyNpmInstallEnabled()) {
+    if (activePayloadMode === 'self-contained') {
         await prepareBundledComponentDependencies(cwd, componentName);
         return;
     }
@@ -1123,6 +1209,58 @@ function verifyPdCliShim() {
     })();
     return { localOk, globalOk, localPath: localShim, localError };
 }
+/**
+ * PRI-672: the ReleaseManager authority module ships as the release-manager/
+ * payload component (package name create-principles-disciple). Installed to
+ * ~/.pd/runtime so the console's rewritten `create-principles-disciple`
+ * dependency resolves; installConsole creates the resolution link.
+ */
+function getInstalledReleaseManagerDir() {
+    return path.join(getPdRuntimeDir(), 'release-manager');
+}
+function installBundledReleaseManagerPackage(pluginDir) {
+    const source = path.join(pluginDir, 'release-manager');
+    const destination = getInstalledReleaseManagerDir();
+    if (!existsSync(path.join(source, 'package.json')) || !existsSync(path.join(source, 'dist', 'update', 'release-manager-authority.js'))) {
+        throw new Error('Bundled release-manager component is incomplete (missing package.json or dist/update/release-manager-authority.js). Re-run the installer with a current package.');
+    }
+    rmSync(destination, { recursive: true, force: true });
+    cpSync(source, destination, { recursive: true });
+}
+/**
+ * PR #1525 review: the npm-distributed payload ships release-manager/ as
+ * package.json + dist only — no node_modules. Without its own dependencies
+ * (tuf-js / @tufjs/models) the authority module's static import chain
+ * (release-manager → trust-metadata → tuf-js) cannot resolve, and the gap
+ * would only surface later as `installer_missing` in the console. The
+ * self-contained payload ships the bundle-time npm ci node_modules, so
+ * registry resolution runs for the npm-distributed shape only.
+ */
+async function installReleaseManagerDependencies() {
+    if (!isNpmDependencyResolutionEnabled())
+        return;
+    await runNpmInstall(getInstalledReleaseManagerDir(), 'ReleaseManager');
+}
+/**
+ * PR #1525 review smoke: import the REAL authority module from the installed
+ * tree so a dependency gap fails the install loudly here with a structured
+ * message instead of surfacing as `installer_missing` at console runtime.
+ * Mode-independent — the self-contained payload's shipped node_modules is
+ * proven the same way.
+ */
+async function verifyReleaseManagerAuthorityImports() {
+    const authorityPath = path.join(getInstalledReleaseManagerDir(), 'dist', 'update', 'release-manager-authority.js');
+    if (!existsSync(authorityPath)) {
+        throw new Error('Installed release-manager authority module not found — installation is incomplete.');
+    }
+    try {
+        await import(pathToFileURL(authorityPath).href);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`ReleaseManager authority module failed to load — its runtime dependencies are incomplete. Re-run the installer to repair the installation. (${detail})`, { cause: error });
+    }
+}
 function installConsole(consoleDir) {
     const consoleSrc = path.join(consoleDir, 'console');
     const consoleDest = getInstalledConsoleDir();
@@ -1149,6 +1287,19 @@ function installConsole(consoleDir) {
             symlinkSync(path.relative(path.dirname(pluginLinkPath), installedPluginDir()), pluginLinkPath, 'dir');
         }
     }
+    // PRI-672: console resolves its create-principles-disciple dependency (the
+    // ReleaseManager authority module, rewritten to file:../release-manager by
+    // bundle-plugin.mjs) through this link into ~/.pd/runtime.
+    const releaseManagerLinkPath = path.join(consoleDest, 'node_modules', 'create-principles-disciple');
+    if (!existsSync(releaseManagerLinkPath)) {
+        mkdirSync(path.dirname(releaseManagerLinkPath), { recursive: true });
+        if (isWindows()) {
+            symlinkSync(getInstalledReleaseManagerDir(), releaseManagerLinkPath, 'junction');
+        }
+        else {
+            symlinkSync(path.relative(path.dirname(releaseManagerLinkPath), getInstalledReleaseManagerDir()), releaseManagerLinkPath, 'dir');
+        }
+    }
 }
 function getInstalledCoreDir() {
     return path.join(getPdRuntimeDir(), 'core');
@@ -1747,7 +1898,12 @@ export async function install(options, pluginDir, mode = {}) {
     const quiet = mode.quiet === true;
     const nonInteractive = mode.nonInteractive ?? quiet;
     activeHostTarget = options.host;
-    if (!legacyNpmInstallEnabled()) {
+    // Decide the payload shape once: self-contained (release asset) or
+    // npm-distributed (registry-resolved dependencies). A present `_release`
+    // asset keeps the hard preflight; the npm-distributed shape must pass
+    // the component form-gate or fail loud naming what is missing.
+    activePayloadMode = decideInstallPayloadMode(pluginDir);
+    if (activePayloadMode === 'self-contained') {
         try {
             await preflightSelfContainedReleaseAsset(pluginDir);
         }
@@ -1777,6 +1933,26 @@ export async function install(options, pluginDir, mode = {}) {
             };
         }
     }
+    else {
+        if (!quiet)
+            logger.warn('npm-distributed package detected — resolving component dependencies from the npm registry.');
+        const missing = missingNpmDistributedComponents(pluginDir);
+        if (missing.length > 0) {
+            return {
+                success: false,
+                workspaceDir: options.workspaceDir,
+                configYamlPath: getConfigYamlPath(options.workspaceDir),
+                templatesCount: 0,
+                components: { plugin: 'skipped', cli: 'skipped', console: 'skipped' },
+                verification: { features: 'skipped', storyA: 'skipped' },
+                enabledChannels: options.channels,
+                nextAction: 'The package is incomplete — reinstall it: npm cache clear --force && npx create-principles-disciple@latest. No changes were made.',
+                reason: `npm_bundle_incomplete: missing ${missing.join(', ')}`,
+                component: 'Release asset',
+                error: `Bundled components incomplete (missing ${missing.join(', ')}) — the npm package is corrupted or truncated. No changes were made.`,
+            };
+        }
+    }
     // Gateway lock pre-flight: a running gateway holds native-module file handles
     // that make the backup rename fail with EPERM. Decide stop/abort/proceed
     // BEFORE mutating anything (cli-5: abort/stop-failed paths must not mutate).
@@ -1922,6 +2098,12 @@ export async function install(options, pluginDir, mode = {}) {
         installBundledCodexAdapter(pluginDir);
         stepIndex++;
         installBundledLayoutPackage(pluginDir);
+        if (spinner)
+            updateProgress(spinner, stepIndex, 'Installing release-manager authority module...');
+        installBundledReleaseManagerPackage(pluginDir);
+        await installReleaseManagerDependencies();
+        await verifyReleaseManagerAuthorityImports();
+        stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Installing plugin...');
         await installPluginToStaging(pluginDir, options.language);
@@ -2012,6 +2194,20 @@ export async function install(options, pluginDir, mode = {}) {
             updateProgress(spinner, stepIndex, 'Creating config...');
         await createConfigFile(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
+        // commands and hooks would write to two different state trees.
+        try {
+            const divergence = detectOpenClawMainWorkspaceDivergence(options.workspaceDir);
+            if (divergence.divergent) {
+                logger.warn(`Workspace divergence detected: ${divergence.detail}. ` +
+                    `${divergence.nextAction} ` +
+                    `Until fixed, OpenClaw sessions in "${divergence.openclawMainWorkspace}" may be unable to record pain signals (needs_evidence).`);
+            }
+        }
+        catch (e) {
+            logger.warn(`OpenClaw workspace divergence check failed (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+        }
         if (spinner)
             updateProgress(spinner, stepIndex, 'Initializing PD databases...');
         try {