@vortex-os/computer-use 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vortex-os/computer-use",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Add-on — read-only screen perception (structured UIA tree + pixel fallback + change watch) exposed as an MCP server, layered on @vortex-os/base. Windows-first. Control (mouse/keyboard) is intentionally out of scope.",
   "license": "MIT",
   "author": "vortex-os-project",
@@ -24,6 +24,14 @@
   "bin": {
     "vortex-mcp-computer-use": "scripts/mcp-stdio.mjs"
   },
+  "vortex": {
+    "mcpServers": {
+      "vortex-computer-use": {
+        "command": "node",
+        "args": ["node_modules/@vortex-os/computer-use/scripts/mcp-stdio.mjs"]
+      }
+    }
+  },
   "scripts": {
     "verify": "node scripts/verify.mjs"
   },

package/scripts/mcp-stdio.mjs

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-// computer-use — MCP stdio server (PoC). Exposes the CLI dispatcher (action-ext.mjs) as MCP tools.
-// Same backend logic (OS-native). Tools: probe · read_ui · capture_screen.
-// Depends on: @modelcontextprotocol/sdk (pulled in by memory-extended, present in the instance node_modules).
-//   In the real add-on this ships packaged as scripts/mcp-stdio.mjs + bin vortex-mcp-action (design §21).
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+// @vortex-os/computer-use — read-only screen-perception MCP stdio server (Windows-first).
+// Tools: probe · read_ui · capture_screen · watch_capture · poll_change · beep. Control is out of scope.
+// Two modes (bin `vortex-mcp-computer-use`):
+//   - default: run the stdio server (what an MCP host launches).
+//   - `install`: self-register into the project `.mcp.json` under the non-reserved key
+//     `vortex-computer-use` (merge-safe). e.g. `npx vortex-mcp-computer-use install`.
+// Optional dep: @modelcontextprotocol/sdk — loaded DYNAMICALLY only on the serve path (see the
+// bottom dispatch), so `install` registers and exits without needing the SDK present.
 import { spawnSync, spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { readFileSync, unlinkSync, statSync, mkdtempSync, rmSync, existsSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs';
+import { readFileSync, unlinkSync, statSync, mkdtempSync, rmSync, existsSync, mkdirSync, writeFileSync, renameSync, appendFileSync } from 'node:fs';
 import { tmpdir, homedir } from 'node:os';
 import { createHmac, randomBytes } from 'node:crypto';
 
@@ -408,11 +409,8 @@ const TOOLS = [
   },
 ];
 
-const server = new Server({ name: 'computer-use', version: '0.0.1-poc' }, { capabilities: { tools: {} } });
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
+// The CallTool handler — standalone (no SDK types), wired to the server only on the serve path.
+async function handleCallTool(req) {
   const { name, arguments: a = {} } = req.params;
   const useWorker = plat === 'win32';   // the resident worker is Windows PowerShell backend only
   let result;
@@ -534,13 +532,86 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
   } finally {
     if (reqDir) { try { rmSync(reqDir, { recursive: true, force: true }); } catch {} }
   }
-});
+}
 
 // Clean up the worker on server shutdown (it would also auto-terminate via stdin EOF when the parent dies, but do it explicitly).
 process.on('exit', () => workerMgr.dispose());
 process.on('SIGINT', () => process.exit(0));
 process.on('SIGTERM', () => process.exit(0));
 
-const transport = new StdioServerTransport();
-await server.connect(transport);
-process.stderr.write(`[computer-use MCP] ready on stdio (worker=${plat === 'win32' ? 'on' : 'off'}; tools: probe, read_ui, capture_screen, watch_capture, poll_change, beep)\n`);
+// ── install mode: self-register into the project .mcp.json (stage 1) ─────────
+// `vortex-mcp-computer-use install [--path <file>]` — merge-safe registration. ALWAYS uses the
+// non-reserved key "vortex-computer-use" (the host reserves "computer-use" and silently won't load
+// it), preserves every other server + top-level field, and refuses to overwrite a malformed file.
+const SERVER_KEY = 'vortex-computer-use';
+const SERVER_ENTRY = { command: 'node', args: ['node_modules/@vortex-os/computer-use/scripts/mcp-stdio.mjs'] };
+
+const isObjLit = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const refuse = (msg) => { process.stderr.write(`[install] ${msg}\n`); process.exit(1); };
+
+function runInstall(argv) {
+  const i = argv.indexOf('--path');
+  let target;
+  if (i >= 0) {
+    const v = argv[i + 1];
+    if (!v || v.startsWith('--')) refuse('--path requires a file path argument.');
+    target = v;
+  } else {
+    target = join(process.cwd(), '.mcp.json');
+  }
+  let existing = {};
+  if (existsSync(target)) {
+    let txt;
+    try { txt = readFileSync(target, 'utf8').trim(); }
+    catch (e) { refuse(`${target} could not be read — left untouched: ${e.message}`); }
+    if (txt) {
+      let parsed;
+      try { parsed = JSON.parse(txt); }
+      catch (e) { refuse(`${target} is not valid JSON — refusing to overwrite (fix it first): ${e.message}`); }
+      if (!isObjLit(parsed)) refuse(`${target} is not a JSON object — refusing to overwrite.`);
+      if (parsed.mcpServers !== undefined && !isObjLit(parsed.mcpServers)) refuse(`${target} has a non-object "mcpServers" — refusing to overwrite.`);
+      existing = parsed;
+    }
+  }
+  const servers = isObjLit(existing.mcpServers) ? existing.mcpServers : {};
+  // ADD-ONLY: never clobber an existing "vortex-computer-use" entry (the user may have customized it).
+  if (Object.prototype.hasOwnProperty.call(servers, SERVER_KEY)) {
+    process.stdout.write(JSON.stringify({ ok: true, action: 'already-present', path: target, serverKey: SERVER_KEY }, null, 2) + '\n');
+    process.stderr.write(`[install] "${SERVER_KEY}" already registered in ${target} — left unchanged.\n`);
+    return;
+  }
+  const preserved = Object.keys(servers);
+  const merged = { ...existing, mcpServers: { ...servers, [SERVER_KEY]: SERVER_ENTRY } };
+  // Atomic write via a PRIVATE temp dir (random name, not a guessable sibling): write inside with
+  // exclusive-create, rename onto the target, then remove the dir. Avoids following a pre-placed
+  // temp symlink and leaves no stray temp on failure (codex r2 MEDIUM).
+  try { mkdirSync(dirname(target), { recursive: true }); } catch {}
+  const tmpDir = mkdtempSync(join(dirname(target), '.mcp-cu-'));
+  const tmp = join(tmpDir, 'mcp.json');
+  try {
+    writeFileSync(tmp, JSON.stringify(merged, null, 2) + '\n', { encoding: 'utf8', flag: 'wx' });
+    renameSync(tmp, target);
+  } finally {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+  process.stdout.write(JSON.stringify({ ok: true, action: 'added', path: target, serverKey: SERVER_KEY, preservedServers: preserved }, null, 2) + '\n');
+  process.stderr.write(
+    `[install] added "${SERVER_KEY}" in ${target}` +
+      (preserved.length ? ` (kept: ${preserved.join(', ')})` : '') + '\n' +
+      `[install] Restart the agent — or approve the new MCP server when prompted — to load the computer-use tools.\n`,
+  );
+}
+
+if (process.argv.slice(2).includes('install')) {
+  runInstall(process.argv.slice(2));
+} else {
+  // Serve path: load the MCP SDK dynamically (so `install` never requires it), wire the handlers, connect.
+  const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
+  const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+  const { ListToolsRequestSchema, CallToolRequestSchema } = await import('@modelcontextprotocol/sdk/types.js');
+  const server = new Server({ name: 'computer-use', version: '0.2.1' }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, handleCallTool);
+  await server.connect(new StdioServerTransport());
+  process.stderr.write(`[computer-use MCP] ready on stdio (worker=${plat === 'win32' ? 'on' : 'off'}; tools: probe, read_ui, capture_screen, watch_capture, poll_change, beep)\n`);
+}