@wipcomputer/wip-ldm-os 0.4.79 → 0.4.80

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.79"
+  version: "0.4.80"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/ldm.js

@@ -2892,6 +2892,63 @@ async function cmdDoctor() {
     cleanupStaleClaudeCodeEnv();
   }
 
+  // 3b. MCP health check (Phase 3c)
+  //
+  // Walk ~/.claude.json#mcpServers. For every entry whose command is node
+  // and whose first arg resolves under ~/.ldm/extensions/ or ~/.openclaw/
+  // extensions/, verify the file exists and parses. Report any that do not.
+  //
+  // This catches the failure mode where an extension renamed its MCP file,
+  // updated its deployed artifacts, but the old .claude.json entry still
+  // points at a path that was rotated into _trash. Surfacing these in
+  // doctor makes the class of failure loud instead of silent.
+  {
+    const ccUserPath = join(HOME, '.claude.json');
+    const ccUser = readJSON(ccUserPath);
+    const ldmExtRoot = LDM_EXTENSIONS;
+    const ocExtRoot = join(HOME, '.openclaw', 'extensions');
+    const broken = [];
+    if (ccUser?.mcpServers) {
+      for (const [name, cfg] of Object.entries(ccUser.mcpServers)) {
+        if (cfg?.command !== 'node') continue;
+        const args = Array.isArray(cfg.args) ? cfg.args : [];
+        const first = args[0];
+        if (!first || typeof first !== 'string') continue;
+        const underExt = first.startsWith(ldmExtRoot + '/') || first.startsWith(ocExtRoot + '/');
+        if (!underExt) continue;
+        if (!existsSync(first)) {
+          broken.push({ name, path: first, reason: 'missing' });
+          continue;
+        }
+        try {
+          execSync(`node --check "${first}"`, { stdio: 'pipe', timeout: 5000 });
+        } catch (e) {
+          const stderr = (e && e.stderr && e.stderr.toString && e.stderr.toString().trim()) || (e && e.message) || 'unparseable';
+          broken.push({ name, path: first, reason: 'unparseable', detail: stderr.split('\n')[0] });
+        }
+      }
+    }
+    if (broken.length > 0) {
+      for (const b of broken) {
+        const detail = b.detail ? ` (${b.detail})` : '';
+        console.log(`  ! MCP ${b.name}: ${b.reason} at ${b.path}${detail}`);
+      }
+      if (FIX_FLAG && ccUser?.mcpServers) {
+        for (const b of broken) {
+          delete ccUser.mcpServers[b.name];
+          console.log(`  + Removed dangling MCP: ${b.name}`);
+        }
+        writeFileSync(ccUserPath, JSON.stringify(ccUser, null, 2) + '\n');
+        // --fix resolved them, do not count as outstanding issues
+      } else {
+        console.log(`    Run: ldm doctor --fix to remove ${broken.length} dangling MCP entr${broken.length === 1 ? 'y' : 'ies'}`);
+        issues += broken.length;
+      }
+    } else if (ccUser?.mcpServers && Object.keys(ccUser.mcpServers).length > 0) {
+      console.log(`  + MCP entries under LDM/OC extensions: all paths exist and parse`);
+    }
+  }
+
   // 4. Check sacred locations
   const sacred = [
     { path: join(LDM_ROOT, 'memory'), label: 'memory/' },

package/lib/deploy.mjs

@@ -245,9 +245,17 @@ function buildSourceInfo(repoPath, pkg) {
     hasInfo = true;
   }
 
-  // If the repo path is inside ~/.ldm/tmp/, it was cloned from somewhere.
-  // Try to get the remote URL from git.
-  if (!source.repo) {
+  // If the repo path is itself a git working tree, trust its origin URL.
+  // Previously this ran git remote unconditionally, which walks up the
+  // directory tree. For npm-sourced installs extracted under ~/.ldm/tmp/
+  // (inside the tracked ~/.ldm repo), git happily returned the parent
+  // tracking repo's remote (wipcomputer/...-system-private) as the
+  // source for every extension. Registry source.repo was therefore
+  // unreliable. Now we only consult git if repoPath itself has a .git
+  // entry (directory for normal clones, file for worktrees). If it
+  // does not, we leave source.repo unset rather than capturing an
+  // ancestor's remote.
+  if (!source.repo && existsSync(join(repoPath, '.git'))) {
     try {
       const remote = execSync('git remote get-url origin 2>/dev/null', {
         cwd: repoPath,
@@ -882,6 +890,60 @@ function verifyOcConfig(pluginDirName) {
   }
 }
 
+/**
+ * Phase 3b: remove a stale MCP registration for an extension whose current
+ * source no longer exposes an MCP interface. Keyed on path, not source
+ * metadata (buildSourceInfo is known to capture the parent repo's remote
+ * when extraction lands inside another git working tree).
+ *
+ * Removes the entry from ~/.claude.json#mcpServers if the args path
+ * resolves under LDM_EXTENSIONS/<toolName> or OC_EXTENSIONS/<toolName>.
+ * No-op if no entry exists or the path points elsewhere.
+ */
+function unregisterStaleMCP(toolName) {
+  const ccUserPath = join(HOME, '.claude.json');
+  const ccUser = readJSON(ccUserPath);
+  const entry = ccUser?.mcpServers?.[toolName];
+  if (!entry) return;
+
+  const firstArg = Array.isArray(entry.args) ? entry.args[0] : null;
+  if (!firstArg || typeof firstArg !== 'string') return;
+
+  const ldmExt = join(LDM_EXTENSIONS, toolName);
+  const ocExt = join(OC_EXTENSIONS, toolName);
+  const pointsHere = firstArg.startsWith(ldmExt + '/') || firstArg.startsWith(ocExt + '/');
+  if (!pointsHere) return;
+
+  if (DRY_RUN) {
+    ok(`MCP: would unregister stale ${toolName} entry pointing at ${firstArg} (dry run)`);
+    return;
+  }
+
+  try {
+    execSync(`claude mcp remove ${toolName} --scope user`, { stdio: 'pipe' });
+    ok(`MCP: unregistered stale ${toolName} entry (source no longer exposes MCP)`);
+  } catch {
+    // Fallback: direct edit to ~/.claude.json
+    try {
+      const cfg = readJSON(ccUserPath) || {};
+      if (cfg.mcpServers && cfg.mcpServers[toolName]) {
+        delete cfg.mcpServers[toolName];
+        writeJSON(ccUserPath, cfg);
+        ok(`MCP: unregistered stale ${toolName} entry via direct .claude.json edit`);
+      }
+    } catch (e) {
+      log(`Warning: could not unregister stale MCP ${toolName}: ${e.message}`);
+    }
+  }
+
+  // Also clean OpenClaw side if installed.
+  try {
+    execSync(`openclaw mcp unset ${toolName}`, { stdio: 'pipe' });
+  } catch {
+    // Non-fatal. OpenClaw may not be installed, or may not have had this mcp.
+  }
+}
+
 function registerMCP(repoPath, door, toolName) {
   let rawName = toolName || door.name || basename(repoPath);
   // Strip /tmp/ clone prefixes (ldm-install-, wip-install-)
@@ -894,6 +956,27 @@ function registerMCP(repoPath, door, toolName) {
     : existsSync(ldmFallbackPath) ? ldmFallbackPath
     : repoServerPath;
 
+  // Postcondition: the resolved entrypoint must exist and parse before we
+  // touch ~/.claude.json. Previously, if the published tarball did not
+  // contain the declared mcp-server file (see wip-1password 0.2.3-alpha.2
+  // bug writeup), we still wrote the registration and left a dangling
+  // "Failed to connect" entry that was invisible until the user ran
+  // `claude mcp list`. Fail loudly instead.
+  if (!existsSync(mcpPath)) {
+    fail(`MCP: ${name} registration aborted. Resolved path does not exist: ${mcpPath}`);
+    fail(`MCP: candidates checked: ${ldmServerPath}, ${ldmFallbackPath}, ${repoServerPath}`);
+    fail(`MCP: verify the published package includes "${door.file}" (check files array).`);
+    return false;
+  }
+  try {
+    execSync(`node --check "${mcpPath}"`, { stdio: 'pipe', timeout: 5000 });
+  } catch (e) {
+    const stderr = (e && e.stderr && e.stderr.toString && e.stderr.toString().trim()) || (e && e.message) || 'unknown error';
+    fail(`MCP: ${name} registration aborted. Entrypoint failed node --check: ${mcpPath}`);
+    fail(`MCP: ${stderr}`);
+    return false;
+  }
+
   // Check ~/.claude.json (user-level MCP)
   const ccUserPath = join(HOME, '.claude.json');
   const ccUser = readJSON(ccUserPath);
@@ -1272,6 +1355,12 @@ export function installSingleTool(toolPath) {
     } else {
       skip(`MCP: ${toolName} not enabled. Run: ldm enable ${toolName}`);
     }
+  } else {
+    // Phase 3b: source no longer exposes an MCP interface (file renamed,
+    // moved to src/, removed, etc). If a prior install registered an MCP
+    // whose args point into this extension's directory, un-register it so
+    // claude mcp list does not keep a dangling "Failed to connect" entry.
+    unregisterStaleMCP(toolName);
   }
 
   if (interfaces.claudeCodeHook) {

package/package.json

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