@ainecto/cli 0.0.0-stage → 0.5.0

package/dist/bin/mcp.js

@@ -0,0 +1,874 @@
+#!/usr/bin/env node
+
+// src/core/config/endpoints.ts
+var DEFAULT_ENDPOINTS = {
+  prod: "https://ainecto.com/mcp",
+  dev: "https://dev.ai-erd.com/mcp"
+};
+var LEGACY_PROD_ENDPOINT = "https://ai-erd.com/mcp";
+var LEGACY_DEFAULT_ENDPOINTS = [
+  LEGACY_PROD_ENDPOINT,
+  "https://dev.ainecto.com/mcp"
+];
+var TOKEN_SLOT_FALLBACKS = {
+  [DEFAULT_ENDPOINTS.prod]: [LEGACY_PROD_ENDPOINT]
+};
+function fallbackTokenEndpointsFor(endpoint) {
+  return TOKEN_SLOT_FALLBACKS[normalizeEndpoint(endpoint)] ?? [];
+}
+function resolveEndpoint(input = {}) {
+  const envVars = input.envVars ?? process.env;
+  const env = input.env ?? "prod";
+  if (input.endpoint) {
+    return { env, endpoint: normalizeEndpoint(input.endpoint), source: "flag" };
+  }
+  if (envVars.AINECTO_MCP_ENDPOINT) {
+    return { env, endpoint: normalizeEndpoint(envVars.AINECTO_MCP_ENDPOINT), source: "env" };
+  }
+  return { env, endpoint: DEFAULT_ENDPOINTS[env], source: "default" };
+}
+function normalizeEndpoint(endpoint) {
+  const url = new URL(endpoint);
+  assertTrustedEndpointUrl(url, "MCP endpoint");
+  url.hash = "";
+  return url.toString().replace(/\/$/, "");
+}
+function isDefaultEndpoint(endpoint) {
+  const normalized = normalizeEndpoint(endpoint);
+  return Object.values(DEFAULT_ENDPOINTS).includes(normalized) || LEGACY_DEFAULT_ENDPOINTS.includes(normalized);
+}
+function assertTrustedEndpointUrl(value, label = "URL") {
+  const url = typeof value === "string" ? new URL(value) : value;
+  if (url.protocol === "https:") {
+    return;
+  }
+  if (url.protocol === "http:" && isLoopbackHostname(url.hostname)) {
+    return;
+  }
+  throw new Error(`${label} must use https, except http is allowed for localhost loopback endpoints.`);
+}
+function assertLoopbackRedirectUrl(value) {
+  const url = new URL(value);
+  if (url.protocol === "http:" && isLoopbackHostname(url.hostname)) {
+    return;
+  }
+  throw new Error("OAuth redirect URI must be an http localhost loopback URL.");
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+}
+function assertEnv(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "prod" || value === "dev") {
+    return value;
+  }
+  throw new Error(`Invalid --env value "${value}". Expected "prod" or "dev".`);
+}
+
+// src/core/auth/tokenStore.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, rename, rm, stat, writeFile, chmod } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/core/harness/role.ts
+var HARNESS_ROLES = ["design", "development", "test", "validation"];
+var ROLE_SCOPE_PREFIX = "ai-erd:role:";
+var ROLE_HEADER = "X-AI-ERD-Role";
+var ROLE_ENV_VAR = "AINECTO_ROLE";
+var LEGACY_ROLE_ENV_VAR = "AI_ERD_ROLE";
+function resolveRole(input = {}) {
+  if (input.role !== void 0) {
+    return { role: assertRole(input.role), source: "flag" };
+  }
+  const envVars = input.envVars ?? process.env;
+  for (const envVar of [ROLE_ENV_VAR, LEGACY_ROLE_ENV_VAR]) {
+    const fromEnv = envVars[envVar];
+    if (fromEnv && fromEnv.trim()) {
+      return { role: assertRole(fromEnv), source: "env", envVar };
+    }
+  }
+  return { source: "none" };
+}
+function assertRole(value) {
+  const normalized = value.trim().toLowerCase();
+  if (HARNESS_ROLES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid role "${value}". Expected one of: ${HARNESS_ROLES.join(", ")}.`
+  );
+}
+
+// src/core/auth/tokenStore.ts
+var FileTokenStore = class {
+  filePath;
+  constructor(rootDir = join(homedir(), ".ainecto")) {
+    this.filePath = join(rootDir, "tokens.json");
+  }
+  async load(endpoint) {
+    const file = await this.readFile();
+    return file[tokenKey(endpoint)];
+  }
+  async save(endpoint, token) {
+    assertNoRoleScope(token);
+    const file = await this.readFile();
+    file[tokenKey(endpoint)] = { ...token, endpoint, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.writeFile(file);
+  }
+  async delete(endpoint) {
+    const file = await this.readFile();
+    delete file[tokenKey(endpoint)];
+    await this.writeFile(file);
+  }
+  async readFile() {
+    try {
+      await this.hardenExistingPermissions();
+      const raw = await readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Token file must contain an object.");
+      }
+      return parsed;
+    } catch (error) {
+      if (isNodeError(error, "ENOENT")) {
+        return {};
+      }
+      throw error;
+    }
+  }
+  async writeFile(file) {
+    await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
+    await chmod(dirname(this.filePath), 448);
+    const tmpPath = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmpPath, `${JSON.stringify(file, null, 2)}
+`, { mode: 384 });
+    await chmod(tmpPath, 384);
+    await rename(tmpPath, this.filePath);
+    await chmod(this.filePath, 384);
+  }
+  async hardenExistingPermissions() {
+    const dirPath = dirname(this.filePath);
+    await chmodIfPermissive(dirPath, 448);
+    await chmodIfPermissive(this.filePath, 384);
+  }
+};
+function tokenKey(endpoint) {
+  return createHash("sha256").update(endpoint).digest("hex");
+}
+function assertNoRoleScope(token) {
+  if (token.scope?.split(/\s+/).some((scope) => scope.startsWith(ROLE_SCOPE_PREFIX))) {
+    throw new Error(
+      "Refusing to store a role-scoped access token: sign-in is one per machine and the role comes from the repository. Run `ainecto auth login` again."
+    );
+  }
+}
+function isNodeError(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+async function chmodIfPermissive(path, mode) {
+  try {
+    const result = await stat(path);
+    if ((result.mode & 63) !== 0) {
+      await chmod(path, mode);
+    }
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/core/auth/oauth.ts
+import { createHash as createHash2, randomBytes } from "crypto";
+import { createServer } from "http";
+import { spawn } from "child_process";
+import { URLSearchParams } from "url";
+
+// src/core/auth/clientRegistration.ts
+async function registerPublicClient(registrationEndpoint, redirectUri, fetchImpl = fetch) {
+  assertTrustedEndpointUrl(registrationEndpoint, "OAuth client registration endpoint");
+  assertLoopbackRedirectUrl(redirectUri);
+  const response = await fetchImpl(registrationEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify({
+      client_name: "AiNecto CLI",
+      redirect_uris: [redirectUri],
+      token_endpoint_auth_method: "none",
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OAuth client registration failed with HTTP ${response.status}.`);
+  }
+  const body = await response.json();
+  if (!isRecord(body) || typeof body.client_id !== "string") {
+    throw new Error("OAuth client registration response did not include client_id.");
+  }
+  return {
+    clientId: body.client_id,
+    clientSecret: typeof body.client_secret === "string" ? body.client_secret : void 0
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/auth/oauth.ts
+var DEFAULT_LOGIN_TIMEOUT_MS = 3e5;
+var OAuthLoginError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "OAuthLoginError";
+  }
+  code;
+};
+var OAuthClient = class {
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.envVars = options.envVars ?? process.env;
+    this.openBrowserImpl = options.openBrowser ?? openBrowser;
+  }
+  options;
+  fetchImpl;
+  envVars;
+  openBrowserImpl;
+  async getAccessToken() {
+    const envToken = this.envVars.AINECTO_TOKEN;
+    if (envToken) {
+      assertEnvTokenEndpointAllowed(this.options.endpoint, this.envVars);
+      return envToken;
+    }
+    const stored = await this.loadStored();
+    if (!stored) {
+      return void 0;
+    }
+    if (!shouldRefresh(stored)) {
+      return stored.accessToken;
+    }
+    if (this.options.readOnly) {
+      return isExpired(stored) ? void 0 : stored.accessToken;
+    }
+    if (!stored.refreshToken) {
+      return isExpired(stored) ? void 0 : stored.accessToken;
+    }
+    return this.refreshStoredToken({ ...stored, refreshToken: stored.refreshToken });
+  }
+  async refreshAfterUnauthorized() {
+    const stored = await this.loadStored();
+    if (this.options.readOnly || !stored?.refreshToken) {
+      return void 0;
+    }
+    return this.refreshStoredToken({ ...stored, refreshToken: stored.refreshToken });
+  }
+  async login() {
+    const pkce = generatePkcePair();
+    const state = generateOAuthState();
+    const loopback = await createLoopbackReceiver(state);
+    try {
+      const metadata = await discoverOAuthMetadata(this.options.endpoint, this.fetchImpl);
+      const registration = metadata.registrationEndpoint ? await registerPublicClient(metadata.registrationEndpoint, loopback.redirectUri, this.fetchImpl) : { clientId: "ainecto-cli" };
+      const authorizeUrl = new URL(metadata.authorizationEndpoint);
+      authorizeUrl.searchParams.set("response_type", "code");
+      authorizeUrl.searchParams.set("client_id", registration.clientId);
+      authorizeUrl.searchParams.set("redirect_uri", loopback.redirectUri);
+      authorizeUrl.searchParams.set("code_challenge", pkce.codeChallenge);
+      authorizeUrl.searchParams.set("code_challenge_method", "S256");
+      authorizeUrl.searchParams.set("resource", this.options.endpoint);
+      authorizeUrl.searchParams.set("state", state);
+      assertTrustedEndpointUrl(authorizeUrl, "OAuth authorization URL");
+      const url = authorizeUrl.toString();
+      this.options.onAuthorizeUrl?.(url);
+      const browserFailure = this.openBrowserImpl(url).then(() => new Promise(() => void 0));
+      const code = await withTimeout(
+        Promise.race([loopback.waitForCode(), browserFailure]),
+        this.options.loginTimeoutMs ?? DEFAULT_LOGIN_TIMEOUT_MS
+      );
+      const token = await exchangeToken(metadata.tokenEndpoint, {
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: loopback.redirectUri,
+        client_id: registration.clientId,
+        code_verifier: pkce.codeVerifier,
+        resource: this.options.endpoint,
+        ...registration.clientSecret ? { client_secret: registration.clientSecret } : {}
+      }, this.fetchImpl);
+      const stored = toStoredToken(this.options.endpoint, token, metadata, registration);
+      await this.options.tokenStore.save(this.options.endpoint, stored);
+      return stored;
+    } finally {
+      await loopback.close();
+    }
+  }
+  /**
+   * ★대체로 읽는 옛 칸도 함께 지운다. 새 칸만 지우면 다음 읽기가 곧바로 옛 칸으로 대체돼
+   * «로그아웃했는데 여전히 로그인됨»이 된다. 로그인은 기계당 한 번이므로 옛 CLI 의 칸도 같이 끝난다.
+   */
+  async logout() {
+    await this.options.tokenStore.delete(this.options.endpoint);
+    for (const fallback of fallbackTokenEndpointsFor(this.options.endpoint)) {
+      await this.options.tokenStore.delete(fallback);
+    }
+  }
+  /** 이 주소의 칸, 비었으면 옛 기본 주소의 칸({@link fallbackTokenEndpointsFor}). 쓰기는 늘 이 주소의 칸이다. */
+  async loadStored() {
+    const own = await this.options.tokenStore.load(this.options.endpoint);
+    if (own) {
+      return own;
+    }
+    for (const fallback of fallbackTokenEndpointsFor(this.options.endpoint)) {
+      const stored = await this.options.tokenStore.load(fallback);
+      if (stored) {
+        return stored;
+      }
+    }
+    return void 0;
+  }
+  /** 부르는 쪽이 refresh token 이 있음을 이미 확인했다 — 타입이 그것을 요구한다. */
+  async refreshStoredToken(stored) {
+    const metadata = await discoverOAuthMetadata(this.options.endpoint, this.fetchImpl);
+    const token = await exchangeToken(metadata.tokenEndpoint, {
+      grant_type: "refresh_token",
+      refresh_token: stored.refreshToken,
+      client_id: stored.clientId ?? "ainecto-cli",
+      ...stored.clientSecret ? { client_secret: stored.clientSecret } : {},
+      resource: this.options.endpoint
+    }, this.fetchImpl);
+    const next = toStoredToken(this.options.endpoint, token, metadata, stored);
+    await this.options.tokenStore.save(this.options.endpoint, next);
+    return next.accessToken;
+  }
+};
+function generatePkcePair() {
+  const codeVerifier = randomBytes(32).toString("base64url");
+  const codeChallenge = createHash2("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+function generateOAuthState() {
+  return randomBytes(32).toString("base64url");
+}
+function isExpired(token, now = Date.now()) {
+  return token.expiresAt !== void 0 && token.expiresAt <= now;
+}
+async function withTimeout(work, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const minutes = timeoutMs / 6e4;
+      const span = Number.isInteger(minutes) ? `${minutes} minute${minutes === 1 ? "" : "s"}` : `${timeoutMs} ms`;
+      reject(new OAuthLoginError(
+        "LOGIN_TIMEOUT",
+        `Sign-in was not completed within ${span}. Nothing was saved \u2014 run the same command again.`
+      ));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([work, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function shouldRefresh(token, now = Date.now()) {
+  if (!token.expiresAt) {
+    return false;
+  }
+  return token.expiresAt - now < 6e4;
+}
+async function discoverOAuthMetadata(endpoint, fetchImpl = fetch) {
+  assertTrustedEndpointUrl(endpoint, "MCP endpoint");
+  const resourceMetadataUrl = await discoverResourceMetadataUrl(endpoint, fetchImpl);
+  assertTrustedEndpointUrl(resourceMetadataUrl, "OAuth protected resource metadata URL");
+  const resourceMetadata = await fetchJson(resourceMetadataUrl, fetchImpl);
+  const authorizationServers = resourceMetadata.authorization_servers;
+  if (!Array.isArray(authorizationServers) || typeof authorizationServers[0] !== "string") {
+    throw new Error("OAuth protected resource metadata did not include authorization_servers.");
+  }
+  const authServer = authorizationServers[0];
+  assertTrustedEndpointUrl(authServer, "OAuth authorization server");
+  const metadataUrl = authServer.includes("/.well-known/") ? authServer : `${authServer.replace(/\/$/, "")}/.well-known/oauth-authorization-server`;
+  assertTrustedEndpointUrl(metadataUrl, "OAuth authorization server metadata URL");
+  const metadata = await fetchJson(metadataUrl, fetchImpl);
+  if (typeof metadata.authorization_endpoint !== "string" || typeof metadata.token_endpoint !== "string") {
+    throw new Error("OAuth authorization server metadata is missing authorization_endpoint or token_endpoint.");
+  }
+  assertTrustedEndpointUrl(metadata.authorization_endpoint, "OAuth authorization endpoint");
+  assertTrustedEndpointUrl(metadata.token_endpoint, "OAuth token endpoint");
+  if (typeof metadata.registration_endpoint === "string") {
+    assertTrustedEndpointUrl(metadata.registration_endpoint, "OAuth client registration endpoint");
+  }
+  if (typeof metadata.issuer === "string") {
+    assertTrustedEndpointUrl(metadata.issuer, "OAuth issuer");
+  }
+  const codeChallengeMethodsSupported = parseStringArray(metadata.code_challenge_methods_supported);
+  if (!codeChallengeMethodsSupported.includes("S256")) {
+    throw new Error("OAuth authorization server metadata must support PKCE S256.");
+  }
+  return {
+    authorizationEndpoint: metadata.authorization_endpoint,
+    tokenEndpoint: metadata.token_endpoint,
+    registrationEndpoint: typeof metadata.registration_endpoint === "string" ? metadata.registration_endpoint : void 0,
+    issuer: typeof metadata.issuer === "string" ? metadata.issuer : void 0,
+    codeChallengeMethodsSupported
+  };
+}
+async function discoverResourceMetadataUrl(endpoint, fetchImpl) {
+  const challengeUrl = new URL(endpoint);
+  assertTrustedEndpointUrl(challengeUrl, "MCP endpoint");
+  const response = await fetchImpl(challengeUrl, { method: "GET" });
+  const challenge = response.headers.get("www-authenticate");
+  const fromChallenge = challenge ? parseBearerChallengeParam(challenge, "resource_metadata") : void 0;
+  if (fromChallenge) {
+    assertTrustedEndpointUrl(fromChallenge, "OAuth protected resource metadata URL");
+    return fromChallenge;
+  }
+  const origin = new URL(endpoint).origin;
+  const fallback = `${origin}/.well-known/oauth-protected-resource`;
+  assertTrustedEndpointUrl(fallback, "OAuth protected resource metadata URL");
+  return fallback;
+}
+function parseBearerChallengeParam(header, name) {
+  const pattern = new RegExp(`${name}="([^"]+)"`);
+  return pattern.exec(header)?.[1];
+}
+async function exchangeToken(tokenEndpoint, params, fetchImpl) {
+  assertTrustedEndpointUrl(tokenEndpoint, "OAuth token endpoint");
+  const response = await fetchImpl(tokenEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params)
+  });
+  if (!response.ok) {
+    throw new Error(`OAuth token exchange failed with HTTP ${response.status}.`);
+  }
+  return response.json();
+}
+function toStoredToken(endpoint, token, metadata, previous) {
+  if (typeof token.access_token !== "string") {
+    throw new Error("OAuth token response did not include access_token.");
+  }
+  const expiresIn = typeof token.expires_in === "number" ? token.expires_in : void 0;
+  return {
+    endpoint,
+    accessToken: token.access_token,
+    refreshToken: typeof token.refresh_token === "string" ? token.refresh_token : previous?.refreshToken,
+    tokenType: typeof token.token_type === "string" ? token.token_type : previous?.tokenType,
+    expiresAt: expiresIn ? Date.now() + expiresIn * 1e3 : previous?.expiresAt,
+    scope: typeof token.scope === "string" ? token.scope : previous?.scope,
+    clientId: previous?.clientId ?? "ainecto-cli",
+    clientSecret: previous?.clientSecret,
+    authorizationServer: metadata.issuer,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function createLoopbackReceiver(expectedState, host = "127.0.0.1") {
+  let resolveCode;
+  let rejectCode;
+  const codePromise = new Promise((resolve, reject) => {
+    resolveCode = resolve;
+    rejectCode = reject;
+  });
+  codePromise.catch(() => void 0);
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const error = url.searchParams.get("error");
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (error) {
+      res.writeHead(400, { "content-type": "text/plain" });
+      res.end("AiNecto CLI authorization failed. You can close this tab.");
+      rejectCode(new Error(`OAuth authorization failed: ${error}`));
+      return;
+    }
+    if (!state || state !== expectedState) {
+      res.writeHead(400, { "content-type": "text/plain" });
+      res.end("AiNecto CLI authorization state mismatch. You can close this tab.");
+      rejectCode(new Error("OAuth state mismatch."));
+      return;
+    }
+    if (!code) {
+      res.writeHead(400, { "content-type": "text/plain" });
+      res.end("Missing OAuth code.");
+      rejectCode(new Error("OAuth redirect did not include a code."));
+      return;
+    }
+    res.writeHead(200, { "content-type": "text/plain" });
+    res.end("AiNecto CLI authorization complete. You can close this tab.");
+    resolveCode(code);
+  });
+  await new Promise((resolve, 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());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Loopback OAuth server did not bind to a TCP port.");
+  }
+  return {
+    redirectUri: `http://127.0.0.1:${address.port}/callback`,
+    waitForCode: () => codePromise,
+    close: () => new Promise((resolve, reject) => {
+      server.closeAllConnections?.();
+      server.close((error) => error ? reject(error) : resolve());
+    })
+  };
+}
+function parseStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+async function fetchJson(url, fetchImpl) {
+  assertTrustedEndpointUrl(url, "OAuth metadata URL");
+  const response = await fetchImpl(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch OAuth metadata from ${url}: HTTP ${response.status}.`);
+  }
+  return response.json();
+}
+function getBrowserOpenCommand(url, platform = process.platform) {
+  assertTrustedEndpointUrl(url, "OAuth authorization URL");
+  if (platform === "darwin") {
+    return { command: "open", args: [url] };
+  }
+  if (platform === "win32") {
+    return { command: "explorer.exe", args: [url] };
+  }
+  return { command: "xdg-open", args: [url] };
+}
+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) => {
+    const unavailable = (reason) => new OAuthLoginError(
+      "BROWSER_UNAVAILABLE",
+      `Could not open a browser on this machine (${command}: ${reason}). Sign-in needs a browser here.`
+    );
+    let child;
+    try {
+      child = spawnImpl(command, args, { stdio: "ignore", detached: true });
+    } catch (error) {
+      reject(unavailable(error instanceof Error ? error.message : String(error)));
+      return;
+    }
+    child.once("error", (error) => reject(unavailable(error.message)));
+    if (platform === "win32") {
+      child.once("spawn", () => resolve());
+    } else {
+      child.once("exit", (code, signal) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(unavailable(code === null ? `stopped by ${signal ?? "a signal"}` : `exited with code ${code}`));
+        }
+      });
+    }
+    child.unref();
+  });
+}
+function openBrowser(url) {
+  return launchBrowser(url);
+}
+function assertEnvTokenEndpointAllowed(endpoint, envVars) {
+  if (envVars.AINECTO_ALLOW_CUSTOM_ENDPOINT_TOKEN === "1") {
+    return;
+  }
+  if (isDefaultEndpoint(endpoint)) {
+    return;
+  }
+  throw new Error("AINECTO_TOKEN can only be used with the default prod/dev endpoints. Set AINECTO_ALLOW_CUSTOM_ENDPOINT_TOKEN=1 only when you intentionally trust the custom endpoint.");
+}
+
+// src/core/version.ts
+var CLI_VERSION = true ? "0.5.0" : "dev";
+var PACKAGE_NAME = "@ainecto/mcp";
+var CLI_USER_AGENT = `${PACKAGE_NAME} ${CLI_VERSION}`;
+
+// src/core/mcp/rpcClient.ts
+var McpRpcError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+  code;
+  details;
+};
+var McpRpcClient = class {
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  options;
+  fetchImpl;
+  nextId = 1;
+  initialize() {
+    return this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: PACKAGE_NAME, version: CLI_VERSION }
+    });
+  }
+  async toolsList() {
+    const result = await this.request("tools/list", {});
+    if (!isRecord2(result) || !Array.isArray(result.tools)) {
+      throw new McpRpcError("tools/list response did not include a tools array.", "MCP_PROTOCOL_ERROR", result);
+    }
+    return result.tools;
+  }
+  async toolsCall(name, args) {
+    return this.request("tools/call", { name, arguments: args ?? {} });
+  }
+  async request(method, params) {
+    const response = await this.sendRaw({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method,
+      params
+    });
+    if (!response) {
+      return void 0;
+    }
+    if ("error" in response) {
+      throw new McpRpcError(response.error.message, "MCP_ERROR", response.error);
+    }
+    return response.result;
+  }
+  async sendRaw(request) {
+    const token = await this.options.tokenProvider?.getAccessToken();
+    let response = await this.postJson(request, token);
+    if (response.status === 401 && this.options.tokenProvider) {
+      const refreshed = await this.options.tokenProvider.refreshAfterUnauthorized();
+      if (refreshed) {
+        response = await this.postJson(request, refreshed);
+      }
+    }
+    if (response.status === 204 || response.status === 202) {
+      return void 0;
+    }
+    const text = await response.text();
+    if (!response.ok) {
+      throw new McpRpcError(
+        `MCP HTTP request failed with HTTP ${response.status}.`,
+        "MCP_HTTP_ERROR",
+        httpErrorDetails(response.status, text, this.options.envVars ?? process.env)
+      );
+    }
+    if (!text.trim()) {
+      return void 0;
+    }
+    const parsed = JSON.parse(text);
+    if (!isJsonRpcResponse(parsed)) {
+      throw new McpRpcError("MCP response was not a JSON-RPC response.", "MCP_PROTOCOL_ERROR", parsed);
+    }
+    return parsed;
+  }
+  postJson(request, token) {
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json"
+    };
+    if (token) {
+      headers.authorization = `Bearer ${token}`;
+    }
+    if (this.options.role) {
+      headers[ROLE_HEADER.toLowerCase()] = this.options.role;
+    }
+    return this.fetchImpl(this.options.endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    });
+  }
+};
+function isJsonRpcResponse(value) {
+  return isRecord2(value) && value.jsonrpc === "2.0" && ("result" in value || "error" in value);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function httpErrorDetails(status, body, envVars) {
+  const details = { status };
+  if (envVars.AINECTO_CLI_DEBUG === "1" || envVars.AINECTO_DEBUG === "1") {
+    details.body = safeBodyPreview(body);
+  }
+  return details;
+}
+function safeBodyPreview(body) {
+  return body.length > 500 ? `${body.slice(0, 500)}...` : body;
+}
+
+// src/core/mcp/stdioBridge.ts
+import { createInterface } from "readline";
+async function runStdioBridge(options) {
+  const lines = createInterface({ input: options.input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const request = parseJsonRpcRequest(line);
+      const response = await options.client.sendRaw(request);
+      if (response && request.id !== void 0) {
+        options.output.write(`${JSON.stringify(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 }
+      })}
+`);
+    }
+  }
+}
+function parseJsonRpcRequest(line) {
+  const parsed = JSON.parse(line);
+  if (!isRecord3(parsed) || parsed.jsonrpc !== "2.0" || typeof parsed.method !== "string") {
+    throw new Error("Invalid JSON-RPC request.");
+  }
+  return {
+    jsonrpc: "2.0",
+    id: typeof parsed.id === "string" || typeof parsed.id === "number" || parsed.id === null ? parsed.id : void 0,
+    method: parsed.method,
+    params: parsed.params
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/adapters/mcp/connector.ts
+async function runConnector(options) {
+  const auth = new OAuthClient({ endpoint: options.endpoint, tokenStore: new FileTokenStore() });
+  const client = new McpRpcClient({
+    endpoint: options.endpoint,
+    tokenProvider: auth,
+    role: options.role
+  });
+  await runStdioBridge({
+    input: options.input,
+    output: options.output,
+    errorOutput: options.errorOutput,
+    client
+  });
+}
+
+// src/core/output/render.ts
+function renderError(error, options = {}) {
+  const shape = toErrorShape(error);
+  if (options.json) {
+    return `${JSON.stringify(shape, null, 2)}
+`;
+  }
+  return `Error: ${shape.error.message}
+`;
+}
+function toErrorShape(error) {
+  if (error instanceof Error) {
+    const maybe = error;
+    return {
+      ok: false,
+      error: {
+        code: maybe.code ?? "CLI_ERROR",
+        message: error.message,
+        details: redactSecrets(maybe.details)
+      }
+    };
+  }
+  return { ok: false, error: { code: "CLI_ERROR", message: String(error) } };
+}
+function redactSecrets(value) {
+  return redactSecretsInner(value, /* @__PURE__ */ new WeakSet());
+}
+function redactSecretsInner(value, seen) {
+  if (typeof value === "string") {
+    return redactSecretString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSecretsInner(item, seen));
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[circular]";
+    }
+    seen.add(value);
+    const output = {};
+    for (const [key, child] of Object.entries(value)) {
+      output[key] = isSecretKey(key) ? "[redacted]" : redactSecretsInner(child, seen);
+    }
+    return output;
+  }
+  return value;
+}
+function isSecretKey(key) {
+  const normalized = key.toLowerCase().replace(/-/g, "_");
+  return normalized === "authorization" || normalized.includes("access_token") || normalized.includes("refresh_token") || normalized.includes("client_secret") || normalized.includes("token");
+}
+function redactSecretString(value) {
+  return value.replace(/("(?:authorization|access_token|refresh_token|client_secret|token)"\s*:\s*")([^"]*)(")/gi, "$1[redacted]$3").replace(/((?:authorization|access_token|refresh_token|client_secret|token)=)([^&\s"']+)/gi, "$1[redacted]").replace(/(authorization:\s*bearer\s+)([^\s,}]+)/gi, "$1[redacted]").replace(/(bearer\s+)(eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/gi, "$1[redacted]");
+}
+
+// src/adapters/mcp/args.ts
+function parseMcpArgs(argv) {
+  const result = { help: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--env") {
+      result.env = assertEnv(requireFlagValue(arg, argv[++index]));
+    } else if (arg === "--endpoint") {
+      result.endpoint = requireFlagValue(arg, argv[++index]);
+    } else if (arg === "--role") {
+      result.role = assertRole(requireFlagValue(arg, argv[++index]));
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return result;
+}
+function requireFlagValue(flag, value) {
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+
+// src/bin/mcp.ts
+try {
+  const args = parseMcpArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(
+      `Usage: mcp [--env prod|dev] [--endpoint URL] [--role ${HARNESS_ROLES.join("|")}]
+`
+    );
+    process.exit(0);
+  }
+  const resolved = resolveEndpoint({ env: args.env, endpoint: args.endpoint });
+  const resolvedRole = resolveRole({ role: args.role });
+  await runConnector({
+    endpoint: resolved.endpoint,
+    role: resolvedRole.role ?? null,
+    input: process.stdin,
+    output: process.stdout,
+    errorOutput: process.stderr
+  });
+} catch (error) {
+  process.stderr.write(renderError(error));
+  process.exitCode = 1;
+}
+//# sourceMappingURL=mcp.js.map