@wipcomputer/wip-ldm-os 0.4.85-alpha.25 → 0.4.85-alpha.27

package/bin/ldm.js

@@ -22,7 +22,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, cpSync, chmodSync, unlinkSync, readlinkSync, renameSync, statSync, lstatSync, symlinkSync } from 'node:fs';
 import { join, basename, resolve, dirname } from 'node:path';
-import { execFileSync, execSync, spawnSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -3284,27 +3284,89 @@ async function cmdDoctor() {
 
 const STATUS_NPM_TIMEOUT_MS = parsePositiveInt(process.env.LDM_STATUS_NPM_TIMEOUT_MS, 5000);
 const STATUS_TOTAL_BUDGET_MS = parsePositiveInt(process.env.LDM_STATUS_TOTAL_BUDGET_MS, 60000);
+const STATUS_NPM_CONCURRENCY = parsePositiveInt(process.env.LDM_STATUS_NPM_CONCURRENCY, 8);
+const STATUS_NPM_REGISTRY_URL = process.env.LDM_STATUS_NPM_REGISTRY_URL || 'https://registry.npmjs.org';
 
-function npmViewVersionForStatus(pkg, timeoutMs) {
-  return execFileSync('npm', ['view', pkg, 'version'], {
-    encoding: 'utf8',
-    timeout: timeoutMs,
-    stdio: ['ignore', 'pipe', 'ignore'],
-  }).trim();
+async function npmViewVersionForStatus(pkg, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const registry = STATUS_NPM_REGISTRY_URL.replace(/\/+$/, '');
+    const response = await fetch(`${registry}/${encodeURIComponent(pkg)}`, {
+      signal: controller.signal,
+      headers: { accept: 'application/vnd.npm.install-v1+json, application/json' },
+    });
+    if (!response.ok) {
+      const error = new Error(`npm registry returned ${response.status}`);
+      error.statusCode = response.status;
+      throw error;
+    }
+    const metadata = await response.json();
+    return metadata?.['dist-tags']?.latest || '';
+  } finally {
+    clearTimeout(timeout);
+  }
 }
 
 function remainingStatusBudgetMs(startedAt) {
   return Math.max(0, STATUS_TOTAL_BUDGET_MS - (Date.now() - startedAt));
 }
 
+function formatStatusElapsed(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return '0ms';
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
 function classifyStatusCheckError(error) {
-  if (error?.signal === 'SIGTERM' || error?.code === 'ETIMEDOUT' || String(error?.message || '').includes('ETIMEDOUT')) {
+  if (error?.name === 'AbortError' || error?.signal === 'SIGTERM' || error?.code === 'ETIMEDOUT' || String(error?.message || '').includes('ETIMEDOUT')) {
     return 'timeout';
   }
   return 'unavailable';
 }
 
-function cmdStatus() {
+async function runStatusProbesWithConcurrency(items, concurrency, statusStartedAt) {
+  if (items.length === 0) return [];
+
+  const results = new Array(items.length);
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const item = items[index];
+      const remaining = remainingStatusBudgetMs(statusStartedAt);
+
+      if (remaining <= 0) {
+        results[index] = { ...item, status: 'skipped', reason: 'budget', elapsedMs: 0 };
+        continue;
+      }
+
+      const timeout = Math.min(STATUS_NPM_TIMEOUT_MS, remaining);
+      const probeStartedAt = Date.now();
+      console.log(`    ${item.name}: checking npm`);
+
+      try {
+        const latest = await npmViewVersionForStatus(item.npm, timeout);
+        results[index] = { ...item, status: 'ok', latest, elapsedMs: Date.now() - probeStartedAt };
+      } catch (error) {
+        results[index] = {
+          ...item,
+          status: 'skipped',
+          reason: classifyStatusCheckError(error),
+          elapsedMs: Date.now() - probeStartedAt,
+        };
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+
+async function cmdStatus() {
   const version = readJSON(VERSION_PATH);
   const registry = readJSON(REGISTRY_PATH);
   const extCount = Object.keys(registry?.extensions || {}).length;
@@ -3338,18 +3400,14 @@ function cmdStatus() {
   console.log('');
   console.log('  Checking updates:');
 
-  let cliUpdate = null;
-  try {
-    const timeout = Math.min(STATUS_NPM_TIMEOUT_MS, remainingStatusBudgetMs(statusStartedAt));
-    if (timeout <= 0) throw new Error('status update-check budget exhausted');
-    console.log('    ldm cli: checking npm');
-    const latest = npmViewVersionForStatus('@wipcomputer/wip-ldm-os', timeout);
-    if (latest && semverNewer(latest, PKG_VERSION)) cliUpdate = latest;
-  } catch (error) {
-    skipped.push({ name: 'ldm cli', npm: '@wipcomputer/wip-ldm-os', reason: classifyStatusCheckError(error) });
-  }
-
   // Check extensions against npm using registry source info (#262)
+  const probeItems = [{
+    kind: 'cli',
+    name: 'ldm cli',
+    npm: '@wipcomputer/wip-ldm-os',
+    current: PKG_VERSION,
+  }];
+
   const updates = [];
   for (const [name, info] of Object.entries(registry?.extensions || {})) {
     // Use registry source.npm (v2) or fall back to extension's package.json
@@ -3362,19 +3420,37 @@ function cmdStatus() {
     if (!npmPkg) continue;
     const currentVersion = info?.installed?.version || info.version;
     if (!currentVersion) continue;
-    try {
-      const timeout = Math.min(STATUS_NPM_TIMEOUT_MS, remainingStatusBudgetMs(statusStartedAt));
-      if (timeout <= 0) {
-        skipped.push({ name, npm: npmPkg, reason: 'budget' });
-        continue;
-      }
-      console.log(`    ${name}: checking npm`);
-      const latest = npmViewVersionForStatus(npmPkg, timeout);
-      if (latest && semverNewer(latest, currentVersion)) {
-        updates.push({ name, current: currentVersion, latest, npm: npmPkg });
-      }
-    } catch (error) {
-      skipped.push({ name, npm: npmPkg, reason: classifyStatusCheckError(error) });
+    probeItems.push({
+      kind: 'extension',
+      name,
+      npm: npmPkg,
+      current: currentVersion,
+    });
+  }
+
+  let cliUpdate = null;
+  const probeResults = await runStatusProbesWithConcurrency(probeItems, STATUS_NPM_CONCURRENCY, statusStartedAt);
+  for (const result of probeResults) {
+    if (!result) continue;
+    if (result.status === 'skipped') {
+      skipped.push({
+        name: result.name,
+        npm: result.npm,
+        reason: result.reason,
+        elapsedMs: result.elapsedMs,
+      });
+      continue;
+    }
+
+    if (result.kind === 'cli') {
+      if (result.latest && semverNewer(result.latest, PKG_VERSION)) cliUpdate = result.latest;
+    } else if (result.latest && semverNewer(result.latest, result.current)) {
+      updates.push({
+        name: result.name,
+        current: result.current,
+        latest: result.latest,
+        npm: result.npm,
+      });
     }
   }
 
@@ -3407,7 +3483,7 @@ function cmdStatus() {
     console.log('');
     console.log('  Update checks skipped:');
     for (const item of skipped) {
-      console.log(`    ${item.name}: [${item.reason}] ${item.npm}`);
+      console.log(`    ${item.name}: [${item.reason} ${formatStatusElapsed(item.elapsedMs)}] ${item.npm}`);
     }
   }
 
@@ -4866,7 +4942,7 @@ async function main() {
       await cmdDoctor();
       break;
     case 'status':
-      cmdStatus();
+      await cmdStatus();
       break;
     case 'sessions':
       await cmdSessions();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.85-alpha.25",
+  "version": "0.4.85-alpha.27",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {
@@ -18,11 +18,12 @@
   "scripts": {
     "build:bridge": "cd src/bridge && npm install && npx tsup core.ts mcp-server.ts cli.ts openclaw.ts --format esm --dts --clean --outDir ../../dist/bridge",
     "build": "npm run build:bridge",
-    "prepublishOnly": "npm run build:bridge && npm run validate:bin-manifest && npm run test:install-prompt-policy && npm run test:ldm-status-timeout",
+    "prepublishOnly": "npm run build:bridge && npm run validate:bin-manifest && npm run test:install-prompt-policy && npm run test:ldm-status-timeout && npm run test:ldm-status-concurrency",
     "validate:bin-manifest": "node scripts/validate-bin-manifest.mjs",
     "test:skill-frontmatter": "node scripts/test-skill-frontmatter.mjs",
     "test:install-prompt-policy": "node scripts/test-install-prompt-policy.mjs",
     "test:ldm-status-timeout": "node scripts/test-ldm-status-timeout.mjs",
+    "test:ldm-status-concurrency": "node scripts/test-ldm-status-concurrency.mjs",
     "test:installer-update-tracks": "node scripts/test-installer-update-tracks.mjs",
     "test:installer-hook-toolname": "node scripts/test-installer-hook-toolname.mjs",
     "test:installer-target-self-update": "node scripts/test-installer-target-self-update.mjs",

package/scripts/test-ldm-status-concurrency.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const tempRoot = mkdtempSync(join(tmpdir(), 'ldm-status-concurrency-'));
+const sourceVersion = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version;
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function listen(server) {
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve(server.address()));
+  });
+}
+
+function createRegistryServer(delayMs) {
+  let active = 0;
+  let maxActive = 0;
+  const server = createServer((_req, res) => {
+    active += 1;
+    maxActive = Math.max(maxActive, active);
+    setTimeout(() => {
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ 'dist-tags': { latest: '1.0.0' } }));
+      active -= 1;
+    }, delayMs);
+  });
+  return { server, getMaxActive: () => maxActive };
+}
+
+function writeFixture(home) {
+  const extensions = join(home, '.ldm', 'extensions');
+  mkdirSync(extensions, { recursive: true });
+  writeFileSync(join(home, '.ldm', 'version.json'), JSON.stringify({
+    version: '0.0.0-test',
+    installed: '2026-05-12T00:00:00.000Z',
+    updated: '2026-05-12T00:00:00.000Z',
+  }, null, 2) + '\n');
+
+  const registry = { extensions: {} };
+  for (let i = 1; i <= 8; i += 1) {
+    registry.extensions[`ext-${i}`] = {
+      source: { npm: `ext-${i}` },
+      installed: { version: '1.0.0' },
+    };
+  }
+  writeFileSync(join(extensions, 'registry.json'), JSON.stringify(registry, null, 2) + '\n');
+}
+
+function runStatus({ concurrency, registryUrl, home }) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [join(root, 'bin', 'ldm.js'), 'status'], {
+      cwd: root,
+      env: {
+        ...process.env,
+        HOME: home,
+        LDM_STATUS_NPM_REGISTRY_URL: registryUrl,
+        LDM_STATUS_NPM_CONCURRENCY: String(concurrency),
+        LDM_STATUS_NPM_TIMEOUT_MS: '2000',
+        LDM_STATUS_TOTAL_BUDGET_MS: '10000',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('close', status => resolve({ status, stdout, stderr }));
+  });
+}
+
+async function runFixture({ concurrency, delayMs }) {
+  const home = join(tempRoot, `home-${concurrency}-${delayMs}`);
+  writeFixture(home);
+  const registry = createRegistryServer(delayMs);
+  const address = await listen(registry.server);
+  const startedAt = Date.now();
+  const result = await runStatus({
+    concurrency,
+    home,
+    registryUrl: `http://${address.address}:${address.port}`,
+  });
+  const elapsedMs = Date.now() - startedAt;
+  registry.server.closeAllConnections();
+  registry.server.close();
+  return { result, elapsedMs, maxActive: registry.getMaxActive() };
+}
+
+try {
+  const concurrent = await runFixture({ concurrency: 4, delayMs: 500 });
+  assert(concurrent.result.status === 0, `concurrent ldm status exited ${concurrent.result.status}\nstdout:\n${concurrent.result.stdout}\nstderr:\n${concurrent.result.stderr}`);
+  assert(concurrent.elapsedMs < 3000, `concurrent ldm status should finish well before serial runtime; elapsed ${concurrent.elapsedMs}ms`);
+  assert(concurrent.maxActive >= 4, `registry server should see concurrent probes; max active ${concurrent.maxActive}`);
+  assert(concurrent.result.stdout.includes(`LDM OS v${sourceVersion}`), `status should print installed LDM OS version\n${concurrent.result.stdout}`);
+  assert(concurrent.result.stdout.includes('Extensions: 8'), `status should print extension count\n${concurrent.result.stdout}`);
+  assert(concurrent.result.stdout.includes('ext-8: checking npm'), `status should check every staged extension\n${concurrent.result.stdout}`);
+  assert(!concurrent.result.stdout.includes('Update checks skipped:'), `concurrent status should not skip checks in this fixture\n${concurrent.result.stdout}`);
+
+  const serialFallback = await runFixture({ concurrency: 1, delayMs: 10 });
+  assert(serialFallback.result.status === 0, `serial fallback ldm status exited ${serialFallback.result.status}\nstdout:\n${serialFallback.result.stdout}\nstderr:\n${serialFallback.result.stderr}`);
+  assert(serialFallback.maxActive === 1, `serial fallback should only run one probe at a time; max active ${serialFallback.maxActive}`);
+  assert(serialFallback.result.stdout.includes('ext-8: checking npm'), `serial fallback should still check every staged extension\n${serialFallback.result.stdout}`);
+  assert(!serialFallback.result.stdout.includes('Update checks skipped:'), `serial fallback should not skip checks in this fixture\n${serialFallback.result.stdout}`);
+} finally {
+  rmSync(tempRoot, { recursive: true, force: true });
+}
+
+console.log('ldm status concurrency regression passed');

package/scripts/test-ldm-status-timeout.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -13,9 +14,38 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
+function runStatus({ home, registryUrl }) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [join(root, 'bin', 'ldm.js'), 'status'], {
+      cwd: root,
+      env: {
+        ...process.env,
+        HOME: home,
+        LDM_STATUS_NPM_REGISTRY_URL: registryUrl,
+        LDM_STATUS_NPM_TIMEOUT_MS: '75',
+        LDM_STATUS_TOTAL_BUDGET_MS: '250',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('close', status => resolve({ status, stdout, stderr }));
+  });
+}
+
+function listen(server) {
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve(server.address()));
+  });
+}
+
 try {
   const home = join(tempRoot, 'home');
-  const fakeBin = join(tempRoot, 'bin');
   const extensions = join(home, '.ldm', 'extensions');
 
   mkdirSync(extensions, { recursive: true });
@@ -37,33 +67,19 @@ try {
     },
   }, null, 2) + '\n');
 
-  mkdirSync(fakeBin, { recursive: true });
-  const fakeNpm = join(fakeBin, 'npm');
-  writeFileSync(fakeNpm, `#!/usr/bin/env bash
-if [ "$1" = "view" ]; then
-  sleep 2
-  echo "9.9.9"
-  exit 0
-fi
-echo "unexpected npm command: $*" >&2
-exit 64
-`);
-  chmodSync(fakeNpm, 0o755);
+  const server = createServer((_req, res) => {
+    setTimeout(() => {
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ 'dist-tags': { latest: '9.9.9' } }));
+    }, 2000);
+  });
+  const address = await listen(server);
 
   const startedAt = Date.now();
-  const result = spawnSync(process.execPath, [join(root, 'bin', 'ldm.js'), 'status'], {
-    cwd: root,
-    encoding: 'utf8',
-    timeout: 3000,
-    env: {
-      ...process.env,
-      HOME: home,
-      PATH: `${fakeBin}:${process.env.PATH || ''}`,
-      LDM_STATUS_NPM_TIMEOUT_MS: '75',
-      LDM_STATUS_TOTAL_BUDGET_MS: '250',
-    },
-  });
+  const result = await runStatus({ home, registryUrl: `http://${address.address}:${address.port}` });
   const elapsedMs = Date.now() - startedAt;
+  server.closeAllConnections();
+  server.close();
 
   assert(result.status === 0, `ldm status exited ${result.status}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
   assert(elapsedMs < 2500, `ldm status should return before the process timeout; elapsed ${elapsedMs}ms`);
@@ -72,7 +88,7 @@ exit 64
   assert(result.stdout.includes('Checking updates:'), `status should show progress before update checks\n${result.stdout}`);
   assert(result.stdout.includes('hung-extension: checking npm'), `status should print the extension name before probing it\n${result.stdout}`);
   assert(result.stdout.includes('Update checks skipped:'), `status should report skipped checks instead of hanging\n${result.stdout}`);
-  assert(result.stdout.includes('hung-extension: [timeout] hung-extension'), `hung extension should be reported as a timeout\n${result.stdout}`);
+  assert(/hung-extension: \[timeout \d+(ms|\.\d+s)\] hung-extension/.test(result.stdout), `hung extension should be reported as a timeout with elapsed time\n${result.stdout}`);
 } finally {
   rmSync(tempRoot, { recursive: true, force: true });
 }