zerno-mcp 0.1.0 → 0.1.2

package/README.md

@@ -4,8 +4,19 @@ Local stdio MCP server for ZERNO code-agent integrations.
 
 ## Usage
 
+Recommended setup:
+
+```bash
+npx -y zerno-mcp@0.1.2 setup
+```
+
+The setup command opens ZERNO in the browser, lets the user choose a project,
+creates the project-scoped MCP token, and writes local agent configs.
+
+Agent runtime:
+
 ```bash
-npx -y zerno-mcp@0.1.0
+npx -y zerno-mcp@0.1.2
 ```
 
 Required environment:

package/dist/index.js

@@ -14,10 +14,15 @@
 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 * as client from "./zerno-client.js";
 import { renderTaskCardHTML, renderTaskListHTML, renderBacklogHealthHTML, renderTaskCardMarkdown, renderTaskListMarkdown, renderBacklogHealthMarkdown, } from "./ui/widgets.js";
 import { renderStrategyBriefHTML, renderStrategyBriefMarkdown, renderAlignmentHTML, renderAlignmentMarkdown, renderProductHealthHTML, renderProductHealthMarkdown, renderWeeklyReviewHTML, renderWeeklyReviewMarkdown, } from "./ui/brain.js";
-const server = new Server({ name: "zerno-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+if (process.argv[2] === "setup") {
+    const { runSetup } = await import("./setup.js");
+    await runSetup(process.argv.slice(3));
+    process.exit(0);
+}
+const client = await import("./zerno-client.js");
+const server = new Server({ name: "zerno-mcp", version: "0.1.2" }, { capabilities: { tools: {} } });
 function asRecord(value) {
     if (value && typeof value === "object") {
         return value;

package/dist/setup.js

@@ -0,0 +1,239 @@
+import { createServer } from "node:http";
+import { spawnSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+const DEFAULT_API_URL = "https://zerno.one";
+const PACKAGE_SPEC = "zerno-mcp@0.1.2";
+const MANAGED_START = "# ZERNO MCP:START";
+const MANAGED_END = "# ZERNO MCP:END";
+function argValue(args, name) {
+    const prefix = `${name}=`;
+    const direct = args.find((arg) => arg.startsWith(prefix));
+    if (direct)
+        return direct.slice(prefix.length);
+    const idx = args.indexOf(name);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+function b64url(input) {
+    return input.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function newOpaque(bytes = 32) {
+    return b64url(randomBytes(bytes));
+}
+function pkceChallenge(verifier) {
+    return b64url(createHash("sha256").update(verifier).digest());
+}
+function openBrowser(url) {
+    const command = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
+    const args = platform() === "win32" ? ["/c", "start", "", url] : [url];
+    spawnSync(command, args, { stdio: "ignore" });
+}
+function callbackServer() {
+    return new Promise((resolve, reject) => {
+        let done = () => { };
+        let fail = () => { };
+        const result = new Promise((ok, bad) => {
+            done = ok;
+            fail = bad;
+        });
+        const server = createServer((req, res) => {
+            const requestUrl = new URL(req.url || "/", "http://127.0.0.1");
+            if (!requestUrl.pathname.startsWith("/zerno-mcp/callback")) {
+                res.writeHead(404).end("Not found");
+                return;
+            }
+            const error = requestUrl.searchParams.get("error") || undefined;
+            const code = requestUrl.searchParams.get("code") || "";
+            const state = requestUrl.searchParams.get("state") || "";
+            const ok = Boolean(code) && !error;
+            res.writeHead(ok ? 200 : 400, { "Content-Type": "text/html; charset=utf-8" }).end(successHtml(ok, error));
+            server.close();
+            if (ok)
+                done({ code, state });
+            else
+                fail(new Error(error || "OAuth callback did not include code"));
+        });
+        server.on("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                reject(new Error("Failed to allocate local callback port"));
+                return;
+            }
+            resolve({ redirectUri: `http://127.0.0.1:${address.port}/zerno-mcp/callback`, result });
+        });
+    });
+}
+function successHtml(ok, error) {
+    const title = ok ? "ZERNO MCP connected" : "ZERNO MCP setup failed";
+    const body = ok
+        ? "You can close this tab and return to the terminal."
+        : `Authorization failed: ${escapeHtml(error || "unknown error")}`;
+    return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${title}</title><style>body{margin:0;min-height:100vh;display:grid;place-items:center;background:#111;color:#f5f5f5;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}.card{width:min(520px,calc(100vw - 32px));border:1px solid #333;border-radius:20px;background:#1b1b1b;padding:32px;box-shadow:0 20px 80px #0008}.mark{width:44px;height:44px;border-radius:14px;background:#9cff00;margin-bottom:20px}h1{font-size:28px;line-height:1.1;margin:0 0 12px}p{color:#bbb;font-size:15px;line-height:1.5;margin:0}</style></head><body><main class="card"><div class="mark"></div><h1>${title}</h1><p>${body}</p></main></body></html>`;
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"]/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[ch] || ch));
+}
+async function apiRequest(apiUrl, path, init = {}) {
+    const response = await fetch(`${apiUrl.replace(/\/+$/, "")}${path}`, {
+        ...init,
+        headers: { "Content-Type": "application/json", ...(init.headers || {}) },
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status}: ${body || response.statusText}`);
+    }
+    return (await response.json());
+}
+async function oauthConnect(apiUrl) {
+    const callback = await callbackServer();
+    const registered = await apiRequest(apiUrl, "/oauth/register", {
+        method: "POST",
+        body: JSON.stringify({
+            client_name: "ZERNO MCP CLI",
+            redirect_uris: [callback.redirectUri],
+            grant_types: ["authorization_code"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+            scope: "mcp",
+        }),
+    });
+    const verifier = newOpaque(48);
+    const state = newOpaque(24);
+    const params = new URLSearchParams({
+        response_type: "code",
+        client_id: registered.client_id,
+        redirect_uri: callback.redirectUri,
+        scope: "mcp",
+        state,
+        code_challenge: pkceChallenge(verifier),
+        code_challenge_method: "S256",
+    });
+    const authUrl = `${apiUrl.replace(/\/+$/, "")}/oauth/authorize?${params.toString()}`;
+    console.log("Opening ZERNO authorization in your browser...");
+    console.log(`If it does not open, paste this URL:\n${authUrl}\n`);
+    openBrowser(authUrl);
+    const result = await callback.result;
+    if (result.state !== state)
+        throw new Error("OAuth state mismatch");
+    const form = new URLSearchParams({
+        grant_type: "authorization_code",
+        code: result.code,
+        redirect_uri: callback.redirectUri,
+        client_id: registered.client_id,
+        code_verifier: verifier,
+    });
+    const token = await apiRequest(apiUrl, "/oauth/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: form.toString(),
+    });
+    return { token: token.access_token, projectId: token.project_id };
+}
+function runtimeEnv(apiUrl, rawToken, projectId) {
+    return { ZERNO_API_URL: apiUrl, ZERNO_API_TOKEN: rawToken, ZERNO_PROJECT_ID: projectId };
+}
+function writeJson(filePath, value) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+function ensureGitignoreLine(line) {
+    const filePath = join(process.cwd(), ".gitignore");
+    const existing = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+    if (existing.split(/\r?\n/).map((item) => item.trim()).includes(line))
+        return;
+    writeFileSync(filePath, `${existing.trimEnd()}\n${line}\n`, "utf8");
+}
+function stripJsonComments(input) {
+    return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function readJson(filePath) {
+    if (!existsSync(filePath))
+        return {};
+    return JSON.parse(stripJsonComments(readFileSync(filePath, "utf8")));
+}
+function quoteToml(value) {
+    return JSON.stringify(value);
+}
+function codexConfigPath() {
+    return join(homedir(), ".codex", "config.toml");
+}
+function claudeConfigPath() {
+    if (platform() === "darwin")
+        return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    if (platform() === "win32")
+        return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+function writeCodex(env) {
+    const filePath = codexConfigPath();
+    const managed = [
+        MANAGED_START,
+        "[mcp_servers.zerno]",
+        'command = "npx"',
+        `args = ["-y", "${PACKAGE_SPEC}"]`,
+        "",
+        "[mcp_servers.zerno.env]",
+        ...Object.entries(env).map(([key, value]) => `${key} = ${quoteToml(value)}`),
+        MANAGED_END,
+        "",
+    ].join("\n");
+    const existing = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+    const pattern = new RegExp(`${MANAGED_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${MANAGED_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "m");
+    const next = pattern.test(existing) ? existing.replace(pattern, managed) : `${existing.trimEnd()}\n\n${managed}`;
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, next, { mode: 0o600 });
+    return filePath;
+}
+function writeClaude(env) {
+    const filePath = claudeConfigPath();
+    const cfg = readJson(filePath);
+    const servers = cfg.mcpServers && typeof cfg.mcpServers === "object" ? cfg.mcpServers : {};
+    servers.zerno = { command: "npx", args: ["-y", PACKAGE_SPEC], env };
+    cfg.mcpServers = servers;
+    writeJson(filePath, cfg);
+    return filePath;
+}
+function writeOpenCode(env) {
+    const filePath = join(process.cwd(), "opencode.jsonc");
+    const cfg = readJson(filePath);
+    const mcp = cfg.mcp && typeof cfg.mcp === "object" ? cfg.mcp : {};
+    mcp.zerno = { type: "local", command: ["npx", "-y", PACKAGE_SPEC], enabled: true, environment: env };
+    cfg.mcp = mcp;
+    writeJson(filePath, cfg);
+    ensureGitignoreLine("opencode.jsonc");
+    return filePath;
+}
+function writeClaudeCode(env) {
+    // Project-scoped Claude Code config: `<cwd>/.mcp.json`. Same shape as
+    // Claude Desktop's `claude_desktop_config.json` (mcpServers map).
+    const filePath = join(process.cwd(), ".mcp.json");
+    const cfg = readJson(filePath);
+    const servers = cfg.mcpServers && typeof cfg.mcpServers === "object" ? cfg.mcpServers : {};
+    servers.zerno = { command: "npx", args: ["-y", PACKAGE_SPEC], env };
+    cfg.mcpServers = servers;
+    writeJson(filePath, cfg);
+    ensureGitignoreLine(".mcp.json");
+    return filePath;
+}
+export async function runSetup(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log([
+            "Usage: npx -y zerno-mcp@0.1.2 setup [--api-url https://zerno.one]",
+            "",
+            "Opens the hosted ZERNO OAuth consent screen, lets the user choose a project,",
+            "and writes local Codex, Claude Desktop, and OpenCode MCP configs.",
+        ].join("\n"));
+        return;
+    }
+    const apiUrl = argValue(args, "--api-url") || DEFAULT_API_URL;
+    const auth = await oauthConnect(apiUrl);
+    const env = runtimeEnv(apiUrl, auth.token, auth.projectId);
+    const written = [["Codex", writeCodex(env)], ["Claude Desktop", writeClaude(env)], ["OpenCode", writeOpenCode(env)]];
+    console.log("\nZERNO MCP is configured.");
+    for (const [client, filePath] of written)
+        console.log(`- ${client}: ${filePath}`);
+    console.log("\nRestart your agent so it reloads MCP servers.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zerno-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "MCP server connecting OpenCode to ZERNO cloud product brain",
   "type": "module",
   "main": "dist/index.js",