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

package/bin/ldm.js

@@ -1537,13 +1537,21 @@ async function cmdInstall() {
     // npm install --prefix silently fails for scoped packages in temp directories...
     // it creates the lock file but doesn't extract files. npm pack is reliable.
     const npmName = resolvedTarget;
+    // --alpha and --beta select the corresponding npm dist-tag instead of @latest.
+    // Without this, `ldm install --alpha <pkg>` was pulling the @latest version
+    // from npm pack and an existing global install would never advance to the
+    // current alpha. Now the tag flows through pack + the downstream
+    // installSingleTool's `npm install -g <pkg>@<version>` step uses the
+    // version baked into the alpha tarball.
+    const npmTag = ALPHA_FLAG ? 'alpha' : (BETA_FLAG ? 'beta' : '');
+    const packTarget = npmTag ? `${npmName}@${npmTag}` : npmName;
     const tempDir = join(LDM_TMP, `npm-${Date.now()}`);
     console.log('');
-    console.log(`  Installing ${npmName} from npm...`);
+    console.log(`  Installing ${packTarget} from npm...`);
     try {
       mkdirSync(tempDir, { recursive: true });
       // Use npm pack + tar instead of npm install --prefix
-      const tarball = execSync(`npm pack ${npmName} --pack-destination "${tempDir}" 2>/dev/null`, {
+      const tarball = execSync(`npm pack ${packTarget} --pack-destination "${tempDir}" 2>/dev/null`, {
         encoding: 'utf8', timeout: 60000, cwd: tempDir,
       }).trim();
       const tarPath = join(tempDir, tarball);
@@ -4289,6 +4297,164 @@ async function main() {
     console.log('');
   }
 
+  // ── ldm uninstall <pkg> ──
+  //
+  // Removes a single LDM-installed package. Used to reset a single
+  // extension between dogfood cycles without taking down the rest of
+  // LDM OS. Pairs with the per-package cleanup hook each package may
+  // ship (e.g. `codex-daemon uninstall --purge` for Codex Remote
+  // Control), which the user runs first to clean up product-specific
+  // state. This command then removes the LDM-side install record + the
+  // global npm package + the LDM extension dir.
+  //
+  // Safety:
+  //   - Never touches ~/.codex/ or other unrelated user state.
+  //   - Never removes ~/.ldm/memory/ or ~/.ldm/agents/.
+  //   - Never removes other extensions.
+  //   - Idempotent: running twice exits cleanly.
+  //   - Refuses to uninstall LDM OS itself (use `ldm uninstall` for that).
+
+  async function cmdUninstallPackage(pkgName) {
+    const isDryRun = args.includes('--dry-run');
+
+    if (pkgName === 'wip-ldm-os' || pkgName === '@wipcomputer/wip-ldm-os') {
+      console.error('  Refusing to uninstall LDM OS itself with `ldm uninstall <pkg>`.');
+      console.error('  To remove all of LDM OS: ldm uninstall');
+      process.exit(1);
+    }
+
+    console.log('');
+    console.log(`  ldm uninstall ${pkgName}`);
+    console.log('  ────────────────────────────────────');
+
+    // 1. Look up the package in the registry.
+    const registryPath = join(LDM_EXTENSIONS, 'registry.json');
+    let registry = { _format: 'v1', extensions: {} };
+    try {
+      if (existsSync(registryPath)) {
+        registry = JSON.parse(readFileSync(registryPath, 'utf8'));
+      }
+    } catch (e) {
+      console.error(`  ! could not read registry at ${registryPath}: ${e.message}`);
+    }
+    const entry = registry.extensions?.[pkgName] || null;
+
+    // 2. Resolve npm package name.
+    //    Registry entries from npm installs put the npm name in `source.npm`
+    //    or in the top-level `name` field. Fall back to the user-supplied
+    //    pkgName (works for unscoped packages).
+    const npmPkg = entry?.source?.npm || entry?.name || pkgName;
+
+    // 3. Resolve LDM extension dir(s).
+    const ldmExtPath = entry?.paths?.ldm
+      || entry?.ldmPath
+      || join(LDM_EXTENSIONS, pkgName);
+    const ocExtPath = entry?.paths?.openclaw
+      || entry?.ocPath
+      || null;
+
+    // 4. Build the action plan.
+    const actions = [];
+    let pkgInstalledGlobally = false;
+    try {
+      const npmList = execSync(`npm list -g --depth=0 --json 2>/dev/null`, { encoding: 'utf8' });
+      const deps = JSON.parse(npmList).dependencies || {};
+      pkgInstalledGlobally = !!deps[npmPkg];
+    } catch {}
+
+    if (pkgInstalledGlobally) {
+      actions.push({ kind: 'npm-uninstall', npmPkg });
+    } else {
+      actions.push({ kind: 'skip', label: `npm: ${npmPkg} not installed globally` });
+    }
+    if (existsSync(ldmExtPath)) {
+      actions.push({ kind: 'rm-dir', label: 'LDM extension dir', path: ldmExtPath });
+    } else {
+      actions.push({ kind: 'skip', label: `LDM extension dir: ${ldmExtPath} already gone` });
+    }
+    if (ocExtPath && existsSync(ocExtPath)) {
+      actions.push({ kind: 'rm-dir', label: 'OpenClaw extension dir', path: ocExtPath });
+    }
+    if (entry) {
+      actions.push({ kind: 'registry-remove', name: pkgName });
+    } else {
+      actions.push({ kind: 'skip', label: `registry: no entry for ${pkgName}` });
+    }
+
+    const realActions = actions.filter(a => a.kind !== 'skip');
+    const skips = actions.filter(a => a.kind === 'skip');
+
+    console.log('');
+    if (realActions.length === 0) {
+      for (const s of skips) console.log(`  - ${s.label}`);
+      console.log('');
+      console.log('  Nothing to do.');
+      console.log('');
+      console.log('  Will NOT touch ~/.codex/ or ~/.ldm/memory/ or other extensions.');
+      return;
+    }
+    console.log('  Will:');
+    for (const a of realActions) {
+      switch (a.kind) {
+        case 'npm-uninstall':
+          console.log(`    - npm uninstall -g ${a.npmPkg}`);
+          break;
+        case 'rm-dir':
+          console.log(`    - remove ${a.label}: ${a.path}`);
+          break;
+        case 'registry-remove':
+          console.log(`    - remove registry entry for ${a.name}`);
+          break;
+      }
+    }
+    for (const s of skips) console.log(`    - skipped: ${s.label}`);
+    console.log('');
+    console.log('  Will NOT touch ~/.codex/ or ~/.ldm/memory/ or other extensions.');
+
+    if (isDryRun) {
+      console.log('');
+      console.log('  Dry run. Nothing removed.');
+      console.log('');
+      console.log('  Re-run without --dry-run to apply.');
+      return;
+    }
+
+    console.log('');
+    for (const a of realActions) {
+      switch (a.kind) {
+        case 'npm-uninstall':
+          try {
+            execSync(`npm uninstall -g ${a.npmPkg}`, { stdio: 'pipe', timeout: 60000 });
+            console.log(`  + npm uninstall -g ${a.npmPkg}`);
+          } catch (e) {
+            console.error(`  ! npm uninstall -g ${a.npmPkg} failed: ${e.message}`);
+          }
+          break;
+        case 'rm-dir':
+          try {
+            execSync(`rm -rf "${a.path}"`, { stdio: 'pipe' });
+            console.log(`  + removed ${a.label}: ${a.path}`);
+          } catch (e) {
+            console.error(`  ! could not remove ${a.path}: ${e.message}`);
+          }
+          break;
+        case 'registry-remove':
+          try {
+            delete registry.extensions[a.name];
+            writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
+            console.log(`  + removed registry entry for ${a.name}`);
+          } catch (e) {
+            console.error(`  ! could not update registry: ${e.message}`);
+          }
+          break;
+      }
+    }
+
+    console.log('');
+    console.log('  Uninstalled.');
+    console.log('');
+  }
+
   // ── ldm worktree ──
 
   async function cmdWorktree() {
@@ -4619,9 +4785,17 @@ async function main() {
     case 'disable':
       await cmdDisable();
       break;
-    case 'uninstall':
-      await cmdUninstall();
+    case 'uninstall': {
+      // ldm uninstall <pkg> [--dry-run]   removes one package
+      // ldm uninstall                     removes the whole LDM OS install
+      const target = args.slice(1).find(a => !a.startsWith('--'));
+      if (target) {
+        await cmdUninstallPackage(target);
+      } else {
+        await cmdUninstall();
+      }
       break;
+    }
     case 'worktree':
       await cmdWorktree();
       break;

package/lib/deploy.mjs

@@ -1097,18 +1097,18 @@ function registerMCP(repoPath, door, toolName) {
  *
  * Returns true if at least one door installed successfully.
  */
-function installClaudeCodeHook(repoPath, doorOrDoors) {
+function installClaudeCodeHook(repoPath, doorOrDoors, toolName = basename(repoPath)) {
   const doors = Array.isArray(doorOrDoors) ? doorOrDoors : [doorOrDoors];
   let anyOk = false;
   for (const door of doors) {
-    if (installClaudeCodeHookEvent(repoPath, door)) {
+    if (installClaudeCodeHookEvent(repoPath, door, toolName)) {
       anyOk = true;
     }
   }
   return anyOk;
 }
 
-function installClaudeCodeHookEvent(repoPath, door) {
+function installClaudeCodeHookEvent(repoPath, door, toolName = basename(repoPath)) {
   const settingsPath = join(HOME, '.claude', 'settings.json');
   let settings = readJSON(settingsPath);
 
@@ -1117,7 +1117,6 @@ function installClaudeCodeHookEvent(repoPath, door) {
     return false;
   }
 
-  const toolName = basename(repoPath);
   const extDir = join(LDM_EXTENSIONS, toolName);
   const installedGuard = join(extDir, 'guard.mjs');
 
@@ -1422,7 +1421,7 @@ export function installSingleTool(toolPath) {
 
   if (interfaces.claudeCodeHook) {
     if (isEnabled || isAlreadyDeployed) {
-      if (installClaudeCodeHook(toolPath, interfaces.claudeCodeHook)) installed++;
+      if (installClaudeCodeHook(toolPath, interfaces.claudeCodeHook, toolName)) installed++;
     } else {
       skip(`Hook: ${toolName} not enabled`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.84",
+  "version": "0.4.85-alpha.2",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {
@@ -22,6 +22,7 @@
     "validate:bin-manifest": "node scripts/validate-bin-manifest.mjs",
     "test:skill-frontmatter": "node scripts/test-skill-frontmatter.mjs",
     "test:installer-update-tracks": "node scripts/test-installer-update-tracks.mjs",
+    "test:installer-hook-toolname": "node scripts/test-installer-hook-toolname.mjs",
     "test:ldm-install-bin-shim": "node scripts/test-ldm-install-preserves-foreign-bin.mjs",
     "test:doctor-cron-target": "node scripts/test-doctor-cron-target.mjs",
     "test:bin-manifest": "node scripts/test-bin-manifest.mjs",

package/scripts/test-installer-hook-toolname.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const tempHome = mkdtempSync(join(tmpdir(), 'ldm-hook-toolname-home-'));
+const tempPkg = mkdtempSync(join(tmpdir(), 'ldm-npm-pack-'));
+
+try {
+  process.env.HOME = tempHome;
+
+  mkdirSync(join(tempHome, '.claude'), { recursive: true });
+  writeFileSync(join(tempHome, '.claude', 'settings.json'), JSON.stringify({ hooks: {} }, null, 2) + '\n');
+  const staleExtDir = join(tempHome, '.ldm', 'extensions', 'wip-branch-guard');
+  mkdirSync(staleExtDir, { recursive: true });
+  writeFileSync(join(staleExtDir, 'guard.mjs'), 'console.log("stale guard");\n');
+  writeFileSync(join(staleExtDir, 'package.json'), JSON.stringify({
+    name: '@wipcomputer/wip-branch-guard',
+    version: '1.9.89',
+  }, null, 2) + '\n');
+  writeFileSync(join(tempHome, '.ldm', 'extensions', 'registry.json'), JSON.stringify({
+    _format: 'v2',
+    extensions: {
+      'wip-branch-guard': {
+        version: '1.9.89',
+        ldmPath: staleExtDir,
+        paths: { ldm: staleExtDir },
+        interfaces: ['module', 'skill', 'claudeCodeHook'],
+      },
+    },
+  }, null, 2) + '\n');
+
+  const extractedPackageDir = join(tempPkg, 'package');
+  mkdirSync(extractedPackageDir, { recursive: true });
+  writeFileSync(join(extractedPackageDir, 'package.json'), JSON.stringify({
+    name: '@wipcomputer/wip-branch-guard',
+    version: '1.9.90',
+    type: 'module',
+    main: 'guard.mjs',
+    claudeCode: {
+      hooks: [
+        { event: 'PreToolUse', matcher: 'Write|Edit|Bash', command: 'node guard.mjs', timeout: 5 },
+      ],
+    },
+  }, null, 2) + '\n');
+  writeFileSync(join(extractedPackageDir, 'guard.mjs'), 'console.log("guard 1.9.90");\n');
+  writeFileSync(join(extractedPackageDir, 'SKILL.md'), '---\nname: wip-branch-guard\ndescription: "test skill"\n---\n');
+
+  const { installSingleTool } = await import('../lib/deploy.mjs');
+  const installed = installSingleTool(extractedPackageDir);
+  if (installed === 0) throw new Error('installer did not process the test package');
+
+  const expectedDir = join(tempHome, '.ldm', 'extensions', 'wip-branch-guard');
+  const wrongDir = join(tempHome, '.ldm', 'extensions', 'package');
+  if (!existsSync(join(expectedDir, 'guard.mjs'))) {
+    throw new Error('guard.mjs was not deployed under the package-derived tool name');
+  }
+  if (!existsSync(join(expectedDir, 'package.json'))) {
+    throw new Error('package.json was not deployed under the package-derived tool name');
+  }
+  if (existsSync(wrongDir)) {
+    throw new Error('hook deployment used basename(repoPath) instead of package-derived tool name');
+  }
+
+  const settings = JSON.parse(readFileSync(join(tempHome, '.claude', 'settings.json'), 'utf8'));
+  const command = settings.hooks?.PreToolUse?.[0]?.hooks?.[0]?.command || '';
+  if (!command.includes('/wip-branch-guard/guard.mjs')) {
+    throw new Error(`hook command points at the wrong extension path: ${command}`);
+  }
+
+  const deployedPkg = JSON.parse(readFileSync(join(expectedDir, 'package.json'), 'utf8'));
+  if (deployedPkg.version !== '1.9.90') {
+    throw new Error(`deployed package version mismatch: ${deployedPkg.version}`);
+  }
+
+  console.log('installer hook tool-name regression check passed');
+} finally {
+  rmSync(tempHome, { recursive: true, force: true });
+  rmSync(tempPkg, { recursive: true, force: true });
+}

package/src/hosted-mcp/nginx/codex-relay.conf

@@ -0,0 +1,109 @@
+# Codex Remote Control relay
+#
+# Routes /api/codex-relay/* to the wip-mcp Node app at 127.0.0.1:18800.
+# Without these blocks nginx falls back to /index.html and the phone-side
+# bootstrap + ws-ticket calls receive HTML, which breaks the E2EE handshake
+# and the relay attach flow.
+#
+# Owners: this snippet pairs with src/hosted-mcp/server.mjs codex-relay
+# routes and the kaleidoscope-private phone surface. See
+# wip-ldm-os-private/ai/product/plans-prds/codex-remote-control/
+# for the full architecture.
+#
+# Include from inside the wip.computer server block.
+
+# ── HTTP routes ──────────────────────────────────────────────────────
+# bootstrap (GET) ... phone reads daemon E2EE pubkey + presence
+location /api/codex-relay/bootstrap/ {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# ws-ticket (POST) ... single-use, route-bound, 60s TTL
+location /api/codex-relay/ws-ticket {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# state (GET) ... daemon presence diagnostic
+location /api/codex-relay/state {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# pair-init (POST) ... codex-daemon link starts here
+location /api/codex-relay/pair-init {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# pair-status (GET) ... daemon polls during pair flow
+location /api/codex-relay/pair-status/ {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# pair-complete (POST) ... phone -> server after passkey + code
+location /api/codex-relay/pair-complete {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# ── WebSocket routes ────────────────────────────────────────────────
+# Standard nginx WebSocket pattern: Upgrade + Connection "upgrade", long
+# read/send timeout for daemon's persistent socket, buffering off so
+# streamed Codex events don't pool.
+
+# Phone side ... attached with ?ticket=<single-use>
+location /api/codex-relay/web/ {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection "upgrade";
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    proxy_read_timeout 86400;
+    proxy_send_timeout 86400;
+    proxy_buffering off;
+}
+
+# Daemon side ... long-lived presence socket from the user's Mac
+location /api/codex-relay/daemon {
+    proxy_pass http://127.0.0.1:18800;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection "upgrade";
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    proxy_read_timeout 86400;
+    proxy_send_timeout 86400;
+    proxy_buffering off;
+}

package/src/hosted-mcp/nginx/wip.computer.conf

@@ -7,103 +7,77 @@ server {
     access_log /var/log/nginx/wip.computer.access.log;
     error_log /var/log/nginx/wip.computer.error.log;
 
-    location / {
-        autoindex off;
-        try_files $uri $uri/ /index.html;
+    # Docs redirect to docs.wip.computer
+    location = /doc {
+        return 301 https://docs.wip.computer;
     }
-
-    add_header X-Frame-Options "SAMEORIGIN" always;
-    add_header X-Content-Type-Options "nosniff" always;
-    add_header X-XSS-Protection "1; mode=block" always;
-
-    # ── Codex Remote Control relay ──
-    # The Node app at 127.0.0.1:18800 (wip-mcp/server.mjs) owns these.
-    # Without these blocks, nginx falls back to /index.html and the
-    # phone-side bootstrap + ws-ticket calls receive HTML, which breaks
-    # E2EE handshake and relay attach. See:
-    # wip-ldm-os-private/ai/product/plans-prds/codex-remote-control/
-
-    # HTTP routes: bootstrap (GET), ws-ticket (POST), state (GET),
-    # pair-init (POST), pair-status (GET), pair-complete (POST).
-    location /api/codex-relay/bootstrap/ {
-        proxy_pass http://127.0.0.1:18800;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
+    location = /docs {
+        return 301 https://docs.wip.computer;
     }
-    location /api/codex-relay/ws-ticket {
-        proxy_pass http://127.0.0.1:18800;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-    location /api/codex-relay/state {
-        proxy_pass http://127.0.0.1:18800;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
+    location /docs/ {
+        return 301 https://docs.wip.computer;
     }
-    location /api/codex-relay/pair-init {
-        proxy_pass http://127.0.0.1:18800;
+
+    # MCP server
+    # OAuth 2.0 for Claude iOS connector
+    include snippets/mcp-oauth.conf;
+    include snippets/mcp-server.conf;
+
+    # Codex Remote Control relay (HTTP + WSS proxy_pass to wip-mcp Node app
+    # at 127.0.0.1:18800; covers /api/codex-relay/bootstrap, ws-ticket, state,
+    # pair-init/status/complete, web/<tid>, daemon).
+    include snippets/codex-relay.conf;
+
+    # Codex Remote Control phone surface
+    # The Next.js app at kaleidoscope.wip.computer (port 3001) renders
+    # /codex-remote-control/[threadId]. The MCP tool's auth URL uses
+    # wip.computer as the origin, so wip.computer/codex-remote-control/<tid>
+    # must reach the same Next.js app. WebSocket Upgrade headers included
+    # so live-reload / RSC streams work cleanly.
+    location /codex-remote-control/ {
+        proxy_pass http://127.0.0.1:3001;
         proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
     }
-    location /api/codex-relay/pair-status/ {
-        proxy_pass http://127.0.0.1:18800;
+
+    # Health check
+    location /health {
+        proxy_pass http://127.0.0.1:18800/health;
         proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
     }
-    location /api/codex-relay/pair-complete {
-        proxy_pass http://127.0.0.1:18800;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
+
+
+    # Demo pages (static files)
+    location /demo {
+        alias /var/www/wip.computer/app/mcp-server/demo;
+        index index.html;
+        try_files $uri $uri/ $uri/index.html =404;
     }
 
-    # WebSocket routes: phone (web) and daemon long-lived sockets.
-    # Upgrade headers are the standard WebSocket-via-nginx pattern.
-    # Long read timeout because daemon sockets stay open indefinitely.
-    location /api/codex-relay/web/ {
-        proxy_pass http://127.0.0.1:18800;
+    # Demo API (proxied to MCP server)
+    location /demo/api/ {
+        proxy_pass http://127.0.0.1:18800/demo/api/;
         proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_read_timeout 86400;
-        proxy_send_timeout 86400;
-        proxy_buffering off;
     }
-    location /api/codex-relay/daemon {
-        proxy_pass http://127.0.0.1:18800;
-        proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_read_timeout 86400;
-        proxy_send_timeout 86400;
-        proxy_buffering off;
+
+    location / {
+        autoindex off;
+        try_files $uri $uri/ /index.html;
     }
 
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
     location ~ /\. {
         deny all;
     }

package/src/hosted-mcp/app/codex-remote-control/index.html

@@ -1,254 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
-<title>Codex remote control</title>
-<style>
-  *, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }
-  :root {
-    --bg: #FFFDF5;
-    --bg-event: #F5F3ED;
-    --bg-tool: #F0EDE6;
-    --text: #1a1a1a;
-    --text-muted: #8a8580;
-    --accent: #0033FF;
-    --danger: #b00020;
-    --border: #E0DDD6;
-    --user-bubble: #E8F0FE;
-    --font: -apple-system, BlinkMacSystemFont, "SF Pro Text", system-ui, sans-serif;
-    --mono: ui-monospace, "SF Mono", Menlo, monospace;
-  }
-  html, body { height: 100%; font-family: var(--font); background: var(--bg); color: var(--text); }
-  body { display: flex; flex-direction: column; }
-  header { padding: 12px 16px; padding-top: calc(12px + env(safe-area-inset-top, 0px)); border-bottom: 1px solid var(--border); display: flex; align-items: center; gap: 10px; }
-  header .id { flex: 1; font-size: 13px; color: var(--text-muted); font-family: var(--mono); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-  header .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--text-muted); }
-  header .dot.online { background: #2ea44f; }
-  header .dot.offline { background: var(--danger); }
-  main { flex: 1; overflow-y: auto; padding: 16px; padding-bottom: 0; -webkit-overflow-scrolling: touch; }
-  .event { margin-bottom: 12px; padding: 12px 14px; border-radius: 10px; background: var(--bg-event); font-size: 14px; line-height: 1.45; }
-  .event .meta { font-size: 11px; color: var(--text-muted); font-family: var(--mono); margin-bottom: 4px; text-transform: uppercase; letter-spacing: 0.05em; }
-  .event.user { background: var(--user-bubble); }
-  .event.agent_message { background: var(--bg); border: 1px solid var(--border); }
-  .event.command_execution { background: var(--bg-tool); font-family: var(--mono); white-space: pre-wrap; word-break: break-all; }
-  .event.command_execution.failed { border-left: 3px solid var(--danger); }
-  .event.error { background: #fff0f0; border: 1px solid #f0c0c0; color: var(--danger); }
-  .event.system { background: transparent; color: var(--text-muted); font-size: 12px; padding: 6px 0; text-align: center; }
-  .event pre { font-family: var(--mono); white-space: pre-wrap; word-break: break-word; font-size: 13px; }
-  footer { padding: 12px; padding-bottom: calc(12px + env(safe-area-inset-bottom, 0px)); border-top: 1px solid var(--border); background: var(--bg); }
-  .composer { display: flex; gap: 8px; align-items: flex-end; }
-  textarea {
-    flex: 1; min-height: 44px; max-height: 120px; padding: 12px;
-    border: 1px solid var(--border); border-radius: 10px;
-    background: var(--bg); color: var(--text); font-family: var(--font); font-size: 16px;
-    resize: none;
-  }
-  textarea:focus { outline: 2px solid var(--accent); outline-offset: -1px; }
-  button { padding: 12px 16px; border: none; border-radius: 10px; font-family: var(--font); font-size: 14px; font-weight: 600; cursor: pointer; -webkit-tap-highlight-color: transparent; }
-  button:active { transform: scale(0.97); }
-  button:disabled { opacity: 0.4; cursor: not-allowed; }
-  .btn-send { background: var(--accent); color: white; }
-  .btn-stop { background: var(--danger); color: white; }
-</style>
-</head>
-<body>
-<header>
-  <div class="dot" id="presence" title="connecting"></div>
-  <div class="id" id="threadId">...</div>
-  <button id="stopBtn" class="btn-stop" type="button" disabled>Stop</button>
-</header>
-<main id="log"></main>
-<footer>
-  <form class="composer" id="composer">
-    <textarea id="prompt" rows="1" placeholder="Tell Codex what to do..." autocomplete="off"></textarea>
-    <button type="submit" class="btn-send" id="sendBtn">Send</button>
-  </form>
-</footer>
-<script>
-function getApiKey() { return sessionStorage.getItem("wip_api_key"); }
-function getHandle() { return sessionStorage.getItem("wip_handle") || ""; }
-
-function ensureSignedIn() {
-  if (!getApiKey()) {
-    location.href = "/app/login.html?next=" + encodeURIComponent(location.pathname);
-    return false;
-  }
-  return true;
-}
-
-function parsePath() {
-  // /:handle/codex-remote-control/:threadId
-  const m = location.pathname.match(/^\/([^/]+)\/codex-remote-control\/([^/]+)\/?$/);
-  if (!m) return null;
-  return { handle: decodeURIComponent(m[1]), threadId: decodeURIComponent(m[2]) };
-}
-
-function setPresence(state) {
-  const dot = document.getElementById("presence");
-  dot.classList.remove("online", "offline");
-  if (state === "online") dot.classList.add("online");
-  if (state === "offline") dot.classList.add("offline");
-  dot.title = state;
-}
-
-function appendEvent(html, kind) {
-  const log = document.getElementById("log");
-  const div = document.createElement("div");
-  div.className = "event " + (kind || "");
-  div.innerHTML = html;
-  log.appendChild(div);
-  log.scrollTop = log.scrollHeight;
-  return div;
-}
-
-function escapeHtml(s) {
-  return String(s).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[c]));
-}
-
-function renderItem(item) {
-  if (item.type === "agent_message") {
-    return appendEvent('<div class="meta">codex</div>' + escapeHtml(item.text || "").replace(/\n/g, "<br>"), "agent_message");
-  }
-  if (item.type === "command_execution") {
-    const status = (item.status || "").toString();
-    const out = item.aggregated_output ? '\n\n' + item.aggregated_output : "";
-    return appendEvent(
-      '<div class="meta">$ ' + escapeHtml(status) + (item.exit_code != null ? " (exit " + item.exit_code + ")" : "") + '</div>' +
-      '<pre>' + escapeHtml(item.command || "") + escapeHtml(out) + '</pre>',
-      "command_execution" + (status === "failed" ? " failed" : ""),
-    );
-  }
-  if (item.type === "reasoning") {
-    return appendEvent('<div class="meta">reasoning</div>' + escapeHtml(item.text || ""), "reasoning");
-  }
-  return appendEvent('<div class="meta">' + escapeHtml(item.type || "item") + '</div><pre>' + escapeHtml(JSON.stringify(item, null, 2)) + '</pre>', "item");
-}
-
-let ws = null;
-let pendingId = 1;
-
-function send(req) {
-  if (!ws || ws.readyState !== WebSocket.OPEN) return;
-  ws.send(JSON.stringify(req));
-}
-
-function connect(threadId) {
-  const apiKey = getApiKey();
-  const proto = location.protocol === "https:" ? "wss:" : "ws:";
-  const url = proto + "//" + location.host + "/api/codex-relay/web/" + encodeURIComponent(threadId) + "?token=" + encodeURIComponent(apiKey);
-  ws = new WebSocket(url);
-
-  ws.addEventListener("open", () => {
-    setPresence("online");
-    appendEvent("connected. open this thread in Codex on your Mac if it's not already.", "system");
-  });
-
-  ws.addEventListener("close", (ev) => {
-    setPresence("offline");
-    appendEvent("disconnected (code " + ev.code + ")", "system");
-  });
-
-  ws.addEventListener("error", () => {
-    setPresence("offline");
-  });
-
-  ws.addEventListener("message", (ev) => {
-    let msg;
-    try { msg = JSON.parse(ev.data); } catch { return; }
-    if (msg.type === "session.started") {
-      // Daemon assigned a temp id; the real thread id will arrive in thread.started.
-      return;
-    }
-    if (msg.type === "session.event") {
-      const evt = msg.event || {};
-      if (evt.type === "thread.started") {
-        // ok
-        return;
-      }
-      if (evt.type === "turn.started") {
-        document.getElementById("stopBtn").disabled = false;
-        return;
-      }
-      if (evt.type === "item.completed" && evt.item) {
-        renderItem(evt.item);
-        return;
-      }
-      if (evt.type === "item.started") {
-        return; // skip; we render on completed for now
-      }
-      if (evt.type === "turn.completed") {
-        document.getElementById("stopBtn").disabled = true;
-        const u = evt.usage;
-        if (u) appendEvent("turn complete (" + (u.input_tokens || 0) + " in / " + (u.output_tokens || 0) + " out)", "system");
-        else appendEvent("turn complete", "system");
-        return;
-      }
-      if (evt.type === "turn.failed") {
-        document.getElementById("stopBtn").disabled = true;
-        appendEvent("turn failed: " + (evt.error && evt.error.message ? evt.error.message : "unknown"), "error");
-        return;
-      }
-      return;
-    }
-    if (msg.type === "ack") return;
-    if (msg.type === "error") {
-      appendEvent("error: " + (msg.message || ""), "error");
-      return;
-    }
-  });
-}
-
-function init() {
-  if (!ensureSignedIn()) return;
-  const parsed = parsePath();
-  if (!parsed) {
-    appendEvent("Invalid URL. Expected /<handle>/codex-remote-control/<thread-id>.", "error");
-    return;
-  }
-  document.getElementById("threadId").textContent = parsed.threadId;
-  connect(parsed.threadId);
-
-  // Open or attach to the session on the daemon. session.start returns a temp
-  // sessionId; the actual thread.id arrives via thread.started in the stream.
-  setTimeout(() => {
-    send({ type: "session.start", id: "open-" + (pendingId += 1) });
-  }, 250);
-
-  document.getElementById("composer").addEventListener("submit", (ev) => {
-    ev.preventDefault();
-    const input = document.getElementById("prompt");
-    const text = input.value.trim();
-    if (!text) return;
-    input.value = "";
-    appendEvent('<div class="meta">you</div>' + escapeHtml(text), "user");
-    send({
-      type: "session.send",
-      id: "send-" + (pendingId += 1),
-      sessionId: parsed.threadId,
-      prompt: text,
-    });
-  });
-
-  document.getElementById("stopBtn").addEventListener("click", () => {
-    send({ type: "session.interrupt", id: "stop-" + (pendingId += 1), sessionId: parsed.threadId });
-  });
-
-  // Submit on Cmd+Enter / Ctrl+Enter; auto-resize.
-  const ta = document.getElementById("prompt");
-  ta.addEventListener("input", () => {
-    ta.style.height = "auto";
-    ta.style.height = Math.min(120, ta.scrollHeight) + "px";
-  });
-  ta.addEventListener("keydown", (ev) => {
-    if ((ev.metaKey || ev.ctrlKey) && ev.key === "Enter") {
-      ev.preventDefault();
-      document.getElementById("composer").requestSubmit();
-    }
-  });
-}
-
-init();
-</script>
-</body>
-</html>