@wipcomputer/wip-ldm-os 0.4.29 → 0.4.31

package/SKILL.md

@@ -5,7 +5,7 @@ license: MIT
 interface: [cli, skill]
 metadata:
   display-name: "LDM OS"
-  version: "0.4.29"
+  version: "0.4.31"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/ldm.js

@@ -30,6 +30,7 @@ const LDM_ROOT = join(HOME, '.ldm');
 const LDM_EXTENSIONS = join(LDM_ROOT, 'extensions');
 const VERSION_PATH = join(LDM_ROOT, 'version.json');
 const REGISTRY_PATH = join(LDM_EXTENSIONS, 'registry.json');
+const LDM_TMP = join(LDM_ROOT, 'tmp');
 
 // Install log (#101): append to ~/.ldm/logs/install.log
 import { appendFileSync } from 'node:fs';
@@ -227,7 +228,21 @@ function loadCatalog() {
 }
 
 function findInCatalog(id) {
-  return loadCatalog().find(c => c.id === id);
+  const q = id.toLowerCase();
+  const catalog = loadCatalog();
+  // Exact id match
+  const exact = catalog.find(c => c.id === id);
+  if (exact) return exact;
+  // Partial id match (e.g. "xai-grok" matches "wip-xai-grok")
+  const partial = catalog.find(c => c.id.toLowerCase().includes(q) || q.includes(c.id.toLowerCase()));
+  if (partial) return partial;
+  // Name match (case-insensitive, e.g. "xAI Grok")
+  const byName = catalog.find(c => c.name && c.name.toLowerCase() === q);
+  if (byName) return byName;
+  // registryMatches match
+  const byRegistry = catalog.find(c => (c.registryMatches || []).some(m => m.toLowerCase() === q));
+  if (byRegistry) return byRegistry;
+  return null;
 }
 
 // ── ldm init ──
@@ -484,8 +499,22 @@ async function cmdInstall() {
     return cmdInstallCatalog();
   }
 
+  // If target is a private repo (org/name-private), redirect to public (#134)
+  let resolvedTarget = target;
+  if (target.match(/^[\w-]+\/[\w.-]+-private$/) && !existsSync(resolve(target))) {
+    const publicRepo = target.replace(/-private$/, '');
+    const catalogHit = findInCatalog(basename(publicRepo));
+    if (catalogHit) {
+      console.log(`  Redirecting ${target} to public repo: ${catalogHit.repo}`);
+      resolvedTarget = catalogHit.repo;
+    } else {
+      console.log(`  Redirecting ${target} to public repo: ${publicRepo}`);
+      resolvedTarget = publicRepo;
+    }
+  }
+
   // Check if target is a catalog ID (e.g. "memory-crystal")
-  const catalogEntry = findInCatalog(target);
+  const catalogEntry = findInCatalog(resolvedTarget);
   if (catalogEntry) {
     console.log('');
     console.log(`  Resolved "${target}" via catalog to ${catalogEntry.repo}`);
@@ -493,10 +522,11 @@ async function cmdInstall() {
     // Use the repo field to clone from GitHub
     const repoTarget = catalogEntry.repo;
     const repoName = basename(repoTarget);
-    const repoPath = join('/tmp', `ldm-install-${repoName}`);
+    const repoPath = join(LDM_TMP, `ldm-install-${repoName}`);
     const httpsUrl = `https://github.com/${repoTarget}.git`;
     const sshUrl = `git@github.com:${repoTarget}.git`;
 
+    mkdirSync(LDM_TMP, { recursive: true });
     console.log(`  Cloning ${repoTarget}...`);
     try {
       if (existsSync(repoPath)) {
@@ -523,8 +553,8 @@ async function cmdInstall() {
 
     await installFromPath(repoPath);
 
-    // Clean up /tmp/ clone after install (#32)
-    if (!DRY_RUN && (repoPath.startsWith('/tmp/') || repoPath.startsWith('/private/tmp/'))) {
+    // Clean up staging clone after install (#32, #135)
+    if (!DRY_RUN && repoPath.startsWith(LDM_TMP)) {
       try { execSync(`rm -rf "${repoPath}"`, { stdio: 'pipe' }); } catch {}
     }
     return;
@@ -534,10 +564,10 @@ async function cmdInstall() {
   let repoPath;
 
   // Check if target looks like an npm package (starts with @ or is a plain name without /)
-  if (target.startsWith('@') || (!target.includes('/') && !existsSync(resolve(target)))) {
+  if (resolvedTarget.startsWith('@') || (!resolvedTarget.includes('/') && !existsSync(resolve(resolvedTarget)))) {
     // Try npm install to temp dir
-    const npmName = target;
-    const tempDir = join('/tmp', `ldm-install-npm-${Date.now()}`);
+    const npmName = resolvedTarget;
+    const tempDir = join(LDM_TMP, `ldm-install-npm-${Date.now()}`);
     console.log('');
     console.log(`  Installing ${npmName} from npm...`);
     try {
@@ -560,19 +590,20 @@ async function cmdInstall() {
     }
   }
 
-  if (!repoPath && (target.startsWith('http') || target.startsWith('git@') || target.match(/^[\w-]+\/[\w.-]+$/))) {
-    const isShorthand = target.match(/^[\w-]+\/[\w.-]+$/);
+  if (!repoPath && (resolvedTarget.startsWith('http') || resolvedTarget.startsWith('git@') || resolvedTarget.match(/^[\w-]+\/[\w.-]+$/))) {
+    const isShorthand = resolvedTarget.match(/^[\w-]+\/[\w.-]+$/);
     const httpsUrl = isShorthand
-      ? `https://github.com/${target}.git`
-      : target;
+      ? `https://github.com/${resolvedTarget}.git`
+      : resolvedTarget;
     const sshUrl = isShorthand
-      ? `git@github.com:${target}.git`
-      : target.replace(/^https:\/\/github\.com\//, 'git@github.com:');
+      ? `git@github.com:${resolvedTarget}.git`
+      : resolvedTarget.replace(/^https:\/\/github\.com\//, 'git@github.com:');
     const repoName = basename(httpsUrl).replace('.git', '');
-    repoPath = join('/tmp', `ldm-install-${repoName}`);
+    repoPath = join(LDM_TMP, `ldm-install-${repoName}`);
 
+    mkdirSync(LDM_TMP, { recursive: true });
     console.log('');
-    console.log(`  Cloning ${isShorthand ? target : httpsUrl}...`);
+    console.log(`  Cloning ${isShorthand ? resolvedTarget : httpsUrl}...`);
     try {
       if (existsSync(repoPath)) {
         execSync(`rm -rf "${repoPath}"`, { stdio: 'pipe' });
@@ -590,7 +621,7 @@ async function cmdInstall() {
       process.exit(1);
     }
   } else if (!repoPath) {
-    repoPath = resolve(target);
+    repoPath = resolve(resolvedTarget);
     if (!existsSync(repoPath)) {
       console.error(`  x Path not found: ${repoPath}`);
       process.exit(1);
@@ -605,8 +636,8 @@ async function cmdInstall() {
 
   await installFromPath(repoPath);
 
-  // Clean up /tmp/ clone after install (#32)
-  if (!DRY_RUN && (repoPath.startsWith('/tmp/') || repoPath.startsWith('/private/tmp/'))) {
+  // Clean up staging clone after install (#32, #135)
+  if (!DRY_RUN && repoPath.startsWith(LDM_TMP)) {
     try { execSync(`rm -rf "${repoPath}"`, { stdio: 'pipe' }); } catch {}
   }
 }
@@ -735,9 +766,51 @@ async function cmdInstallCatalog() {
     console.log('');
   }
 
+  // Clean ghost entries from registry (#134, #135)
+  if (registry?.extensions) {
+    const names = Object.keys(registry.extensions);
+    let cleaned = 0;
+    for (const name of names) {
+      // Remove -private duplicates (e.g. wip-xai-grok-private when wip-xai-grok exists)
+      const publicName = name.replace(/-private$/, '');
+      if (name !== publicName && registry.extensions[publicName]) {
+        delete registry.extensions[name];
+        cleaned++;
+        continue;
+      }
+      // Remove ldm-install- prefixed entries (ghost from /tmp/ clones)
+      if (name.startsWith('ldm-install-')) {
+        const cleanName = name.replace(/^ldm-install-/, '');
+        delete registry.extensions[name];
+        cleaned++;
+      }
+    }
+    if (cleaned > 0 && !DRY_RUN) {
+      writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2));
+      installLog(`Cleaned ${cleaned} ghost registry entries`);
+    }
+  }
+
   // Build the update plan: check ALL installed extensions against npm (#55)
   const npmUpdates = [];
 
+  // Check CLI self-update (#132)
+  try {
+    const cliLatest = execSync('npm view @wipcomputer/wip-ldm-os version 2>/dev/null', {
+      encoding: 'utf8', timeout: 10000,
+    }).trim();
+    if (cliLatest && cliLatest !== PKG_VERSION) {
+      npmUpdates.push({
+        name: 'LDM OS CLI',
+        catalogNpm: '@wipcomputer/wip-ldm-os',
+        currentVersion: PKG_VERSION,
+        latestVersion: cliLatest,
+        hasUpdate: true,
+        isCLI: true,
+      });
+    }
+  } catch {}
+
   // Check every installed extension against npm via catalog
   console.log('  Checking npm for updates...');
   for (const [name, entry] of Object.entries(reconciled)) {
@@ -819,17 +892,51 @@ async function cmdInstallCatalog() {
     } catch {}
   }
 
+  // Check parent packages for toolbox-style repos (#132)
+  // If sub-tools are installed but the parent npm package has a newer version,
+  // report the parent as needing an update (not the individual sub-tool).
+  const checkedNpm = new Set(npmUpdates.map(u => u.catalogNpm));
+  for (const comp of components) {
+    if (!comp.npm || checkedNpm.has(comp.npm)) continue;
+    if (!comp.registryMatches || comp.registryMatches.length === 0) continue;
+
+    // If any registryMatch is installed, check the parent package
+    const installedMatch = comp.registryMatches.find(m => reconciled[m]);
+    if (!installedMatch) continue;
+
+    const currentVersion = reconciled[installedMatch]?.ldmVersion || reconciled[installedMatch]?.ocVersion || '?';
+
+    try {
+      const latest = execSync(`npm view ${comp.npm} version 2>/dev/null`, {
+        encoding: 'utf8', timeout: 10000,
+      }).trim();
+      if (latest && latest !== currentVersion) {
+        // Remove any sub-tool entries that duplicate this parent
+        for (let i = npmUpdates.length - 1; i >= 0; i--) {
+          if (npmUpdates[i].catalogNpm === comp.npm && !npmUpdates[i].isCLI) {
+            npmUpdates.splice(i, 1);
+          }
+        }
+        npmUpdates.push({
+          name: comp.id,
+          catalogRepo: comp.repo,
+          catalogNpm: comp.npm,
+          currentVersion,
+          latestVersion: latest,
+          hasUpdate: true,
+          isParent: true,
+          registryMatches: comp.registryMatches,
+        });
+      }
+    } catch {}
+    checkedNpm.add(comp.npm);
+  }
+
   const totalUpdates = npmUpdates.length;
 
   if (DRY_RUN) {
     // Summary block (#80)
-    const cliLatest = (() => {
-      try {
-        return execSync('npm view @wipcomputer/wip-ldm-os version 2>/dev/null', {
-          encoding: 'utf8', timeout: 10000,
-        }).trim();
-      } catch { return null; }
-    })();
+    const cliUpdate = npmUpdates.find(u => u.isCLI);
 
     const agentDirs = (() => {
       try {
@@ -848,8 +955,8 @@ async function cmdInstallCatalog() {
     console.log('');
     console.log('  Summary');
     console.log('  ────────────────────────────────────');
-    if (cliLatest && cliLatest !== PKG_VERSION) {
-      console.log(`  LDM OS CLI       v${PKG_VERSION}  ->  v${cliLatest}  (auto-updates on install)`);
+    if (cliUpdate) {
+      console.log(`  LDM OS CLI       v${PKG_VERSION}  ->  v${cliUpdate.latestVersion}`);
     } else {
       console.log(`  LDM OS CLI       v${PKG_VERSION} (latest)`);
     }
@@ -918,13 +1025,21 @@ async function cmdInstallCatalog() {
       }
     } catch {}
 
-    // Check orphaned /tmp/ dirs
+    // Check orphaned staging dirs (old /tmp/ and new ~/.ldm/tmp/)
     try {
       const tmpCount = readdirSync('/private/tmp').filter(d => d.startsWith('ldm-install-')).length;
       if (tmpCount > 0) {
         healthIssues.push(`  ! ${tmpCount} orphaned /tmp/ldm-install-* dirs (would clean up)`);
       }
     } catch {}
+    try {
+      if (existsSync(LDM_TMP)) {
+        const ldmTmpCount = readdirSync(LDM_TMP).filter(d => d.startsWith('ldm-install-')).length;
+        if (ldmTmpCount > 0) {
+          healthIssues.push(`  ! ${ldmTmpCount} orphaned ~/.ldm/tmp/ldm-install-* dirs (would clean up)`);
+        }
+      }
+    } catch {}
 
     if (healthIssues.length > 0) {
       console.log('');
@@ -1075,7 +1190,7 @@ async function cmdInstallCatalog() {
     }
   } catch {}
 
-  // 3. Clean orphaned /tmp/ldm-install-* dirs
+  // 3. Clean orphaned staging dirs (old /tmp/ and new ~/.ldm/tmp/)
   try {
     const tmpDirs = readdirSync('/private/tmp').filter(d => d.startsWith('ldm-install-'));
     if (tmpDirs.length > 0) {
@@ -1087,6 +1202,19 @@ async function cmdInstallCatalog() {
       console.log(`  + Cleaned ${tmpDirs.length} orphaned /tmp/ clone(s)`);
     }
   } catch {}
+  try {
+    if (existsSync(LDM_TMP)) {
+      const ldmTmpDirs = readdirSync(LDM_TMP).filter(d => d.startsWith('ldm-install-'));
+      if (ldmTmpDirs.length > 0) {
+        console.log(`  Cleaning ${ldmTmpDirs.length} orphaned ~/.ldm/tmp/ dirs...`);
+        for (const d of ldmTmpDirs) {
+          try { execSync(`rm -rf "${join(LDM_TMP, d)}"`, { stdio: 'pipe', timeout: 10000 }); } catch {}
+        }
+        healthFixes++;
+        console.log(`  + Cleaned ${ldmTmpDirs.length} orphaned ~/.ldm/tmp/ clone(s)`);
+      }
+    }
+  } catch {}
 
   if (healthFixes > 0) {
     console.log(`  ${healthFixes} health issue(s) fixed.`);
@@ -2036,6 +2164,208 @@ async function main() {
     console.log('');
   }
 
+  // ── ldm uninstall (#114) ──
+
+  async function cmdUninstall() {
+    const keepData = !args.includes('--all');
+    const isDryRun = args.includes('--dry-run');
+
+    console.log('');
+    console.log('  LDM OS Uninstall');
+    console.log('  ────────────────────────────────────');
+
+    if (keepData) {
+      console.log('  Your data will be PRESERVED:');
+      console.log('    ~/.ldm/memory/     (crystal.db, shared memory)');
+      console.log('    ~/.ldm/agents/     (identity, journals, daily logs)');
+      console.log('');
+      console.log('  Use --all to remove everything including data.');
+    } else {
+      console.log('  WARNING: --all flag set. ALL data will be removed.');
+      console.log('  This includes crystal.db, agent files, journals, everything.');
+    }
+
+    console.log('');
+    console.log('  Will remove:');
+
+    // 1. MCP servers
+    const claudeJsonPath = join(HOME, '.claude.json');
+    try {
+      const claudeJson = JSON.parse(readFileSync(claudeJsonPath, 'utf8'));
+      const mcpNames = Object.keys(claudeJson.mcpServers || {}).filter(n =>
+        n.includes('crystal') || n.includes('wip-') || n.includes('memory') ||
+        n.includes('grok') || n.includes('lesa') || n.includes('1password')
+      );
+      if (mcpNames.length > 0) {
+        console.log(`    MCP servers: ${mcpNames.join(', ')}`);
+      }
+    } catch {}
+
+    // 2. CC hooks
+    const settingsPath = join(HOME, '.claude', 'settings.json');
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      let hookCount = 0;
+      for (const [event, entries] of Object.entries(settings.hooks || {})) {
+        for (const entry of (Array.isArray(entries) ? entries : [])) {
+          for (const h of (entry.hooks || [])) {
+            if (h.command?.includes('.ldm') || h.command?.includes('wip-')) hookCount++;
+          }
+        }
+      }
+      if (hookCount > 0) console.log(`    CC hooks: ${hookCount} hook(s)`);
+    } catch {}
+
+    // 3. Skills
+    const skillsDir = join(HOME, '.openclaw', 'skills');
+    try {
+      const skills = readdirSync(skillsDir).filter(d => d !== '.DS_Store');
+      if (skills.length > 0) console.log(`    Skills: ${skills.join(', ')}`);
+    } catch {}
+
+    // 4. Cron jobs
+    try {
+      const crontab = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
+      const ldmLines = crontab.split('\n').filter(l => l.includes('.ldm') || l.includes('crystal-capture') || l.includes('process-monitor'));
+      if (ldmLines.length > 0) console.log(`    Cron jobs: ${ldmLines.length}`);
+    } catch {}
+
+    // 5. Global npm packages
+    try {
+      const npmList = execSync('npm list -g --depth=0 --json 2>/dev/null', { encoding: 'utf8' });
+      const deps = JSON.parse(npmList).dependencies || {};
+      const wipPkgs = Object.keys(deps).filter(n => n.startsWith('@wipcomputer/'));
+      if (wipPkgs.length > 0) console.log(`    npm packages: ${wipPkgs.join(', ')}`);
+    } catch {}
+
+    // 6. Directories
+    console.log(`    ~/.ldm/extensions/`);
+    if (!keepData) {
+      console.log(`    ~/.ldm/memory/`);
+      console.log(`    ~/.ldm/agents/`);
+    }
+    console.log(`    ~/.ldm/state/, bin/, hooks/, logs/, sessions/, messages/`);
+
+    if (isDryRun) {
+      console.log('');
+      console.log('  Dry run. Nothing removed.');
+      console.log('');
+      return;
+    }
+
+    // Confirm
+    if (process.stdin.isTTY) {
+      const { createInterface } = await import('readline');
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise(resolve => {
+        rl.question('\n  Type "uninstall" to confirm: ', resolve);
+      });
+      rl.close();
+      if (answer.trim() !== 'uninstall') {
+        console.log('  Cancelled.');
+        return;
+      }
+    }
+
+    console.log('');
+    console.log('  Removing...');
+
+    // 1. Unregister MCP servers
+    try {
+      const claudeJson = JSON.parse(readFileSync(claudeJsonPath, 'utf8'));
+      const mcpNames = Object.keys(claudeJson.mcpServers || {}).filter(n =>
+        n.includes('crystal') || n.includes('wip-') || n.includes('memory') ||
+        n.includes('grok') || n.includes('lesa') || n.includes('1password')
+      );
+      for (const name of mcpNames) {
+        delete claudeJson.mcpServers[name];
+      }
+      writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + '\n');
+      console.log(`  + Removed ${mcpNames.length} MCP server(s)`);
+    } catch {}
+
+    // 2. Remove CC hooks
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      let removed = 0;
+      for (const [event, entries] of Object.entries(settings.hooks || {})) {
+        if (!Array.isArray(entries)) continue;
+        for (const entry of entries) {
+          if (!entry.hooks) continue;
+          const before = entry.hooks.length;
+          entry.hooks = entry.hooks.filter(h => !h.command?.includes('.ldm') && !h.command?.includes('wip-'));
+          removed += before - entry.hooks.length;
+        }
+        settings.hooks[event] = entries.filter(e => e.hooks?.length > 0);
+      }
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+      console.log(`  + Removed ${removed} CC hook(s)`);
+    } catch {}
+
+    // 3. Remove skills
+    try {
+      const skills = readdirSync(skillsDir).filter(d => d !== '.DS_Store');
+      for (const s of skills) {
+        execSync(`rm -rf "${join(skillsDir, s)}"`, { stdio: 'pipe' });
+      }
+      console.log(`  + Removed ${skills.length} skill(s)`);
+    } catch {}
+
+    // 4. Remove cron jobs
+    try {
+      const crontab = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
+      const filtered = crontab.split('\n').filter(l =>
+        !l.includes('.ldm') && !l.includes('crystal-capture') && !l.includes('process-monitor')
+      ).join('\n');
+      execSync(`echo "${filtered}" | crontab -`, { stdio: 'pipe' });
+      console.log('  + Cleaned cron jobs');
+    } catch {}
+
+    // 5. Remove npm packages
+    try {
+      const npmList = execSync('npm list -g --depth=0 --json 2>/dev/null', { encoding: 'utf8' });
+      const deps = JSON.parse(npmList).dependencies || {};
+      const wipPkgs = Object.keys(deps).filter(n => n.startsWith('@wipcomputer/'));
+      for (const pkg of wipPkgs) {
+        if (pkg === '@wipcomputer/wip-ldm-os') continue; // uninstall self last
+        try { execSync(`npm uninstall -g ${pkg}`, { stdio: 'pipe', timeout: 30000 }); } catch {}
+      }
+      console.log(`  + Removed ${wipPkgs.length - 1} npm package(s)`);
+    } catch {}
+
+    // 6. Remove directories
+    const dirsToRemove = ['extensions', 'state', 'bin', 'hooks', 'logs', 'sessions', 'messages', 'shared', '_trash'];
+    if (!keepData) {
+      dirsToRemove.push('memory', 'agents', 'secrets', 'backups');
+    }
+    for (const dir of dirsToRemove) {
+      const p = join(LDM_ROOT, dir);
+      if (existsSync(p)) {
+        execSync(`rm -rf "${p}"`, { stdio: 'pipe' });
+      }
+    }
+    // Remove config and version files
+    for (const f of ['version.json', 'config.json']) {
+      const p = join(LDM_ROOT, f);
+      if (existsSync(p)) unlinkSync(p);
+    }
+    console.log('  + Removed ~/.ldm/ contents');
+
+    if (keepData) {
+      console.log('');
+      console.log('  Preserved:');
+      console.log('    ~/.ldm/memory/   (your data)');
+      console.log('    ~/.ldm/agents/   (identity + journals)');
+    }
+
+    // 7. Self-uninstall
+    console.log('');
+    console.log('  To finish, run: npm uninstall -g @wipcomputer/wip-ldm-os');
+    console.log('');
+    console.log('  LDM OS uninstalled.');
+    console.log('');
+  }
+
   if (command === '--version' || command === '-v') {
     console.log(PKG_VERSION);
     process.exit(0);
@@ -2079,6 +2409,9 @@ async function main() {
     case 'disable':
       await cmdDisable();
       break;
+    case 'uninstall':
+      await cmdUninstall();
+      break;
     default:
       console.error(`  Unknown command: ${command}`);
       console.error(`  Run: ldm --help`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.29",
+  "version": "0.4.31",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "main": "src/boot/boot-hook.mjs",