@wipcomputer/wip-ldm-os 0.4.85-alpha.8 → 0.4.86

package/scripts/test-kaleidoscope-qr-authenticator-confirmation.mjs

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+
+const loginFiles = [
+  "src/hosted-mcp/app/kaleidoscope-login.html",
+  "src/hosted-mcp/demo/login.html",
+];
+
+function assertContains(source, needle, label) {
+  if (!source.includes(needle)) {
+    throw new Error(`${label} missing expected text: ${needle}`);
+  }
+}
+
+function assertBefore(source, first, second, label) {
+  const firstIndex = source.indexOf(first);
+  const secondIndex = source.indexOf(second);
+  if (firstIndex === -1 || secondIndex === -1 || firstIndex >= secondIndex) {
+    throw new Error(`${label} expected "${first}" before "${second}"`);
+  }
+}
+
+function extractFunction(source, name) {
+  const start = source.indexOf(`function ${name}(`);
+  if (start === -1) throw new Error(`could not find function ${name}`);
+  const bodyStart = source.indexOf("{", start);
+  let depth = 0;
+  for (let i = bodyStart; i < source.length; i += 1) {
+    if (source[i] === "{") depth += 1;
+    if (source[i] === "}") depth -= 1;
+    if (depth === 0) return source.slice(start, i + 1);
+  }
+  throw new Error(`could not extract function ${name}`);
+}
+
+function assertNotContains(source, needle, label) {
+  if (source.includes(needle)) {
+    throw new Error(`${label} must not contain: ${needle}`);
+  }
+}
+
+for (const file of loginFiles) {
+  const html = readFileSync(file, "utf8");
+  const followFunction = extractFunction(html, "followPairNextIfPresent");
+  const backFunction = extractFunction(html, "backToLoginAfterQrScan");
+
+  assertContains(html, 'id="qr-auth-confirm-view"', `${file} confirmation view`);
+  assertContains(html, "Your authenticated Kaleidoscope session is available on your other device.", `${file} confirmation headline`);
+  assertContains(html, "Back to login", `${file} back button copy`);
+  assertNotContains(html, "Open session here", `${file} authenticator completion must not offer local demo open`);
+  assertNotContains(html, ">Close</button>", `${file} authenticator completion must not show close action`);
+  assertNotContains(html, "Kaleidoscope is ready there.", `${file} removed ready helper copy`);
+  assertNotContains(html, "Open Kaleidoscope here", `${file} removed duplicated open copy`);
+  assertNotContains(html, "Keep using Kaleidoscope on the other device.", `${file} removed cancel helper copy`);
+  assertNotContains(html, "Scan QR Code", `${file} login-page scanner action must be absent`);
+  assertNotContains(html, "BarcodeDetector", `${file} login-page scanner detector must be absent`);
+  assertNotContains(html, "getUserMedia", `${file} login-page scanner camera code must be absent`);
+  assertContains(html, "You can close this page.", `${file} close fallback copy`);
+
+  assertContains(html, "function showQrAuthenticatorConfirmation(identity, isNewAccount)", `${file} confirmation function`);
+  assertContains(html, "function backToLoginAfterQrScan()", `${file} back-to-login function`);
+
+  assertContains(
+    html,
+    "if (DEMO_NEXT_REGEX.test(approveResponse.next)) {\n      return showQrAuthenticatorConfirmation(identity, isNewAccount === true);\n    }",
+    `${file} QR authenticator demo next shows confirmation`,
+  );
+  assertBefore(
+    html,
+    "return showQrAuthenticatorConfirmation(identity, isNewAccount === true);",
+    "next = approveResponse.next;",
+    `${file} confirmation intercepts approve next before redirect`,
+  );
+  assertNotContains(followFunction, "location.replace('/demo');", `${file} QR approve path must not directly enter demo`);
+  assertNotContains(followFunction, 'location.href = "/demo";', `${file} QR approve path must not assign demo href`);
+  assertNotContains(followFunction, "storeDemoHandoffIfNeeded('/demo'", `${file} QR approve path must not store demo handoff`);
+
+  assertContains(backFunction, "location.replace('/login?next=/demo');", `${file} back returns to login`);
+  assertNotContains(backFunction, "storeDemoHandoffIfNeeded", `${file} back must not store demo handoff`);
+  assertNotContains(backFunction, "location.replace('/demo')", `${file} back must not open demo`);
+
+  assertContains(html, "if (await followPairNextIfPresent(approveResponse, result, true)) return;", `${file} create caller stops after confirmation`);
+  assertContains(html, "if (await followPairNextIfPresent(approveResponse, result, false)) return;", `${file} sign-in caller stops after confirmation`);
+  assertContains(html, "storeDemoHandoffIfNeeded(data.next, data, qrLoginMode === 'register');", `${file} requester QR status still stores handoff`);
+  assertContains(html, "location.replace(data.next);", `${file} requester QR status still redirects`);
+  assertContains(html, "storeDemoHandoffIfNeeded('/demo', result, true);", `${file} same-device create still stores demo handoff`);
+  assertContains(html, "storeDemoHandoffIfNeeded('/demo', result, false);", `${file} same-device sign-in still stores demo handoff`);
+}
+
+console.log("kaleidoscope QR authenticator confirmation checks passed");

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

@@ -0,0 +1,96 @@
+#!/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-timeout-'));
+const sourceVersion = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version;
+
+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 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');
+  writeFileSync(join(extensions, 'registry.json'), JSON.stringify({
+    extensions: {
+      'hung-extension': {
+        source: { npm: 'hung-extension' },
+        installed: { version: '1.0.0' },
+      },
+      'second-extension': {
+        source: { npm: 'second-extension' },
+        installed: { version: '1.0.0' },
+      },
+    },
+  }, null, 2) + '\n');
+
+  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 = 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`);
+  assert(result.stdout.includes(`LDM OS v${sourceVersion}`), `status should print installed LDM OS version\n${result.stdout}`);
+  assert(result.stdout.includes('Extensions: 2'), `status should print extension count\n${result.stdout}`);
+  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(/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 });
+}
+
+console.log('ldm status timeout regression passed');