expandai 0.0.4 → 0.0.6

package/src/Install/Codex/Mcp.ts

@@ -1,114 +0,0 @@
-import { homedir } from 'node:os'
-import { Config, Console, Effect, Match, Record, Schema } from 'effect'
-import { parse, stringify, type TomlTableWithoutBigInt } from 'smol-toml'
-import { CliInvocation, ConfigIo, McpParseError, McpWriteError, SERVER_KEY } from '../Domain.js'
-import type { InstallScope } from '../Mcp.js'
-
-export class Entry extends Schema.Class<Entry>('CodexMcpEntry')({
-	command: Schema.NonEmptyTrimmedString,
-	args: Schema.Array(Schema.String),
-	env: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
-	enabled: Schema.Boolean,
-}) {}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-const getMcpServers = Effect.fn(function* (config: TomlTableWithoutBigInt) {
-	const servers = config.mcp_servers
-	return isRecord(servers) ? servers : {}
-})
-
-function toStringifyValue(value: TomlTableWithoutBigInt) {
-	// smol-toml's stringify type accepts any; keep the unsafe boundary local.
-	return value as unknown as Record<string, unknown>
-}
-
-/**
- * Codex MCP descriptor — Codex stores MCP servers in TOML config under
- * `[mcp_servers.<name>]`.
- *
- *   - global  → `~/.codex/config.toml`
- *   - project → `<cwd>/.codex/config.toml`
- */
-export class CodexMcp extends Effect.Service<CodexMcp>()('@expandai/cli/Install/Codex/Mcp', {
-	dependencies: [ConfigIo.Default, CliInvocation.Default],
-	effect: Effect.gen(function* () {
-		const io = yield* ConfigIo
-		const cli = yield* CliInvocation
-		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-
-		const pathFor = Effect.fn(function* (scope: InstallScope) {
-			return yield* Match.value(scope).pipe(
-				Match.when('global', () => Effect.succeed(`${home}/.codex/config.toml`)),
-				Match.when('project', () => Effect.succeed(`${cwd}/.codex/config.toml`)),
-				Match.exhaustive,
-			)
-		})
-
-		const readConfig = Effect.fn(function* (file: string) {
-			const text = yield* io.readText(file)
-			return yield* Effect.try({
-				try: () => parse(text, { integersAsBigInt: false }),
-				catch: (error) => new McpParseError({ path: file, error }),
-			})
-		})
-
-		const writeConfig = Effect.fn(function* (file: string, value: TomlTableWithoutBigInt) {
-			const encoded = yield* Effect.try({
-				try: () => stringify(toStringifyValue(value)),
-				catch: (error) => new McpWriteError({ path: file, error }),
-			})
-			yield* io.writeText(file, encoded).pipe(Effect.mapError((error) => new McpWriteError({ path: file, error })))
-		})
-
-		const install = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const config = yield* readConfig(file)
-			const servers = yield* getMcpServers(config)
-
-			const invocation = yield* cli.resolve()
-			const entryModel = new Entry({
-				command: invocation.command,
-				args: [...invocation.args, 'mcp', 'run'],
-				env: { EXPANDAI_HARNESS: 'codex' },
-				enabled: true,
-			})
-
-			const entry: TomlTableWithoutBigInt = {
-				command: entryModel.command,
-				args: [...entryModel.args],
-				env: { ...entryModel.env },
-				enabled: entryModel.enabled,
-			}
-
-			yield* writeConfig(file, {
-				...config,
-				mcp_servers: Record.set(servers, SERVER_KEY, entry),
-			})
-			yield* Console.log(`Installed expandai MCP server into ${file}`)
-		})
-
-		const uninstall = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const config = yield* readConfig(file)
-			const servers = yield* getMcpServers(config)
-			if (!(SERVER_KEY in servers)) {
-				return
-			}
-			yield* writeConfig(file, { ...config, mcp_servers: Record.remove(servers, SERVER_KEY) })
-			yield* Console.log(`Removed expandai MCP server from ${file}`)
-		})
-
-		const isInstalled = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const config = yield* readConfig(file)
-			const servers = yield* getMcpServers(config)
-			return SERVER_KEY in servers
-		})
-
-		return { install, uninstall, isInstalled, pathFor } as const
-	}),
-}) {}

package/src/Install/Codex/Skill.ts

@@ -1,44 +0,0 @@
-import { homedir } from 'node:os'
-import { Config, Effect, Match } from 'effect'
-import { SkillIo } from '../Domain.js'
-import type { InstallScope } from '../Mcp.js'
-
-/**
- * Codex skills use the open agent skills locations:
- *
- *   - global  → `~/.agents/skills/<name>/`
- *   - project → `<cwd>/.agents/skills/<name>/`
- */
-
-export const SKILL_NAME = 'expandai'
-
-export class CodexSkill extends Effect.Service<CodexSkill>()('@expandai/cli/Install/Codex/Skill', {
-	dependencies: [SkillIo.Default],
-	effect: Effect.gen(function* () {
-		const io = yield* SkillIo
-		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-
-		const pathFor = Effect.fn(function* (scope: InstallScope) {
-			return yield* Match.value(scope).pipe(
-				Match.when('global', () => Effect.succeed(`${home}/.agents/skills/${SKILL_NAME}`)),
-				Match.when('project', () => Effect.succeed(`${cwd}/.agents/skills/${SKILL_NAME}`)),
-				Match.exhaustive,
-			)
-		})
-
-		const install = Effect.fn(function* (scope: InstallScope) {
-			return yield* io.install(yield* pathFor(scope))
-		})
-
-		const uninstall = Effect.fn(function* (scope: InstallScope) {
-			return yield* io.uninstall(yield* pathFor(scope))
-		})
-
-		const isCurrent = Effect.fn(function* (scope: InstallScope) {
-			return yield* io.isCurrent(yield* pathFor(scope))
-		})
-
-		return { install, uninstall, isCurrent, pathFor } as const
-	}),
-}) {}

package/src/Install/Cursor/Mcp.ts

@@ -1,85 +0,0 @@
-import { homedir } from 'node:os'
-import { Config, Console, Effect, Match, Record, Schema } from 'effect'
-import { CliInvocation, ConfigIo, McpParseError, McpServersConfigSchema, McpWriteError, SERVER_KEY } from '../Domain.js'
-import type { InstallScope } from '../Mcp.js'
-
-/**
- * Cursor MCP descriptor — same `mcpServers` shape as Claude Code, different
- * paths.
- *
- *   - global  → `~/.cursor/mcp.json`
- *   - project → `<cwd>/.cursor/mcp.json`
- */
-export class Entry extends Schema.Class<Entry>('CursorMcpEntry')({
-	type: Schema.Literal('stdio'),
-	command: Schema.NonEmptyTrimmedString,
-	args: Schema.Array(Schema.String),
-	env: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
-}) {}
-
-export class CursorMcp extends Effect.Service<CursorMcp>()('@expandai/cli/Install/Cursor/Mcp', {
-	dependencies: [ConfigIo.Default, CliInvocation.Default],
-	effect: Effect.gen(function* () {
-		const io = yield* ConfigIo
-		const cli = yield* CliInvocation
-		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-
-		const pathFor = Effect.fn(function* (scope: InstallScope) {
-			return yield* Match.value(scope).pipe(
-				Match.when('global', () => Effect.succeed(`${home}/.cursor/mcp.json`)),
-				Match.when('project', () => Effect.succeed(`${cwd}/.cursor/mcp.json`)),
-				Match.exhaustive,
-			)
-		})
-
-		const readConfig = Effect.fn(function* (file: string) {
-			return yield* io
-				.read(file, McpServersConfigSchema)
-				.pipe(Effect.mapError((error) => new McpParseError({ path: file, error })))
-		})
-
-		const writeConfig = Effect.fn(function* (file: string, value: unknown) {
-			yield* io
-				.write(file, value, McpServersConfigSchema)
-				.pipe(Effect.mapError((error) => new McpWriteError({ path: file, error })))
-		})
-
-		const install = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const config = yield* readConfig(file)
-			const invocation = yield* cli.resolve()
-			yield* writeConfig(file, {
-				...config,
-				mcpServers: {
-					...config.mcpServers,
-					[SERVER_KEY]: new Entry({
-						type: 'stdio',
-						command: invocation.command,
-						args: [...invocation.args, 'mcp', 'run'],
-						env: { EXPANDAI_HARNESS: 'cursor' },
-					}),
-				},
-			})
-			yield* Console.log(`Installed expandai MCP server into ${file}`)
-		})
-
-		const uninstall = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const config = yield* readConfig(file)
-			if (!(SERVER_KEY in config.mcpServers)) {
-				return
-			}
-			yield* writeConfig(file, { ...config, mcpServers: Record.remove(config.mcpServers, SERVER_KEY) })
-			yield* Console.log(`Removed expandai MCP server from ${file}`)
-		})
-
-		const isInstalled = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const config = yield* readConfig(file)
-			return SERVER_KEY in config.mcpServers
-		})
-
-		return { install, uninstall, isInstalled, pathFor } as const
-	}),
-}) {}

package/src/Install/Cursor/Skill.ts

@@ -1,51 +0,0 @@
-import { homedir } from 'node:os'
-import { Config, Effect, Match } from 'effect'
-import { SkillIo } from '../Domain.js'
-import type { InstallScope } from '../Mcp.js'
-
-/**
- * Cursor skills are auto-loaded from these locations (per
- * cursor.com/docs/skills):
- *
- *   - global  → `~/.cursor/skills/<name>/`
- *   - project → `<cwd>/.cursor/skills/<name>/`
- *
- * Cursor also compat-loads `.claude/skills/`, `.codex/skills/`, `.agents/skills/`
- * at both project and user scope, but we ship to Cursor's native paths.
- *
- * Format is the same SKILL.md + YAML frontmatter open standard as Claude Code
- * and OpenCode, so the bundled `skills/expandai/` directory copies in unchanged.
- */
-
-export const SKILL_NAME = 'expandai'
-
-export class CursorSkill extends Effect.Service<CursorSkill>()('@expandai/cli/Install/Cursor/Skill', {
-	dependencies: [SkillIo.Default],
-	effect: Effect.gen(function* () {
-		const io = yield* SkillIo
-		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-
-		const pathFor = Effect.fn(function* (scope: InstallScope) {
-			return yield* Match.value(scope).pipe(
-				Match.when('global', () => Effect.succeed(`${home}/.cursor/skills/${SKILL_NAME}`)),
-				Match.when('project', () => Effect.succeed(`${cwd}/.cursor/skills/${SKILL_NAME}`)),
-				Match.exhaustive,
-			)
-		})
-
-		const install = Effect.fn(function* (scope: InstallScope) {
-			return yield* io.install(yield* pathFor(scope))
-		})
-
-		const uninstall = Effect.fn(function* (scope: InstallScope) {
-			return yield* io.uninstall(yield* pathFor(scope))
-		})
-
-		const isCurrent = Effect.fn(function* (scope: InstallScope) {
-			return yield* io.isCurrent(yield* pathFor(scope))
-		})
-
-		return { install, uninstall, isCurrent, pathFor } as const
-	}),
-}) {}

package/src/Install/Domain.ts

@@ -1,221 +0,0 @@
-import { FileSystem, Path } from '@effect/platform'
-import { NodeFileSystem, NodePath } from '@effect/platform-node'
-import { Array, Config, Effect, Inspectable, Layer, Schema, String } from 'effect'
-
-export class McpParseError extends Schema.TaggedError<McpParseError>()('McpParseError', {
-	path: Schema.String,
-	error: Schema.Defect,
-}) {
-	get message() {
-		return `Failed to parse MCP config at ${this.path}: ${Inspectable.format(this.error)}`
-	}
-}
-
-export class McpWriteError extends Schema.TaggedError<McpWriteError>()('McpWriteError', {
-	path: Schema.String,
-	error: Schema.Defect,
-}) {
-	get message() {
-		return `Failed to write MCP config at ${this.path}: ${Inspectable.format(this.error)}`
-	}
-}
-
-export const Host = Schema.Literal('claude-code', 'cursor', 'opencode', 'codex')
-export type Host = typeof Host.Type
-
-/**
- * The agent harness invoking the CLI — every install target plus 'unknown'
- * for uninstrumented callers. Installers bake `EXPANDAI_HARNESS=<host>` into
- * MCP/hook configs; telemetry reads it back.
- */
-export const Harness = Schema.Literal(...Host.literals, 'unknown')
-export type Harness = typeof Harness.Type
-
-export const InstallScope = Schema.Literal('project', 'global')
-export type InstallScope = typeof InstallScope.Type
-
-const McpServerMap = Schema.Record({ key: Schema.String, value: Schema.Unknown })
-
-export const McpServersConfigSchema = Schema.parseJson(
-	Schema.Struct({ mcpServers: Schema.optionalWith(McpServerMap, { default: () => ({}) }) }, McpServerMap),
-	{ space: 2 },
-)
-
-export const OpencodeConfigSchema = Schema.parseJson(
-	Schema.Struct({ mcp: Schema.optionalWith(McpServerMap, { default: () => ({}) }) }, McpServerMap),
-	{ space: 2 },
-)
-
-export const SERVER_KEY = 'expandai'
-
-/** How a host config should launch the CLI: `command` plus leading args. */
-export interface CliCommand {
-	readonly command: string
-	readonly args: ReadonlyArray<string>
-}
-
-export const DIRECT_CLI: CliCommand = { command: 'expandai', args: [] }
-const NPX_CLI: CliCommand = { command: 'npx', args: ['-y', 'expandai'] }
-
-/**
- * Renders a `CliCommand` as the single shell string Claude Code stores for hook
- * entries. MCP descriptors keep `command`/`args` separate because they exec
- * directly; hooks are run through a shell, so they need one flat line.
- */
-export function cliShellCommand(cli: CliCommand, args: ReadonlyArray<string>): string {
-	return [cli.command, ...cli.args, ...args].join(' ')
-}
-
-/**
- * Resolves how installed host configs should invoke the expandai CLI. MCP
- * entries exec their `command` directly (no shell), so the fallback decision
- * happens at install time: prefer the `expandai` binary when it is on PATH,
- * otherwise write an `npx -y expandai` invocation so installs performed via
- * `npx expandai …` keep working without a global CLI install.
- */
-const makeCliInvocation = Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem
-	const path = yield* Path.Path
-	const searchPath = yield* Config.string('PATH').pipe(Config.withDefault(''))
-
-	const resolve = Effect.fn('CliInvocation.resolve')(function* () {
-		// ':' is the POSIX PATH delimiter — the install flow already assumes
-		// POSIX conventions (HOME-based config paths, shell hooks).
-		const onPath = yield* Effect.exists(Array.filter(searchPath.split(':'), String.isNonEmpty), (dir) =>
-			fs.exists(path.join(dir, 'expandai')).pipe(Effect.orElseSucceed(() => false)),
-		)
-		return onPath ? DIRECT_CLI : NPX_CLI
-	})
-
-	return { resolve } as const
-})
-
-export class CliInvocation extends Effect.Service<CliInvocation>()('@expandai/cli/Install/CliInvocation', {
-	dependencies: [NodeFileSystem.layer, NodePath.layer],
-	effect: makeCliInvocation,
-}) {
-	/** Dependency-open layer so fixtures can supply their own file system and PATH. */
-	static readonly layer = Layer.effect(CliInvocation, makeCliInvocation.pipe(Effect.map(CliInvocation.make)))
-}
-
-export const readConfigText = Effect.fn(function* (file: string) {
-	const fs = yield* FileSystem.FileSystem
-	const exists = yield* fs.exists(file)
-	if (!exists) {
-		return '{}'
-	}
-	return yield* fs.readFileString(file)
-})
-
-export const writeConfigText = Effect.fn(function* (file: string, text: string) {
-	const fs = yield* FileSystem.FileSystem
-	const path = yield* Path.Path
-	yield* fs.makeDirectory(path.dirname(file), { recursive: true })
-	yield* fs.writeFileString(file, `${text}\n`)
-})
-
-/**
- * Captures `FileSystem` + `Path` once and exposes string-encoded JSON read/
- * write methods that don't re-yield them on every call. Use this from inside
- * an `Effect.Service` gen block so the install/uninstall methods don't have
- * to re-thread `provideService` calls.
- */
-export class ConfigIo extends Effect.Service<ConfigIo>()('@expandai/cli/Install/ConfigIo', {
-	dependencies: [NodeFileSystem.layer, NodePath.layer],
-	effect: Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem
-		const path = yield* Path.Path
-
-		const read = Effect.fn('ConfigIo.read')(function* <A>(file: string, schema: Schema.Schema<A, string>) {
-			const text = yield* readConfigText(file).pipe(Effect.provideService(FileSystem.FileSystem, fs))
-			return yield* Schema.decode(schema)(text)
-		})
-
-		const write = Effect.fn('ConfigIo.write')(function* <A>(
-			file: string,
-			value: unknown,
-			schema: Schema.Schema<A, string>,
-		) {
-			const encoded = yield* Schema.encodeUnknown(schema)(value)
-			yield* writeConfigText(file, encoded).pipe(
-				Effect.provideService(FileSystem.FileSystem, fs),
-				Effect.provideService(Path.Path, path),
-			)
-		})
-
-		const exists = Effect.fn('ConfigIo.exists')(function* (file: string) {
-			return yield* fs.exists(file)
-		})
-
-		// Raw text I/O for formats `ConfigIo.read`/`write` can't handle through a
-		// `Schema.parseJson(...)` schema (e.g. Codex's TOML). Missing file reads
-		// as an empty string — callers attach their own parser-specific default.
-		const readText = Effect.fn('ConfigIo.readText')(function* (file: string) {
-			const present = yield* fs.exists(file)
-			return present ? yield* fs.readFileString(file) : ''
-		})
-
-		const writeText = Effect.fn('ConfigIo.writeText')(function* (file: string, text: string) {
-			yield* writeConfigText(file, text).pipe(
-				Effect.provideService(FileSystem.FileSystem, fs),
-				Effect.provideService(Path.Path, path),
-			)
-		})
-
-		return { read, write, exists, readText, writeText } as const
-	}),
-}) {}
-
-/**
- * Captures `FileSystem` + `Path` once and exposes skill directory copy/remove
- * operations. The bundled `SKILL.md` lives at `<cli>/skills/expandai/` (or
- * `<build>/skills/expandai/` in production); this service computes that path
- * from its own `import.meta.url`, so per-host skill descriptors only need to
- * provide `pathFor` and call `io.install(target)` / `io.uninstall(target)`.
- */
-export class SkillIo extends Effect.Service<SkillIo>()('@expandai/cli/Install/SkillIo', {
-	dependencies: [NodeFileSystem.layer, NodePath.layer],
-	effect: Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem
-		const path = yield* Path.Path
-
-		const sourceDir = path.resolve(
-			path.dirname(yield* path.fromFileUrl(new URL(import.meta.url))),
-			'..',
-			'..',
-			'skills',
-			'expandai',
-		)
-
-		const install = Effect.fn('SkillIo.install')(function* (target: string) {
-			yield* fs.makeDirectory(path.dirname(target), { recursive: true })
-			yield* fs.copy(sourceDir, target, { overwrite: true })
-			return target
-		})
-
-		const uninstall = Effect.fn('SkillIo.uninstall')(function* (target: string) {
-			const exists = yield* fs.exists(target)
-			if (exists) {
-				yield* fs.remove(target, { recursive: true })
-			}
-			return target
-		})
-
-		/**
-		 * Whether the installed skill matches the bundled one. Presence alone is not
-		 * enough: an upgraded CLI ships new skill text, and a harness whose install is
-		 * gated on "the file exists" would keep serving the old instructions forever.
-		 */
-		const isCurrent = Effect.fn('SkillIo.isCurrent')(function* (target: string) {
-			const targetFile = path.join(target, 'SKILL.md')
-			if (!(yield* fs.exists(targetFile))) return false
-			const [installed, bundled] = yield* Effect.all([
-				fs.readFileString(targetFile),
-				fs.readFileString(path.join(sourceDir, 'SKILL.md')),
-			])
-			return installed === bundled
-		})
-
-		return { install, uninstall, isCurrent } as const
-	}),
-}) {}

package/src/Install/Hook.ts

@@ -1,50 +0,0 @@
-import { Effect, Match, Schema } from 'effect'
-import { ClaudeHook } from './Claude/Hook.js'
-import { type InstallScope, Mcp } from './Mcp.js'
-import { OpencodeHook } from './Opencode/Hook.js'
-
-/**
- * Hook install dispatcher. Bundles MCP install + per-host hook config:
- *
- *   - claude-code: writes the matcher into `~/.claude/settings.json` (global)
- *     or `<cwd>/.claude/settings.json` (project), then registers expandai as
- *     an MCP server at the matching scope.
- *   - opencode:    writes the webfetch plugin file into `.opencode/plugins/`
- *     (project) or `~/.config/opencode/plugins/` (global), plus registers
- *     expandai as an MCP server.
- *
- * Cursor has no hook system per opencode.ai/docs and Cursor's docs, so it's
- * absent from this Host union (compare with `Mcp.Host` which includes Cursor).
- */
-export const HookHost = Schema.Literal('claude-code', 'opencode')
-export type HookHost = typeof HookHost.Type
-
-export class HookInstaller extends Effect.Service<HookInstaller>()('@expandai/cli/Install/Hook', {
-	dependencies: [Mcp.Default, ClaudeHook.Default, OpencodeHook.Default],
-	effect: Effect.gen(function* () {
-		const mcp = yield* Mcp
-		const claudeHook = yield* ClaudeHook
-		const opencodeHook = yield* OpencodeHook
-
-		const install = Effect.fn('HookInstaller.install')(function* (host: HookHost, scope: InstallScope) {
-			// Bundle: MCP install first, then host-specific hook config.
-			yield* mcp.install(host, scope)
-			yield* Match.value(host).pipe(
-				Match.when('claude-code', () => claudeHook.install(scope)),
-				Match.when('opencode', () => opencodeHook.install(scope)),
-				Match.exhaustive,
-			)
-		})
-
-		const uninstall = Effect.fn('HookInstaller.uninstall')(function* (host: HookHost, scope: InstallScope) {
-			yield* Match.value(host).pipe(
-				Match.when('claude-code', () => claudeHook.uninstall(scope)),
-				Match.when('opencode', () => opencodeHook.uninstall(scope)),
-				Match.exhaustive,
-			)
-			yield* mcp.uninstall(host, scope)
-		})
-
-		return { install, uninstall } as const
-	}),
-}) {}

package/src/Install/Mcp.ts

@@ -1,71 +0,0 @@
-import { Effect, Match } from 'effect'
-import { ClaudeMcp } from './Claude/Mcp.js'
-import { CodexMcp } from './Codex/Mcp.js'
-import { CursorMcp } from './Cursor/Mcp.js'
-import type { Host, InstallScope } from './Domain.js'
-import { OpencodeMcp } from './Opencode/Mcp.js'
-
-export { Host, InstallScope, McpParseError, McpWriteError } from './Domain.js'
-
-/**
- * MCP install dispatcher. Per-host descriptors live in `Install/<Host>/Mcp.ts`
- * and contribute their path resolution + entry shape; this service handles
- * the file I/O (read existing config, merge, write back) and routes by host.
- *
- *   - claude-code (~/.claude.json | <cwd>/.mcp.json) → mcpServers shape
- *   - cursor      (~/.cursor/mcp.json | <cwd>/.cursor/mcp.json) → mcpServers
- *   - opencode    (~/.config/opencode/opencode.json | <cwd>/opencode.json) → opencode `mcp` shape
- *   - codex       (~/.codex/config.toml | <cwd>/.codex/config.toml) → Codex TOML `mcp_servers`
- */
-
-export class Mcp extends Effect.Service<Mcp>()('@expandai/cli/Install/Mcp', {
-	dependencies: [ClaudeMcp.Default, CursorMcp.Default, OpencodeMcp.Default, CodexMcp.Default],
-	effect: Effect.gen(function* () {
-		const claude = yield* ClaudeMcp
-		const cursor = yield* CursorMcp
-		const opencode = yield* OpencodeMcp
-		const codex = yield* CodexMcp
-
-		const pathFor = Effect.fn('Mcp.pathFor')(function* (host: Host, scope: InstallScope) {
-			return yield* Match.value(host).pipe(
-				Match.when('claude-code', () => claude.pathFor(scope)),
-				Match.when('cursor', () => cursor.pathFor(scope)),
-				Match.when('opencode', () => opencode.pathFor(scope)),
-				Match.when('codex', () => codex.pathFor(scope)),
-				Match.exhaustive,
-			)
-		})
-
-		const install = Effect.fn('Mcp.install')(function* (host: Host, scope: InstallScope) {
-			yield* Match.value(host).pipe(
-				Match.when('claude-code', () => claude.install(scope)),
-				Match.when('cursor', () => cursor.install(scope)),
-				Match.when('opencode', () => opencode.install(scope)),
-				Match.when('codex', () => codex.install(scope)),
-				Match.exhaustive,
-			)
-		})
-
-		const uninstall = Effect.fn('Mcp.uninstall')(function* (host: Host, scope: InstallScope) {
-			yield* Match.value(host).pipe(
-				Match.when('claude-code', () => claude.uninstall(scope)),
-				Match.when('cursor', () => cursor.uninstall(scope)),
-				Match.when('opencode', () => opencode.uninstall(scope)),
-				Match.when('codex', () => codex.uninstall(scope)),
-				Match.exhaustive,
-			)
-		})
-
-		const isInstalled = Effect.fn('Mcp.isInstalled')(function* (host: Host, scope: InstallScope) {
-			return yield* Match.value(host).pipe(
-				Match.when('claude-code', () => claude.isInstalled(scope)),
-				Match.when('cursor', () => cursor.isInstalled(scope)),
-				Match.when('opencode', () => opencode.isInstalled(scope)),
-				Match.when('codex', () => codex.isInstalled(scope)),
-				Match.exhaustive,
-			)
-		})
-
-		return { install, uninstall, isInstalled, pathFor } as const
-	}),
-}) {}