@stage5/lumine 0.2.39 → 0.2.41

package/lib/agent/mcp-server.js

@@ -0,0 +1,138 @@
+import readline from "node:readline";
+
+import { resolveAuth } from "../auth.js";
+import { createExternalAgentToolSession } from "./tool-session.js";
+import { readAgentRuntimeFile } from "./trace.js";
+
+const MCP_PROTOCOL_VERSION = "2025-06-18";
+
+export async function agentMcpCommand(options) {
+  if (!options.runtimeFile) {
+    throw new Error("agent-mcp requires --runtime-file.");
+  }
+  if (!options.traceFile) {
+    throw new Error("agent-mcp requires --trace-file.");
+  }
+  const runtimeEnvelope = await readAgentRuntimeFile(options.runtimeFile);
+  const runtime = runtimeEnvelope.runtime;
+  const buildId = Number(options.buildIdFlag || 0);
+  if (!buildId) throw new Error("agent-mcp requires --build.");
+  if (!options.baseFilesHash) {
+    throw new Error("agent-mcp requires --base-files-hash.");
+  }
+  const auth = await resolveAuth(options);
+  const session = await createExternalAgentToolSession({
+    options,
+    auth,
+    buildId,
+    baseFilesHash: options.baseFilesHash,
+    dir: options.dir,
+    runtime,
+    traceFile: options.traceFile,
+    provider: runtimeEnvelope.provider || "external",
+  });
+  const tools = (Array.isArray(runtime.tools) ? runtime.tools : [])
+    .filter((tool) => tool?.type === "function" && tool?.name)
+    .map((tool) => ({
+      name: tool.name,
+      description: tool.description || "",
+      inputSchema: tool.parameters || {
+        type: "object",
+        additionalProperties: true,
+      },
+    }));
+
+  const input = readline.createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity,
+    terminal: false,
+  });
+  const pending = new Set();
+  input.on("line", (line) => {
+    if (!line.trim()) return;
+    const operation = handleMcpMessage({ line, session, tools }).catch(
+      (error) => {
+        process.stderr.write(
+          `lumine agent-mcp: ${String(error?.message || error)}\n`,
+        );
+      },
+    );
+    pending.add(operation);
+    operation.finally(() => pending.delete(operation));
+  });
+  await new Promise((resolve) => input.once("close", resolve));
+  await Promise.allSettled(Array.from(pending));
+}
+
+async function handleMcpMessage({ line, session, tools }) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return writeMcpError(null, -32700, "Parse error");
+  }
+  const id = message?.id;
+  const method = String(message?.method || "");
+  if (id === undefined || id === null) return;
+
+  if (method === "initialize") {
+    return writeMcpResult(id, {
+      protocolVersion:
+        String(message?.params?.protocolVersion || "") || MCP_PROTOCOL_VERSION,
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: {
+        name: "lumine-external-agent-runtime",
+        version: "1.0.0",
+      },
+    });
+  }
+  if (method === "ping") return writeMcpResult(id, {});
+  if (method === "tools/list") {
+    return writeMcpResult(id, { tools });
+  }
+  if (method === "tools/call") {
+    const toolName = String(message?.params?.name || "");
+    const toolArguments = message?.params?.arguments || {};
+    try {
+      const output = await session.call(toolName, toolArguments);
+      const isError = output?.ok === false || Boolean(output?.error);
+      return writeMcpResult(id, {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output),
+          },
+        ],
+        isError,
+      });
+    } catch (error) {
+      return writeMcpResult(id, {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              ok: false,
+              error: String(error?.message || error),
+            }),
+          },
+        ],
+        isError: true,
+      });
+    }
+  }
+  return writeMcpError(id, -32601, `Method not found: ${method}`);
+}
+
+function writeMcpResult(id, result) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+}
+
+function writeMcpError(id, code, message) {
+  process.stdout.write(
+    `${JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      error: { code, message },
+    })}\n`,
+  );
+}

package/lib/agent/providers/claude-code.js

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+
+import { createSubscriptionAgentEnvironment } from "./environment.js";
+
+const CLAUDE_RUNTIME_SUFFIX = `
+
+EXTERNAL LUMINE RUNTIME:
+- Use only the Lumine MCP tools supplied for this run.
+- Do not use built-in filesystem, shell, web, skill, or subagent tools.
+- The real project is available only through Lumine tools.
+- Never reveal hidden chain-of-thought or private reasoning.`;
+
+export async function runClaudeCodeAgentPass({
+  options,
+  runtime,
+  isolationDir,
+  mcp,
+}) {
+  if (options.authToken) {
+    throw new Error(
+      "Claude Code external-agent runs require a saved `lumine login`; --auth-token is not forwarded into an MCP child process.",
+    );
+  }
+  const binary =
+    options.providerPath || process.env.LUMINE_CLAUDE_PATH || "claude";
+  const mcpConfig = {
+    mcpServers: {
+      lumine: {
+        type: "stdio",
+        command: process.execPath,
+        args: [
+          mcp.cliPath,
+          "agent-mcp",
+          "--dir",
+          mcp.dir,
+          "--runtime-file",
+          mcp.runtimeFile,
+          "--trace-file",
+          mcp.traceFile,
+          "--api-url",
+          options.apiUrl,
+          "--auth-file",
+          options.authFile,
+          "--build",
+          String(mcp.buildId),
+          "--base-files-hash",
+          mcp.baseFilesHash,
+          "--no-update-check",
+        ],
+      },
+    },
+  };
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--no-session-persistence",
+    "--disable-slash-commands",
+    "--no-chrome",
+    "--permission-mode",
+    "dontAsk",
+    "--tools",
+    "",
+    "--allowedTools",
+    "mcp__lumine__*",
+    "--strict-mcp-config",
+    "--mcp-config",
+    JSON.stringify(mcpConfig),
+    "--system-prompt",
+    `${runtime.systemPrompt}${CLAUDE_RUNTIME_SUFFIX}`,
+    ...(options.model ? ["--model", options.model] : []),
+    ...(options.agentEffort ? ["--effort", options.agentEffort] : []),
+    runtime.initialPrompt,
+  ];
+  const result = await runClaudeProcess({
+    binary,
+    args,
+    cwd: isolationDir,
+    streamJson: true,
+  });
+  return { finalText: result.finalText };
+}
+
+export async function reviewClaudeCodeAgentLoop({
+  options,
+  isolationDir,
+  prompt,
+  systemPrompt,
+  outputSchema,
+}) {
+  const binary =
+    options.providerPath || process.env.LUMINE_CLAUDE_PATH || "claude";
+  const result = await runClaudeProcess({
+    binary,
+    cwd: isolationDir,
+    streamJson: false,
+    args: [
+      "-p",
+      "--output-format",
+      "json",
+      "--no-session-persistence",
+      "--disable-slash-commands",
+      "--no-chrome",
+      "--permission-mode",
+      "dontAsk",
+      "--tools",
+      "",
+      "--allowedTools",
+      "",
+      "--strict-mcp-config",
+      "--mcp-config",
+      JSON.stringify({ mcpServers: {} }),
+      "--system-prompt",
+      systemPrompt,
+      "--json-schema",
+      JSON.stringify(outputSchema),
+      ...(options.model ? ["--model", options.model] : []),
+      ...(options.agentEffort ? ["--effort", options.agentEffort] : []),
+      prompt,
+    ],
+  });
+  if (result.structuredOutput) return result.structuredOutput;
+  try {
+    return JSON.parse(result.finalText);
+  } catch {
+    throw new Error("Claude Code did not return valid loop-review JSON.");
+  }
+}
+
+async function runClaudeProcess({ binary, args, cwd, streamJson }) {
+  const child = spawn(binary, args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: createSubscriptionAgentEnvironment(),
+  });
+  child.stderr.on("data", (chunk) => process.stderr.write(chunk));
+  let finalText = "";
+  let structuredOutput = null;
+  let rawOutput = "";
+
+  if (streamJson) {
+    const lines = readline.createInterface({
+      input: child.stdout,
+      crlfDelay: Infinity,
+      terminal: false,
+    });
+    lines.on("line", (line) => {
+      if (!line.trim()) return;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (event?.type === "assistant") {
+        const texts = (event.message?.content || [])
+          .filter((block) => block?.type === "text")
+          .map((block) => String(block.text || "").trim())
+          .filter(Boolean);
+        if (texts.length > 0) finalText = texts.join("\n\n");
+      }
+      if (event?.type === "result") {
+        if (typeof event.result === "string" && event.result.trim()) {
+          finalText = event.result.trim();
+        }
+        if (event.structured_output) {
+          structuredOutput = event.structured_output;
+        }
+      }
+    });
+  } else {
+    child.stdout.on("data", (chunk) => {
+      rawOutput += chunk.toString("utf8");
+    });
+  }
+
+  const result = await new Promise((resolve, reject) => {
+    child.once("error", (error) =>
+      reject(normalizeProviderLaunchError(error, binary)),
+    );
+    child.once("exit", (code, signal) => {
+      if (code === 0) return resolve({ code });
+      reject(
+        new Error(
+          `Claude Code exited before completing the Lumine pass (${signal || code}).`,
+        ),
+      );
+    });
+  });
+  void result;
+
+  if (!streamJson) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawOutput);
+    } catch {
+      throw new Error("Claude Code returned an invalid JSON result.");
+    }
+    finalText = String(parsed?.result || "").trim();
+    structuredOutput = parsed?.structured_output || null;
+  }
+  return { finalText, structuredOutput };
+}
+
+function normalizeProviderLaunchError(error, binary) {
+  if (error?.code === "ENOENT") {
+    return new Error(
+      `Claude Code CLI was not found at ${binary}. Install it, sign in with your subscription, or pass --provider-path.`,
+    );
+  }
+  return error;
+}