@wipcomputer/wip-ldm-os 0.4.85-alpha.26 → 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 { execFile, execSync, spawnSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -3285,21 +3285,27 @@ 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 new Promise((resolvePromise, rejectPromise) => {
-    execFile('npm', ['view', pkg, 'version'], {
-      encoding: 'utf8',
-      timeout: timeoutMs,
-      maxBuffer: 1024 * 1024,
-    }, (error, stdout) => {
-      if (error) {
-        rejectPromise(error);
-        return;
-      }
-      resolvePromise(String(stdout || '').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) {
@@ -3313,7 +3319,7 @@ function formatStatusElapsed(ms) {
 }
 
 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';

package/package.json

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

package/scripts/test-ldm-status-concurrency.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,7 +14,28 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
-function writeFixture(home, fakeBin) {
+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({
@@ -30,55 +52,63 @@ function writeFixture(home, fakeBin) {
     };
   }
   writeFileSync(join(extensions, 'registry.json'), JSON.stringify(registry, null, 2) + '\n');
-
-  mkdirSync(fakeBin, { recursive: true });
-  const fakeNpm = join(fakeBin, 'npm');
-  writeFileSync(fakeNpm, `#!/usr/bin/env bash
-if [ "$1" = "view" ]; then
-  sleep "\${FAKE_NPM_SLEEP:-1}"
-  echo "1.0.0"
-  exit 0
-fi
-echo "unexpected npm command: $*" >&2
-exit 64
-`);
-  chmodSync(fakeNpm, 0o755);
 }
 
-function runStatus({ concurrency, sleepSeconds, timeoutMs }) {
-  const home = join(tempRoot, `home-${concurrency}-${sleepSeconds}`);
-  const fakeBin = join(tempRoot, `bin-${concurrency}-${sleepSeconds}`);
-  writeFixture(home, fakeBin);
+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 = spawnSync(process.execPath, [join(root, 'bin', 'ldm.js'), 'status'], {
-    cwd: root,
-    encoding: 'utf8',
-    timeout: timeoutMs,
-    env: {
-      ...process.env,
-      HOME: home,
-      PATH: `${fakeBin}:${process.env.PATH || ''}`,
-      FAKE_NPM_SLEEP: String(sleepSeconds),
-      LDM_STATUS_NPM_CONCURRENCY: String(concurrency),
-      LDM_STATUS_NPM_TIMEOUT_MS: '2000',
-      LDM_STATUS_TOTAL_BUDGET_MS: '10000',
-    },
+  const result = await runStatus({
+    concurrency,
+    home,
+    registryUrl: `http://${address.address}:${address.port}`,
   });
-  return { result, elapsedMs: Date.now() - startedAt };
+  const elapsedMs = Date.now() - startedAt;
+  registry.server.closeAllConnections();
+  registry.server.close();
+  return { result, elapsedMs, maxActive: registry.getMaxActive() };
 }
 
 try {
-  const concurrent = runStatus({ concurrency: 4, sleepSeconds: 1, timeoutMs: 7000 });
+  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 < 6500, `concurrent ldm status should finish well before serial runtime; elapsed ${concurrent.elapsedMs}ms`);
+  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 = runStatus({ concurrency: 1, sleepSeconds: 0.05, timeoutMs: 5000 });
+  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 {

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`);