@wipcomputer/wip-ldm-os 0.2.14 → 0.3.2

package/SKILL.md

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

package/bin/ldm.js

@@ -9,6 +9,11 @@
  *   ldm install           Install/update all registered components
  *   ldm doctor            Check health of all extensions
  *   ldm status            Show LDM OS version and extension count
+ *   ldm sessions          List active sessions
+ *   ldm msg send <to> <b> Send a message to a session
+ *   ldm msg list          List pending messages
+ *   ldm msg broadcast <b> Send to all sessions
+ *   ldm updates           Show available updates
  *   ldm --version         Show version
  */
 
@@ -47,6 +52,8 @@ const JSON_OUTPUT = args.includes('--json');
 const YES_FLAG = args.includes('--yes') || args.includes('-y');
 const NONE_FLAG = args.includes('--none');
 const FIX_FLAG = args.includes('--fix');
+const CLEANUP_FLAG = args.includes('--cleanup');
+const CHECK_FLAG = args.includes('--check');
 
 function readJSON(path) {
   try {
@@ -61,6 +68,68 @@ function writeJSON(path, data) {
   writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
 }
 
+// ── CLI version check (#29) ──
+
+function checkCliVersion() {
+  try {
+    const result = execSync('npm view @wipcomputer/wip-ldm-os version 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 10000,
+    }).trim();
+    if (result && result !== PKG_VERSION) {
+      console.log('');
+      console.log(`  CLI is outdated: v${PKG_VERSION} installed, v${result} available.`);
+      console.log(`  Run: npm install -g @wipcomputer/wip-ldm-os@${result}`);
+    }
+  } catch {
+    // npm check failed, skip silently
+  }
+}
+
+// ── Stale hook cleanup (#30) ──
+
+function cleanStaleHooks() {
+  const settingsPath = join(HOME, '.claude', 'settings.json');
+  const settings = readJSON(settingsPath);
+  if (!settings?.hooks) return 0;
+
+  let cleaned = 0;
+
+  for (const [event, hookGroups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(hookGroups)) continue;
+
+    // Filter out hook groups where ALL hooks point to non-existent paths
+    const original = hookGroups.length;
+    settings.hooks[event] = hookGroups.filter(group => {
+      const hooks = group.hooks || [];
+      if (hooks.length === 0) return true; // keep empty groups (matcher-only)
+
+      // Check each hook command for stale paths
+      const liveHooks = hooks.filter(h => {
+        if (!h.command) return true;
+        // Extract the path from "node /path/to/file.mjs" or "node \"/path/to/file.mjs\""
+        const match = h.command.match(/node\s+"?([^"]+)"?\s*$/);
+        if (!match) return true; // keep non-node commands
+        const scriptPath = match[1];
+        if (existsSync(scriptPath)) return true;
+        console.log(`  + Removed stale hook: ${event} -> ${scriptPath}`);
+        cleaned++;
+        return false;
+      });
+
+      // Keep the group if it still has live hooks
+      group.hooks = liveHooks;
+      return liveHooks.length > 0;
+    });
+  }
+
+  if (cleaned > 0) {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+
+  return cleaned;
+}
+
 // ── Catalog helpers ──
 
 function loadCatalog() {
@@ -83,7 +152,10 @@ async function cmdInit() {
     join(LDM_ROOT, 'agents'),
     join(LDM_ROOT, 'memory'),
     join(LDM_ROOT, 'state'),
+    join(LDM_ROOT, 'sessions'),
+    join(LDM_ROOT, 'messages'),
     join(LDM_ROOT, 'shared', 'boot'),
+    join(LDM_ROOT, 'shared', 'cron'),
   ];
 
   const existing = existsSync(VERSION_PATH);
@@ -558,6 +630,10 @@ async function cmdInstallCatalog() {
 
   console.log('');
   console.log(`  Updated ${updated}/${updatable.length} extension(s).`);
+
+  // Check if CLI itself is outdated (#29)
+  checkCliVersion();
+
   console.log('');
 }
 
@@ -631,11 +707,21 @@ async function cmdDoctor() {
     }
   }
 
+  // --fix: clean stale hook paths in settings.json (#30)
+  if (FIX_FLAG) {
+    const hooksCleaned = cleanStaleHooks();
+    if (hooksCleaned > 0) {
+      issues = Math.max(0, issues - hooksCleaned);
+    }
+  }
+
   // 4. Check sacred locations
   const sacred = [
     { path: join(LDM_ROOT, 'memory'), label: 'memory/' },
     { path: join(LDM_ROOT, 'agents'), label: 'agents/' },
     { path: join(LDM_ROOT, 'state'), label: 'state/' },
+    { path: join(LDM_ROOT, 'sessions'), label: 'sessions/' },
+    { path: join(LDM_ROOT, 'messages'), label: 'messages/' },
   ];
 
   for (const s of sacred) {
@@ -653,6 +739,29 @@ async function cmdDoctor() {
   if (settings?.hooks) {
     const hookCount = Object.values(settings.hooks).reduce((sum, arr) => sum + (arr?.length || 0), 0);
     console.log(`  + Claude Code hooks: ${hookCount} configured`);
+
+    // Check for stale hook paths
+    let staleHooks = 0;
+    for (const [event, hookGroups] of Object.entries(settings.hooks)) {
+      if (!Array.isArray(hookGroups)) continue;
+      for (const group of hookGroups) {
+        for (const h of (group.hooks || [])) {
+          if (!h.command) continue;
+          const match = h.command.match(/node\s+"?([^"]+)"?\s*$/);
+          if (!match) continue;
+          if (!existsSync(match[1])) {
+            staleHooks++;
+            if (!FIX_FLAG) {
+              console.log(`  ! Stale hook: ${event} -> ${match[1]}`);
+            }
+          }
+        }
+      }
+    }
+    if (staleHooks > 0 && !FIX_FLAG) {
+      console.log(`    Run: ldm doctor --fix to clean ${staleHooks} stale hook(s)`);
+      issues += staleHooks;
+    }
   } else {
     console.log(`  - Claude Code hooks: none configured`);
   }
@@ -716,6 +825,218 @@ function cmdStatus() {
   console.log('');
 }
 
+// ── ldm sessions ──
+
+async function cmdSessions() {
+  const { listSessions } = await import('../lib/sessions.mjs');
+  const sessions = listSessions({ includeStale: CLEANUP_FLAG });
+
+  if (CLEANUP_FLAG) {
+    // listSessions already cleans stale when includeStale is false.
+    // With --cleanup, we list stale ones so user can see them, then re-run without stale.
+    const stale = sessions.filter(s => !s.alive);
+    if (stale.length > 0) {
+      const { deregisterSession } = await import('../lib/sessions.mjs');
+      for (const s of stale) {
+        deregisterSession(s.name);
+      }
+      console.log(`  Cleaned ${stale.length} stale session(s).`);
+    } else {
+      console.log('  No stale sessions found.');
+    }
+    console.log('');
+    return;
+  }
+
+  const live = sessions.filter(s => s.alive);
+
+  if (JSON_OUTPUT) {
+    console.log(JSON.stringify(live, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log('  Active Sessions');
+  console.log('  ────────────────────────────────────');
+
+  if (live.length === 0) {
+    console.log('  No active sessions.');
+  } else {
+    for (const s of live) {
+      const age = timeSince(s.startTime);
+      console.log(`  ${s.name}  agent=${s.agentId}  pid=${s.pid}  up=${age}`);
+    }
+  }
+
+  console.log('');
+}
+
+function timeSince(isoString) {
+  try {
+    const ms = Date.now() - new Date(isoString).getTime();
+    const secs = Math.floor(ms / 1000);
+    if (secs < 60) return `${secs}s`;
+    const mins = Math.floor(secs / 60);
+    if (mins < 60) return `${mins}m`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24) return `${hours}h ${mins % 60}m`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ${hours % 24}h`;
+  } catch {
+    return '?';
+  }
+}
+
+// ── ldm msg ──
+
+async function cmdMsg() {
+  const subcommand = args[1];
+
+  if (!subcommand || subcommand === 'list') {
+    return cmdMsgList();
+  }
+  if (subcommand === 'send') {
+    return cmdMsgSend();
+  }
+  if (subcommand === 'broadcast') {
+    return cmdMsgBroadcast();
+  }
+
+  console.error(`  Unknown msg subcommand: ${subcommand}`);
+  console.error('  Usage: ldm msg [send <to> <body> | list | broadcast <body>]');
+  process.exit(1);
+}
+
+async function cmdMsgList() {
+  const { readMessages } = await import('../lib/messages.mjs');
+  const sessionName = process.env.CLAUDE_SESSION_NAME || 'unknown';
+  const messages = readMessages(sessionName, { markRead: false });
+
+  if (JSON_OUTPUT) {
+    console.log(JSON.stringify(messages, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(`  Messages for "${sessionName}"`);
+  console.log('  ────────────────────────────────────');
+
+  if (messages.length === 0) {
+    console.log('  No pending messages.');
+  } else {
+    for (const m of messages) {
+      const ts = m.timestamp?.split('T')[1]?.split('.')[0] || '';
+      console.log(`  [${m.type}] ${ts} from=${m.from}: ${m.body}`);
+    }
+  }
+
+  console.log('');
+}
+
+async function cmdMsgSend() {
+  const { sendMessage } = await import('../lib/messages.mjs');
+  // args: ['msg', 'send', '<to>', '<body...>']
+  const to = args[2];
+  const body = args.slice(3).filter(a => !a.startsWith('--')).join(' ');
+
+  if (!to || !body) {
+    console.error('  Usage: ldm msg send <to> <body>');
+    process.exit(1);
+  }
+
+  const sessionName = process.env.CLAUDE_SESSION_NAME || 'ldm-cli';
+  const id = sendMessage({ from: sessionName, to, body, type: 'chat' });
+
+  if (id) {
+    console.log(`  Message sent to "${to}" (id: ${id})`);
+  } else {
+    console.error('  x Failed to send message.');
+    process.exit(1);
+  }
+}
+
+async function cmdMsgBroadcast() {
+  const { sendMessage } = await import('../lib/messages.mjs');
+  // args: ['msg', 'broadcast', '<body...>']
+  const body = args.slice(2).filter(a => !a.startsWith('--')).join(' ');
+
+  if (!body) {
+    console.error('  Usage: ldm msg broadcast <body>');
+    process.exit(1);
+  }
+
+  const sessionName = process.env.CLAUDE_SESSION_NAME || 'ldm-cli';
+  const id = sendMessage({ from: sessionName, to: 'all', body, type: 'chat' });
+
+  if (id) {
+    console.log(`  Broadcast sent (id: ${id})`);
+  } else {
+    console.error('  x Failed to send broadcast.');
+    process.exit(1);
+  }
+}
+
+// ── ldm updates ──
+
+async function cmdUpdates() {
+  if (CHECK_FLAG) {
+    // Re-check npm registry
+    const { checkForUpdates } = await import('../lib/updates.mjs');
+    console.log('  Checking npm for updates...');
+    console.log('');
+    const result = checkForUpdates();
+
+    if (JSON_OUTPUT) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (result.updatesAvailable === 0) {
+      console.log(`  Checked ${result.checked} extensions. Everything is up to date.`);
+    } else {
+      console.log(`  Checked ${result.checked} extensions. ${result.updatesAvailable} update(s) available:`);
+      console.log('');
+      for (const u of result.updates) {
+        console.log(`    ${u.name}: ${u.currentVersion} -> ${u.latestVersion} (${u.packageName})`);
+      }
+      console.log('');
+      console.log('  Run: ldm install');
+    }
+    console.log('');
+    return;
+  }
+
+  // Show cached results
+  const { readUpdateManifest } = await import('../lib/updates.mjs');
+  const manifest = readUpdateManifest();
+
+  if (JSON_OUTPUT) {
+    console.log(JSON.stringify(manifest || {}, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log('  Available Updates');
+  console.log('  ────────────────────────────────────');
+
+  if (!manifest) {
+    console.log('  No update check has been run yet.');
+    console.log('  Run: ldm updates --check');
+  } else if (manifest.updatesAvailable === 0) {
+    console.log(`  Everything is up to date. (checked ${manifest.checkedAt?.split('T')[0] || 'unknown'})`);
+  } else {
+    console.log(`  ${manifest.updatesAvailable} update(s) available (checked ${manifest.checkedAt?.split('T')[0] || 'unknown'}):`);
+    console.log('');
+    for (const u of manifest.updates) {
+      console.log(`    ${u.name}: ${u.currentVersion} -> ${u.latestVersion}`);
+    }
+    console.log('');
+    console.log('  Run: ldm install');
+  }
+
+  console.log('');
+}
+
 // ── Main ──
 
 async function main() {
@@ -730,10 +1051,19 @@ async function main() {
     console.log('    ldm install                 Update all registered extensions');
     console.log('    ldm doctor                  Check health of all extensions');
     console.log('    ldm status                  Show version and extension list');
+    console.log('    ldm sessions                List active sessions');
+    console.log('    ldm sessions --cleanup      Remove stale session entries');
+    console.log('    ldm msg send <to> <body>    Send a message to a session');
+    console.log('    ldm msg list                List pending messages');
+    console.log('    ldm msg broadcast <body>    Send to all sessions');
+    console.log('    ldm updates                 Show available updates from cache');
+    console.log('    ldm updates --check         Re-check npm registry for updates');
     console.log('');
     console.log('  Flags:');
     console.log('    --dry-run   Show what would happen without making changes');
     console.log('    --json      Output results as JSON');
+    console.log('    --cleanup   Remove stale entries (sessions)');
+    console.log('    --check     Re-check registry (updates)');
     console.log('');
     console.log('  Interfaces detected:');
     console.log('    CLI        ... package.json bin -> npm install -g');
@@ -770,6 +1100,15 @@ async function main() {
     case 'status':
       cmdStatus();
       break;
+    case 'sessions':
+      await cmdSessions();
+      break;
+    case 'msg':
+      await cmdMsg();
+      break;
+    case 'updates':
+      await cmdUpdates();
+      break;
     default:
       console.error(`  Unknown command: ${command}`);
       console.error(`  Run: ldm --help`);