@nema-project/nema 0.0.0-stage → 0.1.4

package/dist/chunks/chunk-WT3XUFWU.js

@@ -0,0 +1,86 @@
+// ../../../packages/shared/dist/ownedHelper.js
+import { execFile } from "node:child_process";
+async function runHelperFile(command, args, options = {}, scope) {
+  if (!scope) {
+    return new Promise((resolve) => {
+      execFile(command, args, options, (error2, stdout2, stderr2) => {
+        const out2 = Buffer.isBuffer(stdout2) ? stdout2 : Buffer.from(stdout2 ?? "");
+        const err2 = Buffer.isBuffer(stderr2) ? stderr2 : Buffer.from(stderr2 ?? "");
+        const childError = error2;
+        resolve({
+          error: error2 ?? null,
+          stdout: out2,
+          stderr: err2,
+          code: childError && typeof childError.code === "number" ? childError.code : childError ? null : 0,
+          signal: childError?.signal ?? null,
+          timedOut: Boolean(childError?.killed)
+        });
+      });
+    });
+  }
+  const maxBuffer = options.maxBuffer ?? 1024 * 1024;
+  let child;
+  try {
+    child = await scope.spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: [options.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+      windowsHide: true,
+      signal: options.signal
+    });
+  } catch (cause) {
+    const error2 = cause instanceof Error ? cause : new Error(String(cause));
+    const code = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+    return {
+      error: error2,
+      stdout: Buffer.alloc(0),
+      stderr: Buffer.alloc(0),
+      code: typeof code === "number" ? code : null,
+      signal: null,
+      timedOut: false
+    };
+  }
+  const stdout = [];
+  const stderr = [];
+  let outSize = 0;
+  let errSize = 0;
+  let overflow = false;
+  let timedOut = false;
+  const collect = (target, chunk, isOut) => {
+    if (overflow)
+      return;
+    if (isOut)
+      outSize += chunk.length;
+    else
+      errSize += chunk.length;
+    if (outSize + errSize > maxBuffer) {
+      overflow = true;
+      child.kill("SIGTERM");
+      return;
+    }
+    target.push(Buffer.from(chunk));
+  };
+  child.stdout?.on("data", (chunk) => collect(stdout, chunk, true));
+  child.stderr?.on("data", (chunk) => collect(stderr, chunk, false));
+  if (options.input !== void 0 && child.stdin) {
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(options.input);
+  }
+  let timer;
+  if (options.timeout && options.timeout > 0)
+    timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, options.timeout);
+  const closed = await child.closed;
+  if (timer)
+    clearTimeout(timer);
+  const out = Buffer.concat(stdout);
+  const err = Buffer.concat(stderr);
+  const error = overflow ? Object.assign(new Error(`maxBuffer exceeded: ${maxBuffer} bytes`), { code: "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" }) : timedOut ? Object.assign(new Error("Command timed out"), { code: "ETIMEDOUT", killed: true }) : closed.code === 0 ? null : Object.assign(new Error(err.toString("utf8").trim() || `${command} exited ${closed.code ?? closed.signal ?? "unknown"}`), { code: closed.code, signal: closed.signal });
+  return { error, stdout: out, stderr: err, code: closed.code, signal: closed.signal, timedOut };
+}
+
+export {
+  runHelperFile
+};

package/dist/claude/adapter.d.ts

@@ -0,0 +1,19 @@
+import type { TaskAssign, TaskEvent } from "@nema/shared";
+import type { AgentAdapter, AgentResult } from "../daemon/runner.js";
+import type { OwnedHelperScope } from "@nema/shared/ownedHelper";
+export type ClaudeCodeAdapterOptions = {
+    nemaHome: string;
+    cliEntry: string;
+    claudeBin?: string;
+    parentEnv?: NodeJS.ProcessEnv;
+    execPath?: string;
+    timeoutMs?: number;
+    ownedHelpers?: OwnedHelperScope;
+};
+export declare class ClaudeCodeAdapter implements AgentAdapter {
+    private readonly opts;
+    readonly name = "claude-code";
+    constructor(opts: ClaudeCodeAdapterOptions);
+    run(task: TaskAssign, onEvent: (e: TaskEvent) => void, signal?: AbortSignal): Promise<AgentResult>;
+    private execute;
+}

package/dist/claude/adapter.js

@@ -0,0 +1,258 @@
+// claude/adapter.js
+import { spawn, spawnSync } from "node:child_process";
+import { rmSync } from "node:fs";
+import path from "node:path";
+import { commandSpec } from "../platform.js";
+import { configErrorMessage, loadConfig } from "../config.js";
+import { parseClaudeLine, roomToolsOk } from "./events.js";
+import { claudeAllowedToolNames } from "../direct/tools.js";
+import { prepareClaudeLaunch } from "./launch.js";
+import { readClaudeToken } from "./token.js";
+var NOT_FOUND = "\u627E\u4E0D\u5230 claude\u3002\u8BF7\u5148\u5B89\u88C5 Claude Code \u5E76\u628A\u5B83\u653E\u5230 PATH \u4E0A\u3002";
+var START_FAILED = "\u65E0\u6CD5\u542F\u52A8 Claude\u3002";
+var toolLimitMessage = (n) => `Claude \u5DE5\u5177\u8C03\u7528\u8D85\u8FC7 ${n} \u6B21\uFF0C\u4EFB\u52A1\u5DF2\u4E2D\u6B62\u3002`;
+var timedOutMessage = (minutes) => `Claude \u8FD0\u884C\u8D85\u8FC7 ${minutes} \u5206\u949F\uFF0C\u4EFB\u52A1\u5DF2\u4E2D\u6B62\u3002`;
+var NO_INIT = "Claude \u6CA1\u6709\u7ED9\u51FA\u5DE5\u5177\u9762\u5C31\u9000\u51FA\u4E86\u3002";
+var NO_REPLY = "Claude \u6CA1\u6709\u8FD4\u56DE\u56DE\u590D\u3002";
+var RUN_FAILED = "Claude \u8FD0\u884C\u5931\u8D25\uFF0C\u4EFB\u52A1\u5DF2\u4E2D\u6B62\u3002";
+var LOGIN_FAILED = "Claude \u767B\u5F55\u5931\u8D25\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C claude setup-token\uFF0C\u518D\u628A\u4EE4\u724C\u4ECE\u6807\u51C6\u8F93\u5165\u4EA4\u7ED9 nema auth claude\u3002";
+var MAX_TOOL_CALLS = 60;
+var STDERR_CAP = 8 * 1024;
+var AUTH_STDERR = /authentication|not logged in|login|oauth|setup-token|401/i;
+function message(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function userMessage(prompt) {
+  return `${JSON.stringify({
+    type: "user",
+    message: { role: "user", content: [{ type: "text", text: prompt }] }
+  })}
+`;
+}
+var ClaudeCodeAdapter = class {
+  opts;
+  name = "claude-code";
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async run(task, onEvent, signal) {
+    if (signal?.aborted)
+      return { ok: false, error: "Claude \u8FD0\u884C\u5DF2\u4E2D\u6B62\u3002" };
+    let token;
+    try {
+      token = readClaudeToken(this.opts.nemaHome);
+    } catch (e) {
+      return { ok: false, error: message(e) };
+    }
+    let model;
+    try {
+      model = loadConfig(this.opts.nemaHome).model;
+    } catch (e) {
+      return { ok: false, error: configErrorMessage(e) };
+    }
+    let launch;
+    try {
+      launch = prepareClaudeLaunch({
+        nemaHome: this.opts.nemaHome,
+        taskId: task.taskId,
+        hubUrl: task.hubUrl,
+        runToken: task.runToken,
+        token,
+        model,
+        cliEntry: this.opts.cliEntry,
+        execPath: this.opts.execPath ?? process.execPath,
+        parentEnv: this.opts.parentEnv ?? process.env,
+        pluginTools: task.pluginTools,
+        ...task.limits ? { maxTurns: task.limits.maxModelCalls } : {}
+      });
+    } catch (e) {
+      return { ok: false, error: message(e) };
+    }
+    try {
+      return await this.execute(task, launch, onEvent, signal);
+    } finally {
+      rmSync(launch.runDir, { recursive: true, force: true });
+    }
+  }
+  async execute(task, launch, onEvent, signal) {
+    const bin = this.opts.claudeBin ?? "claude";
+    const timeoutMs = task.limits?.timeoutMs ?? this.opts.timeoutMs ?? 6e5;
+    const maxToolCalls = task.limits?.maxToolCalls ?? MAX_TOOL_CALLS;
+    const minutes = task.limits ? Math.round(task.limits.timeoutMs / 6e4) : 10;
+    const allowed = new Set(claudeAllowedToolNames(task.pluginTools));
+    const command = commandSpec(bin, launch.args, launch.env);
+    let child;
+    try {
+      child = this.opts.ownedHelpers ? await this.opts.ownedHelpers.spawn(command.bin, command.args, {
+        cwd: path.join(launch.runDir, "work"),
+        env: launch.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        signal
+      }) : spawn(command.bin, command.args, {
+        cwd: path.join(launch.runDir, "work"),
+        env: launch.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true,
+        windowsHide: true
+      });
+    } catch (error) {
+      if (error.name === "AbortError")
+        return { ok: false, error: "Claude \u8FD0\u884C\u5DF2\u4E2D\u6B62\u3002" };
+      return { ok: false, error: error.code === "ENOENT" ? NOT_FOUND : START_FAILED };
+    }
+    const owned = "closed" in child;
+    const closedPromise = owned ? child.closed : new Promise((resolveClosed) => {
+      child.once("close", (code, closeSignal) => resolveClosed({ code, signal: closeSignal }));
+    });
+    return new Promise((resolve) => {
+      let settled = false;
+      let closed = false;
+      let initOk = false;
+      let initSeen = false;
+      let toolCount = 0;
+      let buf = "";
+      let stderrBuf = "";
+      const killTree = () => {
+        if (owned) {
+          child.kill("SIGKILL");
+          return;
+        }
+        const pid = child.pid;
+        if (pid === void 0 || pid <= 0 || pid === process.pid)
+          return;
+        if (process.platform === "win32") {
+          spawnSync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+          return;
+        }
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch (e) {
+          const code = e.code;
+          if (code !== "ESRCH" && code !== "EPERM")
+            throw e;
+        }
+      };
+      const finish = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", cancel);
+        killTree();
+        if (closed)
+          return resolve(result);
+        void closedPromise.then(() => resolve(result));
+      };
+      const cancel = () => finish({ ok: false, error: "Claude \u8FD0\u884C\u5DF2\u4E2D\u6B62\u3002" });
+      const handle = (line) => {
+        if (settled)
+          return;
+        const ev = parseClaudeLine(line);
+        if (ev.kind === "ignore")
+          return;
+        if (ev.kind === "tools") {
+          const outside = ev.names.find((name) => !allowed.has(name));
+          if (outside !== void 0) {
+            return finish({ ok: false, error: `Claude \u8C03\u7528\u4E86 Room \u4EE5\u5916\u7684\u5DE5\u5177 ${outside}\uFF0C\u4EFB\u52A1\u5DF2\u4E2D\u6B62\u3002` });
+          }
+        }
+        if (ev.kind === "failure")
+          return finish({ ok: false, error: RUN_FAILED });
+        if (ev.kind === "init") {
+          if (initSeen)
+            return;
+          initSeen = true;
+          const check = roomToolsOk(ev.tools, ev.mcpServers, allowed);
+          if (!check.ok)
+            return finish({ ok: false, error: check.error });
+          initOk = true;
+          return;
+        }
+        if (!initOk)
+          return;
+        if (ev.kind === "text")
+          return onEvent({ type: "progress", text: ev.text });
+        if (ev.kind === "tools") {
+          for (const name of ev.names) {
+            toolCount += 1;
+            if (toolCount > maxToolCalls)
+              return finish({ ok: false, error: toolLimitMessage(maxToolCalls) });
+            onEvent({ type: "tool_call", text: name });
+          }
+          return;
+        }
+        finish({ ok: true, reply: ev.text });
+      };
+      const take = (chunk) => {
+        if (settled)
+          return;
+        buf += chunk;
+        let nl;
+        while (!settled && (nl = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          handle(line);
+        }
+      };
+      const timer = setTimeout(() => finish({ ok: false, error: timedOutMessage(minutes) }), timeoutMs);
+      signal?.addEventListener("abort", cancel, { once: true });
+      if (signal?.aborted)
+        cancel();
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
+      if (!owned) {
+        child.on("spawn", () => {
+          if (settled)
+            killTree();
+        });
+        child.on("error", (err) => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", cancel);
+          killTree();
+          resolve({ ok: false, error: err.code === "ENOENT" ? NOT_FOUND : START_FAILED });
+        });
+      }
+      child.stdout?.on("data", take);
+      child.stderr?.on("data", (chunk) => {
+        const room = STDERR_CAP - stderrBuf.length;
+        if (room <= 0)
+          return;
+        stderrBuf += chunk.length > room ? chunk.slice(0, room) : chunk;
+      });
+      child.stdin?.on("error", () => {
+      });
+      const onClose = () => {
+        closed = true;
+        killTree();
+        if (settled)
+          return;
+        if (buf.trim())
+          handle(buf);
+        buf = "";
+        if (!settled) {
+          let error = NO_INIT;
+          if (initOk)
+            error = NO_REPLY;
+          else if (AUTH_STDERR.test(stderrBuf))
+            error = LOGIN_FAILED;
+          finish({ ok: false, error });
+        }
+      };
+      if (owned)
+        void closedPromise.then(onClose);
+      else
+        child.once("close", onClose);
+      try {
+        child.stdin?.end(userMessage(task.prompt));
+      } catch {
+      }
+    });
+  }
+};
+export {
+  ClaudeCodeAdapter
+};

package/dist/claude/events.d.ts

@@ -0,0 +1,29 @@
+export type McpServer = {
+    name: string;
+    status: string | null;
+};
+export type ClaudeLine = {
+    kind: "init";
+    tools: string[] | null;
+    mcpServers: McpServer[] | null;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "tools";
+    names: string[];
+} | {
+    kind: "result";
+    text: string;
+} | {
+    kind: "failure";
+} | {
+    kind: "ignore";
+};
+export declare function parseClaudeLine(line: string): ClaudeLine;
+export declare function roomToolsOk(tools: string[] | null, mcpServers: McpServer[] | null, allowed?: ReadonlySet<string>): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/claude/events.js

@@ -0,0 +1,75 @@
+// claude/events.js
+import { CLAUDE_ROOM_TOOLS } from "./launch.js";
+var FAILURE = "Claude \u7684\u5DE5\u5177\u9762\u65E0\u6CD5\u786E\u8BA4\u4E3A\u53EA\u6709 Room\uFF1A";
+var roomOnly = new Set(CLAUDE_ROOM_TOOLS);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function strings(value) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+    return null;
+  return value;
+}
+function serverList(value) {
+  if (!Array.isArray(value))
+    return null;
+  const servers = [];
+  for (const item of value) {
+    if (!isRecord(item) || typeof item.name !== "string")
+      return null;
+    servers.push({ name: item.name, status: typeof item.status === "string" ? item.status : null });
+  }
+  return servers;
+}
+function parseClaudeLine(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return { kind: "ignore" };
+  }
+  if (!isRecord(value))
+    return { kind: "ignore" };
+  if (value.type === "system" && value.subtype === "init") {
+    return { kind: "init", tools: strings(value.tools), mcpServers: serverList(value.mcp_servers) };
+  }
+  if (value.type === "assistant" && isRecord(value.message) && Array.isArray(value.message.content)) {
+    let text;
+    const names = [];
+    for (const block of value.message.content) {
+      if (!isRecord(block))
+        continue;
+      if (block.type === "tool_use" && typeof block.name === "string") {
+        names.push(block.name);
+        continue;
+      }
+      if (text === void 0 && block.type === "text" && typeof block.text === "string")
+        text = block.text;
+    }
+    if (names.length > 0)
+      return { kind: "tools", names };
+    if (text !== void 0)
+      return { kind: "text", text };
+  }
+  if (value.type === "result") {
+    const subtype = value.subtype;
+    if (value.is_error === true || typeof subtype === "string" && subtype.startsWith("error_")) {
+      return { kind: "failure" };
+    }
+    if (typeof value.result === "string")
+      return { kind: "result", text: value.result };
+  }
+  return { kind: "ignore" };
+}
+function roomToolsOk(tools, mcpServers, allowed = roomOnly) {
+  const toolsOk = tools !== null && tools.every((name) => allowed.has(name)) && CLAUDE_ROOM_TOOLS.every((name) => tools.includes(name));
+  const room = mcpServers?.length === 1 ? mcpServers[0] : void 0;
+  const mcpOk = room?.name === "room" && room.status === "connected";
+  if (toolsOk && mcpOk)
+    return { ok: true };
+  return { ok: false, error: `${FAILURE}${JSON.stringify({ tools, mcpServers })}` };
+}
+export {
+  parseClaudeLine,
+  roomToolsOk
+};

package/dist/claude/launch.d.ts

@@ -0,0 +1,22 @@
+import type { PluginToolSpec } from "@nema/shared";
+export declare const CLAUDE_ROOM_TOOLS: readonly ["mcp__room__list_entries", "mcp__room__read_entry", "mcp__room__upsert_entry", "mcp__room__open_thread"];
+export type ClaudeLaunch = {
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    runDir: string;
+    mcpPath: string;
+};
+export declare function prepareClaudeLaunch(o: {
+    nemaHome: string;
+    taskId: string;
+    hubUrl: string;
+    runToken: string;
+    token: string;
+    model?: string;
+    cliEntry: string;
+    execPath: string;
+    parentEnv: NodeJS.ProcessEnv;
+    pluginTools?: PluginToolSpec[];
+    /** `--max-turns`; defaults to 24. */
+    maxTurns?: number;
+}): ClaudeLaunch;

package/dist/claude/launch.js

@@ -0,0 +1,80 @@
+// claude/launch.js
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { claudeAllowedToolNames } from "../direct/tools.js";
+import { windowsRuntimeEnv } from "../platform.js";
+var CLAUDE_ROOM_TOOLS = [
+  "mcp__room__list_entries",
+  "mcp__room__read_entry",
+  "mcp__room__upsert_entry",
+  "mcp__room__open_thread"
+];
+function prepareClaudeLaunch(o) {
+  if (!/^[A-Za-z0-9_-]+$/.test(o.taskId))
+    throw new Error("unsafe task id");
+  const runDir = path.join(o.nemaHome, "run", o.taskId);
+  const configDir = path.join(runDir, "claude-config");
+  const workDir = path.join(runDir, "work");
+  const mcpPath = path.join(runDir, "mcp.json");
+  rmSync(runDir, { recursive: true, force: true });
+  mkdirSync(configDir, { recursive: true, mode: 448 });
+  mkdirSync(workDir);
+  writeFileSync(mcpPath, JSON.stringify({
+    mcpServers: {
+      room: {
+        command: o.execPath,
+        args: [o.cliEntry, "mcp"],
+        env: { NEMA_HUB_URL: o.hubUrl, NEMA_RUN_TOKEN: o.runToken }
+      }
+    }
+  }), { mode: 384 });
+  const env = windowsRuntimeEnv(o.parentEnv);
+  for (const key of ["PATH", "LANG", "LC_ALL", "TERM"]) {
+    if (o.parentEnv[key] !== void 0)
+      env[key] = o.parentEnv[key];
+  }
+  Object.assign(env, {
+    TMPDIR: tmpdir(),
+    HOME: configDir,
+    CLAUDE_CONFIG_DIR: configDir,
+    CLAUDE_CODE_OAUTH_TOKEN: o.token
+  });
+  if (process.platform === "win32") {
+    env.USERPROFILE = configDir;
+    env.APPDATA = path.join(configDir, "AppData", "Roaming");
+    env.LOCALAPPDATA = path.join(configDir, "AppData", "Local");
+    env.PATH ??= Object.entries(o.parentEnv).find(([key]) => key.toLowerCase() === "path")?.[1];
+    mkdirSync(env.APPDATA, { recursive: true });
+    mkdirSync(env.LOCALAPPDATA, { recursive: true });
+  }
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--input-format",
+    "stream-json",
+    "--verbose",
+    "--strict-mcp-config",
+    "--mcp-config",
+    mcpPath,
+    "--setting-sources",
+    "",
+    // --allowedTools only pre-approves. Without this, init lists Bash, Read, Write and friends.
+    "--tools",
+    "",
+    "--allowedTools",
+    claudeAllowedToolNames(o.pluginTools ?? []).join(","),
+    "--disallowedTools",
+    "AskUserQuestion",
+    "--max-turns",
+    String(o.maxTurns ?? 24)
+  ];
+  if (o.model !== void 0)
+    args.push("--model", o.model);
+  return { args, env, runDir, mcpPath };
+}
+export {
+  CLAUDE_ROOM_TOOLS,
+  prepareClaudeLaunch
+};

package/dist/claude/token.d.ts

@@ -0,0 +1,9 @@
+import type { Out } from "../direct/authCommands.js";
+export declare const claudeTokenPath: (nemaHome: string) => string;
+export declare function saveClaudeToken(nemaHome: string, token: string): void;
+export declare function readClaudeToken(nemaHome: string): string;
+export declare function authClaude(o: {
+    nemaHome: string;
+    out: Out;
+    stdin: NodeJS.ReadableStream;
+}): Promise<number>;

package/dist/claude/token.js

@@ -0,0 +1,87 @@
+// claude/token.js
+import { randomUUID } from "node:crypto";
+import { closeSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { openPrivateFile, privateModeMatches, protectPrivatePath } from "../secrets/permissions.js";
+var INVALID_TOKEN = "token \u5FC5\u987B\u662F\u4E00\u884C\u975E\u7A7A\u6587\u672C";
+var SYMLINK_TOKEN = "Claude Code token \u6587\u4EF6\u662F\u7B26\u53F7\u94FE\u63A5\uFF0C\u5DF2\u62D2\u7EDD\u3002";
+var MISSING_TOKEN = "\u6CA1\u6709 Claude Code token\u3002\u8BF7\u8FD0\u884C claude setup-token\uFF0C\u518D\u628A\u4EE4\u724C\u4ECE\u6807\u51C6\u8F93\u5165\u4EA4\u7ED9 nema auth claude\u3002";
+var TOKEN_MODE = "Claude Code token \u6587\u4EF6\u6743\u9650\u5FC5\u987B\u662F 0600";
+var claudeTokenPath = (nemaHome) => path.join(nemaHome, "claude-code-token");
+function saveClaudeToken(nemaHome, token) {
+  if (token === "" || token.includes("\n") || token.includes("\r"))
+    throw new Error(INVALID_TOKEN);
+  const file = claudeTokenPath(nemaHome);
+  try {
+    if (lstatSync(file).isSymbolicLink())
+      throw new Error(SYMLINK_TOKEN);
+  } catch (e) {
+    if (e.code !== "ENOENT")
+      throw e;
+  }
+  mkdirSync(nemaHome, { recursive: true, mode: 448 });
+  protectPrivatePath(nemaHome, 448);
+  const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  const fd = openSync(tmp, "wx", 384);
+  try {
+    try {
+      writeSync(fd, token);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    protectPrivatePath(tmp, 384);
+    renameSync(tmp, file);
+  } catch (e) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw e;
+  }
+}
+function readClaudeToken(nemaHome) {
+  const file = claudeTokenPath(nemaHome);
+  let fd;
+  try {
+    fd = openPrivateFile(file);
+  } catch (e) {
+    if (e.code === "ENOENT")
+      throw new Error(MISSING_TOKEN);
+    if (e.code === "ELOOP")
+      throw new Error(SYMLINK_TOKEN);
+    throw e;
+  }
+  try {
+    const st = fstatSync(fd);
+    if (!st.isFile() || !privateModeMatches(st))
+      throw new Error(TOKEN_MODE);
+    return readFileSync(fd, "utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+async function authClaude(o) {
+  const lines = createInterface({ input: o.stdin });
+  let token = "";
+  for await (const line of lines) {
+    token = line.trim();
+    break;
+  }
+  lines.close();
+  try {
+    saveClaudeToken(o.nemaHome, token);
+    o.out.log("\u5DF2\u4FDD\u5B58 Claude Code token");
+    return 0;
+  } catch (e) {
+    o.out.error(e instanceof Error ? e.message : String(e));
+    return 1;
+  }
+}
+export {
+  authClaude,
+  claudeTokenPath,
+  readClaudeToken,
+  saveClaudeToken
+};

package/dist/codex/adapter.d.ts

@@ -0,0 +1,17 @@
+import type { TaskAssign, TaskEvent } from "@nema/shared";
+import type { AgentAdapter, AgentResult } from "../daemon/runner.js";
+export type CodexAdapterOptions = {
+    codexBin?: string;
+    nemaHome: string;
+    userCodexHome: string;
+    cliEntry: string;
+    timeoutMs?: number;
+};
+export declare const CONFIDENTIAL_REFUSAL = "codex-cli \u9002\u914D\u5668\u5728\u4FDD\u5BC6 workspace \u4E2D\u88AB\u7981\u7528\uFF08\u9694\u79BB\u672A\u901A\u8FC7\u9A8C\u8BC1\uFF09\u3002\u8BF7\u6539\u7528 codex-direct\uFF1Anema config set adapter codex-direct\uFF0C\u6216\u5728 workspace \u8BBE\u7F6E\u4E2D\u5173\u95ED\u4FDD\u5BC6\u3002";
+export declare class CodexAdapter implements AgentAdapter {
+    private readonly opts;
+    readonly name = "codex-cli";
+    constructor(opts: CodexAdapterOptions);
+    run(task: TaskAssign, onEvent: (e: TaskEvent) => void): Promise<AgentResult>;
+    private exec;
+}