syncstaff-mcp 0.2.3

package/dist/mcp/login.js

@@ -0,0 +1,169 @@
+import { hostname } from "node:os";
+import { repoRoot } from "../lib/agent-state.js";
+import { loadClientConfig, saveClientConfig, } from "../lib/client-config.js";
+import { adapterRequestHeaders } from "../lib/version.js";
+function option(args, name) {
+    const exact = `--${name}`;
+    const index = args.indexOf(exact);
+    if (index !== -1)
+        return args[index + 1];
+    const prefix = `${exact}=`;
+    return args.find((value) => value.startsWith(prefix))?.slice(prefix.length);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Where Keel is, when nobody said.
+ *
+ * This used to be `http://localhost:7377`, which is right for one developer
+ * running a server on their own machine and wrong for everyone else — and
+ * "everyone else" is who runs this command. They got a connection refused
+ * against a host they never chose, which reads as "Keel is down" rather than
+ * "you didn't say where Keel is".
+ *
+ * A hosted default is the honest one for a package whose whole purpose is
+ * connecting to a hosted server. Override with `--server` or `KEEL_URL`;
+ * self-hosters set it once at login and it is remembered in
+ * `.keel/config.json` thereafter.
+ */
+export const DEFAULT_KEEL_SERVER = "https://openclaw212onubuntu-s-2vcpu-4gb-amd-nyc3-01.taild4ce34.ts.net";
+function normalizeServer(value) {
+    let server;
+    try {
+        server = new URL(value.trim());
+    }
+    catch {
+        throw new Error("keel login: --server must be an absolute HTTP(S) URL");
+    }
+    if (!["http:", "https:"].includes(server.protocol) ||
+        server.username ||
+        server.password ||
+        server.search ||
+        server.hash) {
+        throw new Error("keel login: --server must be an HTTP(S) URL without credentials, a query, or a fragment");
+    }
+    return server.toString().replace(/\/+$/, "");
+}
+function apiError(method, path, status, body) {
+    const detail = typeof body.error === "string" ? body.error : JSON.stringify(body);
+    return new Error(`${method} ${path} -> ${status}: ${detail}`);
+}
+/** Run the interactive device login used by both the public `keel` bin and the local hook CLI. */
+export async function runLogin(args, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const root = repoRoot(cwd);
+    const env = deps.env ?? process.env;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const write = deps.write ?? ((message) => process.stdout.write(`${message}\n`));
+    const wait = deps.wait ?? sleep;
+    const existing = loadClientConfig(root);
+    const chosenServer = option(args, "server") ?? env.KEEL_URL ?? env.CHARTER_URL ?? existing?.server;
+    // Keep the localhost fallback so a developer running a local server still
+    // needs no flags — but remember that nobody asked for it.
+    //
+    // Whoever set this project up has a `.keel/config.json` with the real
+    // server in it, so they never reach this line. The next person to clone
+    // does, gets ECONNREFUSED against a host they never chose, and reads it as
+    // "Keel is down". Three lines below, `--project` refuses to guess at all;
+    // there is no principled reason these two behave differently, and the
+    // asymmetry is invisible to everyone who already has a config.
+    const serverWasDefaulted = !chosenServer;
+    const server = normalizeServer(chosenServer ?? DEFAULT_KEEL_SERVER);
+    const project = option(args, "project") ?? env.KEEL_PROJECT ?? env.CHARTER_PROJECT ?? existing?.project;
+    if (!project?.trim()) {
+        throw new Error("keel login: --project <id|name> (or KEEL_PROJECT) is required");
+    }
+    const vendor = option(args, "vendor") ?? env.KEEL_VENDOR ?? env.CHARTER_VENDOR ?? existing?.vendor ?? "other";
+    const clientName = option(args, "name") ?? `${vendor} on ${hostname()}`;
+    const request = async (path, body) => {
+        const response = await fetchImpl(`${server}${path}`, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...adapterRequestHeaders() },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10_000),
+        });
+        return {
+            status: response.status,
+            body: (await response.json().catch(() => ({}))),
+        };
+    };
+    /** Append the "you never chose this server" hint to any first-contact failure. */
+    const withServerHint = (error) => {
+        if (!serverWasDefaulted)
+            return error;
+        error.message +=
+            `\n\nNo --server was given, so this defaulted to ${server}.` +
+                `\nIf you meant a hosted Keel, pass --server <url> or set KEEL_URL.`;
+        return error;
+    };
+    let issued;
+    try {
+        issued = await request("/auth/device/code", {
+            project: project.trim(),
+            client_name: clientName,
+        });
+    }
+    catch (error) {
+        // A connection refusal never reaches the status check below, and is
+        // exactly the case the hint exists for.
+        throw withServerHint(error instanceof Error ? error : new Error(String(error)));
+    }
+    if (issued.status !== 201) {
+        throw withServerHint(apiError("POST", "/auth/device/code", issued.status, issued.body));
+    }
+    if (typeof issued.body.device_code !== "string" ||
+        typeof issued.body.user_code !== "string" ||
+        typeof issued.body.verification_uri_complete !== "string") {
+        throw new Error("keel login: server returned an invalid device authorization response");
+    }
+    const verificationUrl = new URL(issued.body.verification_uri_complete, `${server}/`).toString();
+    write(`Open this link in your browser:\n${verificationUrl}`);
+    write(`Code: ${issued.body.user_code}`);
+    write("Waiting for approval…");
+    const expiresAt = typeof issued.body.expires_at === "string"
+        ? Date.parse(issued.body.expires_at)
+        : Date.now() + Number(issued.body.expires_in_seconds ?? 600) * 1000;
+    if (!Number.isFinite(expiresAt)) {
+        throw new Error("keel login: server returned an invalid device authorization expiry");
+    }
+    const initialInterval = Number(issued.body.interval_seconds ?? 2);
+    let intervalSeconds = Number.isFinite(initialInterval) ? Math.max(0, initialInterval) : 2;
+    while (Date.now() < expiresAt) {
+        await wait(intervalSeconds * 1000);
+        const polled = await request("/auth/device/token", {
+            device_code: issued.body.device_code,
+        });
+        if (polled.status === 202 && polled.body.status === "authorization_pending") {
+            const nextInterval = Number(polled.body.interval_seconds ?? intervalSeconds);
+            if (Number.isFinite(nextInterval)) {
+                intervalSeconds = Math.max(intervalSeconds, Math.max(0, nextInterval));
+            }
+            continue;
+        }
+        if (polled.status !== 200) {
+            throw apiError("POST", "/auth/device/token", polled.status, polled.body);
+        }
+        for (const key of ["token", "team_id", "project_id", "project_name"]) {
+            if (typeof polled.body[key] !== "string" || !polled.body[key]) {
+                throw new Error(`keel login: token response omitted ${key}`);
+            }
+        }
+        const config = {
+            version: 1,
+            server,
+            project: polled.body.project_id,
+            token: polled.body.token,
+            vendor,
+        };
+        const configPath = saveClientConfig(root, config);
+        write(`Connected to ${polled.body.project_name}. Credentials saved to ${configPath}.`);
+        return {
+            configPath,
+            projectId: polled.body.project_id,
+            projectName: polled.body.project_name,
+            teamId: polled.body.team_id,
+        };
+    }
+    throw new Error("keel login: device authorization expired before approval");
+}

package/dist/mcp/setup.js

@@ -0,0 +1,90 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { repoRoot } from "../lib/agent-state.js";
+import { DEFAULT_KEEL_SERVER, runLogin } from "./login.js";
+const PACKAGE_VERSION = "0.2.2";
+function option(args, name) {
+    const flag = `--${name}`;
+    const index = args.indexOf(flag);
+    if (index !== -1)
+        return args[index + 1];
+    return args.find((value) => value.startsWith(`${flag}=`))?.slice(flag.length + 1);
+}
+/**
+ * The folder being set up, as a project name the server will accept.
+ *
+ * Server-side names are created verbatim, so normalise here rather than
+ * letting a directory like "My App" become a name nobody can retype.
+ */
+export function defaultProjectName(root) {
+    const base = root.split(/[\\/]/).filter(Boolean).pop() ?? "";
+    return base.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+export function writeMcpConfig(root, packageVersion = PACKAGE_VERSION) {
+    const path = join(root, ".mcp.json");
+    let config = {};
+    if (existsSync(path)) {
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf8"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                config = parsed;
+        }
+        catch {
+            throw new Error(`Syncstaff setup: ${path} exists but is not valid JSON`);
+        }
+    }
+    config.mcpServers = {
+        ...(config.mcpServers && typeof config.mcpServers === "object" ? config.mcpServers : {}),
+        sync: {
+            command: "npx",
+            // The public Syncstaff adapter package. Keep generated client configs on
+            // the canonical product name so fresh installs never expose retired names.
+            args: ["-y", `syncstaff-mcp@${packageVersion}`],
+            // Bounds the adapter's V8 heap so several concurrent agent processes
+            // (one per coding session) don't each grow unbounded on a developer's
+            // machine — tsk_01M1MQ01E1D7JSEHFVE2RCK8DJ. 256MB is generous enough
+            // to avoid GC thrashing during multi-file AST traversal while still
+            // capping the worst case.
+            env: { NODE_OPTIONS: "--max-old-space-size=256" },
+        },
+    };
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    return path;
+}
+export async function runSetup(args, deps = {}) {
+    const root = repoRoot(deps.cwd ?? process.cwd());
+    const env = deps.env ?? process.env;
+    const write = deps.write ?? ((message) => process.stdout.write(`${message}\n`));
+    const rl = createInterface({ input, output });
+    try {
+        const ask = async (label, current) => {
+            const supplied = current.trim();
+            if (supplied)
+                return supplied;
+            return (await rl.question(`${label}: `)).trim();
+        };
+        const server = await ask("Syncstaff server", option(args, "server") ?? env.SYNCSTAFF_URL ?? env.NAIB_URL ?? env.KEEL_URL ?? DEFAULT_KEEL_SERVER);
+        // Default to the directory being set up. Asking someone to name a project
+        // while they are standing inside it is asking them to read it off their
+        // own screen — and the name they invent instead is the one that then has
+        // to match at approval time.
+        const project = await ask("Project id or name", option(args, "project") ?? env.SYNCSTAFF_PROJECT ?? env.NAIB_PROJECT ?? env.KEEL_PROJECT ?? defaultProjectName(root));
+        const vendor = await ask("Agent vendor", option(args, "vendor") ?? env.SYNCSTAFF_VENDOR ?? env.NAIB_VENDOR ?? env.KEEL_VENDOR ?? "other");
+        if (!project)
+            throw new Error("Syncstaff setup: project is required");
+        const result = await runLogin(["--server", server, "--project", project, "--vendor", vendor], {
+            cwd: root,
+            env,
+            write,
+        });
+        const configPath = writeMcpConfig(root);
+        write(`Syncstaff is ready for ${result.projectName}.`);
+        write(`MCP configuration saved to ${configPath}`);
+        write("Restart your coding agent so it loads the Syncstaff MCP server as sync.");
+    }
+    finally {
+        rl.close();
+    }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "syncstaff-mcp",
+  "version": "0.2.3",
+  "description": "MCP adapter for Syncstaff cross-agent coordination",
+  "type": "module",
+  "bin": {
+    "syncstaff-mcp": "dist/mcp/index.js",
+    "syncstaff": "dist/mcp/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm --prefix ../.. run build:mcp-package",
+    "smoke": "node ../../scripts/smoke-mcp-package.mjs",
+    "prepublishOnly": "npm run build && npm run smoke"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/server": "^2.0.0",
+    "zod": "^4.2.0"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jb63126/sync.git",
+    "directory": "keel/packages/mcp"
+  },
+  "keywords": [
+    "syncstaff",
+    "mcp",
+    "model-context-protocol",
+    "multi-agent",
+    "coordination"
+  ]
+}