saeeol 1.4.1 → 1.4.3

package/src/mcp/mcp-types.ts

@@ -1,110 +0,0 @@
-// The MCP SDK only sets windowsHide:true in Electron (checks `'type' in process`).
-if (process.platform === "win32" && !("type" in process)) {
-  Object.defineProperty(process, "type", { value: "saeeol-bun", configurable: true })
-}
-
-import { type Tool, type JSONSchema7, dynamicTool, jsonSchema } from "ai"
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import { type Tool as MCPToolDef, CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js"
-import { ConfigMCP } from "../config/mcp"
-import { Config } from "@/config/config"
-import * as Log from "@saeeol/core/util/log"
-import { NamedError } from "@saeeol/core/util/error"
-import z from "zod/v4"
-import { InstallationVersion } from "@saeeol/core/installation/version"
-import { withTimeout } from "@/util/timeout"
-import { BusEvent } from "../bus/bus-event"
-import { Effect, Schema } from "effect"
-import { zod as effectZod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-const log = Log.create({ service: "mcp" })
-
-export const DEFAULT_TIMEOUT = 30_000
-
-export function ensureDockerRm(cmd: string, args: string[]): string[] {
-  const isDocker = cmd === "docker" || cmd === "podman"
-  if (!isDocker) return args
-  const runIdx = args.indexOf("run")
-  if (runIdx < 0) return args
-  if (args.includes("--rm")) return args
-  const result = [...args]
-  result.splice(runIdx + 1, 0, "--rm")
-  return result
-}
-
-export const Resource = Schema.Struct({
-  name: Schema.String, uri: Schema.String,
-  description: Schema.optional(Schema.String), mimeType: Schema.optional(Schema.String),
-  client: Schema.String,
-}).annotate({ identifier: "McpResource" }).pipe(withStatics((s) => ({ zod: effectZod(s) })))
-export type Resource = Schema.Schema.Type<typeof Resource>
-
-export const ToolsChanged = BusEvent.define("mcp.tools.changed", Schema.Struct({ server: Schema.String }))
-export const BrowserOpenFailed = BusEvent.define("mcp.browser.open.failed", Schema.Struct({ mcpName: Schema.String, url: Schema.String }))
-export const Failed = NamedError.create("MCPFailed", z.object({ name: z.string() }))
-
-export type MCPClient = Client
-export type McpEntry = NonNullable<Config.Info["mcp"]>[string]
-
-const StatusConnected = Schema.Struct({ status: Schema.Literal("connected") }).annotate({ identifier: "MCPStatusConnected" })
-const StatusDisabled = Schema.Struct({ status: Schema.Literal("disabled") }).annotate({ identifier: "MCPStatusDisabled" })
-const StatusFailed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.String }).annotate({ identifier: "MCPStatusFailed" })
-const StatusNeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({ identifier: "MCPStatusNeedsAuth" })
-const StatusNeedsReg = Schema.Struct({ status: Schema.Literal("needs_client_registration"), error: Schema.String }).annotate({ identifier: "MCPStatusNeedsClientRegistration" })
-
-export const Status = Schema.Union([StatusConnected, StatusDisabled, StatusFailed, StatusNeedsAuth, StatusNeedsReg])
-  .annotate({ identifier: "MCPStatus", discriminator: "status" })
-  .pipe(withStatics((s) => ({ zod: effectZod(s) })))
-export type Status = Schema.Schema.Type<typeof Status>
-
-export const sanitize = (s: string) => s.replace(/[^a-zA-Z0-9_-]/g, "_")
-export function remoteURL(key: string, value: string) {
-  if (URL.canParse(value)) return new URL(value)
-  log.warn("invalid remote mcp url", { key })
-}
-export function isMcpConfigured(entry: McpEntry): entry is ConfigMCP.Info {
-  return typeof entry === "object" && entry !== null && "type" in entry
-}
-
-export function convertMcpTool(mcpTool: MCPToolDef, client: MCPClient, timeout?: number): Tool {
-  const inputSchema = mcpTool.inputSchema
-  const schema: JSONSchema7 = { ...(inputSchema as JSONSchema7), type: "object", properties: (inputSchema.properties ?? {}) as JSONSchema7["properties"], additionalProperties: false }
-  return dynamicTool({
-    description: mcpTool.description ?? "", inputSchema: jsonSchema(schema),
-    execute: async (args: unknown) => client.callTool({ name: mcpTool.name, arguments: (args || {}) as Record<string, unknown> }, CallToolResultSchema, { resetTimeoutOnProgress: true, timeout }),
-  })
-}
-
-export function defs(key: string, client: MCPClient, timeout?: number) {
-  return Effect.tryPromise({ try: () => withTimeout(client.listTools(), timeout ?? DEFAULT_TIMEOUT), catch: (err) => (err instanceof Error ? err : new Error(String(err))) }).pipe(
-    Effect.map((r) => r.tools),
-    Effect.catch((err) => { log.error("failed to get tools from client", { key, error: err }); return Effect.succeed(undefined) }),
-  )
-}
-
-export function fetchFromClient<T extends { name: string }>(clientName: string, client: Client, listFn: (c: Client) => Promise<T[]>, label: string) {
-  return Effect.tryPromise({ try: () => listFn(client), catch: (e: any) => { log.error(`failed to get ${label}`, { clientName, error: e.message }); return e } }).pipe(
-    Effect.map((items) => {
-      const out: Record<string, T & { client: string }> = {}
-      for (const item of items) out[sanitize(clientName) + ":" + sanitize(item.name)] = { ...item, client: clientName }
-      return out
-    }),
-    Effect.orElseSucceed(() => undefined),
-  )
-}
-
-export type { MCPToolDef }
-export { SSEClientTransport }
-export type Transport = StdioClientTransport | StreamableHTTPClientTransport | SSEClientTransport
-export type TransportWithAuth = StreamableHTTPClientTransport | SSEClientTransport
-export const pendingOAuthTransports = new Map<string, TransportWithAuth>()
-export type PromptInfo = Awaited<ReturnType<MCPClient["listPrompts"]>>["prompts"][number]
-export type ResourceInfo = Awaited<ReturnType<MCPClient["listResources"]>>["resources"][number]
-export interface CreateResult { mcpClient?: MCPClient; status: Status; defs?: MCPToolDef[] }
-export interface AuthResult { authorizationUrl: string; oauthState: string; client?: MCPClient }
-export interface State { status: Record<string, Status>; clients: Record<string, MCPClient>; defs: Record<string, MCPToolDef[]> }
-export type AuthStatus = "authenticated" | "expired" | "not_authenticated"

package/src/mcp/oauth-callback.ts

@@ -1,263 +0,0 @@
-import { createConnection } from "net"
-import { createServer } from "http"
-import * as Log from "@saeeol/core/util/log"
-import { OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_PATH, parseRedirectUri } from "./oauth-provider"
-import * as SaeeolOAuthCallback from "../overlay/mcp-oauth-callback" 
-
-const log = Log.create({ service: "mcp.oauth-callback" })
-
-// Current callback server configuration (may differ from defaults if custom redirectUri is used)
-let currentPort = OAUTH_CALLBACK_PORT
-let currentPath = OAUTH_CALLBACK_PATH
-
-const HTML_SUCCESS = `<!DOCTYPE html>
-<html>
-<head>
-    <title>Saeeol - Authorization Successful</title>
-    <style>
-    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
-    .container { text-align: center; padding: 2rem; }
-    h1 { color: #4ade80; margin-bottom: 1rem; }
-    p { color: #aaa; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>Authorization Successful</h1>
-        <p>You can close this window and return to Saeeol.</p>
-      </div>
-  <script>setTimeout(() => window.close(), 2000);</script>
-</body>
-</html>`
-
-const HTML_ERROR = (error: string) => `<!DOCTYPE html>
-<html>
-<head>
-    <title>Saeeol - Authorization Failed</title>
-    <style>
-    body { font-family: system-ui, -apple-system, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e; color: #eee; }
-    .container { text-align: center; padding: 2rem; }
-    h1 { color: #f87171; margin-bottom: 1rem; }
-    p { color: #aaa; }
-    .error { color: #fca5a5; font-family: monospace; margin-top: 1rem; padding: 1rem; background: rgba(248,113,113,0.1); border-radius: 0.5rem; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>Authorization Failed</h1>
-    <p>An error occurred during authorization.</p>
-    <div class="error">${error}</div>
-  </div>
-</body>
-</html>`
-
-interface PendingAuth {
-  resolve: (code: string) => void
-  reject: (error: Error) => void
-  timeout: ReturnType<typeof setTimeout>
-}
-
-let server: ReturnType<typeof createServer> | undefined
-const pendingAuths = new Map<string, PendingAuth>()
-// Reverse index: mcpName → oauthState, so cancelPending(mcpName) can
-// find the right entry in pendingAuths (which is keyed by oauthState).
-const mcpNameToState = new Map<string, string>()
-
-const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes
-
-function cleanupStateIndex(oauthState: string) {
-  for (const [name, state] of mcpNameToState) {
-    if (state === oauthState) {
-      mcpNameToState.delete(name)
-      break
-    }
-  }
-}
-
-function handleRequest(req: import("http").IncomingMessage, res: import("http").ServerResponse) {
-  const url = new URL(req.url || "/", `http://localhost:${currentPort}`)
-
-  if (url.pathname !== currentPath) {
-    res.writeHead(404)
-    res.end("Not found")
-    return
-  }
-
-  const code = url.searchParams.get("code")
-  const state = url.searchParams.get("state")
-  const error = url.searchParams.get("error")
-  const errorDescription = url.searchParams.get("error_description")
-
-  log.info("received oauth callback", { hasCode: !!code, state, error })
-
-  // Enforce state parameter presence
-  if (!state) {
-    const errorMsg = "Missing required state parameter - potential CSRF attack"
-    log.error("oauth callback missing state parameter", { url: url.toString() })
-    res.writeHead(400, { "Content-Type": "text/html" })
-    res.end(HTML_ERROR(errorMsg))
-    return
-  }
-
-  if (error) {
-    const errorMsg = errorDescription || error
-    if (pendingAuths.has(state)) {
-      const pending = pendingAuths.get(state)!
-      clearTimeout(pending.timeout)
-      pendingAuths.delete(state)
-      cleanupStateIndex(state)
-      pending.reject(new Error(errorMsg))
-    }
-    res.writeHead(200, { "Content-Type": "text/html" })
-    res.end(HTML_ERROR(errorMsg))
-    return
-  }
-
-  if (!code) {
-    res.writeHead(400, { "Content-Type": "text/html" })
-    res.end(HTML_ERROR("No authorization code provided"))
-    return
-  }
-
-  // Validate state parameter
-  if (!pendingAuths.has(state)) {
-    const errorMsg = "Invalid or expired state parameter - potential CSRF attack"
-    log.error("oauth callback with invalid state", { state, pendingStates: Array.from(pendingAuths.keys()) })
-    res.writeHead(400, { "Content-Type": "text/html" })
-    res.end(HTML_ERROR(errorMsg))
-    return
-  }
-
-  const pending = pendingAuths.get(state)!
-
-  clearTimeout(pending.timeout)
-  pendingAuths.delete(state)
-  cleanupStateIndex(state)
-  pending.resolve(code)
-
-  res.writeHead(200, { "Content-Type": "text/html" })
-  res.end(HTML_SUCCESS)
-}
-
-export async function ensureRunning(redirectUri?: string): Promise<void> {
-  await SaeeolOAuthCallback.ensureRunning({
-    redirectUri,
-    parse: parseRedirectUri,
-    state: () => ({ server, port: currentPort, path: currentPath }),
-    set: (next) => {
-      server = next.server
-      currentPort = next.port
-      currentPath = next.path
-    },
-    create: () => createServer(handleRequest),
-    stop,
-    info: (msg, data) => log.info(msg, data),
-    error: (msg, data) => log.error(msg, data),
-  })
-  return
-
-  // Parse the redirect URI to get port and path (uses defaults if not provided)
-  const { port, path } = parseRedirectUri(redirectUri)
-
-  // If server is running on a different port/path, stop it first
-  if (server && (currentPort !== port || currentPath !== path)) {
-    log.info("stopping oauth callback server to reconfigure", { oldPort: currentPort, newPort: port })
-    await stop()
-  }
-
-  if (server) return
-
-  const running = await isPortInUse(port)
-  if (running) {
-    log.info("oauth callback server already running on another instance", { port })
-    return
-  }
-
-  currentPort = port
-  currentPath = path
-
-  server = createServer(handleRequest)
-  await new Promise<void>((resolve, reject) => {
-    // races us between isPortInUse() and listen() (notably across parallel
-    // bun test subprocesses). Treat it as "another instance owns the port",
-    // matching the isPortInUse() branch above instead of crashing.
-    const onError = (err: Error & { code?: string }) => {
-      if (err.code === "EADDRINUSE") {
-        log.info("oauth callback port bound by another instance", { port: currentPort })
-        server?.close()
-        server = undefined
-        resolve()
-        return
-      }
-      reject(err)
-    }
-    server!.on("error", onError)
-    server!.listen(currentPort, () => {
-      server!.off("error", onError) 
-      log.info("oauth callback server started", { port: currentPort, path: currentPath })
-      resolve()
-    })
-  })
-}
-
-export function waitForCallback(oauthState: string, mcpName?: string): Promise<string> {
-  if (mcpName) mcpNameToState.set(mcpName, oauthState)
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      if (pendingAuths.has(oauthState)) {
-        pendingAuths.delete(oauthState)
-        if (mcpName) mcpNameToState.delete(mcpName)
-        reject(new Error("OAuth callback timeout - authorization took too long"))
-      }
-    }, CALLBACK_TIMEOUT_MS)
-
-    pendingAuths.set(oauthState, { resolve, reject, timeout })
-  })
-}
-
-export function cancelPending(mcpName: string): void {
-  // Look up the oauthState for this mcpName via the reverse index
-  const oauthState = mcpNameToState.get(mcpName)
-  const key = oauthState ?? mcpName
-  const pending = pendingAuths.get(key)
-  if (pending) {
-    clearTimeout(pending.timeout)
-    pendingAuths.delete(key)
-    mcpNameToState.delete(mcpName)
-    pending.reject(new Error("Authorization cancelled"))
-  }
-}
-
-export async function isPortInUse(port: number = OAUTH_CALLBACK_PORT): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = createConnection(port, "127.0.0.1")
-    socket.on("connect", () => {
-      socket.destroy()
-      resolve(true)
-    })
-    socket.on("error", () => {
-      resolve(false)
-    })
-  })
-}
-
-export async function stop(): Promise<void> {
-  if (server) {
-    await new Promise<void>((resolve) => server!.close(() => resolve()))
-    server = undefined
-    log.info("oauth callback server stopped")
-  }
-
-  for (const [_name, pending] of pendingAuths) {
-    clearTimeout(pending.timeout)
-    pending.reject(new Error("OAuth callback server stopped"))
-  }
-  pendingAuths.clear()
-  mcpNameToState.clear()
-}
-
-export function isRunning(): boolean {
-  return server !== undefined
-}
-
-export * as McpOAuthCallback from "./oauth-callback"

package/src/mcp/oauth-provider.ts

@@ -1,214 +0,0 @@
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
-import type {
-  OAuthClientMetadata,
-  OAuthTokens,
-  OAuthClientInformation,
-  OAuthClientInformationFull,
-} from "@modelcontextprotocol/sdk/shared/auth.js"
-import { Effect } from "effect"
-import { McpAuth } from "./auth"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "mcp.oauth" })
-
-const OAUTH_CALLBACK_PORT = 19876
-const OAUTH_CALLBACK_PATH = "/mcp/oauth/callback"
-
-export interface McpOAuthConfig {
-  clientId?: string
-  clientSecret?: string
-  scope?: string
-  redirectUri?: string
-}
-
-export interface McpOAuthCallbacks {
-  onRedirect: (url: URL) => void | Promise<void>
-}
-
-export class McpOAuthProvider implements OAuthClientProvider {
-  constructor(
-    private mcpName: string,
-    private serverUrl: string,
-    private config: McpOAuthConfig,
-    private callbacks: McpOAuthCallbacks,
-    private auth: McpAuth.Interface,
-  ) {}
-
-  get redirectUrl(): string {
-    if (this.config.redirectUri) {
-      return this.config.redirectUri
-    }
-    return `http://127.0.0.1:${OAUTH_CALLBACK_PORT}${OAUTH_CALLBACK_PATH}`
-  }
-
-  get clientMetadata(): OAuthClientMetadata {
-    return {
-      redirect_uris: [this.redirectUrl],
-      client_name: "SAEEOL",
-      client_uri: "https://saeeol.ai",
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      token_endpoint_auth_method: this.config.clientSecret ? "client_secret_post" : "none",
-    }
-  }
-
-  async clientInformation(): Promise<OAuthClientInformation | undefined> {
-    // Check config first (pre-registered client)
-    if (this.config.clientId) {
-      return {
-        client_id: this.config.clientId,
-        client_secret: this.config.clientSecret,
-      }
-    }
-
-    // Check stored client info (from dynamic registration)
-    // Use getForUrl to validate credentials are for the current server URL
-    const entry = await Effect.runPromise(this.auth.getForUrl(this.mcpName, this.serverUrl))
-    if (entry?.clientInfo) {
-      // Check if client secret has expired
-      if (entry.clientInfo.clientSecretExpiresAt && entry.clientInfo.clientSecretExpiresAt < Date.now() / 1000) {
-        log.info("client secret expired, need to re-register", { mcpName: this.mcpName })
-        return undefined
-      }
-      return {
-        client_id: entry.clientInfo.clientId,
-        client_secret: entry.clientInfo.clientSecret,
-      }
-    }
-
-    // No client info or URL changed - will trigger dynamic registration
-    return undefined
-  }
-
-  async saveClientInformation(info: OAuthClientInformationFull): Promise<void> {
-    await Effect.runPromise(
-      this.auth.updateClientInfo(
-        this.mcpName,
-        {
-          clientId: info.client_id,
-          clientSecret: info.client_secret,
-          clientIdIssuedAt: info.client_id_issued_at,
-          clientSecretExpiresAt: info.client_secret_expires_at,
-        },
-        this.serverUrl,
-      ),
-    )
-    log.info("saved dynamically registered client", {
-      mcpName: this.mcpName,
-      clientId: info.client_id,
-    })
-  }
-
-  async tokens(): Promise<OAuthTokens | undefined> {
-    // Use getForUrl to validate tokens are for the current server URL
-    const entry = await Effect.runPromise(this.auth.getForUrl(this.mcpName, this.serverUrl))
-    if (!entry?.tokens) return undefined
-
-    return {
-      access_token: entry.tokens.accessToken,
-      token_type: "Bearer",
-      refresh_token: entry.tokens.refreshToken,
-      expires_in: entry.tokens.expiresAt
-        ? Math.max(0, Math.floor(entry.tokens.expiresAt - Date.now() / 1000))
-        : undefined,
-      scope: entry.tokens.scope,
-    }
-  }
-
-  async saveTokens(tokens: OAuthTokens): Promise<void> {
-    await Effect.runPromise(
-      this.auth.updateTokens(
-        this.mcpName,
-        {
-          accessToken: tokens.access_token,
-          refreshToken: tokens.refresh_token,
-          expiresAt: tokens.expires_in ? Date.now() / 1000 + tokens.expires_in : undefined,
-          scope: tokens.scope,
-        },
-        this.serverUrl,
-      ),
-    )
-    log.info("saved oauth tokens", { mcpName: this.mcpName })
-  }
-
-  async redirectToAuthorization(authorizationUrl: URL): Promise<void> {
-    log.info("redirecting to authorization", { mcpName: this.mcpName, url: authorizationUrl.toString() })
-    await this.callbacks.onRedirect(authorizationUrl)
-  }
-
-  async saveCodeVerifier(codeVerifier: string): Promise<void> {
-    await Effect.runPromise(this.auth.updateCodeVerifier(this.mcpName, codeVerifier))
-  }
-
-  async codeVerifier(): Promise<string> {
-    const entry = await Effect.runPromise(this.auth.get(this.mcpName))
-    if (!entry?.codeVerifier) {
-      throw new Error(`No code verifier saved for MCP server: ${this.mcpName}`)
-    }
-    return entry.codeVerifier
-  }
-
-  async saveState(state: string): Promise<void> {
-    await Effect.runPromise(this.auth.updateOAuthState(this.mcpName, state))
-  }
-
-  async state(): Promise<string> {
-    const entry = await Effect.runPromise(this.auth.get(this.mcpName))
-    if (entry?.oauthState) {
-      return entry.oauthState
-    }
-
-    // Generate a new state if none exists — the SDK calls state() as a
-    // generator, not just a reader, so we need to produce a value even when
-    // startAuth() hasn't pre-saved one (e.g. during automatic auth on first
-    // connect).
-    const newState = Array.from(crypto.getRandomValues(new Uint8Array(32)))
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("")
-    await Effect.runPromise(this.auth.updateOAuthState(this.mcpName, newState))
-    return newState
-  }
-
-  async invalidateCredentials(type: "all" | "client" | "tokens"): Promise<void> {
-    log.info("invalidating credentials", { mcpName: this.mcpName, type })
-    const entry = await Effect.runPromise(this.auth.get(this.mcpName))
-    if (!entry) {
-      return
-    }
-
-    switch (type) {
-      case "all":
-        await Effect.runPromise(this.auth.remove(this.mcpName))
-        break
-      case "client":
-        delete entry.clientInfo
-        await Effect.runPromise(this.auth.set(this.mcpName, entry))
-        break
-      case "tokens":
-        delete entry.tokens
-        await Effect.runPromise(this.auth.set(this.mcpName, entry))
-        break
-    }
-  }
-}
-
-export { OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_PATH }
-
-/**
- * Parse a redirect URI to extract port and path for the callback server.
- * Returns defaults if the URI can't be parsed.
- */
-export function parseRedirectUri(redirectUri?: string): { port: number; path: string } {
-  if (!redirectUri) {
-    return { port: OAUTH_CALLBACK_PORT, path: OAUTH_CALLBACK_PATH }
-  }
-
-  try {
-    const url = new URL(redirectUri)
-    const port = url.port ? parseInt(url.port, 10) : url.protocol === "https:" ? 443 : 80
-    const path = url.pathname || OAUTH_CALLBACK_PATH
-    return { port, path }
-  } catch {
-    return { port: OAUTH_CALLBACK_PORT, path: OAUTH_CALLBACK_PATH }
-  }
-}

package/src/md.d.ts

@@ -1,4 +0,0 @@
-declare module "*.md" {
-  const content: string
-  export default content
-}

package/src/node.ts

@@ -1,6 +0,0 @@
-export { Config } from "@/config/config"
-export { Server } from "./server/server"
-export { bootstrap } from "./cli/bootstrap"
-export * as Log from "@saeeol/core/util/log"
-export { Database } from "@/storage/db"
-export { JsonMigration } from "@/storage/json-migration"

package/src/overlay/agent/agent-remove.ts

@@ -1,74 +0,0 @@
-import { NamedError } from "@saeeol/core/util/error"
-import { Glob } from "@saeeol/core/util/glob"
-import { Instance } from "../../project/instance"
-import { InstanceStore } from "../../project/instance-store"
-import { makeRuntime } from "@/effect/run-service"
-import z from "zod"
-import path from "path"
-
-export const RemoveError = NamedError.create(
-  "AgentRemoveError",
-  z.object({
-    name: z.string(),
-    message: z.string(),
-  }),
-)
-
-export async function remove(name: string) {
-  const { Agent } = await import("../../agent/agent")
-  const agents = makeRuntime(Agent.Service, Agent.defaultLayer)
-  const agent = await agents.runPromise((svc) => svc.get(name))
-  if (!agent) throw new RemoveError({ name, message: "agent not found" })
-  if (agent.native) throw new RemoveError({ name, message: "cannot remove native agent" })
-  if (agent.options?.source === "organization")
-    throw new RemoveError({ name, message: "cannot remove organization agent — manage it from the cloud dashboard" })
-
-  const { unlink, writeFile } = await import("fs/promises")
-  let found = false
-
-  const { Config } = await import("../../config/config")
-  const dirs = await Config.directories()
-  const patterns = ["{agent,agents}/**/" + name + ".md", "{mode,modes}/" + name + ".md"]
-  for (const dir of dirs) {
-    for (const pattern of patterns) {
-      const matches = await Glob.scan(pattern, { cwd: dir, absolute: true, dot: true })
-      for (const file of matches) {
-        if (await Bun.file(file).exists()) {
-          await unlink(file)
-          found = true
-        }
-      }
-    }
-  }
-
-  const { ModesMigrator } = await import("@/saeeol/modes-migrator")
-  const { SaeeolPaths } = await import("@/saeeol/paths")
-  const os = await import("os")
-  const matter = (await import("gray-matter")).default
-  const home = os.default.homedir()
-  const modesFiles = [
-    path.join(SaeeolPaths.vscodeGlobalStorage(), "settings", "custom_modes.yaml"),
-    path.join(home, ".saeeol", "cli", "global", "settings", "custom_modes.yaml"),
-    path.join(home, ".saeeolmodes"),
-    path.join(Instance.directory, ".saeeolmodes"),
-  ]
-
-  for (const file of modesFiles) {
-    const modes = await ModesMigrator.readModesFile(file)
-    if (!modes.length) continue
-
-    const filtered = modes.filter((m: { slug: string }) => m.slug !== name)
-    if (filtered.length === modes.length) continue
-
-    const yaml = matter
-      .stringify("", { customModes: filtered })
-      .replace(/^---\n/, "")
-      .replace(/\n---\n?$/, "")
-    await writeFile(file, yaml)
-    found = true
-  }
-
-  if (!found) throw new RemoveError({ name, message: "no agent file found on disk" })
-
-  await InstanceStore.disposeInstance(Instance.current)
-}