@nema-project/nema 0.0.0-stage → 0.1.3

package/dist/github/client.js

@@ -0,0 +1,383 @@
+import {
+  runHelperFile
+} from "../chunks/chunk-WT3XUFWU.js";
+import {
+  GH_COMMAND_TOOLS,
+  PLUGINS
+} from "../chunks/chunk-HEIQINX3.js";
+
+// github/client.js
+import { execFile, spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+import { readGithubToken } from "../secrets/github.js";
+import { commandSpec, windowsRuntimeEnv } from "../platform.js";
+var GITHUB_ARGS = ["stdio", "--read-only", "--toolsets", "pull_requests,issues"];
+var NOT_INSTALLED = "github-mcp-server \u672A\u5B89\u88C5";
+var STOPPED = "GitHub \u63D2\u4EF6\u5DF2\u505C\u6B62";
+var TIMED_OUT = "GitHub \u63D2\u4EF6\u8C03\u7528\u8D85\u65F6";
+var START_FAILED = "GitHub \u63D2\u4EF6\u542F\u52A8\u5931\u8D25";
+var MAX_TEXT = 65536;
+var CALL_TIMEOUT_MS = 6e4;
+var RETRY_DELAY_MS = 6e4;
+var STATUS_TIMEOUT_MS = 1e4;
+var GITHUB_TOOLS = (PLUGINS.find((plugin) => plugin.id === "github")?.functions ?? []).map((fn) => fn.name.slice("github__".length)).filter((name) => !GH_COMMAND_TOOLS.includes(name));
+var noTool = (tool) => new Error(`GitHub \u63D2\u4EF6\u6CA1\u6709\u5DE5\u5177 ${tool}`);
+function cutUtf8(text, maxBytes) {
+  if (Buffer.byteLength(text) <= maxBytes)
+    return text;
+  let bytes = 0;
+  let index = 0;
+  for (const ch of text) {
+    const size = Buffer.byteLength(ch);
+    if (bytes + size > maxBytes)
+      break;
+    bytes += size;
+    index += ch.length;
+  }
+  return text.slice(0, index);
+}
+var ExactEnvStdioTransport = class {
+  bin;
+  env;
+  cwd;
+  ownedHelpers;
+  child;
+  buffer = new ReadBuffer();
+  closing;
+  spawnedChild;
+  startPromise;
+  closed = false;
+  onclose;
+  onerror;
+  onmessage;
+  constructor(bin, env, cwd, ownedHelpers) {
+    this.bin = bin;
+    this.env = env;
+    this.cwd = cwd;
+    this.ownedHelpers = ownedHelpers;
+  }
+  start() {
+    if (this.ownedHelpers) {
+      this.startPromise = this.startOwned();
+      return this.startPromise;
+    }
+    return new Promise((resolve, reject) => {
+      const command = commandSpec(this.bin, [...GITHUB_ARGS], this.env);
+      const child = spawn(command.bin, command.args, { env: this.env, cwd: this.cwd, stdio: ["pipe", "pipe", "ignore"], shell: false, windowsHide: true });
+      this.child = child;
+      this.spawnedChild = child;
+      let spawned = false;
+      child.on("error", (error) => {
+        if (!spawned)
+          reject(error);
+        else
+          this.onerror?.(error);
+      });
+      child.on("spawn", () => {
+        spawned = true;
+        resolve();
+      });
+      child.on("close", () => {
+        this.child = void 0;
+        this.onclose?.();
+      });
+      child.stdin?.on("error", (error) => this.onerror?.(error));
+      child.stdout?.on("data", (chunk) => this.readMessages(chunk));
+    });
+  }
+  async startOwned() {
+    const command = commandSpec(this.bin, [...GITHUB_ARGS], this.env);
+    const child = await this.ownedHelpers.spawn(command.bin, command.args, {
+      env: this.env,
+      cwd: this.cwd,
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    });
+    if (this.closed) {
+      child.kill("SIGTERM");
+      await child.closed;
+      throw new Error(STOPPED);
+    }
+    this.child = child;
+    this.spawnedChild = child;
+    void child.closed.then(() => {
+      this.child = void 0;
+      this.onclose?.();
+    });
+    child.stdin?.on("error", (error) => this.onerror?.(error));
+    child.stdout?.on("data", (chunk) => this.readMessages(chunk));
+  }
+  readMessages(chunk) {
+    this.buffer.append(chunk);
+    for (; ; ) {
+      let message;
+      try {
+        message = this.buffer.readMessage();
+      } catch (error) {
+        this.onerror?.(error);
+        continue;
+      }
+      if (message === null)
+        break;
+      this.onmessage?.(message);
+    }
+  }
+  send(message) {
+    return new Promise((resolve, reject) => {
+      const stdin = this.child?.stdin;
+      if (!stdin || !stdin.writable) {
+        reject(new Error(STOPPED));
+        return;
+      }
+      if (stdin.write(serializeMessage(message)))
+        resolve();
+      else
+        stdin.once("drain", resolve);
+    });
+  }
+  async close() {
+    if (this.closing)
+      return this.closing;
+    this.closed = true;
+    this.closing = this.closeChild();
+    return this.closing;
+  }
+  async closeChild() {
+    if (this.startPromise)
+      await this.startPromise.catch(() => {
+      });
+    const child = this.spawnedChild;
+    this.child = void 0;
+    this.buffer.clear();
+    if (child && !isChildProcess(child)) {
+      child.kill("SIGTERM");
+      await child.closed;
+      return;
+    }
+    if (child && child.exitCode === null && child.signalCode === null) {
+      await new Promise((resolve) => {
+        let killTimer;
+        const done = () => {
+          if (killTimer)
+            clearTimeout(killTimer);
+          resolve();
+        };
+        child.once("close", done);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        killTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 2e3);
+        killTimer.unref();
+      });
+    }
+  }
+};
+function isChildProcess(child) {
+  return "exitCode" in child;
+}
+var GithubMcp = class {
+  opts;
+  conn = null;
+  starting = null;
+  startError = null;
+  closed = false;
+  closing;
+  startingTransport;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get bin() {
+    return this.opts.bin || "github-mcp-server";
+  }
+  homeDir() {
+    const dir = path.join(this.opts.nemaHome, "run", "github", "home");
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    return dir;
+  }
+  basePath() {
+    return this.opts.spawnEnv?.PATH ?? process.env.PATH ?? "";
+  }
+  warn(message) {
+    (this.opts.warn ?? ((m) => console.warn(m)))(message);
+  }
+  /** `installed`: the binary runs. `loggedIn`: the token file is readable. Never starts the server. */
+  async status() {
+    let loggedIn = true;
+    let tokenDetail = "";
+    try {
+      readGithubToken(this.opts.nemaHome);
+    } catch (e) {
+      loggedIn = false;
+      tokenDetail = e instanceof Error ? e.message : String(e);
+    }
+    const version = await this.version();
+    if (!version.ok)
+      return { installed: false, loggedIn, detail: version.detail };
+    return { installed: true, loggedIn, detail: loggedIn ? version.detail : tokenDetail };
+  }
+  version() {
+    const home = this.homeDir();
+    const command = commandSpec(this.bin, ["--version"]);
+    if (this.opts.ownedHelpers) {
+      return runHelperFile(command.bin, command.args, {
+        env: { ...windowsRuntimeEnv(process.env), PATH: this.basePath(), HOME: home },
+        cwd: home,
+        timeout: STATUS_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+        encoding: "utf8"
+      }, this.opts.ownedHelpers).then((result) => result.error ? { ok: false, detail: result.error.code === "ENOENT" ? NOT_INSTALLED : START_FAILED } : { ok: true, detail: cutUtf8(result.stdout.toString("utf8").trim(), 200) });
+    }
+    return new Promise((resolve) => {
+      execFile(command.bin, command.args, { env: { ...windowsRuntimeEnv(process.env), PATH: this.basePath(), HOME: home }, cwd: home, timeout: STATUS_TIMEOUT_MS, shell: false, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+        if (error) {
+          resolve({ ok: false, detail: error.code === "ENOENT" ? NOT_INSTALLED : START_FAILED });
+          return;
+        }
+        resolve({ ok: true, detail: cutUtf8(String(stdout).trim(), 200) });
+      });
+    });
+  }
+  /** Calls one fixed read tool and returns its text content, capped at 64 KB. */
+  async call(tool, args) {
+    if (!GITHUB_TOOLS.includes(tool))
+      throw noTool(tool);
+    if (this.closed)
+      throw new Error(STOPPED);
+    const conn = await this.ensure();
+    if (!conn.tools.has(tool))
+      throw noTool(tool);
+    let result;
+    try {
+      result = await Promise.race([
+        conn.client.callTool({ name: tool, arguments: args }, void 0, {
+          timeout: this.opts.timeoutMs ?? CALL_TIMEOUT_MS
+        }),
+        conn.stopped
+      ]);
+    } catch (e) {
+      if (!conn.alive)
+        throw new Error(STOPPED);
+      const message = e instanceof Error ? e.message : String(e);
+      if (/timed out|timeout/i.test(message))
+        throw new Error(TIMED_OUT);
+      throw new Error(`GitHub \u63D2\u4EF6\u8C03\u7528\u5931\u8D25\uFF1A${cutUtf8(message, 2e3)}`);
+    }
+    const content = Array.isArray(result.content) ? result.content : [];
+    const text = content.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n");
+    if (result.isError)
+      throw new Error(`GitHub\uFF1A${cutUtf8(text, 2e3)}`);
+    return cutUtf8(text, MAX_TEXT);
+  }
+  async ensure() {
+    if (this.conn?.alive)
+      return this.conn;
+    const token = readGithubToken(this.opts.nemaHome);
+    if (this.startError && Date.now() < this.startError.until)
+      throw new Error(this.startError.message);
+    if (!this.starting) {
+      this.starting = this.start(token).then((conn) => {
+        this.starting = null;
+        this.startError = null;
+        this.conn = conn;
+        return conn;
+      }, (error) => {
+        this.starting = null;
+        const message = error instanceof Error ? error.message : String(error);
+        this.startError = { message, until: Date.now() + (this.opts.retryDelayMs ?? RETRY_DELAY_MS) };
+        throw new Error(message);
+      });
+    }
+    return this.starting;
+  }
+  async start(token) {
+    if (this.closed)
+      throw new Error(STOPPED);
+    const home = this.homeDir();
+    const transport = new ExactEnvStdioTransport(this.bin, { ...windowsRuntimeEnv(process.env), PATH: this.basePath(), HOME: home, GITHUB_PERSONAL_ACCESS_TOKEN: token }, home, this.opts.ownedHelpers);
+    this.startingTransport = transport;
+    const client = new Client({ name: "nema-daemon", version: "0.1.0" });
+    let markStopped = () => {
+    };
+    const stopped = new Promise((_, reject) => {
+      markStopped = reject;
+    });
+    stopped.catch(() => {
+    });
+    const conn = { client, transport, tools: /* @__PURE__ */ new Set(), alive: true, stopped };
+    client.onclose = () => {
+      conn.alive = false;
+      if (this.conn === conn)
+        this.conn = null;
+      markStopped(new Error(STOPPED));
+    };
+    client.onerror = () => {
+    };
+    try {
+      await client.connect(transport, { timeout: this.opts.timeoutMs ?? CALL_TIMEOUT_MS });
+      const listed = await client.listTools(void 0, { timeout: this.opts.timeoutMs ?? CALL_TIMEOUT_MS });
+      const offered = new Set(listed.tools.map((item) => item.name));
+      for (const tool of GITHUB_TOOLS) {
+        if (offered.has(tool))
+          conn.tools.add(tool);
+        else
+          this.warn(`[nema] github-mcp-server \u6CA1\u6709\u5DE5\u5177 ${tool}\uFF0C\u5DF2\u8DF3\u8FC7`);
+      }
+    } catch (e) {
+      conn.alive = false;
+      await transport.close().catch(() => {
+      });
+      if (this.startingTransport === transport)
+        this.startingTransport = void 0;
+      if (this.closed)
+        throw new Error(STOPPED);
+      if (e.code === "ENOENT")
+        throw new Error(NOT_INSTALLED);
+      throw new Error(START_FAILED);
+    }
+    if (this.closed) {
+      conn.alive = false;
+      await transport.close().catch(() => {
+      });
+      if (this.startingTransport === transport)
+        this.startingTransport = void 0;
+      throw new Error(STOPPED);
+    }
+    if (this.startingTransport === transport)
+      this.startingTransport = void 0;
+    return conn;
+  }
+  close() {
+    if (this.closing)
+      return this.closing;
+    this.closed = true;
+    const conn = this.conn;
+    this.conn = null;
+    if (conn) {
+      conn.alive = false;
+      conn.client.onclose?.();
+    }
+    const starting = this.starting;
+    this.closing = Promise.all([
+      conn?.transport.close() ?? Promise.resolve(),
+      this.startingTransport?.close() ?? Promise.resolve(),
+      starting?.then((pending) => pending.transport.close(), () => {
+      }) ?? Promise.resolve()
+    ]).then(() => {
+    });
+    return this.closing;
+  }
+};
+export {
+  GITHUB_ARGS,
+  GITHUB_TOOLS,
+  GithubMcp
+};

package/dist/github/gh.d.ts

@@ -0,0 +1,56 @@
+import type { OwnedHelperScope } from "@nema/shared/ownedHelper";
+export type GithubStatus = {
+    installed: boolean;
+    loggedIn: boolean;
+    detail: string;
+};
+export interface GithubReader {
+    call(tool: string, args: object): Promise<unknown>;
+    status(): Promise<GithubStatus>;
+    close(): Promise<void>;
+}
+export type GithubRequest = {
+    kind: "rest";
+    endpoint: string;
+    fields: Record<string, string>;
+    accept?: string;
+} | {
+    kind: "graphql";
+    query: string;
+    variables: Record<string, unknown>;
+} | {
+    kind: "pr_status";
+    owner: string;
+    repo: string;
+    number: number;
+    fields: Record<string, string>;
+} | {
+    kind: "check_runs";
+    owner: string;
+    repo: string;
+    number: number;
+    fields: Record<string, string>;
+};
+/** Translate the six declared GitHub tools into reviewed, fixed read-only API requests. */
+export declare function githubApiRequest(tool: string, input: object): GithubRequest;
+export type GithubGhOptions = {
+    bin?: string;
+    env?: NodeJS.ProcessEnv;
+    ownedHelpers?: OwnedHelperScope;
+    timeoutMs?: number;
+};
+export declare class GithubGh implements GithubReader {
+    private readonly options;
+    private readonly abort;
+    private closed;
+    private readonly pending;
+    constructor(options?: GithubGhOptions);
+    private get bin();
+    private get env();
+    private execute;
+    /** `github__gh_read` / `github__gh_write`: the hub already scoped the call; the table is applied again here. */
+    private command;
+    call(tool: string, args: object): Promise<unknown>;
+    status(): Promise<GithubStatus>;
+    close(): Promise<void>;
+}