@murk-security/cli 0.3.1 → 0.4.0

package/mcp-server.mjs

@@ -14,10 +14,24 @@ 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,
-});
+const fail = (error) => {
+  // Free-pentest gate (402): give the agent a clear, actionable message + link so
+  // it tells the user to subscribe rather than reporting a generic error.
+  if (error && error.upgrade) {
+    const url = error.upgradeUrl || 'the MURK billing page in the dashboard';
+    return {
+      content: [{
+        type: 'text',
+        text: `This MURK organization has used its one free pentest. To run more pentests the user needs to subscribe. Tell the user to open ${url} and choose a plan, then retry.`,
+      }],
+      isError: true,
+    };
+  }
+  return {
+    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 = {}) {

package/murk.mjs

@@ -6,6 +6,8 @@
  * those, read-only, and refuses everything else.
  *
  *   murk login                                       # browser sign-in; authorizes this machine
+ *   murk logout                                      # revoke this machine's credential
+ *   murk whoami                                      # show login status
  *   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)
@@ -21,8 +23,8 @@ 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';
+import { mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } 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(/\/$/, '');
@@ -79,10 +81,36 @@ async function api(method, path, 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}`);
+  if (!res.ok) {
+    const err = new Error(data.error ?? `HTTP ${res.status}`);
+    err.status = res.status;
+    err.upgrade = Boolean(data.upgrade);     // free-pentest gate (402)
+    err.upgradeUrl = data.upgradeUrl;
+    throw err;
+  }
   return data;
 }
 
+/** Free-tier gate, surfaced early and clearly. Returns before scanning when the
+ * org has spent its free pentest; notes the free run on the first scan. Billing
+ * being off (self-host) or unreachable never blocks a scan — the launch stays
+ * the authoritative gate. */
+async function ensureCanLaunch() {
+  let s;
+  try { s = await api('GET', '/api/billing/status'); }
+  catch (e) { if (e.status === 503 || e.status === 409) return; throw e; }
+  const ent = s.entitlement;
+  if (!ent || !ent.gated) return;
+  if (!ent.canLaunch) {
+    log('you’ve used your free pentest. Subscribe to run more:');
+    log(`  ${s.billingUrl || API_URL}`);
+    process.exit(2);
+  }
+  if (!ent.subscribed && !ent.freePentestUsed) {
+    log(`free trial: this is your 1 free pentest (up to ${ent.freeMaxMinutes} min). Subscribe any time for unlimited: ${s.billingUrl || ''}`.trimEnd());
+  }
+}
+
 /** 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. */
@@ -167,6 +195,7 @@ async function launchScan(applicationId) {
 async function cmdScan(url) {
   await ensureAuth();
   preflightChecks([url]);
+  await ensureCanLaunch(); // fail fast + note the free trial before opening the tunnel
   let done = false;
   const ws = openTunnel([url], {
     onReady: async (_u, applicationId) => {
@@ -183,7 +212,14 @@ async function cmdScan(url) {
             break;
           }
         }
-      } catch (e) { log(`scan failed: ${e instanceof Error ? e.message : e}`); }
+      } catch (e) {
+        if (e && e.upgrade) {
+          log('you’ve used your free pentest. Subscribe to run more:');
+          log(`  ${e.upgradeUrl || API_URL}`);
+        } else {
+          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.'); },
@@ -280,6 +316,35 @@ async function ensureAuth() {
   await cmdLogin();
 }
 
+// Revoke the stored credential server-side and remove it locally. Env-provided tokens
+// (MURK_API_TOKEN, for CI) are left alone — unset the variable to "log out" of those.
+async function cmdLogout() {
+  if (process.env.MURK_API_TOKEN) {
+    log('MURK_API_TOKEN is set in your environment — unset it to log out. (No stored credential was changed.)');
+    return;
+  }
+  const stored = readCredential();
+  if (!stored) { log('not logged in.'); return; }
+  try {
+    await fetch(`${API_URL}/api/cli/auth/logout`, { method: 'POST', headers: { Authorization: `Bearer ${stored}` } });
+  } catch { /* offline — still clear the local credential below */ }
+  try { rmSync(CRED_PATH, { force: true }); } catch { /* noop */ }
+  TOKEN = '';
+  log('logged out — credential revoked and removed.');
+}
+
+// Report whether this machine is authenticated, and validate the credential against the API.
+async function cmdWhoami() {
+  if (!TOKEN) { log('not logged in. Run: murk login'); return; }
+  const src = process.env.MURK_API_TOKEN ? 'MURK_API_TOKEN env' : '~/.murk/credentials.json';
+  try {
+    const res = await fetch(`${API_URL}/api/applications`, { headers: { Authorization: `Bearer ${TOKEN}` } });
+    if (res.ok) log(`logged in to ${API_URL}  (credential: ${src})`);
+    else if (res.status === 401) log('stored credential is invalid or revoked — run: murk login');
+    else log(`logged in (${src}), but ${API_URL} returned HTTP ${res.status}`);
+  } catch (e) { log(`could not reach ${API_URL}: ${e instanceof Error ? e.message : e}`); }
+}
+
 function parseExposed(rest) {
   const exposed = [];
   for (let i = 0; i < rest.length; i++) {
@@ -294,6 +359,10 @@ function main() {
   const fatal = (e) => die(e instanceof Error ? e.message : String(e));
   if (cmd === 'login') {
     void cmdLogin().catch(fatal);
+  } else if (cmd === 'logout') {
+    void cmdLogout().catch(fatal);
+  } else if (cmd === 'whoami') {
+    void cmdWhoami().catch(fatal);
   } else if (cmd === 'mcp') {
     void cmdMcp(parseExposed(rest)).catch(fatal);
   } else if (cmd === 'connect') {
@@ -304,6 +373,8 @@ function main() {
     process.stdout.write(
       'usage:\n' +
       '  murk login                                      # browser sign-in; authorizes this machine\n' +
+      '  murk logout                                     # revoke this machine’s credential\n' +
+      '  murk whoami                                     # show login status\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',
@@ -313,4 +384,11 @@ function main() {
 }
 
 // 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();
+// Compare realpaths so a bin symlink (node_modules/.bin/murk -> murk.mjs, as npx installs it)
+// still counts as direct execution — a plain href compare misses the symlink and no-ops.
+function isEntrypoint() {
+  const arg = process.argv[1];
+  if (!arg) return false;
+  try { return realpathSync(arg) === realpathSync(fileURLToPath(import.meta.url)); } catch { return false; }
+}
+if (isEntrypoint()) main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@murk-security/cli",
-  "version": "0.3.1",
+  "version": "0.4.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": {