@wipcomputer/wip-ldm-os 0.2.13 → 0.3.1

package/lib/updates.mjs

@@ -0,0 +1,173 @@
+/**
+ * lib/updates.mjs
+ * NPM update checker with cached manifest.
+ * Reads the extension registry, checks npm for newer versions,
+ * and writes results to ~/.ldm/state/available-updates.json.
+ * Zero external dependencies.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+const HOME = process.env.HOME || '';
+const LDM_ROOT = join(HOME, '.ldm');
+const LDM_EXTENSIONS = join(LDM_ROOT, 'extensions');
+const STATE_DIR = join(LDM_ROOT, 'state');
+const UPDATES_PATH = join(STATE_DIR, 'available-updates.json');
+const REGISTRY_PATH = join(LDM_EXTENSIONS, 'registry.json');
+
+// ── Helpers ──
+
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJSON(path, data) {
+  mkdirSync(join(path, '..'), { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+
+// ── Semver comparison ──
+// Copied from deploy.mjs to keep this module self-contained.
+
+/**
+ * Compare two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
+export function compareSemver(a, b) {
+  if (!a || !b) return 0;
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na > nb) return 1;
+    if (na < nb) return -1;
+  }
+  return 0;
+}
+
+// ── Catalog lookup ──
+
+let _catalog = null;
+
+function loadCatalog() {
+  if (_catalog) return _catalog;
+  try {
+    // Try the installed location first, then the repo-relative location
+    const paths = [
+      join(LDM_EXTENSIONS, 'wip-ldm-os', 'catalog.json'),
+      join(LDM_ROOT, 'catalog.json'),
+    ];
+    for (const p of paths) {
+      const data = readJSON(p);
+      if (data?.components) {
+        _catalog = data;
+        return data;
+      }
+    }
+  } catch {}
+  return { components: [] };
+}
+
+/**
+ * Resolve the npm package name for a registry entry.
+ * Checks the catalog for an npm field, or infers from the name.
+ * @param {string} name - Extension name from registry
+ * @param {Object} info - Registry entry info
+ * @returns {string|null} npm package name or null
+ */
+export function resolveNpmName(name, info) {
+  // Check catalog for npm field
+  const catalog = loadCatalog();
+  for (const c of catalog.components || []) {
+    // Match by ID or by registryMatches
+    if (c.id === name || (c.registryMatches || []).includes(name)) {
+      if (c.npm) return c.npm;
+    }
+  }
+
+  // Check if the registry entry itself has a packageName
+  if (info?.packageName) return info.packageName;
+
+  // Check deployed package.json for npm name
+  if (info?.ldmPath) {
+    const pkg = readJSON(join(info.ldmPath, 'package.json'));
+    if (pkg?.name) return pkg.name;
+  }
+
+  return null;
+}
+
+// ── Update checking ──
+
+/**
+ * Check for available updates by querying npm registry.
+ * Reads ~/.ldm/extensions/registry.json, checks each entry against npm,
+ * and writes results to ~/.ldm/state/available-updates.json.
+ * @returns {{ checkedAt: string, checked: number, updatesAvailable: number, updates: Array }}
+ */
+export function checkForUpdates() {
+  const registry = readJSON(REGISTRY_PATH);
+  if (!registry?.extensions) {
+    return { checkedAt: new Date().toISOString(), checked: 0, updatesAvailable: 0, updates: [] };
+  }
+
+  const updates = [];
+  let checked = 0;
+
+  for (const [name, info] of Object.entries(registry.extensions)) {
+    const npmName = resolveNpmName(name, info);
+    if (!npmName) continue;
+
+    const currentVersion = info.version;
+    if (!currentVersion || currentVersion === 'unknown' || currentVersion === '?') continue;
+
+    try {
+      const result = execSync(`npm view ${npmName} version 2>/dev/null`, {
+        encoding: 'utf8',
+        timeout: 10000,
+      }).trim();
+
+      checked++;
+
+      if (result && compareSemver(result, currentVersion) > 0) {
+        updates.push({
+          name,
+          packageName: npmName,
+          currentVersion,
+          latestVersion: result,
+          checkedAt: new Date().toISOString(),
+        });
+      }
+    } catch {
+      // Skip on failure (network error, package not found, timeout, etc.)
+    }
+  }
+
+  const manifest = {
+    checkedAt: new Date().toISOString(),
+    checked,
+    updatesAvailable: updates.length,
+    updates,
+  };
+
+  // Write to cache
+  try {
+    writeJSON(UPDATES_PATH, manifest);
+  } catch {}
+
+  return manifest;
+}
+
+/**
+ * Read the cached update manifest without re-checking npm.
+ * @returns {Object|null} The cached manifest or null if not found
+ */
+export function readUpdateManifest() {
+  return readJSON(UPDATES_PATH);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.2.13",
+  "version": "0.3.1",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "main": "src/boot/boot-hook.mjs",
@@ -8,7 +8,12 @@
     "ldm": "bin/ldm.js",
     "wip-ldm-os": "bin/ldm.js",
     "ldm-scaffold": "bin/scaffold.sh",
-    "ldm-boot-install": "src/boot/install-cli.js"
+    "ldm-boot-install": "src/boot/install-cli.js",
+    "lesa": "dist/bridge/cli.js"
+  },
+  "scripts": {
+    "build:bridge": "cd src/bridge && npm install && npx tsup core.ts mcp-server.ts cli.ts --format esm --dts --clean --outDir ../../dist/bridge",
+    "build": "npm run build:bridge"
   },
   "claudeCode": {
     "hook": {
@@ -22,7 +27,9 @@
     "src/",
     "lib/",
     "bin/",
+    "dist/bridge/",
     "templates/",
+    "docs/",
     "catalog.json",
     "SKILL.md"
   ],

package/src/boot/boot-hook.mjs

@@ -5,7 +5,7 @@
 // Follows guard.mjs pattern: stdin JSON in, stdout JSON out, exit 0 always.
 
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
+import { join, dirname, resolve, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
@@ -212,6 +212,41 @@ async function main() {
     }
   }
 
+  // ── Register session (fire-and-forget) ──
+  try {
+    const { registerSession } = await import('../../lib/sessions.mjs');
+    const name = process.env.CLAUDE_SESSION_NAME || basename(input?.cwd || process.cwd()) || `session-${process.pid}`;
+    registerSession({
+      name,
+      agentId: config?.agentId || 'unknown',
+      pid: process.ppid || process.pid,
+      meta: { cwd: input?.cwd },
+    });
+  } catch {}
+
+  // ── Check pending messages ──
+  try {
+    const { readMessages } = await import('../../lib/messages.mjs');
+    const sessionName = process.env.CLAUDE_SESSION_NAME || basename(input?.cwd || process.cwd()) || 'unknown';
+    const pending = readMessages(sessionName, { markRead: false });
+    if (pending.length > 0) {
+      const msgLines = pending.map(m => `  [${m.type}] ${m.from}: ${m.body}`).join('\n');
+      sections.push(`== Pending Messages (${pending.length}) ==\n${msgLines}`);
+    }
+  } catch {}
+
+  // ── Check for updates ──
+  try {
+    const { readUpdateManifest } = await import('../../lib/updates.mjs');
+    const manifest = readUpdateManifest();
+    if (manifest?.updatesAvailable > 0) {
+      const updateLines = manifest.updates
+        .map(u => `  ${u.name}: ${u.currentVersion} -> ${u.latestVersion}`)
+        .join('\n');
+      sections.push(`== Updates Available (${manifest.updatesAvailable}) ==\n${updateLines}\nRun: ldm install`);
+    }
+  } catch {}
+
   const elapsed = Date.now() - startTime;
   const footer = `== Boot complete. Loaded ${loaded.length}/9 files in ${elapsed}ms. ==`;
   if (skipped.length > 0) {

package/src/bridge/cli.ts

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// lesa-bridge/cli.ts: CLI interface.
+// lesa send "message", lesa inbox, lesa search "query", lesa read <file>
+
+import { existsSync, statSync } from "node:fs";
+import {
+  resolveConfig,
+  resolveGatewayConfig,
+  resolveApiKey,
+  sendMessage,
+  searchConversations,
+  searchWorkspace,
+  readWorkspaceFile,
+  discoverSkills,
+} from "./core.js";
+
+const config = resolveConfig();
+
+function usage(): void {
+  console.log(`lesa-bridge: Claude Code CLI ↔ OpenClaw TUI agent bridge
+
+Usage:
+  lesa send <message>         Send a message to the OpenClaw agent
+  lesa search <query>         Semantic search over conversation history
+  lesa memory <query>         Keyword search across workspace files
+  lesa read <path>            Read a workspace file (relative to workspace/)
+  lesa status                 Show bridge configuration
+  lesa diagnose               Check gateway, inbox, DB, skills health
+  lesa help                   Show this help
+
+Examples:
+  lesa send "What are you working on?"
+  lesa search "API key resolution"
+  lesa memory "compaction"
+  lesa read MEMORY.md
+  lesa read memory/2026-02-10.md`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    usage();
+    process.exit(0);
+  }
+
+  const arg = args.slice(1).join(" ");
+
+  switch (command) {
+    case "send": {
+      if (!arg) {
+        console.error("Error: message required. Usage: lesa send <message>");
+        process.exit(1);
+      }
+      try {
+        const reply = await sendMessage(config.openclawDir, arg);
+        console.log(reply);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case "search": {
+      if (!arg) {
+        console.error("Error: query required. Usage: lesa search <query>");
+        process.exit(1);
+      }
+      try {
+        const results = await searchConversations(config, arg);
+        if (results.length === 0) {
+          console.log("No results found.");
+        } else {
+          const icon: Record<string, string> = { fresh: "🟢", recent: "🟡", aging: "🟠", stale: "🔴" };
+          for (const [i, r] of results.entries()) {
+            const sim = r.similarity !== undefined ? ` (${(r.similarity * 100).toFixed(1)}%)` : "";
+            const fresh = r.freshness ? ` ${icon[r.freshness]} ${r.freshness}` : "";
+            console.log(`[${i + 1}]${sim}${fresh} ${r.sessionKey} ${r.date}`);
+            console.log(r.text);
+            if (i < results.length - 1) console.log("\n---\n");
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case "memory": {
+      if (!arg) {
+        console.error("Error: query required. Usage: lesa memory <query>");
+        process.exit(1);
+      }
+      try {
+        const results = searchWorkspace(config.workspaceDir, arg);
+        if (results.length === 0) {
+          console.log(`No workspace files matched "${arg}".`);
+        } else {
+          for (const r of results) {
+            console.log(`### ${r.path}`);
+            for (const excerpt of r.excerpts) {
+              console.log(`  ${excerpt.replace(/\n/g, "\n  ")}`);
+            }
+            console.log();
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case "read": {
+      if (!arg) {
+        console.error("Error: path required. Usage: lesa read <path>");
+        process.exit(1);
+      }
+      try {
+        const result = readWorkspaceFile(config.workspaceDir, arg);
+        console.log(result.content);
+      } catch (err: any) {
+        console.error(err.message);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case "status": {
+      console.log(`lesa-bridge status`);
+      console.log(`  OpenClaw dir:  ${config.openclawDir}`);
+      console.log(`  Workspace:     ${config.workspaceDir}`);
+      console.log(`  Database:      ${config.dbPath}`);
+      console.log(`  Inbox port:    ${config.inboxPort}`);
+      console.log(`  Embedding:     ${config.embeddingModel} (${config.embeddingDimensions}d)`);
+      break;
+    }
+
+    case "diagnose": {
+      console.log("lesa-bridge diagnose\n");
+      let issues = 0;
+
+      // 1. OpenClaw dir
+      if (existsSync(config.openclawDir)) {
+        console.log(`  ✓ OpenClaw dir exists: ${config.openclawDir}`);
+      } else {
+        console.log(`  ✗ OpenClaw dir missing: ${config.openclawDir}`);
+        issues++;
+      }
+
+      // 2. Gateway config + connectivity
+      try {
+        const gw = resolveGatewayConfig(config.openclawDir);
+        console.log(`  ✓ Gateway config found (port ${gw.port}, token present)`);
+
+        try {
+          const resp = await fetch(`http://127.0.0.1:${gw.port}/health`, { signal: AbortSignal.timeout(3000) });
+          if (resp.ok) {
+            console.log(`  ✓ Gateway responding on port ${gw.port}`);
+          } else {
+            console.log(`  ✗ Gateway returned ${resp.status}`);
+            issues++;
+          }
+        } catch {
+          console.log(`  ✗ Gateway not reachable on port ${gw.port}`);
+          issues++;
+        }
+      } catch (err: any) {
+        console.log(`  ✗ Gateway config: ${err.message}`);
+        issues++;
+      }
+
+      // 3. Inbox endpoint
+      try {
+        const resp = await fetch(`http://127.0.0.1:${config.inboxPort}/status`, { signal: AbortSignal.timeout(3000) });
+        const data = await resp.json() as { ok: boolean; pending: number };
+        if (data.ok) {
+          console.log(`  ✓ Inbox endpoint responding (${data.pending} pending)`);
+        } else {
+          console.log(`  ✗ Inbox endpoint returned unexpected response`);
+          issues++;
+        }
+      } catch {
+        console.log(`  - Inbox not running (normal if MCP server isn't started)`);
+      }
+
+      // 4. Embeddings DB
+      if (existsSync(config.dbPath)) {
+        const stats = statSync(config.dbPath);
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(1);
+        console.log(`  ✓ Embeddings DB exists (${sizeMB} MB)`);
+      } else {
+        console.log(`  ✗ Embeddings DB missing: ${config.dbPath}`);
+        issues++;
+      }
+
+      // 5. API key
+      const apiKey = resolveApiKey(config.openclawDir);
+      if (apiKey) {
+        console.log(`  ✓ OpenAI API key found (semantic search enabled)`);
+      } else {
+        console.log(`  - No OpenAI API key (text search fallback)`);
+      }
+
+      // 6. Skills
+      try {
+        const skills = discoverSkills(config.openclawDir);
+        const executable = skills.filter(s => s.hasScripts).length;
+        console.log(`  ✓ Skills discovered: ${skills.length} total, ${executable} executable`);
+      } catch (err: any) {
+        console.log(`  ✗ Skill discovery failed: ${err.message}`);
+        issues++;
+      }
+
+      // 7. Workspace
+      if (existsSync(config.workspaceDir)) {
+        console.log(`  ✓ Workspace dir exists`);
+      } else {
+        console.log(`  ✗ Workspace dir missing: ${config.workspaceDir}`);
+        issues++;
+      }
+
+      console.log();
+      if (issues === 0) {
+        console.log("  All checks passed.");
+      } else {
+        console.log(`  ${issues} issue(s) found.`);
+      }
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      usage();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});