zerno-mcp 0.1.0 → 0.1.1

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.1 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.1
 ```
 
 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.1" }, { capabilities: { tools: {} } });
 function asRecord(value) {
     if (value && typeof value === "object") {
         return value;

package/dist/setup.js

@@ -0,0 +1,256 @@
+import { createServer } from "node:http";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+const DEFAULT_API_URL = "https://zerno.one";
+const PACKAGE_SPEC = "zerno-mcp@0.1.1";
+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 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 localCallback() {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const requestUrl = new URL(req.url || "/", "http://127.0.0.1");
+            if (!requestUrl.pathname.startsWith("/desktop-auth/callback")) {
+                res.writeHead(404).end("Not found");
+                return;
+            }
+            const desktopToken = requestUrl.searchParams.get("desktopToken") || "";
+            const apiBaseUrl = requestUrl.searchParams.get("apiBaseUrl") || undefined;
+            res
+                .writeHead(desktopToken ? 200 : 400, { "Content-Type": "text/html; charset=utf-8" })
+                .end(desktopToken
+                ? "<h1>ZERNO MCP connected</h1><p>You can close this tab and return to the terminal.</p>"
+                : "<h1>ZERNO MCP setup failed</h1><p>Missing login token.</p>");
+            server.close();
+            if (desktopToken) {
+                tokenResolve({ desktopToken, apiBaseUrl });
+            }
+            else {
+                tokenReject(new Error("Browser callback did not include desktopToken"));
+            }
+        });
+        let tokenResolve = () => { };
+        let tokenReject = () => { };
+        const token = new Promise((ok, fail) => {
+            tokenResolve = ok;
+            tokenReject = fail;
+        });
+        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({ url: `http://127.0.0.1:${address.port}/desktop-auth/callback`, token });
+        });
+    });
+}
+async function apiRequest(apiUrl, path, token, init = {}) {
+    const response = await fetch(`${apiUrl.replace(/\/+$/, "")}${path}`, {
+        ...init,
+        headers: {
+            "Content-Type": "application/json",
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+            ...(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 browserLogin(apiUrl) {
+    const callback = await localCallback();
+    const query = new URLSearchParams({
+        redirectUri: callback.url,
+        deviceName: `${hostname()} zerno-mcp setup`,
+        platform: platform(),
+        deviceId: `${hostname()}-${platform()}`,
+    });
+    const authUrl = `${apiUrl.replace(/\/+$/, "")}/api/desktop/auth/browser/start?${query.toString()}`;
+    console.log("Opening ZERNO login in your browser...");
+    console.log(`If it does not open, paste this URL:\n${authUrl}\n`);
+    openBrowser(authUrl);
+    const browserToken = await callback.token;
+    const effectiveApiUrl = browserToken.apiBaseUrl || apiUrl;
+    const verified = await apiRequest(effectiveApiUrl, "/api/desktop/auth/verify-token", null, {
+        method: "POST",
+        body: JSON.stringify({
+            token: browserToken.desktopToken,
+            deviceName: `${hostname()} zerno-mcp setup`,
+            platform: platform(),
+            deviceId: `${hostname()}-${platform()}`,
+        }),
+    });
+    return { apiUrl: effectiveApiUrl, accessToken: verified.accessToken, email: verified.user.email };
+}
+async function selectProject(apiUrl, accessToken, requestedProjectId) {
+    const data = await apiRequest(apiUrl, "/api/desktop/projects", accessToken);
+    if (data.projects.length === 0) {
+        throw new Error("No ZERNO projects found for this account.");
+    }
+    if (requestedProjectId) {
+        const match = data.projects.find((project) => project.id === requestedProjectId || project.slug === requestedProjectId);
+        if (!match)
+            throw new Error(`Project not found: ${requestedProjectId}`);
+        return match;
+    }
+    if (data.projects.length === 1) {
+        console.log(`Using project: ${data.projects[0].name}`);
+        return data.projects[0];
+    }
+    console.log("Choose ZERNO project:");
+    data.projects.forEach((project, index) => {
+        console.log(`${index + 1}. ${project.name}${project.slug ? ` (${project.slug})` : ""}`);
+    });
+    const rl = createInterface({ input, output });
+    try {
+        for (;;) {
+            const answer = await rl.question("Project number: ");
+            const idx = Number(answer.trim());
+            if (Number.isInteger(idx) && idx >= 1 && idx <= data.projects.length) {
+                return data.projects[idx - 1];
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+async function createMcpToken(apiUrl, accessToken, projectId) {
+    const data = await apiRequest(apiUrl, `/api/desktop/projects/${projectId}/mcp-token`, accessToken, { method: "POST" });
+    return data.raw_token;
+}
+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;
+}
+export async function runSetup(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log([
+            "Usage: npx -y zerno-mcp@0.1.1 setup [--api-url https://zerno.one] [--project <id-or-slug>]",
+            "",
+            "Opens browser login, creates a project-scoped MCP token, and writes local",
+            "Codex, Claude Desktop, and OpenCode MCP configs.",
+        ].join("\n"));
+        return;
+    }
+    const apiUrl = argValue(args, "--api-url") || DEFAULT_API_URL;
+    const projectArg = argValue(args, "--project");
+    const auth = await browserLogin(apiUrl);
+    console.log(`Logged in as ${auth.email}`);
+    const project = await selectProject(auth.apiUrl, auth.accessToken, projectArg);
+    const rawToken = await createMcpToken(auth.apiUrl, auth.accessToken, project.id);
+    const env = runtimeEnv(auth.apiUrl, rawToken, project.id);
+    const written = [
+        ["Codex", writeCodex(env)],
+        ["Claude Desktop", writeClaude(env)],
+        ["OpenCode", writeOpenCode(env)],
+    ];
+    console.log(`\nZERNO MCP is configured for project: ${project.name}`);
+    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.1",
   "description": "MCP server connecting OpenCode to ZERNO cloud product brain",
   "type": "module",
   "main": "dist/index.js",