@ainecto/cli 0.8.1 → 0.10.0

package/dist/bin/mcp.js

@@ -420,8 +420,8 @@ function toStoredToken(endpoint, token, metadata, previous) {
 async function createLoopbackReceiver(expectedState, host = "127.0.0.1") {
   let resolveCode;
   let rejectCode;
-  const codePromise = new Promise((resolve, reject) => {
-    resolveCode = resolve;
+  const codePromise = new Promise((resolve2, reject) => {
+    resolveCode = resolve2;
     rejectCode = reject;
   });
   codePromise.catch(() => void 0);
@@ -452,12 +452,12 @@ async function createLoopbackReceiver(expectedState, host = "127.0.0.1") {
     res.end("AiNecto CLI authorization complete. You can close this tab.");
     resolveCode(code);
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.once("error", (error) => reject(new OAuthLoginError(
       "CALLBACK_UNAVAILABLE",
       `Could not start the local sign-in callback on ${host} (${error.message}). If this command runs in a sandbox, allow local network binding or run it outside the sandbox.`
     )));
-    server.listen(0, host, () => resolve());
+    server.listen(0, host, () => resolve2());
   });
   const address = server.address();
   if (!address || typeof address === "string") {
@@ -466,9 +466,9 @@ async function createLoopbackReceiver(expectedState, host = "127.0.0.1") {
   return {
     redirectUri: `http://127.0.0.1:${address.port}/callback`,
     waitForCode: () => codePromise,
-    close: () => new Promise((resolve, reject) => {
+    close: () => new Promise((resolve2, reject) => {
       server.closeAllConnections?.();
-      server.close((error) => error ? reject(error) : resolve());
+      server.close((error) => error ? reject(error) : resolve2());
     })
   };
 }
@@ -497,7 +497,7 @@ function launchBrowser(url, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const { command, args } = getBrowserOpenCommand(url, platform);
   const spawnImpl = deps.spawnImpl ?? spawn;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const unavailable = (reason) => new OAuthLoginError(
       "BROWSER_UNAVAILABLE",
       `Could not open a browser on this machine (${command}: ${reason}). Sign-in needs a browser here.`
@@ -511,11 +511,11 @@ function launchBrowser(url, deps = {}) {
     }
     child.once("error", (error) => reject(unavailable(error.message)));
     if (platform === "win32") {
-      child.once("spawn", () => resolve());
+      child.once("spawn", () => resolve2());
     } else {
       child.once("exit", (code, signal) => {
         if (code === 0) {
-          resolve();
+          resolve2();
         } else {
           reject(unavailable(code === null ? `stopped by ${signal ?? "a signal"}` : `exited with code ${code}`));
         }
@@ -547,13 +547,14 @@ function legacyRoleInput(flag, envVars = process.env) {
 }
 
 // src/core/version.ts
-var CLI_VERSION = true ? "0.8.1" : UNBUNDLED_VERSION;
+var CLI_VERSION = true ? "0.10.0" : UNBUNDLED_VERSION;
 var PACKAGE_NAME = "@ainecto/mcp";
 var CLI_USER_AGENT = `${PACKAGE_NAME} ${CLI_VERSION}`;
 
 // src/core/mcp/rpcClient.ts
 var CHANNEL_HEADER = "X-AiNecto-Channel";
 var AGENT_HEADER = "X-AiNecto-Agent";
+var AGENT_NAME_HEADER = "X-AiNecto-Agent-Name";
 var MAX_AGENT_NAME_LENGTH = 100;
 var McpRpcError = class extends Error {
   constructor(message, code, details) {
@@ -626,10 +627,11 @@ var McpRpcClient = class {
     }
     const text = await response.text();
     if (!response.ok) {
+      const serverError = parseServerError(text);
       throw new McpRpcError(
-        `MCP HTTP request failed with HTTP ${response.status}.`,
+        `MCP HTTP request failed with HTTP ${response.status}${serverError ? ` \u2014 ${describeServerError(serverError)}` : "."}`,
         "MCP_HTTP_ERROR",
-        httpErrorDetails(response.status, text, this.options.envVars ?? process.env)
+        { ...httpErrorDetails(response.status, text, this.options.envVars ?? process.env), ...serverError ? { error: serverError.error } : {} }
       );
     }
     if (!text.trim()) {
@@ -657,6 +659,9 @@ var McpRpcClient = class {
     if (this.agent) {
       headers[AGENT_HEADER.toLowerCase()] = this.agent;
     }
+    if (this.options.agentName) {
+      headers[AGENT_NAME_HEADER.toLowerCase()] = this.options.agentName;
+    }
     return this.fetchImpl(this.options.endpoint, {
       method: "POST",
       headers,
@@ -674,6 +679,25 @@ function printableHeaderValue(value) {
   const printable = value.replace(/[^\x20-\x7E]/g, "").trim().slice(0, MAX_AGENT_NAME_LENGTH).trim();
   return printable || void 0;
 }
+function parseServerError(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord2(parsed) || typeof parsed.error !== "string" || !parsed.error.trim()) {
+    return void 0;
+  }
+  return {
+    error: parsed.error.trim(),
+    description: typeof parsed.error_description === "string" && parsed.error_description.trim() ? parsed.error_description : void 0
+  };
+}
+function describeServerError(serverError) {
+  const line = serverError.description ? `${serverError.error}: ${serverError.description}` : serverError.error;
+  return line.replace(/\s+/g, " ").trim();
+}
 function isJsonRpcResponse(value) {
   return isRecord2(value) && value.jsonrpc === "2.0" && ("result" in value || "error" in value);
 }
@@ -699,27 +723,49 @@ async function runStdioBridge(options) {
     if (!line.trim()) {
       continue;
     }
+    let request;
+    try {
+      request = parseJsonRpcRequest(line);
+    } catch (error) {
+      writeLine(options.output, failure(null, error instanceof SyntaxError ? PARSE_ERROR : INVALID_REQUEST, error));
+      continue;
+    }
     try {
-      const request = parseJsonRpcRequest(line);
       if (request.method === "initialize") {
         options.client.useAgent(clientInfoName(request.params));
       }
       const response = await options.client.sendRaw(request);
       if (response && request.id !== void 0) {
-        options.output.write(`${JSON.stringify(response)}
-`);
+        writeLine(options.output, response);
       }
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      options.output.write(`${JSON.stringify({
-        jsonrpc: "2.0",
-        id: null,
-        error: { code: -32603, message }
-      })}
+      if (request.id === void 0) {
+        options.errorOutput.write(`${errorMessage(error)}
 `);
+        continue;
+      }
+      writeLine(options.output, failure(request.id, INTERNAL_ERROR, error));
     }
   }
 }
+var PARSE_ERROR = -32700;
+var INVALID_REQUEST = -32600;
+var INTERNAL_ERROR = -32603;
+function failure(id, code, error) {
+  const data = error instanceof McpRpcError ? { code: error.code, ...isRecord3(error.details) ? error.details : {} } : void 0;
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message: errorMessage(error), ...data ? { data } : {} }
+  };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function writeLine(output, message) {
+  output.write(`${JSON.stringify(message)}
+`);
+}
 function parseJsonRpcRequest(line) {
   const parsed = JSON.parse(line);
   if (!isRecord3(parsed) || parsed.jsonrpc !== "2.0" || typeof parsed.method !== "string") {
@@ -739,6 +785,109 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/core/harness/agentTargets.ts
+import { basename } from "path";
+var SERVER_NAME = "ainecto";
+var REMOTE_SIGN_IN = {
+  "claude-code": `Claude Code \u2014 in a session, run /mcp, pick "${SERVER_NAME}" and sign in`,
+  cursor: `Cursor \u2014 sign in when "${SERVER_NAME}" asks for it in Cursor's MCP settings`,
+  codex: `Codex \u2014 signs in while setup connects it (its sign-in link is printed above); if that did not finish, run \`codex mcp login ${SERVER_NAME}\``
+};
+
+// src/core/harness/harnessDoc.ts
+var MARKER_BEGIN = "<!-- ainecto:begin -->";
+var MARKER_END = "<!-- ainecto:end -->";
+var HARNESS_DIR = ".ainecto";
+var HARNESS_DOC_PATH = `${HARNESS_DIR}/HARNESS.md`;
+var HARNESS_CONFIG_PATH = `${HARNESS_DIR}/config.json`;
+var HARNESS_RECORD_PATH = `${HARNESS_DIR}/init-record.json`;
+var DOC_KEY = "HARNESS.DOC";
+var AGENT_NOTE_KEY = "HARNESS.AGENT_NOTE";
+var REQUIRED_VARIABLES = {
+  [DOC_KEY]: ["endpoint"],
+  [AGENT_NOTE_KEY]: ["harnessDocPath", "serverName"]
+};
+var DEFAULT_AGENT_NOTE = `${MARKER_BEGIN}
+## AiNecto Harness
+
+This repository uses AiNecto as its design source of truth. Read \`{{harnessDocPath}}\` before doing
+work that touches requirements, the ERD, or architecture.
+
+AiNecto tools come from the \`{{serverName}}\` MCP server. Every session sees the same tools; the
+signed-in user's AiNecto permissions decide what they may change, and the server refuses the rest.
+${MARKER_END}`;
+
+// src/core/harness/repositoryFiles.ts
+import { lstat, readFile as readFile2, realpath } from "fs/promises";
+import { dirname as dirname2, join as join2, resolve, sep } from "path";
+async function findGitRoot(cwd) {
+  for (let at = resolve(cwd); ; at = dirname2(at)) {
+    try {
+      await lstat(join2(at, ".git"));
+      return at;
+    } catch {
+    }
+    if (dirname2(at) === at) {
+      return void 0;
+    }
+  }
+}
+async function readManagedFile(root, path) {
+  await assertInsideRepository(root, path);
+  return readIfExists(join2(root, path));
+}
+async function readIfExists(absolutePath) {
+  try {
+    return await readFile2(absolutePath, "utf8");
+  } catch (error) {
+    if (isNodeError2(error, "ENOENT")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function assertInsideRepository(root, relativePath) {
+  const absolutePath = join2(root, relativePath);
+  const realRoot = await realpath(root);
+  let realParent;
+  try {
+    realParent = await realpath(dirname2(absolutePath));
+  } catch (error) {
+    if (isNodeError2(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+  if (realParent !== realRoot && !realParent.startsWith(realRoot + sep)) {
+    throw new Error(
+      `${relativePath} resolves outside the repository (${realParent}); refusing to touch it.`
+    );
+  }
+  try {
+    if ((await lstat(absolutePath)).isSymbolicLink()) {
+      throw new Error(`${relativePath} is a symbolic link; refusing to write through it.`);
+    }
+  } catch (error) {
+    if (!isNodeError2(error, "ENOENT")) {
+      throw error;
+    }
+  }
+}
+function isNodeError2(error, code) {
+  return typeof error === "object" && error !== null && error.code === code;
+}
+
+// src/core/harness/agentName.ts
+var AGENT_NAME_PATH = `${HARNESS_DIR}/agent.local`;
+function agentNameOf(raw) {
+  const name = raw?.trim();
+  return name ? name : void 0;
+}
+async function readAgentName(cwd) {
+  const root = await findGitRoot(cwd) ?? cwd;
+  return agentNameOf(await readManagedFile(root, AGENT_NAME_PATH));
+}
+
 // src/adapters/mcp/connector.ts
 async function runConnector(options) {
   const legacyRole = legacyRoleInput(options.legacyRoleFlag, options.envVars);
@@ -751,7 +900,8 @@ async function runConnector(options) {
     endpoint: options.endpoint,
     tokenProvider: auth,
     legacyRole,
-    // 에이전트의 MCP 연결 — 에이전트 이름은 브리지가 호스트의 initialize 에서 읽어 싣는다.
+    agentName: options.agentFlag ?? await readAgentName(options.cwd ?? process.cwd()),
+    // 에이전트의 MCP 연결 — 에이전트 «종류»는 브리지가 호스트의 initialize 에서 읽어 싣는다(«이름»은 위 agentName).
     channel: "mcp"
   });
   await runStdioBridge({
@@ -829,6 +979,12 @@ function parseMcpArgs(argv) {
       result.env = assertEnv(requireFlagValue(arg, argv[++index]));
     } else if (arg === "--endpoint") {
       result.endpoint = requireFlagValue(arg, argv[++index]);
+    } else if (arg === "--agent") {
+      const name = agentNameOf(requireFlagValue(arg, argv[++index]));
+      if (name === void 0) {
+        throw new Error(`${arg} requires a value.`);
+      }
+      result.agent = name;
     } else if (arg === "--role") {
       const value = argv[index + 1];
       if (value !== void 0 && !value.startsWith("--")) {
@@ -854,13 +1010,14 @@ function requireFlagValue(flag, value) {
 try {
   const args = parseMcpArgs(process.argv.slice(2));
   if (args.help) {
-    process.stdout.write("Usage: mcp [--env prod|dev] [--endpoint URL]\n");
+    process.stdout.write("Usage: mcp [--env prod|dev] [--endpoint URL] [--agent NAME]\n");
     process.exit(0);
   }
   const resolved = resolveEndpoint({ env: args.env, endpoint: args.endpoint });
   await runConnector({
     endpoint: resolved.endpoint,
     legacyRoleFlag: args.legacyRole,
+    agentFlag: args.agent,
     input: process.stdin,
     output: process.stdout,
     errorOutput: process.stderr