@nema-project/nema 0.0.0-stage → 0.1.4

package/dist/doctor.js

@@ -0,0 +1,178 @@
+// doctor.js
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { commandSpec } from "./platform.js";
+import { requireSystemGit } from "./systemGit.js";
+import { claudeTokenPath, readClaudeToken } from "./claude/token.js";
+import { checkCodexAuth } from "./codex/isolation.js";
+import { AuthStore, UNUSABLE_FILE_MESSAGE } from "./direct/authStore.js";
+import { readByokKey } from "./direct/byok.js";
+import { readCodexCliTokens } from "./direct/codexLogin.js";
+import { jwtExp } from "./direct/jwt.js";
+import { siwcRefresher } from "./direct/siwc.js";
+import { graphifyInstallStatus } from "./repos/graphify.js";
+import { REPORT_AGENTS, reportHookInstalled } from "./report/install.js";
+import { reportTokenPath } from "./report/token.js";
+import { githubTokenPath, readGithubToken } from "./secrets/github.js";
+var execFileAsync = promisify(execFile);
+function defaultTokenFile(env = process.env) {
+  const raw = env.NEMA_DATA_DIR || path.join(os.homedir(), ".nema", "data");
+  const dir = raw === "~" ? os.homedir() : raw.startsWith("~/") ? path.join(os.homedir(), raw.slice(2)) : raw;
+  return path.join(dir, "daemon-token");
+}
+var msg = (e) => e instanceof Error ? e.message : String(e);
+async function version(bin, args) {
+  const command = commandSpec(bin, args);
+  const { stdout } = await execFileAsync(command.bin, command.args, { timeout: 1e4, windowsHide: true });
+  return stdout.trim().split("\n")[0] ?? "";
+}
+function directLoginCheck(opts) {
+  const name = "\u76F4\u8FDE\u767B\u5F55";
+  const required = opts.adapter === "codex-direct" && (opts.authMode ?? "siwc") !== "byok";
+  if (opts.authMode === "byok")
+    return { name, ok: true, detail: "\u672A\u68C0\u67E5\uFF08authMode=byok \u4F7F\u7528 BYOK key\uFF09" };
+  if ((opts.authMode ?? "siwc") === "compat") {
+    try {
+      const t = readCodexCliTokens(opts.userCodexHome);
+      const tail = t.accountId ? `\uFF0C\u8D26\u53F7 \u2026${t.accountId.slice(-4)}` : "";
+      const exp2 = t.exp === null ? "\u5230\u671F\u65F6\u95F4\u672A\u77E5" : `\u5230\u671F ${new Date(t.exp * 1e3).toISOString()}`;
+      return { name, ok: true, detail: `\u5DF2\u767B\u5F55\uFF08compat\uFF0C\u8BFB\u53D6 Codex \u767B\u5F55${tail}\uFF0C${exp2}\uFF09` };
+    } catch (e) {
+      return { name, ok: !required, detail: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  const { auth, reason } = new AuthStore(opts.nemaHome, siwcRefresher).inspect();
+  if (!auth)
+    return { name, ok: !required, detail: reason === "unusable" ? UNUSABLE_FILE_MESSAGE : "\u672A\u767B\u5F55" };
+  if (auth.tokens.refresh_token === "")
+    return { name, ok: !required, detail: "\u5DF2\u5931\u6548\uFF0C\u8BF7\u8FD0\u884C nema auth login" };
+  const exp = jwtExp(auth.tokens.access_token);
+  return { name, ok: true, detail: `\u5DF2\u767B\u5F55\uFF08${auth.mode}\uFF0C${exp === null ? "\u5230\u671F\u65F6\u95F4\u672A\u77E5" : `\u5230\u671F ${new Date(exp * 1e3).toISOString()}`}\uFF09` };
+}
+var CLAUDE_ONLY = "\u672A\u68C0\u67E5\uFF08\u4EC5 adapter=claude-code \u9700\u8981\uFF09";
+var CLAUDE_MISSING = "\u627E\u4E0D\u5230 claude\u3002\u8BF7\u5148\u5B89\u88C5 Claude Code \u5E76\u628A\u5B83\u653E\u5230 PATH \u4E0A\u3002";
+async function claudeBinaryCheck(opts) {
+  const name = "claude \u53EF\u7528";
+  if (opts.adapter !== "claude-code")
+    return { name, ok: true, detail: CLAUDE_ONLY };
+  try {
+    return { name, ok: true, detail: await version("claude", ["--version"]) };
+  } catch {
+    return { name, ok: false, detail: CLAUDE_MISSING };
+  }
+}
+function claudeTokenCheck(opts) {
+  const name = "Claude Code token";
+  if (opts.adapter !== "claude-code")
+    return { name, ok: true, detail: CLAUDE_ONLY };
+  try {
+    readClaudeToken(opts.nemaHome);
+    return { name, ok: true, detail: `${process.platform === "win32" ? "\u79C1\u6709 Windows ACL" : "\u6743\u9650\u4E3A 0600"}\uFF08${claudeTokenPath(opts.nemaHome)}\uFF09` };
+  } catch (e) {
+    return { name, ok: false, detail: msg(e) };
+  }
+}
+async function graphifyCheck(opts) {
+  const name = "graphify \u53EF\u7528";
+  try {
+    const status = await graphifyInstallStatus(opts.graphify);
+    return { name, ok: true, detail: status.detail };
+  } catch (e) {
+    return { name, ok: true, detail: msg(e) };
+  }
+}
+function byokCheck(opts) {
+  const name = "BYOK";
+  if (opts.adapter !== "codex-direct" || opts.authMode !== "byok") {
+    return { name, ok: true, detail: "\u672A\u542F\u7528\uFF08\u4EC5 authMode=byok \u9700\u8981\uFF09" };
+  }
+  const problems = [];
+  try {
+    readByokKey(opts.nemaHome);
+  } catch (e) {
+    problems.push(msg(e));
+  }
+  if (!opts.model)
+    problems.push("\u672A\u8BBE\u7F6E model\uFF0C\u8BF7\u8FD0\u884C nema config set model <\u540D\u79F0>");
+  return {
+    name,
+    ok: problems.length === 0,
+    detail: problems.length === 0 ? `${process.platform === "win32" ? "key \u4F7F\u7528\u79C1\u6709 Windows ACL" : "key \u6587\u4EF6\u6743\u9650\u4E3A 0600"}\uFF0Cmodel \u5DF2\u8BBE\u7F6E` : problems.join("\uFF1B")
+  };
+}
+var GITHUB_MCP_SERVER_HINT = "https://github.com/github/github-mcp-server/releases";
+async function githubMcpServerCheck(opts) {
+  const name = "github-mcp-server";
+  try {
+    return { name, ok: true, detail: `\u53EF\u7528\uFF1A${await version(opts.githubMcpServerBin ?? "github-mcp-server", ["--version"])}` };
+  } catch {
+    return { name, ok: true, detail: `\u672A\u5B89\u88C5\uFF1A\u8BF7\u4ECE ${GITHUB_MCP_SERVER_HINT} \u4E0B\u8F7D` };
+  }
+}
+function githubTokenCheck(opts) {
+  const name = "GitHub \u4EE4\u724C";
+  if (!existsSync(githubTokenPath(opts.nemaHome)))
+    return { name, ok: true, detail: "\u4E0D\u5B58\u5728\uFF08\u53EF\u8FD0\u884C nema auth github\uFF09" };
+  try {
+    readGithubToken(opts.nemaHome);
+    return { name, ok: true, detail: `\u5B58\u5728\uFF0C${process.platform === "win32" ? "\u79C1\u6709 Windows ACL" : "\u6743\u9650\u4E3A 0600"}\uFF08${githubTokenPath(opts.nemaHome)}\uFF09` };
+  } catch (e) {
+    return { name, ok: true, detail: msg(e) };
+  }
+}
+async function runDoctor(opts) {
+  const checks = [];
+  try {
+    checks.push({ name: "git \u53EF\u7528", ok: true, detail: await requireSystemGit() });
+  } catch (e) {
+    checks.push({ name: "git \u53EF\u7528", ok: false, detail: msg(e) });
+  }
+  const fileRequired = opts.adapter === "codex-direct" && (opts.authMode ?? "siwc") === "compat";
+  try {
+    checks.push({ name: "codex \u53EF\u7528", ok: true, detail: await version(opts.codexBin, ["--version"]) });
+  } catch (e) {
+    checks.push({ name: "codex \u53EF\u7528", ok: true, detail: `\u672A\u5B89\u88C5\uFF08Codex \u5DF2\u6539\u4E3A\u76F4\u8FDE\uFF0C\u4E0D\u542F\u52A8 CLI\uFF09\uFF1A${msg(e)}` });
+  }
+  const auth = checkCodexAuth(opts.userCodexHome);
+  checks.push({
+    name: "Codex \u767B\u5F55\u6587\u4EF6",
+    ok: auth.ok || !fileRequired,
+    detail: auth.ok ? auth.authPath : fileRequired ? auth.error : "\u672A\u627E\u5230\uFF08\u4EC5 authMode=compat \u9700\u8981\uFF09"
+  });
+  checks.push(directLoginCheck(opts));
+  checks.push(byokCheck(opts));
+  const statusUrl = `${opts.hubUrl.replace(/\/+$/, "")}/api/daemon/status`;
+  try {
+    const res = await fetch(statusUrl, { signal: AbortSignal.timeout(3e3) });
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    const body = await res.json();
+    checks.push({ name: "hub \u53EF\u8FBE", ok: true, detail: `${opts.hubUrl}\uFF08daemon ${body.connected ? "\u5DF2\u8FDE\u63A5" : "\u672A\u8FDE\u63A5"}\uFF09` });
+  } catch (e) {
+    checks.push({ name: "hub \u53EF\u8FBE", ok: false, detail: `\u65E0\u6CD5\u8BBF\u95EE ${statusUrl}\uFF1A${msg(e)}\u3002\u8BF7\u5148\u8FD0\u884C npm run dev` });
+  }
+  const hasToken = existsSync(opts.tokenFile);
+  checks.push({
+    name: "daemon token \u6587\u4EF6",
+    ok: hasToken,
+    detail: hasToken ? opts.tokenFile : `\u627E\u4E0D\u5230 ${opts.tokenFile}\u3002\u8BF7\u5148\u542F\u52A8 hub\uFF08\u5B83\u4F1A\u751F\u6210\u8BE5\u6587\u4EF6\uFF09`
+  });
+  checks.push(await claudeBinaryCheck(opts));
+  checks.push(claudeTokenCheck(opts));
+  checks.push(await graphifyCheck(opts));
+  const agentHome = opts.agentHome ?? os.homedir();
+  for (const agent of REPORT_AGENTS) {
+    checks.push({ name: `\u4E0A\u62A5\u94A9\u5B50\uFF1A${agent}`, ok: true, detail: reportHookInstalled(agent, agentHome) ? "\u5DF2\u5B89\u88C5" : "\u672A\u5B89\u88C5" });
+  }
+  checks.push({ name: "\u4E0A\u62A5\u4EE4\u724C", ok: true, detail: existsSync(reportTokenPath(opts.nemaHome)) ? "\u5B58\u5728" : "\u4E0D\u5B58\u5728" });
+  checks.push(await githubMcpServerCheck(opts));
+  checks.push(githubTokenCheck(opts));
+  return checks;
+}
+export {
+  defaultTokenFile,
+  runDoctor
+};

package/dist/extensions/handlers.d.ts

@@ -0,0 +1,2 @@
+import type { RpcRouter } from "../daemon/rpc.js";
+export declare function registerExtensionHandlers(router: RpcRouter, nemaHome: string): void;

package/dist/extensions/handlers.js

@@ -0,0 +1,10 @@
+// extensions/handlers.js
+import path from "node:path";
+import { openExtensionStore } from "./store.js";
+function registerExtensionHandlers(router, nemaHome) {
+  const store = openExtensionStore(path.join(nemaHome, "extensions"));
+  router.register("extensions.list", async () => store.list());
+}
+export {
+  registerExtensionHandlers
+};

package/dist/extensions/store.d.ts

@@ -0,0 +1,11 @@
+import { type ExtensionRecord } from "@nema/shared";
+export type { Availability, ExtensionKind, ExtensionRecord, InstallState, Provision, UseState } from "@nema/shared";
+export { bundledExtensions } from "@nema/shared";
+export declare function openExtensionStore(root: string): {
+    list(): ExtensionRecord[];
+    putManaged(record: ExtensionRecord): void;
+    removeManaged(id: string): void;
+    detach(id: string): void;
+    installManaged(record: ExtensionRecord, stagedDir: string): void;
+    cancelInstall(id: string): void;
+};

package/dist/extensions/store.js

@@ -0,0 +1,132 @@
+import {
+  bundledExtensions
+} from "../chunks/chunk-HEIQINX3.js";
+
+// extensions/store.js
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var ID = /^[a-z][a-z0-9-]{0,63}$/;
+var BUNDLED_IDS = new Set(bundledExtensions().map((row) => row.id));
+function assertId(id) {
+  if (!ID.test(id) || BUNDLED_IDS.has(id))
+    throw new Error(`invalid extension id: ${id}`);
+}
+function indexPath(root) {
+  return path.join(root, "index.json");
+}
+function readExtra(root) {
+  const file = indexPath(root);
+  if (!existsSync(file))
+    return [];
+  const parsed = JSON.parse(readFileSync(file, "utf8"));
+  if (!Array.isArray(parsed))
+    return [];
+  return parsed;
+}
+function writeExtra(root, rows) {
+  mkdirSync(root, { recursive: true });
+  writeFileSync(indexPath(root), JSON.stringify(rows));
+}
+function managedPath(root, id) {
+  const extensions = path.resolve(root, "extensions");
+  const target = path.resolve(extensions, id);
+  if (path.dirname(target) !== extensions)
+    throw new Error("invalid extension id");
+  return { extensions, target };
+}
+function ownedDirectory(root, id) {
+  const { extensions, target } = managedPath(root, id);
+  mkdirSync(extensions, { recursive: true });
+  const realExtensions = realpathSync(extensions);
+  if (!existsSync(target))
+    return target;
+  const stat = lstatSync(target);
+  const real = realpathSync(target);
+  const relative = path.relative(realExtensions, real);
+  const inside = relative === id || relative.startsWith(id + path.sep);
+  if (stat.isSymbolicLink() || !inside)
+    throw new Error("extension directory points outside the managed root");
+  return real;
+}
+function openExtensionStore(root) {
+  return {
+    list() {
+      const extra = readExtra(root).filter((row) => !BUNDLED_IDS.has(row.id));
+      return [...bundledExtensions(), ...extra];
+    },
+    putManaged(record) {
+      assertId(record.id);
+      if (record.provision === "managed") {
+        const target = ownedDirectory(root, record.id);
+        if (!existsSync(target))
+          mkdirSync(target);
+      } else if (record.provision !== "external")
+        throw new Error("bundled extensions are not installed here");
+      const rows = readExtra(root).filter((row) => row.id !== record.id);
+      rows.push(record);
+      writeExtra(root, rows);
+    },
+    removeManaged(id) {
+      const current = readExtra(root).find((row) => row.id === id);
+      if (!current) {
+        if (BUNDLED_IDS.has(id))
+          throw new Error("bundled extensions cannot be removed");
+        throw new Error("extension is not managed");
+      }
+      if (current.provision === "bundled")
+        throw new Error("bundled extensions cannot be removed");
+      if (current.provision !== "managed")
+        throw new Error("extension is not managed");
+      const target = ownedDirectory(root, id);
+      if (existsSync(target))
+        rmSync(target, { recursive: true, force: true });
+      writeExtra(root, readExtra(root).filter((row) => row.id !== id));
+    },
+    detach(id) {
+      const current = readExtra(root).find((row) => row.id === id);
+      if (!current || current.provision !== "external")
+        throw new Error("extension is not external");
+      writeExtra(root, readExtra(root).filter((row) => row.id !== id));
+    },
+    installManaged(record, stagedDir) {
+      assertId(record.id);
+      if (record.provision !== "managed")
+        throw new Error("only a managed extension can be installed");
+      if (!existsSync(stagedDir) || !lstatSync(stagedDir).isDirectory()) {
+        throw new Error("staged extension directory is missing");
+      }
+      const { extensions, target } = managedPath(root, record.id);
+      mkdirSync(extensions, { recursive: true });
+      const incoming = path.join(extensions, `.${record.id}.incoming`);
+      rmSync(incoming, { recursive: true, force: true });
+      try {
+        cpSync(stagedDir, incoming, { recursive: true });
+        if (existsSync(target)) {
+          ownedDirectory(root, record.id);
+          rmSync(target, { recursive: true, force: true });
+        }
+        renameSync(incoming, target);
+      } catch (error) {
+        rmSync(incoming, { recursive: true, force: true });
+        throw error;
+      }
+      const rows = readExtra(root).filter((row) => row.id !== record.id);
+      rows.push({ ...record, provision: "managed", installState: "installed", error: null });
+      writeExtra(root, rows);
+    },
+    cancelInstall(id) {
+      assertId(id);
+      const current = readExtra(root).find((row) => row.id === id);
+      if (!current || current.installState !== "installing")
+        throw new Error("extension is not installing");
+      const target = ownedDirectory(root, id);
+      if (existsSync(target))
+        rmSync(target, { recursive: true, force: true });
+      writeExtra(root, readExtra(root).map((row) => row.id === id ? { ...row, installState: "absent", error: null } : row));
+    }
+  };
+}
+export {
+  bundledExtensions,
+  openExtensionStore
+};

package/dist/github/client.d.ts

@@ -0,0 +1,47 @@
+import type { OwnedHelperScope } from "@nema/shared/ownedHelper";
+export declare const GITHUB_ARGS: readonly ["stdio", "--read-only", "--toolsets", "pull_requests,issues"];
+/**
+ * The fixed tool list this MCP server provides, from the `github` manifest. Nothing else is ever called.
+ * The `gh_read` / `gh_write` command tools run through the `gh` CLI, not this server.
+ */
+export declare const GITHUB_TOOLS: readonly string[];
+export type GithubMcpOpts = {
+    nemaHome: string;
+    /** Defaults to `github-mcp-server` from PATH. */
+    bin?: string;
+    /** Overrides the PATH the child sees; defaults to the daemon's PATH. */
+    spawnEnv?: {
+        PATH?: string;
+    };
+    /** For tests. */
+    timeoutMs?: number;
+    retryDelayMs?: number;
+    warn?: (message: string) => void;
+    ownedHelpers?: OwnedHelperScope;
+};
+export declare class GithubMcp {
+    private readonly opts;
+    private conn;
+    private starting;
+    private startError;
+    private closed;
+    private closing?;
+    private startingTransport?;
+    constructor(opts: GithubMcpOpts);
+    private get bin();
+    private homeDir;
+    private basePath;
+    private warn;
+    /** `installed`: the binary runs. `loggedIn`: the token file is readable. Never starts the server. */
+    status(): Promise<{
+        installed: boolean;
+        loggedIn: boolean;
+        detail: string;
+    }>;
+    private version;
+    /** Calls one fixed read tool and returns its text content, capped at 64 KB. */
+    call(tool: string, args: object): Promise<unknown>;
+    private ensure;
+    private start;
+    close(): Promise<void>;
+}