@wipcomputer/wip-ldm-os 0.4.85-alpha.2 → 0.4.85-alpha.20

package/scripts/test-install-prompt-policy.mjs

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = fileURLToPath(new URL("..", import.meta.url));
+
+const files = [
+  "README.md",
+  "SKILL.md",
+  "shared/templates/install-prompt.md",
+];
+
+const contents = Object.fromEntries(
+  files.map((file) => [file, readFileSync(join(repoRoot, file), "utf8")]),
+);
+
+const failures = [];
+
+for (const file of ["README.md", "shared/templates/install-prompt.md"]) {
+  const text = contents[file];
+  for (const phrase of [
+    "Use the install document and live local checks as the source of truth. Do not search memory or prior notes for this install.",
+    "If installed: run `ldm status`",
+    "If yes to dry run, run `ldm install --dry-run`.",
+    "`npm install -g @wipcomputer/wip-ldm-os@latest && ldm install && ldm doctor`",
+    "Then run:\n`ldm init --dry-run`",
+    "If I say install, run:\n`ldm init`",
+  ]) {
+    if (!text.includes(phrase)) {
+      failures.push(`${file} missing install prompt phrase: ${phrase}`);
+    }
+  }
+  if (text.includes("If it is, run ldm install --dry-run")) {
+    failures.push(`${file} still tells installed users to start with ldm install --dry-run`);
+  }
+}
+
+const skill = contents["SKILL.md"];
+for (const phrase of [
+  "Do not run GitHub release commands during the install-state flow.",
+  "Do not run `gh release list` or `gh release view` unless the user explicitly asks for release notes.",
+  "Use the output of `ldm status`, installed package metadata, and npm metadata.",
+  "Do not use GitHub release commands here.",
+]) {
+  if (!skill.includes(phrase)) {
+    failures.push(`SKILL.md missing install policy phrase: ${phrase}`);
+  }
+}
+
+if (/gh release (list|view) --repo/.test(skill)) {
+  failures.push("SKILL.md still includes concrete gh release commands in the install flow");
+}
+
+if (failures.length > 0) {
+  console.error("install prompt policy checks failed:");
+  for (const failure of failures) console.error(`  - ${failure}`);
+  process.exit(1);
+}
+
+console.log("install-prompt-policy: LDM OS prompt and install doc agree");

package/scripts/test-installer-skill-directory.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const home = mkdtempSync(join(tmpdir(), 'ldm-skill-dir-home-'));
+const source = mkdtempSync(join(tmpdir(), 'ldm-skill-dir-source-'));
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+try {
+  process.env.HOME = home;
+
+  for (const dir of ['.claude', '.openclaw', '.codex', '.agents']) {
+    mkdirSync(join(home, dir), { recursive: true });
+  }
+
+  const skillDir = join(source, 'skills', 'wip-ai-chat-ui');
+  mkdirSync(join(skillDir, 'references'), { recursive: true });
+  mkdirSync(join(skillDir, 'agents'), { recursive: true });
+  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: wip-ai-chat-ui\ndescription: "test skill"\n---\n\n# Test Skill\n');
+  writeFileSync(join(skillDir, 'references', 'stack.md'), '# Stack\n');
+  writeFileSync(join(skillDir, 'agents', 'openai.yaml'), 'display_name: "WIP AI Chat UI"\n');
+
+  const { detectInterfacesJSON } = await import('../lib/detect.mjs');
+  const detected = detectInterfacesJSON(source);
+  assert(detected.interfaceCount === 1, 'skill directory repo should expose one interface');
+  assert(detected.interfaces.skill?.skills?.[0]?.name === 'wip-ai-chat-ui', 'skill directory name should be detected');
+
+  const { installFromPath } = await import('../lib/deploy.mjs');
+  const result = await installFromPath(source);
+  assert(result.interfaces === 1, 'skill directory install should process one interface');
+
+  for (const target of [
+    join(home, '.claude', 'skills', 'wip-ai-chat-ui'),
+    join(home, '.openclaw', 'skills', 'wip-ai-chat-ui'),
+    join(home, '.codex', 'skills', 'wip-ai-chat-ui'),
+    join(home, '.agents', 'skills', 'wip-ai-chat-ui'),
+  ]) {
+    assert(existsSync(join(target, 'SKILL.md')), `${target} should include SKILL.md`);
+    assert(existsSync(join(target, 'references', 'stack.md')), `${target} should include references`);
+    assert(existsSync(join(target, 'agents', 'openai.yaml')), `${target} should include agents metadata`);
+    assert(!lstatSync(target).isSymbolicLink(), `${target} should be a deployed directory, not a symlink`);
+  }
+
+  const codexSkill = readFileSync(join(home, '.codex', 'skills', 'wip-ai-chat-ui', 'SKILL.md'), 'utf8');
+  assert(codexSkill.includes('name: wip-ai-chat-ui'), 'Codex target should contain the expected skill');
+
+  console.log('installer skill directory regression passed');
+} finally {
+  rmSync(home, { recursive: true, force: true });
+  rmSync(source, { recursive: true, force: true });
+}

package/scripts/test-installer-skill-dry-run-destinations.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const home = mkdtempSync(join(tmpdir(), 'ldm-skill-dry-run-home-'));
+const source = mkdtempSync(join(tmpdir(), 'ldm-skill-dry-run-source-'));
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+try {
+  process.env.HOME = home;
+
+  for (const dir of ['.claude', '.openclaw', '.codex', '.agents']) {
+    mkdirSync(join(home, dir), { recursive: true });
+  }
+
+  const workspace = join(home, 'workspace');
+  mkdirSync(workspace, { recursive: true });
+  mkdirSync(join(home, '.ldm'), { recursive: true });
+  writeFileSync(join(home, '.ldm', 'config.json'), JSON.stringify({
+    workspace,
+    harnesses: {
+      'claude-code': {
+        detected: true,
+        home: join(home, '.claude'),
+        skills: join(home, '.claude', 'skills'),
+      },
+      openclaw: {
+        detected: true,
+        home: join(home, '.openclaw'),
+        skills: join(home, '.openclaw', 'skills'),
+      },
+      codex: {
+        detected: true,
+        home: join(home, '.codex'),
+        skills: join(home, '.codex', 'skills'),
+      },
+      'wip-agents': {
+        detected: true,
+        home: join(home, '.agents'),
+        skills: join(home, '.agents', 'skills'),
+      },
+    },
+  }, null, 2));
+
+  mkdirSync(join(source, 'references'), { recursive: true });
+  mkdirSync(join(source, 'agents'), { recursive: true });
+  writeFileSync(join(source, 'package.json'), JSON.stringify({
+    name: '@wipcomputer/wip-ai-chat-ui',
+    version: '0.1.1',
+  }, null, 2));
+  writeFileSync(join(source, 'SKILL.md'), '---\nname: wip-ai-chat-ui\ndescription: "test skill"\n---\n\n# Test Skill\n');
+  writeFileSync(join(source, 'references', 'stack.md'), '# Stack\n');
+  writeFileSync(join(source, 'agents', 'openai.yaml'), 'display_name: "WIP AI Chat UI"\n');
+
+  const { setFlags, installFromPath } = await import('../lib/deploy.mjs');
+
+  const lines = [];
+  const originalLog = console.log;
+  console.log = (...args) => lines.push(args.join(' '));
+
+  try {
+    setFlags({ dryRun: true, jsonOutput: false });
+    const result = await installFromPath(source);
+    assert(result.interfaces === 1, 'dry run should process one skill interface');
+  } finally {
+    console.log = originalLog;
+  }
+
+  const output = lines.join('\n');
+
+  for (const expected of [
+    'Would copy:',
+    '- SKILL.md',
+    '- references/',
+    '- agents/',
+    'Permanent copy:',
+    join(home, '.ldm', 'extensions', 'wip-ai-chat-ui', 'SKILL.md'),
+    join(home, '.ldm', 'extensions', 'wip-ai-chat-ui', 'references/'),
+    'Agent skill targets:',
+    `claude-code: ${join(home, '.claude', 'skills', 'wip-ai-chat-ui')}`,
+    join(home, '.claude', 'skills', 'wip-ai-chat-ui', 'SKILL.md'),
+    `openclaw: ${join(home, '.openclaw', 'skills', 'wip-ai-chat-ui')}`,
+    join(home, '.openclaw', 'skills', 'wip-ai-chat-ui', 'references/'),
+    `codex: ${join(home, '.codex', 'skills', 'wip-ai-chat-ui')}`,
+    `wip-agents: ${join(home, '.agents', 'skills', 'wip-ai-chat-ui')}`,
+    'Workspace docs target:',
+    `${join(workspace, 'settings', 'docs', 'skills', 'wip-ai-chat-ui')} (references/ only)`,
+  ]) {
+    assert(output.includes(expected), `dry-run output should include ${expected}\n\n${output}`);
+  }
+
+  console.log('installer skill dry-run destinations regression passed');
+} finally {
+  rmSync(home, { recursive: true, force: true });
+  rmSync(source, { recursive: true, force: true });
+}

package/scripts/test-installer-target-self-update.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const cli = readFileSync(join(root, 'bin', 'ldm.js'), 'utf8');
+
+const helperName = 'function maybeSelfUpdateLdmCliBeforeInstall()';
+const helperIdx = cli.indexOf(helperName);
+if (helperIdx === -1) {
+  throw new Error('Missing shared LDM OS self-update preflight helper');
+}
+
+const helperBlock = cli.slice(helperIdx, cli.indexOf('// ── Dead backup trigger cleanup', helperIdx));
+if (!helperBlock.includes('Dry run only: continuing with v${PKG_VERSION}.')) {
+  throw new Error('Self-update helper must warn on dry run without updating');
+}
+
+if (!helperBlock.includes("execSync(`npm install -g @wipcomputer/wip-ldm-os@${latest}`")) {
+  throw new Error('Self-update helper must update LDM OS before real installs');
+}
+
+if (!helperBlock.includes("spawnSync('ldm'")) {
+  throw new Error('Self-update helper must re-run the original install command without shell joining args');
+}
+
+if (helperBlock.includes('process.argv.slice(2).join')) {
+  throw new Error('Self-update helper must preserve argv boundaries when re-running install');
+}
+
+const cmdInstallIdx = cli.indexOf('async function cmdInstall()');
+const lockIdx = cli.indexOf('acquireInstallLock()', cmdInstallIdx);
+const initIdx = cli.indexOf('LDM OS not initialized. Running init first', cmdInstallIdx);
+const targetIdx = cli.indexOf('// Find the target (skip flags)', cmdInstallIdx);
+const preflightCallIdx = cli.indexOf('maybeSelfUpdateLdmCliBeforeInstall();', cmdInstallIdx);
+if (cmdInstallIdx === -1 || targetIdx === -1 || preflightCallIdx === -1) {
+  throw new Error('Could not find cmdInstall self-update placement');
+}
+
+if (preflightCallIdx > lockIdx || preflightCallIdx > initIdx) {
+  throw new Error('Self-update preflight must run before lock acquisition and init work');
+}
+
+if (preflightCallIdx > targetIdx) {
+  throw new Error('Self-update preflight must run before target resolution so app installs are covered');
+}
+
+const catalogIdx = cli.indexOf('async function cmdInstallCatalog()');
+const oldCatalogBlock = cli.indexOf('Self-update: check if CLI itself is outdated', catalogIdx);
+const autoDetectIdx = cli.indexOf('autoDetectExtensions();', catalogIdx);
+if (oldCatalogBlock !== -1 && oldCatalogBlock < autoDetectIdx) {
+  throw new Error('Catalog install should not own the only self-update block');
+}
+
+const tempRoot = mkdtempSync(join(tmpdir(), 'ldm-target-self-update-'));
+try {
+  const home = join(tempRoot, 'home');
+  const fakeBin = join(tempRoot, 'bin');
+  const target = join(tempRoot, 'target skill with spaces');
+
+  mkdirSync(join(home, '.ldm'), { recursive: true });
+  writeFileSync(join(home, '.ldm', 'version.json'), JSON.stringify({
+    version: '0.0.0',
+    installed: new Date().toISOString(),
+    updated: new Date().toISOString(),
+  }, null, 2) + '\n');
+
+  mkdirSync(fakeBin, { recursive: true });
+  const fakeNpm = join(fakeBin, 'npm');
+  writeFileSync(fakeNpm, `#!/usr/bin/env bash
+if [ "$1" = "view" ] && [ "$2" = "@wipcomputer/wip-ldm-os" ] && [ "$3" = "dist-tags.alpha" ]; then
+  echo "99.0.0-alpha.1"
+  exit 0
+fi
+echo "unexpected npm command: $*" >&2
+exit 64
+`);
+  chmodSync(fakeNpm, 0o755);
+
+  mkdirSync(target, { recursive: true });
+  writeFileSync(join(target, 'SKILL.md'), `---
+name: test-target-skill
+description: Test target skill for installer self-update dry-run checks.
+---
+
+# Test Target Skill
+`);
+
+  const result = spawnSync(process.execPath, [
+    join(root, 'bin', 'ldm.js'),
+    'install',
+    '--alpha',
+    '--dry-run',
+    target,
+  ], {
+    cwd: root,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HOME: home,
+      PATH: `${fakeBin}:${process.env.PATH || ''}`,
+    },
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`Runtime dry-run exited ${result.status}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+
+  if (!result.stdout.includes('LDM OS CLI v')) {
+    throw new Error(`Runtime dry-run did not print the LDM OS skew warning\nstdout:\n${result.stdout}`);
+  }
+
+  if (!result.stdout.includes('-> v99.0.0-alpha.1 (alpha track) is available.')) {
+    throw new Error(`Runtime dry-run did not include the selected alpha track version\nstdout:\n${result.stdout}`);
+  }
+
+  if (!result.stdout.includes('Dry run only: continuing with v')) {
+    throw new Error(`Runtime dry-run did not say it would continue without updating\nstdout:\n${result.stdout}`);
+  }
+
+  if (!result.stdout.includes('Installing: target skill with spaces (dry run)')) {
+    throw new Error(`Runtime dry-run did not continue to the targeted install preview\nstdout:\n${result.stdout}`);
+  }
+} finally {
+  rmSync(tempRoot, { recursive: true, force: true });
+}
+
+console.log('targeted install self-update regression checks passed');

package/shared/templates/install-prompt.md

@@ -6,7 +6,18 @@ Open your AI and paste this:
 
 Read https://wip.computer/install/wip-ldm-os.txt
 
-Check if LDM OS is already installed. If it is, run ldm install --dry-run and show me what I have and what's new.
+Use the install document and live local checks as the source of truth. Do not search memory or prior notes for this install.
+
+Check if LDM OS is installed (`which ldm && ldm --version`). Branch.
+
+If installed: run `ldm status` and show me the version table and what's new for each component. Then ask:
+- Do you have questions?
+- Want to see a dry run?
+
+If yes to dry run, run `ldm install --dry-run`.
+
+If I say install, run:
+`npm install -g @wipcomputer/wip-ldm-os@latest && ldm install && ldm doctor`
 
 If not, walk me through setup and explain:
 
@@ -19,7 +30,14 @@ Then ask:
 - Do you have questions?
 - Want to see a dry run?
 
-If I say yes: Install the CLI first (npm install -g @wipcomputer/wip-ldm-os) and then run ldm install --dry-run.
+If yes to dry run, install the CLI first:
+`npm install -g @wipcomputer/wip-ldm-os`
+
+Then run:
+`ldm init --dry-run`
+
+If I say install, run:
+`ldm init`
 
 Show me exactly what will change. Don't install anything until I say "install".
 

package/src/hosted-mcp/README.md

@@ -0,0 +1,15 @@
+# Hosted MCP And Relay
+
+This directory contains the public source for the hosted WIP relay that serves `wip.computer`.
+
+It includes:
+
+- OAuth, passkey, and hosted MCP routes in `server.mjs`;
+- Codex Remote Control relay routes under `/api/codex-relay/*`;
+- nginx snippets for the relay, MCP, and site proxy;
+- Prisma schema and migrations for Postgres-backed account, API key, passkey, device, and wallet state;
+- PM2 and deploy helpers for the WIP-operated VPS.
+
+WIP runs the production hosted relay so user setup is easy and works across networks. The source is public so users can inspect the relay path and build their own infrastructure.
+
+For the self-hosting shape, read [docs/self-host.md](docs/self-host.md).

package/src/hosted-mcp/app/footer.js

@@ -0,0 +1,74 @@
+// Shared footer for all Kaleidoscope pages (production-owned).
+// Include with: <div id="kscope-footer"></div><script src="/app/footer.js"></script>
+(function() {
+  var container = document.getElementById('kscope-footer');
+  if (!container) return;
+
+  var mobile = navigator.maxTouchPoints > 0 && window.innerWidth < 768;
+
+  // Desktop: fixed at bottom. Mobile: in page flow (below fold).
+  if (mobile) {
+    container.style.cssText = 'background:#FFFDF5;padding:16px 0;';
+  } else {
+    container.style.cssText = 'position:fixed;bottom:0;left:0;right:0;background:#FFFDF5;padding:16px 0;';
+  }
+
+  var inner = document.createElement('div');
+  inner.style.cssText = 'max-width:980px;margin:0 auto;padding:0 24px;border-top:1px solid rgba(0,0,0,0.06);padding-top:16px;text-align:left;font-size:13px;color:#a8a4a0;line-height:1.6;';
+
+  // On mobile, copyright and links on separate lines (like Apple)
+  if (mobile) {
+    inner.innerHTML = '<p style="margin:0;">WIP Computer, Inc.</p>'
+      + '<p style="margin:2px 0 0;">Learning Dreaming Machines</p>'
+      + '<p style="margin:8px 0 0;">Copyright &copy; 2026 WIP Computer, Inc. All rights reserved.</p>'
+      + '<p style="margin:4px 0 0;">'
+      + '<a href="/legal/privacy/en-ww/" style="color:#a8a4a0;text-decoration:none;">Privacy Policy</a> &nbsp;|&nbsp; '
+      + '<a href="/legal/internet-services/terms/site.html" style="color:#a8a4a0;text-decoration:none;">Terms of Use</a></p>'
+      + '<p style="margin:4px 0 0;">'
+      + '<a href="/agent.txt" style="color:#a8a4a0;text-decoration:none;">Are you an AI Agent?</a></p>'
+      + '<p style="margin:4px 0 0;">Made in California.</p>';
+  } else {
+    inner.innerHTML = '<p style="margin:0;">WIP Computer, Inc.</p>'
+      + '<p style="margin:2px 0 0;">Learning Dreaming Machines</p>'
+      + '<p style="margin:8px 0 0;">Copyright &copy; 2026 WIP Computer, Inc. All rights reserved. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'
+      + '<a href="/legal/privacy/en-ww/" style="color:#a8a4a0;text-decoration:none;">Privacy Policy</a> &nbsp;|&nbsp; '
+      + '<a href="/legal/internet-services/terms/site.html" style="color:#a8a4a0;text-decoration:none;">Terms of Use</a></p>'
+      + '<p style="margin:4px 0 0;">'
+      + '<a href="/agent.txt" style="color:#a8a4a0;text-decoration:none;">Are you an AI Agent?</a> &nbsp;|&nbsp; '
+      + '<a id="localPasskeysToggle" onclick="toggleLocalPasskeys()" style="color:#a8a4a0;text-decoration:none;cursor:pointer;display:inline-flex;align-items:center;gap:4px;vertical-align:middle;">'
+      + '<span id="passkeys-dot" style="display:inline-block;width:8px;height:8px;border-radius:50%;"></span> '
+      + '<span id="passkeys-label">Local passkeys off</span></a></p>'
+      + '<p style="margin:4px 0 0;">Made in California.</p>';
+  }
+
+  container.appendChild(inner);
+
+  // Local passkeys toggle
+  if (!window.isLocalPasskeysOn) {
+    window.isLocalPasskeysOn = function() { return localStorage.getItem('localPasskeys') === 'on'; };
+  }
+  if (!window.toggleLocalPasskeys) {
+    window.toggleLocalPasskeys = function() {
+      var on = isLocalPasskeysOn();
+      localStorage.setItem('localPasskeys', on ? 'off' : 'on');
+      updatePasskeysDot();
+    };
+  }
+  if (!window.updatePasskeysDot) {
+    window.updatePasskeysDot = function() {
+      var dot = document.getElementById('passkeys-dot');
+      var label = document.getElementById('passkeys-label');
+      if (!dot) return;
+      if (isLocalPasskeysOn()) {
+        dot.style.background = '#2E7D32';
+        dot.style.opacity = '1';
+        if (label) label.textContent = 'Local passkeys on';
+      } else {
+        dot.style.background = '#D32F2F';
+        dot.style.opacity = '0.4';
+        if (label) label.textContent = 'Local passkeys off';
+      }
+    };
+  }
+  updatePasskeysDot();
+})();