@murk-security/cli 0.0.0-stage → 0.3.0

package/mcp-server.mjs

@@ -0,0 +1,148 @@
+/**
+ * MURK MCP tool surface — the single source of truth for the MCP tools, shared by:
+ *   - the hosted HTTP endpoint (control-plane/src/mcp.ts -> mcp-http.ts), and
+ *   - the local CLI MCP server (`murk mcp`, in murk.mjs) which bundles the tunnel.
+ *
+ * It is transport- and auth-agnostic: it takes an `api(method, path, body)` that performs an
+ * authenticated control-plane request (absolute path from the host root, e.g. /api/applications)
+ * and returns parsed JSON (throwing on a non-2xx). No backend logic lives here; every tool is a
+ * call to an existing control-plane endpoint.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+const ok = (data) => ({
+  content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+});
+const fail = (error) => ({
+  content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+  isError: true,
+});
+
+/** Build the MURK MCP server with all tools, backed by the given authenticated `api`. */
+export function buildMurkMcpServer(api, opts = {}) {
+  const RUNNER_MODE = opts.runnerMode ?? 'basic-harness';
+
+  async function getApplication(applicationId) {
+    const apps = await api('GET', '/api/applications');
+    const list = Array.isArray(apps) ? apps : (apps.applications ?? []);
+    const app = list.find((a) => a.id === applicationId);
+    if (!app) throw new Error(`application ${applicationId} not found`);
+    return app;
+  }
+
+  // Create -> preflight -> launch an assessment of the given kind (the flow the dashboard
+  // uses), returning the started run.
+  async function launchAssessment(app, o) {
+    const config = {
+      applicationId: app.id,
+      applicationName: app.name,
+      assessmentName: o.name,
+      target: {
+        sourceAssetId: app.sourceAssetId,
+        environmentAssetIds: (app.environments ?? []).map((e) => e.assetId),
+      },
+      scope: {},
+      identities: app.identities ?? [],
+      policy: { profile: 'standard', destructiveActions: false, maxConcurrency: 2, maxDurationMinutes: 20 },
+      packs: ['surface', 'sast', 'intel', 'scan', 'authz'],
+      kind: o.kind,
+      ...(o.remediateFindingId ? { remediateFindingId: o.remediateFindingId } : {}),
+    };
+    const created = await api('POST', '/api/assessments', config);
+    const pre = await api('POST', `/api/assessments/${created.id}/preflight`, { runnerMode: RUNNER_MODE });
+    if (!pre.ok) {
+      const failed = (pre.checks ?? []).filter((c) => !c.ok).map((c) => (c.detail ? `${c.name}: ${c.detail}` : c.name));
+      throw new Error(`preflight did not pass: ${failed.join('; ') || 'unknown'}`);
+    }
+    return api('POST', `/api/assessments/${created.id}/runs`, { runnerMode: RUNNER_MODE });
+  }
+
+  const server = new McpServer({ name: 'murk', version: '0.1.0' });
+
+  server.registerTool(
+    'murk_list_applications',
+    { title: 'List applications', description: 'List the applications (targets) in your MURK organization, including locally-connected apps.' },
+    async () => {
+      try { return ok(await api('GET', '/api/applications')); } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_list_findings',
+    {
+      title: 'List findings',
+      description: 'List findings, optionally filtered by application, status (open/fixed/regressed/accepted) or severity.',
+      inputSchema: { applicationId: z.string().optional(), status: z.string().optional(), severity: z.string().optional() },
+    },
+    async ({ applicationId, status, severity }) => {
+      try {
+        const data = await api('GET', '/api/findings');
+        let list = Array.isArray(data) ? data : (data.findings ?? []);
+        list = list.filter((f) =>
+          (!applicationId || f.applicationId === applicationId) &&
+          (!status || f.status === status) &&
+          (!severity || f.severity === severity));
+        return ok(list);
+      } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_get_finding',
+    { title: 'Get finding', description: 'Get one finding by id, including its reproduction recipe and any generated patch.', inputSchema: { findingId: z.string() } },
+    async ({ findingId }) => {
+      try { return ok(await api('GET', `/api/findings/${encodeURIComponent(findingId)}`)); } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_list_runs',
+    { title: 'List runs', description: 'List assessment runs in your organization.' },
+    async () => {
+      try { return ok(await api('GET', '/api/runs')); } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_get_run',
+    { title: 'Get run', description: 'Get a run and its findings by id.', inputSchema: { runId: z.string() } },
+    async ({ runId }) => {
+      try {
+        // Let a missing/erroring run surface as a clear failure (like murk_get_finding) rather
+        // than silently returning {}. Findings are tolerated as [] (a valid run may have none).
+        const run = await api('GET', `/api/runs/${encodeURIComponent(runId)}`);
+        const findings = await api('GET', `/api/runs/${encodeURIComponent(runId)}/findings`).catch(() => []);
+        return ok({ run, findings });
+      } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_scan',
+    { title: 'Scan an application', description: 'Start a security assessment of an application (public or locally-connected). Returns the started run.', inputSchema: { applicationId: z.string() } },
+    async ({ applicationId }) => {
+      try { return ok(await launchAssessment(await getApplication(applicationId), { kind: 'assess', name: 'Scan (via MCP)' })); } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_retest',
+    { title: 'Retest findings', description: 'Re-verify an application’s known findings; findings that no longer reproduce are marked fixed.', inputSchema: { applicationId: z.string() } },
+    async ({ applicationId }) => {
+      try { return ok(await launchAssessment(await getApplication(applicationId), { kind: 'retest', name: 'Retest (via MCP)' })); } catch (e) { return fail(e); }
+    },
+  );
+
+  server.registerTool(
+    'murk_create_patch',
+    { title: 'Create a patch', description: 'Generate a code patch for one finding (requires a connected source repo) and open a PR.', inputSchema: { findingId: z.string(), applicationId: z.string() } },
+    async ({ findingId, applicationId }) => {
+      try {
+        return ok(await launchAssessment(await getApplication(applicationId), { kind: 'remediate', name: 'Patch (via MCP)', remediateFindingId: findingId }));
+      } catch (e) { return fail(e); }
+    },
+  );
+
+  return server;
+}

package/murk.mjs

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/**
+ * murk — run MURK's MCP server for your AI agent and scan locally-running apps with MURK's
+ * HOSTED runner over a secure OUTBOUND tunnel. Nothing inbound to your network, no local runner,
+ * no model key. You choose exactly which localhost URLs are exposed; this process forwards ONLY
+ * those, read-only, and refuses everything else.
+ *
+ *   murk login                                       # browser sign-in; authorizes this machine
+ *   murk mcp --expose http://localhost:3000          # MCP server for your agent + tunnel
+ *   murk scan http://localhost:3000                  # one-shot: connect, scan, disconnect
+ *   murk connect --expose http://localhost:3000      # tunnel only (no MCP)
+ *
+ * Env:
+ *   MURK_API_URL        API origin. Default https://api.murk.sh (set to http://localhost:8788 for dev)
+ *   MURK_DASHBOARD_URL  dashboard origin for login. Default https://app.murk.sh (localhost:3000 for dev)
+ *   MURK_API_TOKEN      an org API token (murk_...) — overrides the stored login credential (for CI)
+ */
+import WebSocket from 'ws';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+// Default to the hosted MURK service; devs point these at a local control-plane/dashboard.
+const API_URL = (process.env.MURK_API_URL ?? 'https://api.murk.sh').replace(/\/$/, '');
+const DASHBOARD_URL = (process.env.MURK_DASHBOARD_URL ?? 'https://app.murk.sh').replace(/\/$/, '');
+const MAX_BODY = 10 * 1024 * 1024;
+const CRED_PATH = path.join(os.homedir(), '.murk', 'credentials.json');
+
+function die(msg) { process.stderr.write(`murk: ${msg}\n`); process.exit(1); }
+function log(msg) { process.stderr.write(`murk: ${msg}\n`); }
+
+// Credential: the MURK_API_TOKEN env (CI) wins; otherwise the token stored by `murk login`.
+function readCredential() {
+  try { return JSON.parse(readFileSync(CRED_PATH, 'utf8')).token || ''; } catch { return ''; }
+}
+function saveCredential(token) {
+  mkdirSync(path.dirname(CRED_PATH), { recursive: true });
+  writeFileSync(CRED_PATH, JSON.stringify({ token }, null, 2), { mode: 0o600 });
+}
+let TOKEN = process.env.MURK_API_TOKEN || readCredential();
+
+// Only localhost / private (RFC1918, link-local, CGNAT) targets — your own machine/network.
+export function isLocal(raw) {
+  let host;
+  try { host = new URL(raw).hostname.toLowerCase(); } catch { return false; }
+  if (host.startsWith('[') && host.endsWith(']')) host = host.slice(1, -1); // WHATWG URL keeps IPv6 brackets
+  if (host === 'localhost' || host === '::1' || host.endsWith('.localhost') || host.endsWith('.local') || host.endsWith('.internal')) return true;
+  const m = /^(\d{1,3})\.(\d{1,3})\.\d{1,3}\.\d{1,3}$/.exec(host);
+  if (!m) return false;
+  const a = Number(m[1]), b = Number(m[2]);
+  return a === 127 || a === 0 || a === 10 || (a === 192 && b === 168) || (a === 172 && b >= 16 && b <= 31) || (a === 169 && b === 254);
+}
+
+export const normOrigin = (u) => new URL(u).origin;
+
+/** Pure scope decision — the client-side trust boundary, extracted so it is unit-testable.
+ * `allow` is a Set of exact exposed origins. Returns the resolved URL to fetch, or a refusal
+ * reason. Enforces: read-only (GET/HEAD), a parseable path, and exact-origin allowlisting
+ * (so off-target host/port/scheme, metadata, and other RFC1918 destinations are all refused).
+ * Redirects are NOT followed to another host by the caller (`redirect: 'manual'`). */
+export function scopeDecision(allow, msg) {
+  const method = String(msg?.method || 'GET').toUpperCase();
+  if (method !== 'GET' && method !== 'HEAD') return { ok: false, message: 'refused: read-only (GET/HEAD) only' };
+  let resolved;
+  try { resolved = new URL(String(msg?.path ?? '/'), msg?.target); } catch { return { ok: false, message: 'refused: bad path' }; }
+  if (!allow.has(resolved.origin)) return { ok: false, message: `refused: ${resolved.origin} is not an exposed target` };
+  return { ok: true, method, resolved };
+}
+
+async function api(method, path, body) {
+  const res = await fetch(`${API_URL}${path}`, {
+    method,
+    headers: { Authorization: `Bearer ${TOKEN}`, ...(body === undefined ? {} : { 'Content-Type': 'application/json' }) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await res.text();
+  let data; try { data = text ? JSON.parse(text) : {}; } catch { data = { raw: text }; }
+  if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
+  return data;
+}
+
+/** Open the tunnel for a set of exposed origins. `onReady(url, appId)` fires as each target
+ * is registered server-side. The scope allowlist is enforced HERE — this process is the
+ * trust boundary on the customer side. */
+function openTunnel(exposed, { onReady, onClose } = {}) {
+  const allow = new Set(exposed.map(normOrigin));
+  const wsUrl = `${API_URL.replace(/^http/, 'ws')}/api/local-scan/tunnel`;
+  const ws = new WebSocket(wsUrl, { headers: { Authorization: `Bearer ${TOKEN}` } });
+
+  ws.on('open', () => ws.send(JSON.stringify({ t: 'hello', targets: exposed.map((url) => ({ url })) })));
+  ws.on('unexpected-response', (_req, res) => die(`tunnel rejected (HTTP ${res.statusCode}). Check MURK_API_TOKEN / MURK_API_URL.`));
+  ws.on('message', async (raw) => {
+    let msg; try { msg = JSON.parse(raw.toString()); } catch { return; }
+    if (msg.t === 'ready') { log(`exposed ${msg.url}  ->  application ${msg.applicationId}`); onReady?.(msg.url, msg.applicationId); return; }
+    if (msg.t === 'rejected') { log(`server rejected ${msg.url}: ${msg.reason}`); return; }
+    if (msg.t !== 'req') return;
+    // ---- CLIENT-SIDE SCOPE ENFORCEMENT (the trust boundary) ----
+    const reply = (obj) => { try { ws.send(JSON.stringify({ ...obj, id: msg.id })); } catch { /* closing */ } };
+    const decision = scopeDecision(allow, msg);
+    if (!decision.ok) return reply({ t: 'err', message: decision.message });
+    const { method, resolved } = decision;
+    try {
+      const headers = (msg.headers && typeof msg.headers === 'object') ? { ...msg.headers } : {};
+      delete headers.host; delete headers.Host;
+      const r = await fetch(resolved, { method, headers, redirect: 'manual' }); // never follow a redirect to another host
+      const buf = Buffer.from(await r.arrayBuffer());
+      const body = buf.length > MAX_BODY ? buf.subarray(0, MAX_BODY) : buf;
+      const outHeaders = {};
+      r.headers.forEach((v, k) => { outHeaders[k] = v; });
+      reply({ t: 'res', status: r.status, headers: outHeaders, bodyB64: body.toString('base64') });
+    } catch (e) {
+      reply({ t: 'err', message: `local fetch failed: ${e instanceof Error ? e.message : 'error'}` });
+    }
+  });
+  ws.on('close', () => onClose?.());
+  ws.on('error', (e) => log(`tunnel error: ${e instanceof Error ? e.message : e}`));
+  return ws;
+}
+
+function preflightChecks(exposed) {
+  if (!exposed.length) die('nothing to expose. Use: murk mcp --expose http://localhost:3000');
+  for (const u of exposed) {
+    try { new URL(u); } catch { die(`not a URL: ${u}`); }
+    if (!isLocal(u)) die(`${u} is not a localhost/private origin. murk only tunnels your own local/internal apps.`);
+  }
+}
+
+async function cmdConnect(exposed) {
+  await ensureAuth();
+  preflightChecks(exposed);
+  log(`connecting to ${API_URL} ...`);
+  let ws;
+  const connect = () => {
+    ws = openTunnel(exposed, {
+      onClose: () => { log('tunnel closed; reconnecting in 3s (Ctrl-C to stop) ...'); setTimeout(connect, 3000); },
+    });
+  };
+  connect();
+  const stop = () => { log('disconnecting.'); try { ws?.close(); } catch { /* noop */ } process.exit(0); };
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+}
+
+async function launchScan(applicationId) {
+  const apps = await api('GET', '/api/applications');
+  const list = Array.isArray(apps) ? apps : (apps.applications ?? []);
+  const app = list.find((a) => a.id === applicationId);
+  if (!app) throw new Error('application not found after connect');
+  const assetIds = (app.environments ?? []).map((e) => e.assetId);
+  const config = {
+    applicationId: app.id, applicationName: app.name, assessmentName: `Local scan ${new Date().toISOString()}`,
+    target: { environmentAssetIds: assetIds }, scope: {}, identities: app.identities ?? [],
+    policy: { profile: 'standard', destructiveActions: false, maxConcurrency: 1, maxDurationMinutes: 15 },
+    packs: ['surface', 'sast', 'intel', 'scan', 'authz'], kind: 'assess',
+  };
+  const created = await api('POST', '/api/assessments', config);
+  const pre = await api('POST', `/api/assessments/${created.id}/preflight`, { runnerMode: 'basic-harness' });
+  if (pre && pre.ok === false) throw new Error('preflight did not pass');
+  const run = await api('POST', `/api/assessments/${created.id}/runs`, { runnerMode: 'basic-harness' });
+  return run.runId ?? run.id ?? run.run?.id;
+}
+
+async function cmdScan(url) {
+  await ensureAuth();
+  preflightChecks([url]);
+  let done = false;
+  const ws = openTunnel([url], {
+    onReady: async (_u, applicationId) => {
+      try {
+        log('starting hosted scan ...');
+        const runId = await launchScan(applicationId);
+        log(`run ${runId} started; watching ...`);
+        for (;;) {
+          await new Promise((r) => setTimeout(r, 4000));
+          const run = await api('GET', `/api/runs/${encodeURIComponent(runId)}`).catch(() => ({}));
+          const status = String(run.status ?? run.run?.status ?? '').toLowerCase();
+          if (['completed', 'failed', 'cancelled', 'error'].includes(status)) {
+            log(`scan ${status}. View it in the dashboard (application ${applicationId}).`);
+            break;
+          }
+        }
+      } catch (e) { log(`scan failed: ${e instanceof Error ? e.message : e}`); }
+      finally { done = true; try { ws.close(); } catch { /* noop */ } process.exit(0); }
+    },
+    onClose: () => { if (!done) die('tunnel closed before the scan finished.'); },
+  });
+}
+
+// `murk mcp [--expose URL ...]` — run MURK's MCP server over stdio (for `claude mcp add`,
+// Cursor, etc.) AND, in the same process, bridge any --expose'd local apps over the tunnel so
+// the hosted runner can scan them. One command: the tunnel is just part of the MCP server. The
+// --expose set is the user-declared allowlist, enforced client-side in openTunnel.
+async function cmdMcp(exposed) {
+  await ensureAuth();
+  for (const u of exposed) {
+    try { new URL(u); } catch { die(`not a URL: ${u}`); }
+    if (!isLocal(u)) die(`${u} is not a localhost/private origin. murk only exposes your own local/internal apps.`);
+  }
+  if (exposed.length) {
+    log(`exposing ${exposed.join(', ')} over the tunnel`);
+    let ws;
+    const connect = () => {
+      ws = openTunnel(exposed, {
+        onClose: () => { log('tunnel closed; reconnecting in 3s ...'); setTimeout(connect, 3000); },
+      });
+    };
+    connect();
+  }
+  // stdout is the MCP protocol channel; keep all logging on stderr (log()/die() already do).
+  const { buildMurkMcpServer } = await import('./mcp-server.mjs');
+  const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+  const server = buildMurkMcpServer(api);
+  await server.connect(new StdioServerTransport());
+  log(`murk MCP server ready on stdio${exposed.length ? ` (exposing ${exposed.length} local app(s))` : ''}`);
+}
+
+function openBrowser(url) {
+  if (process.env.MURK_NO_BROWSER) return; // headless/SSH: the URL is printed to stderr instead
+  const [cmd, args] = process.platform === 'darwin'
+    ? ['open', [url]]
+    : process.platform === 'win32'
+      ? ['cmd', ['/c', 'start', '', url]]
+      : ['xdg-open', [url]];
+  try { spawn(cmd, args, { stdio: 'ignore', detached: true }).unref(); } catch { /* fall back to the printed URL */ }
+}
+
+const LOGIN_OK_HTML =
+  '<!doctype html><meta charset=utf-8><title>MURK CLI authorized</title>' +
+  '<body style="font:16px system-ui;max-width:32rem;margin:4rem auto;padding:0 1rem;color:#111">' +
+  '<h1 style="font-size:1.25rem">✓ MURK CLI authorized</h1>' +
+  '<p>You can close this tab and return to your terminal.</p></body>';
+
+// Browser sign-in that authorizes THIS machine (like `gh`/`wrangler login`): open the dashboard
+// /activate page, which signs you in and approves the CLI; it then hands a one-time code back to
+// this process over loopback, which we exchange for an org token stored in ~/.murk/credentials.
+async function cmdLogin() {
+  const state = randomBytes(24).toString('base64url');
+  const token = await new Promise((resolve, reject) => {
+    let timer;
+    const server = http.createServer((req, res) => {
+      let u; try { u = new URL(req.url, 'http://127.0.0.1'); } catch { res.writeHead(400).end(); return; }
+      const code = u.searchParams.get('code');
+      if (!code || u.searchParams.get('state') !== state) { res.writeHead(400, { 'Content-Type': 'text/html' }).end('<h1>Invalid login response</h1>'); return; }
+      res.writeHead(200, { 'Content-Type': 'text/html' }).end(LOGIN_OK_HTML);
+      clearTimeout(timer);
+      server.close();
+      fetch(`${API_URL}/api/cli/auth/exchange`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ code, state }),
+      }).then(async (r) => {
+        const d = await r.json().catch(() => ({}));
+        if (!r.ok || !d.token) throw new Error(d.error || `exchange failed (HTTP ${r.status})`);
+        resolve(d.token);
+      }).catch(reject);
+    });
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const url = `${DASHBOARD_URL}/?cli_login=1&port=${port}&state=${encodeURIComponent(state)}`;
+      log('opening your browser to sign in and authorize this machine:');
+      log(`  ${url}`);
+      openBrowser(url);
+      log('waiting for approval (Ctrl-C to cancel) ...');
+    });
+    timer = setTimeout(() => { try { server.close(); } catch { /* noop */ } reject(new Error('login timed out after 3 minutes')); }, 180_000);
+    timer.unref(); // don't keep the process alive once login completes
+  });
+  saveCredential(token);
+  TOKEN = token;
+  log('logged in. Credential saved to ~/.murk/credentials.json');
+}
+
+// Ensure we have a credential before doing authenticated work; log in via the browser if not.
+async function ensureAuth() {
+  if (TOKEN) return;
+  log('not logged in — starting browser sign-in ...');
+  await cmdLogin();
+}
+
+function parseExposed(rest) {
+  const exposed = [];
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === '--expose' || rest[i] === '-e') { if (rest[i + 1]) exposed.push(rest[++i]); }
+    else if (rest[i].startsWith('http')) exposed.push(rest[i]);
+  }
+  return exposed;
+}
+
+function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  const fatal = (e) => die(e instanceof Error ? e.message : String(e));
+  if (cmd === 'login') {
+    void cmdLogin().catch(fatal);
+  } else if (cmd === 'mcp') {
+    void cmdMcp(parseExposed(rest)).catch(fatal);
+  } else if (cmd === 'connect') {
+    void cmdConnect(parseExposed(rest)).catch(fatal);
+  } else if (cmd === 'scan') {
+    void cmdScan(rest.find((a) => a.startsWith('http'))).catch(fatal);
+  } else {
+    process.stdout.write(
+      'usage:\n' +
+      '  murk login                                      # browser sign-in; authorizes this machine\n' +
+      '  murk mcp [--expose http://localhost:3000 ...]   # MCP server for your agent; exposes local apps\n' +
+      '  murk scan http://localhost:3000                 # one-shot: connect, scan, disconnect\n' +
+      '  murk connect --expose http://localhost:3000     # tunnel only (no MCP)\n',
+    );
+    process.exit(cmd ? 1 : 0);
+  }
+}
+
+// Run the CLI only when executed directly, not when imported (e.g. by the test suite).
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main();

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "@murk-security/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Run MURK's MCP server for your AI agent and scan locally-running apps with MURK's hosted runner over a secure outbound tunnel — no local runner, no model key.",
+  "type": "module",
+  "bin": {
+    "murk": "./murk.mjs"
+  },
+  "files": [
+    "murk.mjs",
+    "mcp-server.mjs"
+  ],
+  "keywords": [
+    "murk",
+    "mcp",
+    "security",
+    "scanner",
+    "model-context-protocol"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "ws": "^8.21.0",
+    "zod": "^4.5.4"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.