ethagent 0.2.1 → 1.0.0

package/src/mcp/approvals.ts

@@ -0,0 +1,113 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { z } from 'zod'
+import { atomicWriteText } from '../storage/atomicWrite.js'
+import { ensureConfigDir, getConfigDir } from '../storage/config.js'
+
+export type ProjectMcpDecision = 'approved' | 'rejected'
+
+const ProjectDecisionSchema = z.object({
+  workspaceRoot: z.string().min(1),
+  serverName: z.string().min(1),
+  configHash: z.string().min(1),
+  decision: z.enum(['approved', 'rejected']),
+})
+
+const DisabledServerSchema = z.object({
+  workspaceRoot: z.string().min(1),
+  serverName: z.string().min(1),
+})
+
+const McpLocalStateSchema = z.object({
+  version: z.literal(1),
+  projectServers: z.array(ProjectDecisionSchema),
+  disabledServers: z.array(DisabledServerSchema),
+})
+
+type McpLocalState = z.infer<typeof McpLocalStateSchema>
+
+function getMcpLocalStatePath(): string {
+  return path.join(getConfigDir(), 'mcp-state.json')
+}
+
+export async function getProjectMcpDecision(params: {
+  workspaceRoot: string
+  serverName: string
+  configHash: string
+}): Promise<ProjectMcpDecision | undefined> {
+  const state = await loadMcpLocalState()
+  const workspaceRoot = path.resolve(params.workspaceRoot)
+  return state.projectServers.find(entry =>
+    path.resolve(entry.workspaceRoot) === workspaceRoot &&
+    entry.serverName === params.serverName &&
+    entry.configHash === params.configHash,
+  )?.decision
+}
+
+export async function setProjectMcpDecision(params: {
+  workspaceRoot: string
+  serverName: string
+  configHash: string
+  decision: ProjectMcpDecision
+}): Promise<void> {
+  const state = await loadMcpLocalState()
+  const workspaceRoot = path.resolve(params.workspaceRoot)
+  const next = state.projectServers.filter(entry =>
+    !(path.resolve(entry.workspaceRoot) === workspaceRoot && entry.serverName === params.serverName),
+  )
+  next.push({
+    workspaceRoot,
+    serverName: params.serverName,
+    configHash: params.configHash,
+    decision: params.decision,
+  })
+  await writeMcpLocalState({ ...state, projectServers: next })
+}
+
+export async function isMcpServerDisabled(workspaceRoot: string, serverName: string): Promise<boolean> {
+  const state = await loadMcpLocalState()
+  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
+  return state.disabledServers.some(entry =>
+    path.resolve(entry.workspaceRoot) === normalizedWorkspaceRoot && entry.serverName === serverName,
+  )
+}
+
+export async function setMcpServerEnabled(params: {
+  workspaceRoot: string
+  serverName: string
+  enabled: boolean
+}): Promise<void> {
+  const state = await loadMcpLocalState()
+  const workspaceRoot = path.resolve(params.workspaceRoot)
+  const withoutServer = state.disabledServers.filter(entry =>
+    !(path.resolve(entry.workspaceRoot) === workspaceRoot && entry.serverName === params.serverName),
+  )
+  const disabledServers = params.enabled
+    ? withoutServer
+    : [...withoutServer, { workspaceRoot, serverName: params.serverName }]
+  await writeMcpLocalState({ ...state, disabledServers })
+}
+
+async function loadMcpLocalState(): Promise<McpLocalState> {
+  let raw: string
+  try {
+    raw = await fs.readFile(getMcpLocalStatePath(), 'utf8')
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return emptyState()
+    throw err
+  }
+  try {
+    return McpLocalStateSchema.parse(JSON.parse(raw))
+  } catch {
+    return emptyState()
+  }
+}
+
+async function writeMcpLocalState(state: McpLocalState): Promise<void> {
+  await ensureConfigDir()
+  await atomicWriteText(getMcpLocalStatePath(), JSON.stringify(McpLocalStateSchema.parse(state), null, 2) + '\n')
+}
+
+function emptyState(): McpLocalState {
+  return { version: 1, projectServers: [], disabledServers: [] }
+}

package/src/mcp/config.ts

@@ -0,0 +1,235 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { z } from 'zod'
+import { atomicWriteText } from '../storage/atomicWrite.js'
+import { ensureConfigDir, getConfigDir } from '../storage/config.js'
+
+export type McpConfigScope = 'user' | 'project'
+
+const McpStdioServerConfigSchema = z.object({
+  type: z.literal('stdio').optional(),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional(),
+  cwd: z.string().min(1).optional(),
+})
+
+const McpHttpServerConfigSchema = z.object({
+  type: z.literal('http'),
+  url: z.string().url(),
+  headers: z.record(z.string()).optional(),
+})
+
+const McpSseServerConfigSchema = z.object({
+  type: z.literal('sse'),
+  url: z.string().url(),
+  headers: z.record(z.string()).optional(),
+})
+
+export const McpServerConfigSchema = z.union([
+  McpStdioServerConfigSchema,
+  McpHttpServerConfigSchema,
+  McpSseServerConfigSchema,
+])
+
+export const McpJsonConfigSchema = z.object({
+  mcpServers: z.record(McpServerConfigSchema),
+})
+
+export type McpServerConfig = z.infer<typeof McpServerConfigSchema>
+export type McpJsonConfig = z.infer<typeof McpJsonConfigSchema>
+
+export type ScopedMcpServerConfig = {
+  name: string
+  scope: McpConfigScope
+  config: McpServerConfig
+  configHash: string
+}
+
+export type McpConfigIssue = {
+  scope: McpConfigScope
+  filePath: string
+  serverName?: string
+  severity: 'error' | 'warning'
+  message: string
+}
+
+export type LoadedMcpConfigs = {
+  servers: ScopedMcpServerConfig[]
+  issues: McpConfigIssue[]
+}
+
+export function getUserMcpConfigPath(): string {
+  return path.join(getConfigDir(), 'mcp.json')
+}
+
+export function getProjectMcpConfigPath(cwd: string): string {
+  return path.join(path.resolve(cwd), '.mcp.json')
+}
+
+export async function loadMcpConfigs(cwd: string): Promise<LoadedMcpConfigs> {
+  const user = await readMcpConfigFile(getUserMcpConfigPath(), 'user', true)
+  const project = await readMcpConfigFile(getProjectMcpConfigPath(cwd), 'project', true)
+  const byName = new Map<string, ScopedMcpServerConfig>()
+  for (const server of user.servers) byName.set(server.name, server)
+  for (const server of project.servers) byName.set(server.name, server)
+  return {
+    servers: [...byName.values()],
+    issues: [...user.issues, ...project.issues],
+  }
+}
+
+export async function addMcpServerConfig(params: {
+  cwd: string
+  scope: McpConfigScope
+  name: string
+  config: McpServerConfig
+}): Promise<string> {
+  const filePath = params.scope === 'user' ? getUserMcpConfigPath() : getProjectMcpConfigPath(params.cwd)
+  const current = await readRawMcpConfig(filePath)
+  current.mcpServers[params.name] = params.config
+  if (params.scope === 'user') await ensureConfigDir()
+  await atomicWriteText(filePath, JSON.stringify(current, null, 2) + '\n')
+  return filePath
+}
+
+export function parseMcpServerConfigJson(value: string): McpServerConfig {
+  return McpServerConfigSchema.parse(JSON.parse(value))
+}
+
+export function mcpServerTransport(config: McpServerConfig): 'stdio' | 'http' | 'sse' {
+  return config.type === 'http' || config.type === 'sse' ? config.type : 'stdio'
+}
+
+export function stableMcpConfigHash(config: McpServerConfig): string {
+  return crypto.createHash('sha256').update(stableJson(config)).digest('hex').slice(0, 16)
+}
+
+async function readMcpConfigFile(
+  filePath: string,
+  scope: McpConfigScope,
+  expandVars: boolean,
+): Promise<LoadedMcpConfigs> {
+  let raw: string
+  try {
+    raw = await fs.readFile(filePath, 'utf8')
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return { servers: [], issues: [] }
+    return {
+      servers: [],
+      issues: [{ scope, filePath, severity: 'error', message: `failed to read MCP config: ${(err as Error).message}` }],
+    }
+  }
+
+  let parsedJson: unknown
+  try {
+    parsedJson = JSON.parse(raw)
+  } catch (err: unknown) {
+    return {
+      servers: [],
+      issues: [{ scope, filePath, severity: 'error', message: `MCP config is not valid JSON: ${(err as Error).message}` }],
+    }
+  }
+
+  const parsed = McpJsonConfigSchema.safeParse(parsedJson)
+  if (!parsed.success) {
+    return {
+      servers: [],
+      issues: parsed.error.issues.map(issue => ({
+        scope,
+        filePath,
+        severity: 'error',
+        message: `MCP config schema error at ${issue.path.join('.') || 'root'}: ${issue.message}`,
+      })),
+    }
+  }
+
+  const servers: ScopedMcpServerConfig[] = []
+  const issues: McpConfigIssue[] = []
+  for (const [name, config] of Object.entries(parsed.data.mcpServers)) {
+    const expanded = expandVars ? expandEnvVars(config) : { config, missing: [] }
+    if (expanded.missing.length > 0) {
+      issues.push({
+        scope,
+        filePath,
+        serverName: name,
+        severity: 'warning',
+        message: `missing environment variables: ${expanded.missing.join(', ')}`,
+      })
+    }
+    if (process.platform === 'win32' && 'command' in expanded.config && isBareNpxCommand(expanded.config.command)) {
+      issues.push({
+        scope,
+        filePath,
+        serverName: name,
+        severity: 'warning',
+        message: 'Windows MCP stdio servers should use command "cmd" with args ["/c", "npx", ...]',
+      })
+    }
+    servers.push({
+      name,
+      scope,
+      config: expanded.config,
+      configHash: stableMcpConfigHash(expanded.config),
+    })
+  }
+  return { servers, issues }
+}
+
+async function readRawMcpConfig(filePath: string): Promise<McpJsonConfig> {
+  let raw: string
+  try {
+    raw = await fs.readFile(filePath, 'utf8')
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return { mcpServers: {} }
+    throw err
+  }
+  return McpJsonConfigSchema.parse(JSON.parse(raw))
+}
+
+function expandEnvVars(config: McpServerConfig): { config: McpServerConfig; missing: string[] } {
+  const missing = new Set<string>()
+  const expanded = expandValue(config, missing)
+  return { config: McpServerConfigSchema.parse(expanded), missing: [...missing].sort() }
+}
+
+function expandValue(value: unknown, missing: Set<string>): unknown {
+  if (typeof value === 'string') return expandString(value, missing)
+  if (Array.isArray(value)) return value.map(item => expandValue(item, missing))
+  if (value && typeof value === 'object') {
+    const out: Record<string, unknown> = {}
+    for (const [key, child] of Object.entries(value)) out[key] = expandValue(child, missing)
+    return out
+  }
+  return value
+}
+
+function expandString(value: string, missing: Set<string>): string {
+  return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-(.*?))?\}/g, (_match, name: string, fallback: string | undefined) => {
+    const envValue = process.env[name]
+    if (envValue !== undefined) return envValue
+    if (fallback !== undefined) return fallback
+    missing.add(name)
+    return ''
+  })
+}
+
+function isBareNpxCommand(command: string): boolean {
+  const normalized = command.replace(/\\/g, '/').toLowerCase()
+  return normalized === 'npx' || normalized.endsWith('/npx')
+}
+
+function stableJson(value: unknown): string {
+  return JSON.stringify(sortForStableJson(value))
+}
+
+function sortForStableJson(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortForStableJson)
+  if (value && typeof value === 'object') {
+    const out: Record<string, unknown> = {}
+    for (const key of Object.keys(value).sort()) out[key] = sortForStableJson((value as Record<string, unknown>)[key])
+    return out
+  }
+  return value
+}