@wipcomputer/wip-ldm-os 0.4.85-alpha.12 → 0.4.85-alpha.14

package/bin/ldm.js

@@ -22,7 +22,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, cpSync, chmodSync, unlinkSync, readlinkSync, renameSync, statSync, lstatSync, symlinkSync } from 'node:fs';
 import { join, basename, resolve, dirname } from 'node:path';
-import { execSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -229,6 +229,62 @@ function checkCliVersion() {
   }
 }
 
+function selectedLdmNpmTrack() {
+  return ALPHA_FLAG ? 'alpha' : BETA_FLAG ? 'beta' : 'latest';
+}
+
+function selectedLdmTrackLabel(npmTag) {
+  return npmTag === 'latest' ? '' : ` (${npmTag} track)`;
+}
+
+function latestLdmCliForSelectedTrack() {
+  const npmTag = selectedLdmNpmTrack();
+  const npmViewCmd = npmTag === 'latest'
+    ? 'npm view @wipcomputer/wip-ldm-os version 2>/dev/null'
+    : `npm view @wipcomputer/wip-ldm-os dist-tags.${npmTag} 2>/dev/null`;
+  const latest = execSync(npmViewCmd, {
+    encoding: 'utf8',
+    timeout: 15000,
+  }).trim();
+  return { latest, npmTag };
+}
+
+function maybeSelfUpdateLdmCliBeforeInstall() {
+  // This shared preflight covers both bare `ldm install` and targeted
+  // `ldm install <app>`. Dry runs never update, but still disclose skew.
+  if (process.env.LDM_SELF_UPDATED) return;
+
+  try {
+    const { latest, npmTag } = latestLdmCliForSelectedTrack();
+    if (!latest || !semverNewer(latest, PKG_VERSION)) return;
+
+    const trackLabel = selectedLdmTrackLabel(npmTag);
+
+    if (DRY_RUN) {
+      console.log(`  LDM OS CLI v${PKG_VERSION} -> v${latest}${trackLabel} is available.`);
+      console.log(`  Dry run only: continuing with v${PKG_VERSION}.`);
+      console.log('');
+      return;
+    }
+
+    console.log(`  LDM OS CLI v${PKG_VERSION} -> v${latest}${trackLabel}. Updating first...`);
+    try {
+      execSync(`npm install -g @wipcomputer/wip-ldm-os@${latest}`, { stdio: 'inherit', timeout: 60000 });
+      console.log(`  CLI updated to v${latest}. Re-running with new code...`);
+      console.log('');
+      const reArgs = process.argv.slice(2);
+      const child = spawnSync('ldm', reArgs.length > 0 ? reArgs : ['install'], {
+        stdio: 'inherit',
+        env: { ...process.env, LDM_SELF_UPDATED: '1' },
+      });
+      if (child.error) throw child.error;
+      process.exit(child.status ?? 1);
+    } catch (e) {
+      console.log(`  ! Self-update failed: ${e.message}. Continuing with v${PKG_VERSION}.`);
+    }
+  } catch {}
+}
+
 // ── Dead backup trigger cleanup (#207) ──
 // Three backup systems were competing. Only ai.openclaw.ldm-backup (3am) works.
 // This removes: broken cron entry (LDMDevTools.app), old com.wipcomputer.daily-backup.
@@ -1440,23 +1496,6 @@ async function showCatalogPicker() {
 // ── ldm install ──
 
 async function cmdInstall() {
-  if (!DRY_RUN && !acquireInstallLock()) return;
-
-  // Ensure LDM is initialized
-  if (!existsSync(VERSION_PATH)) {
-    console.log('  LDM OS not initialized. Running init first...');
-    console.log('');
-    cmdInit();
-  }
-
-  const { setFlags, installFromPath, installSingleTool, installToolbox, detectHarnesses } = await import('../lib/deploy.mjs');
-  const { detectInterfacesJSON } = await import('../lib/detect.mjs');
-
-  // Refresh harness detection (catches newly installed harnesses)
-  detectHarnesses();
-
-  setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT, origin: 'manual' });
-
   // --help flag (#81)
   if (args.includes('--help') || args.includes('-h')) {
     console.log(`
@@ -1476,6 +1515,25 @@ async function cmdInstall() {
     process.exit(0);
   }
 
+  maybeSelfUpdateLdmCliBeforeInstall();
+
+  if (!DRY_RUN && !acquireInstallLock()) return;
+
+  // Ensure LDM is initialized
+  if (!existsSync(VERSION_PATH)) {
+    console.log('  LDM OS not initialized. Running init first...');
+    console.log('');
+    cmdInit();
+  }
+
+  const { setFlags, installFromPath, installSingleTool, installToolbox, detectHarnesses } = await import('../lib/deploy.mjs');
+  const { detectInterfacesJSON } = await import('../lib/detect.mjs');
+
+  // Refresh harness detection (catches newly installed harnesses)
+  detectHarnesses();
+
+  setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT, origin: 'manual' });
+
   // Find the target (skip flags)
   const target = args.slice(1).find(a => !a.startsWith('--'));
 
@@ -1921,38 +1979,6 @@ async function cmdInstallCatalog() {
   // No lock here. cmdInstall() already holds it when calling this.
   installLog(`ldm install started (v${PKG_VERSION}, DRY_RUN=${DRY_RUN})`);
 
-  // Self-update: check if CLI itself is outdated. Update first, then re-exec.
-  // This breaks the chicken-and-egg: new features in ldm install are always
-  // available because the installer upgrades itself before doing anything else.
-  // --alpha and --beta flags check the corresponding npm dist-tag instead of @latest.
-  if (!DRY_RUN && !process.env.LDM_SELF_UPDATED) {
-    try {
-      const npmTag = ALPHA_FLAG ? 'alpha' : BETA_FLAG ? 'beta' : 'latest';
-      const trackLabel = npmTag === 'latest' ? '' : ` (${npmTag} track)`;
-      const npmViewCmd = npmTag === 'latest'
-        ? 'npm view @wipcomputer/wip-ldm-os version 2>/dev/null'
-        : `npm view @wipcomputer/wip-ldm-os dist-tags.${npmTag} 2>/dev/null`;
-      const latest = execSync(npmViewCmd, {
-        encoding: 'utf8', timeout: 15000,
-      }).trim();
-      if (latest && semverNewer(latest, PKG_VERSION)) {
-        console.log(`  LDM OS CLI v${PKG_VERSION} -> v${latest}${trackLabel}. Updating first...`);
-        try {
-          execSync(`npm install -g @wipcomputer/wip-ldm-os@${latest}`, { stdio: 'inherit', timeout: 60000 });
-          console.log(`  CLI updated to v${latest}. Re-running with new code...`);
-          console.log('');
-          // Re-exec with the new binary. LDM_SELF_UPDATED prevents infinite loop.
-          // process.argv.slice(2) skips 'node' and the script path, keeps just 'install' + flags
-          const reArgs = process.argv.slice(2).join(' ') || 'install';
-          execSync(`LDM_SELF_UPDATED=1 ldm ${reArgs}`, { stdio: 'inherit' });
-          process.exit(0);
-        } catch (e) {
-          console.log(`  ! Self-update failed: ${e.message}. Continuing with v${PKG_VERSION}.`);
-        }
-      }
-    } catch {}
-  }
-
   autoDetectExtensions();
 
   // Migrate old registry entries to v2 format (#262)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.85-alpha.12",
+  "version": "0.4.85-alpha.14",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {
@@ -23,6 +23,7 @@
     "test:skill-frontmatter": "node scripts/test-skill-frontmatter.mjs",
     "test:installer-update-tracks": "node scripts/test-installer-update-tracks.mjs",
     "test:installer-hook-toolname": "node scripts/test-installer-hook-toolname.mjs",
+    "test:installer-target-self-update": "node scripts/test-installer-target-self-update.mjs",
     "test:installer-skill-directory": "node scripts/test-installer-skill-directory.mjs",
     "test:installer-skill-dry-run-destinations": "node scripts/test-installer-skill-dry-run-destinations.mjs",
     "test:ldm-install-bin-shim": "node scripts/test-ldm-install-preserves-foreign-bin.mjs",

package/scripts/test-installer-target-self-update.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const cli = readFileSync(join(root, 'bin', 'ldm.js'), 'utf8');
+
+const helperName = 'function maybeSelfUpdateLdmCliBeforeInstall()';
+const helperIdx = cli.indexOf(helperName);
+if (helperIdx === -1) {
+  throw new Error('Missing shared LDM OS self-update preflight helper');
+}
+
+const helperBlock = cli.slice(helperIdx, cli.indexOf('// ── Dead backup trigger cleanup', helperIdx));
+if (!helperBlock.includes('Dry run only: continuing with v${PKG_VERSION}.')) {
+  throw new Error('Self-update helper must warn on dry run without updating');
+}
+
+if (!helperBlock.includes("execSync(`npm install -g @wipcomputer/wip-ldm-os@${latest}`")) {
+  throw new Error('Self-update helper must update LDM OS before real installs');
+}
+
+if (!helperBlock.includes("spawnSync('ldm'")) {
+  throw new Error('Self-update helper must re-run the original install command without shell joining args');
+}
+
+if (helperBlock.includes('process.argv.slice(2).join')) {
+  throw new Error('Self-update helper must preserve argv boundaries when re-running install');
+}
+
+const cmdInstallIdx = cli.indexOf('async function cmdInstall()');
+const lockIdx = cli.indexOf('acquireInstallLock()', cmdInstallIdx);
+const initIdx = cli.indexOf('LDM OS not initialized. Running init first', cmdInstallIdx);
+const targetIdx = cli.indexOf('// Find the target (skip flags)', cmdInstallIdx);
+const preflightCallIdx = cli.indexOf('maybeSelfUpdateLdmCliBeforeInstall();', cmdInstallIdx);
+if (cmdInstallIdx === -1 || targetIdx === -1 || preflightCallIdx === -1) {
+  throw new Error('Could not find cmdInstall self-update placement');
+}
+
+if (preflightCallIdx > lockIdx || preflightCallIdx > initIdx) {
+  throw new Error('Self-update preflight must run before lock acquisition and init work');
+}
+
+if (preflightCallIdx > targetIdx) {
+  throw new Error('Self-update preflight must run before target resolution so app installs are covered');
+}
+
+const catalogIdx = cli.indexOf('async function cmdInstallCatalog()');
+const oldCatalogBlock = cli.indexOf('Self-update: check if CLI itself is outdated', catalogIdx);
+const autoDetectIdx = cli.indexOf('autoDetectExtensions();', catalogIdx);
+if (oldCatalogBlock !== -1 && oldCatalogBlock < autoDetectIdx) {
+  throw new Error('Catalog install should not own the only self-update block');
+}
+
+const tempRoot = mkdtempSync(join(tmpdir(), 'ldm-target-self-update-'));
+try {
+  const home = join(tempRoot, 'home');
+  const fakeBin = join(tempRoot, 'bin');
+  const target = join(tempRoot, 'target skill with spaces');
+
+  mkdirSync(join(home, '.ldm'), { recursive: true });
+  writeFileSync(join(home, '.ldm', 'version.json'), JSON.stringify({
+    version: '0.0.0',
+    installed: new Date().toISOString(),
+    updated: new Date().toISOString(),
+  }, null, 2) + '\n');
+
+  mkdirSync(fakeBin, { recursive: true });
+  const fakeNpm = join(fakeBin, 'npm');
+  writeFileSync(fakeNpm, `#!/usr/bin/env bash
+if [ "$1" = "view" ] && [ "$2" = "@wipcomputer/wip-ldm-os" ] && [ "$3" = "dist-tags.alpha" ]; then
+  echo "99.0.0-alpha.1"
+  exit 0
+fi
+echo "unexpected npm command: $*" >&2
+exit 64
+`);
+  chmodSync(fakeNpm, 0o755);
+
+  mkdirSync(target, { recursive: true });
+  writeFileSync(join(target, 'SKILL.md'), `---
+name: test-target-skill
+description: Test target skill for installer self-update dry-run checks.
+---
+
+# Test Target Skill
+`);
+
+  const result = spawnSync(process.execPath, [
+    join(root, 'bin', 'ldm.js'),
+    'install',
+    '--alpha',
+    '--dry-run',
+    target,
+  ], {
+    cwd: root,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HOME: home,
+      PATH: `${fakeBin}:${process.env.PATH || ''}`,
+    },
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`Runtime dry-run exited ${result.status}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+
+  if (!result.stdout.includes('LDM OS CLI v')) {
+    throw new Error(`Runtime dry-run did not print the LDM OS skew warning\nstdout:\n${result.stdout}`);
+  }
+
+  if (!result.stdout.includes('-> v99.0.0-alpha.1 (alpha track) is available.')) {
+    throw new Error(`Runtime dry-run did not include the selected alpha track version\nstdout:\n${result.stdout}`);
+  }
+
+  if (!result.stdout.includes('Dry run only: continuing with v')) {
+    throw new Error(`Runtime dry-run did not say it would continue without updating\nstdout:\n${result.stdout}`);
+  }
+
+  if (!result.stdout.includes('Installing: target skill with spaces (dry run)')) {
+    throw new Error(`Runtime dry-run did not continue to the targeted install preview\nstdout:\n${result.stdout}`);
+  }
+} finally {
+  rmSync(tempRoot, { recursive: true, force: true });
+}
+
+console.log('targeted install self-update regression checks passed');