@wipcomputer/wip-ldm-os 0.4.53 → 0.4.55

package/SKILL.md

@@ -9,7 +9,7 @@ license: MIT
 compatibility: Requires git, npm, node. Node.js 18+.
 metadata:
   display-name: "LDM OS"
-  version: "0.4.53"
+  version: "0.4.55"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/ldm.js

@@ -521,6 +521,16 @@ async function cmdInit() {
     }
   }
 
+  // Detect installed harnesses (CC, OC, Codex, Cursor, Claude macOS)
+  try {
+    const { detectHarnesses } = await import('../lib/deploy.mjs');
+    const { harnesses } = detectHarnesses();
+    const detected = Object.entries(harnesses).filter(([,h]) => h.detected).map(([name]) => name);
+    if (detected.length > 0) {
+      console.log(`  + Harnesses detected: ${detected.join(', ')}`);
+    }
+  } catch {}
+
   console.log('');
   console.log(`  LDM OS v${PKG_VERSION} initialized at ${LDM_ROOT}`);
   console.log('');
@@ -627,9 +637,12 @@ async function cmdInstall() {
     cmdInit();
   }
 
-  const { setFlags, installFromPath, installSingleTool, installToolbox } = await import('../lib/deploy.mjs');
+  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 });
 
   // --help flag (#81)

package/lib/deploy.mjs

@@ -76,9 +76,91 @@ function saveRegistry(registry) {
   writeJSON(REGISTRY_PATH, registry);
 }
 
-// Core extensions are always enabled. Everything else defaults to disabled on first install.
+// Core extensions are always enabled.
 const CORE_EXTENSIONS = new Set(['memory-crystal']);
 
+// ── Harness Detection ──
+
+const LDM_CONFIG_PATH = join(LDM_ROOT, 'config.json');
+
+/**
+ * Detect which AI harnesses are installed on this system.
+ * Writes results to ~/.ldm/config.json so the installer knows where to deploy.
+ */
+export function detectHarnesses() {
+  const harnesses = {};
+
+  // Claude Code CLI
+  const claudeHome = join(HOME, '.claude');
+  harnesses['claude-code'] = {
+    detected: existsSync(claudeHome),
+    home: claudeHome,
+    skills: join(claudeHome, 'skills'),
+    rules: join(claudeHome, 'rules'),
+    settings: join(claudeHome, 'settings.json'),
+  };
+
+  // Claude macOS app
+  const claudeMacHome = join(HOME, 'Library', 'Application Support', 'Claude');
+  harnesses['claude-macos'] = {
+    detected: existsSync(claudeMacHome),
+    home: claudeMacHome,
+  };
+
+  // OpenClaw (Lesa)
+  harnesses['openclaw'] = {
+    detected: existsSync(OC_ROOT),
+    home: OC_ROOT,
+    skills: join(OC_ROOT, 'skills'),
+    extensions: OC_EXTENSIONS,
+  };
+
+  // Codex
+  const codexHome = join(HOME, '.codex');
+  harnesses['codex'] = {
+    detected: existsSync(codexHome),
+    home: codexHome,
+    skills: join(codexHome, 'skills'),
+  };
+
+  // Cursor
+  const cursorHome = join(HOME, '.cursor');
+  harnesses['cursor'] = {
+    detected: existsSync(cursorHome),
+    home: cursorHome,
+  };
+
+  // Read workspace from existing config
+  let workspace = '';
+  try {
+    const existing = readJSON(LDM_CONFIG_PATH) || {};
+    workspace = (existing.workspace || '').replace('~', HOME);
+  } catch {}
+
+  // Save to config
+  try {
+    const existing = readJSON(LDM_CONFIG_PATH) || {};
+    existing.harnesses = harnesses;
+    writeJSON(LDM_CONFIG_PATH, existing);
+  } catch {}
+
+  return { harnesses, workspace };
+}
+
+/**
+ * Get detected harnesses from config. Runs detection if not cached.
+ */
+function getHarnesses() {
+  try {
+    const config = readJSON(LDM_CONFIG_PATH) || {};
+    if (config.harnesses) {
+      const workspace = (config.workspace || '').replace('~', HOME);
+      return { harnesses: config.harnesses, workspace };
+    }
+  } catch {}
+  return detectHarnesses();
+}
+
 function updateRegistry(name, info) {
   const registry = loadRegistry();
   const existing = registry.extensions[name];
@@ -86,7 +168,7 @@ function updateRegistry(name, info) {
   registry.extensions[name] = {
     ...existing,
     ...info,
-    enabled: existing?.enabled ?? true,
+    enabled: existing?.enabled ?? true,  // New installs are enabled by default. User runs ldm disable to turn off.
     updatedAt: new Date().toISOString(),
   };
   saveRegistry(registry);
@@ -650,76 +732,57 @@ function installClaudeCodeHook(repoPath, door) {
 }
 
 function installSkill(repoPath, toolName) {
-  let skillSrc = join(repoPath, 'SKILL.md');
-  const ocSkillDir = join(OC_ROOT, 'skills', toolName);
-  const ocSkillDest = join(ocSkillDir, 'SKILL.md');
+  const { harnesses, workspace } = getHarnesses();
 
-  // If the original source is gone (tmp clone cleaned up), use the already-deployed OC copy
-  if (!existsSync(skillSrc) && existsSync(ocSkillDest)) {
-    skillSrc = ocSkillDest;
-  }
+  // Find SKILL.md source: repo path first, then permanent copy at ~/.ldm/extensions/
+  let skillSrc = join(repoPath, 'SKILL.md');
+  const permanentSkill = join(LDM_EXTENSIONS, toolName, 'SKILL.md');
+  if (!existsSync(skillSrc) && existsSync(permanentSkill)) skillSrc = permanentSkill;
   if (!existsSync(skillSrc)) return false;
 
-  if (existsSync(ocSkillDest)) {
-    try {
-      const srcContent = readFileSync(skillSrc, 'utf8');
-      const destContent = readFileSync(ocSkillDest, 'utf8');
-      if (srcContent === destContent) {
-        skip(`Skill: ${toolName} already deployed`);
-        return true;
-      }
-    } catch {}
-  }
+  // Find references/ source: repo path first, then permanent copy
+  let refsSrc = join(repoPath, 'references');
+  const permanentRefs = join(LDM_EXTENSIONS, toolName, 'references');
+  if (!existsSync(refsSrc) && existsSync(permanentRefs)) refsSrc = permanentRefs;
 
   if (DRY_RUN) {
-    ok(`Skill: would deploy ${toolName}/SKILL.md (dry run)`);
+    const targets = Object.entries(harnesses).filter(([,h]) => h.detected && h.skills).map(([name]) => name);
+    ok(`Skill: would deploy ${toolName} to ${targets.join(', ')} (dry run)`);
     return true;
   }
 
   try {
-    // Deploy to OpenClaw (~/.openclaw/skills/)
-    mkdirSync(ocSkillDir, { recursive: true });
-    cpSync(skillSrc, ocSkillDest);
-
-    // Deploy to Claude Code (~/.claude/skills/) - standard discovery path
-    const ccSkillDir = join(HOME, '.claude', 'skills', toolName);
-    if (existsSync(join(HOME, '.claude'))) {
-      mkdirSync(ccSkillDir, { recursive: true });
-      cpSync(skillSrc, join(ccSkillDir, 'SKILL.md'));
+    const deployed = [];
+
+    // 1. Save permanent copy to ~/.ldm/extensions/<name>/ (survives tmp cleanup)
+    const ldmSkillDir = join(LDM_EXTENSIONS, toolName);
+    mkdirSync(ldmSkillDir, { recursive: true });
+    cpSync(skillSrc, join(ldmSkillDir, 'SKILL.md'));
+    if (existsSync(refsSrc) && refsSrc !== permanentRefs) {
+      cpSync(refsSrc, join(ldmSkillDir, 'references'), { recursive: true });
     }
 
-    ok(`Skill: deployed to ~/.openclaw/skills/ and ~/.claude/skills/`);
-
-    // Deploy references/ if it exists (Agent Skills Spec pattern)
-    let refsSrc = join(repoPath, 'references');
-    // Fallback to already-deployed OC copy if source is gone
-    if (!existsSync(refsSrc) && existsSync(join(ocSkillDir, 'references'))) {
-      refsSrc = join(ocSkillDir, 'references');
-    }
-    if (existsSync(refsSrc)) {
-      // To OpenClaw skill dir
-      cpSync(refsSrc, join(ocSkillDir, 'references'), { recursive: true });
-      // To Claude Code skill dir
-      if (existsSync(ccSkillDir)) {
-        cpSync(refsSrc, join(ccSkillDir, 'references'), { recursive: true });
+    // 2. Deploy to every detected harness that has a skills path
+    for (const [name, harness] of Object.entries(harnesses)) {
+      if (!harness.detected || !harness.skills) continue;
+      const dest = join(harness.skills, toolName);
+      mkdirSync(dest, { recursive: true });
+      cpSync(skillSrc, join(dest, 'SKILL.md'));
+      if (existsSync(refsSrc)) {
+        cpSync(refsSrc, join(dest, 'references'), { recursive: true });
       }
+      deployed.push(name);
+    }
 
-      // Also deploy to home (settings/docs/skills/) so all agents can read them
-      try {
-        const ldmConfigPath = join(LDM_ROOT, 'config.json');
-        if (existsSync(ldmConfigPath)) {
-          const ldmConfig = JSON.parse(readFileSync(ldmConfigPath, 'utf8'));
-          const workspace = (ldmConfig.workspace || '').replace('~', HOME);
-          if (workspace && existsSync(workspace)) {
-            const homeRefsDest = join(workspace, 'settings', 'docs', 'skills', toolName);
-            mkdirSync(homeRefsDest, { recursive: true });
-            cpSync(refsSrc, homeRefsDest, { recursive: true });
-            ok(`Skill: references/ deployed to ${homeRefsDest.replace(HOME, '~')}`);
-          }
-        }
-      } catch {}
+    // 3. Deploy references/ to home (workspace settings/docs/skills/)
+    if (existsSync(refsSrc) && workspace && existsSync(workspace)) {
+      const homeRefsDest = join(workspace, 'settings', 'docs', 'skills', toolName);
+      mkdirSync(homeRefsDest, { recursive: true });
+      cpSync(refsSrc, homeRefsDest, { recursive: true });
+      deployed.push('home');
     }
 
+    ok(`Skill: ${toolName} deployed to ${deployed.join(', ')}`);
     return true;
   } catch (e) {
     fail(`Skill: deploy failed. ${e.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.53",
+  "version": "0.4.55",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {