faceless-cli 1.1.7 → 1.1.9

package/src/mcp/stdio.mjs

@@ -2,112 +2,103 @@ import fs from "node:fs";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { resolveApiKey, resolveBaseUrl } from "../config.mjs";
+import { loadConfig, resolveApiKey, resolveBaseUrl } from "../config.mjs";
 import { CliError, request } from "../client.mjs";
 
 const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
 let spec;
 try {
-  spec = JSON.parse(
-    fs.readFileSync(new URL("../generated/operations.json", import.meta.url), "utf8")
-  );
+	spec = JSON.parse(fs.readFileSync(new URL("../generated/operations.json", import.meta.url), "utf8"));
 } catch {
-  throw new Error(
-    'cli/src/generated/operations.json is missing. Run "npm run generate:agents" in the repo root to generate it.'
-  );
+	throw new Error('cli/src/generated/operations.json is missing. Run "npm run generate:agents" in the repo root to generate it.');
 }
 const operations = spec.operations.filter((op) => op.mcp && op.mcp.enabled);
 
 function toolInputSchema(op) {
-  const properties = {
-    ...((op.querySchema && op.querySchema.properties) || {}),
-    ...((op.requestSchema && op.requestSchema.properties) || {}),
-  };
-  const required = [
-    ...new Set([
-      ...((op.querySchema && op.querySchema.required) || []),
-      ...((op.requestSchema && op.requestSchema.required) || []),
-    ]),
-  ];
-  const schema = { type: "object", properties, additionalProperties: false };
-  if (required.length) schema.required = required;
-  return schema;
+	const properties = {
+		...((op.querySchema && op.querySchema.properties) || {}),
+		...((op.requestSchema && op.requestSchema.properties) || {}),
+	};
+	const required = [...new Set([...((op.querySchema && op.querySchema.required) || []), ...((op.requestSchema && op.requestSchema.required) || [])])];
+	const schema = { type: "object", properties, additionalProperties: false };
+	if (required.length) schema.required = required;
+	return schema;
 }
 
 function errorResult(type, message) {
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({ success: false, error: { type, message } }),
-      },
-    ],
-  };
+	return {
+		isError: true,
+		content: [
+			{
+				type: "text",
+				text: JSON.stringify({ success: false, error: { type, message } }),
+			},
+		],
+	};
 }
 
 export async function runMcpServer() {
-  const server = new Server(
-    { name: "faceless", version: pkg.version },
-    { capabilities: { tools: {} } }
-  );
+	const server = new Server({ name: "faceless", version: pkg.version }, { capabilities: { tools: {} } });
 
-  const tools = operations.map((op) => ({
-    name: op.mcp.name,
-    description: `${op.summary}. ${op.description}`,
-    inputSchema: toolInputSchema(op),
-  }));
+	const tools = operations.map((op) => ({
+		name: op.mcp.name,
+		description: `${op.summary}. ${op.description}`,
+		inputSchema: toolInputSchema(op),
+	}));
 
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
 
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
-    const name = req.params.name;
-    const args = { ...(req.params.arguments || {}) };
-    const op = operations.find((o) => o.mcp.name === name);
-    if (!op) return errorResult("invalid_input", `Unknown tool: ${name}`);
+	server.setRequestHandler(CallToolRequestSchema, async (req) => {
+		const name = req.params.name;
+		const args = { ...(req.params.arguments || {}) };
+		const op = operations.find((o) => o.mcp.name === name);
+		if (!op) return errorResult("invalid_input", `Unknown tool: ${name}`);
 
-    const apiKey = resolveApiKey({});
-    if (!apiKey) {
-      return errorResult(
-        "unauthorized",
-        'No API key configured. Set the FACELESS_API_KEY environment variable or run "faceless login". Create keys in your team settings at https://faceless.so/team.'
-      );
-    }
+		// A null key is fine when `faceless login` stored an OAuth session: request() resolves and
+		// refreshes it. Only fail fast when NEITHER credential exists, and say the browser flow first -
+		// it is the path an agent can actually complete without a human pasting a key.
+		const apiKey = resolveApiKey({});
+		if (!apiKey && !loadConfig().oauth?.refreshToken) {
+			return errorResult(
+				"unauthorized",
+				'Not authenticated. Run "faceless login" (opens a browser for OAuth - no key to paste), or set the FACELESS_API_KEY environment variable with a key from https://faceless.so/team.'
+			);
+		}
 
-    let path = op.path;
-    for (const match of op.path.matchAll(/\{(\w+)\}/g)) {
-      const param = match[1];
-      if (args[param] === undefined || args[param] === null) {
-        return errorResult("invalid_input", `Missing required parameter: ${param}`);
-      }
-      path = path.replace(`{${param}}`, encodeURIComponent(String(args[param])));
-      delete args[param];
-    }
+		let path = op.path;
+		for (const match of op.path.matchAll(/\{(\w+)\}/g)) {
+			const param = match[1];
+			if (args[param] === undefined || args[param] === null) {
+				return errorResult("invalid_input", `Missing required parameter: ${param}`);
+			}
+			path = path.replace(`{${param}}`, encodeURIComponent(String(args[param])));
+			delete args[param];
+		}
 
-    try {
-      const method = op.method.toLowerCase();
-      const hasBody = method !== "get" && method !== "delete";
-      // Transport-level replay key (same semantics as the HTTP Idempotency-Key
-      // header and the remote MCP's idempotencyKey argument), not operation input.
-      const { idempotencyKey, ...opArgs } = args;
-      const result = await request({
-        method: op.method,
-        path,
-        query: hasBody ? undefined : opArgs,
-        body: hasBody ? opArgs : undefined,
-        apiKey,
-        baseUrl: resolveBaseUrl({}),
-        idempotencyKey,
-      });
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-      };
-    } catch (err) {
-      if (err instanceof CliError) return errorResult(err.type, err.message);
-      return errorResult("internal_error", err.message || "Unknown error");
-    }
-  });
+		try {
+			const method = op.method.toLowerCase();
+			const hasBody = method !== "get" && method !== "delete";
+			// Transport-level replay key (same semantics as the HTTP Idempotency-Key
+			// header and the remote MCP's idempotencyKey argument), not operation input.
+			const { idempotencyKey, ...opArgs } = args;
+			const result = await request({
+				method: op.method,
+				path,
+				query: hasBody ? undefined : opArgs,
+				body: hasBody ? opArgs : undefined,
+				apiKey,
+				baseUrl: resolveBaseUrl({}),
+				idempotencyKey,
+			});
+			return {
+				content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+			};
+		} catch (err) {
+			if (err instanceof CliError) return errorResult(err.type, err.message);
+			return errorResult("internal_error", err.message || "Unknown error");
+		}
+	});
 
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
 }

package/src/oauth.mjs

@@ -0,0 +1,306 @@
+import crypto from "node:crypto";
+import http from "node:http";
+import { execFile } from "node:child_process";
+import { loadConfig, saveConfig } from "./config.mjs";
+import { CliError } from "./client.mjs";
+
+// OAuth 2.0 login for the CLI and the MCP stdio server.
+//
+// This is what makes `faceless login` work for an AGENT, not just a human with a key to paste:
+// dynamic client registration (RFC 7591), the authorization-code + PKCE flow with the redirect
+// caught on a loopback listener (RFC 8252), and refresh-token rotation handled transparently on
+// every subsequent request. The only human moment is approving the consent screen.
+//
+// The server side of all of this lives in the main app (src/pages/api/oauth2/*); this file is a
+// client of the same documents any third-party agent would read.
+
+const LOOPBACK_PORT = 8976;
+const REDIRECT_URI = `http://127.0.0.1:${LOOPBACK_PORT}/callback`;
+/** Refresh this many ms before expiry, so a token cannot die mid-request. */
+const EXPIRY_SKEW_MS = 60 * 1000;
+
+/** https://faceless.so/api/v1 -> https://faceless.so (where the oauth2 + well-known routes live). */
+export const siteBaseFrom = (apiBaseUrl) =>
+	String(apiBaseUrl || "")
+		.replace(/\/+$/, "")
+		.replace(/\/api\/v1$/, "");
+
+export function generatePkce() {
+	const verifier = crypto.randomBytes(32).toString("base64url");
+	const challenge = crypto.createHash("sha256").update(verifier, "ascii").digest("base64url");
+	return { verifier, challenge };
+}
+
+async function postJson(url, body) {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+	});
+	let payload = null;
+	try {
+		payload = await response.json();
+	} catch {
+		payload = null;
+	}
+	return { status: response.status, payload };
+}
+
+/** Register (or reuse) this machine's public client. One client per config file is plenty. */
+async function ensureClient(site) {
+	const config = loadConfig();
+	if (config.oauthClientId) return config.oauthClientId;
+	const { status, payload } = await postJson(`${site}/api/oauth2/register`, {
+		client_name: `faceless-cli (${process.env.USER || process.env.USERNAME || "user"})`,
+		redirect_uris: [REDIRECT_URI],
+	});
+	if (status !== 201 || !payload?.client_id) {
+		throw new CliError("server_error", `OAuth client registration failed (${status}): ${payload?.error_description || "unknown error"}`);
+	}
+	saveConfig({ oauthClientId: payload.client_id });
+	return payload.client_id;
+}
+
+/** Every scope the server publishes; the consent screen is where the user narrows it. */
+async function allScopes(site) {
+	try {
+		const response = await fetch(`${site}/.well-known/oauth-protected-resource`);
+		const metadata = await response.json();
+		if (Array.isArray(metadata?.scopes_supported) && metadata.scopes_supported.length) return metadata.scopes_supported.join(" ");
+	} catch {
+		/* fall through */
+	}
+	return ""; // absent scope -> server's read-only default
+}
+
+/**
+ * The page the loopback listener serves after the consent redirect.
+ *
+ * Three rules, each learned from the first version being wrong:
+ *  - It must not claim success before it is true. "Logged in" was sent before the error/state
+ *    params were even read, so DENYING consent still showed "Logged in", and even a real approval
+ *    has only produced a code at this point - the exchange can still fail in the terminal.
+ *  - It must scrub itself from history. The redirect lands with ?code=... in the URL, and the
+ *    browser stores that in history/autocomplete; history.replaceState drops the query so a
+ *    credential-bearing URL is never retained. The code is never echoed into the HTML either.
+ *  - It should look like ours. A bare unstyled heading at a raw IP reads as broken or phishy.
+ */
+export const callbackHtml = ({ ok, detail = "", site = "https://faceless.so" }) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Faceless CLI</title>
+<meta name="robots" content="noindex" />
+<script>history.replaceState(null, "", "/callback");</script>
+<style>
+  /* The consent page's visual shell (src/pages/oauth2/authorize.jsx, which itself mirrors /login),
+     replicated with the app's real tokens because this page is served from the CLI's loopback
+     listener where Tailwind and React do not exist: #060607 canvas, orbiting-star canvas at half
+     opacity, two blurred glow orbs (primary-600 / info-500), the .fa-grain noise overlay, the
+     top-left logo, and the #0A0A0D hairline card. This page renders one second after the consent
+     screen; any style break between them reads as leaving the product. */
+  * { box-sizing: border-box; }
+  body { margin: 0; min-height: 100vh; background: #060607; color: #fff;
+         font: 16px/1.6 Inter, -apple-system, "Segoe UI", Roboto, sans-serif; }
+  .ambient { position: fixed; inset: 0; pointer-events: none; overflow: hidden; }
+  .stars { position: absolute; inset: 0; opacity: 0.5; }
+  .orb-a { position: absolute; top: -160px; right: 8%; width: 480px; height: 480px;
+           border-radius: 50%; background: rgba(127, 20, 255, 0.08); filter: blur(160px); }
+  .orb-b { position: absolute; bottom: -10%; left: -6%; width: 420px; height: 420px;
+           border-radius: 50%; background: rgba(48, 180, 255, 0.04); filter: blur(130px); }
+  .grain { position: absolute; inset: 0; opacity: 0.04;
+           background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='140' height='140'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='3' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='140' height='140' filter='url(%23n)'/%3E%3C/svg%3E"); }
+  .logo { position: absolute; left: 2.5rem; top: 2rem; z-index: 10; }
+  .logo img { display: block; width: 120px; height: auto; }
+  .shell { position: relative; z-index: 10; min-height: 100vh; display: flex;
+           align-items: center; justify-content: center; padding: 2.5rem 1rem; }
+  .card { position: relative; overflow: hidden; width: 100%; max-width: 420px; padding: 1.5rem 1.25rem;
+          background: #0A0A0D; border: 1px solid rgba(255, 255, 255, 0.08); border-radius: 1.5rem; }
+  .hairline { pointer-events: none; position: absolute; left: 2.5rem; right: 2.5rem; top: 0; height: 1px;
+              background: linear-gradient(to right, transparent, rgba(255, 255, 255, 0.2), transparent); }
+  h1 { margin: 0 0 0.35rem; font-size: 22px; font-weight: 600; letter-spacing: -0.01em; color: #fff; }
+  .fail h1 { color: #f87171; }
+  p { margin: 0; font-size: 13px; line-height: 1.55; color: #AEAEB2; }
+  .hint { margin-top: 1rem; font-size: 12px; color: #8E8E93; }
+</style>
+</head>
+<body>
+<div class="ambient" aria-hidden="true">
+  <canvas class="stars" id="stars"></canvas>
+  <div class="orb-a"></div>
+  <div class="orb-b"></div>
+  <div class="grain"></div>
+</div>
+<div class="logo"><img src="${site}/faceless-logo.png" alt="Faceless" /></div>
+<div class="shell">
+  <main class="card ${ok ? "" : "fail"}">
+    <div class="hairline"></div>
+    <h1>${ok ? "Authorization received" : "Authorization failed"}</h1>
+    <p>${ok ? "You can close this tab. The login finishes in your terminal." : `${detail} See your terminal for details.`}</p>
+    <p class="hint">${ok ? "This window holds no credentials and is safe to close." : "You can retry with `faceless login`."}</p>
+  </main>
+</div>
+<script>
+  // Compact port of the consent page's StarryBackground: stars slowly orbiting a centre point.
+  (function () {
+    var canvas = document.getElementById("stars");
+    var ctx = canvas.getContext("2d");
+    canvas.width = window.innerWidth;
+    canvas.height = window.innerHeight;
+    var cx = canvas.width / 2, cy = canvas.height / 2;
+    var stars = [];
+    for (var i = 0; i < 140; i++) {
+      stars.push({
+        radius: Math.random() * 1.5,
+        angle: Math.random() * Math.PI * 2,
+        orbit: Math.random() * (canvas.width / 2) + 100,
+        speed: Math.random() * 0.001 + 0.0005,
+      });
+    }
+    (function animate() {
+      ctx.clearRect(0, 0, canvas.width, canvas.height);
+      ctx.fillStyle = "#fff";
+      for (var j = 0; j < stars.length; j++) {
+        var s = stars[j];
+        s.angle += s.speed;
+        var x = cx + Math.cos(s.angle) * s.orbit;
+        var y = cy + Math.sin(s.angle) * s.orbit;
+        ctx.globalAlpha = 0.9 - Math.min(0.7, s.orbit / canvas.width);
+        ctx.beginPath();
+        ctx.arc(x, y, s.radius, 0, Math.PI * 2);
+        ctx.fill();
+      }
+      ctx.globalAlpha = 1;
+      requestAnimationFrame(animate);
+    })();
+  })();
+</script>
+</body>
+</html>`;
+
+const openBrowser = (url) => {
+	const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+	execFile(command, [url], () => {});
+};
+
+/**
+ * The interactive login: registers a client, opens the consent screen, catches the redirect on a
+ * loopback listener, exchanges the code, and returns the token set. Writes nothing itself beyond
+ * the client id - the caller decides how to store the tokens.
+ */
+export async function loginWithOAuth({ baseUrl, log = () => {} }) {
+	const site = siteBaseFrom(baseUrl);
+	const clientId = await ensureClient(site);
+	const { verifier, challenge } = generatePkce();
+	const state = crypto.randomBytes(8).toString("base64url");
+	const scope = await allScopes(site);
+
+	const authorizeUrl =
+		`${site}/oauth2/authorize?response_type=code&client_id=${clientId}` +
+		`&redirect_uri=${encodeURIComponent(REDIRECT_URI)}${scope ? `&scope=${encodeURIComponent(scope)}` : ""}` +
+		`&state=${state}&code_challenge=${challenge}&code_challenge_method=S256`;
+
+	log(`Opening your browser to authorize this machine...\n  ${authorizeUrl}\n`);
+	openBrowser(authorizeUrl);
+
+	const code = await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			server.close();
+			reject(new CliError("timeout", "Timed out after 5 minutes waiting for browser approval."));
+		}, 300000);
+		const server = http.createServer((req, res) => {
+			const url = new URL(req.url, `http://127.0.0.1:${LOOPBACK_PORT}`);
+			if (url.pathname !== "/callback") {
+				res.writeHead(404).end();
+				return;
+			}
+			// Validate BEFORE responding, so the page tells the truth: the first version sent
+			// "Logged in" unconditionally, including when the user had just clicked Deny.
+			const errorParam = url.searchParams.get("error");
+			const stateOk = url.searchParams.get("state") === state;
+			const code = url.searchParams.get("code");
+			const ok = stateOk && !errorParam && Boolean(code);
+			const detail = !stateOk
+				? "The redirect did not match this login attempt."
+				: errorParam === "access_denied"
+					? "You denied the request."
+					: errorParam
+						? `The server rejected the request (${errorParam}).`
+						: "No authorization code arrived.";
+			res.writeHead(ok ? 200 : 400, {
+				"Content-Type": "text/html; charset=utf-8",
+				// The redirect URL carried a credential (the code); nothing about it may be cached.
+				"Cache-Control": "no-store",
+				"Referrer-Policy": "no-referrer",
+			});
+			res.end(callbackHtml({ ok, detail, site }));
+			clearTimeout(timer);
+			server.close();
+			if (!stateOk) return reject(new CliError("unauthorized", "State mismatch in OAuth redirect."));
+			if (errorParam)
+				return reject(new CliError("unauthorized", `Authorization was ${errorParam === "access_denied" ? "denied" : `rejected: ${errorParam}`}.`));
+			if (!code) return reject(new CliError("unauthorized", "Redirect arrived without an authorization code."));
+			resolve(code);
+		});
+		server.on("error", (err) => {
+			clearTimeout(timer);
+			reject(
+				err?.code === "EADDRINUSE"
+					? new CliError("server_error", `Port ${LOOPBACK_PORT} is in use; free it and retry.`)
+					: new CliError("server_error", `Loopback listener failed: ${err.message}`)
+			);
+		});
+		server.listen(LOOPBACK_PORT, "127.0.0.1");
+	});
+
+	const { status, payload } = await postJson(`${site}/api/oauth2/token`, {
+		grant_type: "authorization_code",
+		code,
+		redirect_uri: REDIRECT_URI,
+		client_id: clientId,
+		code_verifier: verifier,
+	});
+	if (status !== 200 || !payload?.access_token) {
+		throw new CliError("server_error", `Token exchange failed (${status}): ${payload?.error_description || payload?.error || "unknown"}`);
+	}
+	return tokenSetFrom(payload, site, clientId);
+}
+
+const tokenSetFrom = (payload, site, clientId) => ({
+	site,
+	clientId,
+	accessToken: payload.access_token,
+	refreshToken: payload.refresh_token,
+	scope: payload.scope,
+	expiresAt: Date.now() + (Number(payload.expires_in) || 3600) * 1000,
+});
+
+/**
+ * A valid access token from the stored OAuth session, refreshing (and persisting the rotated pair)
+ * when it is near expiry. Returns null when there is no OAuth session at all; throws when the
+ * session existed but is dead (family revoked, refresh expired) so the caller can say "log in
+ * again" instead of a bare 401.
+ */
+export async function ensureOauthAccessToken() {
+	const config = loadConfig();
+	const session = config.oauth;
+	if (!session?.refreshToken) return null;
+
+	if (session.accessToken && Date.now() < Number(session.expiresAt || 0) - EXPIRY_SKEW_MS) {
+		return session.accessToken;
+	}
+
+	const { status, payload } = await postJson(`${session.site}/api/oauth2/token`, {
+		grant_type: "refresh_token",
+		refresh_token: session.refreshToken,
+		client_id: session.clientId,
+	});
+	if (status !== 200 || !payload?.access_token) {
+		// Rotation means a dead refresh token is unrecoverable; clear it so the next error is honest.
+		saveConfig({ oauth: undefined });
+		throw new CliError("unauthorized", 'Your OAuth session has expired or was revoked. Run "faceless login" again.');
+	}
+	const rotated = tokenSetFrom(payload, session.site, session.clientId);
+	saveConfig({ oauth: rotated });
+	return rotated.accessToken;
+}